The

Art

of Engineering greener (soft computing) software

WCCI'26, Maastricht

JJ Merelo, university of Granada, Spain, `jmerelo@ugr.es`

Or, how Dutch art (and history) can help us save energy in our evolutionary algorithms

Greatest Dutch invention

🎨 Renaissance!

Art is about problem solving via optimization

Computers need power to operate

Boy, do they need power...

But also...

Moore's law is dead

Clock speed is not improving any more, many architectural improvements made performance increase in the last few years, but we are already in the diminishing returns territory: lots of architecturar improvements are needed to extract a tiny bit of performance improvement. Besides, Moore's said that power consumption and speed could be improved simultaneously. That's no longer true. By the way, there's a connection between both: a bourgeois middle class needs a new solution to its spiritual needs, hence Geert Groote and its devotio moderna. It's not the first time that engineering changes society changes art, and back

You can't make applications run much faster

Make them greener*

Tutorial organization

Energy/power and all that

How and where power is spent

Measuring energy spent

Modeling energy consumption

We need to understand

What are we measuring

How can we measure it

How can we measure our stuff

We do need to measure

What are we measuring

Socket ~= Processor → x cores → y threads

DRAM/Memory

GPUs

Other units: Apple Neural Engine Architecture, for instance.

Cores are not homogeneous

P cores for performance, e cores for (energy) efficiency

Multi-die architecture

Sometimes with heterogeneous frequency/voltage

Intel has the same kind of architecture, but for different purposes.. There's some explanation on this On these articles.. E-cores generally occupy less space, and their clock speed is slower; these two things together make them consume less energy. In many cases, they are older architectures (several generations before) repackaged. In general, modern architectures are designed for peak performance, but also energy management. Apple Silicon M3 Ultra: 28 p-cores, 8 e-cores

System does its best to keep processor temperature in a range

Different states change frequency and voltage

Baseline: system does its best to save energy

Processors run machine code instructions

They take different number of cycles and consume a different amount of energy

And they use on-chip caches, instructions decoders and so on

We need our applications to ride this system

And extract as little power from it as possible

Good engineering can help

It's the system that draws energy

You can mostly measure the whole system

Yet you need to measure a single application

Measure energy drawn from the external plug

Problems: measuring the whole system (hard disk, external graphics card)...

... And synchronization

Good ones can be €€€

Use system APIs and interfaces

Using seudo-registers or system calls to place estimates

IOreport for Apple

Other devices have different interfaces

Running average power limit: RAPL

Prevalent in the Intel world (including AMD)

Provides registers that estimate energy usage

`PKG` or "package", includes all on-chip energy consumption

Intel chipsets have more granularity: memory, core/PP0, uncore/PP1, "PSys"...

Measuring energy consumed by an application

Command line tools

Language-specific libraries

Let's check the marketplace

Command	Platforms	Attaches to command
`scaphandre`	RAPL, others	Sometimes
`pinpoint`	RAPL, IOReport for M1, others	Yes
`perf`	Linux	No
`pumas`	Mac	No

Those are the two things that you need: there should be an uniform way of measuring consumption in different environments, and you should be able to run the command that contains your workload, what you're insterested in. If it's not run with your command, but in the background (and can be started or killed, or simply kinda find what was happenning when your command was running) you need a certain amount of instrumentation to get it going.So pinpoint it is. Scaphandre attaches depending on the data output: it does for stdout, does not for others.

🤿 `scaphandre` for process-level power meter

sudo julia  examples/BBOB_sphere_with_baseline.jl 40 10000 50 10 256 &
sudo time scaphandre stdout -s 1 -p 10

Here we are seeing for the first time this algorithm, Brave New Algorithm, which we are going to see many times later on. This needed a certain amount of scaffolding to process time (using the system command) and extract power for our specific process, and then plot it using $. What we see is that even with the same process we have a certain amount of dispersion, due to several factors, including the fact that it's a metaheuristic, so it might have more or less running time. Some issues with scaphandre: sampling time, the fact that you have to estimate sub-sampling energy consumption, and so on. You need to trust also the measures, which include a certain amount of assumptions. While this is possible the true consumption, you still need to take into account the fact that your process is going to be running while the rest of the machine does.

Using pyJoules

import sys
from pyJoules.energy_meter import measure_energy
from sacrypt import process_text_v0

@measure_energy
def run_process(process_func, file_path):
    process_func(file_path)

if __name__ == "__main__":
    run_process(process_text_v0, file_path)

`sudo` make me a sandwich

$ sudo ./.venv/bin/python bin/sacrypt-energy.py ../data/3romanzi.txt v1
begin timestamp : 1742670844.3934789; tag : run_process; duration : 0.08716917037963867; package_0 : 3239548.0; core_0 : 55554.0; nvidia_gpu_0 : 1150

Since energy profiles can reveal a lot about specific things that are being done in the system, it's been converted into a privileged API, which needs sudo to run.

We need a methodology

Use different parameters

Repeat for statistical significance

Analyzing Italian literature

We need a script (written in this case in Perl) which captures the output of pyJoules, processes it, and puts in in a format; then we use R to plot the result. We are plotting the PKG here, that is, what is consumed by the system-on-chip, which is normally the most important part of energy consumption. What we see is that, for every file, there is roughly a proportion between time and energy spent; however, this proportion is different for every one, indicating that the way energy is tapped is different. Also, there's a certain, mostly horizontal, spread (that is, you can consume a range of energy even spending the same time). Spread can be 1-2 joules in some cases, around 10% of the total measure. What we see here is that there's pretty much a linear increase between the size of the file, time needed to process it and energy spent. All's good and well, unless you need to process terabytes of code... Also take into account that we're measuring 30 times. Energy management in modern computers makes relatively unpredictable the outcome, so statistics are sorely needed.

One does not just measure

Experimental design is needed

But we're measuring the whole system here

A baseline that eliminates system overhead is needed

We can't do that from the program itself

Measuring only energy spent by our workload

E(Workload) = E(measured) - E(baseline)

Baseline includes operating context + runtime overhead

E(measured) = E(workload) + E(framework) + E(system)

System, or framework, or both need to be isolated

Establish a baseline

$ sudo pinpoint sleep 1
Energy counter stats for 'sleep 1':
[interval: 50ms, before: 0ms, after: 0ms, delay: 0ms, runs: 1]

	10.64 J nvml:nvidia_geforce_rtx_4070_super_0
	22.17 J rapl:pkg

	1.00109098 seconds time elapsed

Very high variability

Operating context matters

Taken from Best practices in measuring energy consumption in population-based metaheuristics

Interleave workload-baseline measurements

High variability? Repeat for statistical significance

Choices for greener algorithms: many moving parts

Nouen Watch from the early 16th century, Dutch watchmaker from the same city as Bosch

Machine/OS/Hardware platform

Language

Language-specific optimizations

Some rules of thumb for energy savings

Hardware: several orders of magnitude

Language 2-3 orders of magnitude

Program: 1 order of magnitude

Trade-off energy/time

At the hardware/language level, at least

There's no free lunch, but we can have very cheap lunch at the program level

Can we beat Python

JavaScript is a very popular language

`% Copilot rewrite this in node.js`

Leaving Python in the dust

What about different interpreters for JavaScript? node vs. bun

Different levels: it's complicated

Measuring is important

Like him, always measure when a change is made

The

Art

of Engineering greener (soft computing) software

WCCI'26, Maastricht

JJ Merelo, university of Granada, Spain, jmerelo@ugr.es

Or, how Dutch art (and history) can help us save energy in our evolutionary algorithms

Greatest Dutch invention

🎨 Renaissance!

Art is about problem solving via optimization

Computers need power to operate

Boy, do they need power...

But also...

Moore's law is dead

You can't make applications run much faster

Make them greener*

Tutorial organization

Energy/power and all that

How and where power is spent

Measuring energy spent

Modeling energy consumption

We need to understand

What are we measuring

How can we measure it

How can we measure our stuff

We do need to measure

What are we measuring

Socket ~= Processor → x cores → y threads

DRAM/Memory

GPUs

Other units: Apple Neural Engine Architecture, for instance.

Cores are not homogeneous

P cores for performance, e cores for (energy) efficiency

Multi-die architecture

Sometimes with heterogeneous frequency/voltage

System does its best to keep processor temperature in a range

Different states change frequency and voltage

Baseline: system does its best to save energy

Processors run machine code instructions

They take different number of cycles and consume a different amount of energy

And they use on-chip caches, instructions decoders and so on

We need our applications to ride this system

And extract as little power from it as possible

Good engineering can help

It's the system that draws energy

You can mostly measure the whole system

Yet you need to measure a single application

Measure energy drawn from the external plug

Problems: measuring the whole system (hard disk, external graphics card)...

... And synchronization

Good ones can be €€€

Use system APIs and interfaces

Using seudo-registers or system calls to place estimates

IOreport for Apple

Other devices have different interfaces

Running average power limit: RAPL

Prevalent in the Intel world (including AMD)

Provides registers that estimate energy usage

PKG or "package", includes all on-chip energy consumption

Intel chipsets have more granularity: memory, core/PP0, uncore/PP1, "PSys"...

Measuring energy consumed by an application

Command line tools

Language-specific libraries

Let's check the marketplace

🤿 scaphandre for process-level power meter

Using pyJoules

sudo make me a sandwich

We need a methodology

Use different parameters

Repeat for statistical significance

Analyzing Italian literature

One does not just measure

Experimental design is needed

But we're measuring the whole system here

A baseline that eliminates system overhead is needed

We can't do that from the program itself

Measuring only energy spent by our workload

E(Workload) = E(measured) - E(baseline)

Baseline includes operating context + runtime overhead

E(measured) = E(workload) + E(framework) + E(system)

System, or framework, or both need to be isolated

JJ Merelo, university of Granada, Spain, `jmerelo@ugr.es`

`PKG` or "package", includes all on-chip energy consumption

🤿 `scaphandre` for process-level power meter

`sudo` make me a sandwich

`% Copilot rewrite this in node.js`