*/
#include <ne-data.h>
-#include "ne_unittest_utils.h"
+#include <ne-model.h>
+#include <ne_test_utils_gtest.h>
#include <npubinfmt.h>
#include <cstdlib>
/**
* @brief Test checkCapability()
*/
-TEST (ne_core_data_test, check_capability)
-{
+TEST (ne_core_data_test, check_capability) {
std::unique_ptr<DataConverter> converter (new DataConverter (true));
converter->setDataType (DATA_TYPE_QASYMM8, DATA_TYPE_QASYMM8);
/**
* @brief Test checkCapability() with negative cases
*/
-TEST (ne_core_data_test, check_capability_n)
-{
+TEST (ne_core_data_test, check_capability_n) {
std::unique_ptr<DataConverter> converter (new DataConverter (true));
/* layouts are not resolved yet */
/* some layouts are not supported */
converter->setDataType (DATA_TYPE_QASYMM8, DATA_TYPE_QASYMM8);
- converter->setDataLayout (DATA_LAYOUT_NCHW, DATA_LAYOUT_TRIV2);
+ converter->setDataLayout (DATA_LAYOUT_TRIV, DATA_LAYOUT_TRIV2);
EXPECT_FALSE (converter->checkCapability ());
}
/**
* @brief Test perform() with quantization (QASYMM8)
*/
-TEST (ne_core_data_test, perform_quantization_asymm8)
-{
+TEST (ne_core_data_test, perform_quantization_asymm8) {
std::unique_ptr<DataConverter> converter (new DataConverter (true));
- uint16_t * src_data = new uint16_t [4096];
- uint8_t * dst_data = new uint8_t [4096];
+ uint16_t *src_data = new uint16_t[4096];
+ uint8_t *dst_data = new uint8_t[4096];
uint32_t data_dims[] = {1, 8, 8, 64};
uint32_t zero = 127;
float scale = 127.0;
EXPECT_EQ (dst_data[i], (uint8_t) val);
}
- delete [] src_data;
- delete [] dst_data;
+ delete[] src_data;
+ delete[] dst_data;
}
/**
* @brief Test perform() with quantization (QSYMM16)
*/
-TEST (ne_core_data_test, perform_quantization_symm16)
-{
+TEST (ne_core_data_test, perform_quantization_symm16) {
std::unique_ptr<DataConverter> converter (new DataConverter (true));
- uint32_t * src_data = new uint32_t [4096];
- int16_t * dst_data = new int16_t [4096];
+ uint32_t *src_data = new uint32_t[4096];
+ int16_t *dst_data = new int16_t[4096];
uint32_t data_dims[] = {1, 8, 8, 64};
uint32_t zero = 0;
float scale = 127.0;
EXPECT_EQ (dst_data[i], (int16_t) val);
}
- delete [] src_data;
- delete [] dst_data;
+ delete[] src_data;
+ delete[] dst_data;
}
/**
* @brief Test perform() with quantization (negative)
*/
-TEST (ne_core_data_test, perform_quantization_n)
-{
+TEST (ne_core_data_test, perform_quantization_n) {
std::unique_ptr<DataConverter> converter (new DataConverter (true));
- uint32_t * src_data = new uint32_t [4096];
- int16_t * dst_data = new int16_t [4096];
+ uint32_t *src_data = new uint32_t[4096];
+ int16_t *dst_data = new int16_t[4096];
uint32_t data_dims[] = {1, 8, 8, 64};
uint32_t zero = 0;
float scale = 0.0;
EXPECT_EQ (dst_data[i], 0);
}
- delete [] src_data;
- delete [] dst_data;
+ delete[] src_data;
+ delete[] dst_data;
}
/**
* @brief Test perform() with dequantization (QASYMM8)
*/
-TEST (ne_core_data_test, perform_dequantization_asymm8)
-{
+TEST (ne_core_data_test, perform_dequantization_asymm8) {
std::unique_ptr<DataConverter> converter (new DataConverter (false));
- uint8_t * src_data = new uint8_t [4096];
- uint16_t * dst_data = new uint16_t [4096];
+ uint8_t *src_data = new uint8_t[4096];
+ uint16_t *dst_data = new uint16_t[4096];
uint32_t data_dims[] = {1, 8, 8, 64};
uint32_t zero = 127;
float scale = 127.0;
EXPECT_EQ (dst_data[i], (uint16_t) val);
}
- delete [] src_data;
- delete [] dst_data;
+ delete[] src_data;
+ delete[] dst_data;
}
/**
* @brief Test perform() with dequantization (QSYMM16)
*/
-TEST (ne_core_data_test, perform_dequantization_symm16)
-{
+TEST (ne_core_data_test, perform_dequantization_symm16) {
std::unique_ptr<DataConverter> converter (new DataConverter (false));
- int16_t * src_data = new int16_t [4096];
- uint32_t * dst_data = new uint32_t [4096];
+ int16_t *src_data = new int16_t[4096];
+ uint32_t *dst_data = new uint32_t[4096];
uint32_t data_dims[] = {1, 8, 8, 64};
uint32_t zero = 0;
float scale = 127.0;
EXPECT_EQ (dst_data[i], (int32_t) val);
}
- delete [] src_data;
- delete [] dst_data;
+ delete[] src_data;
+ delete[] dst_data;
}
/**
* @brief Test perform() with layer conversion (QASYMM8)
*/
-TEST (ne_core_data_test, perform_layer_conversion_asymm8)
-{
+TEST (ne_core_data_test, perform_layer_conversion_asymm8) {
std::unique_ptr<DataConverter> converter (new DataConverter (true));
- uint8_t * src_data = new uint8_t [4096];
- uint8_t * dst_data = new uint8_t [4096];
+ uint8_t *src_data = new uint8_t[4096];
+ uint8_t *dst_data = new uint8_t[4096];
uint32_t data_dims[] = {1, 8, 8, 64};
uint32_t granularity = DATA_GRANULARITY;
EXPECT_EQ (converter->perform (), 4096);
for (int i = 0; i < 4096; i += granularity) {
- EXPECT_EQ (memcmp (src_data + i,
- dst_data + (granularity / 2) * (i / granularity),
- granularity / 2), 0);
+ EXPECT_EQ (
+ memcmp (src_data + i, dst_data + (granularity / 2) * (i / granularity), granularity / 2),
+ 0);
EXPECT_EQ (memcmp (src_data + i + (granularity / 2),
- dst_data + (granularity / 2) * (i / granularity) + 2048,
- granularity / 2), 0);
+ dst_data + (granularity / 2) * (i / granularity) + 2048, granularity / 2),
+ 0);
}
- delete [] src_data;
- delete [] dst_data;
+ delete[] src_data;
+ delete[] dst_data;
}
/**
* @brief Test perform() with layer conversion (QSYMM16)
*/
-TEST (ne_core_data_test, perform_layer_conversion_symm16)
-{
+TEST (ne_core_data_test, perform_layer_conversion_symm16) {
std::unique_ptr<DataConverter> converter (new DataConverter (true));
- int16_t * src_data = new int16_t [4096];
- int16_t * dst_data = new int16_t [4096];
+ int16_t *src_data = new int16_t[4096];
+ int16_t *dst_data = new int16_t[4096];
uint32_t data_dims[] = {1, 8, 8, 64};
uint32_t granularity = DATA_GRANULARITY;
/* check values */
for (int i = 0; i < 4096; i += granularity) {
- EXPECT_EQ (memcmp (src_data + i,
- dst_data + (granularity / 2) * (i / granularity),
- granularity / 2), 0);
+ EXPECT_EQ (
+ memcmp (src_data + i, dst_data + (granularity / 2) * (i / granularity), granularity / 2),
+ 0);
EXPECT_EQ (memcmp (src_data + i + (granularity / 2),
- dst_data + (granularity / 2) * (i / granularity) + 2048,
- granularity / 2), 0);
+ dst_data + (granularity / 2) * (i / granularity) + 2048, granularity / 2),
+ 0);
}
/* 2-TOPS */
EXPECT_EQ (converter->perform (), 4096 * 2);
for (int i = 0; i < 4096; i += granularity) {
- EXPECT_EQ (memcmp (src_data + i,
- dst_data + (granularity / 4) * (i / granularity),
- granularity / 4), 0);
+ EXPECT_EQ (
+ memcmp (src_data + i, dst_data + (granularity / 4) * (i / granularity), granularity / 4),
+ 0);
EXPECT_EQ (memcmp (src_data + i + (granularity / 4),
- dst_data + (granularity / 4) * (i / granularity) + 1024,
- granularity / 4), 0);
+ dst_data + (granularity / 4) * (i / granularity) + 1024, granularity / 4),
+ 0);
EXPECT_EQ (memcmp (src_data + i + 2 * (granularity / 4),
- dst_data + (granularity / 4) * (i / granularity) + 2048,
- granularity / 4), 0);
+ dst_data + (granularity / 4) * (i / granularity) + 2048, granularity / 4),
+ 0);
EXPECT_EQ (memcmp (src_data + i + 3 * (granularity / 4),
- dst_data + (granularity / 4) * (i / granularity) + 3072,
- granularity / 4), 0);
+ dst_data + (granularity / 4) * (i / granularity) + 3072, granularity / 4),
+ 0);
}
- delete [] src_data;
- delete [] dst_data;
+ delete[] src_data;
+ delete[] dst_data;
}
/**
* @brief Test perform() with negative cases
*/
-TEST (ne_core_data_test, perform_n)
-{
+TEST (ne_core_data_test, perform_n) {
std::unique_ptr<DataConverter> converter (new DataConverter (true));
- char * dummy_data = new char [4096];
+ char *dummy_data = new char[4096];
uint32_t dummy_dims[] = {1, 1, 1, 4096};
/* invalid parameters */
converter->setDataDims (dummy_dims);
EXPECT_EQ (converter->perform (), 0);
- delete [] dummy_data;
+ delete[] dummy_data;
+}
+
+/**
+ * @brief Test quantize() with various types (dummy)
+ */
+TEST (ne_core_data_test, dummy_quantize) {
+ data_type npu_types[] = {DATA_TYPE_SRNPU, DATA_TYPE_QASYMM8, DATA_TYPE_QSYMM16};
+ data_type std_types[] = {DATA_TYPE_INT8, DATA_TYPE_UINT8, DATA_TYPE_INT16, DATA_TYPE_UINT16,
+ DATA_TYPE_INT32, DATA_TYPE_UINT32, DATA_TYPE_INT64, DATA_TYPE_UINT64,
+ DATA_TYPE_FLOAT32, DATA_TYPE_FLOAT64};
+ uint32_t data_dims[] = {1, 1, 1, 1024};
+
+ void *src_data = calloc (1, 4096);
+ ASSERT_NE (src_data, nullptr);
+ void *dst_data = calloc (1, 4096);
+ if (dst_data == nullptr) {
+ free (src_data);
+ ASSERT_NE (dst_data, nullptr);
+ }
+
+ /* std to npu */
+ std::unique_ptr<DataConverter> converter (new DataConverter (true));
+
+ converter->setDataLayout (DATA_LAYOUT_TRIV2, DATA_LAYOUT_TRIV2);
+ converter->setDataDims (data_dims);
+ converter->setTops (2);
+ converter->setQuantZero (127);
+ converter->setQuantScale (1.0);
+
+ for (auto &s : std_types) {
+ converter->setData (src_data, dst_data, get_data_size (s));
+ for (auto &n : npu_types) {
+ converter->setDataType (s, n);
+ converter->perform ();
+ }
+ }
+
+ /* npu to std */
+ converter.reset (new DataConverter (false));
+
+ converter->setDataLayout (DATA_LAYOUT_TRIV2, DATA_LAYOUT_TRIV2);
+ converter->setDataDims (data_dims);
+ converter->setTops (2);
+ converter->setQuantZero (127);
+ converter->setQuantScale (1.0);
+
+ for (auto &n : npu_types) {
+ converter->setData (src_data, dst_data, get_data_size (n));
+ for (auto &s : std_types) {
+ converter->setDataType (n, s);
+ converter->perform ();
+ }
+ }
+
+ free (src_data);
+ free (dst_data);
+}
+
+/**
+ * @brief Data conversion from NHWC to TRIV2
+ */
+TEST (ne_core_data_test, layout_conversion_from_nhwc) {
+ std::unique_ptr<DataConverter> converter (new DataConverter (true));
+
+ uint32_t N = 1, H = 10, W = 10;
+ uint32_t channels[] = {1, 3, 16, 32, 64};
+
+ for (auto C : channels) {
+ uint32_t data_dims[] = {N, H, W, C};
+ uint32_t MPA_L = 32;
+ if (C == 1 || C == 3)
+ MPA_L = C;
+
+ uint32_t src_size = N * H * W * C;
+ uint8_t *src_data = new uint8_t[src_size];
+
+ uint32_t dst_size = N * H * W * (((C + MPA_L - 1) / MPA_L) * MPA_L);
+ uint8_t *dst_data = new uint8_t[dst_size];
+
+ converter->setTops (2);
+ converter->setData (src_data, dst_data, src_size);
+ converter->setDataDims (data_dims);
+ converter->setDataLayout (DATA_LAYOUT_NHWC, DATA_LAYOUT_TRIV2);
+ converter->setDataType (DATA_TYPE_QASYMM8, DATA_TYPE_QASYMM8);
+
+ EXPECT_TRUE (converter->checkCapability ());
+
+ /* fill any data */
+ for (int i = 0; i < src_size; i++) src_data[i] = i;
+ for (int i = 0; i < dst_size; i++) dst_data[i] = 0;
+
+ EXPECT_EQ (converter->perform (), src_size);
+
+ uint32_t std_offset;
+ uint32_t npu_offset;
+ for (int n = 0; n < N; n++) {
+ for (int h = 0; h < H; h++) {
+ for (int w = 0; w < W; w++) {
+ for (int c = 0; c < C; c++) {
+ std_offset = c + C * (w + W * (h + n * H));
+ npu_offset = c % MPA_L + MPA_L * (w + W * (h + (n + c / MPA_L) * H));
+ EXPECT_EQ (src_data[std_offset], dst_data[npu_offset]);
+ }
+ }
+ }
+ }
+
+ delete[] src_data;
+ delete[] dst_data;
+ }
+}
+
+/**
+ * @brief Data conversion from TRIV2 to NHWC
+ */
+TEST (ne_core_data_test, layout_conversion_to_nhwc) {
+ std::unique_ptr<DataConverter> converter (new DataConverter (false));
+
+ uint32_t N = 1, H = 10, W = 100;
+ uint32_t channels[] = {1, 3, 16, 32, 64};
+
+ for (auto C : channels) {
+ uint32_t data_dims[] = {N, H, W, C};
+ uint32_t MPA_L = 32;
+
+ uint32_t src_size = N * H * W * (((C + MPA_L - 1) / MPA_L) * MPA_L);
+ uint8_t *src_data = new uint8_t[src_size];
+
+ uint32_t dst_size = N * H * W * C;
+ uint8_t *dst_data = new uint8_t[dst_size];
+
+ converter->setTops (2);
+ converter->setData (src_data, dst_data, src_size);
+ converter->setDataDims (data_dims);
+ converter->setDataLayout (DATA_LAYOUT_TRIV2, DATA_LAYOUT_NHWC);
+ converter->setDataType (DATA_TYPE_QASYMM8, DATA_TYPE_QASYMM8);
+
+ EXPECT_TRUE (converter->checkCapability ());
+
+ /* fill any data */
+ for (int i = 0; i < src_size; i++) src_data[i] = i;
+ for (int i = 0; i < dst_size; i++) dst_data[i] = 0;
+
+ EXPECT_EQ (converter->perform (), src_size);
+
+ uint32_t std_offset;
+ uint32_t npu_offset;
+ for (int n = 0; n < N; n++) {
+ for (int h = 0; h < H; h++) {
+ for (int w = 0; w < W; w++) {
+ for (int c = 0; c < C; c++) {
+ std_offset = c + C * (w + W * (h + n * H));
+ npu_offset = (c % MPA_L) + MPA_L * (w + W * (h + (n + c / MPA_L) * H));
+ EXPECT_EQ (src_data[npu_offset], dst_data[std_offset]);
+ }
+ }
+ }
+ }
+
+ delete[] src_data;
+ delete[] dst_data;
+ }
+}
+
+/**
+ * @brief Data conversion from NCHW to TRIV2
+ */
+TEST (ne_core_data_test, layout_conversion_from_nchw) {
+ std::unique_ptr<DataConverter> converter (new DataConverter (true));
+
+ uint32_t N = 1, H = 10, W = 10;
+ uint32_t channels[] = {1, 3, 16, 32, 64};
+
+ for (auto C : channels) {
+ uint32_t data_dims[] = {N, H, W, C};
+ uint32_t MPA_L = 32;
+ if (C == 1 || C == 3)
+ MPA_L = C;
+
+ uint32_t src_size = N * H * W * C;
+ uint8_t *src_data = new uint8_t[src_size];
+
+ uint32_t dst_size = N * H * W * (((C + MPA_L - 1) / MPA_L) * MPA_L);
+ uint8_t *dst_data = new uint8_t[dst_size];
+
+ converter->setTops (2);
+ converter->setData (src_data, dst_data, src_size);
+ converter->setDataDims (data_dims);
+ converter->setDataLayout (DATA_LAYOUT_NCHW, DATA_LAYOUT_TRIV2);
+ converter->setDataType (DATA_TYPE_QASYMM8, DATA_TYPE_QASYMM8);
+
+ EXPECT_TRUE (converter->checkCapability ());
+
+ /* fill any data */
+ for (int i = 0; i < src_size; i++) src_data[i] = i;
+ for (int i = 0; i < dst_size; i++) dst_data[i] = 0;
+
+ EXPECT_EQ (converter->perform (), src_size);
+
+ uint32_t std_offset;
+ uint32_t npu_offset;
+ for (int n = 0; n < N; n++) {
+ for (int c = 0; c < C; c++) {
+ for (int h = 0; h < H; h++) {
+ for (int w = 0; w < W; w++) {
+ std_offset = w + W * (h + H * (c + n * C));
+ npu_offset = (c % MPA_L) + MPA_L * (w + W * (h + (n + c / MPA_L) * H));
+ EXPECT_EQ (src_data[std_offset], dst_data[npu_offset]);
+ }
+ }
+ }
+ }
+
+ delete[] src_data;
+ delete[] dst_data;
+ }
+}
+
+/**
+ * @brief Data conversion from TRIV2 to NCHW
+ */
+TEST (ne_core_data_test, layout_conversion_to_nchw) {
+ std::unique_ptr<DataConverter> converter (new DataConverter (false));
+
+ uint32_t N = 1, H = 10, W = 10;
+ uint32_t channels[] = {1, 3, 16, 32, 64};
+
+ for (auto C : channels) {
+ uint32_t data_dims[] = {N, H, W, C};
+ uint32_t MPA_L = 32;
+
+ uint32_t src_size = N * H * W * (((C + MPA_L - 1) / MPA_L) * MPA_L);
+ uint8_t *src_data = new uint8_t[src_size];
+
+ uint32_t dst_size = N * H * W * C;
+ uint8_t *dst_data = new uint8_t[dst_size];
+
+ converter->setTops (2);
+ converter->setData (src_data, dst_data, src_size);
+ converter->setDataDims (data_dims);
+ converter->setDataLayout (DATA_LAYOUT_TRIV2, DATA_LAYOUT_NCHW);
+ converter->setDataType (DATA_TYPE_QASYMM8, DATA_TYPE_QASYMM8);
+
+ EXPECT_TRUE (converter->checkCapability ());
+
+ /* fill any data */
+ for (int i = 0; i < src_size; i++) src_data[i] = i;
+ for (int i = 0; i < dst_size; i++) dst_data[i] = 0;
+
+ EXPECT_EQ (converter->perform (), src_size);
+
+ uint32_t std_offset;
+ uint32_t npu_offset;
+ for (int n = 0; n < N; n++) {
+ for (int c = 0; c < C; c++) {
+ for (int h = 0; h < H; h++) {
+ for (int w = 0; w < W; w++) {
+ std_offset = w + W * (h + H * (c + n * C));
+ npu_offset = (c % MPA_L) + MPA_L * (w + W * (h + (n + c / MPA_L) * H));
+ EXPECT_EQ (src_data[npu_offset], dst_data[std_offset]);
+ }
+ }
+ }
+ }
+
+ delete[] src_data;
+ delete[] dst_data;
+ }
}
/**
* @brief main function for unit test
*/
int
-main (int argc, char **argv)
-{
+main (int argc, char **argv) {
return start_gtest (argc, argv);
}
projects / platform / adaptation / npu / trix-engine.git / blobdiff