Best practices to ensure low power consumption [closed] - c

Question

Closed. This question needs to be more focused. It is not currently accepting answers.
Want to improve this question? Update the question so it focuses on one problem only by editing this post.
Closed 7 years ago.
Improve this question
Assume I have two programs P1 and P2 which perform the same functionality, but P1 consumes lesser power than P2 when they run. What are some best practices in coding that help me write good (in terms of low power consumption) programs like P1? You can assume C or any other popular language.
I am asking from a battery saving point of view (say, for a smartphone).

Answer 1

To start off, let's consider what consumes power on a modern CPU (most to least):
running at higher frequencies
keeping more cores online
doing any kind of work
If a particular thread is taking a while to do something, the kernel might boost the CPU frequency to ensure smooth performance, thereby increasing power consumption. In fact, power consumption increases with CPU frequency - exponentially (!) so (PDF), so it's a really good idea to reduce how long it takes to get any particular thing done as much as possible.
If multiple tasks are active and doing enough work that they cannot easily and/or performantly share a single core, the kernel will bring additional cores online (well, technically they're just not sleeping anymore - they were never offline) if available, again, in order to ensure smooth performance. Now this scales roughly about linearly, especially, in mobile ARM processors, according to NVIDIA (PDF).
When the processor doesn't have any work to do, the kernel will put it to sleep if possible, which usually consumes ridiculously small amounts of power, thus vastly increasing how long the device can run on its battery.
So far, we have essentially established that we should do as little work as possible, should do whatever we need to do as fast as possible, and that we should minimize any overhead we have via threads. The neat thing about these attributes is that doing optimizing for them will also likely increase performance! So without further ado, let's actually start seeing what we can do:
Block / No Event Loops
When we use nonblocking calls, we usually end up doing a lot of polling. This means that we are just burning through CPU cycles like an insane madman until something happens. Event loops are the usual way that people go about doing this and are an excellent example of what not to do.
Instead, use blocking calls. Often, with things such as IO, it may take quite a while for a request to complete. In this time, the kernel can allow another thread or process to use the CPU (thus reducing the overall usage of the processor) or can sleep the processor.
In other words, turn something like this:
while (!event) {
event = getEvent (read);
}
into something like this:
read ();
Vectorize
Sometimes, you have a lot of data that you need to process. Vector operations allow you to process more data faster (usually - in rare occasions they can be much slower and just exist for compatibility). Therefore, vectorizing your code can often allow for it to complete its task faster, thus utilizing less processing resources.
Today, many compilers can auto-vectorize with the appropriate flags. For instance, on gcc, the flag -ftree-vectorize will enable auto-vectorization (if available) which can accelerate code massively by processing more data at a time when appropriate, often freeing up registers in the process (thus reducing register pressure), which also has the beneficial side effect of reducing loads and stores, which can in turn further increase performance.
On some platforms, vendors may provide libraries for processing certain kinds of data that may help with this. For instance, the Accelerate framework by Apple includes functions for dealing with vector and matrix data.
However, in certain cases, you may want to do the vectorization yourself, such as when the compiler does not see the opportunity to vectorize or does not fully utilize the opportunity, you may want to vectorize your code yourself. This is often done in assembly, but if you use gcc or clang, you can simply use a form of intrinsics to write portable vectorized code (albeit for all platforms with the specified vector size):
typedef float v4f __attribute__ (((vector_size (16)));
// calculates (r = a * b + c) four floats at a time
void vmuladd (const v4f *a, const v4f *b, const v4f *c, int n) {
int x;
for (x = 0; x < n; x++) {
r[x] = a[x] * b[x];
r[x] = r[x] + c[x];
}
}
This may not be useful on older platforms, but this could seriously improve performance on ARM64 and other modern 64-bit platforms (x86_64, etc.).
Parallelization
Remember how I said that keeps more cores online is bad because it consumes power? Well:
Parallelization via multiple threads doesn't necessarily mean using more cores. If you paid attention to the whole thing I said about using blocking functions, threads could allow you to get work done while other threads wait on IO. That being said, you should not use those extra threads as "IO worker" threads that simply wait on IO - you'll just end up polling all over again. Instead, divide up the individual, atomic tasks that you need to get done among the threads so that for the most part, they can work independently.
It's better to consume more cores than to have to boost clock frequency (linear vs exponential). If you have a task that needs to do a shit ton of processing, it might be useful to break up that processing among a few threads so that they can utilize the available cores. If you do this, take care to ensure that only minimal synchronization is required across the threads; we don't want to waste even more cycles just waiting for synchronization.
When possible, try to combine both of the approaches - parallelize tasks when you have a lot of things to do and parallelize computation when you have a lot of a single thing to do. If you do end up using threads, try to make them block when waiting for work (pthreads - POSIX threads available on both Android and iOS have POSIX semaphores that can help with this) and try to make them long running.
If you have a situation in which you will often need to create and destroy threads, it might be worthwhile to utilize a thread pool. How you accomplish this varies based on the task that you have at hand, but a set of queues is a common way to accomplish this. Ensure that your pools' threads block when there is no work if you use one (this can again be accomplished using the above mentioned POSIX semaphores).
Minimize Work
Try to do as little as you can get by doing. When possible, offload work to external servers up in the cloud, where power consumption isn't as critical of a concern (for most people - this changes once you are at scale).
In situations where you must poll, reducing the frequency of the polling by calling a sleep function can often help - turn something like this:
while (!event) {
event = getEvent ();
}
into something like this:
event = getEvent ();
while (!event) {
sleep (25); // in ms
event = getEvent ();
}
Also, batch processing can work well if you don't have real time requirements (although this may be a good case to push it to the cloud) or if you get lots of independent data rapidly - change something like this:
while (!exit) {
event = getEventBlocking ();
process (event);
}
into something more like this:
while (!exit) {
int x;
event_type *events[16];
for (x = 0; (x < 16) && availableEvents (); x++) {
events[x] = getEventBlocking ();
}
int y;
for (y = 0; y < x; y++) {
process (events[y]);
}
}
This can increase performance by increasing the speed via instruction and data cache locality. If possible, it'd be nice to take this a step further (when such functionality is available on your platform of choice):
while (!exit) {
int x;
event_types **events = getEventsAllBlocking (&x);
int y;
for (y = 0; y < x; y++) {
process (events[y]);
}
}
This will increase performance and waste fewer cycles on waiting and performing function calls. Furthermore, this speedup can become quite noticeable with large amounts of data.
Optimize
This one is pretty easy: crank up the optimization settings on your compiler. Check out the documentation for relevant optimizations that you can enable and benchmark to see if they increase performance and/or reduce power consumption.
On GCC and clang, you can enable recommended safe optimizations by using the flag -O2. Bear in mind that this can make debugging slightly harder, so only use it on production releases.
All in all:
do as little work as possible
don't waste time in event loops
optimize to get shit done in less time
vectorize to get more data processed faster
parallelize to use available resources more efficiently