Working with tensor handles in test file. Going to try using owned.

Author: Iainmon

Diff for: CMakeLists.txt

@@ -35,7 +35,7 @@ download_libtorch(
 )
 
 
-add_library(bridge OBJECT ${BRIDGE_DIR}/include/bridge.h ${BRIDGE_DIR}/lib/bridge.cpp)
+add_library(bridge STATIC ${BRIDGE_DIR}/include/bridge.h ${BRIDGE_DIR}/lib/bridge.cpp)
 
 target_include_directories(
     bridge

Diff for: lib/Bridge.chpl

@@ -0,0 +1,84 @@
+module Bridge {
+
+    import Utilities as util;
+    use Utilities.Standard;
+    use Allocators;
+
+
+    extern record bridge_tensor_t {
+        var data: c_ptr(real(32));
+        var sizes: c_ptr(int(32));
+        var dim: int(32);
+    }
+
+    proc tensorHandle(type eltType) type {
+        if eltType == real(32) then
+            return bridge_tensor_t;
+        else {
+            compilerWarning("BridgeTensorHandle: Unsupported type");
+            return bridge_tensor_t;
+        }
+    }
+
+
+    extern proc convolve2d(
+        in input: bridge_tensor_t, 
+        in kernel: bridge_tensor_t, 
+        in bias: bridge_tensor_t, 
+        in stride: int(32), 
+        in padding: int(32)): bridge_tensor_t;
+
+    extern proc unsafe(const ref arr: [] real(32)): c_ptr(real(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 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;
+        return shape;
+    }
+
+    proc bridgeTensorToArray(param rank: int, package: bridge_tensor_t): [] real(32) {
+        const shape = bridgeTensorShape(rank, package);
+        const dom = util.domainFromShape((...shape));
+        var result: [dom] real(32);
+        forall (i,idx) in dom.everyZip() do
+            result[idx] = package.data[i];
+        deallocate(package.data);
+        deallocate(package.sizes);
+        return result;
+    }
+
+
+    proc bridgeTensorToExistingArray(ref existing: [] real(32), package: bridge_tensor_t) {
+        const shape = bridgeTensorShape(existing.rank, package);
+        if existing.shape != shape then
+            util.err("BridgeTensorToExistingArray: Shape mismatch");
+        const dom = existing.domain;
+        forall (i,idx) in dom.everyZip() do
+            existing[idx] = package.data[i];
+        deallocate(package.data);
+        deallocate(package.sizes);
+    }
+
+    proc createBridgeTensor(const ref data: [] real(32)): bridge_tensor_t {
+        var result: bridge_tensor_t;
+        result.data = c_ptrToConst(data) : c_ptr(real(32));
+        result.sizes = allocate(int(32),data.rank);
+        const sizeArr = getSizeArray(data);
+        for i in 0..<data.rank do
+            result.sizes[i] = sizeArr[i];
+
+        result.dim = data.rank;
+        return result;
+    }
+
+
+}

Diff for: lib/NDArray.chpl

@@ -14,6 +14,8 @@ import Utilities as util;
 use Utilities.Standard;
 use Utilities.Types;
 
+import Bridge;
+
 type domainType = _domain(?);
 
 /* The most fundamental tensor type.
@@ -1245,6 +1247,22 @@ proc ndarray.degenerateFlatten(): [] eltType {
     return flat;
 }
 
+proc ndarray.toBridgeTensor(): Bridge.tensorHandle(eltType) do
+    return Bridge.createBridgeTensor(this.data);
+
+proc type ndarray.fromBridgeTensor(param rank: int, handle: Bridge.tensorHandle(eltType)): ndarray(rank,real(32)) {
+    const arr = Bridge.bridgeTensorToArray(rank,handle);
+    return new ndarray(arr);
+}
+
+
+proc ref ndarray.loadFromBridgeTensor(handle: Bridge.tensorHandle(eltType)): void {
+    const shape = Bridge.bridgeTensorShape(rank,handle);
+    if shape != this.shape then
+        this.reshapeDomain(util.domainFromShape((...shape)));
+    Bridge.bridgeTensorToExistingArray(this.data,handle);
+}
+
 proc ndarray.shapeArray(): [] int do
     return util.tupleToArray((...this.shape));
 

Diff for: test/tiny/layer_test.chpl

@@ -2,6 +2,8 @@ use Tensor;
 use Layer;
 use Network except ReLU, Linear, Flatten;
 
+use Bridge;
+use Utilities as util;
 
 var x = Tensor.arange(2,3);
 writeln(x);
@@ -33,4 +35,38 @@ var net2 = new Sequential(
 
 y = net2(x);
 writeln(y);
-writeln(net2.signature);
+writeln(net2.signature);
+
+
+
+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 input: [util.domainFromShape(2,64,28,28)] real(32) = 1.0;
+var kernel: [util.domainFromShape(128,64,3,3)] real(32) = 2.0;
+var bias: [util.domainFromShape(128)] real(32) = 3.0;
+var stride: int(32) = 1;
+var padding: int(32) = 1;
+writeln("Begin.");
+var resultBT = convolve2d(createBridgeTensor(input), createBridgeTensor(kernel), createBridgeTensor(bias), stride, padding);
+var result = bridgeTensorToArray(4, resultBT);
+// writeln("Input: ", input);
+// writeln("Kernel: ", kernel);
+// writeln("Bias: ", bias);
+// writeln("Result: ", result);
+writeln("Result: ", result.size);
+
+
+var arr = ndarray.arange(2,3);
+writeln(arr);
+writeln(arr.toBridgeTensor());
+
+var bt = arr.toBridgeTensor();
+arr.loadFromBridgeTensor(bt);
+writeln(arr);
+writeln(arr.shape);
+writeln(ndarray.fromBridgeTensor(2,bt));