optimize generated exe?

[retsyo]

In short, any way to optimize the speed/size of generated exe file?

TLDR:
On my windows 10 64bits with MSYS2+MingW64, the following nim code

import times

proc fibonacci(n: int64): int64 {.discardable.} =
    if n <= 2:
        return 1

    return fibonacci(n - 1) + fibonacci(n - 2)

var N = 45
var st = cpuTime()

for i in 1 .. 10:
    fibonacci(N)

var et = cpuTime()

echo fibonacci(N)

echo et - st

can be compiled and run with

nim c -d:release -d:speed --opt:speed --passL:-s --passc:-flto -r fib

and the output is

1134903170
9.172000000000001

whereas, the following nelua code

require 'math'
require 'os'

local function fibonacci(n: integer): integer
    if n <= 2 then
        return 1
    end
    return fibonacci(n - 1) + fibonacci(n - 2)
end

local N = 45
local st = os.time()

for i = 1, 10 do
    fibonacci(N)
end

local et = os.time()

print(fibonacci(N))

print( et - st )

is compiled with nelua fib.lua and the output is

1134903170
21

[Andre-LA]

try with --release

[edubart]

Use --release or --maximum-performance flag for more aggressive optimizations (see nelua --help). Also you want to use os.clock() instead of os.time() to measure benchmarks.

[retsyo]

--maximum-performance reduce the time from 21 seconds to 12.953 seconds, which is still longer than 9.17 seconds

[edubart]

--maximum-performance reduce the time from 21 seconds to 12.953 seconds, which is still longer than 9.17 seconds

The difference should be mainly due to how GCC layouts function addresses, memory and optimize, nothing related to Nelua. For instance this is the C code generated for the fibonacci function by Nelua (you can check the C file with --print-code):

int64_t a_fibonacci(int64_t n) {
  if((n <= 2)) {
    return 1;
  }
  return (a_fibonacci((n - 1)) + a_fibonacci((n - 2)));
}

As you can see the code cannot be simpler than that, and it does exactly what you wrote.

This is the same fibonacci C code generated by your Nim example (check your Nim cache directory):

static N_INLINE(NI64, subInt64)(NI64 a, NI64 b) {
	NI64 result;
{	result = (NI64)0;
	result = (NI64)((NU64)(a) - (NU64)(b));
	{
		NIM_BOOL T3_;
		T3_ = (NIM_BOOL)0;
		T3_ = (IL64(0) <= (NI64)(result ^ a));
		if (T3_) goto LA4_;
		T3_ = (IL64(0) <= (NI64)(result ^ (NI64)((NU64) ~(b))));
		LA4_: ;
		if (!T3_) goto LA5_;
		goto BeforeRet_;
	}
	LA5_: ;
	raiseOverflow();
	}BeforeRet_: ;
	return result;
}
static N_INLINE(NI64, addInt64)(NI64 a, NI64 b) {
	NI64 result;
{	result = (NI64)0;
	result = (NI64)((NU64)(a) + (NU64)(b));
	{
		NIM_BOOL T3_;
		T3_ = (NIM_BOOL)0;
		T3_ = (IL64(0) <= (NI64)(result ^ a));
		if (T3_) goto LA4_;
		T3_ = (IL64(0) <= (NI64)(result ^ b));
		LA4_: ;
		if (!T3_) goto LA5_;
		goto BeforeRet_;
	}
	LA5_: ;
	raiseOverflow();
	}BeforeRet_: ;
	return result;
}
N_LIB_PRIVATE N_NIMCALL(NI64, fibonacci__AgYjVt05pWYlnKVfVECeug)(NI64 n) {
	NI64 result;
	NI64 TM__R8RUzYq41iOx0I9bZH5Nyrw_2;
	NI64 T5_;
	NI64 TM__R8RUzYq41iOx0I9bZH5Nyrw_3;
	NI64 T6_;
	NI64 TM__R8RUzYq41iOx0I9bZH5Nyrw_4;
{	result = (NI64)0;
	{
		if (!(n <= IL64(2))) goto LA3_;
		result = IL64(1);
		goto BeforeRet_;
	}
	LA3_: ;
	TM__R8RUzYq41iOx0I9bZH5Nyrw_2 = subInt64(n, IL64(1));
	T5_ = (NI64)0;
	T5_ = fibonacci__AgYjVt05pWYlnKVfVECeug((NI64)(TM__R8RUzYq41iOx0I9bZH5Nyrw_2));
	TM__R8RUzYq41iOx0I9bZH5Nyrw_3 = subInt64(n, IL64(2));
	T6_ = (NI64)0;
	T6_ = fibonacci__AgYjVt05pWYlnKVfVECeug((NI64)(TM__R8RUzYq41iOx0I9bZH5Nyrw_3));
	TM__R8RUzYq41iOx0I9bZH5Nyrw_4 = addInt64(T5_, T6_);
	result = (NI64)(TM__R8RUzYq41iOx0I9bZH5Nyrw_4);
	goto BeforeRet_;
	}BeforeRet_: ;
	return result;
}

Notice that the Nim code has higher complexity, yet your C compiler managed to optimize better the Nim code somehow. The difference should be because of memory layout addresses and pure lucky. To really benchmark and compare languages you should consider multiple different benchmarks, you cannot compare languages efficiency based on a single example, because you will be measuring luck.

I've took the same code and used Clang, and then Nelua completes in 2 seconds and Nim completes in 65 seconds with Clang, so the result is inverted and drastically changed.

[retsyo]

thank you for detailed explain