uTensor · dboyliao · Oct 28, 2017 · Oct 28, 2017 · Oct 29, 2017 · Oct 29, 2017
diff --git a/context.hpp b/context.hpp
@@ -1,6 +1,9 @@
 #ifndef UTENSOR_CTX_H
 #define UTENSOR_CTX_H
 
+#include "uTensorBase.hpp"
+#include "stdio.h"
+
 //#include <list>
 
 //TODO: how do we deal with dangling tensors?
@@ -11,45 +14,46 @@
 //      tensors can be all pointers here, but destructors has to set data to nullptr
 //      push(op, input_t_list, output_t_list)  or  push(op, init-list, init-list)
 //      TensorListModifierOp
-class Context : uTensor {
+class Context : public uTensor {
 protected:
-  vector<Operator> op_list;
+  vector<Operator*> op_list;
   bool del_onsight;
   //std::unordered_map<Tensor*> TensorList;  //all tensors alive  //kill all unused if malloc failed?
   //uint32_t m_size; //remaining memory size
   //void registerTensor(Tensor* t);
   //void gc(void); //garbage collector, delete any tracked unreferenced tensor
 
-  void initOpTensors(TList &t_list);
-  void deinitTensors(TList &t_list);
-  void updateInputTensorRef(TList &t_list);
-  void dcrRefCount(TList &t_list);
+  void initTensors(const TList &t_list);
+  void deinitTensors(const TList &t_list);
+  void updateInputTensorRef(const TList &t_list);
+  void dcrRefCount(TList t_list);
 
 public:
-  void push(Operator op, TList &_inputs, TList &_outputs);
+  void push(Operator *op, TList &_inputs, TList &_outputs);
   int run(void);
+
+  Context() {
+    del_onsight = true;
+  }
 };
 
-Context() {
-  del_onsight = true;
-}
 
-void Context::push(Operator op, TList &_inputs, TList &_outputs) {
-  if(op.getInputCount() != _inputs.size()) {
+void Context::push(Operator *op, TList &_inputs, TList &_outputs) {
+  if(op->getInputs().size() != _inputs.size()) {
     ERR_EXIT("valid number of inputs\r\n");
   }
-  if(op.getOutputCount() != _outputs.size()) {
+  if(op->getOutputs().size() != _outputs.size()) {
     ERR_EXIT("valid number of output\r\n");
   }
 
-  op.setInputs(_inputs);
-  op.setOutputs(_outputs);
+  op->setInputs(_inputs);
+  op->setOutputs(_outputs);
   op_list.push_back(op);
   updateInputTensorRef(_inputs);
 
 }
 
-void Context::updateInputTensorRef(TList &t_list) {
+void Context::updateInputTensorRef(const TList &t_list) {
   for(auto t:t_list) {
     t->incrRef();  //if an initial ref value is supplied to the tensor at compile time
                     //then this function does nothing
@@ -58,42 +62,45 @@ void Context::updateInputTensorRef(TList &t_list) {
   }
 }
 
-void Context::initOpTensors(vector<Tensor*> &t_list) {
+void Context::initTensors(const TList &t_list) {
   for(auto t:t_list) {
     t->inFocus();
   }
 }
 
-void Context::deinitTensors(vector<Tensor*> &t_list) {
+void Context::deinitTensors(const TList &t_list) {
   for(auto t:t_list) {
     t->deFocus();
   }
 }
 
-void Context::dcrRefCount(vector<Tensor*> &t_list) {
+void Context::dcrRefCount(TList t_list) {
   for(auto t:t_list) {
     t->dcrRef();
     if(t->getRef() < 1 && del_onsight) {
       delete t;
     }
+  }
 }
 
 int Context::run(void) {
   //unref2nullTensors();
 
   for(auto op:op_list) {
-    initTensors(op.getInputs());
-    initTensors(op.getOutputs());
+    initTensors(op->getInputs());
+    initTensors(op->getOutputs());
 
-    op.init();
-    op.compute();
-    op.deinit();
+    op->inFocus();
+    op->compute();
+    op->deFocus();
 
-    deinitOpTensors(op.getInputs());
-    deinitOpTensors(op.getOutputs());
+    deinitTensors(op->getInputs());
+    deinitTensors(op->getOutputs());
 
-    decreRefCount(op.getInputs());
+    dcrRefCount(op->getInputs());
   }
+
+  return 0;
 }
 
 #endif // UTENSOR_CTX_H
diff --git a/main.cpp b/main.cpp
@@ -1,11 +1,11 @@
-#include <random>
 #include "FATFileSystem.h"
 #include "SDBlockDevice.h"
 #include "mbed.h"
 #include "stdio.h"
 #include "uTensor_util.hpp"
 #include "tensor.hpp"
 #include "tensorIdxImporterTests.hpp"
+#include "context.hpp"
 //#include "deep_mnist_mlp.hpp"
 
 Serial pc(USBTX, USBRX, 115200);
@@ -33,9 +33,13 @@ int main(int argc, char** argv) {
    idxTest.printSummary();
    printf("Matrix: \r\n");
 //   matrixTests.printSummary();
+
+  Context ctx;
   //In [24]: tf.get_default_graph().get_tensor_by_name("import/y_pred:0").eval(feed_dict={x: mnist.test.images[0:1]})
   //Out[24]: array([7])
 
+  printf("\r\ndone...\r\n");
+
   ON_ERR(fs.unmount(), "fs unmount ");
   ON_ERR(bd.deinit(), "SDBlockDevice de-init ");
 }
diff --git a/tensor.hpp b/tensor.hpp
@@ -8,20 +8,32 @@
 #include "stdlib.h"
 #include "uTensor_util.hpp"
 
+enum class DType : char { 
+  uint8,
+  int8,
+  uint16,
+  int32,
+  flt,
+  dbl,
+};
+
 class uTensor {
+ public:
   virtual void inFocus(){};
   virtual void deFocus(){};
-
- public:
   virtual ~uTensor() = 0;
 };
 
+
 uTensor::~uTensor() {}
 class TensorBase {
  public:
   std::vector<uint32_t> shape;
   void* data;
   uint32_t total_size;
+  DType dtype;
+  uint16_t ref_count;
+  bool allow_runtime_ref_inc;  //to support compile-time ref count
 
   ~TensorBase() {
     if (data != nullptr) {
@@ -31,7 +43,7 @@ class TensorBase {
   }
 };
 
-class Tensor : uTensor {
+class Tensor : public uTensor {
   virtual void* read(size_t offset, size_t ele) { return nullptr; }
   virtual void* write(size_t offset, size_t ele) { return nullptr; }
 
@@ -67,13 +79,16 @@ class Tensor : uTensor {
     s->data = (void*)malloc(unit_size() * s->total_size);
     if (s->data == NULL)
       ERR_EXIT("ran out of memory for %lu malloc", unit_size() * s->total_size);
+
+    s->ref_count = 0;
+    s->allow_runtime_ref_inc = false;
   }
 
   std::vector<uint32_t> getShape(void) { return s->shape; }
 
   uint32_t getSize(void) { return s->total_size; }
 
-  virtual uint16_t unit_size(void) {}
+  virtual uint16_t unit_size(void) { return 0; }
 
   uint32_t getSize_in_bytes(void) { return s->total_size * unit_size(); }
 
@@ -90,6 +105,31 @@ class Tensor : uTensor {
     return (const T*)write(offset, ele);
   }
 
+  DType getDType(void) {
+    return s->dtype;
+  }
+
+  uint16_t incrRef() {
+    if(s->allow_runtime_ref_inc) {
+      s->ref_count += 1;
+    }
+
+    return s->ref_count;
+  }
+
+  uint16_t dcrRef() {
+    s->ref_count -= 1;
+    return s->ref_count;
+  }
+
+  uint16_t getRef() {
+    return s->ref_count;
+  }
+
+  bool is_ref_runtime(void) {
+    return s->allow_runtime_ref_inc;
+  }
+
   ~Tensor() {
     s = nullptr;
     DEBUG("Tensor Destructed\r\n");
@@ -101,9 +141,10 @@ class RamTensor : public Tensor {
   // need deep copy
  public:
   RamTensor() : Tensor() {
-    std::vector<uint32_t> v(3, 3);
+    std::vector<uint32_t> v(3, 3);  ///NT: why (3,3)?
     Tensor::init<T>(v);
     cursor = nullptr;
+    //dtype = something...
   }
 
   RamTensor(std::initializer_list<uint32_t> l) : Tensor() {

diff --git a/uTensorBase.hpp b/uTensorBase.hpp
@@ -5,20 +5,14 @@
 
 typedef vector<Tensor*> TList;
 
-class uTensor {
-  virtual void inFocus() {};
-  virtual void deFocus() {};
-  virtual ~uTensor() = 0;
-};
-
-
 //isType() https://stackoverflow.com/questions/9974596/how-to-check-whether-two-pointers-point-to-the-same-object-or-not
 //double dispatch
 
 //new vs stack
-class Operator {
+class Operator : public uTensor{
 protected:
   //setup input/output info in derived constructors
+  //ref count?
   TList inputs;
   vector<DType> dtype_in;
   TList outputs;
@@ -29,24 +23,24 @@ class Operator {
   void setInputs(TList &_inputs) {
     if(_inputs.size() != inputs.size()) ERR_EXIT("Input Tensor list mismatched...");
 
-    for(uint8_t i = 0; i < input.size(); i++) {
-      if(dtype_in[i] != inputs.getType()) {
+    for(uint8_t i = 0; i < inputs.size(); i++) {
+      if(dtype_in[i] != inputs[i]->getDType()) {
         ERR_EXIT("Tensor Type mismatched...");
       }
 
-      input[i] = _inputs[i];
+      inputs[i] = _inputs[i];
     }
   }
 
   void setOutputs(TList &_outputs) {
     if(_outputs.size() != outputs.size()) ERR_EXIT("Input Tensor list mismatched...");
 
-    for(uint8_t i = 0; i < output.size(); i++) {
-      if(dtype_out[i].getType() != output[i].getType()) {
+    for(uint8_t i = 0; i < outputs.size(); i++) {
+      if(dtype_out[i] != outputs[i]->getDType()) {
         ERR_EXIT("Tensor Type mismatched...");
       }
 
-      output[i] = _output[i]
+      outputs[i] = _outputs[i];
     }
   }
 

diff --git a/uTensor_util.hpp b/uTensor_util.hpp
@@ -18,16 +18,16 @@ void return_error(int ret_val) {
   }
 }
 
-void errno_error(void* ret_val) {
-  if (ret_val == NULL) {
-    printf(" [**Failure**] %d \r\n", errno);
-    printf("Exiting...\r\n");
-    fflush(stdout);
-    exit(-1);
-  } else {
-    printf("  [DONE]\r\n");
-  }
-}
+// void errno_error(void* ret_val) {
+//   if (ret_val == NULL) {
+//     printf(" [**Failure**] %d \r\n", errno);
+//     printf("Exiting...\r\n");
+//     fflush(stdout);
+//     exit(-1);
+//   } else {
+//     printf("  [DONE]\r\n");
+//   }
+// }
 
 #define ON_ERR(FUNC, MSG) \
   {                       \
@@ -44,8 +44,9 @@ void errno_error(void* ret_val) {
 
 #else  // MBED_CONF_APP_DEBUG_MSG
 
-void errno_error(void* ret_val) { /*DOES NOTHING*/
-}
+// void errno_error(void* ret_val) { /*DOES NOTHING*/
+// }
+
 #define ON_ERR(FUNC, MSG) FUNC
 #define DEBUG(MSG, ...)