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

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