From 99849ee0f0f28ff956bafb7d00e60bfd205651e8 Mon Sep 17 00:00:00 2001 From: lg Date: Tue, 27 Nov 2018 13:55:31 +0800 Subject: [PATCH 1/9] add `value_type_t value_type()` and `void* data()` for basic_raw_tensor --- include/ttl/bits/std_raw_tensor.hpp | 4 ++++ tests/test_raw_tensor.cpp | 18 +++++++++++++----- 2 files changed, 17 insertions(+), 5 deletions(-) diff --git a/include/ttl/bits/std_raw_tensor.hpp b/include/ttl/bits/std_raw_tensor.hpp index 3f7b937..5f64822 100644 --- a/include/ttl/bits/std_raw_tensor.hpp +++ b/include/ttl/bits/std_raw_tensor.hpp @@ -38,6 +38,8 @@ class basic_raw_tensor { } + value_type_t value_type() const { return value_type_; } + shape_t shape() const { return shape_; } template R *data() const @@ -49,6 +51,8 @@ class basic_raw_tensor return reinterpret_cast(data_.get()); } + void *data() const { return data_.get(); } + template > basic_tensor_ref ref_as() const { diff --git a/tests/test_raw_tensor.cpp b/tests/test_raw_tensor.cpp index 57c943f..58f80f6 100644 --- a/tests/test_raw_tensor.cpp +++ b/tests/test_raw_tensor.cpp @@ -6,30 +6,38 @@ using ttl::experimental::raw_tensor; TEST(raw_tensor_test, test1) { - using scalar_encoding = raw_tensor::encoder_type; + using encoder = raw_tensor::encoder_type; using raw_shape = raw_tensor::shape_type; { - raw_tensor t(scalar_encoding::value()); + raw_tensor t(encoder::value()); ASSERT_EQ(t.shape().size(), static_cast(1)); + ASSERT_EQ(t.value_type(), encoder::value()); + ASSERT_EQ(t.data(), t.data()); t.ref_as(); t.view_as(); } { - raw_tensor t(scalar_encoding::value(), 1); + raw_tensor t(encoder::value(), 1); ASSERT_EQ(t.shape().size(), static_cast(1)); + ASSERT_EQ(t.value_type(), encoder::value()); + ASSERT_EQ(t.data(), t.data()); t.ref_as(); t.view_as(); } { - raw_tensor t(scalar_encoding::value(), 1, 2); + raw_tensor t(encoder::value(), 1, 2); ASSERT_EQ(t.shape().size(), static_cast(2)); + ASSERT_EQ(t.value_type(), encoder::value()); + ASSERT_EQ(t.data(), t.data()); t.ref_as(); t.view_as(); } { - raw_tensor t(scalar_encoding::value(), 1, 2, 3); + raw_tensor t(encoder::value(), 1, 2, 3); + ASSERT_EQ(t.value_type(), encoder::value()); ASSERT_EQ(t.shape().size(), static_cast(6)); + ASSERT_EQ(t.data(), t.data()); t.ref_as(); t.view_as(); } From f5e2948d5125ec5f6307589757ddd7f8704046dc Mon Sep 17 00:00:00 2001 From: lg Date: Tue, 27 Nov 2018 13:58:41 +0800 Subject: [PATCH 2/9] add flat_tensor_ref and flat_tensor_view --- include/ttl/bits/std_allocator.hpp | 31 +++++++++++ include/ttl/bits/std_flat_tensor.hpp | 79 +++++++++++++++++++++++----- include/ttl/bits/std_raw_tensor.hpp | 6 +++ include/ttl/tensor | 8 ++- tests/test_flat_tensor.cpp | 9 +++- 5 files changed, 118 insertions(+), 15 deletions(-) create mode 100644 include/ttl/bits/std_allocator.hpp diff --git a/include/ttl/bits/std_allocator.hpp b/include/ttl/bits/std_allocator.hpp new file mode 100644 index 0000000..3810599 --- /dev/null +++ b/include/ttl/bits/std_allocator.hpp @@ -0,0 +1,31 @@ +#pragma once +#include + +namespace ttl +{ +namespace internal +{ +template using own_ptr = std::unique_ptr; + +template class ref_ptr +{ + R *ptr_; + + public: + ref_ptr(R *ptr) : ptr_(ptr) {} + + R *get() const { return ptr_; } +}; + +template class view_ptr +{ + const R *ptr_; + + public: + view_ptr(R *ptr) : ptr_(ptr) {} + + const R *get() const { return ptr_; } +}; + +} // namespace internal +} // namespace ttl diff --git a/include/ttl/bits/std_flat_tensor.hpp b/include/ttl/bits/std_flat_tensor.hpp index 720fc0d..8b97fda 100644 --- a/include/ttl/bits/std_flat_tensor.hpp +++ b/include/ttl/bits/std_flat_tensor.hpp @@ -4,6 +4,7 @@ #include #include +#include #include #include @@ -12,25 +13,21 @@ namespace ttl namespace internal { -template > -class basic_flat_tensor +template +class abstract_flat_tensor { const shape_t shape_; - std::unique_ptr data_; + data_holder_t data_; - public: - using value_type = R; - using shape_type = shape_t; - - template - explicit basic_flat_tensor(D... d) : basic_flat_tensor(shape_t(d...)) + protected: + explicit abstract_flat_tensor(const shape_t shape, R *data) + : shape_(shape), data_(data) { } - explicit basic_flat_tensor(const shape_t &shape) - : shape_(shape), data_(new R[shape_.size()]) - { - } + public: + using value_type = R; + using shape_type = shape_t; shape_t shape() const { return shape_; } @@ -56,5 +53,61 @@ class basic_flat_tensor } }; +template > +class basic_flat_tensor : public abstract_flat_tensor> +{ + public: + template + explicit basic_flat_tensor(D... d) : basic_flat_tensor(shape_t(d...)) + { + } + + explicit basic_flat_tensor(const shape_t &shape) + : abstract_flat_tensor>(shape, + new R[shape.size()]) + { + } +}; + +template > +class basic_flat_tensor_ref + : public abstract_flat_tensor> +{ + public: + template + explicit basic_flat_tensor_ref(R *data, D... d) + : basic_flat_tensor_ref(data, shape_t(d...)) + { + } + + explicit basic_flat_tensor_ref(R *data, const shape_t &shape) + : abstract_flat_tensor>(shape, data) + { + } +}; + +template +basic_flat_tensor_ref ref(const basic_flat_tensor &t) +{ + return basic_flat_tensor_ref(t.data(), t.shape()); +} + +template > +class basic_flat_tensor_view + : public abstract_flat_tensor> +{ + public: + template + explicit basic_flat_tensor_view(const R *data, D... d) + : basic_flat_tensor_view(data, shape_t(d...)) + { + } + + explicit basic_flat_tensor_view(const R *data, const shape_t &shape) + : abstract_flat_tensor>(shape, data) + { + } +}; + } // namespace internal } // namespace ttl diff --git a/include/ttl/bits/std_raw_tensor.hpp b/include/ttl/bits/std_raw_tensor.hpp index 5f64822..1ff9da0 100644 --- a/include/ttl/bits/std_raw_tensor.hpp +++ b/include/ttl/bits/std_raw_tensor.hpp @@ -4,6 +4,7 @@ #include #include +#include #include #include @@ -65,6 +66,11 @@ class basic_raw_tensor return ranked_as>(); } + template basic_flat_tensor_ref typed_as() const + { + return basic_flat_tensor_ref(data(), shape_); + } + private: template T ranked_as() const { diff --git a/include/ttl/tensor b/include/ttl/tensor index b7ae44b..a83bef5 100644 --- a/include/ttl/tensor +++ b/include/ttl/tensor @@ -32,7 +32,13 @@ namespace ttl namespace experimental { template using flat_tensor = internal::basic_flat_tensor; -} + +template +using flat_tensor_ref = internal::basic_flat_tensor_ref; + +template +using flat_tensor_view = internal::basic_flat_tensor_view; +} // namespace experimental } // namespace ttl #include diff --git a/tests/test_flat_tensor.cpp b/tests/test_flat_tensor.cpp index e56afa7..c8de8f9 100644 --- a/tests/test_flat_tensor.cpp +++ b/tests/test_flat_tensor.cpp @@ -13,8 +13,12 @@ TEST(flat_tensor_test, test1) ASSERT_EQ(t.shape().size(), static_cast(1)); t.ref_as<0>(); t.view_as<0>(); - + t.data(); static_assert(std::is_same::value, ""); + + const auto r = ref(t); + r.ref_as<0>(); + r.view_as<0>(); } { flat_tensor t(1); @@ -23,6 +27,7 @@ TEST(flat_tensor_test, test1) ASSERT_EQ(t.shape().size(), static_cast(1)); t.ref_as<1>(); t.view_as<1>(); + t.data(); } { flat_tensor t(1, 2); @@ -31,6 +36,7 @@ TEST(flat_tensor_test, test1) ASSERT_EQ(t.shape().size(), static_cast(2)); t.ref_as<2>(); t.view_as<2>(); + t.data(); } { flat_tensor t(1, 2, 3); @@ -39,5 +45,6 @@ TEST(flat_tensor_test, test1) ASSERT_EQ(t.shape().size(), static_cast(6)); t.ref_as<3>(); t.view_as<3>(); + t.data(); } } From a1ba6fcab5bcf695c4de2d2294084df89bf44590 Mon Sep 17 00:00:00 2001 From: lg Date: Sat, 8 Dec 2018 19:47:27 +0800 Subject: [PATCH 3/9] init raw_tensor_ref and raw_tensor_view --- .gitignore | 3 ++ include/ttl/bits/std_raw_tensor.hpp | 64 ++++++++++++++++++++++++++++- include/ttl/tensor | 8 +++- 3 files changed, 73 insertions(+), 2 deletions(-) diff --git a/.gitignore b/.gitignore index f5bd7ca..681bb39 100644 --- a/.gitignore +++ b/.gitignore @@ -32,6 +32,9 @@ *.app *.log +# VIM +*.swp + /3rdparty /bin /libgtest-dev-prefix diff --git a/include/ttl/bits/std_raw_tensor.hpp b/include/ttl/bits/std_raw_tensor.hpp index 1ff9da0..3c9b29c 100644 --- a/include/ttl/bits/std_raw_tensor.hpp +++ b/include/ttl/bits/std_raw_tensor.hpp @@ -14,7 +14,15 @@ namespace internal { template > -class basic_raw_tensor +class basic_raw_tensor; + +template > +class basic_raw_tensor_ref; + +template > +class basic_raw_tensor_view; + +template class basic_raw_tensor { using value_type_t = typename DataEncoder::value_type; @@ -79,5 +87,59 @@ class basic_raw_tensor } }; +template class basic_raw_tensor_ref +{ + using value_type_t = typename DataEncoder::value_type; + + const value_type_t value_type_; + const shape_t shape_; + + void *const data_; + + public: + using encoder_type = DataEncoder; + using shape_type = shape_t; + + template + explicit basic_raw_tensor_ref(void *data, const value_type_t value_type, + D... d) + : basic_raw_tensor_ref(data, value_type, shape_t(d...)) + { + } + + explicit basic_raw_tensor_ref(void *data, const value_type_t value_type, + const shape_t &shape) + : value_type_(value_type), shape_(shape), data_(data) + { + } +}; + +template class basic_raw_tensor_view +{ + using value_type_t = typename DataEncoder::value_type; + + const value_type_t value_type_; + const shape_t shape_; + + const void *const data_; + + public: + using encoder_type = DataEncoder; + using shape_type = shape_t; + + template + explicit basic_raw_tensor_view(void *data, const value_type_t value_type, + D... d) + : basic_raw_tensor_view(data, value_type, shape_t(d...)) + { + } + + explicit basic_raw_tensor_view(void *data, const value_type_t value_type, + const shape_t &shape) + : value_type_(value_type), shape_(shape), data_(data) + { + } +}; + } // namespace internal } // namespace ttl diff --git a/include/ttl/tensor b/include/ttl/tensor index a83bef5..9f69479 100644 --- a/include/ttl/tensor +++ b/include/ttl/tensor @@ -51,5 +51,11 @@ namespace experimental { using raw_tensor = internal::basic_raw_tensor< std::experimental::basic_type_encoder>; -} + +using raw_tensor_ref = internal::basic_raw_tensor_ref< + std::experimental::basic_type_encoder>; + +using raw_tensor_view = internal::basic_raw_tensor_view< + std::experimental::basic_type_encoder>; +} // namespace experimental } // namespace ttl From 19ef47166174a1035fc68c4f00d6f4bd2d529067 Mon Sep 17 00:00:00 2001 From: lg Date: Mon, 11 Feb 2019 18:26:21 +0800 Subject: [PATCH 4/9] new C API :: new_tensor1 --- examples/example_c_api.c | 11 +++++++++-- include/tensor.h | 3 +++ src/tensor.cpp | 10 ++++++++++ tests/test_tensor_c_api.cpp | 13 +++++++++++++ 4 files changed, 35 insertions(+), 2 deletions(-) diff --git a/examples/example_c_api.c b/examples/example_c_api.c index e5dc91c..e378b71 100644 --- a/examples/example_c_api.c +++ b/examples/example_c_api.c @@ -3,7 +3,14 @@ int main() { - tensor_t *pt = new_tensor(dtypes.u8, 1, 1); - del_tensor(pt); + { + tensor_t *pt = new_tensor(dtypes.u8, 1, 1); + del_tensor(pt); + } + { + int dims[1] = {1}; + tensor_t *pt = new_tensor1(dtypes.u8, 1, dims); + del_tensor(pt); + } return 0; } diff --git a/include/tensor.h b/include/tensor.h index 4574615..44325e4 100644 --- a/include/tensor.h +++ b/include/tensor.h @@ -23,6 +23,9 @@ typedef struct tensor_s tensor_t; extern tensor_t *new_tensor(uint8_t /*! value_type */, int /*! rank */, ...); +extern tensor_t *new_tensor1(uint8_t /*! value_type */, int /*! rank */, + const int * /* dims */); + extern void del_tensor(const tensor_t * /*! p_tensor_t */); #ifdef __cplusplus diff --git a/src/tensor.cpp b/src/tensor.cpp index d552820..7b469a6 100644 --- a/src/tensor.cpp +++ b/src/tensor.cpp @@ -37,4 +37,14 @@ tensor_t *new_tensor(uint8_t value_type, int rank, ...) return new tensor_s(value_type, shape); } +tensor_t *new_tensor1(uint8_t value_type, int rank, const int *_dims) +{ + using raw_shape = raw_tensor::shape_type; + using dim_t = raw_shape::dimension_type; + std::vector dims(rank); + std::copy(_dims, _dims + rank, dims.begin()); + raw_shape shape(dims); + return new tensor_s(value_type, shape); +} + void del_tensor(const tensor_t *pt) { delete pt; } diff --git a/tests/test_tensor_c_api.cpp b/tests/test_tensor_c_api.cpp index 408c08b..a5f1bc5 100644 --- a/tests/test_tensor_c_api.cpp +++ b/tests/test_tensor_c_api.cpp @@ -17,8 +17,21 @@ TEST(c_api_test, test1) tensor_t *pt = new_tensor(dt, 2, 2, 3); del_tensor(pt); } + { + int dims[1] = {1}; + tensor_t *pt = new_tensor1(dt, 1, dims); + del_tensor(pt); + } + { + int dims[2] = {2, 3}; + tensor_t *pt = new_tensor1(dt, 2, dims); + del_tensor(pt); + } } +} +TEST(c_api_test, test2) +{ using scalar_encoding = raw_tensor::encoder_type; ASSERT_EQ(scalar_encoding::value(), dtypes.u8); From a288333051b75290ccfa2764eefa8b22add3d69e Mon Sep 17 00:00:00 2001 From: lg Date: Tue, 12 Feb 2019 05:00:55 +0800 Subject: [PATCH 5/9] new C API :: tensor_data --- include/tensor.h | 2 ++ include/ttl/bits/std_raw_tensor.hpp | 2 ++ src/tensor.cpp | 2 ++ 3 files changed, 6 insertions(+) diff --git a/include/tensor.h b/include/tensor.h index 44325e4..13a1700 100644 --- a/include/tensor.h +++ b/include/tensor.h @@ -28,6 +28,8 @@ extern tensor_t *new_tensor1(uint8_t /*! value_type */, int /*! rank */, extern void del_tensor(const tensor_t * /*! p_tensor_t */); +extern void *tensor_data(tensor_t * /*! p_tensor_t */); + #ifdef __cplusplus } #endif diff --git a/include/ttl/bits/std_raw_tensor.hpp b/include/ttl/bits/std_raw_tensor.hpp index 3f7b937..9da41f2 100644 --- a/include/ttl/bits/std_raw_tensor.hpp +++ b/include/ttl/bits/std_raw_tensor.hpp @@ -49,6 +49,8 @@ class basic_raw_tensor return reinterpret_cast(data_.get()); } + void *data() const { return data_.get(); } + template > basic_tensor_ref ref_as() const { diff --git a/src/tensor.cpp b/src/tensor.cpp index 7b469a6..770f3ea 100644 --- a/src/tensor.cpp +++ b/src/tensor.cpp @@ -48,3 +48,5 @@ tensor_t *new_tensor1(uint8_t value_type, int rank, const int *_dims) } void del_tensor(const tensor_t *pt) { delete pt; } + +void *tensor_data(tensor_t *pt) { return pt->data(); } From df490a99bb50312b02f30d4e57fc336ccf3450d2 Mon Sep 17 00:00:00 2001 From: lg Date: Mon, 8 Apr 2019 16:43:06 +0800 Subject: [PATCH 6/9] converting constructors --- include/ttl/bits/std_raw_shape.hpp | 14 ++++++++++++++ include/ttl/bits/std_raw_tensor.hpp | 14 ++++++++++++++ tests/test_raw_tensor.cpp | 25 +++++++++++++++++++++++-- 3 files changed, 51 insertions(+), 2 deletions(-) diff --git a/include/ttl/bits/std_raw_shape.hpp b/include/ttl/bits/std_raw_shape.hpp index 465a2f6..6f161bf 100644 --- a/include/ttl/bits/std_raw_shape.hpp +++ b/include/ttl/bits/std_raw_shape.hpp @@ -11,6 +11,14 @@ namespace ttl { namespace internal { +template +std::vector arr2vec(const std::array &a) +{ + std::vector v(r); + std::copy(a.begin(), a.end(), v.begin()); + return v; +} + template class basic_raw_shape { using dim_t = Dim; @@ -26,6 +34,12 @@ template class basic_raw_shape explicit basic_raw_shape(const std::vector &dims) : dims(dims) {} + template + explicit basic_raw_shape(const basic_shape &shape) + : dims(std::move(arr2vec(shape.dims))) + { + } + rank_t rank() const { return dims.size(); } dim_t size() const diff --git a/include/ttl/bits/std_raw_tensor.hpp b/include/ttl/bits/std_raw_tensor.hpp index 3c9b29c..aee0363 100644 --- a/include/ttl/bits/std_raw_tensor.hpp +++ b/include/ttl/bits/std_raw_tensor.hpp @@ -112,6 +112,13 @@ template class basic_raw_tensor_ref : value_type_(value_type), shape_(shape), data_(data) { } + + template + explicit basic_raw_tensor_ref(const basic_tensor_ref &t) + : value_type_(DataEncoder::template value()), shape_(t.shape()), + data_(t.data()) + { + } }; template class basic_raw_tensor_view @@ -139,6 +146,13 @@ template class basic_raw_tensor_view : value_type_(value_type), shape_(shape), data_(data) { } + + template + explicit basic_raw_tensor_view(const basic_tensor_view &t) + : value_type_(DataEncoder::template value()), shape_(t.shape()), + data_(t.data()) + { + } }; } // namespace internal diff --git a/tests/test_raw_tensor.cpp b/tests/test_raw_tensor.cpp index 58f80f6..8dee73e 100644 --- a/tests/test_raw_tensor.cpp +++ b/tests/test_raw_tensor.cpp @@ -2,10 +2,10 @@ #include -using ttl::experimental::raw_tensor; - TEST(raw_tensor_test, test1) { + using ttl::experimental::raw_tensor; + using encoder = raw_tensor::encoder_type; using raw_shape = raw_tensor::shape_type; @@ -42,3 +42,24 @@ TEST(raw_tensor_test, test1) t.view_as(); } } + +TEST(raw_tensor_test, test_convert) +{ + using ttl::experimental::raw_tensor_ref; + using ttl::experimental::raw_tensor_view; + + ttl::tensor t(10, 224, 244, 3); + { + raw_tensor_ref r(ref(t)); + raw_tensor_view v(view(t)); + } + { + ttl::tensor_ref rt = ref(t); + raw_tensor_ref r(rt); + raw_tensor_view v(view(rt)); + } + { + ttl::tensor_view vt = view(t); + raw_tensor_view v(vt); + } +} From 4f214875a0c4057444d8f1daf2b3aa89311b7bb8 Mon Sep 17 00:00:00 2001 From: lg Date: Tue, 9 Apr 2019 15:16:17 +0800 Subject: [PATCH 7/9] raw_ref and raw_view --- include/ttl/tensor | 12 ++++++++++++ tests/test_raw_tensor.cpp | 12 ++++++++++++ 2 files changed, 24 insertions(+) diff --git a/include/ttl/tensor b/include/ttl/tensor index 9f69479..defaea0 100644 --- a/include/ttl/tensor +++ b/include/ttl/tensor @@ -1,4 +1,6 @@ +// # -*- mode: c++ -*- #pragma once + #include namespace ttl @@ -57,5 +59,15 @@ using raw_tensor_ref = internal::basic_raw_tensor_ref< using raw_tensor_view = internal::basic_raw_tensor_view< std::experimental::basic_type_encoder>; + +template raw_tensor_ref raw_ref(const T &t) +{ + return raw_tensor_ref(ref(t)); +} + +template raw_tensor_view raw_view(const T &t) +{ + return raw_tensor_view(view(t)); +} } // namespace experimental } // namespace ttl diff --git a/tests/test_raw_tensor.cpp b/tests/test_raw_tensor.cpp index 8dee73e..2cf3dd2 100644 --- a/tests/test_raw_tensor.cpp +++ b/tests/test_raw_tensor.cpp @@ -45,6 +45,9 @@ TEST(raw_tensor_test, test1) TEST(raw_tensor_test, test_convert) { + using ttl::experimental::raw_ref; + using ttl::experimental::raw_view; + using ttl::experimental::raw_tensor_ref; using ttl::experimental::raw_tensor_view; @@ -52,14 +55,23 @@ TEST(raw_tensor_test, test_convert) { raw_tensor_ref r(ref(t)); raw_tensor_view v(view(t)); + + raw_tensor_ref r1 = raw_ref(t); + raw_tensor_view v1 = raw_view(t); } { ttl::tensor_ref rt = ref(t); + raw_tensor_ref r(rt); raw_tensor_view v(view(rt)); + + raw_tensor_ref r1 = raw_ref(rt); + raw_tensor_view v1 = raw_view(rt); } { ttl::tensor_view vt = view(t); + raw_tensor_view v(vt); + raw_tensor_view v1 = raw_view(vt); } } From d573da2e00b126c7a6d453cde4ffe84be46cc440 Mon Sep 17 00:00:00 2001 From: lg Date: Tue, 9 Apr 2019 16:41:43 +0800 Subject: [PATCH 8/9] ranked_as for basic_raw_tensor_ref and basic_raw_tensor_view --- include/ttl/bits/std_raw_tensor.hpp | 30 +++++++++++++++++++++++++++++ tests/test_raw_tensor.cpp | 6 +++++- 2 files changed, 35 insertions(+), 1 deletion(-) diff --git a/include/ttl/bits/std_raw_tensor.hpp b/include/ttl/bits/std_raw_tensor.hpp index aee0363..cc7133f 100644 --- a/include/ttl/bits/std_raw_tensor.hpp +++ b/include/ttl/bits/std_raw_tensor.hpp @@ -96,6 +96,15 @@ template class basic_raw_tensor_ref void *const data_; + template R *data() const + { + // TODO: use contracts of c++20 + if (DataEncoder::template value() != value_type_) { + throw std::invalid_argument("invalid scalar type"); + } + return reinterpret_cast(data_); + } + public: using encoder_type = DataEncoder; using shape_type = shape_t; @@ -119,6 +128,12 @@ template class basic_raw_tensor_ref data_(t.data()) { } + + template basic_tensor_ref ranked_as() const + { + return basic_tensor_ref(data(), + shape_.template as_ranked()); + } }; template class basic_raw_tensor_view @@ -130,6 +145,15 @@ template class basic_raw_tensor_view const void *const data_; + template const R *data() const + { + // TODO: use contracts of c++20 + if (DataEncoder::template value() != value_type_) { + throw std::invalid_argument("invalid scalar type"); + } + return reinterpret_cast(data_); + } + public: using encoder_type = DataEncoder; using shape_type = shape_t; @@ -153,6 +177,12 @@ template class basic_raw_tensor_view data_(t.data()) { } + + template basic_tensor_view ranked_as() const + { + return basic_tensor_view(data(), + shape_.template as_ranked()); + } }; } // namespace internal diff --git a/tests/test_raw_tensor.cpp b/tests/test_raw_tensor.cpp index 2cf3dd2..1aba413 100644 --- a/tests/test_raw_tensor.cpp +++ b/tests/test_raw_tensor.cpp @@ -51,13 +51,17 @@ TEST(raw_tensor_test, test_convert) using ttl::experimental::raw_tensor_ref; using ttl::experimental::raw_tensor_view; - ttl::tensor t(10, 224, 244, 3); + using R = float; + ttl::tensor t(10, 224, 244, 3); { raw_tensor_ref r(ref(t)); raw_tensor_view v(view(t)); raw_tensor_ref r1 = raw_ref(t); raw_tensor_view v1 = raw_view(t); + + ttl::tensor_ref _tr = r.ranked_as(); + ttl::tensor_view _tv = v.ranked_as(); } { ttl::tensor_ref rt = ref(t); From 382047ee7509b47473bf06b46698e83d3c891011 Mon Sep 17 00:00:00 2001 From: lg Date: Fri, 12 Apr 2019 19:29:32 +0800 Subject: [PATCH 9/9] -Werror --- CMakeLists.txt | 4 +++- tests/test_raw_tensor.cpp | 2 ++ tests/testing.hpp | 7 +++++++ 3 files changed, 12 insertions(+), 1 deletion(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index b9a0676..7070d81 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -2,8 +2,10 @@ CMAKE_MINIMUM_REQUIRED(VERSION 3.5) PROJECT(stdtensor) SET(CMAKE_CXX_STANDARD 14) -ADD_DEFINITIONS(-Wfatal-errors) + ADD_DEFINITIONS(-Wall) +ADD_DEFINITIONS(-Werror) +ADD_DEFINITIONS(-Wfatal-errors) ADD_LIBRARY(stdtensor src/tensor.cpp) TARGET_INCLUDE_DIRECTORIES(stdtensor PRIVATE ${CMAKE_SOURCE_DIR}/include) diff --git a/tests/test_raw_tensor.cpp b/tests/test_raw_tensor.cpp index 1aba413..b004b25 100644 --- a/tests/test_raw_tensor.cpp +++ b/tests/test_raw_tensor.cpp @@ -61,7 +61,9 @@ TEST(raw_tensor_test, test_convert) raw_tensor_view v1 = raw_view(t); ttl::tensor_ref _tr = r.ranked_as(); + UNUSED(_tr); ttl::tensor_view _tv = v.ranked_as(); + UNUSED(_tv); } { ttl::tensor_ref rt = ref(t); diff --git a/tests/testing.hpp b/tests/testing.hpp index d36cc62..686545c 100644 --- a/tests/testing.hpp +++ b/tests/testing.hpp @@ -1,2 +1,9 @@ #pragma once #include // TODO: don't depend on gtest + +inline void make_unuse(void *) {} + +#define UNUSED(e) \ + { \ + make_unuse(&e); \ + }