diff --git a/llvm/projects/hpvm-tensor-rt/tensor_runtime/include/approxhpvm_runtime_utils.h b/llvm/projects/hpvm-tensor-rt/tensor_runtime/include/approxhpvm_runtime_utils.h
index 471b78fb71751a186438f654a38fb86ab709fab2..d9a705d780b17a31afe234808ccf0df4431dbe08 100644
--- a/llvm/projects/hpvm-tensor-rt/tensor_runtime/include/approxhpvm_runtime_utils.h
+++ b/llvm/projects/hpvm-tensor-rt/tensor_runtime/include/approxhpvm_runtime_utils.h
@@ -6,6 +6,7 @@
#include "configuration.h"
+#include "hpvm-rt-controller.h"
// Utilities header for ApproxHPVM runtime API (wrapper runtime API)
@@ -19,9 +20,17 @@ void* handleTensorAddApproximationTuples(
int param = approxTuples[0].second;
switch (approx) {
case GPUNodeConfiguration::APPROX::FP32 :
- return tensorAdd(input, bias);
+ {
+ void* t_out;
+ t_out = tensorAdd(input, bias);
+ return t_out;
+ }
case GPUNodeConfiguration::APPROX::FP16 :
- return tensorHalfAdd(input, bias);
+ {
+ void* t_out;
+ t_out = tensorHalfAdd(input, bias);
+ return t_out;
+ }
default :
CUSTOM_ASSERT(false && "Unknown approximation type");
ERROR("Unknown approximation type");
@@ -47,9 +56,17 @@ void* handleTensorMulApproximationTuples(
int param = approxTuples[0].second;
switch (approx) {
case GPUNodeConfiguration::APPROX::FP32 :
- return tensorGemmGPU(lhs, rhs);
+ {
+ void* t_out;
+ t_out = tensorGemmGPU(lhs, rhs);
+ return t_out;
+ }
case GPUNodeConfiguration::APPROX::FP16 :
- return tensorHalfGemmGPU(lhs, rhs);
+ {
+ void* t_out;
+ t_out = tensorHalfGemmGPU(lhs, rhs);
+ return t_out;
+ }
default :
CUSTOM_ASSERT(false && "Unknown approximation type");
ERROR("Unknown approximation type");
@@ -77,15 +94,23 @@ void* handleTensorConvApproximationTuples(
int param = approxTuples[0].second;
switch (approx) {
case GPUNodeConfiguration::APPROX::FP32 :
- return tensorConvolution(input, filter,
- conv_pad_h, conv_pad_w,
- conv_stride_h, conv_stride_w,
- 1, 1);
+ {
+ void* t_out;
+ t_out = tensorConvolution(input, filter,
+ conv_pad_h, conv_pad_w,
+ conv_stride_h, conv_stride_w,
+ 1, 1);
+ return t_out;
+ }
case GPUNodeConfiguration::APPROX::FP16 :
- return tensorHalfConvolution(input, filter,
- conv_pad_h, conv_pad_w,
- conv_stride_h, conv_stride_w,
- 1, 1);
+ {
+ void* t_out;
+ t_out = tensorHalfConvolution(input, filter,
+ conv_pad_h, conv_pad_w,
+ conv_stride_h, conv_stride_w,
+ 1, 1);
+ return t_out;
+ }
case GPUNodeConfiguration::APPROX::PERFORATION :
{
int row = 0, col = 0;
@@ -106,10 +131,12 @@ void* handleTensorConvApproximationTuples(
row = 1; col = 1;
break;
}
- return tensorConvPerf(input, filter,
- conv_pad_h, conv_pad_w,
- conv_stride_h, conv_stride_w,
- 1, 1, row, col);
+ void* t_out;
+ t_out = tensorConvPerf(input, filter,
+ conv_pad_h, conv_pad_w,
+ conv_stride_h, conv_stride_w,
+ 1, 1, row, col);
+ return t_out;
}
default :
CUSTOM_ASSERT(false && "Unknown approximation type");
@@ -139,15 +166,23 @@ void* handleTensorGroupConvApproximationTuples(
int param = approxTuples[0].second;
switch (approx) {
case GPUNodeConfiguration::APPROX::FP32 :
- return tensorConvolution(input, filter,
- vertical_pad, horizontal_pad,
- vertical_stride, horizontal_stride,
- conv_mode, conv_groups);
+ {
+ void* t_out;
+ t_out = tensorConvolution(input, filter,
+ vertical_pad, horizontal_pad,
+ vertical_stride, horizontal_stride,
+ conv_mode, conv_groups);
+ return t_out;
+ }
case GPUNodeConfiguration::APPROX::FP16 :
- return tensorHalfConvolution(input, filter,
- vertical_pad, horizontal_pad,
- vertical_stride, horizontal_stride,
- conv_mode, conv_groups);
+ {
+ void* t_out;
+ t_out = tensorHalfConvolution(input, filter,
+ vertical_pad, horizontal_pad,
+ vertical_stride, horizontal_stride,
+ conv_mode, conv_groups);
+ return t_out;
+ }
default :
CUSTOM_ASSERT(false && "Unknown approximation type");
ERROR("Unknown approximation type");
@@ -174,11 +209,19 @@ void* handleTensorBatchNormApproximationTuples(
int param = approxTuples[0].second;
switch (approx) {
case GPUNodeConfiguration::APPROX::FP32 :
- return tensorBatchNorm(input_ptr, gamma_ptr, beta_ptr,
+ {
+ void* t_out;
+ t_out = tensorBatchNorm(input_ptr, gamma_ptr, beta_ptr,
mean_ptr, variance_ptr, epsilon);
+ return t_out;
+ }
case GPUNodeConfiguration::APPROX::FP16 :
- return tensorHalfBatchNorm(input_ptr, gamma_ptr, beta_ptr,
+ {
+ void* t_out;
+ t_out = tensorHalfBatchNorm(input_ptr, gamma_ptr, beta_ptr,
mean_ptr, variance_ptr, epsilon);
+ return t_out;
+ }
default :
CUSTOM_ASSERT(false && "Unknown approximation type");
ERROR("Unknown approximation type");
@@ -204,9 +247,17 @@ void* handleTensorReluApproximationTuples(
int param = approxTuples[0].second;
switch (approx) {
case GPUNodeConfiguration::APPROX::FP32 :
- return tensorRelu(input);
+ {
+ void* t_out;
+ t_out = tensorRelu(input);
+ return t_out;
+ }
case GPUNodeConfiguration::APPROX::FP16 :
- return tensorHalfRelu(input);
+ {
+ void* t_out;
+ t_out = tensorHalfRelu(input);
+ return t_out;
+ }
default :
CUSTOM_ASSERT(false && "Unknown approximation type");
ERROR("Unknown approximation type");
@@ -232,9 +283,17 @@ void* handleTensorClippedReluApproximationTuples(
int param = approxTuples[0].second;
switch (approx) {
case GPUNodeConfiguration::APPROX::FP32 :
- return tensorRelu2(input, min, max);
+ {
+ void* t_out;
+ t_out = tensorRelu2(input, min, max);
+ return t_out;
+ }
case GPUNodeConfiguration::APPROX::FP16 :
- return tensorHalfRelu2(input, min, max);
+ {
+ void* t_out;
+ t_out = tensorHalfRelu2(input, min, max);
+ return t_out;
+ }
default :
CUSTOM_ASSERT(false && "Unknown approximation type");
ERROR("Unknown approximation type");
@@ -260,9 +319,17 @@ void* handleTensorTanhApproximationTuples(
int param = approxTuples[0].second;
switch (approx) {
case GPUNodeConfiguration::APPROX::FP32 :
- return tensorTanh(input);
+ {
+ void* t_out;
+ t_out = tensorTanh(input);
+ return t_out;
+ }
case GPUNodeConfiguration::APPROX::FP16 :
- return tensorHalfTanh(input);
+ {
+ void* t_out;
+ t_out = tensorHalfTanh(input);
+ return t_out;
+ }
default :
CUSTOM_ASSERT(false && "Unknown approximation type");
ERROR("Unknown approximation type");
@@ -291,17 +358,25 @@ void* handleTensorPoolingApproximationTuples(
int param = approxTuples[0].second;
switch (approx) {
case GPUNodeConfiguration::APPROX::FP32 :
- return tensorPooling(input_ptr,
+ {
+ void* t_out;
+ t_out = tensorPooling(input_ptr,
poolFunction,
window_height, window_width,
vertical_pad, horizontal_pad,
vertical_stride, horizontal_stride);
+ return t_out;
+ }
case GPUNodeConfiguration::APPROX::FP16 :
- return tensorHalfPooling(input_ptr,
+ {
+ void* t_out;
+ t_out = tensorHalfPooling(input_ptr,
poolFunction,
window_height, window_width,
vertical_pad, horizontal_pad,
vertical_stride, horizontal_stride);
+ return t_out;
+ }
default :
CUSTOM_ASSERT(false && "Unknown approximation type");
ERROR("Unknown approximation type");
@@ -323,7 +398,9 @@ void* handleTensorSoftmaxApproximationTuples(
void* input_ptr) {
//TODO: if approximation choices are added for softmax operation,
// implement this like the other handle* functions
- return tensorSoftmax(input_ptr);
+ void* t_out;
+ t_out = tensorSoftmax(input_ptr);
+ return t_out;
}
diff --git a/llvm/projects/hpvm-tensor-rt/tensor_runtime/src/tensor_runtime.cu b/llvm/projects/hpvm-tensor-rt/tensor_runtime/src/tensor_runtime.cu
index 19417da5814a79f1089f68db4532c218726779f4..6b8a365214c47529cf4613442b838a5a7096b3c3 100644
--- a/llvm/projects/hpvm-tensor-rt/tensor_runtime/src/tensor_runtime.cu
+++ b/llvm/projects/hpvm-tensor-rt/tensor_runtime/src/tensor_runtime.cu
@@ -1676,14 +1676,16 @@ void* wrapper_ConvLayer(const char* hpvm_node_id,
int param = approxTuples[0].second;
if (approx == PROMISENodeConfiguration::APPROX::SWING_LEVEL) {
DEBUG("Approximation choice for ConvLayer: swing level %d\n", param);
- return ConvLayer_PROMISE(input, QRanges[0], QRanges[1],
- filter, QRanges[2], QRanges[3],
- bias, QRanges[4], QRanges[5],
- conv_pad_h, conv_pad_w,
- conv_stride_h, conv_stride_w,
- pool_id, pool_size,
- activation_id,
- QRanges[6], QRanges[7], param);
+ void* t_out;
+ t_out = ConvLayer_PROMISE(input, QRanges[0], QRanges[1],
+ filter, QRanges[2], QRanges[3],
+ bias, QRanges[4], QRanges[5],
+ conv_pad_h, conv_pad_w,
+ conv_stride_h, conv_stride_w,
+ pool_id, pool_size,
+ activation_id,
+ QRanges[6], QRanges[7], param);
+ return t_out;
} else {
CUSTOM_ASSERT(false && "Unknown approximation type");
ERROR("Unknown approximation type");
@@ -1883,11 +1885,13 @@ void* wrapper_FCLayer(const char* hpvm_node_id,
int param = approxTuples[0].second;
if (approx == PROMISENodeConfiguration::APPROX::SWING_LEVEL) {
DEBUG("Approximation choice for FCLayer: swing level %d\n", param);
- return FCLayer_PROMISE(input, QRanges[0], QRanges[1],
- weights, QRanges[2], QRanges[3],
- bias, QRanges[4], QRanges[5],
- activation_id,
- QRanges[6], QRanges[7], param);
+ void* t_out;
+ t_out = FCLayer_PROMISE(input, QRanges[0], QRanges[1],
+ weights, QRanges[2], QRanges[3],
+ bias, QRanges[4], QRanges[5],
+ activation_id,
+ QRanges[6], QRanges[7], param);
+ return t_out;
} else {
CUSTOM_ASSERT(false && "Unknown approximation type");
ERROR("Unknown approximation type");