they c me unrollin'

in beautiful code, charles petzold writes about generating assembly and msil (the .net equivalent of bytecode) on the fly to create optimized inner loops.

in c and asssembler, you can unroll loops at build time so that instead of:

mov eax,320
beginning_of_loop:
;do something
dec eax
jnz beginning_of_loop

you have 320 do somethings..

beginning_of_loop:
;do something
;do something
;do something
;do something
;do something
... (314 more)
;do something

if you want to do it less than 320 times,
you jump to beginning_of_loop + size_of 'do something' * (320-how_many_times_you_want_to_do_it) instead of beginning_of_loop.

but if do something looks like:

temp=0;
for (i = 0; i < a; i++)
temp += s[offset+i];
end
d[offset++] = temp/a;

you won't know what a is until runtime. so petzold writes about unrolling this part on the fly. and he claims his generated MSIL-code runs at 4 times the speed of the c# version.

this is interesting. because a modern JIT compiler should be able to unroll this part too.

does it? how can I see the assembler code that the jit actually runs? how many iterations are needed before the jit recompiles this loop into the fastest possible inner loop?

pekka pls explain.

also, in this case you could just keep temp, substract s[offset-1] and add s[offset+a] instead of going through the loop at all.