Is it possible to write a program that calculates its own energy usage?

Question

If I have a program (e.g. a small Python program) on a specific machine. Would the program be able to measure how much energy its computation costed?

I think, there would be two possible ways to go:

A) There is a function that measures the energy of the device before and after the execution of the program.

However, there would be problems concerning the accuracy of the measurement of the device on which the program is executed. Also, at the same time other processes may be executed on the machine, which would (potentially) corrupt the process of measuring. Except for this, it does not seem elegant to me.

B) There is a program that counts the bit-wise computation steps and returns it at the end of the execution. From this, I could possibly calculate the energy consumption of the whole programme knowing the average energy the device takes to carry out one single computation step. However, this seems a bit contradictory to me, since the programme would essentially (at least partly) need to observe itself. Also, I am not sure if this would be a valid measure at all, since it is indirect, and somehow theoretical. -- On the other hand, there would be no perturbations by other programs running on the computer.

Is one of these ways reasonable or are there possibly more convenient of doing this?

Note: I am interested in the real energy usage, not the theoretical. (This is why I think the O-measure of some algorithms within the code would essentially not help me a lot.)

Also: I am not interested in the time measurement, as running the program on different machines will result in different run times. Additionally, knowing the time, does not (in practice) automatically give me the energy usage an all machines.

Rather I am interested in the pure energy usage.

Answer 1

To measure the power consumed by a device it is necessary to measure the voltage (or know its constant value) and to measure the current. The power demand at any instant is given by $$ P = UI $$ where \$P\$ is power in watts (W), \$U\$ is the voltage (V) and \$I\$ is the current (A).

The energy consumed is given by $$ E = \int_0^T P dt$$ where \$E\$ is in joules (J) or watt-seconds (Ws).

Virtually all processors run on constant voltage although it may vary on battery-powered devices. Some processors will report their operating voltage so that will help you determine \$U\$.

Measuring current (and power) will usually require some additional hardware and this is not normally supplied in most computer systems. You have two options:

1. Add in a DC current / power meter between the power supply and the computer.
2. Add in a mains power meter between the mains and the computer's power supply.

Figure 1. A current sensing circuit. Simplifying Current Sensing (Rev. A) - Texas Instruments.

The circuit of Figure 1 is how you would do case 1. It adds a low resistance R_SENSE in series with the positive supply and the output voltage of the amplifier is proportional to the current being drawn. This in turn would be fed into an analog to digital converter (ADC) on your computer - if it has one! Your software would then have to do the integration \$ \int_0^T UI dt \$ to keep track of the energy consumed.

I think your idea is impractical because you won't have control of the hardware your program is to run on.

---

Since laptop battery management has come up a few times in the comments we should consider that.

^{simulate this circuit – Schematic created using CircuitLab}

Figure 2. Laptop battery management can count charge in and out of the battery but it has no idea how much power is being consumed directly from the mains PSU and it has no idea which components are consuming the power.

Answer 2

You can't realistically measure the energy consumed by something you plug into mains. What you must do is measure the instantaneous power it consumes and integrate that over the run time of the program to calculate the total energy consumed.

Your best hope is to add a power measuring device to your setup and write a program that reads the current power consumption periodically. Run your system for a while without running the program of interest and determine the average power consumed. You might want to stop all unnecessary processes while doing this.

Repeat the power measurements while running your program repeatedly many times. Again calculate average power consumption. Subtract the background power from the power-with-program-running and then multiply by the average run time of your program. The result is an estimate of the average energy needed to run your program.

Note that you will need to do this separately for each "machine" of interest. The energy required to run the program will be different for different computing hardware and different operating systems, possibly even different versions of the same operating system.