LÖVE

slime wrote:

miko wrote:

Roland_Yonaba wrote: Of course, it is... Just assume that love functions are packed in a global table. Assigning them to local function make them run faster.

unless you have compiled love against luajit - in this case creating more variables makes things slower.

Incorrect. The only time localizing variables will hurt performance in LuaJIT is when localizing a function/variable in a FFI C library namespace directly. This only applies when you are using the LuaJIT FFI! localizing anything else will help performance!

Boolsheet wrote:Putting it in a table is quite fast, but that comes at the price of memory and later time in the garbage collector.
I'm surprised the recursive variant is so slow, it's usually the fastest. Perhaps it hits a bottleneck somewhere with 2^10 items.

Robin wrote:Maybe making recur() local would help? Since ipairs is localised as well.

local function nop (...)
end

local function recursive (e, ...)
	if e then
		return recursive(...)
	end
end
_G.recursive = recursive


local ipairs = ipairs

function table_ipairs (...)
	for i, e in ipairs {...} do
	end
end


function table_numfor (...)
	local t = { ... }

	for i = 1, #t do
		local e = t[i]
	end
end


local select = select

function select_numfor (...)
	for i = 1, select('#', ...) do
		local e = select(i, ...)
	end
end


local t = {}
local size = 2^10

for i = 1, size do
	t[i] = i
end


local unpack = unpack
local f = _G[...] or nop
local loops = 2^10

for i = 1, loops do
	f(unpack(t))
end

nop:           0.060
recursive:     4.950 (4.890)
table_ipairs:  0.250 (0.190)
table_numfor:  0.130 (0.070)
select_numfor: 5.000 (4.940)

Boolsheet wrote:Putting it in a table is quite fast, but that comes at the price of memory and later time in the garbage collector.
I'm surprised the recursive variant is so slow, it's usually the fastest. Perhaps it hits a bottleneck somewhere with 2^10 items.

Rad3k wrote:As for the memory, I ran the test with enough loops to last a few minutes, and actually lua's memory usage never increased noticably.

Rad3k wrote:Some trivia (may or may not apply to your system):

n - n%1 is a about 28% faster than floor(n) (where floor is localised math.floor), but wrapping it in a custom function kills any benefits, and actually makes it slower.

n + 1 - n%1 is a about 10% faster than math.ceil.

Curiously enough, n - n%1 + 1 is consistently slower than n + 1 - n%1 (still faster than math.ceil though). Why the speed difference? I don't know, but it looks like Lua doesn't optimize expressions. Actually it's perfectly logical, considering that Lua can't know at compile time if a variable will hold a number or something else (e.g. a table with arithmetic metamethods).

Rad3k wrote:Why the speed difference? I don't know,