diff --git a/src/core/dev_api/openvino/core/type/element_iterator.hpp b/src/core/dev_api/openvino/core/type/element_iterator.hpp index 7f042104847905..aed11325447db2 100644 --- a/src/core/dev_api/openvino/core/type/element_iterator.hpp +++ b/src/core/dev_api/openvino/core/type/element_iterator.hpp @@ -67,6 +67,16 @@ constexpr bool is_byte_type(Type_t et) { return !is_bit_type(et) && !is_split_bit_type(et) && !is_nibble_type(et) && et != string; } +/** + * @brief Checks if type is packet in byte from LSB -> MSB order. + * + * @param et Element type to check. + * @return True if type is packet LSB first, false otherwise. + */ +constexpr bool is_lsb_packed(Type_t et) { + return et != u1; +} + /** * @brief Gets bit width of ov::element::Type_t. * @@ -139,16 +149,17 @@ class BitProxy {}; * @tparam ET OpenVINO element type. */ template -class BitProxy::type> { +class BitProxy> { private: template friend class Iterator; //!< Iterator class is friend to access private members to manipulate pointer. - using Bits = typename std::conditional::value, const uint8_t, uint8_t>::type; + using Bits = std::conditional_t, const uint8_t, uint8_t>; - static constexpr size_t m_bits = bit_width(); //!< Number of bit for single value. - static constexpr size_t m_num_values = 8 / m_bits; //!< Number values in byte. - static constexpr size_t m_shift_init = is_nibble_type(ET) ? 0 : 8 - m_bits; //!< Initial value for bit shift. + static constexpr size_t m_bits = bit_width(); //!< Number of bit for single value. + static constexpr size_t m_num_values = 8 / m_bits; //!< Number values in byte. + static constexpr size_t m_shift_init = is_lsb_packed(ET) ? 0 : 8 - m_bits; //!< Initial value for bit shift. + static constexpr size_t m_shift_last = is_lsb_packed(ET) ? 8 - m_bits : 0; //!< Last value for bit shift. Bits* m_ptr; //!< Pointer to T as Bits used to get value from bits. size_t m_bit_shift; //!< Current bit shift to get value. @@ -167,7 +178,7 @@ class BitProxy::type; //!< Fundamental type of bound to BitProxy. + using value_type = std::decay_t; //!< Fundamental type of bound to BitProxy. /** * @brief Compare proxy value with other provided value. @@ -196,7 +207,7 @@ class BitProxy::type* = nullptr> + template * = nullptr> operator value_type() const { return static_cast(get_bit_value()); } @@ -206,7 +217,7 @@ class BitProxy::type* = nullptr> + template * = nullptr> operator value_type() const { return value_type::from_bits(get_bit_value()); } @@ -219,12 +230,12 @@ class BitProxy::type* = nullptr> + template * = nullptr> operator float() const { return ConvertNF4::dequantize(get_bit_value()); } - template ::type* = nullptr> + template * = nullptr> operator float() const { return static_cast(float4_e2m1::from_bits(get_bit_value())); } @@ -234,7 +245,7 @@ class BitProxy::type* = nullptr> + template * = nullptr> operator value_type() const { constexpr auto value_mask = util::make_n_bit_mask(m_bits); constexpr auto value_msb_mask = (1U << (m_bits - 1U)); @@ -252,7 +263,7 @@ class BitProxy::type* = nullptr> + template * = nullptr> BitProxy& operator=(const value_type v) { constexpr auto value_mask = util::make_n_bit_mask(m_bits); set_bit_value(static_cast(v) & value_mask); @@ -263,7 +274,7 @@ class BitProxy::type* = nullptr> + template * = nullptr> BitProxy& operator=(const value_type v) { set_bit_value(v.to_bits()); return *this; @@ -273,7 +284,7 @@ class BitProxy::type* = nullptr> + template * = nullptr> BitProxy& operator=(const float v) { set_bit_value(ConvertNF4::quantize(v)); return *this; @@ -289,7 +300,7 @@ class BitProxy -class BitProxy::type> { +class BitProxy> { private: template friend class Iterator; //!< Iterator class is friend to access private members to manipulate pointer. @@ -314,7 +325,7 @@ class BitProxy::type> { constexpr BitProxy(T* ptr) noexcept : m_ptr{ptr}, m_bit_shift{m_shift_init} {} public: - using value_type = typename std::decay::type; //!< Fundamental type of sub-byte. + using value_type = std::decay_t; //!< Fundamental type of sub-byte. /** * @brief Compare proxy value is equal than rhs. @@ -411,41 +422,38 @@ class Iterator { using iterator_category = std::bidirectional_iterator_tag; using difference_type = std::ptrdiff_t; using value_type = T; - using reference = typename std::conditional::value, const proxy_type&, proxy_type&>::type; - using pointer = typename std::conditional::value, const proxy_type*, proxy_type*>::type; + using reference = std::conditional_t::value, const proxy_type&, proxy_type&>; + using pointer = std::conditional_t::value, const proxy_type*, proxy_type*>; - static_assert(std::is_same::type, ov::fundamental_type_for>::value, + static_assert(std::is_same_v, ov::fundamental_type_for>, "Iterator value_type must be same as fundamental type of ET"); constexpr Iterator(T* ptr) noexcept : m_et_ptr{ptr} {} template constexpr Iterator(U* ptr) noexcept : m_et_ptr{reinterpret_cast(ptr)} { - static_assert(std::is_same::type, int8_t>::value, + static_assert(std::is_same_v, int8_t>, "User type must be int8_t as base type for LP ET"); } // Iteration operators - template - typename std::enable_if>::type& operator++() { - m_et_ptr.m_bit_shift -= m_et_ptr.m_bits; - m_et_ptr.m_bit_shift = m_et_ptr.m_bit_shift % (m_et_ptr.m_num_values * m_et_ptr.m_bits); - m_et_ptr.m_ptr += static_cast(m_et_ptr.m_bit_shift == m_et_ptr.m_shift_init); - return *this; - } - - template - typename std::enable_if>::type& operator++() { - m_et_ptr.m_bit_shift ^= m_et_ptr.m_bits; - m_et_ptr.m_ptr += static_cast(m_et_ptr.m_bit_shift == m_et_ptr.m_shift_init); - return *this; - } - - template - typename std::enable_if>::type& operator++() { - --m_et_ptr.m_bit_shift; - m_et_ptr.m_bit_shift = m_et_ptr.m_bit_shift % m_et_ptr.m_num_values; - m_et_ptr.m_ptr += (m_et_ptr.m_bit_shift == m_et_ptr.m_shift_init) ? 3 : 0; + Iterator& operator++() { + if constexpr (is_nibble_type(ET)) { + m_et_ptr.m_bit_shift ^= m_et_ptr.m_bits; + m_et_ptr.m_ptr += static_cast(m_et_ptr.m_bit_shift == m_et_ptr.m_shift_init); + } else if constexpr (is_split_bit_type(ET)) { + --m_et_ptr.m_bit_shift; + m_et_ptr.m_bit_shift = m_et_ptr.m_bit_shift % m_et_ptr.m_num_values; + m_et_ptr.m_ptr += (m_et_ptr.m_bit_shift == m_et_ptr.m_shift_init) ? 3 : 0; + } else { + if constexpr (is_lsb_packed(ET)) { + m_et_ptr.m_bit_shift += m_et_ptr.m_bits; + } else { + m_et_ptr.m_bit_shift -= m_et_ptr.m_bits; + } + m_et_ptr.m_bit_shift = m_et_ptr.m_bit_shift % (m_et_ptr.m_num_values * m_et_ptr.m_bits); + m_et_ptr.m_ptr += static_cast(m_et_ptr.m_bit_shift == m_et_ptr.m_shift_init); + } return *this; } @@ -455,25 +463,25 @@ class Iterator { return old; } - template - typename std::enable_if>::type& operator+=(const difference_type& n) { - const auto advance = n + (m_et_ptr.m_shift_init - m_et_ptr.m_bit_shift) / m_et_ptr.m_bits; - m_et_ptr.m_bit_shift = m_et_ptr.m_shift_init - (advance % m_et_ptr.m_num_values) * m_et_ptr.m_bits; - m_et_ptr.m_ptr += advance / m_et_ptr.m_num_values; - return *this; - } - - template - typename std::enable_if>::type& operator+=(const difference_type& n) { - m_et_ptr.m_ptr += n / m_et_ptr.m_num_values; - return (n % m_et_ptr.m_num_values) ? ++*this : *this; - } - - template - typename std::enable_if>::type& operator+=(const difference_type& n) { - const auto advance = n + m_et_ptr.m_shift_init - m_et_ptr.m_bit_shift; - m_et_ptr.m_bit_shift = m_et_ptr.m_shift_init - (advance % m_et_ptr.m_num_values); - m_et_ptr.m_ptr += 3 * (advance / m_et_ptr.m_num_values); + Iterator& operator+=(const difference_type& n) { + if constexpr (is_nibble_type(ET)) { + m_et_ptr.m_ptr += n / m_et_ptr.m_num_values; + if (n % m_et_ptr.m_num_values) { + ++*this; + } + } else if constexpr (is_split_bit_type(ET)) { + const auto advance = n + m_et_ptr.m_shift_init - m_et_ptr.m_bit_shift; + m_et_ptr.m_bit_shift = m_et_ptr.m_shift_init - (advance % m_et_ptr.m_num_values); + m_et_ptr.m_ptr += 3 * (advance / m_et_ptr.m_num_values); + } else if constexpr (is_lsb_packed(ET)) { + const auto advance = n + m_et_ptr.m_bit_shift / m_et_ptr.m_bits; + m_et_ptr.m_bit_shift = (advance % m_et_ptr.m_num_values) * m_et_ptr.m_bits; + m_et_ptr.m_ptr += advance / m_et_ptr.m_num_values; + } else { + const auto advance = n + (m_et_ptr.m_shift_init - m_et_ptr.m_bit_shift) / m_et_ptr.m_bits; + m_et_ptr.m_bit_shift = m_et_ptr.m_shift_init - (advance % m_et_ptr.m_num_values) * m_et_ptr.m_bits; + m_et_ptr.m_ptr += advance / m_et_ptr.m_num_values; + } return *this; } @@ -483,26 +491,23 @@ class Iterator { return tmp; } - template - typename std::enable_if>::type& operator--() { - m_et_ptr.m_bit_shift += m_et_ptr.m_bits; - m_et_ptr.m_bit_shift = m_et_ptr.m_bit_shift % (m_et_ptr.m_num_values * m_et_ptr.m_bits); - m_et_ptr.m_ptr -= static_cast(m_et_ptr.m_bit_shift == 0); - return *this; - } - - template - typename std::enable_if>::type& operator--() { - m_et_ptr.m_bit_shift ^= m_et_ptr.m_bits; - m_et_ptr.m_ptr -= static_cast(m_et_ptr.m_bit_shift == 4); - return *this; - } - - template - typename std::enable_if>::type& operator--() { - ++m_et_ptr.m_bit_shift; - m_et_ptr.m_bit_shift = m_et_ptr.m_bit_shift % m_et_ptr.m_num_values; - m_et_ptr.m_ptr -= m_et_ptr.m_bit_shift == 0 ? 3 : 0; + Iterator& operator--() { + if constexpr (is_nibble_type(ET)) { + m_et_ptr.m_bit_shift ^= m_et_ptr.m_bits; + m_et_ptr.m_ptr -= static_cast(m_et_ptr.m_bit_shift == 4); + } else if constexpr (is_split_bit_type(ET)) { + ++m_et_ptr.m_bit_shift; + m_et_ptr.m_bit_shift = m_et_ptr.m_bit_shift % m_et_ptr.m_num_values; + m_et_ptr.m_ptr -= m_et_ptr.m_bit_shift == 0 ? 3 : 0; + } else { + if constexpr (is_lsb_packed(ET)) { + m_et_ptr.m_bit_shift -= m_et_ptr.m_bits; + } else { + m_et_ptr.m_bit_shift += m_et_ptr.m_bits; + } + m_et_ptr.m_bit_shift = m_et_ptr.m_bit_shift % (m_et_ptr.m_num_values * m_et_ptr.m_bits); + m_et_ptr.m_ptr -= static_cast(m_et_ptr.m_bit_shift == m_et_ptr.m_shift_last); + } return *this; } @@ -512,25 +517,25 @@ class Iterator { return old; } - template - typename std::enable_if>::type& operator-=(const difference_type& n) { - const auto advance = m_et_ptr.m_bit_shift / m_et_ptr.m_bits + n; - m_et_ptr.m_bit_shift = (advance % m_et_ptr.m_num_values) * m_et_ptr.m_bits; - m_et_ptr.m_ptr -= advance / m_et_ptr.m_num_values; - return *this; - } - - template - typename std::enable_if>::type& operator-=(const difference_type& n) { - m_et_ptr.m_ptr -= n / m_et_ptr.m_num_values; - return (n % m_et_ptr.m_num_values) ? --*this : *this; - } - - template - typename std::enable_if>::type& operator-=(const difference_type& n) { - const auto advance = m_et_ptr.m_bit_shift + n; - m_et_ptr.m_bit_shift = advance % m_et_ptr.m_num_values; - m_et_ptr.m_ptr -= 3 * (advance / m_et_ptr.m_num_values); + Iterator& operator-=(const difference_type& n) { + if constexpr (is_nibble_type(ET)) { + m_et_ptr.m_ptr -= n / m_et_ptr.m_num_values; + if (n % m_et_ptr.m_num_values) { + --*this; + } + } else if constexpr (is_split_bit_type(ET)) { + const auto advance = m_et_ptr.m_bit_shift + n; + m_et_ptr.m_bit_shift = advance % m_et_ptr.m_num_values; + m_et_ptr.m_ptr -= 3 * (advance / m_et_ptr.m_num_values); + } else if constexpr (is_lsb_packed(ET)) { + const auto advance = n + (m_et_ptr.m_shift_last - m_et_ptr.m_bit_shift) / m_et_ptr.m_bits; + m_et_ptr.m_bit_shift = m_et_ptr.m_shift_last - (advance % m_et_ptr.m_num_values) * m_et_ptr.m_bits; + m_et_ptr.m_ptr -= advance / m_et_ptr.m_num_values; + } else { + const auto advance = m_et_ptr.m_bit_shift / m_et_ptr.m_bits + n; + m_et_ptr.m_bit_shift = (advance % m_et_ptr.m_num_values) * m_et_ptr.m_bits; + m_et_ptr.m_ptr -= advance / m_et_ptr.m_num_values; + } return *this; } diff --git a/src/core/src/op/constant.cpp b/src/core/src/op/constant.cpp index 5577481a8a799b..c358c48173772b 100644 --- a/src/core/src/op/constant.cpp +++ b/src/core/src/op/constant.cpp @@ -281,7 +281,9 @@ void Constant::set_unused_bits(void* buffer) const { if (element::is_bit_type(m_element_type)) { constexpr size_t storage_unit_byte_size = 1; const auto not_aligned_elements = num_elements % (8 / m_element_type.bitwidth()); - const uint8_t not_used_bits_mask = 0xff >> (m_element_type.bitwidth() * not_aligned_elements); + const uint8_t not_used_bits_mask = element::is_lsb_packed(m_element_type) + ? 0xff << (m_element_type.bitwidth() * not_aligned_elements) + : 0xff >> (m_element_type.bitwidth() * not_aligned_elements); reinterpret_cast(buffer)[byte_size - storage_unit_byte_size] &= ~not_used_bits_mask; } else if (element::is_nibble_type(m_element_type) && (num_elements % 2)) { constexpr size_t storage_unit_byte_size = 1; diff --git a/src/core/tests/constant.cpp b/src/core/tests/constant.cpp index c8c314f3ad624b..ff0f6b1c2edd66 100644 --- a/src/core/tests/constant.cpp +++ b/src/core/tests/constant.cpp @@ -866,17 +866,17 @@ TEST(constant, uint1_write_then_cast_custom_type) { TEST(constant, uint2_string) { const auto shape = Shape{4}; - op::v0::Constant c(element::u2, shape, vector{"3", "0", "1", "2"}); + op::v0::Constant c(element::u2, shape, vector{"2", "1", "0", "3"}); auto v = c.cast_vector(); ASSERT_EQ(v.size(), shape_size(shape)); - EXPECT_THAT(v, ElementsAre(3, 0, 1, 2)); + EXPECT_THAT(v, ElementsAre(2, 1, 0, 3)); const auto p = c.get_data_ptr(); EXPECT_EQ(p[0], 0b11000110); - EXPECT_EQ(c.convert_value_to_string(1), "0"); - EXPECT_THAT(c.get_value_strings(), ElementsAre("3", "0", "1", "2")); + EXPECT_EQ(c.convert_value_to_string(1), "1"); + EXPECT_THAT(c.get_value_strings(), ElementsAre("2", "1", "0", "3")); EXPECT_THROW(c.get_strides(), Exception); } @@ -891,7 +891,7 @@ TEST(constant, uint2_string_broadcast) { const auto p = c.get_data_ptr(); EXPECT_EQ(p[0], 0b01010101); - EXPECT_EQ(p[1] & 0b11000000, 0b01000000); + EXPECT_EQ(p[1], 0b00000001); } TEST(constant, uint2_vector_less_than_single_byte) { @@ -905,7 +905,7 @@ TEST(constant, uint2_vector_less_than_single_byte) { EXPECT_THAT(v, ElementsAre(2, 3, 1)); const auto p = c.get_data_ptr(); - EXPECT_EQ(p[0] & 0b11111100, 0b10110100); + EXPECT_EQ(p[0], 0b00011110); } TEST(constant, uint2_vector_bigger_than_single_byte) { @@ -919,20 +919,27 @@ TEST(constant, uint2_vector_bigger_than_single_byte) { EXPECT_THAT(v, ElementsAre(2, 3, 1, 0, 1, 2, 0)); const auto p = c.get_data_ptr(); - EXPECT_EQ(p[0], 0b10110100); - EXPECT_EQ(p[1] & 0b11111100, 0b01100000); + EXPECT_EQ(p[0], 0b00011110); + EXPECT_EQ(p[1], 0b00001001); } TEST(constant, uint2_vector_broadcast) { - const auto shape = Shape{3}; - op::v0::Constant c(element::u2, shape, vector{2}); + const auto shape = Shape{5}; + // Use dynamic allocation to check not used bits have deterministic value + auto constant = std::make_shared(element::u2, shape, vector{2}); + const auto& c = *constant; auto v = c.cast_vector(); ASSERT_EQ(v.size(), shape_size(shape)); EXPECT_THAT(v, Each(2)); const auto p = c.get_data_ptr(); - EXPECT_EQ(p[0] & 0b11111100, 0b10101000); + EXPECT_EQ(p[0], 0b10101010); + EXPECT_EQ(p[1], 0b00000010); + + const auto gv = c.get_vector(); + EXPECT_EQ(gv[0], 0b10101010); + EXPECT_EQ(gv[1], 0b00000010); } TEST(constant, uint2_write_then_cast_custom_type) { diff --git a/src/core/tests/element_iterator_test.cpp b/src/core/tests/element_iterator_test.cpp index 37d5fd05f86bed..0978d231ddced7 100644 --- a/src/core/tests/element_iterator_test.cpp +++ b/src/core/tests/element_iterator_test.cpp @@ -106,15 +106,15 @@ TEST(ElementIteratorTest, write_u2_data) { std::copy(input.begin(), input.end(), iter); - EXPECT_THAT(output, ElementsAre(0x87, 0x0f, 0x66, 0xe4)); + EXPECT_THAT(output, ElementsAre(0b11010010, 0b11110000, 0b10011001, 0b00011011)); } TEST(ElementIteratorTest, read_const_u2_data) { constexpr auto elements_count = 16; - constexpr auto input = std::array{static_cast(0x87), - 0x0f, - 0x66, - static_cast(0xe4)}; + constexpr auto input = std::array{static_cast(0b11010010), + static_cast(0b11110000), + static_cast(0b10011001), + static_cast(0b00011011)}; auto iter = element::iterator(input.data()); EXPECT_THAT(std::vector(iter, iter + elements_count), @@ -123,10 +123,10 @@ TEST(ElementIteratorTest, read_const_u2_data) { TEST(ElementIteratorTest, read_non_const_u2_data) { constexpr auto elements_count = 16; - auto input = std::array{static_cast(0x87), - 0x0f, - 0x66, - static_cast(0xe4)}; + auto input = std::array{static_cast(0b11010010), + static_cast(0b11110000), + static_cast(0b10011001), + static_cast(0b00011011)}; auto iter = element::iterator(input.data()); EXPECT_THAT(std::vector(iter, iter + elements_count), @@ -134,31 +134,39 @@ TEST(ElementIteratorTest, read_non_const_u2_data) { } TEST(ElementIteratorTest, read_u2_data_increment_decrement_iterator) { - auto input = std::array{0x33, static_cast(0x93)}; + auto input = std::array{static_cast(0b00100111), static_cast(0b10011011)}; auto iter = element::iterator(input.data() + 1); - EXPECT_EQ(*iter--, 2); // 2nd byte 1st half-nibble - EXPECT_EQ(*iter++, 3); // 1st byte 4th half-nibble - EXPECT_EQ(*++iter, 1); // 2nd byte 2nd half-nibble - EXPECT_EQ(*iter--, 1); // 2nd byte 2nd half-nibble - EXPECT_EQ(*--iter, 3); // 1st byte 4th half-nibble + EXPECT_EQ(*iter--, 3); // 2nd byte 4th half-nibble + EXPECT_EQ(*iter++, 0); // 1st byte 1st half-nibble + EXPECT_EQ(*++iter, 2); // 2nd byte 3rd half-nibble + EXPECT_EQ(*iter--, 2); // 2nd byte 3rdt half-nibble + EXPECT_EQ(*--iter, 0); // 1st byte 1st half-nibble + EXPECT_EQ(*--iter, 2); // 1st byte 2nd half-nibble } TEST(ElementIteratorTest, read_u2_data_iterator_with_offset) { - auto input = std::array{0x43, static_cast(0x93), 0x41}; + auto input = std::array{0b01000011, static_cast(0b100010011), 0b01000001}; auto iter = element::iterator(input.data() + 1); - EXPECT_EQ(*iter, 2); // 2nd byte 1st half-nibble - EXPECT_EQ(*(iter - 3), 0); // 1st byte 2nd half-nibble - EXPECT_EQ(*(iter - 4), 1); // 1st byte 1st half-nibble - EXPECT_EQ(*(iter + 1), 1); // 2nd byte 2nd half-nibble - EXPECT_EQ(*(iter + 7), 1); // 3rd byte 4th half-nibble - EXPECT_EQ(*std::prev(iter, 1), 3); // 1st byte 4th half-nibble - EXPECT_EQ(*std::next(iter, 2), 0); // 2nd byte 3rd half-nibble + EXPECT_EQ(*iter, 3); // 2nd byte 4th half-nibble + EXPECT_EQ(*(iter - 0), 3); // 2nd byte 4th half-nibble + EXPECT_EQ(*(iter - 1), 1); // 1st byte 1st half-nibble + EXPECT_EQ(*(iter - 2), 0); // 1st byte 2nd half-nibble + EXPECT_EQ(*(iter - 3), 0); // 1st byte 3rd half-nibble + EXPECT_EQ(*(iter - 4), 3); // 1st byte 4th half-nibble + EXPECT_EQ(*(iter + 0), 3); // 2nd byte 4th half-nibble + EXPECT_EQ(*(iter + 1), 0); // 2nd byte 3rd half-nibble + EXPECT_EQ(*(iter + 7), 1); // 3rd byte 1st half-nibble + EXPECT_EQ(*std::prev(iter, 1), 1); // 1st byte 4th half-nibble + EXPECT_EQ(*std::next(iter, 2), 1); // 2nd byte 2nd half-nibble + + --iter; + EXPECT_EQ(*(iter - 1), 0); // 1st byte 2nd half-nibble } TEST(ElementIteratorTest, u2_value_to_output_stream) { - constexpr auto value = static_cast(0x80); + constexpr auto value = static_cast(0x02); auto iter = element::iterator(&value); std::stringstream s; @@ -168,9 +176,10 @@ TEST(ElementIteratorTest, u2_value_to_output_stream) { } TEST(ElementIteratorTest, read_u2_from_tensor) { - auto input = std::array{0x32, static_cast(0xa3), 0x41, 0x11}; + const auto input = + std::array{static_cast(0b10001100), static_cast(0b11001010), 0b01000001, 0b01000100}; auto t = ov::Tensor(element::u2, Shape{4, 4}, input.data()); - auto iter = element::iterator(static_cast(t.data(element::u2))); + auto iter = element::iterator(static_cast(std::as_const(t).data(element::u2))); EXPECT_THAT(std::vector(iter, iter + t.get_size()), ElementsAre(0, 3, 0, 2, 2, 2, 0, 3, 1, 0, 0, 1, 0, 1, 0, 1)); @@ -211,9 +220,11 @@ TEST(ElementIteratorTest, read_u3_data_iterator_with_offset) { auto iter = element::iterator(input.data() + 3); EXPECT_EQ(*iter, 2); + EXPECT_EQ(*(iter - 0), 2); EXPECT_EQ(*(iter - 3), 6); EXPECT_EQ(*(iter - 4), 1); EXPECT_EQ(*(iter - 5), 6); + EXPECT_EQ(*(iter + 0), 2); EXPECT_EQ(*(iter + 1), 3); EXPECT_EQ(*(iter + 5), 5); EXPECT_EQ(*(iter + 7), 7); diff --git a/src/plugins/template/tests/functional/op_reference/convert_like.cpp b/src/plugins/template/tests/functional/op_reference/convert_like.cpp index 435fd24a09a0a1..4bd069ba418ba8 100644 --- a/src/plugins/template/tests/functional/op_reference/convert_like.cpp +++ b/src/plugins/template/tests/functional/op_reference/convert_like.cpp @@ -32,7 +32,7 @@ INSTANTIATE_TEST_SUITE_P( ov::element::u2, ov::element::boolean, std::vector{0b10010011}, - std::vector{1, 1, 0, 1}), + std::vector{1, 0, 1, 1}), ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape{8}, ov::element::u3, @@ -87,7 +87,7 @@ INSTANTIATE_TEST_SUITE_P( ov::element::u2, ov::element::bf16, std::vector{0b10010011}, - std::vector{2.0f, 1.0f, 0.0f, 3.0f}), + std::vector{3.0f, 0.0f, 1.0f, 2.0f}), ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape{8}, ov::element::u3, @@ -135,7 +135,7 @@ INSTANTIATE_TEST_SUITE_P( ov::element::u2, ov::element::f16, std::vector{0b10010011}, - std::vector{2.0f, 1.0f, 0.0f, 3.0f}), + std::vector{3.0f, 0.0f, 1.0f, 2.0f}), ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape{8}, ov::element::u3, @@ -199,7 +199,7 @@ INSTANTIATE_TEST_SUITE_P( ov::element::u2, ov::element::f32, std::vector{0b10010011}, - std::vector{2.0f, 1.0f, 0.0f, 3.0f}), + std::vector{3.0f, 0.0f, 1.0f, 2.0f}), ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape{8}, ov::element::u3, @@ -380,7 +380,7 @@ INSTANTIATE_TEST_SUITE_P( ov::element::u2, ov::element::i4, std::vector{0b10010011}, - std::vector{0x12, 0x30}), + std::vector{0x03, 0x21}), ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape{8}, ov::element::u3, @@ -483,7 +483,7 @@ INSTANTIATE_TEST_SUITE_P( ov::element::u2, ov::element::i8, std::vector{0b10010011}, - std::vector{2, 1, 0, 3}), + std::vector{3, 0, 1, 2}), ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape{8}, ov::element::u3, @@ -586,7 +586,7 @@ INSTANTIATE_TEST_SUITE_P( ov::element::u2, ov::element::i16, std::vector{0b10010011}, - std::vector{2, 1, 0, 3}), + std::vector{3, 0, 1, 2}), ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape{8}, ov::element::u3, @@ -689,7 +689,7 @@ INSTANTIATE_TEST_SUITE_P( ov::element::u2, ov::element::i32, std::vector{0b10010011}, - std::vector{2, 1, 0, 3}), + std::vector{3, 0, 1, 2}), ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape{8}, ov::element::u3, @@ -792,7 +792,7 @@ INSTANTIATE_TEST_SUITE_P( ov::element::u2, ov::element::i64, std::vector{0b10010011}, - std::vector{2, 1, 0, 3}), + std::vector{3, 0, 1, 2}), ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape{8}, ov::element::u3, @@ -896,7 +896,7 @@ INSTANTIATE_TEST_SUITE_P( ov::element::u2, ov::element::u1, std::vector{0b10010011, 0x00}, - std::vector{0b01010000}), + std::vector{0b10100000}), ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape{8}, ov::element::u3, @@ -1000,7 +1000,7 @@ INSTANTIATE_TEST_SUITE_P( ov::element::u2, ov::element::u4, std::vector{0b10010011}, - std::vector{0x12, 0x30}), + std::vector{0x03, 0x21}), ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape{8}, ov::element::u3, @@ -1104,7 +1104,7 @@ INSTANTIATE_TEST_SUITE_P( ov::element::u2, ov::element::u8, std::vector{0b10010011}, - std::vector{2, 1, 0, 3}), + std::vector{3, 0, 1, 2}), ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape{8}, ov::element::u3, @@ -1208,7 +1208,7 @@ INSTANTIATE_TEST_SUITE_P( ov::element::u2, ov::element::u16, std::vector{0b10010011}, - std::vector{2, 1, 0, 3}), + std::vector{3, 0, 1, 2}), ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape{8}, ov::element::u3, @@ -1312,7 +1312,7 @@ INSTANTIATE_TEST_SUITE_P( ov::element::u2, ov::element::u32, std::vector{0b10010011}, - std::vector{2, 1, 0, 3}), + std::vector{3, 0, 1, 2}), ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape{8}, ov::element::u3, @@ -1415,7 +1415,7 @@ INSTANTIATE_TEST_SUITE_P( ov::element::u2, ov::element::u64, std::vector{0b10010011}, - std::vector{2, 1, 0, 3}), + std::vector{3, 0, 1, 2}), ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape{8}, ov::element::u3, @@ -1525,103 +1525,103 @@ INSTANTIATE_TEST_SUITE_P( ov::element::boolean, ov::element::u2, std::vector{1, 0, 1, 1, 0, 1, 0, 0}, - std::vector{0b01000101, 0b00010000}), + std::vector{0b01010001, 0b00000100}), ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape{2, 4}, ov::element::u1, ov::element::u2, std::vector{0b11001011}, - std::vector{0x50, 0x45}), + std::vector{0x05, 0x51}), ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape{1, 8}, ov::element::u3, ov::element::u2, std::vector{0b00100111, 0b00011010, 0b00001000}, - std::vector{0b00100111, 0b00011010}), + std::vector{0b11011000, 0b10100100}), ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape{2, 4}, ov::element::u4, ov::element::u2, std::vector{0x21, 0x01, 0x31, 0xff}, - std::vector{0b01100100, 0b01111111}), + std::vector{0b00011001, 0b11111101}), ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape{1, 8}, ov::element::u6, ov::element::u2, std::vector{0x02, 0x13, 0x00, 0x81, 0x04, 0b01001011}, - std::vector{0b00100111, 0b00010000}), + std::vector{0b11011000, 0b00000100}), ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape{2, 4}, ov::element::u8, ov::element::u2, std::vector{0, 2, 1, 3, 4, 1, 2, 2}, - std::vector{0b00100111, 0b00011010}), + std::vector{0b11011000, 0b10100100}), ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape{2, 4}, ov::element::u16, ov::element::u2, std::vector{0, 2, 1, 3, 4, 1, 2, 2}, - std::vector{0b00100111, 0b00011010}), + std::vector{0b11011000, 0b10100100}), ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape{2, 4}, ov::element::u32, ov::element::u2, std::vector{0, 2, 1, 3, 4, 1, 2, 2}, - std::vector{0b00100111, 0b00011010}), + std::vector{0b11011000, 0b10100100}), ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape{2, 4}, ov::element::u64, ov::element::u2, std::vector{0, 2, 1, 3, 4, 1, 2, 2}, - std::vector{0b00100111, 0b00011010}), + std::vector{0b11011000, 0b10100100}), ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape{2, 4}, ov::element::i4, ov::element::u2, std::vector{0x21, 0x01, 0x31, 0xff}, - std::vector{0b01100100, 0b01111111}), + std::vector{0b00011001, 0b11111101}), ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape{2, 4}, ov::element::i8, ov::element::u2, std::vector{0, 2, 1, 3, 4, 1, 2, 2}, - std::vector{0b00100111, 0b00011010}), + std::vector{0b11011000, 0b10100100}), ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape{2, 4}, ov::element::i16, ov::element::u2, std::vector{0, 2, 1, 3, 4, 1, 2, 2}, - std::vector{0b00100111, 0b00011010}), + std::vector{0b11011000, 0b10100100}), ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape{2, 4}, ov::element::i32, ov::element::u2, std::vector{0, 2, 1, 3, 4, 1, 2, 2}, - std::vector{0b00100111, 0b00011010}), + std::vector{0b11011000, 0b10100100}), ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape{2, 4}, ov::element::i64, ov::element::u2, std::vector{0, 2, 1, 3, 4, 1, 2, 2}, - std::vector{0b00100111, 0b00011010}), + std::vector{0b11011000, 0b10100100}), ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape{1, 8}, ov::element::f8e4m3, ov::element::u2, std::vector{0.1f, 2.0f, 1.1f, 3.0f, 4.0f, 1.0f, 2.2f, 2.8f}, - std::vector{0b00100111, 0b00011010}), + std::vector{0b11011000, 0b10100100}), ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape{2, 4}, ov::element::f16, ov::element::u2, std::vector{0.1f, 2.0f, 1.1f, 3.0f, 4.0f, 1.0f, 2.2f, 2.8f}, - std::vector{0b00100111, 0b00011010}), + std::vector{0b11011000, 0b10100100}), ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape{2, 4}, ov::element::f32, ov::element::u2, std::vector{0.1f, 2.0f, 1.1f, 3.0f, 4.0f, 1.0f, 2.2f, 2.8f}, - std::vector{0b00100111, 0b00011010}), + std::vector{0b11011000, 0b10100100}), // destination u3 ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape{2, 4}, @@ -1639,7 +1639,7 @@ INSTANTIATE_TEST_SUITE_P( ov::PartialShape{1, 8}, ov::element::u2, ov::element::u3, - std::vector{0b00100111, 0b00011010}, + std::vector{0b11011000, 0b10100100}, std::vector{0b00100111, 0b00011010, 0x00}), ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape{2, 4}, @@ -1754,7 +1754,7 @@ INSTANTIATE_TEST_SUITE_P( ov::PartialShape{1, 8}, ov::element::u2, ov::element::u6, - std::vector{0b00100111, 0b00010000}, + std::vector{0b11011000, 0b00000100}, std::vector{0x02, 0x13, 0x00, 0x01, 0x00, 0x00}), ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape{1, 8},