Lua + FFI vs. Javascript

This short article does not pretend to be an article.

Last time, I compared LuaJIT 2.0 Beta 5 and JavaScript in various browsers using a simple ray tracer as an example. Comparison result: JavaScript in Chrome scored 20,000 RPS and took 1st place, and LuaJIT - 5,000 RPS and last place.

With the release of LuaJIT 2.0 Beta 6, the situation has changed: Lua easily came out on top of Chrome. Let's see how it turned out.



Imagine that you have a large array that needs to be filled with numbers. How do you do this? Here is an example implementation on Lua:

a = {}
for i = 1, n do
  a[i] = i*i - 0.5
end

For large n, this works very slowly: Lua does not know in advance what size the array will be and therefore is forced to increase the size of this array dynamically. Lua does not even know that the indices of the array are numbers in the range 1..n, and the values ​​are integers, so he has to rely on the worst case scenario when they once write to the array like this:

a['qqq'] = {red = 1, green = 0.5, blue = 0.8}

This versatility slows down the program. I would like to inform Lua somehow that we have an array of the form “double a [n]”. You cannot do this with standard Lua tools, but you can add an extension to Lua - the language allows this - and get what you need. This extension is called FFI. Here's how to solve the array problem:

ffi = require'ffi'
a = ffi.new('double[?]', 1 + n)
for i = 1, n do
  a[i] = i*i
end

This simple code change increases the speed many times and reduces the memory many times. Just what you need for a ray tracer.

The previous ray tracer kept in memory a table consisting of flowers - small tables with three fields. A ray was launched through each pixel, its color was calculated, and this color fell into the table. It looked something like this:

pixels = {}
for x = 1, width do
	for y = 1, height do
		local color = raytrace(x, y)
		pixels[y*width + x] = color
	end
end

During operation, this pixel table grew, the time for adding a new element also increased, and the speed of the ray tracer fell. The result is 5,000 RPS (rays per second) and last place.

With the advent of FFI, it became possible to represent the pixels table as an array, having previously allocated memory. The algorithm has become like this:

ffi = require'ffi'
pixels = ffi.new('float[?]', width*height*3)
i = 0
for y = 1, height do
	for x = 1, width do
		local color = raytrace(x, y)
		pixels[i + 0] = color[1]
		pixels[i + 1] = color[2]
		pixels[i + 2] = color[3]
		i = i + 3
	end
end

The code has become a little longer than before, but in other places the code has been simplified: for example, saving such an array in a BMP file is easier. This simple optimization does three things:

1. The amount of memory is reduced to 25 megabytes and does not grow during operation.
2. The speed of the ray tracer does not depend on the size of the resulting image.
3. Speed ​​increases to 40,000 RPS

For comparison: the best result of the previous comparison - JavaScript + Chrome - received 20,000 RPS and spent 150 MB of memory.

Below the test results are partially taken from the previous comparison. Raytrace programs sent the same scene to a screen of 1000 × 1000 pixels by passing 3 beams through each pixel.

Luajit	40,000 RPS	25 Mb
Chrome	20,400 RPS	150 Mb
Opera	15,700 RPS
Firefox	9,300 RPS
Explorer	9,000 RPS

It remains to say that I wrote the Lua raster tracer in a straightforward manner and with each operation on vectors (addition, multiplication by a number) it creates a new vector with the result. This bunch of constantly-created vectors does the job of the garbage collector. If you do not create extra vectors, then the speed of the ray tracer will increase further.

The ray tracer of which I spoke lies here . Run the command "luajit main.lua". Luajit version at least 2.0 Beta 6.