is clean code usually not fast?

[u/20260819]

to be specific i'm writing a cpu-based rasterizer. the maths are not difficult but i find a strange property: if i divide the procedure into some small functions, the code looks cleaner and is easier to maintain but a bit slower. on the contrary if i put everything into a single procedure, it looks stupid but fast. why is that? an example illustrating this

code 1:

if cross_product(x0,y0,x1,y1)>0 then zzz

(and i write a "cross_product" function separately)

code 2:

c=x0y1-y0x1

if c>0 then zzz

code 3:

if x0y1-y0x1>0 then zzz

if i write the entire algorithm in the style of "code 3", it runs the fastest. "code 1" is slowest

is it normal?

[u/two_three_five_eigth]

code 1 has a function call. Calling the function (unlesss it's inlined) means the variables get copied, so 4 extra copies.

Code 2 seems equivalent to code 3, but you've added an extra variable that lives to the end of the block.

Code 3 the calculation is scoped to exactly where it's needed, so the compiler has no trouble optimizing it.

Without digging further, likely 3 is fastest because you did exactly what you needed, which let the compiler optimize it the best.

[u/20260819 → u/two_three_five_eigth]

yes the difference was noticeable. i did a experiment. for comparison, i rotated the same object (the regular dodecahedron) and recorded the fps. the fps varied and i picked the average values

if everything was calculated by functions: ~16 fps

then i copied the barycentric function into the procedure: ~14 fps

then i replaced one of the cross products with direct calculation: ~16 fps

replaced 2 lines: ~19 fps

3 lines: ~20 fps

all direct calculations, no function: ~25 fps