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

package/src/ExpressionExecutorCuda.jl

@@ -22,36 +22,45 @@ export evaluate_gpu
 #
 
 # Evaluate Expressions on the GPU
-function interpret_gpu(exprs::Vector{Expr}, X::Matrix{Float32}, p::Vector{Vector{Float32}}; repetitions=1)::Matrix{Float32}
-	@assert axes(exprs) == axes(p)
-	ncols = size(X, 2)
+function interpret_gpu(expressions::Vector{Expr}, X::Matrix{Float32}, p::Vector{Vector{Float32}}; repetitions=1)::Matrix{Float32}
+	@assert axes(expressions) == axes(p)
+	variableCols = size(X, 2)
+	variableRows = size(X, 1)
 
-	results = Matrix{Float32}(undef, ncols, length(exprs))
-	# TODO: create CuArray for variables here already, as they never change 
-	#		could/should be done even before calling this, but I guess it would be diminishing returns 
-	# 		TODO: test how this would impact performance, if it gets faster, adapt implementation section
-	# TODO: create CuArray for expressions here already. They also do not change over the course of parameter optimisation and therefore a lot of unnecessary calls to expr_to_postfix can be save (even though a cache is used, this should still be faster)
+	variables = CuArray(X)
 
+	exprs = Vector{ExpressionProcessing.PostfixType}(undef, length(expressions))
+	@inbounds Threads.@threads for i in eachindex(expressions)
+		exprs[i] = ExpressionProcessing.expr_to_postfix(expressions[i])
+	end
+	cudaExprs = Utils.create_cuda_array(exprs, ExpressionProcessing.ExpressionElement(EMPTY, 0)) # column corresponds to data for one expression;
+	exprsLength = length(exprs)
+	exprsInnerLength = Utils.get_max_inner_length(exprs)
+	
+	results = Matrix{Float32}(undef, variableCols, length(exprs))
 	for i in 1:repetitions # Simulate parameter tuning -> local search (X remains the same, p gets changed in small steps and must be performed sequentially, which it is with this impl)
-		results = Interpreter.interpret(exprs, X, p)
+		results = Interpreter.interpret(cudaExprs, exprsLength, exprsInnerLength, variables, variableCols, variableRows, p)
 	end
 
 	return results
 end
 
 # Convert Expressions to PTX Code and execute that instead
-function evaluate_gpu(exprs::Vector{Expr}, X::Matrix{Float32}, p::Vector{Vector{Float32}}; repetitions=1)::Matrix{Float32}
-	@assert axes(exprs) == axes(p)
-	ncols = size(X, 2)
+function evaluate_gpu(expressions::Vector{Expr}, X::Matrix{Float32}, p::Vector{Vector{Float32}}; repetitions=1)::Matrix{Float32}
+	@assert axes(expressions) == axes(p)
+	variableCols = size(X, 2)
+	variableRows = size(X, 1)
+	
+	variables = CuArray(X)
 
-	results = Matrix{Float32}(undef, ncols, length(exprs))
-	# TODO: create CuArray for variables here already, as they never change 
-	#		could/should be done even before calling this, but I guess it would be diminishing returns 
-	# 		TODO: test how this would impact performance, if it gets faster, adapt implementation section
-	# TODO: create CuArray for expressions here already. They also do not change over the course of parameter optimisation and therefore a lot of unnecessary calls to expr_to_postfix can be save (even though a cache is used, this should still be faster)
+	exprs = Vector{ExpressionProcessing.PostfixType}(undef, length(expressions))
+	@inbounds Threads.@threads for i in eachindex(expressions)
+		exprs[i] = ExpressionProcessing.expr_to_postfix(expressions[i])
+	end
 
+	results = Matrix{Float32}(undef, variableCols, length(exprs))
 	for i in 1:repetitions # Simulate parameter tuning -> local search (X remains the same, p gets changed in small steps and must be performed sequentially, which it is with this impl)
-		results = Transpiler.evaluate(exprs, X, p)
+		results = Transpiler.evaluate(exprs, variables, variableCols, variableRows, p)
 	end
 
 	return results