Fixes layout stride as the numpy strides

Author: Zhang Zhimin

.clang-format

@@ -2,7 +2,7 @@
 # We'll use defaults from the Google style, but with 4 columns indentation.
 BasedOnStyle: Google
 IndentWidth: 4
-ColumnLimit: 100
+ColumnLimit: 120
 ---
 Language: Cpp
 # Force pointers to the type for C++.
@@ -12,7 +12,6 @@ IndentWidth: 4
 ---
 Language: JavaScript
 # Use 100 columns for JS.
-ColumnLimit: 100
 ---
 Language: Proto
 # Don't format .proto files.

include/matazure/allocator.hpp

@@ -1,6 +1,6 @@
 #pragma once
 
-#include <malloc.h>
+#include <stdlib.h>
 #include <matazure/config.hpp>
 
 namespace matazure {
@@ -13,23 +13,24 @@ class aligned_allocator : public std::allocator<_Type> {
     aligned_allocator& operator=(const aligned_allocator& rhs) { return *this; }
 
     _Type* allocate(size_t size) {
-#ifdef __GNUC__
-        _Type* data = reinterpret_cast<_Type*>(memalign(_Alignment, size * sizeof(_Type)));
+        _Type* data = nullptr;
+#ifdef __WIN32
+        data = reinterpret_cast<_Type*>(_aligned_malloc(size * sizeof(_Type), _Alignment));
 #else
-        _Type* data = reinterpret_cast<_Type*>(_aligned_malloc(size * sizeof(_Type), _Alignment));
+        posix_memalign(reinterpret_cast<void **>(&data), _Alignment, size * sizeof(_Type));
 #endif
         return data;
     }
 
     void deallocate(_Type* p, size_t size) {
-#ifdef __GNUC__
-        free(p);
-#else
+#ifdef __WIN32
         _aligned_free(p);
+#else
+        free(p);
 #endif
     }
 
     ~aligned_allocator(){};
 };
 
-}  // namespace matazure
+}  // namespace matazure

include/matazure/config.hpp

@@ -120,19 +120,16 @@ struct blank_t {};
 }  // namespace matazure
 
 // for assert
-#define MATAZURE_STATIC_ASSERT_DIM_MATCHED(T1, T2) \
-    static_assert(T1::rank == T2::rank, "the rank is not matched")
+#define MATAZURE_STATIC_ASSERT_DIM_MATCHED(T1, T2) static_assert(T1::rank == T2::rank, "the rank is not matched")
 
 #define MATAZURE_STATIC_ASSERT_VALUE_TYPE_MATCHED(T1, T2)                                \
     static_assert(std::is_same<typename T1::value_type, typename T2::value_type>::value, \
                   "the value type is not matched")
 
-#define MATAZURE_STATIC_ASSERT_MEMORY_TYPE_MATCHED(T1, T2)           \
-    static_assert(std::is_same<runtime_t<T1>, runtime_t<T2>>::value, \
-                  "the memory type is not matched")
+#define MATAZURE_STATIC_ASSERT_MEMORY_TYPE_MATCHED(T1, T2) \
+    static_assert(std::is_same<runtime_t<T1>, runtime_t<T2>>::value, "the memory type is not matched")
 
-#define MATAZURE_STATIC_ASSERT_MATRIX_RANK(T) \
-    static_assert(T::rank == 2, "the matrix rank should be 2")
+#define MATAZURE_STATIC_ASSERT_MATRIX_RANK(T) static_assert(T::rank == 2, "the matrix rank should be 2")
 
 #define MATAZURE_CURRENT_FUNCTION "(unknown)"
 
@@ -149,29 +146,68 @@ struct blank_t {};
 #define MATAZURE_UNLIKELY(x) x
 #endif
 
-#if defined(MATAZURE_DISABLE_ASSERTS)
-
-#define MATAZURE_ASSERT(expr, msg) ((void)0)
-
-#else
-
 namespace matazure {
 
-class assert_failed : public std::runtime_error {
+class assert_failed : public std::exception {
+   public:
+    assert_failed(const string& expr, const string& function, const string& file, size_t line,
+                  const std::string& msg = " ")
+        : _expr(expr), _function(function), _file(file), _line(line), _msg(msg) {
+        _what_str = _expr + ", " + _function + ", " + _file + ", " + std::to_string(_line) + ", " + _msg;
+    }
+
+    virtual const char* what() const noexcept override { return _what_str.c_str(); }
+
+   private:
+    string _expr;
+    string _function;
+    string _file;
+    size_t _line;
+    string _msg;
+    string _what_str;
+};
+
+class verify_failed : public std::exception {
    public:
-    assert_failed(const std::string& msg) : std::runtime_error(msg) {}
+    verify_failed(const string& expr, const string& function, const string& file, size_t line,
+                  const std::string& msg = " ")
+        : _expr(expr), _function(function), _file(file), _line(line), _msg(msg) {
+        _what_str = _expr + ", " + _function + ", " + _file + ", " + std::to_string(_line) + ", " + _msg;
+    }
+
+    virtual const char* what() const noexcept override { return _what_str.c_str(); }
+
+   private:
+    string _expr;
+    string _function;
+    string _file;
+    size_t _line;
+    string _msg;
+    string _what_str;
 };
 
-inline void assertion_failed(char const* expr, char const* msg, char const* function,
-                             char const* file, long line) {
-    throw assert_failed(std::string(msg));
-}
+    inline void raise_assert_failed(const string& expr, const string& function, const string& file, long line,
+                                    const string& msg = " ") {
+        throw assert_failed(expr, function, file, line, msg);
+    }
 
-}  // namespace matazure
+    inline void raise_verify_failed(const string& expr, const string& function, const string& file, long line,
+                                    const string& msg = " ") {
+        throw verify_failed(expr, function, file, line, msg);
+    }
 
-#define MATAZURE_ASSERT(expr, msg)                             \
-    (MATAZURE_LIKELY(!!(expr)) ? ((void)0)                     \
-                               : ::matazure::assertion_failed( \
-                                     #expr, msg, MATAZURE_CURRENT_FUNCTION, __FILE__, __LINE__))
+    }  // namespace matazure
 
+#if defined(MATAZURE_DISABLE_ASSERTS)
+#define MATAZURE_ASSERT(expr, msg) ((void)0)
+#else
+#define MATAZURE_ASSERT(expr, ...) \
+    (MATAZURE_LIKELY(!!(expr))     \
+         ? ((void)0)               \
+         : ::matazure::raise_assert_failed(#expr, MATAZURE_CURRENT_FUNCTION, __FILE__, __LINE__, ##__VA_ARGS__))
 #endif
+
+#define MATAZURE_VERIFY(expr, ...) \
+    (MATAZURE_LIKELY(!!(expr))     \
+         ? ((void)0)               \
+         : ::matazure::raise_verify_failed(#expr, MATAZURE_CURRENT_FUNCTION, __FILE__, __LINE__, ##__VA_ARGS__))

include/matazure/dynamic_tensor.hpp

@@ -1,12 +1,12 @@
-#pragma once
+#pragma once
 
 #include <matazure/lambda_tensor.hpp>
 #include <matazure/tensor.hpp>
 
 namespace matazure {
 
-enum struct data_type {
-    undefined = 0,
+enum dtype {
+    none = 0,
     dt_uint8,
     dt_uint16,
     dt_uint32,
@@ -24,67 +24,67 @@ template <typename _T>
 struct get_data_type_traits;
 template <>
 struct get_data_type_traits<std::uint8_t> {
-    const static data_type value = data_type::dt_uint8;
+    const static dtype value = dtype::dt_uint8;
 };
 template <>
 struct get_data_type_traits<std::uint16_t> {
-    const static data_type value = data_type::dt_uint16;
+    const static dtype value = dtype::dt_uint16;
 };
 template <>
 struct get_data_type_traits<std::uint32_t> {
-    const static data_type value = data_type::dt_uint32;
+    const static dtype value = dtype::dt_uint32;
 };
 template <>
 struct get_data_type_traits<std::uint64_t> {
-    const static data_type value = data_type::dt_uint64;
+    const static dtype value = dtype::dt_uint64;
 };
 template <>
 struct get_data_type_traits<std::int8_t> {
-    const static data_type value = data_type::dt_int8;
+    const static dtype value = dtype::dt_int8;
 };
 template <>
 struct get_data_type_traits<std::int16_t> {
-    const static data_type value = data_type::dt_int16;
+    const static dtype value = dtype::dt_int16;
 };
 template <>
 struct get_data_type_traits<std::int32_t> {
-    const static data_type value = data_type::dt_int32;
+    const static dtype value = dtype::dt_int32;
 };
 template <>
 struct get_data_type_traits<std::int64_t> {
-    const static data_type value = data_type::dt_int64;
+    const static dtype value = dtype::dt_int64;
 };
 
-// template <> struct get_data_type_traits<std::float> { const static data_type value =
-// data_type::dt_float16; };
+// template <> struct get_data_type_traits<std::float> { const static dtype value =
+// dtype::dt_float16; };
 template <>
 struct get_data_type_traits<float> {
-    const static data_type value = data_type::dt_float32;
+    const static dtype value = dtype::dt_float32;
 };
 template <>
 struct get_data_type_traits<double> {
-    const static data_type value = data_type::dt_float64;
+    const static dtype value = dtype::dt_float64;
 };
 
-inline int_t get_data_type_size(data_type type) {
-    switch (type) {
-        case data_type::dt_uint8:
+inline int_t get_data_type_size(dtype data_type) {
+    switch (data_type) {
+        case dtype::dt_uint8:
             return 1;
-        case data_type::dt_int8:
+        case dtype::dt_int8:
             return 1;
-        case data_type::dt_uint16:
+        case dtype::dt_uint16:
             return 2;
-        case data_type::dt_int16:
+        case dtype::dt_int16:
             return 2;
-        case data_type::dt_uint32:
+        case dtype::dt_uint32:
             return 4;
-        case data_type::dt_int32:
+        case dtype::dt_int32:
             return 4;
-        case data_type::dt_float16:
+        case dtype::dt_float16:
             return 2;
-        case data_type::dt_float32:
+        case dtype::dt_float32:
             return 4;
-        case data_type::dt_float64:
+        case dtype::dt_float64:
             return 8;
         default:
             MATAZURE_ASSERT(false, "unreachable");
@@ -99,74 +99,72 @@ class dynamic_tensor {
 
     dynamic_tensor() {}
 
-    dynamic_tensor(data_type type, shape_type ts_shape)
-        : type_(type),
-          ts_shape_(ts_shape),
-          size_(reduce(ts_shape_, 1, [](int_t x0, int_t x1) { return x0 * x1; })) {
-        auto p_mem_ = new byte[size_ * element_size()];
-        sp_mem_.reset(p_mem_, [](byte* p) { delete[] p; });
-    }
-
-    dynamic_tensor(data_type type, shape_type ts_shape, shared_ptr<void> sp_mem)
-        : type_(type),
-          ts_shape_(ts_shape),
-          size_(reduce(ts_shape_, 1, [](int_t x0, int_t x1) { return x0 * x1; })),
-          sp_mem_(std::static_pointer_cast<byte>(sp_mem)) {}
+    dynamic_tensor(dtype data_type, shape_type shape, shape_type stride, shared_ptr<void> sp_mem)
+        : data_type_(data_type),
+          shape_(shape),
+          stride_(stride),
+          size_(reduce(shape_, 1, [](int_t x0, int_t x1) { return x0 * x1; })),
+          sp_mem_(std::static_pointer_cast<void>(sp_mem)) {}
 
     dynamic_tensor(const dynamic_tensor& other)
-        : type_(other.type_),
-          ts_shape_(other.ts_shape_),
+        : data_type_(other.data_type_),
+          shape_(other.shape_),
+          stride_(other.stride_),
           size_(other.size_),
           sp_mem_(other.sp_mem_) {}
 
     dynamic_tensor& operator=(const dynamic_tensor& other) {
-        type_ = other.type_;
-        ts_shape_ = other.ts_shape_;
+        data_type_ = other.data_type_;
+        shape_ = other.shape_;
+        stride_ = other.stride_;
         size_ = other.size_;
         sp_mem_ = other.sp_mem_;
         return *this;
     }
 
-    data_type type() const { return type_; }
+    dtype dtype() const { return data_type_; }
+
+    shape_type shape() const { return shape_; }
 
-    shape_type shape() const { return ts_shape_; }
+    shape_type stride() const { return stride_; }
 
-    int_t shape(int_t i) const { return ts_shape_[i]; }
+    int_t shape(int_t i) const { return shape_[i]; }
 
-    int_t rank() const { return ts_shape_.size(); }
+    int_t rank() const { return shape_.size(); }
 
     int_t size() const { return size_; }
 
-    template <typename _Type = byte>
+    template <typename _Type = void>
     shared_ptr<_Type> shared_data() {
         auto sp_mem = sp_mem_;
         shared_ptr<_Type> sp_tmp(data<_Type>(), [sp_mem](_Type* p) {});
         return sp_tmp;
     }
 
-    template <typename _Type = byte>
+    template <typename _Type = void>
     shared_ptr<const _Type> shared_data() const {
         auto sp_mem = sp_mem_;
         shared_ptr<const _Type> sp_tmp(data<_Type>(), [sp_mem](const _Type* p) {});
         return sp_tmp;
     }
 
-    template <typename _Type = byte>
+    template <typename _Type = void>
     _Type* data() {
         return reinterpret_cast<_Type*>(sp_mem_.get());
     }
 
-    template <typename _Type = byte>
+    template <typename _Type = void>
     const _Type* data() const {
         return reinterpret_cast<_Type*>(sp_mem_.get());
     }
 
-    int_t element_size() const { return get_data_type_size(type_); }
+    int_t element_size() const { return get_data_type_size(data_type_); }
 
    private:
-    data_type type_;
-    shared_ptr<byte> sp_mem_ = nullptr;
-    shape_type ts_shape_;
+    enum dtype data_type_;
+    shared_ptr<void> sp_mem_ = nullptr;
+    shape_type shape_;
+    shape_type stride_;
     int_t size_;
 };
 
@@ -175,8 +173,10 @@ dynamic_tensor dynamic_tensor_wrap(_Tensor ts) {
     auto rank = _Tensor::rank;
     dynamic_tensor::shape_type shape(rank);
     copy(ts.shape(), shape);
-    shared_ptr<byte> sp_tmp(reinterpret_cast<byte*>(ts.data()), [ts](byte* p) {});
-    return dynamic_tensor(get_data_type_traits<typename _Tensor::value_type>::value, shape, sp_tmp);
+    dynamic_tensor::shape_type stride(rank);
+    copy(ts.layout().stride(), stride);
+    shared_ptr<void> sp_tmp(reinterpret_cast<void*>(ts.data()), [ts](void* p) {});
+    return dynamic_tensor(get_data_type_traits<typename _Tensor::value_type>::value, shape, stride, sp_tmp);
 }
 
 }  // namespace matazure