[neurun] Apply other types for source/sink. (#2740)

This commit applies other types for source/sink.

Signed-off-by: jiseob.jang <jiseob.jang@samsung.com>

diff --git a/runtimes/neurun/src/backend/acl_cl/feature/View.h b/runtimes/neurun/src/backend/acl_cl/feature/View.h
index 12025ce..5801c2f 100644 (file)
--- a/runtimes/neurun/src/backend/acl_cl/feature/View.h
+++ b/runtimes/neurun/src/backend/acl_cl/feature/View.h
@@ -30,9 +30,7 @@ namespace arm_compute
 namespace feature
 {
 
-template <typename T> class View;
-
-template <> class View<float> final : public nnfw::util::feature::Reader<float>
+template <typename T> class View final : public nnfw::util::feature::Reader<T>
 {
 public:
   View(::arm_compute::ITensor *tensor) : _tensor{tensor}
@@ -50,37 +48,37 @@ public:
   const ::nnfw::util::feature::Shape &shape(void) const { return _shape; }
 
 public:
-  float at(uint32_t ch, uint32_t row, uint32_t col) const override
+  T at(uint32_t ch, uint32_t row, uint32_t col) const override
   {
     const auto offset = feature_index_to_byte_offset(ch, row, col);
 
-    float *ptr = reinterpret_cast<float *>(_tensor->buffer() + offset);
+    T *ptr = reinterpret_cast<T *>(_tensor->buffer() + offset);
 
     return *ptr;
   }
-  float at(uint32_t batch, uint32_t ch, uint32_t row, uint32_t col) const override
+  T at(uint32_t batch, uint32_t ch, uint32_t row, uint32_t col) const override
   {
     const auto offset = feature_index_to_byte_offset(batch, ch, row, col);
 
-    float *ptr = reinterpret_cast<float *>(_tensor->buffer() + offset);
+    T *ptr = reinterpret_cast<T *>(_tensor->buffer() + offset);
 
     return *ptr;
   }
 
 public:
-  float &at(uint32_t ch, uint32_t row, uint32_t col)
+  T &at(uint32_t ch, uint32_t row, uint32_t col)
   {
     const auto offset = feature_index_to_byte_offset(ch, row, col);
 
-    float *ptr = reinterpret_cast<float *>(_tensor->buffer() + offset);
+    T *ptr = reinterpret_cast<T *>(_tensor->buffer() + offset);
 
     return *ptr;
   }
-  float &at(uint32_t batch, uint32_t ch, uint32_t row, uint32_t col)
+  T &at(uint32_t batch, uint32_t ch, uint32_t row, uint32_t col)
   {
     const auto offset = feature_index_to_byte_offset(batch, ch, row, col);
 
-    float *ptr = reinterpret_cast<float *>(_tensor->buffer() + offset);
+    T *ptr = reinterpret_cast<T *>(_tensor->buffer() + offset);
 
     return *ptr;
   }

diff --git a/runtimes/neurun/src/exec/Sink.h b/runtimes/neurun/src/exec/Sink.h
index f054725..eaeea66 100644 (file)
--- a/runtimes/neurun/src/exec/Sink.h
+++ b/runtimes/neurun/src/exec/Sink.h
@@ -45,13 +45,12 @@ struct Sink
 //
 // VectorSink
 //
-class VectorSink final : public Sink
+template <typename T> class VectorSink final : public Sink
 {
 public:
-  VectorSink(const int32_t vlen, uint8_t *base, const size_t size)
-      : _vlen{vlen}, _base{base}, _size{size}
+  VectorSink(const int32_t vlen, T *base, const size_t size) : _vlen{vlen}, _base{base}, _size{size}
   {
-    assert(size >= _vlen * sizeof(float));
+    assert(size == _vlen * sizeof(T));
   }
 
 public:
@@ -62,7 +61,7 @@ public:
 
 private:
   const int32_t _vlen;
-  uint8_t *const _base;
+  T *const _base;
   const size_t _size;
 };
 
@@ -175,13 +174,13 @@ private:
 //
 // FeatureSink
 //
-class FeatureSink final : public Sink
+template <typename T> class FeatureSink final : public Sink
 {
 public:
-  FeatureSink(const nnfw::util::feature::Shape &shape, uint8_t *base, const size_t size)
+  FeatureSink(const nnfw::util::feature::Shape &shape, T *base, const size_t size)
       : _shape{shape}, _base{base}, _size{size}
   {
-    // DO NOTHING
+    assert(size == _shape.N * _shape.H * _shape.W * _shape.C * sizeof(T));
   }
 
 public:
@@ -194,8 +193,8 @@ public:
     }
     else if (typeid(tensor) == typeid(::arm_compute::CLTensor))
     {
-      const ::internal::arm_compute::feature::View<float> from{&tensor};
-      ::internal::nnapi::feature::View<float> into{_shape, _base, _size};
+      const ::internal::arm_compute::feature::View<T> from{&tensor};
+      ::internal::nnapi::feature::View<T> into{_shape, _base, _size};
 
       ::nnfw::util::feature::iterate(_shape)
           << [&](uint32_t bat, uint32_t ch, uint32_t row, uint32_t col) {
@@ -207,7 +206,7 @@ public:
 
 private:
   const nnfw::util::feature::Shape _shape;
-  uint8_t *const _base;
+  T *const _base;
   const size_t _size;
 };
 

diff --git a/runtimes/neurun/src/exec/Source.h b/runtimes/neurun/src/exec/Source.h
index 04a350f..b9cffe6 100644 (file)
--- a/runtimes/neurun/src/exec/Source.h
+++ b/runtimes/neurun/src/exec/Source.h
@@ -47,13 +47,13 @@ struct Source
 //
 // VectorSource
 //
-class VectorSource final : public Source
+template <typename T> class VectorSource final : public Source
 {
 public:
-  VectorSource(const int32_t vlen, const uint8_t *base, const size_t size)
+  VectorSource(const int32_t vlen, const T *base, const size_t size)
       : _vlen{vlen}, _base{base}, _size{size}
   {
-    assert(size >= _vlen * sizeof(float));
+    assert(size == _vlen * sizeof(T));
   }
 
 public:
@@ -64,7 +64,7 @@ public:
 
 private:
   const int32_t _vlen;
-  const uint8_t *const _base;
+  const T *const _base;
   const size_t _size;
 };
 
@@ -172,13 +172,13 @@ private:
 //
 // FeatureSource
 //
-class FeatureSource final : public Source
+template <typename T> class FeatureSource final : public Source
 {
 public:
-  FeatureSource(const nnfw::util::feature::Shape &shape, const uint8_t *base, const size_t size)
+  FeatureSource(const nnfw::util::feature::Shape &shape, const T *base, const size_t size)
       : _shape{shape}, _base{base}, _size{size}
   {
-    // DO NOTHING
+    assert(_size == _shape.N * _shape.H * _shape.W * _shape.C * sizeof(T));
   }
 
 public:
@@ -191,8 +191,8 @@ public:
     }
     else if (typeid(tensor) == typeid(::arm_compute::CLTensor))
     {
-      const ::internal::nnapi::feature::Reader<float> from{_shape, _base, _size};
-      ::internal::arm_compute::feature::View<float> into{&tensor};
+      const ::internal::nnapi::feature::Reader<T> from{_shape, _base, _size};
+      ::internal::arm_compute::feature::View<T> into{&tensor};
 
       ::nnfw::util::feature::iterate(_shape)
           << [&](uint32_t bat, uint32_t ch, uint32_t row, uint32_t col) {
@@ -204,7 +204,7 @@ public:
 
 private:
   const nnfw::util::feature::Shape _shape;
-  const uint8_t *const _base;
+  const T *const _base;
   const size_t _size;
 };
 

diff --git a/runtimes/neurun/src/frontend/execution.cc b/runtimes/neurun/src/frontend/execution.cc
index ff34921..3c80650 100644 (file)
--- a/runtimes/neurun/src/frontend/execution.cc
+++ b/runtimes/neurun/src/frontend/execution.cc
@@ -77,15 +77,15 @@ int ANeuralNetworksExecution_setInput(ANeuralNetworksExecution *execution, int32
 
     const auto len = operands.at(operand_index).shape().dim(1);
 
-    execution->source<neurun::exec::VectorSource>(
-        index, len, reinterpret_cast<const uint8_t *>(buffer), length);
+    execution->source<neurun::exec::VectorSource<float>>(
+        index, len, reinterpret_cast<const float *>(buffer), length);
   }
   else if (operands.at(operand_index).shape().rank() == 4)
   {
     const auto &operand_shape = operands.at(operand_index).shape().asFeature();
 
-    execution->source<neurun::exec::FeatureSource>(
-        index, operand_shape, reinterpret_cast<const uint8_t *>(buffer), length);
+    execution->source<neurun::exec::FeatureSource<float>>(
+        index, operand_shape, reinterpret_cast<const float *>(buffer), length);
   }
   else
   {
@@ -124,15 +124,15 @@ int ANeuralNetworksExecution_setOutput(ANeuralNetworksExecution *execution, int3
 
     const auto len = operands.at(operand_index).shape().dim(1);
 
-    execution->sink<neurun::exec::VectorSink>(index, len, reinterpret_cast<uint8_t *>(buffer),
-                                              length);
+    execution->sink<neurun::exec::VectorSink<float>>(index, len, reinterpret_cast<float *>(buffer),
+                                                     length);
   }
   else if (operands.at(operand_index).shape().rank() == 4)
   {
     const auto &operand_shape = operands.at(operand_index).shape().asFeature();
 
-    execution->sink<neurun::exec::FeatureSink>(index, operand_shape,
-                                               reinterpret_cast<uint8_t *>(buffer), length);
+    execution->sink<neurun::exec::FeatureSink<float>>(index, operand_shape,
+                                                      reinterpret_cast<float *>(buffer), length);
   }
   else
   {

diff --git a/runtimes/neurun/src/internal/nnapi/feature/Reader.h b/runtimes/neurun/src/internal/nnapi/feature/Reader.h
index eb51351..3aac361 100644 (file)
--- a/runtimes/neurun/src/internal/nnapi/feature/Reader.h
+++ b/runtimes/neurun/src/internal/nnapi/feature/Reader.h
@@ -28,44 +28,38 @@ namespace nnapi
 namespace feature
 {
 
-template <typename T> class Reader;
-
-template <> class Reader<float> final : public nnfw::util::feature::Reader<float>
+template <typename T> class Reader final : public nnfw::util::feature::Reader<T>
 {
 public:
-  Reader(const ::nnfw::util::feature::Shape &shape, const uint8_t *ptr, size_t len)
-      : _shape{shape}, _ptr{ptr}, _len{len}
+  Reader(const ::nnfw::util::feature::Shape &shape, const T *ptr, size_t len)
+      : _shape{shape}, _ptr{ptr}
   {
-    // DO NOTHING
+    (void)len; // Workaround for unused variable in release mode
+    assert(shape.N * shape.C * shape.H * shape.W * sizeof(T) == len);
   }
 
 public:
   const nnfw::util::feature::Shape &shape(void) const { return _shape; }
 
 public:
-  float at(uint32_t ch, uint32_t row, uint32_t col) const override
+  T at(uint32_t ch, uint32_t row, uint32_t col) const override
   {
     uint32_t index = index_of(_shape, ch, row, col);
 
-    const auto arr = reinterpret_cast<const float *>(_ptr);
-
-    return arr[index];
+    return _ptr[index];
   }
-  float at(uint32_t batch, uint32_t ch, uint32_t row, uint32_t col) const override
+  T at(uint32_t batch, uint32_t ch, uint32_t row, uint32_t col) const override
   {
     uint32_t index = index_of(_shape, batch, ch, row, col);
 
-    const auto arr = reinterpret_cast<const float *>(_ptr);
-
-    return arr[index];
+    return _ptr[index];
   }
 
 private:
   nnfw::util::feature::Shape _shape;
 
 private:
-  const uint8_t *_ptr;
-  const size_t _len;
+  const T *_ptr;
 };
 
 } // namespace feature

diff --git a/runtimes/neurun/src/internal/nnapi/feature/View.h b/runtimes/neurun/src/internal/nnapi/feature/View.h
index 60335db..2c55b2e 100644 (file)
--- a/runtimes/neurun/src/internal/nnapi/feature/View.h
+++ b/runtimes/neurun/src/internal/nnapi/feature/View.h
@@ -17,6 +17,8 @@
 #ifndef __INTERNAL_NNAPI_FEATURE_VIEW_H__
 #define __INTERNAL_NNAPI_FEATURE_VIEW_H__
 
+#include <cassert>
+
 #include "internal/nnapi/feature/Utils.h"
 
 #include "util/feature/Reader.h"
@@ -28,13 +30,13 @@ namespace nnapi
 namespace feature
 {
 
-template <typename T> class View final : public nnfw::util::feature::Reader<float>
+template <typename T> class View final : public nnfw::util::feature::Reader<T>
 {
 public:
-  View(const ::nnfw::util::feature::Shape &shape, uint8_t *ptr, size_t len)
-      : _shape{shape}, _ptr{ptr}, _len{len}
+  View(const ::nnfw::util::feature::Shape &shape, T *ptr, size_t len) : _shape{shape}, _ptr{ptr}
   {
-    // DO NOTHING
+    (void)len; // Workaround for unused variable in release mode
+    assert(shape.N * shape.C * shape.H * shape.W * sizeof(T) == len);
   }
 
 public:
@@ -45,44 +47,35 @@ public:
   {
     uint32_t index = index_of(_shape, ch, row, col);
 
-    T *arr = reinterpret_cast<T *>(_ptr);
-
-    return arr[index];
+    return _ptr[index];
   }
 
   T at(uint32_t batch, uint32_t ch, uint32_t row, uint32_t col) const override
   {
     uint32_t index = index_of(_shape, batch, ch, row, col);
 
-    T *arr = reinterpret_cast<T *>(_ptr);
-
-    return arr[index];
+    return _ptr[index];
   }
 
   T &at(uint32_t ch, uint32_t row, uint32_t col)
   {
     uint32_t index = index_of(_shape, ch, row, col);
 
-    T *arr = reinterpret_cast<T *>(_ptr);
-
-    return arr[index];
+    return _ptr[index];
   }
 
   T &at(uint32_t batch, uint32_t ch, uint32_t row, uint32_t col)
   {
     uint32_t index = index_of(_shape, batch, ch, row, col);
 
-    T *arr = reinterpret_cast<T *>(_ptr);
-
-    return arr[index];
+    return _ptr[index];
   }
 
 private:
   nnfw::util::feature::Shape _shape;
 
 private:
-  uint8_t *_ptr;
-  const size_t _len;
+  T *_ptr;
 };
 
 } // namespace feature

diff --git a/runtimes/neurun/src/kernel/cpu/PermuteLayer.cc b/runtimes/neurun/src/kernel/cpu/PermuteLayer.cc
index b6f327e..5136735 100644 (file)
--- a/runtimes/neurun/src/kernel/cpu/PermuteLayer.cc
+++ b/runtimes/neurun/src/kernel/cpu/PermuteLayer.cc
@@ -57,7 +57,8 @@ void PermuteLayer::run()
   {
     case Type::NHWC_TO_NCHW:
     {
-      const ::internal::nnapi::feature::Reader<float> from{feature, input_buffer, input_size};
+      const ::internal::nnapi::feature::Reader<float> from{
+          feature, reinterpret_cast<const float *>(input_buffer), input_size};
       ::internal::arm_compute::feature::View<float> into{_output};
 
       // TODO Fix this workaround (We may need codegen::operand::Object instead of ITensor)
@@ -83,7 +84,8 @@ void PermuteLayer::run()
       _input_cl->map(queue);
 
       const ::internal::arm_compute::feature::View<float> from{_input};
-      ::internal::nnapi::feature::View<float> into{feature, output_buffer, output_size};
+      ::internal::nnapi::feature::View<float> into{
+          feature, reinterpret_cast<float *>(output_buffer), output_size};
 
       ::nnfw::util::feature::iterate(feature)
           << [&](uint32_t batch, uint32_t ch, uint32_t row, uint32_t col) {