Change tensor_result_t to bridge_tensor_t.

Author: Iainmon

bridge/Bridge

@@ -7,11 +7,11 @@
 extern "C" {
 #endif
 
-typedef struct tensor_result_t {
+typedef struct bridge_tensor_t {
     float* data;
     int* sizes;
     int dim;
-} tensor_result_t;
+} bridge_tensor_t;
 
 int baz(void);
 
@@ -22,8 +22,8 @@ void wrHelloTorch(void);
 float sumArray(float* arr, int* sizes, int dim);
 
 void increment(float* arr, int* sizes, int dim, float* output);
-tensor_result_t increment2(float* arr, int* sizes, int dim);
-tensor_result_t increment3(tensor_result_t arr);
+bridge_tensor_t increment2(float* arr, int* sizes, int dim);
+bridge_tensor_t increment3(bridge_tensor_t arr);
 
 // void convolve(
 //     float* input,

bridge/bridge.o

@@ -7,14 +7,14 @@ extern proc wrHelloTorch(): void;
 extern proc sumArray(arr: [] real(32), sizes: [] int(32), dim: int(32)): real(32);
 extern proc increment(arr: [] real(32), sizes: [] int(32), dim: int(32), ref output: [] real(32)): void;
 
-extern record tensor_result_t {
+extern record bridge_tensor_t {
     var data: c_ptr(real(32));
     var sizes: c_ptr(int(32));
     var dim: int(32);
 }
 
-extern proc increment2(arr: [] real(32), sizes: [] int(32), dim: int(32)): tensor_result_t;
-extern proc increment3(in arr: tensor_result_t): tensor_result_t;
+extern proc increment2(arr: [] real(32), sizes: [] int(32), dim: int(32)): bridge_tensor_t;
+extern proc increment3(in arr: bridge_tensor_t): bridge_tensor_t;
 
 
 // baz();
@@ -39,40 +39,42 @@ for (idx,i) in zip(dom,0..<dom.size) do
 // writeln("Sum of array: ", sumArray(a,sizes,a.rank));
 
 
-record arrayShape_c {
-    param rank: int;
-    var sizes: [0..<rank] int(32);
-}
+// record arrayShape_c {
+//     param rank: int;
+//     var sizes: [0..<rank] int(32);
+// }
 
-proc getSizeArray(const ref arr: [] ?eltType): [] int(32) {
-    var sizes: [0..<arr.rank] int(32);
-    for i in 0..<arr.rank do
-        sizes[i] = arr.dim(i).size : int(32);
-    return sizes;
-}
 
-proc getArrayShapeC(const ref arr: [] ?eltType): arrayShape_c(arr.rank) {
-    var shape: arrayShape_c(arr.rank);
-    for i in 0..<arr.rank do
-        shape.sizes[i] = arr.dim(i).size : int(32);
-    return shape;
-}
+
+// proc getArrayShapeC(const ref arr: [] ?eltType): arrayShape_c(arr.rank) {
+//     var shape: arrayShape_c(arr.rank);
+//     for i in 0..<arr.rank do
+//         shape.sizes[i] = arr.dim(i).size : int(32);
+//     return shape;
+// }
 
 // writeln("Sum of array: ", sumArray(a,getSizeArray(a),a.rank));
 
 // var shape = getArrayShapeC(a);
 // writeln("Shape of array: ", shape.sizes);
 // writeln("Sum of array: ", sumArray(a,shape.sizes,shape.rank));
 
-var shape = getArrayShapeC(a);
-writeln("A: ", a);
+// var shape = getArrayShapeC(a);
+// writeln("A: ", a);
 
-var b: [a.domain] real(32);
-increment(a,shape.sizes,shape.rank,b);
-writeln("B: ", b);
+// var b: [a.domain] real(32);
+// increment(a,shape.sizes,shape.rank,b);
+// writeln("B: ", b);
 
 
-proc getResultTensorShape(param dim: int, result: tensor_result_t): dim*int {
+proc getSizeArray(const ref arr: [] ?eltType): [] int(32) {
+    var sizes: [0..<arr.rank] int(32);
+    for i in 0..<arr.rank do
+        sizes[i] = arr.dim(i).size : int(32);
+    return sizes;
+}
+
+proc bridgeTensorShape(param dim: int, result: bridge_tensor_t): dim*int {
     var shape: dim*int;
     for i in 0..<dim do
         shape[i] = result.sizes[i] : int;
@@ -88,8 +90,8 @@ proc domainFromShape(shape: int ...?rank): domain(rank,int) {
 }
 
 
-proc tensorResultToArray(param rank: int, package: tensor_result_t): [] real(32) {
-    var shape = getResultTensorShape(rank, package);
+proc bridgeTensorToArray(param rank: int, package: bridge_tensor_t): [] real(32) {
+    var shape = bridgeTensorShape(rank, package);
     var dom = domainFromShape((...shape));
     var result: [dom] real(32);
     forall i in 0..<dom.size {
@@ -110,21 +112,21 @@ proc tensorResultToArray(param rank: int, package: tensor_result_t): [] real(32)
 //     C[idx] = c.data[i];
 // }
 
-var c = tensorResultToArray(shape.rank, increment2(a,shape.sizes,shape.rank));
+// var c = bridgeTensorToArray(shape.rank, increment2(a,shape.sizes,shape.rank));
 
 
-writeln("C: ", c);
+// writeln("C: ", c);
 
 use Allocators;
 
 
 
-proc createTensorResult(ref data: [] real(32)): tensor_result_t {
+proc createBridgeTensor(ref data: [] real(32)): bridge_tensor_t {
     // var alloc = new mallocWrapper();
     // alloc.allocate(1024);
 
 
-    var result: tensor_result_t;
+    var result: bridge_tensor_t;
     result.data = c_ptrTo(data);
     result.sizes = allocate(int(32),data.rank);
     const sizeArr = getSizeArray(data);
@@ -135,10 +137,10 @@ proc createTensorResult(ref data: [] real(32)): tensor_result_t {
     result.dim = data.rank;
     return result;
 
-    // var res = newWithAllocator(alloc, tensor_result_t, result);
+    // var res = newWithAllocator(alloc, bridge_tensor_t, result);
     // return res;
 }
 
-writeln(createTensorResult(a));
+writeln(createBridgeTensor(a));
 
-writeln(tensorResultToArray(2,increment3(createTensorResult(a))));
+writeln(bridgeTensorToArray(2,increment3(createBridgeTensor(a))));

bridge/include/bridge.h

@@ -11,16 +11,16 @@
 using float32_t = float;
 
 
-int tensor_result_elements(tensor_result_t &result) {
+int bridge_tensor_elements(bridge_tensor_t &bt) {
     int size = 1;
-    for (int i = 0; i < result.dim; ++i) {
-        size *= result.sizes[i];
+    for (int i = 0; i < bt.dim; ++i) {
+        size *= bt.sizes[i];
     }
     return size;
 }
 
-size_t tensor_result_size(tensor_result_t &result) {
-    return sizeof(float32_t) * tensor_result_elements(result);
+size_t bridge_tensor_size(bridge_tensor_t &bt) {
+    return sizeof(float32_t) * bridge_tensor_elements(bt);
 }
 
 void store_tensor(torch::Tensor &input, float32_t* dest) {
@@ -29,30 +29,36 @@ void store_tensor(torch::Tensor &input, float32_t* dest) {
     std::memmove(dest,data,bytes_size);
 }
 
-tensor_result_t tensor_result_convert(torch::Tensor &tensor) {
-    tensor_result_t result;
+bridge_tensor_t tensor_result_convert(torch::Tensor &tensor) {
+    bridge_tensor_t result;
     result.dim = tensor.dim();
     result.sizes = new int[result.dim];
     for (int i = 0; i < result.dim; ++i) {
         result.sizes[i] = tensor.size(i);
     }
-    result.data = new float32_t[tensor_result_elements(result)];
+    result.data = new float32_t[bridge_tensor_elements(result)];
     store_tensor(tensor, result.data);
     return result;
 }
 
-void secret() {
-    std::cout << "Secret function called!" << std::endl;
-    auto x = torch::randn({5, 3});
-    // torch::Tensor tensor = torch::eye(3);
-    std::cout << "Tensor: " << x << std::endl;
+torch::Tensor bridge_to_torch(bridge_tensor_t &bt) {
+    std::vector<int64_t> sizes_vec(bt.sizes, bt.sizes + bt.dim);
+    auto shape = at::IntArrayRef(sizes_vec);
+    auto t = torch::from_blob(bt.data, shape, torch::kFloat);
+    return t;
+}
 
-    // std::cout << "Secret function called! Tensor: " << tensor << std::endl;
+extern "C" bridge_tensor_t increment3(bridge_tensor_t arr) {
+    auto t = bridge_to_torch(arr);
+    // Increment the tensor
+    auto incremented_tensor = t + 1;
+
+    return tensor_result_convert(incremented_tensor);
 }
 
+
 extern "C" int baz(void) {
     printf("Hello from baz!\n");
-    secret();
     auto x = torch::randn({5, 3});
     return x.size(0);
 }
@@ -88,7 +94,7 @@ extern "C" void increment(float* arr, int* sizes, int dim, float* output) {
     incremented_tensor.copy_(t + 1);
 }
 
-extern "C" tensor_result_t increment2(float* arr, int* sizes, int dim) {
+extern "C" bridge_tensor_t increment2(float* arr, int* sizes, int dim) {
     // Convert sizes to std::vector<int64_t>
     std::vector<int64_t> sizes_vec(sizes, sizes + dim);
     auto shape = at::IntArrayRef(sizes_vec);
@@ -105,18 +111,6 @@ extern "C" tensor_result_t increment2(float* arr, int* sizes, int dim) {
     return tensor_result_convert(incremented_tensor);
 }
 
-extern "C" tensor_result_t increment3(tensor_result_t arr) {
-    // Convert sizes to std::vector<int64_t>
-    std::vector<int64_t> sizes_vec(arr.sizes, arr.sizes + arr.dim);
-    auto shape = at::IntArrayRef(sizes_vec);
-    auto t = torch::from_blob(arr.data, shape, torch::kFloat);
-
-    // Increment the tensor
-    auto incremented_tensor = t + 1;
-
-    return tensor_result_convert(incremented_tensor);
-}
-
 
 extern "C" float sumArray(float* arr, int* sizes, int dim) {
     // Convert sizes to std::vector<int64_t>