ArmNN
 21.05
Functions
RefTensorHandleTests.cpp File Reference
#include <reference/RefTensorHandle.hpp>
#include <reference/RefTensorHandleFactory.hpp>
#include <boost/test/unit_test.hpp>

Go to the source code of this file.

Functions

 BOOST_AUTO_TEST_CASE (AcquireAndRelease)
 
 BOOST_AUTO_TEST_CASE (RefTensorHandleFactoryMemoryManaged)
 
 BOOST_AUTO_TEST_CASE (RefTensorHandleFactoryImport)
 
 BOOST_AUTO_TEST_CASE (RefTensorHandleImport)
 
 BOOST_AUTO_TEST_CASE (RefTensorHandleGetCapabilities)
 
 BOOST_AUTO_TEST_CASE (RefTensorHandleSupportsInPlaceComputation)
 
 BOOST_AUTO_TEST_CASE (TestManagedConstTensorHandle)
 
 BOOST_AUTO_TEST_CASE (CheckSourceType)
 
 BOOST_AUTO_TEST_CASE (ReusePointer)
 
 BOOST_AUTO_TEST_CASE (MisalignedPointer)
 

Function Documentation

◆ BOOST_AUTO_TEST_CASE() [1/10]

BOOST_AUTO_TEST_CASE ( AcquireAndRelease  )

Definition at line 13 of file RefTensorHandleTests.cpp.

References armnn::Float32, and armnn::info.

14 {
15  std::shared_ptr<RefMemoryManager> memoryManager = std::make_shared<RefMemoryManager>();
16 
17  TensorInfo info({ 1, 1, 1, 1 }, DataType::Float32);
18  RefTensorHandle handle(info, memoryManager);
19 
20  handle.Manage();
21  handle.Allocate();
22 
23  memoryManager->Acquire();
24  {
25  float* buffer = reinterpret_cast<float*>(handle.Map());
26 
27  BOOST_CHECK(buffer != nullptr); // Yields a valid pointer
28 
29  buffer[0] = 2.5f;
30 
31  BOOST_CHECK(buffer[0] == 2.5f); // Memory is writable and readable
32 
33  }
34  memoryManager->Release();
35 
36  memoryManager->Acquire();
37  {
38  float* buffer = reinterpret_cast<float*>(handle.Map());
39 
40  BOOST_CHECK(buffer != nullptr); // Yields a valid pointer
41 
42  buffer[0] = 3.5f;
43 
44  BOOST_CHECK(buffer[0] == 3.5f); // Memory is writable and readable
45  }
46  memoryManager->Release();
47 }

◆ BOOST_AUTO_TEST_CASE() [2/10]

BOOST_AUTO_TEST_CASE ( RefTensorHandleFactoryMemoryManaged  )

Definition at line 49 of file RefTensorHandleTests.cpp.

References armnn::Float32, armnn::info, and armnn::Malloc.

50 {
51  std::shared_ptr<RefMemoryManager> memoryManager = std::make_shared<RefMemoryManager>();
52  RefTensorHandleFactory handleFactory(memoryManager);
53  TensorInfo info({ 1, 1, 2, 1 }, DataType::Float32);
54 
55  // create TensorHandle with memory managed
56  auto handle = handleFactory.CreateTensorHandle(info, true);
57  handle->Manage();
58  handle->Allocate();
59 
60  memoryManager->Acquire();
61  {
62  float* buffer = reinterpret_cast<float*>(handle->Map());
63  BOOST_CHECK(buffer != nullptr); // Yields a valid pointer
64  buffer[0] = 1.5f;
65  buffer[1] = 2.5f;
66  BOOST_CHECK(buffer[0] == 1.5f); // Memory is writable and readable
67  BOOST_CHECK(buffer[1] == 2.5f); // Memory is writable and readable
68  }
69  memoryManager->Release();
70 
71  memoryManager->Acquire();
72  {
73  float* buffer = reinterpret_cast<float*>(handle->Map());
74  BOOST_CHECK(buffer != nullptr); // Yields a valid pointer
75  buffer[0] = 3.5f;
76  buffer[1] = 4.5f;
77  BOOST_CHECK(buffer[0] == 3.5f); // Memory is writable and readable
78  BOOST_CHECK(buffer[1] == 4.5f); // Memory is writable and readable
79  }
80  memoryManager->Release();
81 
82  float testPtr[2] = { 2.5f, 5.5f };
83  // Cannot import as import is disabled
84  BOOST_CHECK(!handle->Import(static_cast<void*>(testPtr), MemorySource::Malloc));
85 }

◆ BOOST_AUTO_TEST_CASE() [3/10]

BOOST_AUTO_TEST_CASE ( RefTensorHandleFactoryImport  )

Definition at line 87 of file RefTensorHandleTests.cpp.

References armnn::Float32, armnn::info, and armnn::Malloc.

88 {
89  std::shared_ptr<RefMemoryManager> memoryManager = std::make_shared<RefMemoryManager>();
90  RefTensorHandleFactory handleFactory(memoryManager);
91  TensorInfo info({ 1, 1, 2, 1 }, DataType::Float32);
92 
93  // create TensorHandle without memory managed
94  auto handle = handleFactory.CreateTensorHandle(info, false);
95  handle->Manage();
96  handle->Allocate();
97  memoryManager->Acquire();
98 
99  // No buffer allocated when import is enabled
100  BOOST_CHECK_THROW(handle->Map(), armnn::NullPointerException);
101 
102  float testPtr[2] = { 2.5f, 5.5f };
103  // Correctly import
104  BOOST_CHECK(handle->Import(static_cast<void*>(testPtr), MemorySource::Malloc));
105  float* buffer = reinterpret_cast<float*>(handle->Map());
106  BOOST_CHECK(buffer != nullptr); // Yields a valid pointer after import
107  BOOST_CHECK(buffer == testPtr); // buffer is pointing to testPtr
108  // Memory is writable and readable with correct value
109  BOOST_CHECK(buffer[0] == 2.5f);
110  BOOST_CHECK(buffer[1] == 5.5f);
111  buffer[0] = 3.5f;
112  buffer[1] = 10.0f;
113  BOOST_CHECK(buffer[0] == 3.5f);
114  BOOST_CHECK(buffer[1] == 10.0f);
115  memoryManager->Release();
116 }

◆ BOOST_AUTO_TEST_CASE() [4/10]

BOOST_AUTO_TEST_CASE ( RefTensorHandleImport  )

Definition at line 118 of file RefTensorHandleTests.cpp.

References armnn::Float32, armnn::info, and armnn::Malloc.

119 {
120  TensorInfo info({ 1, 1, 2, 1 }, DataType::Float32);
121  RefTensorHandle handle(info, static_cast<unsigned int>(MemorySource::Malloc));
122 
123  handle.Manage();
124  handle.Allocate();
125 
126  // No buffer allocated when import is enabled
127  BOOST_CHECK_THROW(handle.Map(), armnn::NullPointerException);
128 
129  float testPtr[2] = { 2.5f, 5.5f };
130  // Correctly import
131  BOOST_CHECK(handle.Import(static_cast<void*>(testPtr), MemorySource::Malloc));
132  float* buffer = reinterpret_cast<float*>(handle.Map());
133  BOOST_CHECK(buffer != nullptr); // Yields a valid pointer after import
134  BOOST_CHECK(buffer == testPtr); // buffer is pointing to testPtr
135  // Memory is writable and readable with correct value
136  BOOST_CHECK(buffer[0] == 2.5f);
137  BOOST_CHECK(buffer[1] == 5.5f);
138  buffer[0] = 3.5f;
139  buffer[1] = 10.0f;
140  BOOST_CHECK(buffer[0] == 3.5f);
141  BOOST_CHECK(buffer[1] == 10.0f);
142 }

◆ BOOST_AUTO_TEST_CASE() [5/10]

BOOST_AUTO_TEST_CASE ( RefTensorHandleGetCapabilities  )

Definition at line 144 of file RefTensorHandleTests.cpp.

References IOutputSlot::Connect(), INetwork::Create(), IConnectableLayer::GetInputSlot(), IConnectableLayer::GetOutputSlot(), and armnn::PaddingRequired.

145 {
146  std::shared_ptr<RefMemoryManager> memoryManager = std::make_shared<RefMemoryManager>();
147  RefTensorHandleFactory handleFactory(memoryManager);
148 
149  // Builds up the structure of the network.
150  INetworkPtr net(INetwork::Create());
151  IConnectableLayer* input = net->AddInputLayer(0);
152  IConnectableLayer* output = net->AddOutputLayer(0);
153  input->GetOutputSlot(0).Connect(output->GetInputSlot(0));
154 
155  std::vector<Capability> capabilities = handleFactory.GetCapabilities(input,
156  output,
157  CapabilityClass::PaddingRequired);
158  BOOST_CHECK(capabilities.empty());
159 }
armnn::IConnectableLayer
Interface for a layer that is connectable to other layers via InputSlots and OutputSlots.
Definition: INetwork.hpp:62
armnn::IConnectableLayer::GetInputSlot
virtual const IInputSlot & GetInputSlot(unsigned int index) const =0
Get a const input slot handle by slot index.
armnn::IConnectableLayer::GetOutputSlot
virtual const IOutputSlot & GetOutputSlot(unsigned int index) const =0
Get the const output slot handle by slot index.
armnn::INetworkPtr
std::unique_ptr< INetwork, void(*)(INetwork *network)> INetworkPtr
Definition: INetwork.hpp:173
armnn::IOutputSlot::Connect
virtual int Connect(IInputSlot &destination)=0

◆ BOOST_AUTO_TEST_CASE() [6/10]

BOOST_AUTO_TEST_CASE ( RefTensorHandleSupportsInPlaceComputation  )

Definition at line 161 of file RefTensorHandleTests.cpp.

References ARMNN_ASSERT.

162 {
163  std::shared_ptr<RefMemoryManager> memoryManager = std::make_shared<RefMemoryManager>();
164  RefTensorHandleFactory handleFactory(memoryManager);
165 
166  // RefTensorHandleFactory does not support InPlaceComputation
167  ARMNN_ASSERT(!(handleFactory.SupportsInPlaceComputation()));
168 }
ARMNN_ASSERT
#define ARMNN_ASSERT(COND)
Definition: Assert.hpp:14

◆ BOOST_AUTO_TEST_CASE() [7/10]

BOOST_AUTO_TEST_CASE ( TestManagedConstTensorHandle  )

Definition at line 170 of file RefTensorHandleTests.cpp.

References armnn::info.

171 {
172  // Initialize arguments
173  void* mem = nullptr;
174  TensorInfo info;
175 
176  // Use PassthroughTensor as others are abstract
177  auto passThroughHandle = std::make_shared<PassthroughTensorHandle>(info, mem);
178 
179  // Test managed handle is initialized with m_Mapped unset and once Map() called its set
180  ManagedConstTensorHandle managedHandle(passThroughHandle);
181  BOOST_CHECK(!managedHandle.IsMapped());
182  managedHandle.Map();
183  BOOST_CHECK(managedHandle.IsMapped());
184 
185  // Test it can then be unmapped
186  managedHandle.Unmap();
187  BOOST_CHECK(!managedHandle.IsMapped());
188 
189  // Test member function
190  BOOST_CHECK(managedHandle.GetTensorInfo() == info);
191 
192  // Test that nullptr tensor handle doesn't get mapped
193  ManagedConstTensorHandle managedHandleNull(nullptr);
194  BOOST_CHECK(!managedHandleNull.IsMapped());
195  BOOST_CHECK_THROW(managedHandleNull.Map(), armnn::Exception);
196  BOOST_CHECK(!managedHandleNull.IsMapped());
197 
198  // Check Unmap() when m_Mapped already false
199  managedHandleNull.Unmap();
200  BOOST_CHECK(!managedHandleNull.IsMapped());
201 }
armnn::Exception
Base class for all ArmNN exceptions so that users can filter to just those.
Definition: Exceptions.hpp:46

◆ BOOST_AUTO_TEST_CASE() [8/10]

BOOST_AUTO_TEST_CASE ( CheckSourceType  )

Definition at line 205 of file RefTensorHandleTests.cpp.

References armnn::DmaBuf, armnn::DmaBufProtected, armnn::Float32, armnn::info, and armnn::Malloc.

206 {
207  TensorInfo info({1}, DataType::Float32);
208  RefTensorHandle handle(info, static_cast<unsigned int>(MemorySource::Malloc));
209 
210  int* testPtr = new int(4);
211 
212  // Not supported
213  BOOST_CHECK(!handle.Import(static_cast<void *>(testPtr), MemorySource::DmaBuf));
214 
215  // Not supported
216  BOOST_CHECK(!handle.Import(static_cast<void *>(testPtr), MemorySource::DmaBufProtected));
217 
218  // Supported
219  BOOST_CHECK(handle.Import(static_cast<void *>(testPtr), MemorySource::Malloc));
220 
221  delete testPtr;
222 }

◆ BOOST_AUTO_TEST_CASE() [9/10]

BOOST_AUTO_TEST_CASE ( ReusePointer  )

Definition at line 224 of file RefTensorHandleTests.cpp.

References armnn::Float32, armnn::info, and armnn::Malloc.

225 {
226  TensorInfo info({1}, DataType::Float32);
227  RefTensorHandle handle(info, static_cast<unsigned int>(MemorySource::Malloc));
228 
229  int* testPtr = new int(4);
230 
231  handle.Import(static_cast<void *>(testPtr), MemorySource::Malloc);
232 
233  // Reusing previously Imported pointer
234  BOOST_CHECK(handle.Import(static_cast<void *>(testPtr), MemorySource::Malloc));
235 
236  delete testPtr;
237 }

◆ BOOST_AUTO_TEST_CASE() [10/10]

BOOST_AUTO_TEST_CASE ( MisalignedPointer  )

Definition at line 239 of file RefTensorHandleTests.cpp.

References BOOST_AUTO_TEST_SUITE_END(), armnn::Float32, armnn::info, and armnn::Malloc.

240 {
241  TensorInfo info({2}, DataType::Float32);
242  RefTensorHandle handle(info, static_cast<unsigned int>(MemorySource::Malloc));
243 
244  // Allocate a 2 int array
245  int* testPtr = new int[2];
246 
247  // Increment pointer by 1 byte
248  void* misalignedPtr = static_cast<void*>(reinterpret_cast<char*>(testPtr) + 1);
249 
250  BOOST_CHECK(!handle.Import(misalignedPtr, MemorySource::Malloc));
251 
252  delete[] testPtr;
253 }