Communication with libtorch now only uses tensor_result_t.

Author: Iainmon

bridge/Bridge

@@ -23,6 +23,7 @@ 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);
 
 // void convolve(
 //     float* input,
@@ -33,8 +34,8 @@ tensor_result_t increment2(float* arr, int* sizes, int dim);
 //     int kernel_dim,
 //     float* output,
 //     int* output_sizes,
-//     int output_dim,
-// )
+//     int output_dim
+// );
 
 #ifdef __cplusplus
 }

bridge/bridge.o

@@ -14,6 +14,7 @@ extern record tensor_result_t {
 }
 
 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;
 
 
 // baz();
@@ -86,18 +87,58 @@ proc domainFromShape(shape: int ...?rank): domain(rank,int) {
     return {(...ranges)};
 }
 
-var c = increment2(a,shape.sizes,shape.rank);
 
-var cShape = getResultTensorShape(shape.rank, c);
+proc tensorResultToArray(param rank: int, package: tensor_result_t): [] real(32) {
+    var shape = getResultTensorShape(rank, package);
+    var dom = domainFromShape((...shape));
+    var result: [dom] real(32);
+    forall i in 0..<dom.size {
+        var idx = dom.orderToIndex(i);
+        result[idx] = package.data[i];
+    }
+    return result;
+}
+// var c = increment2(a,shape.sizes,shape.rank);
 
-var cDom = domainFromShape((...cShape));
+// var cShape = getResultTensorShape(shape.rank, c);
 
-var C: [cDom] real(32);
-forall i in 0..<cDom.size {
-    var idx = cDom.orderToIndex(i);
-    C[idx] = c.data[i];
-}
+// var cDom = domainFromShape((...cShape));
+
+// var C: [cDom] real(32);
+// forall i in 0..<cDom.size {
+//     var idx = cDom.orderToIndex(i);
+//     C[idx] = c.data[i];
+// }
+
+var c = tensorResultToArray(shape.rank, increment2(a,shape.sizes,shape.rank));
+
+
+writeln("C: ", c);
+
+use Allocators;
 
 
-writeln("C: ", C);
 
+proc createTensorResult(ref data: [] real(32)): tensor_result_t {
+    // var alloc = new mallocWrapper();
+    // alloc.allocate(1024);
+
+
+    var result: tensor_result_t;
+    result.data = c_ptrTo(data);
+    result.sizes = allocate(int(32),data.rank);
+    const sizeArr = getSizeArray(data);
+    for i in 0..<data.rank do
+        result.sizes[i] = sizeArr[i];
+
+    // result.sizes = c_ptrTo(getSizeArray(data));
+    result.dim = data.rank;
+    return result;
+
+    // var res = newWithAllocator(alloc, tensor_result_t, result);
+    // return res;
+}
+
+writeln(createTensorResult(a));
+
+writeln(tensorResultToArray(2,increment3(createTensorResult(a))));

bridge/include/bridge.h

@@ -105,6 +105,19 @@ 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>