loop-unrolling

问题 Consider the following simple example: struct __attribute__ ((__packed__)) { int code[1]; int place_holder[100]; } s; void test(int n) { int i; for (i = 0; i < n; i++) { s.code[i] = 1; } } The for-loop is writing to the field code , which is of size 1. The next field after code is place_holder . I would expect that in case of n > 1 , the write to code array would overflow and 1 would be written to place_holder . However, when compiling with -O2 (on gcc 4.9.4 but probably on other versions as

问题 Consider the following simple example: struct __attribute__ ((__packed__)) { int code[1]; int place_holder[100]; } s; void test(int n) { int i; for (i = 0; i < n; i++) { s.code[i] = 1; } } The for-loop is writing to the field code , which is of size 1. The next field after code is place_holder . I would expect that in case of n > 1 , the write to code array would overflow and 1 would be written to place_holder . However, when compiling with -O2 (on gcc 4.9.4 but probably on other versions as

问题 I'm new to CUDA, and I can't understand loop unrolling. I've written a piece of code to understand the technique __global__ void kernel(float *b, int size) { int tid = blockDim.x * blockIdx.x + threadIdx.x; #pragma unroll for(int i=0;i<size;i++) b[i]=i; } Above is my kernel function. In main I call it like below int main() { float * a; //host array float * b; //device array int size=100; a=(float*)malloc(size*sizeof(float)); cudaMalloc((float**)&b,size); cudaMemcpy(b, a, size,

问题 I'm new to CUDA, and I can't understand loop unrolling. I've written a piece of code to understand the technique __global__ void kernel(float *b, int size) { int tid = blockDim.x * blockIdx.x + threadIdx.x; #pragma unroll for(int i=0;i<size;i++) b[i]=i; } Above is my kernel function. In main I call it like below int main() { float * a; //host array float * b; //device array int size=100; a=(float*)malloc(size*sizeof(float)); cudaMalloc((float**)&b,size); cudaMemcpy(b, a, size,

问题 I am writing in C and compiling using clang. I am trying to unroll a loop. The loop is not unrolled and there is a warning. loop not unrolled: the optimizer was unable to perform the requested transformation; the transformation might be disabled or specified as part of an unsupported transformation ordering [-Wpass-failed=transform-warning] You can find the results here: https://godbolt.org/z/4flN-k int foo(int c) { size_t w = 0; size_t i = sizeof(size_t); #pragma unroll while(i--) { w = (w <

问题 I am writing in C and compiling using clang. I am trying to unroll a loop. The loop is not unrolled and there is a warning. loop not unrolled: the optimizer was unable to perform the requested transformation; the transformation might be disabled or specified as part of an unsupported transformation ordering [-Wpass-failed=transform-warning] You can find the results here: https://godbolt.org/z/4flN-k int foo(int c) { size_t w = 0; size_t i = sizeof(size_t); #pragma unroll while(i--) { w = (w <

问题 I have been working with a piece of code which is intensively memory bound. I am trying to optimize it within a single core by manually implementing cache blocking, sw prefetching, loop unrolling etc. Even though cache blocking gives significant improvement in performance. However when i introduce loop unrolling I get tremendous performance degradation. I am compiling with Intel icc with compiler flags -O2 and -ipo in all my test cases. My code is similar to this (3D 25-point stencil): void

问题 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

问题 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

问题 I am attempting to optimise some loops and I have managed but I wonder if I have only done it partially correct. Say for example that I have this loop: for(i=0;i<n;i++){ b[i] = a[i]*2; } unrolling this by a factor of 3, produces this: int unroll = (n/4)*4; for(i=0;i<unroll;i+=4) { b[i] = a[i]*2; b[i+1] = a[i+1]*2; b[i+2] = a[i+2]*2; b[i+3] = a[i+3]*2; } for(;i<n;i++) { b[i] = a[i]*2; } Now is the SSE translation equivalent: __m128 ai_v = _mm_loadu_ps(&a[i]); __m128 two_v = _mm_set1_ps(2); _