updated all to 32-bit to save registers and boost performance

package/src/Interpreter.jl

@@ -8,19 +8,19 @@ export interpret
 "Interprets the given expressions with the values provided.
 # Arguments
  - expressions::Vector{ExpressionProcessing.PostfixType} : The expressions to execute in postfix form
- - variables::Matrix{Float64} : The variables to use. Each column is mapped to the variables x1..xn
- - parameters::Vector{Vector{Float64}} : The parameters to use. Each Vector contains the values for the parameters p1..pn. The number of parameters can be different for every expression
+ - variables::Matrix{Float32} : The variables to use. Each column is mapped to the variables x1..xn
+ - parameters::Vector{Vector{Float32}} : The parameters to use. Each Vector contains the values for the parameters p1..pn. The number of parameters can be different for every expression
 "
-function interpret(expressions::Vector{ExpressionProcessing.PostfixType}, variables::Matrix{Float64}, parameters::Vector{Vector{Float64}})::Matrix{Float64}
+function interpret(expressions::Vector{ExpressionProcessing.PostfixType}, variables::Matrix{Float32}, parameters::Vector{Vector{Float32}})::Matrix{Float32}
 	variableCols = size(variables, 2) # number of sets of variables to use for each expression
 	cudaVars = CuArray(variables)
-	cudaParams = create_cuda_array(parameters, NaN64) # column corresponds to data for one expression
+	cudaParams = create_cuda_array(parameters, NaN32) # column corresponds to data for one expression
 	cudaExprs = create_cuda_array(expressions, ExpressionElement(EMPTY, 0)) # column corresponds to data for one expression
 	# put into seperate cuArray, as this is static and would be inefficient to send seperatly to every kernel
 	cudaStepsize = CuArray([get_max_inner_length(expressions), get_max_inner_length(parameters), size(variables, 1)]) # max num of values per expression; max nam of parameters per expression; number of variables per expression
 
 	# each expression has nr. of variable sets (nr. of columns of the variables) results and there are n expressions
-	cudaResults = CuArray{Float64}(undef, variableCols, length(expressions))
+	cudaResults = CuArray{Float32}(undef, variableCols, length(expressions))
 
 	# Start kernel for each expression to ensure that no warp is working on different expressions
 	for i in eachindex(expressions)
@@ -37,7 +37,7 @@ end
 
 #TODO: Add @inbounds to all indexing after it is verified that all works https://cuda.juliagpu.org/stable/development/kernel/#Bounds-checking
 const MAX_STACK_SIZE = 25 # The max number of values the expression can have. so Constant values, Variables and parameters
-function interpret_expression(expressions::CuDeviceArray{ExpressionElement}, variables::CuDeviceArray{Float64}, parameters::CuDeviceArray{Float64}, results::CuDeviceArray{Float64}, stepsize::CuDeviceArray{Int}, exprIndex::Int)
+function interpret_expression(expressions::CuDeviceArray{ExpressionElement}, variables::CuDeviceArray{Float32}, parameters::CuDeviceArray{Float32}, results::CuDeviceArray{Float32}, stepsize::CuDeviceArray{Int}, exprIndex::Int)
 	index = (blockIdx().x - 1) * blockDim().x + threadIdx().x # ctaid.x * ntid.x + tid.x
 	stride = gridDim().x * blockDim().x # nctaid.x * ntid.x
 	
@@ -46,7 +46,7 @@ function interpret_expression(expressions::CuDeviceArray{ExpressionElement}, var
 	firstParamIndex = ((exprIndex - 1) * stepsize[2]) # Exclusive
 	variableCols = length(variables) / stepsize[3]
 
-	operationStack = MVector{MAX_STACK_SIZE, Float64}(undef) # Try to get this to function with variable size too, to allow better memory usage
+	operationStack = MVector{MAX_STACK_SIZE, Float32}(undef) # Try to get this to function with variable size too, to allow better memory usage
 	operationStackTop = 0 # stores index of the last defined/valid value
 	
 	for varSetIndex in index:stride
@@ -65,9 +65,9 @@ function interpret_expression(expressions::CuDeviceArray{ExpressionElement}, var
 					val = -val
 					operationStack[operationStackTop] = parameters[firstParamIndex + val]
 				end
-			elseif expressions[i].Type == FLOAT64
+			elseif expressions[i].Type == FLOAT32
 				operationStackTop += 1
-				operationStack[operationStackTop] = reinterpret(Float64, expressions[i].Value)
+				operationStack[operationStackTop] = reinterpret(Float32, expressions[i].Value)
 			elseif expressions[i].Type == OPERATOR
 				type = reinterpret(Operator, expressions[i].Value)
 				if type == ADD