onert-micro/luci-interpreter/src/kernels/Fill.test.cpp

   1 /*
   2  * Copyright (c) 2022 Samsung Electronics Co., Ltd. All Rights Reserved
   3  * Copyright 2019 The TensorFlow Authors. All Rights Reserved.
   4  *
   5  * Licensed under the Apache License, Version 2.0 (the "License");
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  *    http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  */
  17
  18 #include "kernels/Fill.h"
  19 #include "kernels/TestUtils.h"
  20 #include "luci_interpreter/TestMemoryManager.h"
  21
  22 namespace luci_interpreter
  23 {
  24 namespace kernels
  25 {
  26 namespace
  27 {
  28
  29 using namespace testing;
  30
  31 class FillTest : public ::testing::Test
  32 {
  33 protected:
  34   void SetUp() override { _memory_manager = std::make_unique<TestMemoryManager>(); }
  35
  36   std::unique_ptr<IMemoryManager> _memory_manager;
  37 };
  38
  39 template <typename T, DataType DT> void runFillIntKernel(IMemoryManager *memory_manager)
  40 {
  41   Shape dims_shape{2};
  42
  43   std::vector<int32_t> dims_data = {2, 3};
  44   std::vector<T> value_data = {5};
  45
  46   Tensor dims = makeInputTensor<loco::DataType::S32>(dims_shape, dims_data, memory_manager);
  47   Tensor value = makeInputTensor<DT>(/*scalar*/ {}, value_data, memory_manager);
  48
  49   Tensor output_tensor = makeOutputTensor(DT);
  50
  51   Fill kernel(&dims, &value, &output_tensor);
  52
  53   kernel.configure();
  54   memory_manager->allocate_memory(output_tensor);
  55   kernel.execute();
  56
  57   std::vector<T> ref_output_data{5, 5, 5, 5, 5, 5};
  58   EXPECT_THAT(extractTensorData<T>(output_tensor), ref_output_data);
  59
  60   std::vector<int32_t> ref_output_shape{2, 3};
  61   EXPECT_THAT(extractTensorShape(output_tensor), ::testing::ElementsAreArray(ref_output_shape));
  62 }
  63
  64 template <DataType DT> void runFillQuantIntKernel(IMemoryManager *memory_manager)
  65 {
  66   Shape dims_shape{2};
  67
  68   std::vector<int32_t> dims_data = {2, 3};
  69   std::vector<float> value_data = {5};
  70
  71   int32_t zero_point = 0;
  72
  73   if (DT == loco::DataType::S8)
  74     zero_point = 1;
  75
  76   Tensor dims = makeInputTensor<loco::DataType::S32>(dims_shape, dims_data, memory_manager);
  77   Tensor value = makeInputTensor<DT>(/*scalar*/ {}, /*scale*/ 0.25, /*zero_point*/ zero_point,
  78                                      value_data, memory_manager);
  79
  80   Tensor output_tensor = makeOutputTensor(DT, /*scale*/ 0.25, /*zero_point*/ zero_point);
  81
  82   Fill kernel(&dims, &value, &output_tensor);
  83
  84   kernel.configure();
  85   memory_manager->allocate_memory(output_tensor);
  86   kernel.execute();
  87
  88   std::vector<float> ref_output_data{5, 5, 5, 5, 5, 5};
  89   EXPECT_THAT(dequantizeTensorData(output_tensor), FloatArrayNear(ref_output_data));
  90
  91   std::vector<int32_t> ref_output_shape{2, 3};
  92   EXPECT_THAT(extractTensorShape(output_tensor), ::testing::ElementsAreArray(ref_output_shape));
  93 }
  94
  95 TEST_F(FillTest, FillInt)
  96 {
  97   // Run for int32_t input
  98   runFillIntKernel<int32_t, loco::DataType::S32>(_memory_manager.get());
  99   // Run for int64_t input
 100   runFillIntKernel<int64_t, loco::DataType::S64>(_memory_manager.get());
 101   // Run for int8_t input
 102   runFillQuantIntKernel<loco::DataType::S8>(_memory_manager.get());
 103   // Run for int16_t input
 104   runFillQuantIntKernel<loco::DataType::S16>(_memory_manager.get());
 105
 106   SUCCEED();
 107 }
 108
 109 TEST_F(FillTest, FillFloat)
 110 {
 111   Shape dims_shape{3};
 112
 113   std::vector<int64_t> dims_data = {2, 2, 2};
 114   std::vector<float> value_data = {5};
 115
 116   Tensor dims = makeInputTensor<loco::DataType::S64>(dims_shape, dims_data, _memory_manager.get());
 117   Tensor value =
 118     makeInputTensor<loco::DataType::FLOAT32>(/*scalar*/ {}, value_data, _memory_manager.get());
 119
 120   Tensor output_tensor = makeOutputTensor(loco::DataType::FLOAT32);
 121
 122   Fill kernel(&dims, &value, &output_tensor);
 123
 124   kernel.configure();
 125   _memory_manager->allocate_memory(output_tensor);
 126   kernel.execute();
 127
 128   std::vector<float> ref_output_data{5, 5, 5, 5, 5, 5, 5, 5};
 129
 130   std::vector<int32_t> ref_output_shape{2, 2, 2};
 131   EXPECT_THAT(extractTensorData<float>(output_tensor), ref_output_data);
 132   EXPECT_THAT(extractTensorShape(output_tensor), ::testing::ElementsAreArray(ref_output_shape));
 133 }
 134
 135 TEST_F(FillTest, Invalid_Input_Shape_NEG)
 136 {
 137   Shape dims_shape{1, 3};
 138
 139   std::vector<int32_t> dims_data = {2, 2, 2};
 140   std::vector<float> value_data = {5};
 141
 142   Tensor dims = makeInputTensor<loco::DataType::S32>(dims_shape, dims_data, _memory_manager.get());
 143   Tensor value =
 144     makeInputTensor<loco::DataType::FLOAT32>(/*scalar*/ {}, value_data, _memory_manager.get());
 145
 146   Tensor output_tensor = makeOutputTensor(loco::DataType::FLOAT32);
 147
 148   Fill kernel(&dims, &value, &output_tensor);
 149   EXPECT_ANY_THROW(kernel.configure());
 150 }
 151
 152 TEST_F(FillTest, Invalid_Value_Shape_NEG)
 153 {
 154   Shape dims_shape{3};
 155
 156   std::vector<int32_t> dims_data = {2, 2, 2};
 157   std::vector<float> value_data = {5};
 158
 159   Tensor dims = makeInputTensor<loco::DataType::S32>(dims_shape, dims_data, _memory_manager.get());
 160   Tensor value = makeInputTensor<loco::DataType::FLOAT32>({1}, value_data, _memory_manager.get());
 161
 162   Tensor output_tensor = makeOutputTensor(loco::DataType::FLOAT32);
 163
 164   Fill kernel(&dims, &value, &output_tensor);
 165   EXPECT_ANY_THROW(kernel.configure());
 166 }
 167
 168 } // namespace
 169 } // namespace kernels
 170 } // namespace luci_interpreter