Energy efficient application development

Question

Are there any tools and techniques to build more energy efficient applications? Any articles, rules or best practices for green programming?

Answer 1

Interesting question - the first thought that occurs to me is going lighter on CPU is more energy efficient (as the CPU runs cooler and fans don't need to come on - plus on some OSes an idle CPU goes into a more energy efficient state). So eliminating things like busy waits for example, and optimising very CPU intensive algorithms may help.

Similarly anything that can be done to wring more life out of an old server may be more energy efficient in the 'green' sense (not having to build and ship and package a new server, not needing to dispose of the old one, etc).

(I always thought the climate simulations running on grid computers were a bit ironic - I ran one for a while on my Mac and it always made the CPU temp go up, the fans come on, and the power supply run hotter - to say nothing of the CO2 emissions from all that :-)

Answer 2

Recently, while preparing a seminar on Design Patterns, I came across an article (can't find it now) that looked at design patterns and, specifically, the Bridge pattern IIRC, in the context of energy efficiency in portable devices. I do not think, however, that many people take this seriously, since we live in a world where to get a more energy-efficient hardware platform, you just wait for one.

If we are talking about battery life and such, then obviously any sort of optimization which makes us use less instructions is better. Also, doing things in RAM instead of swapping to HDD might be more energy-efficient.

Answer 3

Borland C++ Builder 5 and 6 had a horrendous inefficiency for many many years that cause compilation to run about 10 times slower than necessary.

A rough estimate of number of programmers (20,000), minutes/day of wasted CPU time (15), PC power consumption (150 W) and lifespan of the bug (5 years) gave me a figure of about 93 Megawatt hours, or 93 tons of CO2

All from one tiny bug...

So, not really an answer, but I think your question is a highly valid one!

Answer 4

I'm going to answer your question with my own: Is there enough benefit for the cost of green programming?

My knee jerk reaction is that green programming would violate the 80-20 rule, and we could be getting much better green results elsewhere (such as switching to a processor that draws 20 W instead of 47 W)

Good question nonetheless!

Answer 5

I've not come across much at an application level but at the db level there are a class of databases called sensor networks. These are typically battery powered and in remote locations so power consumption is an important factor.

Sensor dbs are usually in a snooze mode and 'wake' when they need to collect data or when they transmit. Without reading the paper about them, this stuff seems very 'embedded' and I've no idea on metrics but I would guess power consumption would be higher when :

1. thrashing the hard drive
2. doing heavy mathematical calculations

Answer 6

At application level, many times caching is overlooked: if you already have a fresh result, you don't have to recompute it. Less computation -> lower power consumption; also, usually less data transferred (-> lower power consumption - infinitesimal, but it adds up). Of course, caching logic has to be lighter than the computation itself, otherwise it defeats the purpose.

For example, in HTTP this can be done with conditional queries - yet rarely do you see it (it can be tricky to keep track of response freshness).

Answer 7

The Less Watts site is a good place to start.

Answer 8

At the IPCV 2008 conference, I saw a presentation that included data for calculating the cost of each instruction on a mobile device in units of power (I believe it was picowatts). Given that as a starting point, I imagine you could make an optimizer that reduced cost simultaneously in computation and power. I don't think it's trivial, but it is certainly possible.

Answer 9

Eliminate the servers, P2P rules :)

1. More efficient use of available machines. They have enough storage and networking capacity that it should be simple to get rid of the big iron.

2. Make sure the backlight of the monitor is out when the machine is not used. Spin down the disk. Not really at application level.

3. If you take a look at current architectures, processing is happening too far away from memory. Going off-chip takes an awful lot of power. If you just count chips in your PC, you'll notice there are more memory chips (8 or 16) than processing ones (CPU+GPU). It makes sense to move the processing towards the memory, but that means a non-unified memory model, which is difficult to program. Basically, a grid inside your PC.

Answer 10

Aside from the absurd solution where you just don't compute (and therefore you don't need the electricity...)

The aim is simply to do the most work with the least amount of energy. Outside of the hardware realm (which you just lower the voltage and frequency), you just have to make sure the work could be done in the least amount of actual execution time.

This is probably a pain to measure because of OoO Execution, etc etc.

I wouldn't lose sleep over it, as long as you use efficient algorithms and such, and not bloat your code unnecessarily.

Answer 11

One generalized answer to the question is don't poll for changes or periodically scan for something to do. Use operating system notifications to process information on an interrupt driven basis.

When you do process information do it efficiently and as a 'bulk' endeavour. One big write to HDD is better than several smaller writes as the disk system can switch to lower power states sooner. The same applies to use of CPUs, hardware radios..etc.

While virtually meaningless on most hardware connected to the grid.. platforms such as laptops and especially mobile phones can benefit quite a bit by applications designed to for power effeciency (Use the CPU and system resources as sparingly as possible)

Answer 12

An interesting thing to think about - how CO2 do you produce while optimizing your code, and how much CO2 is it going to reduce? I can imagine that developing software is a quite CO2-intensive process... ;)

Answer 13

Wow, the possibilities are endless here:

General Ideas:

• Compile much less frequently. Compiling is CPU intensive, and CPU's are watt hogs
• Stop running those crazy unit tests all the time.
• Heck, shut down that Continuous Integration server! Come on, you really only need to build every couple of days anyway, bottom line.
• Limit checkins to your source control system. Think of all those watts burning down the wire and on the remote server!
• Stop commenting your code. (Okay, so that should probably be "Don't start commenting your code".....)
• Save on Pixels. Set your screen resolution to 640x480. Fewer pixels, fewer watts!
• Code only in APL.
• Don't code any more bugs. Bugs require more compiles, more testing, more typing, and more CPU time.
• If your system allows code folding, keep as much code folded as possible. Saves on monitor output.
• Keep all your caffeinated beverages at room temperature.
• Unplug your USB Missile Shooter. Totally forget about the humping dog Memory stick.
• Take the batteries out of that Light Saber behind your desk and use it without the soothing purple glow.
• Generally, keep all your numbers small. I'd suggest never using big numbers. Big numbers probably use more energy.
• Get a mouse-ball based mouse. That red light has to be burning watts.

Since keystrokes require energy to process and display:

• Many languages let you put multiple statements on one line. Do that as much as possible.
• Pursuant to that, never break long lines of code into multiple lines.
• Don't refactor. Too often this creates more code that you have to scroll through.
• Name all variables with as few letters as possible. Preferably one letter. Generally two. Three max.
• Stop putting blank lines in between lines of code. Saves on Enter keystrokes and scrolling!
• Shoot, eliminate unnecessary white space altogether. When you get right down to it, what exactly does white space do? Nothing, that's what.

That's all I can think of right now. There has to be more stuff like this! Come on guys, let's put our heads together and really go green!

Answer 14

Energy efficiency depends on the hardware and the OS that you are running on, as well as the library, that you are using.

If you are doing application development on a typical PC, then your application will be waiting for system messages most of the time. Typical frameworks (e.g. C#, Java, Delphi, Visual Basic) contain the basic functionality for these messaged to trigger events that your program will react to (e.g. OnClick). If you stick to this way of programming, there is not much that you need to think about. When your application is waiting for system messages, the OS knows, that the application is not busy and can make use of its built in power saving functionality. Things that you might consider are improvements on the IO-part of your program (e.g. combining several file reads or writes into one combined one).

If your application involve a lot of processing (e.g. when you need to create independent threads to handle the processing without freezing the UI) you will need to think more about power efficiency. Optimizing the IO-part may be a good starting point.

Things that you should generally avoid are busy loops polling for an event (e.g. change of a bit in a register, or the availability of data from another thread). Use synchronization functions of your OS (e.g. Events, Semaphores, Mutexes, WaitForSingleObject, ...) instead.

In embedded systems there are many more things to consider ( / under your control).

I am working at the moment on a wireless sensor network, where each node will be able to run on small batteries for years. In order to achieve that, two things had to be done.

1) Design a very power efficient hardware by selecting low power consumption parts with efficient sleep modes. Many Microcontrollers have the possibility to switch off sub systems when not in use. They also have various power reduction or sleep modes. During a sleep mode program execution is stopped, while all RAM is kept. Depending on the specific mode certain sub systems are still alive and will wake up the controller when needed.

2) Program the firmware to make use of low power modes, whenever possible. Switch off sensors / transmitters when not in use. Let the controller sleep as often as possible (e.g. use timers to wake up from programmed delays instead of busy wait delays, when waiting for external events program a wakeup interrupt and go to sleep). As a result of these endeavours your firmware becomes much more complex. There are many more states, that your program maybe in, and error conditions (e.g. timeouts) need to be cought by making use of subsystems.

Answer 15

Intel have some Energy Efficient Software Guidelines on their site, and links to a wide range of tools for helping with this.

Looks like a good place to start!

Answer 16

Use a native code compiler. Yes, you will have to write code to explicitly free used objects. The benefit is that you save the run time environment from having to run a garbage collector that continuously tries to determine which objects aren't in use anymore.

Also, disable compiler options that waste run-time CPU cycles, like range checking. A well tested program must never violate range constraints, so range checking is only needed during debugging.

Answer 17

Energy efficiency in programming is, when the value is maximized and the environmental costs are minimized. In other words, it can be green programming, if your application consumes more computer resources but has a shorter time to market. Simply because the environmental costs of a late product launch can be much bigger.

The simplest way to do green programming is to eat less pizzas and drink less cola. Buy local food, instead.

Answer 18

During test phase for different operating systems, different configurations, use virtualization (virtual machine) instead of adding new computers or servers. Virtualization can also be an alternative when we need to add more servers while the usage of available servers are not optimal (underload) yet.

Answer 19

Of course you probably don't want to purposefully build software that is energy-ineffecient, but I think this really misses the point.

Productivity software in general should be considered energy-efficient, because no matter how much energy the program itself requires it's going to be orders of magnitude less than the real-world task it replaces. So what if your app requires an extra watt to retrieve and display that fancy document from the file server, if it means a person didn't have to get up and retrieve and actual real paper document from a filing cabinet. Now there's no energy expended in producing and delivering the paper (or the filing cabinet and office space to hold them both, for that matter).

Even eye-candy UI features can be energy efficient. Maybe your new flashy/pretty whizbang UI feature requires more cpu time, but if it helps someone complete a task in less time than it used to you'll still end up with a net savings. Or maybe it helped drive sales of the software in the first place, such that without the nice graphics people would be using inferior software and therefore less productive.

Using StackOverflow as an example, let's say it was built to be very energy inefficient, such that even simple searches require 4 times as much electricity as a comparable service. But if it saves you from spending an extra hour Googling those other sites it comes out to a net gain.

In other words, if you believe in you have a quality product, then you have an energy efficient product. It's much more important to focus on providing a good workflow that people will actually use.

Answer 20

Set up your IDE to show a black background rather than white. This will give you extra battery time on a laptop. OS X users can actually invert the entire OS's colours (black <-> white) by pressing CTRL+ALT+SHIFT+COMMAND+SPACE+BACKSPACE+INSERT+8 (or something like that).

Answer 21

Develop on VIM with a black background. Build your apps to have dark backgrounds.

Answer 22

Support older operating systems and hardware, some hardware upgrades are driven by new software.

Answer 23

Work from home. I did a quick estimate of kilos of CO2 put into the atmosphere by my commute, and it's frightening.

Answer 24

There is an excellent PDC video here on the topic wrt Windows:

http://channel9.msdn.com/pdc2008/PC19/

"Inefficient background activity has a dramatic impact on system performance, power consumption, responsiveness, and memory footprint. This session demonstrates best practices for background process design and dives deep on the capabilities of the Service Control Manager (SCM) and Task Scheduler."

Answer 25

Don't open your computer ;)

If you need to open your computer, don't send spam mail :O

If you need to send an email, you must be use plain text. Don't use the HTML format and pictures.

Don't browse rich web site :P (Like as this site.)

Joke, joke...

Answer 26

As for energetic efficiency, from now on all my software (tools to) will put the monitor on standby if the software or the computer is not used for x minutes.

Of course there many tools and system way to do this, but not every user know about it or know how to do it. So from now on it’s a standard feature.

Saving the planet one disconnected monitor at a time.

Answer 27

I think something that is going to help here is the advent of cloud computing.

Now that you are going to be billed for every CPU second, every HTTP request, every byte of storage, there is much more motivation to code economically.