adding GC

Author: fschlimb

setup.py

@@ -29,7 +29,7 @@ def build_cmake(self, ext):
         extdir.parent.mkdir(parents=True, exist_ok=True)
 
         # example of cmake args
-        config = 'Debug' # if self.debug else 'Release'  # 'RelWithDebInfo' #'Release'
+        config = 'Debug' if self.debug else 'Release'  # 'RelWithDebInfo' #'Release'
         cmake_args = [
             '-DCMAKE_LIBRARY_OUTPUT_DIRECTORY=' + str(extdir.parent.absolute()),
             '-DCMAKE_BUILD_TYPE=' + config

src/Creator.cpp

@@ -89,9 +89,9 @@ struct DeferredFromShape : public Deferred
     }
 };
 
-tensor_i::future_type Creator::create_from_shape(CreatorId op, const shape_type & shape, DTypeId dtype)
+ddptensor * Creator::create_from_shape(CreatorId op, const shape_type & shape, DTypeId dtype)
 {
-    return defer<DeferredFromShape>(op, shape, dtype);
+    return new ddptensor(defer<DeferredFromShape>(op, shape, dtype));
 }
 
 struct DeferredFull : public Deferred
@@ -125,10 +125,10 @@ struct DeferredFull : public Deferred
     }
 };
 
-tensor_i::future_type Creator::full(const shape_type & shape, const py::object & val, DTypeId dtype)
+ddptensor * Creator::full(const shape_type & shape, const py::object & val, DTypeId dtype)
 {
     auto v = mk_scalar(val, dtype);
-    return defer<DeferredFull>(shape, v, dtype);
+    return new ddptensor(defer<DeferredFull>(shape, v, dtype));
 }
 
 struct DeferredArange : public Deferred
@@ -161,15 +161,15 @@ struct DeferredArange : public Deferred
     }
 };
 
-tensor_i::future_type Creator::arange(uint64_t start, uint64_t end, uint64_t step, DTypeId dtype)
+ddptensor * Creator::arange(uint64_t start, uint64_t end, uint64_t step, DTypeId dtype)
 {
-    return defer<DeferredArange>(start, end, step, dtype);
+    return new ddptensor(defer<DeferredArange>(start, end, step, dtype));
 }
 
-tensor_i::future_type Creator::mk_future(const py::object & b)
+ddptensor * Creator::mk_future(const py::object & b)
 {
-    if(py::isinstance<tensor_i::future_type>(b)) {
-        return b.cast<tensor_i::future_type>();
+    if(py::isinstance<ddptensor>(b)) {
+        return b.cast<ddptensor*>();
     } else if(py::isinstance<py::float_>(b)) {
         return Creator::full({1}, b, FLOAT64);
     } else if(py::isinstance<py::int_>(b)) {

src/Deferred.cpp

@@ -11,13 +11,15 @@ Deferred::future_type Deferred::get_future()
     return {std::move(tensor_i::promise_type::get_future()), _guid};
 }
 
+#if 0
 void Deferred::set_value(tensor_i::ptr_type && v)
 {
     if(_guid != Registry::NOGUID) {
         Registry::put(_guid, v);
     }
     tensor_i::promise_type::set_value(std::forward<tensor_i::ptr_type>(v));
 }
+#endif
 
 Deferred::future_type Deferred::defer(Deferred::ptr_type && d, bool is_global)
 {
@@ -26,6 +28,7 @@ Deferred::future_type Deferred::defer(Deferred::ptr_type && d, bool is_global)
         if(d) d->_guid = Registry::get_guid();
     }
     auto f = d ? d->get_future() : Deferred::future_type();
+    Registry::put(f);
     _deferred.push(std::move(d));
     return f;
 }

src/EWBinOp.cpp

@@ -149,8 +149,8 @@ struct DeferredEWBinOp : public Deferred
 
     void run()
     {
-        const auto a = std::move(Registry::get(_a));
-        const auto b = std::move(Registry::get(_b));
+        const auto a = std::move(Registry::get(_a).get());
+        const auto b = std::move(Registry::get(_b).get());
         set_value(std::move(TypeDispatch<x::EWBinOp>(a, b, _op)));
     }
 
@@ -168,13 +168,13 @@ struct DeferredEWBinOp : public Deferred
     }
 };
 
-tensor_i::future_type EWBinOp::op(EWBinOpId op, const tensor_i::future_type & a, const py::object & b)
+ddptensor * EWBinOp::op(EWBinOpId op, const ddptensor & a, const py::object & b)
 {
     auto bb = Creator::mk_future(b);
     if(op == __MATMUL__) {
-        return LinAlgOp::vecdot(a, bb, 0);
+        return LinAlgOp::vecdot(a, *bb, 0);
     }
-    return defer<DeferredEWBinOp>(op, a, bb);
+    return new ddptensor(defer<DeferredEWBinOp>(op, a.get(), bb->get()));
 }
 
 FACTORY_INIT(DeferredEWBinOp, F_EWBINOP);

src/EWUnyOp.cpp

@@ -121,7 +121,7 @@ struct DeferredEWUnyOp : public Deferred
 
     void run()
     {
-        const auto a = std::move(Registry::get(_a));
+        const auto a = std::move(Registry::get(_a).get());
         set_value(std::move(TypeDispatch<x::EWUnyOp>(a, _op)));
     }
 
@@ -138,9 +138,9 @@ struct DeferredEWUnyOp : public Deferred
     }
 };
 
-tensor_i::future_type EWUnyOp::op(EWUnyOpId op, const tensor_i::future_type & a)
+ddptensor * EWUnyOp::op(EWUnyOpId op, const ddptensor & a)
 {
-    return defer<DeferredEWUnyOp>(op, a);
+    return new ddptensor(defer<DeferredEWUnyOp>(op, a.get()));
 }
 
 FACTORY_INIT(DeferredEWUnyOp, F_EWUNYOP);

src/IEWBinOp.cpp

@@ -82,14 +82,14 @@ struct DeferredIEWBinOp : public Deferred
     IEWBinOpId _op;
 
     DeferredIEWBinOp() = default;
-    DeferredIEWBinOp(IEWBinOpId op, tensor_i::future_type & a, const tensor_i::future_type & b)
+    DeferredIEWBinOp(IEWBinOpId op, const tensor_i::future_type & a, const tensor_i::future_type & b)
         : _a(a.id()), _b(b.id()), _op(op)
     {}
 
     void run()
     {
-        const auto a = std::move(Registry::get(_a));
-        const auto b = std::move(Registry::get(_b));
+        const auto a = std::move(Registry::get(_a).get());
+        const auto b = std::move(Registry::get(_b).get());
         set_value(std::move(TypeDispatch<x::IEWBinOp>(a, b, _op)));
     }
 
@@ -107,9 +107,10 @@ struct DeferredIEWBinOp : public Deferred
     }
 };
 
-tensor_i::future_type IEWBinOp::op(IEWBinOpId op, tensor_i::future_type & a, const py::object & b)
+ddptensor * IEWBinOp::op(IEWBinOpId op, ddptensor & a, const py::object & b)
 {
-    return defer<DeferredIEWBinOp>(op, a, Creator::mk_future(b));
+    auto bb = Creator::mk_future(b);
+    return new ddptensor(defer<DeferredIEWBinOp>(op, a.get(), bb->get()));
 }
 
 FACTORY_INIT(DeferredIEWBinOp, F_IEWBINOP);

src/LinAlgOp.cpp

@@ -123,8 +123,8 @@ struct DeferredLinAlgOp : public Deferred
 
     void run()
     {
-        const auto a = std::move(Registry::get(_a));
-        const auto b = std::move(Registry::get(_b));
+        const auto a = std::move(Registry::get(_a).get());
+        const auto b = std::move(Registry::get(_b).get());
         set_value(std::move(TypeDispatch<x::LinAlgOp>(a, b, _axis)));
     }
 
@@ -142,9 +142,9 @@ struct DeferredLinAlgOp : public Deferred
     }
 };
 
-tensor_i::future_type LinAlgOp::vecdot(const tensor_i::future_type & a, const tensor_i::future_type & b, int axis)
+ddptensor * LinAlgOp::vecdot(const ddptensor & a, const ddptensor & b, int axis)
 {
-    return defer<DeferredLinAlgOp>(a, b, axis);
+    return new ddptensor(defer<DeferredLinAlgOp>(a.get(), b.get(), axis));
 }
 
 FACTORY_INIT(DeferredLinAlgOp, F_LINALGOP);

src/MPIMediator.cpp

@@ -64,7 +64,7 @@ void MPIMediator::pull(rank_type from, id_type guid, const NDSlice & slice, void
     ser.adapter().flush();
     int cnt = static_cast<int>(ser.adapter().writtenBytesCount());
 
-    auto sz = slice.size() * Registry::get(id)->item_size();
+    auto sz = slice.size() * Registry::get(id).get()->item_size();
     MPI_Irecv(rbuff, sz, MPI_CHAR, from, PUSH_TAG, comm, &request[1]);
     MPI_Isend(buff.data(), cnt, MPI_CHAR, from, REQ_TAG, comm, &request[0]);
     auto error_code = MPI_Waitall(2, &request[0], &status[0]);
@@ -173,7 +173,7 @@ void MPIMediator::listen()
             MPI_Irecv(buff.data(), buff.size(), MPI_CHAR, MPI_ANY_SOURCE, REQ_TAG, comm, &request_in);
 
             // Now find the array in question and send back its bufferized slice
-            tensor_i::ptr_type ptr = Registry::get(id);
+            tensor_i::ptr_type ptr = Registry::get(id).get();
             // Wait for previous answer to complete so that we can re-use the buffer
             MPI_Wait(&request_out, MPI_STATUS_IGNORE);
             ptr->bufferize(slice, rbuff);

src/ManipOp.cpp

@@ -36,7 +36,7 @@ struct DeferredManipOp : public Deferred
 
     void run()
     {
-        const auto a = std::move(Registry::get(_a));
+        const auto a = std::move(Registry::get(_a).get());
         set_value(std::move(TypeDispatch<x::ManipOp>(a, _shape)));
     }
 
@@ -53,9 +53,9 @@ struct DeferredManipOp : public Deferred
     }
 };
 
-tensor_i::future_type ManipOp::reshape(const tensor_i::future_type & a, const shape_type & shape)
+ddptensor * ManipOp::reshape(const ddptensor & a, const shape_type & shape)
 {
-    return defer<DeferredManipOp>(a, shape);
+    return new ddptensor(defer<DeferredManipOp>(a.get(), shape));
 }
 
 FACTORY_INIT(DeferredManipOp, F_MANIPOP);

src/Random.cpp

@@ -62,9 +62,9 @@ struct DeferredRandomOp : public Deferred
 };
 
 
-Random::future_type Random::rand(DTypeId dtype, const shape_type & shape, const py::object & lower, const py::object & upper)
+ddptensor * Random::rand(DTypeId dtype, const shape_type & shape, const py::object & lower, const py::object & upper)
 {
-    return defer<DeferredRandomOp>(shape, x::to_native<double>(lower), x::to_native<double>(upper), dtype);
+    return new ddptensor(defer<DeferredRandomOp>(shape, x::to_native<double>(lower), x::to_native<double>(upper), dtype));
 }
 
 void Random::seed(uint64_t s)