1 /*
2 * Copyright (c) 2019 Arm Limited.
3 *
4 * SPDX-License-Identifier: MIT
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to
8 * deal in the Software without restriction, including without limitation the
9 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
10 * sell copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included in all
14 * copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
22 * SOFTWARE.
23 */
24 #include "arm_compute/runtime/BlobLifetimeManager.h"
25 #include "arm_compute/runtime/Memory.h"
26 #include "arm_compute/runtime/MemoryGroup.h"
27 #include "arm_compute/runtime/MemoryManagerOnDemand.h"
28 #include "arm_compute/runtime/PoolManager.h"
29 #include "tests/framework/Asserts.h"
30 #include "tests/framework/Macros.h"
31 #include "tests/framework/datasets/Datasets.h"
32 #include "tests/validation/Validation.h"
33 #include "utils/TypePrinter.h"
34
35 namespace arm_compute
36 {
37 namespace test
38 {
39 namespace validation
40 {
41 namespace
42 {
43 /** Mock class of memory manageable objects */
44 class MockMemoryManageable : public IMemoryManageable
45 {
46 public:
associate_memory_group(IMemoryGroup * memory_group)47 void associate_memory_group(IMemoryGroup *memory_group) override
48 {
49 ARM_COMPUTE_UNUSED(memory_group);
50 }
51 };
52 /** Creates a lifetime of three objects where the two of them can share the same underlying within the given scope
53 *
54 * @warning Contents and pointers of the objects registered will be invalid at the end of the function thus do not dereference.
55 *
56 * @param[in] mg The memory group under which the manageable objects will be registered
57 */
generate_lifetime_info(MemoryGroup & mg)58 void generate_lifetime_info(MemoryGroup &mg)
59 {
60 MockMemoryManageable a{}, b{}, c{};
61 Memory m_a{}, m_b{}, m_c{};
62
63 // Generate a custom lifetime for the objects
64 mg.manage(&a);
65 mg.manage(&b);
66 mg.finalize_memory(&a, m_a, 12U /* size */, 8U /* alignment */);
67 mg.manage(&c);
68 mg.finalize_memory(&b, m_b, 128U /* size */, 16U /* alignment */);
69 mg.finalize_memory(&c, m_c, 32U /* size */, 0U /* alignment */);
70 }
71 } // namespace
72 TEST_SUITE(UNIT)
TEST_SUITE(LifetimeManager)73 TEST_SUITE(LifetimeManager)
74
75 /** Validate memory group register */
76 TEST_CASE(MemoryGroupRegister, framework::DatasetMode::ALL)
77 {
78 auto lft_mgr = std::make_shared<BlobLifetimeManager>();
79 auto pool_mgr = std::make_shared<PoolManager>();
80 auto mm = std::make_shared<MemoryManagerOnDemand>(lft_mgr, pool_mgr);
81 MemoryGroup mg(mm);
82
83 // Register group
84 lft_mgr->register_group(&mg);
85
86 // Generate lifetime information
87 generate_lifetime_info(mg);
88
89 // Validate lifetime manager state
90 ARM_COMPUTE_EXPECT(lft_mgr->info().size() == 2, framework::LogLevel::ERRORS);
91 ARM_COMPUTE_EXPECT(lft_mgr->info()[0].size == 128, framework::LogLevel::ERRORS);
92 ARM_COMPUTE_EXPECT(lft_mgr->info()[0].alignment == 16, framework::LogLevel::ERRORS);
93 ARM_COMPUTE_EXPECT(lft_mgr->info()[0].owners == 1, framework::LogLevel::ERRORS);
94 ARM_COMPUTE_EXPECT(lft_mgr->info()[1].size == 32, framework::LogLevel::ERRORS);
95 ARM_COMPUTE_EXPECT(lft_mgr->info()[1].alignment == 8, framework::LogLevel::ERRORS);
96 ARM_COMPUTE_EXPECT(lft_mgr->info()[1].owners == 2, framework::LogLevel::ERRORS);
97 ARM_COMPUTE_EXPECT(mg.mappings().size() == 3, framework::LogLevel::ERRORS);
98 }
99
100 /** Validate memory group release */
TEST_CASE(MemoryGroupRelease,framework::DatasetMode::ALL)101 TEST_CASE(MemoryGroupRelease, framework::DatasetMode::ALL)
102 {
103 auto lft_mgr = std::make_shared<BlobLifetimeManager>();
104 auto pool_mgr = std::make_shared<PoolManager>();
105 auto mm = std::make_shared<MemoryManagerOnDemand>(lft_mgr, pool_mgr);
106 MemoryGroup mg(mm);
107
108 // Register group
109 lft_mgr->register_group(&mg);
110
111 // Generate lifetime information
112 generate_lifetime_info(mg);
113
114 // Check group mappings
115 ARM_COMPUTE_EXPECT(mg.mappings().size() == 3, framework::LogLevel::ERRORS);
116
117 // Release group and validate its mappings
118 lft_mgr->release_group(&mg);
119 ARM_COMPUTE_EXPECT(mg.mappings().size() == 0, framework::LogLevel::ERRORS);
120 }
121
122 TEST_SUITE_END() // LifetimeManager
123 TEST_SUITE_END()
124 } // namespace validation
125 } // namespace test
126 } // namespace arm_compute
127