benchmarking: moved frontend calls and sending postfixExprs+vars outside to drastically reduce amount of calculations

package/src/Transpiler.jl

@@ -12,10 +12,7 @@ const Operand = Union{Float32, String} # Operand is either fixed value or regist
  - kwparam ```frontendCache```: The cache that stores the (partial) results of the frontend, to speedup the pre-processing
  - kwparam ```frontendCache```: The cache that stores the result of the transpilation. Useful for parameter optimisation, as the same expression gets executed multiple times
 "
-function evaluate(expressions::Vector{Expr}, variables::Matrix{Float32}, parameters::Vector{Vector{Float32}})::Matrix{Float32}
-	varRows = size(variables, 1)
-	variableCols = size(variables, 2)
-	# kernels = Vector{CuFunction}(undef, length(expressions))
+function evaluate(expressions::Vector{ExpressionProcessing.PostfixType}, cudaVars::CuArray{Float32}, variableColumns::Integer, variableRows::Integer, parameters::Vector{Vector{Float32}})::Matrix{Float32}
 
 	# TODO: test this again with multiple threads. The first time I tried, I was using only one thread
 	# Test this parallel version again when doing performance tests. With the simple "functionality" tests this took 0.03 seconds while sequential took "0.00009" seconds
@@ -35,7 +32,7 @@ function evaluate(expressions::Vector{Expr}, variables::Matrix{Float32}, paramet
 
 	# 	formattedExpr = ExpressionProcessing.expr_to_postfix(expressions[i])
 
-	# 	kernel = transpile(formattedExpr, varRows, Utils.get_max_inner_length(parameters), variableCols, i-1) # i-1 because julia is 1-based but PTX needs 0-based indexing
+	# 	kernel = transpile(formattedExpr, varRows, Utils.get_max_inner_length(parameters), variableColumns, i-1) # i-1 because julia is 1-based but PTX needs 0-based indexing
 
 	# 	linker = CuLink()
 	# 	add_data!(linker, "ExpressionProcessing", kernel)
@@ -48,14 +45,13 @@ function evaluate(expressions::Vector{Expr}, variables::Matrix{Float32}, paramet
 	# 	@lock cacheLock transpilerCache[expressions[i]] = kernels[i]
 	# end
 
-	cudaVars = CuArray(variables) # maybe put in shared memory (see PerformanceTests.jl for more info)
 	cudaParams = Utils.create_cuda_array(parameters, NaN32) # maybe make constant (see PerformanceTests.jl for more info)
 
 	# each expression has nr. of variable sets (nr. of columns of the variables) results and there are n expressions
-	cudaResults = CuArray{Float32}(undef, variableCols, length(expressions))
+	cudaResults = CuArray{Float32}(undef, variableColumns, length(expressions))
 
-	threads = min(variableCols, 256)
-	blocks = cld(variableCols, threads)
+	threads = min(variableColumns, 256)
+	blocks = cld(variableColumns, threads)
 	
 	kernelName = "evaluate_gpu"
 	# TODO: Implement batching as a middleground between "transpile everything and then run" and "tranpile one run one" even though cudacall is async
@@ -65,8 +61,8 @@ function evaluate(expressions::Vector{Expr}, variables::Matrix{Float32}, paramet
 		# 	continue
 		# end
 		
-		formattedExpr = ExpressionProcessing.expr_to_postfix(expressions[i])
-		kernel = transpile(formattedExpr, varRows, Utils.get_max_inner_length(parameters), variableCols, i-1, kernelName) # i-1 because julia is 1-based but PTX needs 0-based indexing
+		# formattedExpr = ExpressionProcessing.expr_to_postfix(expressions[i])
+		kernel = transpile(expressions[i], variableRows, Utils.get_max_inner_length(parameters), variableColumns, i-1, kernelName) # i-1 because julia is 1-based but PTX needs 0-based indexing
 
 		linker = CuLink()
 		add_data!(linker, kernelName, kernel)