tests/unittests/ne_core_data_test.cc

   1 /**
   2  * Proprietary
   3  * Copyright (C) 2021 Samsung Electronics
   4  * Copyright (C) 2021 Dongju Chae <dongju.chae@samsung.com>
   5  */
   6 /**
   7  * @file ne_core_data_test.cc
   8  * @date 17 Feb 2021
   9  * @brief UnitTests to test functionality of data converter
  10  * @author Dongju Chae <dongju.chae@samsung.com>
  11  * @bug No known bugs except for NYI items
  12  */
  13
  14 #include <ne-data.h>
  15 #include "ne_unittest_utils.h"
  16
  17 #include <npubinfmt.h>
  18 #include <cstdlib>
  19
  20 /**
  21  * @brief Test checkCapability()
  22  */
  23 TEST (ne_core_data_test, check_capability) {
  24   std::unique_ptr<DataConverter> converter (new DataConverter (true));
  25   converter->setDataType (DATA_TYPE_QASYMM8, DATA_TYPE_QASYMM8);
  26
  27   converter->setDataLayout (DATA_LAYOUT_NHWC, DATA_LAYOUT_TRIV2);
  28   EXPECT_TRUE (converter->checkCapability ());
  29
  30   converter->setDataLayout (DATA_LAYOUT_TRIV2, DATA_LAYOUT_NHWC);
  31   EXPECT_TRUE (converter->checkCapability ());
  32 }
  33
  34 /**
  35  * @brief Test checkCapability() with negative cases
  36  */
  37 TEST (ne_core_data_test, check_capability_n) {
  38   std::unique_ptr<DataConverter> converter (new DataConverter (true));
  39
  40   /* layouts are not resolved yet */
  41   converter->setDataLayout (DATA_LAYOUT_MODEL, DATA_LAYOUT_MODEL);
  42   EXPECT_FALSE (converter->checkCapability ());
  43
  44   /* types are not resolved yet */
  45   converter->setDataLayout (DATA_LAYOUT_NHWC, DATA_LAYOUT_TRIV2);
  46   converter->setDataType (DATA_TYPE_MODEL, DATA_TYPE_MODEL);
  47   EXPECT_FALSE (converter->checkCapability ());
  48
  49   /* some layouts are not supported */
  50   converter->setDataType (DATA_TYPE_QASYMM8, DATA_TYPE_QASYMM8);
  51   converter->setDataLayout (DATA_LAYOUT_NCHW, DATA_LAYOUT_TRIV2);
  52   EXPECT_FALSE (converter->checkCapability ());
  53 }
  54
  55 /**
  56  * @brief Test perform() with quantization (QASYMM8)
  57  */
  58 TEST (ne_core_data_test, perform_quantization_asymm8) {
  59   std::unique_ptr<DataConverter> converter (new DataConverter (true));
  60   uint16_t *src_data = new uint16_t[4096];
  61   uint8_t *dst_data = new uint8_t[4096];
  62   uint32_t data_dims[] = {1, 8, 8, 64};
  63   uint32_t zero = 127;
  64   float scale = 127.0;
  65   double max = 255.0;
  66   double min = 0.0;
  67
  68   converter->setData (src_data, dst_data, 4096 * 2);
  69   converter->setDataDims (data_dims);
  70   converter->setDataLayout (DATA_LAYOUT_TRIV2, DATA_LAYOUT_TRIV2);
  71   converter->setDataType (DATA_TYPE_UINT16, DATA_TYPE_QASYMM8);
  72   converter->setQuantZero (zero);
  73   converter->setQuantScale (scale);
  74
  75   /* fill any data */
  76   for (int i = 0; i < 4096; i++) {
  77     src_data[i] = rand () % UINT16_MAX;
  78     dst_data[i] = 0;
  79   }
  80
  81   EXPECT_EQ (converter->perform (), 4096 * 2);
  82
  83   /* check quantized value */
  84   for (int i = 0; i < 4096; i++) {
  85     double val = src_data[i];
  86     val = val / scale;
  87     val += zero;
  88     val = (val > max) ? max : val;
  89     val = (val < min) ? min : val;
  90     EXPECT_EQ (dst_data[i], (uint8_t) val);
  91   }
  92
  93   delete[] src_data;
  94   delete[] dst_data;
  95 }
  96
  97 /**
  98  * @brief Test perform() with quantization (QSYMM16)
  99  */
 100 TEST (ne_core_data_test, perform_quantization_symm16) {
 101   std::unique_ptr<DataConverter> converter (new DataConverter (true));
 102   uint32_t *src_data = new uint32_t[4096];
 103   int16_t *dst_data = new int16_t[4096];
 104   uint32_t data_dims[] = {1, 8, 8, 64};
 105   uint32_t zero = 0;
 106   float scale = 127.0;
 107   double max = 32767.0;
 108   double min = -32768.0;
 109
 110   converter->setData (src_data, dst_data, 4096 * 4);
 111   converter->setDataDims (data_dims);
 112   converter->setDataLayout (DATA_LAYOUT_TRIV2, DATA_LAYOUT_TRIV2);
 113   converter->setDataType (DATA_TYPE_UINT32, DATA_TYPE_QSYMM16);
 114   converter->setQuantZero (zero);
 115   converter->setQuantScale (scale);
 116
 117   /* fill any data */
 118   for (int i = 0; i < 4096; i++) {
 119     src_data[i] = rand () % UINT32_MAX;
 120     dst_data[i] = 0;
 121   }
 122
 123   EXPECT_EQ (converter->perform (), 4096 * 4);
 124
 125   /* check quantized value */
 126   for (int i = 0; i < 4096; i++) {
 127     double val = src_data[i];
 128     val = val / scale;
 129     val += zero;
 130     val = (val > max) ? max : val;
 131     val = (val < min) ? min : val;
 132     EXPECT_EQ (dst_data[i], (int16_t) val);
 133   }
 134
 135   delete[] src_data;
 136   delete[] dst_data;
 137 }
 138
 139 /**
 140  * @brief Test perform() with quantization (negative)
 141  */
 142 TEST (ne_core_data_test, perform_quantization_n) {
 143   std::unique_ptr<DataConverter> converter (new DataConverter (true));
 144   uint32_t *src_data = new uint32_t[4096];
 145   int16_t *dst_data = new int16_t[4096];
 146   uint32_t data_dims[] = {1, 8, 8, 64};
 147   uint32_t zero = 0;
 148   float scale = 0.0;
 149
 150   converter->setData (src_data, dst_data, 4096 * 4);
 151   converter->setDataDims (data_dims);
 152   converter->setDataLayout (DATA_LAYOUT_TRIV2, DATA_LAYOUT_TRIV2);
 153   converter->setDataType (DATA_TYPE_UINT32, DATA_TYPE_QSYMM16);
 154   converter->setQuantZero (zero);
 155   converter->setQuantScale (scale);
 156
 157   /* fill any data */
 158   for (int i = 0; i < 4096; i++) {
 159     src_data[i] = rand () % UINT32_MAX;
 160     dst_data[i] = 0;
 161   }
 162
 163   EXPECT_EQ (converter->perform (), 4096 * 4);
 164
 165   /* failed to quantize */
 166   for (int i = 0; i < 4096; i++) {
 167     EXPECT_EQ (dst_data[i], 0);
 168   }
 169
 170   delete[] src_data;
 171   delete[] dst_data;
 172 }
 173
 174 /**
 175  * @brief Test perform() with dequantization (QASYMM8)
 176  */
 177 TEST (ne_core_data_test, perform_dequantization_asymm8) {
 178   std::unique_ptr<DataConverter> converter (new DataConverter (false));
 179   uint8_t *src_data = new uint8_t[4096];
 180   uint16_t *dst_data = new uint16_t[4096];
 181   uint32_t data_dims[] = {1, 8, 8, 64};
 182   uint32_t zero = 127;
 183   float scale = 127.0;
 184
 185   converter->setData (src_data, dst_data, 4096);
 186   converter->setDataDims (data_dims);
 187   converter->setDataLayout (DATA_LAYOUT_TRIV2, DATA_LAYOUT_TRIV2);
 188   converter->setDataType (DATA_TYPE_QASYMM8, DATA_TYPE_UINT16);
 189   converter->setQuantZero (zero);
 190   converter->setQuantScale (scale);
 191
 192   /* fill any data */
 193   for (int i = 0; i < 4096; i++) {
 194     src_data[i] = rand () % UINT8_MAX;
 195     dst_data[i] = 0;
 196   }
 197
 198   EXPECT_EQ (converter->perform (), 4096);
 199
 200   /* check dequantized value */
 201   for (int i = 0; i < 4096; i++) {
 202     double val = src_data[i];
 203     val -= zero;
 204     val *= scale;
 205     EXPECT_EQ (dst_data[i], (uint16_t) val);
 206   }
 207
 208   delete[] src_data;
 209   delete[] dst_data;
 210 }
 211
 212 /**
 213  * @brief Test perform() with dequantization (QSYMM16)
 214  */
 215 TEST (ne_core_data_test, perform_dequantization_symm16) {
 216   std::unique_ptr<DataConverter> converter (new DataConverter (false));
 217   int16_t *src_data = new int16_t[4096];
 218   uint32_t *dst_data = new uint32_t[4096];
 219   uint32_t data_dims[] = {1, 8, 8, 64};
 220   uint32_t zero = 0;
 221   float scale = 127.0;
 222
 223   converter->setData (src_data, dst_data, 4096 * 2);
 224   converter->setDataDims (data_dims);
 225   converter->setDataLayout (DATA_LAYOUT_TRIV2, DATA_LAYOUT_TRIV2);
 226   converter->setDataType (DATA_TYPE_QSYMM16, DATA_TYPE_UINT32);
 227   converter->setQuantZero (zero);
 228   converter->setQuantScale (scale);
 229
 230   /* fill any data */
 231   for (int i = 0; i < 4096; i++) {
 232     src_data[i] = rand () % INT16_MAX;
 233     dst_data[i] = 0;
 234   }
 235
 236   EXPECT_EQ (converter->perform (), 4096 * 2);
 237
 238   /* check dequantized value */
 239   for (int i = 0; i < 4096; i++) {
 240     double val = src_data[i];
 241     val -= zero;
 242     val *= scale;
 243     EXPECT_EQ (dst_data[i], (int32_t) val);
 244   }
 245
 246   delete[] src_data;
 247   delete[] dst_data;
 248 }
 249
 250 /**
 251  * @brief Test perform() with layer conversion (QASYMM8)
 252  */
 253 TEST (ne_core_data_test, perform_layer_conversion_asymm8) {
 254   std::unique_ptr<DataConverter> converter (new DataConverter (true));
 255   uint8_t *src_data = new uint8_t[4096];
 256   uint8_t *dst_data = new uint8_t[4096];
 257   uint32_t data_dims[] = {1, 8, 8, 64};
 258   uint32_t granularity = DATA_GRANULARITY;
 259
 260   converter->setData (src_data, dst_data, 4096);
 261   converter->setDataDims (data_dims);
 262   converter->setDataLayout (DATA_LAYOUT_NHWC, DATA_LAYOUT_TRIV2);
 263   converter->setDataType (DATA_TYPE_QASYMM8, DATA_TYPE_QASYMM8);
 264
 265   /* fill any data */
 266   for (int i = 0; i < 4096; i++) {
 267     src_data[i] = rand () % UINT8_MAX;
 268     dst_data[i] = 0;
 269   }
 270
 271   EXPECT_EQ (converter->perform (), 4096);
 272
 273   /* check values */
 274   EXPECT_EQ (memcmp (src_data, dst_data, 4096), 0);
 275
 276   /* 2-TOPS */
 277   converter->setTops (2);
 278   EXPECT_EQ (converter->perform (), 4096);
 279
 280   for (int i = 0; i < 4096; i += granularity) {
 281     EXPECT_EQ (
 282         memcmp (src_data + i, dst_data + (granularity / 2) * (i / granularity),
 283                 granularity / 2),
 284         0);
 285     EXPECT_EQ (memcmp (src_data + i + (granularity / 2),
 286                        dst_data + (granularity / 2) * (i / granularity) + 2048,
 287                        granularity / 2),
 288                0);
 289   }
 290
 291   delete[] src_data;
 292   delete[] dst_data;
 293 }
 294
 295 /**
 296  * @brief Test perform() with layer conversion (QSYMM16)
 297  */
 298 TEST (ne_core_data_test, perform_layer_conversion_symm16) {
 299   std::unique_ptr<DataConverter> converter (new DataConverter (true));
 300   int16_t *src_data = new int16_t[4096];
 301   int16_t *dst_data = new int16_t[4096];
 302   uint32_t data_dims[] = {1, 8, 8, 64};
 303   uint32_t granularity = DATA_GRANULARITY;
 304
 305   converter->setData (src_data, dst_data, 4096 * 2);
 306   converter->setDataDims (data_dims);
 307   converter->setDataLayout (DATA_LAYOUT_NHWC, DATA_LAYOUT_TRIV2);
 308   converter->setDataType (DATA_TYPE_QSYMM16, DATA_TYPE_QSYMM16);
 309
 310   /* fill any data */
 311   for (int i = 0; i < 4096; i++) {
 312     src_data[i] = rand () % INT16_MAX;
 313     dst_data[i] = 0;
 314   }
 315
 316   EXPECT_EQ (converter->perform (), 4096 * 2);
 317
 318   /* check values */
 319   for (int i = 0; i < 4096; i += granularity) {
 320     EXPECT_EQ (
 321         memcmp (src_data + i, dst_data + (granularity / 2) * (i / granularity),
 322                 granularity / 2),
 323         0);
 324     EXPECT_EQ (memcmp (src_data + i + (granularity / 2),
 325                        dst_data + (granularity / 2) * (i / granularity) + 2048,
 326                        granularity / 2),
 327                0);
 328   }
 329
 330   /* 2-TOPS */
 331   converter->setTops (2);
 332   EXPECT_EQ (converter->perform (), 4096 * 2);
 333
 334   for (int i = 0; i < 4096; i += granularity) {
 335     EXPECT_EQ (
 336         memcmp (src_data + i, dst_data + (granularity / 4) * (i / granularity),
 337                 granularity / 4),
 338         0);
 339     EXPECT_EQ (memcmp (src_data + i + (granularity / 4),
 340                        dst_data + (granularity / 4) * (i / granularity) + 1024,
 341                        granularity / 4),
 342                0);
 343     EXPECT_EQ (memcmp (src_data + i + 2 * (granularity / 4),
 344                        dst_data + (granularity / 4) * (i / granularity) + 2048,
 345                        granularity / 4),
 346                0);
 347     EXPECT_EQ (memcmp (src_data + i + 3 * (granularity / 4),
 348                        dst_data + (granularity / 4) * (i / granularity) + 3072,
 349                        granularity / 4),
 350                0);
 351   }
 352
 353   delete[] src_data;
 354   delete[] dst_data;
 355 }
 356
 357 /**
 358  * @brief Test perform() with negative cases
 359  */
 360 TEST (ne_core_data_test, perform_n) {
 361   std::unique_ptr<DataConverter> converter (new DataConverter (true));
 362   char *dummy_data = new char[4096];
 363   uint32_t dummy_dims[] = {1, 1, 1, 4096};
 364
 365   /* invalid parameters */
 366   converter->setData (nullptr, nullptr, 4096);
 367   EXPECT_EQ (converter->perform (), 0);
 368
 369   converter->setData (dummy_data, nullptr, 4096);
 370   EXPECT_EQ (converter->perform (), 0);
 371
 372   converter->setData (nullptr, dummy_data, 4096);
 373   EXPECT_EQ (converter->perform (), 0);
 374
 375   converter->setData (dummy_data, dummy_data, 0);
 376   EXPECT_EQ (converter->perform (), 0);
 377
 378   converter->setData (dummy_data, dummy_data, 4096);
 379   converter->setDataDims (nullptr);
 380   EXPECT_EQ (converter->perform (), 0);
 381
 382   /* still layout/types are not resolved */
 383   converter->setDataDims (dummy_dims);
 384   EXPECT_EQ (converter->perform (), 0);
 385
 386   delete[] dummy_data;
 387 }
 388
 389 /**
 390  * @brief main function for unit test
 391  */
 392 int
 393 main (int argc, char **argv) {
 394   return start_gtest (argc, argv);
 395 }