loop-unrolling

Given the following code #include <stdio.h> int main(int argc, char **argv) { int k = 0; for( k = 0; k < 20; ++k ) { printf( "%d\n", k ) ; } } Using GCC 5.1 or later with -x c -std=c99 -O3 -funroll-all-loops --param max-completely-peeled-insns=1000 --param max-completely-peel-times=10000 does partially loop unrolling, it unrolls the loop ten times and then does a conditional jump. .LC0: .string "%d\n" main: pushq %rbx xorl %ebx, %ebx .L2: movl %ebx, %esi movl $.LC0, %edi xorl %eax, %eax call printf leal 1(%rbx), %esi movl $.LC0, %edi xorl %eax, %eax call printf leal 2(%rbx), %esi movl $.LC0,

wikipedia ( here ) gives a compile time unrolling of for loop....... i was wondering can we use a similar for loop with template statements inside... for example... is the following loop valid template<int max_subdomain> void Device<max_sudomain>::createSubDomains() { for(int i=0; i< max_subdomain; ++i) { SubDomain<i> tmp(member); ... // some operations on tmp ... } } SubDomain is a class which takes in the a template parameter int and here has been constructed with an argument that is a member of the Device class. Thanks for the answer guys... now that you know what i want... is there anyway

In CUDA it is possible to unroll loops using the #pragma unroll directive to improve performance by increasing instruction level parallelism. The #pragma can optionally be followed by a number that specifies how many times the loop must be unrolled. Unfortunately the docs do not give specific directions on when this directive should be used. Since small loops with a known trip count are already unrolled by the compiler, should #pragma unroll be used on larger loops? On small loops with a variable counter? And what about the optional number of unrolls? Also is there recommended documentation

I have a lot of if, else if statements and I know there has to be a better way to do this but even after searching stackoverflow I'm unsure of how to do so in my particular case. I am parsing text files (bills) and assigning the name of the service provider to a variable (txtvar.Provider) based on if certain strings appear on the bill. This is a small sample of what I'm doing (don't laugh, I know it's messy). All in all, There are approximately 300 if, else if's. if (txtvar.BillText.IndexOf("SWGAS.COM") > -1) { txtvar.Provider = "Southwest Gas"; } else if (txtvar.BillText.IndexOf("georgiapower

What is the loop unrolling policy for JIT? Or if there is no simple answer to that, then is there some way i can check where/when loop unrolling is being performed in a loop? GNode child = null; for(int i=0;i<8;i++){ child = octree.getNeighbor(nn, i, MethodFlag.NONE); if(child==null) break; RecurseForce(leaf, child, dsq, epssq); } Basically, i have a piece of code above that has a static number of iterations (eight), and it does bad when i leave the for loop as it is. But when i manually unroll the loop, it does significantly better. I am interested in finding out if the JIT actually does

When a compiler performs a loop-unroll optimization, how does it determined by which factor to unroll the loop or whether to unroll the whole loop? Since this is a space-performance trade-off, on average how effictive is this optimization technique in making the program perform better? Also, under what conditions is it recommended to use this technique (i.e certain operations or calculations)? This doesn't have to be specific to a certain compiler. It can be any explanation outlining the idea behind this technique and what has been observed in practice. When a compiler performs a loop unroll

This question is in part a follow up question to GCC 5.1 Loop unrolling . According to the GCC documentation , and as stated in my answer to the above question, flags such as -funroll-loops turn on "complete loop peeling (i.e. complete removal of loops with a small constant number of iterations)" . Therefore, when such a flag is enabled, the compiler can choose to unroll a loop if it determines that this would optimise the execution of a given piece of code. Nevertheless, I noticed in one of my projects that GCC would sometimes unroll loops even though the relevant flags were not enabled . For