Tell gcc to specifically unroll a loop

Question

How can I tell GCC to unroll a particular loop? I have used the CUDA SDK where loops can be unrolled manually using #pragma unroll. Is there a similar feature for gcc? I googled a bit but could not find anything.

Solution 1

GCC gives you a few different ways of handling this:

• Use #pragma directives, like #pragma GCC optimize ("string"...), as seen in the GCC docs. Note that the pragma makes the optimizations global for the remaining functions. If you used #pragma push_options and pop_options macros cleverly, you could probably define this around just one function like so:

  #pragma GCC push_options
  #pragma GCC optimize ("unroll-loops")
  //add 5 to each element of the int array.
  void add5(int a[20]) {
      int i = 19;
      for(; i > 0; i--) {
          a[i] += 5;
      }
  }
  #pragma GCC pop_options
  

• Annotate individual functions with GCC's attribute syntax: check the GCC function attribute docs for a more detailed dissertation on the subject. An example:

  //add 5 to each element of the int array.
  __attribute__((optimize("unroll-loops")))
  void add5(int a[20]) {
      int i = 19;
      for(; i > 0; i--) {
          a[i] += 5;
      }
  }
  

Note: I'm not sure how good GCC is at unrolling reverse-iterated loops (I did it to get Markdown to play nice with my code). The examples should compile fine, though.

Solution 2

GCC 8 has gained a new pragma that allows you to control how loop unrolling is done:

#pragma GCC unroll n

Quoting from the manual:

You can use this pragma to control how many times a loop should be unrolled. It must be placed immediately before a for, while or do loop or a #pragma GCC ivdep, and applies only to the loop that follows. n is an integer constant expression specifying the unrolling factor. The values of 0 and 1 block any unrolling of the loop.

Solution 3

-funroll-loops might be helpful (though it turns on loop-unrolling globally, not per-loop). I'm not sure whether there's a #pragma to do the same...

Comments

[Nils]

nah I found that too, but I want to just unroll a specific loop

[osgx]

bmei from broadcom have a set of patches to add "#pragma unroll" support to gcc.

[Admin]

@Jerry Coffin, How can I use it ? Can you give me a command which uses -funroll-loop ?

[Simplex]

Very cool that there is a function attribute for this, however it's ignored by Apple's latest GCC for iOS: "warning: 'optimize' attribute directive ignored". (I know they've transitioned to LLVM but I'm still using GCC sometimes, as it sometimes produces faster code.) Anyone know why it's ignored? Is Apple's GCC branch too old? On a side note, in the function on which I've been using it, loops get unrolled anyway as long as I use -O3.

[endolith]

I just tried __attribute__((optimize("unroll-loops"))) with some embedded code and it improved speed by only 3%. Manually unrolling 8 times improved speed by 12% and didn't increase program size as much.

[neodelphi]

My gcc tells warning: ignoring #pragma optimize... Is this always available ?

[maxschlepzig]

in case somebody else is wondering, both clang 3.9 and icc 13 don't support this attribute nor the pragma

[mtraceur]

Seems like the more correct/relevant answer for present day.