Return to Revisions

Cybergibbons's answer describes quite nicely the assembly code generation and the differences amongst the two techniques. This is intended to be a complementary answer looking at the issue in terms of practical differences, i.e. how much of a difference either approach will make in terms of execution time.

##Code Variations I did a small analysis involving the following variations:

• Basic void loop() (which gets inlined on compilation)
• Un-inlined void loop() (using __attribute__ ((noinline)))
• Loop with while(1) (which gets optimized)
• Loop with un-optimized while(1) (by adding __asm__ __volatile__("");. This is a nop instruction that prevents optimization of the loop without resulting in additional overheads of a volatile variable)
• An un-inlined void loop() with optimized while(1)
• An un-inlined void loop() with un-optimized while(1)

The sketches can be found here.

##Experiment I ran each of these sketches for 30 seconds, thereby accumulating 300 data points each. There was a 100 millisecond delay call in each loop (without which bad things happen).

##Results I then calculated the mean execution times of each loop, subtracted 100 milliseconds from each and then plotted the results.

http://raw2.github.com/AsheeshR/Arduino-Loop-Analysis/master/Figures/timeplot.png

#Conclusion

• An un-optimised while(1) loop within void loop is faster than a compiler optimised void loop.
• The time difference between the un-optimized code and default Arduino optimized code is insignificant practically. You will be better off compiling manually using avr-gcc and using your own optimisation flags rather than depending on the Arduino IDE to help you with it (if you need microsecond optimisations).

NOTE: The actual time values are not of significance here, the difference between them is. The ~90 microseconds of execution time include a call to Serial.println, micros and delay.

NOTE2: This was done using the Arduino IDE and the default compiler flags that it supplies.