Compute Library
 19.08
MemoryGroupBase.h
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2017-2018 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 #ifndef __ARM_COMPUTE_MEMORYGROUPBASE_H__
25 #define __ARM_COMPUTE_MEMORYGROUPBASE_H__
26 
28 
29 #include "arm_compute/core/Error.h"
32 
33 #include <cstddef>
34 #include <memory>
35 
36 namespace arm_compute
37 {
38 // Forward declarations
39 class IMemory;
40 
42 template <typename TensorType>
43 class MemoryGroupBase : public IMemoryGroup
44 {
45 public:
47  MemoryGroupBase(std::shared_ptr<IMemoryManager> memory_manager = nullptr);
49  ~MemoryGroupBase() = default;
51  MemoryGroupBase(const MemoryGroupBase &) = delete;
53  MemoryGroupBase &operator=(const MemoryGroupBase &) = delete;
55  MemoryGroupBase(MemoryGroupBase &&) = default;
64  void manage(TensorType *obj);
75  void finalize_memory(TensorType *obj, IMemory &obj_memory, size_t size, size_t alignment = 0);
76 
77  // Inherited methods overridden:
78  void acquire() override;
79  void release() override;
80  MemoryMappings &mappings() override;
81 
82 private:
83  void associate_memory_group(TensorType *obj);
84 
85 private:
86  std::shared_ptr<IMemoryManager> _memory_manager;
87  IMemoryPool *_pool;
88  MemoryMappings _mappings;
89 };
90 
91 template <typename TensorType>
92 inline MemoryGroupBase<TensorType>::MemoryGroupBase(std::shared_ptr<IMemoryManager> memory_manager)
93  : _memory_manager(std::move(memory_manager)), _pool(nullptr), _mappings()
94 {
95  if(_memory_manager)
96  {
97  ARM_COMPUTE_ERROR_ON(!_memory_manager->lifetime_manager());
98  }
99 }
100 
101 template <typename TensorType>
102 inline void MemoryGroupBase<TensorType>::manage(TensorType *obj)
103 {
104  if(_memory_manager && _mappings.empty())
105  {
106  ARM_COMPUTE_ERROR_ON(!_memory_manager->lifetime_manager());
107 
108  // Defer registration to the first managed object
109  _memory_manager->lifetime_manager()->register_group(this);
110 
111  // Associate this memory group with the tensor
112  associate_memory_group(obj);
113 
114  // Start object lifetime
115  _memory_manager->lifetime_manager()->start_lifetime(obj);
116  }
117 }
118 
119 template <typename TensorType>
120 inline void MemoryGroupBase<TensorType>::finalize_memory(TensorType *obj, IMemory &obj_memory, size_t size, size_t alignment)
121 {
122  // TODO (geopin01) : Check size (track size in MemoryMappings)
123  // Check if existing mapping is valid
124  ARM_COMPUTE_ERROR_ON(!_mappings.empty() && (_mappings.find(&obj_memory) == std::end(_mappings)));
125 
126  if(_memory_manager && _mappings.empty())
127  {
128  ARM_COMPUTE_ERROR_ON(!_memory_manager->lifetime_manager());
129  _memory_manager->lifetime_manager()->end_lifetime(obj, obj_memory, size, alignment);
130  }
131 }
132 
133 template <typename TensorType>
135 {
136  if(!_mappings.empty())
137  {
138  ARM_COMPUTE_ERROR_ON(!_memory_manager->pool_manager());
139  _pool = _memory_manager->pool_manager()->lock_pool();
140  _pool->acquire(_mappings);
141  }
142 }
143 
144 template <typename TensorType>
146 {
147  if(_pool != nullptr)
148  {
149  ARM_COMPUTE_ERROR_ON(!_memory_manager->pool_manager());
150  ARM_COMPUTE_ERROR_ON(_mappings.empty());
151  _pool->release(_mappings);
152  _memory_manager->pool_manager()->unlock_pool(_pool);
153  _pool = nullptr;
154  }
155 }
156 
157 template <typename TensorType>
159 {
160  return _mappings;
161 }
162 
163 template <typename TensorType>
165 {
166  ARM_COMPUTE_ERROR("Must be implemented by child class");
167 }
168 } // arm_compute
169 #endif /*__ARM_COMPUTE_MEMORYGROUPBASE_H__ */
#define ARM_COMPUTE_ERROR(...)
Print the given message then throw an std::runtime_error.
Definition: Error.h:261
Memory interface.
Definition: IMemory.h:32
~MemoryGroupBase()=default
Default destructor.
void acquire() override
Acquires backing memory for the whole group.
#define ARM_COMPUTE_ERROR_ON(cond)
If the condition is true then an error message is printed and an exception thrown.
Definition: Error.h:337
Copyright (c) 2017-2018 ARM Limited.
void manage(TensorType *obj)
Sets a object to be managed by the given memory group.
MemoryMappings & mappings() override
Gets the memory mapping of the group.
MemoryGroupBase & operator=(const MemoryGroupBase &)=delete
Prevent instances of this class from being copy assigned (As this class contains pointers)
void finalize_memory(TensorType *obj, IMemory &obj_memory, size_t size, size_t alignment=0)
Finalizes memory for a given object.
MemoryGroupBase(std::shared_ptr< IMemoryManager > memory_manager=nullptr)
Default Constructor.
std::map< IMemory *, size_t > MemoryMappings
A map of (handle, index/offset), where handle is the memory handle of the object to provide the memor...
Definition: Types.h:45
void release() override
Releases backing memory of the whole group.