http://cpp.tribe.net/thread/faec10ae-2697-4698-af8a-0b1fec29eb71?format=rss Tribe.net. Local Connections http://CPP.tribe.net/thread/faec10ae-2697-4698-af8a-0b1fec29eb71#dc2d1cb8-3b55-4ed0-b300-d4e3a9a4a5bd Jason, Yes, you can do this with templates. It's called meta-programming, and it's got its' own slew of weirdnesses about it, and like any tool, it can be used to do cool things (good), yet also be used to write code that is absolute hell to figure out (evil). Basically, with templates, you can "run" code at compile-time, without ever "running" the compiled code. Here is a URL that describes some of what is possible with template metaprogramming: http://osl.iu.edu/~tveldhui/papers/Template-Metaprograms/meta-art.html Regards, John Falling You - exploring the beauty of voice and sound http://www.fallingyou.com Sun, 30 Jul 2006 21:36:29 GMT http://CPP.tribe.net/thread/faec10ae-2697-4698-af8a-0b1fec29eb71#dc2d1cb8-3b55-4ed0-b300-d4e3a9a4a5bd John Michael 2006-07-30T21:36:29Z http://CPP.tribe.net/thread/faec10ae-2697-4698-af8a-0b1fec29eb71#7dfd4756-7e9b-4df4-99e1-8039c988d690 btw I was thinking of using a macro like: #define BODY x += p[a++] then in the loop body doing: BODY; BODY; BODY; etc... Turns out that this kills the pipelining since the proc must increment a before issuing the read to the memory controller. The best speed I get comes from hardcoding the offsets as in the code in my prev. post. Sun, 30 Jul 2006 20:35:58 GMT http://CPP.tribe.net/thread/faec10ae-2697-4698-af8a-0b1fec29eb71#7dfd4756-7e9b-4df4-99e1-8039c988d690 Jason 2006-07-30T20:35:58Z http://CPP.tribe.net/thread/faec10ae-2697-4698-af8a-0b1fec29eb71#3632b278-de32-4b65-aeb6-0070196fe1b9 You might be surprised. Unrolling the follwing naive loop: x = 0; for(int a = 0; a<READ_UNROLL_BLOCKSIZE; a++) { x += p[a]; } To the following: int a; x = 0; // we will use 16-fold unroll int blockLimit = READ_UNROLL_BLOCKSIZE & ~15; for(a = 0; a < blockLimit; a+=16) { x += p[a + 0]; x += p[a + 1]; x += p[a + 2]; x += p[a + 3]; x += p[a + 4]; x += p[a + 5]; x += p[a + 6]; x += p[a + 7]; x += p[a + 8]; x += p[a + 9]; x += p[a + 10]; x += p[a + 11]; x += p[a + 12]; x += p[a + 13]; x += p[a + 14]; x += p[a + 15]; } // process the remaining reads for (a = blockLimit; a < READ_UNROLL_BLOCKSIZE;) { x += p[a++]; } results in a significant perf increase. If we run the routine several million times to get a nice sample wed see numbers like this: Running : Loop Unroll Read Running unoptimized version Elapsed time [6.33] seconds Running optimized version Elapsed time [3.17] seconds During the unrolled loop we do 16 read operations before we hit the conditional. This allows the processor to do a lot more pipelining. Unrolling more than 16-fold appears to result in negligible further improvement however. Sun, 30 Jul 2006 20:26:09 GMT http://CPP.tribe.net/thread/faec10ae-2697-4698-af8a-0b1fec29eb71#3632b278-de32-4b65-aeb6-0070196fe1b9 Jason 2006-07-30T20:26:09Z http://CPP.tribe.net/thread/faec10ae-2697-4698-af8a-0b1fec29eb71#75ad724f-13eb-44b9-bc4c-8ad0cd32b70d Not that I know of. You could make an inline function or macro to simplify the code but you'll still have to call the function or macro 16 times. I wonder how much of a performance increase loop unrolling of this type would yield since (I believe) nearly all modern CPU architectures have good branch prediction/multiple execution pipelines for simple loops like this. Sun, 30 Jul 2006 19:51:51 GMT http://CPP.tribe.net/thread/faec10ae-2697-4698-af8a-0b1fec29eb71#75ad724f-13eb-44b9-bc4c-8ad0cd32b70d Jon 2006-07-30T19:51:51Z http://CPP.tribe.net/thread/faec10ae-2697-4698-af8a-0b1fec29eb71#5f60f79a-146a-478a-b63e-0932fb12ebed Is there a c++ preprocessor instruction to repeat something a number of times? I am doing some loop unrolling and I would like to do something like this (making up my own preprocessor command :P) #repeat 16 x += p[a++]; #endrepeat Sun, 30 Jul 2006 19:27:30 GMT http://CPP.tribe.net/thread/faec10ae-2697-4698-af8a-0b1fec29eb71#5f60f79a-146a-478a-b63e-0932fb12ebed Jason 2006-07-30T19:27:30Z