Implement Vector/Angle types as ffi types

[Srlion]

Implementing Vector/Angle should benefit performance by a lot, hence why lots of people implement one in Lua and then convert to C++ if they do lot's of operations, I'm not sure how it could be done from C++ side,

https://luajit.org/ext_ffi_tutorial.html

local ffi = require("ffi")
local type = type

ffi.cdef [[
typedef struct { float x, y, z; } GMOD_Vector_t;
]]

function isvector(v)
    return ffi.istype("GMOD_Vector_t", v)
end

local Vector
local methods = {}
local mt = {
    __index = function(s, k)
        if type(k) == "number" then
            if k == 1 then
                return s.x
            elseif k == 2 then
                return s.y
            elseif k == 3 then
                return s.z
            end
        end
        return methods[k]
    end,
    __eq = function(a, b)
        if not isvector(b) then return false end
        return a.x == b.x and a.y == b.y and a.z == b.z
    end,
    __add = function(a, b) return Vector(a.x + b.x, a.y + b.y, a.z + b.z) end,
    __sub = function(a, b) return Vector(a.x - b.x, a.y - b.y, a.z - b.z) end,
    __mul = function(a, b) return Vector(a.x * b.x, a.y * b.y, a.z * b.z) end,
    __div = function(a, b) return Vector(a.x / b.x, a.y / b.y, a.z / b.z) end,
    __unm = function(a) return Vector(-a.x, -a.y, -a.z) end,
    __tostring = function(a)
        return string.format("%f %f %f", a.x, a.y, a.z)
    end,
}

function methods:Add(v)
    self.x, self.y, self.z = self.x + v.x, self.y + v.y, self.z + v.z
end

Vector = ffi.metatype("GMOD_Vector_t", mt)

local a = Vector()
print(a)

Adding type checking for most functions would be needed, also would need to make sure that the struct matches the source engine's struct

If user decides to disable ffi, could just add the vector type then disable ffi by not allowing access to it

[Zvbhrf]

if type(k) == "number" then

Is isnumber(x) slower than type(x) == "number" in gmod now?

[Srlion]

if type(k) == "number" then

Is isnumber(x) slower than type(x) == "number" in gmod now?

For now yes, waiting for Facepunch/garrysmod#2291

[Zvbhrf]

god, the hell happens with c calls in gmod?

[Srlion]

god, the hell happens with c calls in gmod?

Nothing special really, is* functions use normal C function calls which is slow compared to special functions in luajit like type/getmetatable

[Srlion]

So I managed to make reusable vectors, which was what @RaphaelIT7 wanted to achieve more than just making accessing x/y/z/calling methods on vectors faster, to reduce allocations/gc pressure

local POOL_SIZE = 20000

local ffi = require("ffi")
local type = type
local table = table

ffi.cdef [[
typedef struct { float x, y, z; } GMOD_Vector_t;
]]

function isvector(v)
    return ffi.istype("GMOD_Vector_t", v)
end

local Vector
local methods = {}
local mt = {
    __index = function(s, k)
        if type(k) == "number" then
            if k == 1 then
                return s.x
            elseif k == 2 then
                return s.y
            elseif k == 3 then
                return s.z
            end
        end
        return methods[k]
    end,
    __eq = function(a, b)
        if not isvector(b) then return false end
        return a.x == b.x and a.y == b.y and a.z == b.z
    end,
    __add = function(a, b) return Vector(a.x + b.x, a.y + b.y, a.z + b.z) end,
    __sub = function(a, b) return Vector(a.x - b.x, a.y - b.y, a.z - b.z) end,
    __mul = function(a, b) return Vector(a.x * b.x, a.y * b.y, a.z * b.z) end,
    __div = function(a, b) return Vector(a.x / b.x, a.y / b.y, a.z / b.z) end,
    __unm = function(a) return Vector(-a.x, -a.y, -a.z) end,
    __tostring = function(a)
        return string.format("%f %f %f", a.x, a.y, a.z)
    end
}

function methods:Add(v)
    self.x, self.y, self.z = self.x + v.x, self.y + v.y, self.z + v.z
end

local RawVector = ffi.metatype("GMOD_Vector_t", mt)

local POOL = {}
local function add_to_pool(v)
    table.insert(POOL, v)
    ffi.gc(v, add_to_pool)
end
for i = 1, POOL_SIZE do
    local v = RawVector()
    add_to_pool(v)
end

function Vector(x, y, z)
    if x == nil then
        x = 0
    end
    if y == nil then
        y = 0
    end
    if z == nil then
        z = 0
    end
    local v_pool = table.remove(POOL)
    if v_pool then
        v_pool.x, v_pool.y, v_pool.z = x, y, z
        return v_pool
    end
    return RawVector(x, y, z)
end

local v = Vector(1, 2, 3)
print(#POOL)
v = nil

collectgarbage()
print(#POOL)

local v = Vector(1, 2, 3)
print(#POOL)
v = nil

collectgarbage()
print(#POOL)

A pool of 20k is kinda an overkill and should probably be reduced to avoid pressuring GC.

Stuff missing:

• Type checks to be 1:1 to gmod
• Make it safe when ffi is disabled, so it becomes safe in unsafe environments, eg. using workshop addons that could check for ffi, they could try to use functions like debug.getupvalue or similar functions to gain access to ffi

[RaphaelIT7]

So in I tried to implement Vector's in LuaJIT itself in here:
RaphaelIT7/gmod-lua-shared@4270e3a

From my testing, creating a vector still is faster using FFI than what I did, though the GC calls are far faster for my case (but the memory usage seemed better? probably needs more testing).
It definitely was interesting to try out, though, and since FFI seems to be the better option, I would stick with it instead.
though I will later to add a vector add function to my implementation to see if it performs better than FFI and if maybe it would be worth it to implemement it into LuaJIT itself than use FFI, though I see this as unlikely.

So, for the FFI implementation, I'll have to figure out a good way to ship Lua with HolyLib & all the places I have to hook into to get the type.

I hooked into ILuaInterface::GetUserdata to support cdata(ffi values) and Gmod now accepts FFI variables.

@Srlion script had to be slightly adjusted for this to work since Gmod expects all userdata in a specific structure, but now this would work for any userdata gmod has.

local POOL_SIZE = 20000

local type = type
local table = table

ffi.cdef [[
typedef struct { void* data; uint8_t type; } GMOD_VecUserData;
typedef struct { float x, y, z; } GMOD_Vector_t;

void* malloc(size_t size);
void free(void* ptr);
]]

function isvector(v)
	return ffi.istype("GMOD_Vector_t", v)
end

function toffivec(v)
	if ffi.istype("GMOD_VecUserData", v) and v.data ~= nil and v.data ~= ffi.NULL then
		return ffi.cast("GMOD_Vector_t*", v.data)
	end
end

local Vector
local methods = {}
local mt = {
	__index = function(s, k)
		local vec = toffivec(s)
		if type(k) == "number" then
			if k == 1 then
				return vec.x
			elseif k == 2 then
				return vec.y
			elseif k == 3 then
				return vec.z
			end
		end
		return methods[k]
	end,
	__eq = function(a, b)
		local vec = toffivec(a)
		local vec2 = toffivec(b)
		if not vec2 then return false end
		return vec.x == vec2.x and vec.y == vec2.y and vec.z == vec2.z
	end,
	__add = function(a, b)
		local vec = toffivec(a)
		local vec2 = toffivec(b)
		return Vector(vec.x + vec2.x, vec.y + vec2.y, vec.z + vec2.z)
	end,
	__sub = function(a, b)
		local vec = toffivec(a)
		local vec2 = toffivec(b)
		return Vector(vec.x - vec2.x, vec.y - vec2.y, vec.z - vec2.z)
	end,
	__mul = function(a, b)
		local vec = toffivec(a)
		local vec2 = toffivec(b)
		return Vector(vec.x * vec2.x, vec.y * vec2.y, vec.z * vec2.z)
	end,
	__div = function(a, b)
		local vec = toffivec(a)
		local vec2 = toffivec(b)
		return Vector(vec.x / vec2.x, vec.y / vec2.y, vec.z / vec2.z)
	end,
	__unm = function(a)
		local vec = toffivec(a)
		return Vector(-vec.x, -vec.y, -vec.z)
	end,
	__tostring = function(a)
		local vec = toffivec(a)
		return string.format("%f %f %f", vec.x, vec.y, vec.z)
	end
}

function methods:Add(v)
	local selfVec = toffivec(self)
	local vec = toffivec(v)
	selfVec.x, selfVec.y, selfVec.z = selfVec.x + vec.x, selfVec.y + vec.y, selfVec.z + vec.z
end

local RawVector = ffi.metatype("GMOD_VecUserData", mt)
local references = {} -- For the gc to not nuke the GMOD_Vector_t & cause a segfault in lj_alloc_free
local function CreateVector(x, y, z)
	local vecdata = ffi.new("GMOD_Vector_t")
	vecdata.x = x or 0
	vecdata.y = y or 0
	vecdata.z = z or 0

	local userdata = RawVector()
	userdata.data = ffi.cast("void*", vecdata)
	userdata.type = 10 -- type for Vector
	references[userdata] = vecdata

	return userdata
end

local POOL = {}
local function add_to_pool(v)
	table.insert(POOL, v)
	ffi.gc(v, add_to_pool)
end
for i = 1, POOL_SIZE do
	local v = CreateVector()
	add_to_pool(v)
end

function Vector(x, y, z)
	if x == nil then
		x = 0
	end
	if y == nil then
		y = 0
	end
	if z == nil then
		z = 0
	end
	local v_pool = table.remove(POOL)
	if v_pool then
		local vec = toffivec(v_pool)
		vec.x, vec.y, vec.z = x, y, z
		return v_pool
	end
	return CreateVector(x, y, z)
end
VectorFFI = Vector

local v = Vector(1, 2, 3)
print(#POOL)
v = nil

collectgarbage()
print(#POOL)

local v = Vector(1, 2, 3)
print(#POOL)
v = nil

collectgarbage()
print(#POOL)