Performance of computing constants

Question

How do the following two blocks of pseudo-code compare in terms of speed for both compiled languages and interpreted languages? (Ignoring number of digits)

Essentially, is there any performance loss by writing variables as a function of several constants, rather than computing beforehand? This often makes code more clear.

permanentNum = (3.1416 / 3) + 1.5708
return permanentNumber / userInputNumber

.

permanentNum = 2.6179
return permanentNumber / userInputNumber

Thanks!

"Interpreted" languages these days are often JIT compiled, so the distinction you make is blurry at best — Nemo, Nov 05 '12 at 01:35

Mitch Wheat · Answer 1 · 2012-11-05T01:26:51.677

3

Start by striving for code clarity.

Then measure performance. If there is a performance problem, identify the bottlenecks.

Any bottlenecks are highly unlikely to be in the assignment of constants (compiled or interpreted code).

edited Nov 05 '12 at 01:26

answered Nov 05 '12 at 01:20

Mitch Wheat

295,962
43
465
541

score 3 · Accepted Answer · answered Nov 05 '12 at 01:24

Mitch Wheat's comment is absolutely correct; optimization is something to do after you have clear and correct code, and only when necessary.

To answer the question, though, it obviously depends on the language. Any decent compiler for the C-like languages has a constant-folding optimization pass. On GCC, or Oracle's javac, or any widely used compiler, your two examples will generate the same code.

Interpreted languages are likely slow enough that the cost of a few extra arithmetic operations is not your bottleneck, whether it does constant-folding at parse time or not. :-)

Ah, so "constant folding" is the term I was looking for. I'm actually working on a C# application where this question cropped up once again, and I decided to finally get the low down on it. I'm sure the C# compiler does these sort of optimizations. — Wehrdo, Nov 05 '12 at 01:35

score 1 · Answer 3 · answered Nov 05 '12 at 01:25

Compilers will usually optimize constants like that, so even if you write (3.1416 / 3) + 1.5708 the value that will end up in your object code is 2.6179. Interpreters might do the same, but since they do it at runtime, then yes, the performance will be lower.

However, the difference will probably be negligible so, as Mitch Wheat said, you should favor code clarity. Theoretical analysis is one thing, but the only way to be sure of what are the actual bottlenecks of your particular code (in your particular environment) is testing, profiling, measuring.

Performance of computing constants

3 Answers3