1. Implement RamTensor::resize

dboyliao · dboyliao · commit ac8facf6ea67 · 2020-04-17T16:45:11.000+08:00
2. ReshapeOperator allocate memory for output tensor
diff --git a/TESTS/operators/constants_reshape.hpp b/TESTS/operators/constants_reshape.hpp
@@ -1,7 +1,7 @@
 #ifndef _RESHAPE_TEST_H
 #define _RESHAPE_TEST_H
 
-static const float random_input_arr[15] = { 1.8550491333007812, 4.670377254486084, 1.5111958980560303, 4.3641228675842285, 3.122225284576416, 1.1933523416519165, 3.7784199714660645, 4.052943706512451, 1.0156375169754028, 1.4321529865264893, 3.4896273612976074, 1.3438916206359863, 4.172100067138672, 0.589367151260376, 1.9008618593215942 };
-static const float ref_output_arr[15] = { 1.8550491333007812, 4.670377254486084, 1.5111958980560303, 4.3641228675842285, 3.122225284576416, 1.1933523416519165, 3.7784199714660645, 4.052943706512451, 1.0156375169754028, 1.4321529865264893, 3.4896273612976074, 1.3438916206359863, 4.172100067138672, 0.589367151260376, 1.9008618593215942 };
+static const float random_input_arr[15] = { 3.484638214111328, 2.033799886703491, 3.2437448501586914, 4.783249855041504, 3.497023582458496, 3.511240005493164, 1.558927297592163, 3.7084484100341797, 2.570117712020874, 0.2405869960784912, 1.8713605403900146, 4.19132661819458, 0.6596618890762329, 0.9029078483581543, 0.2223271131515503 };
+static const float ref_output_arr[15] = { 3.484638214111328, 2.033799886703491, 3.2437448501586914, 4.783249855041504, 3.497023582458496, 3.511240005493164, 1.558927297592163, 3.7084484100341797, 2.570117712020874, 0.2405869960784912, 1.8713605403900146, 4.19132661819458, 0.6596618890762329, 0.9029078483581543, 0.2223271131515503 };
 
 #endif // _RESHAPE_TEST_H
diff --git a/TESTS/operators/test_reshape.cpp b/TESTS/operators/test_reshape.cpp
@@ -3,8 +3,8 @@
 
 #include "arenaAllocator.hpp"
 #include "context.hpp"
-#include "Reshape.hpp"
 #include "RamTensor.hpp"
+#include "Reshape.hpp"
 #include "RomTensor.hpp"
 
 #include "gtest/gtest.h"
@@ -19,16 +19,17 @@ TEST(Reshape, reshape_test) {
   Context::get_default_context()->set_metadata_allocator(&meta_allocator);
   Context::get_default_context()->set_ram_data_allocator(&ram_allocator);
   Tensor input_tensor = new RomTensor({ 3,5 }, flt, random_input_arr);
-  Tensor output_tensor = new RamTensor({ 5,3,1 }, flt);
-  ReshapeOperator<float> op;
+  Tensor output_tensor = new RamTensor(flt);
+
+  ReshapeOperator<float> op({ 5,3,1 });
   op
     .set_inputs({ { ReshapeOperator<float>::input, input_tensor } })
     .set_outputs({ { ReshapeOperator<float>::output, output_tensor } })
     .eval();
   for (int i = 0; i < 15; ++i) {
     EXPECT_NEAR((float) output_tensor(i), ref_output_arr[i], 0.0001);
   }
-  TensorShape target_shape(5, 3, 1);
+  TensorShape target_shape(5,3,1);
   TensorShape output_shape = output_tensor->get_shape();
   EXPECT_TRUE(target_shape == output_shape);
 
diff --git a/python/test_scripts/gen_reshape.py b/python/test_scripts/gen_reshape.py
@@ -30,6 +30,7 @@ def main(cpp_fname, const_fname):
     tensor_input = tf.random.uniform((3, 5), maxval=5, dtype=tf.float32)
     np_input = tensor_input.numpy()
     new_shape = [5, 3, 1]
+    op_construct_params.append("{{ {} }}".format(",".join(map(str, new_shape))))
     tensor_output = tf.reshape(tensor_input, new_shape)
     np_output = tensor_output.numpy()
 
@@ -44,9 +45,7 @@ def main(cpp_fname, const_fname):
                 const_var_name="random_input_arr",
             ),
             env.get_template("declare_ram_tensor.cpp").render(
-                tensor_name="output_tensor",
-                shape=np_output.shape,
-                tensor_type_str="float",
+                tensor_name="output_tensor", tensor_type_str="float",
             ),
         ]
     )
@@ -55,7 +54,7 @@ def main(cpp_fname, const_fname):
     output_names.append("output_tensor")
     ref_output_names.append("ref_output_arr")
     other_tests_str.append(
-        f"TensorShape target_shape({ ', '.join(map(str, new_shape)) });\n"
+        f"TensorShape target_shape({ ','.join(map(str, new_shape)) });\n"
         "  TensorShape output_shape = output_tensor->get_shape();\n"
         "  EXPECT_TRUE(target_shape == output_shape);\n"
     )
@@ -74,6 +73,7 @@ def main(cpp_fname, const_fname):
                 declare_tensor_strs=declare_tensor_strs,
                 op_cls=op_cls,
                 op_type_signature=op_type_signature,
+                op_construct_params=op_construct_params,
                 op_name=op_name,
                 inputs_str=inputs_str,
                 outputs_str=outputs_str,
diff --git a/python/test_scripts/jinja_env/templates/declare_ram_tensor.cpp b/python/test_scripts/jinja_env/templates/declare_ram_tensor.cpp
@@ -1 +1,5 @@
-Tensor {{tensor_name}} = new RamTensor({ {%for s in shape%}{{ s }}{{"," if not loop.last}}{%endfor%} }, {{TENSOR_TYPE_MAP[tensor_type_str]}});
+{%if shape %}
+Tensor {{tensor_name}} = new RamTensor({ {%for s in shape%}{{ s }}{{"," if not loop.last}}{%endfor%} }, {{TENSOR_TYPE_MAP[tensor_type_str]}});
+{% else %}
+Tensor {{tensor_name}} = new RamTensor({{TENSOR_TYPE_MAP[tensor_type_str]}});
+{%endif%}
diff --git a/src/uTensor/ops/Reshape.hpp b/src/uTensor/ops/Reshape.hpp
@@ -7,17 +7,22 @@
 #include "uTensor_util.hpp"
 #include "operatorBase.hpp"
 
+using std::array;
+
 namespace uTensor {
 
 template <typename Tin>
 class ReshapeOperator : public OperatorInterface<1, 1> {
 /* reshape input as the shape of output*/
 public:
+  ReshapeOperator(const TensorShape&& shape) : _shape(shape) {}
+  ReshapeOperator(const TensorShape& shape) : _shape(shape) {}
   enum names_in : uint8_t { input };
   enum names_out : uint8_t { output };
   virtual void compute(){
     const Tensor& input_tensor = inputs[input].tensor();
     Tensor& output_tensor = outputs[output].tensor();
+    output_tensor->resize(_shape);
     if (input_tensor->num_elems() != output_tensor->num_elems()){
       uTensor_printf("inconsistent input and output shape for reshape\n");
       Context::get_default_context()->throwError(new InvalidReshapeError);
@@ -39,6 +44,7 @@ class ReshapeOperator : public OperatorInterface<1, 1> {
     }
   }
 private:
+  TensorShape _shape;
   bool _check_input_shape(){
     Tensor& input_tensor = inputs[input].tensor();
     TensorShape shape = input_tensor->get_shape();
diff --git a/src/uTensor/tensors/RamTensor.cpp b/src/uTensor/tensors/RamTensor.cpp
@@ -65,7 +65,19 @@ RamTensor::~RamTensor() {
 }
 
 void RamTensor::resize(TensorShape new_shape) {
-  uTensor_printf("Warning, RAM Tensor resize not implemented\n");
+  // uTensor_printf("Warning, RAM Tensor resize not implemented\n");
+  AllocatorInterface* allocator = Context::get_default_context()->get_ram_data_allocator();
+  void* ptr = allocator->allocate(new_shape.get_linear_size()*_type_size);
+  if (!ptr) {
+    uTensor_printf("OOM when resizing\n");
+    Context::get_default_context()->throwError(new OutOfMemError);
+    return;
+  }
+  if (is_bound(_ram_region, *allocator)) {
+    allocator->unbind(*_ram_region, &_ram_region);
+  }
+  _shape = new_shape;
+  allocator->bind(ptr, &_ram_region);
 }
 
 FutureMaxSizeRamTensor::FutureMaxSizeRamTensor(ttype _type)
diff --git a/src/uTensor/tensors/RamTensor.hpp b/src/uTensor/tensors/RamTensor.hpp
@@ -13,9 +13,9 @@ class RamTensor : public TensorInterface {
   virtual void* read(uint32_t linear_index) const override;
   virtual void* write(uint32_t linear_index) override;
   RamTensor();  // May be useful in subclasses
-  RamTensor(ttype _type);
 
  public:
+  RamTensor(ttype _type);
   RamTensor(TensorShape _shape, ttype _type);
   virtual ~RamTensor();
   virtual void resize(TensorShape new_shape) override;
