Changes between Version 2 and Version 3 of code/PerformanceTips

Timestamp:

Apr 10, 2005, 7:07:13 PM (20 years ago)

Author:

simon

Comment:

—

code/PerformanceTips

@@ -102 +102 @@
 }}}
 This implementation saves us time as 2 less copy constructors are called. In this particular problem we could save time by knowing waht happens behind the scenes.
+ 
+== Pointer arithmetic ==
+Dereferencing a pointer takes some time. If you do something like this:
+{{{
+for( int i = 0; i < numPixels; i++ )
+{
+   rendering_context->back_buffer->surface->bits[i] = some_value; 
+}
+}}}
+you're wasting much time in the loop dereferencing.[br]
+Instead you could do this:
+{{{
+unsigned char *back_surface_bits = rendering_context->back_buffer->surface->bits;
+for( int i = 0; i < numPixels; i++ )
+{
+   back_surface_bits[i] = some_value;
+}
+}}}
+or even faster:
+{{{
+unsigned char *back_surface_bits = rendering_context->back_buffer->surface->bits;
+for( int i = 0; i < numPixels; i++,back_surface_bits++ )
+{
+   *back_surface_bits = some_value;
+}
+}}}
+By leaving the brackets and going into pointer arithmetics the addresses don't have to be calculated, saving you some time to drink a cup of coffee.
+ 
+== Math optimisations ==
+Bit shifting is a very fast way to perform integer math. It is limited in it's use, as you can only multiply and divide by 2, but it is very fast. Consider:
+{{{
+i *= 256;            //i = i * 256
+i = i << 8;          //i = i * 256
+}}}
+Logically, they are the same. For this simple example, the compiler might even turn the first into the second, but as you get more complex the compiler might not be able to make the conversion. Example:
+{{{
+i *= 272             //i = i * 272
+i = i << 8 + i << 4  //i = i * 272
+}}}
+One should also keep in mind, that multiplying is way slower than adding. This is why this makes sense:
+{{{
+a*b + a*c;
+a*(b+c);             //This gets rid of one multiplication, with no change to the meaning of the expression
+}}}
+A variation on the previous item, but this time, replacing two divisions by a division and a multiplication. On every platform that I am aware of, divisions are slower than multiplications, so this rewrite will provide a speed improvement. 
+{{{
+b/a + c/a = (1/a)*(b+c);
+}}}
+The last example is perhaps not so obvious, but the C++ standard requires lazy evaluation.
+{{{
+(a || b ) && c;
+c && ( a || b ); 
+}}}
+In the first case, whenever c happens to be false, ( a || b ) has to be evaluated, whereas in the second case, it can be skipped as the entire expression can never evaluate to true anymore.