fixed CR comments

Author: aestriplex

arm_compute/core/Coordinates.h

@@ -33,6 +33,7 @@
 
 #include <algorithm>
 #include <array>
+#include <vector>
 #include <cstddef>
 
 namespace arm_compute
@@ -55,7 +56,7 @@ class Coordinates : public Dimensions<int>
      * @param[in] coords Vector containing the values to initialize the dimensions.
      */
     template <typename T>
-    constexpr Coordinates(std::vector<T> coords) : Dimensions(coords)
+    constexpr Coordinates(const std::vector<T>& coords) : Dimensions(coords)
     {
     }
 

arm_compute/core/Dimensions.h

@@ -32,6 +32,7 @@
 
 #include <algorithm>
 #include <array>
+#include <vector>
 #include <functional>
 #include <limits>
 #include <numeric>

arm_compute/core/IReducibleTensor.h

@@ -27,6 +27,8 @@
 
 #include "arm_compute/core/SparseTensor.h"
 
+#include <memory>
+
 namespace arm_compute
 {
 /** Forward declaration of COOTensor and CSRTensor class */

arm_compute/core/SparseTensor.h

@@ -29,12 +29,13 @@
 #include "arm_compute/core/Types.h"
 
 #include <functional>
+#include <memory>
 #include <stdexcept>
 
-typedef std::function<bool(const void *)> predicate_t;
-
 namespace arm_compute
 {
+using predicate_t = std::function<bool(const void *)>;
+
 /** Common base class for all sparse tensors */
 class SparseTensor : public ITensor
 {
@@ -63,7 +64,7 @@ class SparseTensor : public ITensor
     /** Returns the ratio of non-zero elements to the total number of elements */
     float density() const;
     /** Returns the dense volume */
-    uint32_t dense_volume(size_t sparse_dim) const;
+    size_t dense_volume(size_t sparse_dim) const;
     /** Returns the number of non zero elements */
     virtual size_t nnz() const = 0;
     /** Converts the sparse tensor to a dense tensor */

arm_compute/core/TensorFormat.h

@@ -21,8 +21,11 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  * SOFTWARE.
  */
-#ifndef ACL_ARM_COMPUTE_RUNTIME_TENSOR_FORMAT_H
-#define ACL_ARM_COMPUTE_RUNTIME_TENSOR_FORMAT_H
+#ifndef ACL_ARM_COMPUTE_CORE_TENSOR_FORMAT_H
+#define ACL_ARM_COMPUTE_CORE_TENSOR_FORMAT_H
+
+namespace arm_compute
+{
 
 enum class TensorFormat
 {
@@ -31,4 +34,6 @@ enum class TensorFormat
     CSR   = 2,
 };
 
-#endif // ACL_ARM_COMPUTE_RUNTIME_TENSOR_FORMAT_H
+} //namespace arm_compute
+
+#endif // ACL_ARM_COMPUTE_CORE_TENSOR_FORMAT_H

arm_compute/runtime/COOTensor.h

@@ -44,9 +44,9 @@ class COOTensor final : public SparseTensor, public IMemoryManageable
     *
     * @param[in] os the output stream; std::cout set as default.
     *
-    * @note It prints (on os stream) the vector of the indices with the format
-    *       index: [idx_0, idx_1, ...], and the corresponding values with the format
-    *       value: [val_0, val_1, ...].
+    * @note Only available when ARM_COMPUTE_ASSERTS_ENABLED is defined.
+    * @note It prints (on os stream) one line per non-zero element with the format
+    *       index: [dim_0, dim_1, ...]  values: [val_0, val_1, ...]
     * @note This print function should overlap the one defined for ITensor.
     */
     void print(std::ostream &os = std::cout) const;

arm_compute/runtime/CSRTensor.h

@@ -44,8 +44,9 @@ class CSRTensor final : public SparseTensor, public IMemoryManageable
     *
     * @param[in] os the output stream; std::cout set as default.
     *
-    * @note It prints (on os stream) the two vectors of the indices with the format
-    *       [row_idx_0, row_idx_1, ...] and [col_idx_0, col_idx_1, ...]
+    * @note Only available when ARM_COMPUTE_ASSERTS_ENABLED is defined.
+    * @note It prints (on os stream) the row offsets, column indices, and values with the format
+    *       r_offsets: [row_offset_0, row_offset_1, ...] cols: [col_idx_0, col_idx_1, ...] values: [val_0, val_1, ...]
     * @note This print function should overlap the one defined for ITensor.
     */
     void print(std::ostream &os = std::cout) const;
@@ -64,10 +65,13 @@ class CSRTensor final : public SparseTensor, public IMemoryManageable
     /** The size of each index element */
     static constexpr size_t index_size = sizeof(int32_t);
 
-    /** Convert a dense tensor to sparse tensor with specified sparse dimensions using COO format.
+    /** Convert a dense tensor to a CSR sparse tensor.
      *
-     *  @param[in] tensor
-     *  @param[in] sparse_dim  It should belong to [1, tensor->info->num_dimensions()]
+     *  @note Only 2D tensors with NCHW layout are supported. @p sparse_dim is
+     *        ignored; CSR always uses sparse_dim = 2.
+     *
+     *  @param[in] tensor     Source dense tensor. Must be 2D.
+     *  @param[in] sparse_dim Unused. Reserved for future use; must be 2.
      */
     CSRTensor(const ITensor *tensor, size_t sparse_dim);
     /** Convert a dense tensor to a *fully* sparse tensor.

src/core/SparseTensor.cpp

@@ -25,6 +25,8 @@
 
 #include "arm_compute/core/Error.h"
 
+#include <numeric>
+
 namespace arm_compute
 {
 SparseTensor::SparseTensor(size_t dim, size_t sparse_dim) : _total_dim(dim), _sparse_dim(sparse_dim)
@@ -48,7 +50,7 @@ float SparseTensor::sparsity() const
 
 float SparseTensor::density() const
 {
-    return static_cast<float>(nnz()) / static_cast<float>(info()->total_size());
+    return static_cast<float>(nnz()) / static_cast<float>(info()->tensor_shape().total_size());
 }
 
 size_t SparseTensor::dim() const
@@ -61,10 +63,10 @@ bool SparseTensor::is_hybrid() const
     return dense_dim() > 0;
 }
 
-uint32_t SparseTensor::dense_volume(size_t sparse_dim) const
+size_t SparseTensor::dense_volume(size_t sparse_dim) const
 {
     const auto &ts = info()->tensor_shape();
-    return std::accumulate(ts.begin() + sparse_dim, ts.end(), 1, std::multiplies<int>());
+    return std::accumulate(ts.begin() + sparse_dim, ts.end(), size_t{1}, std::multiplies<size_t>());
 }
 
 bool SparseTensor::has_non_zero_elements(uint8_t *arr, size_t len, size_t element_size, predicate_t is_non_zero) const

src/runtime/COOTensor.cpp

@@ -52,7 +52,7 @@ COOTensor::COOTensor(const ITensor *tensor, size_t sparse_dim) : SparseTensor(te
                                  "argument must be in [1,%zu] range. %zu is given",
                                  dim(), sparse_dim);
 
-    const uint8_t     *data = tensor->buffer();
+    const uint8_t     *data = tensor->buffer() + info->offset_first_element_in_bytes();
     const size_t dense_dims = dense_dim();
     const auto   is_nonzero = make_is_nonzero_predicate(info->data_type());
 
@@ -75,18 +75,18 @@ COOTensor::COOTensor(const ITensor *tensor, size_t sparse_dim) : SparseTensor(te
     const size_t   slice_size = step * element_size;
 
     size_t value_byte_size = 0;
-    size_t indices_bytes = 0;
     for(size_t i = 0; i < max_iter; i++)
     {
         const size_t offset = i * slice_size;
         if(has_non_zero_elements(const_cast<uint8_t *>(data + offset), slice_size, element_size, is_nonzero))
         {
             value_byte_size += slice_size;
-            indices_bytes += dim() * sizeof(int32_t);
         }
     }
 
-    _allocator.init(coo_tensor_info(info), value_byte_size, indices_bytes);
+    // Indices are stored in _indices (host vector); no index data is written into
+    // the allocator buffer yet, so pass 0 for indices_bytes.
+    _allocator.init(coo_tensor_info(info), value_byte_size, 0);
     _allocator.allocate();
 
     for(size_t i = 0; i < max_iter; i++)
@@ -181,7 +181,7 @@ std::unique_ptr<ITensor> COOTensor::to_dense()
         for(size_t j = 0; j < dense_vol; ++j)
         {
             const void *value_ptr = block_ptr + j * element_size;
-            uint8_t     *base_ptr = tensor->buffer() + final_offset + j * element_size;
+            uint8_t     *base_ptr = tensor->buffer() + first_elem_offset + final_offset + j * element_size;
 
             std::memcpy(base_ptr, value_ptr, element_size);
         }
@@ -211,13 +211,14 @@ const uint8_t *COOTensor::get_value(Coordinates coords) const
     for(size_t i = 0; i < _indices.size(); ++i)
     {
         const Coordinates &c = _indices[i];
-        bool           match = false;
+        bool           match = true;
 
         for(size_t d = 0; d < coords.num_dimensions(); ++d)
         {
-            if(c[d] == coords[d])
+            if(c[d] != coords[d])
             {
-                match = true;
+                match = false;
+                break;
             }
         }
         if(match)

src/runtime/CSRTensor.cpp

@@ -21,7 +21,7 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  * SOFTWARE.
  */
-#include "arm_compute/runtime/COOTensor.h"
+#include "arm_compute/runtime/CSRTensor.h"
 
 #include "arm_compute/core/CoreTypes.h"
 #include "arm_compute/core/Error.h"
@@ -75,7 +75,7 @@ CSRTensor::CSRTensor(const ITensor *tensor, size_t sparse_dim) : SparseTensor(te
             if(is_nonzero(data + element_offset))
             {
                 _col_bytes += index_size;
-                value_byte_size += element_size * dense_volume(sparse_dim);
+                value_byte_size += element_size * dense_volume(this->sparse_dim());
             }
         }
     }