runtime/onert/backend/cpu_common/MemoryPlanner.test.cc

   1 /*
   2  * Copyright (c) 2018 Samsung Electronics Co., Ltd. All Rights Reserved
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <gtest/gtest.h>
  18
  19 #include "MemoryPlanner.h"
  20 #include "ir/Index.h"
  21
  22 TEST(Allocator, allocate_test)
  23 {
  24   ::onert::backend::cpu_common::Allocator allocator(1024);
  25   ASSERT_NE(allocator.base(), nullptr);
  26 }
  27
  28 TEST(BumpPlanner, claim_test)
  29 {
  30   ::onert::backend::cpu_common::BumpPlanner planner;
  31
  32   auto claim = [&planner](uint32_t index, size_t size, uint32_t expected_offset) {
  33     onert::ir::OperandIndex mem_idx(index);
  34     planner.claim(mem_idx, size);
  35     auto mem_blk = planner.memory_plans()[mem_idx];
  36     ASSERT_EQ(mem_blk.offset, expected_offset);
  37     ASSERT_EQ(mem_blk.size, size);
  38   };
  39
  40   claim(0, 10, 0);
  41   claim(1, 20, 10);
  42   claim(2, 30, 30);
  43 }
  44
  45 TEST(FirstFitPlanner, claim_release_test)
  46 {
  47   ::onert::backend::cpu_common::FirstFitPlanner planner;
  48
  49   auto claim = [&planner](uint32_t index, size_t size, uint32_t expected_offset) {
  50     onert::ir::OperandIndex mem_idx(index);
  51     planner.claim(mem_idx, size);
  52     auto mem_blk = planner.memory_plans()[mem_idx];
  53     ASSERT_EQ(mem_blk.offset, expected_offset);
  54     ASSERT_EQ(mem_blk.size, size);
  55   };
  56
  57   auto release = [&planner](uint32_t index) {
  58     onert::ir::OperandIndex mem_idx(index);
  59     planner.release(mem_idx);
  60   };
  61
  62   // 0 CLAIM - 10
  63   claim(0, 10, 0);
  64
  65   // 1 CLAIM - 20
  66   claim(1, 20, 10);
  67
  68   // 2 CLAIM - 30
  69   claim(2, 30, 30);
  70
  71   // 0 RELEASE - 10
  72   release(0);
  73
  74   // 3 CLAIM - 20
  75   claim(3, 20, 60);
  76
  77   // 4 CLAIM - 5
  78   claim(4, 5, 0);
  79
  80   // 5 CLAIM - 10
  81   claim(5, 10, 80);
  82
  83   // 6 CLAIM - 5
  84   claim(6, 5, 5);
  85
  86   // 2 RELEASE - 30
  87   release(2);
  88
  89   // 7 CLAIM - 35
  90   claim(7, 35, 90);
  91
  92   // 8 CLAIM - 10
  93   claim(8, 10, 30);
  94
  95   // 4 RELEASE - 5
  96   release(4);
  97
  98   // 9 CLAIM - 10
  99   claim(9, 10, 40);
 100
 101   // 10 CLAIM - 10
 102   claim(10, 10, 50);
 103
 104   // 6 RELEASE
 105   release(6);
 106
 107   // 1 RELEASE
 108   release(1);
 109
 110   // 8 RELEASE
 111   release(8);
 112
 113   // 9 RELEASE
 114   release(9);
 115
 116   // 10 RELEASE
 117   release(10);
 118
 119   // 3 RELEASE
 120   release(3);
 121
 122   // 5 RELEASE
 123   release(5);
 124
 125   // 7 RELEASE
 126   release(7);
 127 }
 128
 129 TEST(WICPlanner, claim_release_test)
 130 {
 131   ::onert::backend::cpu_common::WICPlanner planner;
 132
 133   auto claim = [&planner](uint32_t index, size_t size) {
 134     onert::ir::OperandIndex mem_idx(index);
 135     planner.claim(mem_idx, size);
 136   };
 137
 138   auto release = [&planner](uint32_t index) {
 139     onert::ir::OperandIndex mem_idx(index);
 140     planner.release(mem_idx);
 141   };
 142
 143   auto verify = [&planner](uint32_t index, uint32_t size, uint32_t expected_offset) {
 144     onert::ir::OperandIndex mem_idx(index);
 145     auto mem_blk = planner.memory_plans()[mem_idx];
 146     ASSERT_EQ(mem_blk.offset, expected_offset);
 147     ASSERT_EQ(mem_blk.size, size);
 148   };
 149
 150   auto capacity = [&planner](uint32_t expected_capacity) {
 151     auto actual_capacity = planner.capacity();
 152     ASSERT_EQ(actual_capacity, expected_capacity);
 153   };
 154
 155   claim(0, 20);
 156   claim(1, 5);
 157   release(0);
 158   claim(2, 10);
 159   release(1);
 160   claim(3, 10);
 161   release(2);
 162   claim(4, 10);
 163   release(3);
 164   claim(5, 20);
 165   release(4);
 166   claim(6, 20);
 167   release(5);
 168   release(7);
 169
 170   // VERIFY 0 - 0
 171   verify(0, 20, 0);
 172
 173   // VERIFY 1 - 20
 174   verify(1, 5, 20);
 175
 176   // VERIFY 2 - 0
 177   verify(2, 10, 0);
 178
 179   // VERIFY 3 - 10
 180   verify(3, 10, 10);
 181
 182   // VERIFY 4 - 20
 183   verify(4, 10, 20);
 184
 185   // VERIFY 5 - 0
 186   verify(5, 20, 0);
 187
 188   // VERIFY 6 - 20
 189   verify(6, 20, 20);
 190
 191   // CAPACITY - 40
 192   capacity(40);
 193 }