inference-engine/tests/unit/cnn_network/layout_tests.cpp

   1 // Copyright (C) 2018 Intel Corporation
   2 //
   3 // SPDX-License-Identifier: Apache-2.0
   4 //
   5
   6 #include <string.h>
   7
   8 #include <gtest/gtest.h>
   9 #include <ie_layouts.h>
  10
  11 using namespace testing;
  12 using namespace InferenceEngine;
  13
  14 class LayoutTest : public ::testing::Test {
  15 public:
  16
  17 };
  18
  19 TEST_F(LayoutTest, offsetNCHW) {
  20     size_t N = 2, C = 3, H = 4, W = 5;
  21     SizeVector dims = { W, H, C, N };
  22
  23     LayoutOffsetCounter loc(InferenceEngine::Layout::NCHW, dims);
  24
  25     size_t p = loc.Offset({ 0, 0, 0, 0 });
  26     EXPECT_EQ(p, 0);
  27
  28     p = loc.Offset({ 1, 1, 1, 1 });
  29     EXPECT_EQ(p, 86);
  30
  31     p = loc.Offset({ 4, 3, 2, 1 });
  32     EXPECT_EQ(p, 119);
  33 }
  34
  35
  36 TEST_F(LayoutTest, offsetNCHW2) {
  37     size_t N = 1, C = 2, H = 3, W = 2;
  38     SizeVector dims = { W, H, C, N };
  39
  40     LayoutOffsetCounter loc(InferenceEngine::Layout::NCHW, dims);
  41
  42     size_t p = loc.Offset({ 0, 1, 0, 0 });
  43     EXPECT_EQ(p, 2);
  44
  45 }
  46
  47
  48 TEST_F(LayoutTest, offsetNHWC) {
  49     size_t N = 1, C = 2, H = 3, W = 2;
  50     SizeVector dims = { W, H, C, N };
  51
  52     LayoutOffsetCounter loc(InferenceEngine::Layout::NHWC, dims);
  53
  54     size_t p = loc.Offset({ 0, 0, 0, 0 });
  55     EXPECT_EQ(p, 0);
  56
  57     p = loc.Offset({ 0, 0, 1, 0 });
  58     EXPECT_EQ(p, 1);
  59
  60     p = loc.Offset({ 1, 0, 0, 0 });
  61     EXPECT_EQ(p, 2);
  62
  63     p = loc.Offset({ 1, 0, 1, 0 });
  64     EXPECT_EQ(p, 3);
  65
  66     p = loc.Offset({ 0, 1, 0, 0 });
  67     EXPECT_EQ(p, 4);
  68
  69 }
  70
  71
  72 TEST_F(LayoutTest, convertNCHWtoNHWC) {
  73     const size_t N = 1, C = 2, H = 3, W = 2;
  74     SizeVector dims = { W, H, C, N };
  75
  76     float sourceBuf[N*C*H*W], destBuf[N*C*H*W], destBuf2[N*C*H*W];
  77     float p = 0.0;
  78     for (int nc = 0; nc < N*C; nc++) {
  79         float v = 0.0;
  80         for (int hw = 0; hw < H*W; hw++) {
  81             sourceBuf[nc*H*W + hw] = v + p;
  82             v++;
  83         }
  84         p += 1000;
  85     }
  86
  87     ConvertLayout<float>(InferenceEngine::Layout::NCHW, InferenceEngine::Layout::NCHW, sourceBuf, destBuf, dims);
  88     EXPECT_TRUE( 0 == memcmp( sourceBuf, destBuf, N*C*H*W * sizeof(float) ) );
  89
  90     ConvertLayout(InferenceEngine::Layout::NCHW, InferenceEngine::Layout::NHWC, sourceBuf, destBuf, dims);
  91     ConvertLayout(InferenceEngine::Layout::NHWC, InferenceEngine::Layout::NCHW, destBuf, destBuf2, dims);
  92     EXPECT_TRUE( 0 == memcmp( sourceBuf, destBuf2, N*C*H*W * sizeof(float) ) );
  93 }
  94