Bridge module is working.

Author: Iainmon

bridge/Bridge

@@ -4,7 +4,7 @@ bridge.o: lib/bridge.cpp include/bridge.h
 	g++ -c lib/bridge.cpp -I include -o bridge.o -I /Users/iainmoncrief/Documents/Github/ChAI/bridge/libtorch/include/torch/csrc/api/include -I /Users/iainmoncrief/Documents/Github/ChAI/bridge/libtorch/include --std=c++17
 
 Bridge: bridge.o lib/Bridge.chpl
-	chpl lib/Bridge.chpl include/bridge.h bridge.o -L /Users/iainmoncrief/Documents/Github/ChAI/bridge/libtorch/lib -ltorch -ltorch_cpu -lc10 --ldflags "-Wl,-rpath,/Users/iainmoncrief/Documents/Github/ChAI/bridge/libtorch/lib" --print-commands
+	chpl lib/Bridge.chpl include/bridge.h bridge.o -L /Users/iainmoncrief/Documents/Github/ChAI/bridge/libtorch/lib -ltorch -ltorch_cpu -lc10 --ldflags "-Wl,-rpath,/Users/iainmoncrief/Documents/Github/ChAI/bridge/libtorch/lib"
 
 clean:
 	rm -f bridge.o

bridge/Makefile

@@ -7,6 +7,12 @@
 extern "C" {
 #endif
 
+typedef struct tensor_result_t {
+    float* data;
+    int* sizes;
+    int dim;
+} tensor_result_t;
+
 int baz(void);
 
 void wrHello(void);
@@ -15,6 +21,21 @@ 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);
+
+// void convolve(
+//     float* input,
+//     int* input_sizes,
+//     int input_dim,
+//     float* kernel,
+//     int* kernel_sizes,
+//     int kernel_dim,
+//     float* output,
+//     int* output_sizes,
+//     int output_dim,
+// )
+
 #ifdef __cplusplus
 }
 #endif

bridge/bridge.o

@@ -5,28 +5,37 @@ extern proc baz(): int;
 extern proc wrHello(): void;
 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 {
+    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;
 
 
-baz();
+// baz();
 
-wrHello();
+// wrHello();
 
 
-wrHelloTorch();
+// wrHelloTorch();
 
-writeln("baz: ", baz());
+// writeln("baz: ", baz());
 
 
 var dom = {0..<10, 0..<10};
 var a: [dom] real(32);
 for (idx,i) in zip(dom,0..<dom.size) do
     a[idx] = i:real(32);
 
-var sizes: [0..1] int(32);
-sizes[0] = dom.dim(0).size : int(32);
-sizes[1] = dom.dim(1).size : int(32);
+// var sizes: [0..1] int(32);
+// sizes[0] = dom.dim(0).size : int(32);
+// sizes[1] = dom.dim(1).size : int(32);
 
-writeln("Sum of array: ", sumArray(a,sizes,a.rank));
+// writeln("Sum of array: ", sumArray(a,sizes,a.rank));
 
 
 record arrayShape_c {
@@ -48,8 +57,47 @@ proc getArrayShapeC(const ref arr: [] ?eltType): arrayShape_c(arr.rank) {
     return shape;
 }
 
-writeln("Sum of array: ", sumArray(a,getSizeArray(a),a.rank));
+// 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("Shape of array: ", shape.sizes);
-writeln("Sum of array: ", sumArray(a,shape.sizes,shape.rank));
+writeln("A: ", a);
+
+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 {
+    var shape: dim*int;
+    for i in 0..<dim do
+        shape[i] = result.sizes[i] : int;
+    return shape;
+}
+
+proc domainFromShape(shape: int ...?rank): domain(rank,int) {
+    const _shape = shape;
+    var ranges: rank*range;
+    for param i in 0..<rank do
+        ranges(i) = 0..<_shape(i);
+    return {(...ranges)};
+}
+
+var c = increment2(a,shape.sizes,shape.rank);
+
+var cShape = getResultTensorShape(shape.rank, c);
+
+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];
+}
+
+
+writeln("C: ", C);
+

bridge/include/bridge.h

@@ -6,6 +6,41 @@
 #include <iostream>
 #include <vector>
 
+#include <cstdint>
+
+using float32_t = float;
+
+
+int tensor_result_elements(tensor_result_t &result) {
+    int size = 1;
+    for (int i = 0; i < result.dim; ++i) {
+        size *= result.sizes[i];
+    }
+    return size;
+}
+
+size_t tensor_result_size(tensor_result_t &result) {
+    return sizeof(float32_t) * tensor_result_elements(result);
+}
+
+void store_tensor(torch::Tensor &input, float32_t* dest) {
+    float32_t * data = input.data_ptr<float32_t>();
+    size_t bytes_size = sizeof(float32_t) * input.numel();
+    std::memmove(dest,data,bytes_size);
+}
+
+tensor_result_t tensor_result_convert(torch::Tensor &tensor) {
+    tensor_result_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)];
+    store_tensor(tensor, result.data);
+    return result;
+}
+
 void secret() {
     std::cout << "Secret function called!" << std::endl;
     auto x = torch::randn({5, 3});
@@ -34,6 +69,42 @@ extern "C" void wrHelloTorch(void) {
     // std::cout << t << std::endl;
 }
 
+
+
+
+extern "C" void increment(float* arr, int* sizes, int dim, float* output) {
+    // Convert sizes to std::vector<int64_t>
+    std::vector<int64_t> sizes_vec(sizes, sizes + dim);
+    auto shape = at::IntArrayRef(sizes_vec);
+    auto t = torch::from_blob(arr, shape, torch::kFloat);
+
+    // // Increment the tensor
+    // auto incremented_tensor = t + 1;
+
+    // // Store the incremented tensor in the output array
+    // storeTensor(incremented_tensor, output);
+
+    auto incremented_tensor = torch::from_blob(output, shape, torch::kFloat);
+    incremented_tensor.copy_(t + 1);
+}
+
+extern "C" tensor_result_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);
+    auto t = torch::from_blob(arr, shape, torch::kFloat);
+
+    // // Increment the tensor
+    // auto incremented_tensor = t + 1;
+
+    // // Store the incremented tensor in the output array
+    // storeTensor(incremented_tensor, output);
+
+    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>