2 // Copyright © 2017 Arm Ltd. All rights reserved.
3 // SPDX-License-Identifier: MIT
6 #include "ClContextControlFixture.hpp"
7 #include "ClWorkloadFactoryHelper.hpp"
9 #include <backendsCommon/MemCopyWorkload.hpp>
11 #include <aclCommon/test/CreateWorkloadClNeon.hpp>
12 #include <aclCommon/ArmComputeTensorUtils.hpp>
14 #include <cl/ClTensorHandle.hpp>
15 #include <cl/ClWorkloadFactory.hpp>
16 #include <cl/workloads/ClWorkloads.hpp>
17 #include <cl/workloads/ClWorkloadUtils.hpp>
19 boost::test_tools::predicate_result CompareIClTensorHandleShape(IClTensorHandle* tensorHandle,
20 std::initializer_list<unsigned int> expectedDimensions)
22 return CompareTensorHandleShape<IClTensorHandle>(tensorHandle, expectedDimensions);
25 BOOST_FIXTURE_TEST_SUITE(CreateWorkloadCl, ClContextControlFixture)
27 template <armnn::DataType DataType>
28 static void ClCreateActivationWorkloadTest()
31 ClWorkloadFactory factory =
32 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
34 auto workload = CreateActivationWorkloadTest<ClActivationWorkload, DataType>(factory, graph);
36 // Checks that inputs/outputs are as we expect them (see definition of CreateActivationWorkloadTest).
37 ActivationQueueDescriptor queueDescriptor = workload->GetData();
38 auto inputHandle = boost::polymorphic_downcast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
39 auto outputHandle = boost::polymorphic_downcast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
41 BOOST_TEST(CompareIClTensorHandleShape(inputHandle, {1, 1}));
42 BOOST_TEST(CompareIClTensorHandleShape(outputHandle, {1, 1}));
45 BOOST_AUTO_TEST_CASE(CreateActivationFloatWorkload)
47 ClCreateActivationWorkloadTest<armnn::DataType::Float32>();
50 BOOST_AUTO_TEST_CASE(CreateActivationFloat16Workload)
52 ClCreateActivationWorkloadTest<armnn::DataType::Float16>();
55 template <typename WorkloadType,
56 typename DescriptorType,
58 armnn::DataType DataType>
59 static void ClCreateElementwiseWorkloadTest()
62 ClWorkloadFactory factory =
63 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
65 auto workload = CreateElementwiseWorkloadTest<WorkloadType, DescriptorType, LayerType, DataType>(factory, graph);
67 // Checks that inputs/outputs are as we expect them (see definition of CreateElementwiseWorkloadTest).
68 DescriptorType queueDescriptor = workload->GetData();
69 auto inputHandle1 = boost::polymorphic_downcast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
70 auto inputHandle2 = boost::polymorphic_downcast<IClTensorHandle*>(queueDescriptor.m_Inputs[1]);
71 auto outputHandle = boost::polymorphic_downcast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
72 BOOST_TEST(CompareIClTensorHandleShape(inputHandle1, {2, 3}));
73 BOOST_TEST(CompareIClTensorHandleShape(inputHandle2, {2, 3}));
74 BOOST_TEST(CompareIClTensorHandleShape(outputHandle, {2, 3}));
77 BOOST_AUTO_TEST_CASE(CreateAdditionFloatWorkload)
79 ClCreateElementwiseWorkloadTest<ClAdditionWorkload,
80 AdditionQueueDescriptor,
82 armnn::DataType::Float32>();
85 BOOST_AUTO_TEST_CASE(CreateAdditionFloat16Workload)
87 ClCreateElementwiseWorkloadTest<ClAdditionWorkload,
88 AdditionQueueDescriptor,
90 armnn::DataType::Float16>();
93 BOOST_AUTO_TEST_CASE(CreateSubtractionFloatWorkload)
95 ClCreateElementwiseWorkloadTest<ClSubtractionWorkload,
96 SubtractionQueueDescriptor,
98 armnn::DataType::Float32>();
101 BOOST_AUTO_TEST_CASE(CreateSubtractionFloat16Workload)
103 ClCreateElementwiseWorkloadTest<ClSubtractionWorkload,
104 SubtractionQueueDescriptor,
106 armnn::DataType::Float16>();
109 BOOST_AUTO_TEST_CASE(CreateMultiplicationFloatWorkloadTest)
111 ClCreateElementwiseWorkloadTest<ClMultiplicationWorkload,
112 MultiplicationQueueDescriptor,
114 armnn::DataType::Float32>();
117 BOOST_AUTO_TEST_CASE(CreateMultiplicationFloat16WorkloadTest)
119 ClCreateElementwiseWorkloadTest<ClMultiplicationWorkload,
120 MultiplicationQueueDescriptor,
122 armnn::DataType::Float16>();
125 BOOST_AUTO_TEST_CASE(CreateMultiplicationUint8WorkloadTest)
127 ClCreateElementwiseWorkloadTest<ClMultiplicationWorkload,
128 MultiplicationQueueDescriptor,
130 armnn::DataType::QuantisedAsymm8>();
133 BOOST_AUTO_TEST_CASE(CreateDivisionFloatWorkloadTest)
135 ClCreateElementwiseWorkloadTest<ClDivisionFloatWorkload,
136 DivisionQueueDescriptor,
138 armnn::DataType::Float32>();
141 BOOST_AUTO_TEST_CASE(CreateDivisionFloat16WorkloadTest)
143 ClCreateElementwiseWorkloadTest<ClDivisionFloatWorkload,
144 DivisionQueueDescriptor,
146 armnn::DataType::Float16>();
149 template <typename BatchNormalizationWorkloadType, armnn::DataType DataType>
150 static void ClCreateBatchNormalizationWorkloadTest(DataLayout dataLayout)
153 ClWorkloadFactory factory =
154 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
156 auto workload = CreateBatchNormalizationWorkloadTest<BatchNormalizationWorkloadType, DataType>
157 (factory, graph, dataLayout);
159 // Checks that inputs/outputs are as we expect them (see definition of CreateBatchNormalizationWorkloadTest).
160 BatchNormalizationQueueDescriptor queueDescriptor = workload->GetData();
161 auto inputHandle = boost::polymorphic_downcast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
162 auto outputHandle = boost::polymorphic_downcast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
166 case DataLayout::NHWC:
167 BOOST_TEST(CompareIClTensorHandleShape(inputHandle, { 2, 4, 4, 3 }));
168 BOOST_TEST(CompareIClTensorHandleShape(outputHandle, { 2, 4, 4, 3 }));
171 BOOST_TEST(CompareIClTensorHandleShape(inputHandle, { 2, 3, 4, 4 }));
172 BOOST_TEST(CompareIClTensorHandleShape(outputHandle, { 2, 3, 4, 4 }));
176 BOOST_AUTO_TEST_CASE(CreateBatchNormalizationFloatNchwWorkload)
178 ClCreateBatchNormalizationWorkloadTest<ClBatchNormalizationFloatWorkload,
179 armnn::DataType::Float32>(DataLayout::NCHW);
182 BOOST_AUTO_TEST_CASE(CreateBatchNormalizationFloat16NchwWorkload)
184 ClCreateBatchNormalizationWorkloadTest<ClBatchNormalizationFloatWorkload,
185 armnn::DataType::Float16>(DataLayout::NCHW);
188 BOOST_AUTO_TEST_CASE(CreateBatchNormalizationFloatNhwcWorkload)
190 ClCreateBatchNormalizationWorkloadTest<ClBatchNormalizationFloatWorkload,
191 armnn::DataType::Float32>(DataLayout::NHWC);
194 BOOST_AUTO_TEST_CASE(CreateBatchNormalizationNhwcFloat16NhwcWorkload)
196 ClCreateBatchNormalizationWorkloadTest<ClBatchNormalizationFloatWorkload,
197 armnn::DataType::Float16>(DataLayout::NHWC);
200 BOOST_AUTO_TEST_CASE(CreateConvertFp16ToFp32Workload)
203 ClWorkloadFactory factory =
204 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
206 auto workload = CreateConvertFp16ToFp32WorkloadTest<ClConvertFp16ToFp32Workload>(factory, graph);
208 ConvertFp16ToFp32QueueDescriptor queueDescriptor = workload->GetData();
209 auto inputHandle = boost::polymorphic_downcast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
210 auto outputHandle = boost::polymorphic_downcast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
212 BOOST_TEST(CompareIClTensorHandleShape(inputHandle, {1, 3, 2, 3}));
213 BOOST_TEST(CompareIClTensorHandleShape(outputHandle, {1, 3, 2, 3}));
214 BOOST_TEST((inputHandle->GetTensor().info()->data_type() == arm_compute::DataType::F16));
215 BOOST_TEST((outputHandle->GetTensor().info()->data_type() == arm_compute::DataType::F32));
218 BOOST_AUTO_TEST_CASE(CreateConvertFp32ToFp16Workload)
221 ClWorkloadFactory factory =
222 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
224 auto workload = CreateConvertFp32ToFp16WorkloadTest<ClConvertFp32ToFp16Workload>(factory, graph);
226 ConvertFp32ToFp16QueueDescriptor queueDescriptor = workload->GetData();
227 auto inputHandle = boost::polymorphic_downcast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
228 auto outputHandle = boost::polymorphic_downcast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
230 BOOST_TEST(CompareIClTensorHandleShape(inputHandle, {1, 3, 2, 3}));
231 BOOST_TEST(CompareIClTensorHandleShape(outputHandle, {1, 3, 2, 3}));
232 BOOST_TEST((inputHandle->GetTensor().info()->data_type() == arm_compute::DataType::F32));
233 BOOST_TEST((outputHandle->GetTensor().info()->data_type() == arm_compute::DataType::F16));
236 template <typename Convolution2dWorkloadType, typename armnn::DataType DataType>
237 static void ClConvolution2dWorkloadTest(DataLayout dataLayout)
240 ClWorkloadFactory factory =
241 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
243 auto workload = CreateConvolution2dWorkloadTest<ClConvolution2dWorkload, DataType>(factory,
247 TensorShape inputShape = (dataLayout == DataLayout::NCHW) ? std::initializer_list<unsigned int>({2, 3, 8, 16})
248 : std::initializer_list<unsigned int>({2, 8, 16, 3});
249 TensorShape outputShape = (dataLayout == DataLayout::NCHW) ? std::initializer_list<unsigned int>({2, 2, 2, 10})
250 : std::initializer_list<unsigned int>({2, 2, 10, 2});
252 // Checks that outputs and inputs are as we expect them (see definition of CreateConvolution2dWorkloadTest).
253 Convolution2dQueueDescriptor queueDescriptor = workload->GetData();
254 auto inputHandle = boost::polymorphic_downcast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
255 auto outputHandle = boost::polymorphic_downcast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
256 BOOST_TEST((inputHandle->GetShape() == inputShape));
257 BOOST_TEST((outputHandle->GetShape() == outputShape));
260 BOOST_AUTO_TEST_CASE(CreateConvolution2dFloatNchwWorkload)
262 ClConvolution2dWorkloadTest<ClConvolution2dWorkload, armnn::DataType::Float32>(DataLayout::NCHW);
265 BOOST_AUTO_TEST_CASE(CreateConvolution2dFloatNhwcWorkload)
267 ClConvolution2dWorkloadTest<ClConvolution2dWorkload, armnn::DataType::Float32>(DataLayout::NHWC);
270 BOOST_AUTO_TEST_CASE(CreateConvolution2dFloat16NchwWorkload)
272 ClConvolution2dWorkloadTest<ClConvolution2dWorkload, armnn::DataType::Float16>(DataLayout::NCHW);
275 BOOST_AUTO_TEST_CASE(CreateConvolution2dFloat16NhwcWorkload)
277 ClConvolution2dWorkloadTest<ClConvolution2dWorkload, armnn::DataType::Float16>(DataLayout::NHWC);
280 template <typename DepthwiseConvolutionWorkloadType, typename armnn::DataType DataType>
281 static void ClDepthwiseConvolutionWorkloadTest(DataLayout dataLayout)
284 ClWorkloadFactory factory =
285 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
287 auto workload = CreateDepthwiseConvolution2dWorkloadTest<DepthwiseConvolutionWorkloadType, DataType>
288 (factory, graph, dataLayout);
290 // Checks that inputs/outputs are as we expect them (see definition of CreateDepthwiseConvolution2dWorkloadTest).
291 DepthwiseConvolution2dQueueDescriptor queueDescriptor = workload->GetData();
292 auto inputHandle = boost::polymorphic_downcast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
293 auto outputHandle = boost::polymorphic_downcast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
295 TensorShape inputShape = (dataLayout == DataLayout::NCHW) ? std::initializer_list<unsigned int>({ 2, 2, 5, 5 })
296 : std::initializer_list<unsigned int>({ 2, 5, 5, 2 });
297 TensorShape outputShape = (dataLayout == DataLayout::NCHW) ? std::initializer_list<unsigned int>({ 2, 2, 5, 5 })
298 : std::initializer_list<unsigned int>({ 2, 5, 5, 2 });
300 BOOST_TEST((inputHandle->GetShape() == inputShape));
301 BOOST_TEST((outputHandle->GetShape() == outputShape));
304 BOOST_AUTO_TEST_CASE(CreateDepthwiseConvolutionFloat32NhwcWorkload)
306 ClDepthwiseConvolutionWorkloadTest<ClDepthwiseConvolutionWorkload, DataType::Float32>(DataLayout::NHWC);
309 template <typename Convolution2dWorkloadType, typename armnn::DataType DataType>
310 static void ClDirectConvolution2dWorkloadTest()
313 ClWorkloadFactory factory =
314 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
316 auto workload = CreateDirectConvolution2dWorkloadTest<ClConvolution2dWorkload, DataType>(factory, graph);
318 // Checks that outputs and inputs are as we expect them (see definition of CreateDirectConvolution2dWorkloadTest).
319 Convolution2dQueueDescriptor queueDescriptor = workload->GetData();
320 auto inputHandle = boost::polymorphic_downcast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
321 auto outputHandle = boost::polymorphic_downcast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
322 BOOST_TEST(CompareIClTensorHandleShape(inputHandle, {2, 3, 6, 6}));
323 BOOST_TEST(CompareIClTensorHandleShape(outputHandle, {2, 2, 6, 6}));
326 BOOST_AUTO_TEST_CASE(CreateDirectConvolution2dFloatWorkload)
328 ClDirectConvolution2dWorkloadTest<ClConvolution2dWorkload, armnn::DataType::Float32>();
331 BOOST_AUTO_TEST_CASE(CreateDirectConvolution2dFloat16Workload)
333 ClDirectConvolution2dWorkloadTest<ClConvolution2dWorkload, armnn::DataType::Float16>();
336 BOOST_AUTO_TEST_CASE(CreateDirectConvolution2dUint8Workload)
338 ClDirectConvolution2dWorkloadTest<ClConvolution2dWorkload, armnn::DataType::QuantisedAsymm8>();
341 template <typename FullyConnectedWorkloadType, typename armnn::DataType DataType>
342 static void ClCreateFullyConnectedWorkloadTest()
345 ClWorkloadFactory factory =
346 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
349 CreateFullyConnectedWorkloadTest<FullyConnectedWorkloadType, DataType>(factory, graph);
351 // Checks that outputs and inputs are as we expect them (see definition of CreateFullyConnectedWorkloadTest).
352 FullyConnectedQueueDescriptor queueDescriptor = workload->GetData();
353 auto inputHandle = boost::polymorphic_downcast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
354 auto outputHandle = boost::polymorphic_downcast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
355 BOOST_TEST(CompareIClTensorHandleShape(inputHandle, {3, 1, 4, 5}));
356 BOOST_TEST(CompareIClTensorHandleShape(outputHandle, {3, 7}));
360 BOOST_AUTO_TEST_CASE(CreateFullyConnectedFloatWorkloadTest)
362 ClCreateFullyConnectedWorkloadTest<ClFullyConnectedWorkload, armnn::DataType::Float32>();
365 BOOST_AUTO_TEST_CASE(CreateFullyConnectedFloat16WorkloadTest)
367 ClCreateFullyConnectedWorkloadTest<ClFullyConnectedWorkload, armnn::DataType::Float16>();
370 template <typename NormalizationWorkloadType, typename armnn::DataType DataType>
371 static void ClNormalizationWorkloadTest(DataLayout dataLayout)
374 ClWorkloadFactory factory =
375 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
377 auto workload = CreateNormalizationWorkloadTest<NormalizationWorkloadType, DataType>(factory, graph, dataLayout);
379 // Checks that inputs/outputs are as we expect them (see definition of CreateNormalizationWorkloadTest).
380 NormalizationQueueDescriptor queueDescriptor = workload->GetData();
381 auto inputHandle = boost::polymorphic_downcast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
382 auto outputHandle = boost::polymorphic_downcast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
384 TensorShape inputShape = (dataLayout == DataLayout::NCHW) ? std::initializer_list<unsigned int>({3, 5, 5, 1})
385 : std::initializer_list<unsigned int>({3, 1, 5, 5});
386 TensorShape outputShape = (dataLayout == DataLayout::NCHW) ? std::initializer_list<unsigned int>({3, 5, 5, 1})
387 : std::initializer_list<unsigned int>({3, 1, 5, 5});
389 BOOST_TEST((inputHandle->GetShape() == inputShape));
390 BOOST_TEST((outputHandle->GetShape() == outputShape));
393 BOOST_AUTO_TEST_CASE(CreateNormalizationFloat32NchwWorkload)
395 ClNormalizationWorkloadTest<ClNormalizationFloatWorkload, armnn::DataType::Float32>(DataLayout::NCHW);
398 BOOST_AUTO_TEST_CASE(CreateNormalizationFloat16NchwWorkload)
400 ClNormalizationWorkloadTest<ClNormalizationFloatWorkload, armnn::DataType::Float16>(DataLayout::NCHW);
403 BOOST_AUTO_TEST_CASE(CreateNormalizationFloat32NhwcWorkload)
405 ClNormalizationWorkloadTest<ClNormalizationFloatWorkload, armnn::DataType::Float32>(DataLayout::NHWC);
408 BOOST_AUTO_TEST_CASE(CreateNormalizationFloat16NhwcWorkload)
410 ClNormalizationWorkloadTest<ClNormalizationFloatWorkload, armnn::DataType::Float16>(DataLayout::NHWC);
413 template <typename armnn::DataType DataType>
414 static void ClPooling2dWorkloadTest(DataLayout dataLayout)
417 ClWorkloadFactory factory =
418 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
420 auto workload = CreatePooling2dWorkloadTest<ClPooling2dWorkload, DataType>(factory, graph, dataLayout);
422 TensorShape inputShape = (dataLayout == DataLayout::NCHW) ? std::initializer_list<unsigned int>({3, 2, 5, 5})
423 : std::initializer_list<unsigned int>({3, 5, 5, 2});
424 TensorShape outputShape = (dataLayout == DataLayout::NCHW) ? std::initializer_list<unsigned int>({3, 2, 2, 4})
425 : std::initializer_list<unsigned int>({3, 2, 4, 2});
427 // Check that inputs/outputs are as we expect them (see definition of CreatePooling2dWorkloadTest).
428 Pooling2dQueueDescriptor queueDescriptor = workload->GetData();
429 auto inputHandle = boost::polymorphic_downcast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
430 auto outputHandle = boost::polymorphic_downcast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
432 BOOST_TEST((inputHandle->GetShape() == inputShape));
433 BOOST_TEST((outputHandle->GetShape() == outputShape));
436 BOOST_AUTO_TEST_CASE(CreatePooling2dFloatNchwWorkload)
438 ClPooling2dWorkloadTest<armnn::DataType::Float32>(DataLayout::NCHW);
441 BOOST_AUTO_TEST_CASE(CreatePooling2dFloatNhwcWorkload)
443 ClPooling2dWorkloadTest<armnn::DataType::Float32>(DataLayout::NHWC);
446 BOOST_AUTO_TEST_CASE(CreatePooling2dFloat16NchwWorkload)
448 ClPooling2dWorkloadTest<armnn::DataType::Float16>(DataLayout::NCHW);
451 BOOST_AUTO_TEST_CASE(CreatePooling2dFloat16NhwcWorkload)
453 ClPooling2dWorkloadTest<armnn::DataType::Float16>(DataLayout::NHWC);
456 static void ClCreatePreluWorkloadTest(const armnn::TensorShape& inputShape,
457 const armnn::TensorShape& alphaShape,
458 const armnn::TensorShape& outputShape,
459 armnn::DataType dataType)
462 ClWorkloadFactory factory =
463 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
465 auto workload = CreatePreluWorkloadTest<ClPreluWorkload>(factory,
472 // Checks that outputs and inputs are as we expect them (see definition of CreatePreluWorkloadTest).
473 PreluQueueDescriptor queueDescriptor = workload->GetData();
474 auto inputHandle = boost::polymorphic_downcast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
475 auto alphaHandle = boost::polymorphic_downcast<IClTensorHandle*>(queueDescriptor.m_Inputs[1]);
476 auto outputHandle = boost::polymorphic_downcast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
478 BOOST_TEST((inputHandle->GetShape() == inputShape));
479 BOOST_TEST((alphaHandle->GetShape() == alphaShape));
480 BOOST_TEST((outputHandle->GetShape() == outputShape));
483 BOOST_AUTO_TEST_CASE(CreatePreluFloat16Workload)
485 ClCreatePreluWorkloadTest({ 1, 4, 1, 2 }, { 5, 4, 3, 1 }, { 5, 4, 3, 2 }, DataType::Float16);
488 BOOST_AUTO_TEST_CASE(CreatePreluFloatWorkload)
490 ClCreatePreluWorkloadTest({ 1, 4, 1, 2 }, { 5, 4, 3, 1 }, { 5, 4, 3, 2 }, DataType::Float32);
493 BOOST_AUTO_TEST_CASE(CreatePreluUint8Workload)
495 ClCreatePreluWorkloadTest({ 1, 4, 1, 2 }, { 5, 4, 3, 1 }, { 5, 4, 3, 2 }, DataType::QuantisedAsymm8);
498 template <typename armnn::DataType DataType>
499 static void ClCreateReshapeWorkloadTest()
502 ClWorkloadFactory factory =
503 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
505 auto workload = CreateReshapeWorkloadTest<ClReshapeWorkload, DataType>(factory, graph);
507 // Checks that outputs and inputs are as we expect them (see definition of CreateReshapeWorkloadTest).
508 ReshapeQueueDescriptor queueDescriptor = workload->GetData();
509 auto inputHandle = boost::polymorphic_downcast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
510 auto outputHandle = boost::polymorphic_downcast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
512 BOOST_TEST(CompareIClTensorHandleShape(inputHandle, {4, 1}));
513 BOOST_TEST(CompareIClTensorHandleShape(outputHandle, {1, 4}));
516 BOOST_AUTO_TEST_CASE(CreateReshapeFloatWorkload)
518 ClCreateReshapeWorkloadTest<armnn::DataType::Float32>();
521 BOOST_AUTO_TEST_CASE(CreateReshapeFloat16Workload)
523 ClCreateReshapeWorkloadTest<armnn::DataType::Float16>();
526 BOOST_AUTO_TEST_CASE(CreateReshapeUint8Workload)
528 ClCreateReshapeWorkloadTest<armnn::DataType::QuantisedAsymm8>();
531 template <typename SoftmaxWorkloadType, typename armnn::DataType DataType>
532 static void ClSoftmaxWorkloadTest()
535 ClWorkloadFactory factory =
536 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
538 auto workload = CreateSoftmaxWorkloadTest<SoftmaxWorkloadType, DataType>(factory, graph);
540 // Checks that inputs/outputs are as we expect them (see definition of ClSoftmaxFloatWorkload).
541 SoftmaxQueueDescriptor queueDescriptor = workload->GetData();
542 auto inputHandle = boost::polymorphic_downcast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
543 auto outputHandle = boost::polymorphic_downcast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
545 BOOST_TEST(CompareIClTensorHandleShape(inputHandle, {4, 1}));
546 BOOST_TEST(CompareIClTensorHandleShape(outputHandle, {4, 1}));
550 BOOST_AUTO_TEST_CASE(CreateSoftmaxFloatWorkloadTest)
552 ClSoftmaxWorkloadTest<ClSoftmaxFloatWorkload, armnn::DataType::Float32>();
555 BOOST_AUTO_TEST_CASE(CreateSoftmaxFloat16WorkloadTest)
557 ClSoftmaxWorkloadTest<ClSoftmaxFloatWorkload, armnn::DataType::Float16>();
560 template <typename armnn::DataType DataType>
561 static void ClSplitterWorkloadTest()
564 ClWorkloadFactory factory =
565 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
567 auto workload = CreateSplitterWorkloadTest<ClSplitterWorkload, DataType>(factory, graph);
569 // Checks that outputs are as we expect them (see definition of CreateSplitterWorkloadTest).
570 SplitterQueueDescriptor queueDescriptor = workload->GetData();
571 auto inputHandle = boost::polymorphic_downcast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
572 BOOST_TEST(CompareIClTensorHandleShape(inputHandle, {5, 7, 7}));
574 auto outputHandle1 = boost::polymorphic_downcast<IClTensorHandle*>(queueDescriptor.m_Outputs[1]);
575 BOOST_TEST(CompareIClTensorHandleShape(outputHandle1, {2, 7, 7}));
577 auto outputHandle2 = boost::polymorphic_downcast<IClTensorHandle*>(queueDescriptor.m_Outputs[2]);
578 BOOST_TEST(CompareIClTensorHandleShape(outputHandle2, {2, 7, 7}));
580 auto outputHandle0 = boost::polymorphic_downcast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
581 BOOST_TEST(CompareIClTensorHandleShape(outputHandle0, {1, 7, 7}));
584 BOOST_AUTO_TEST_CASE(CreateSplitterFloatWorkload)
586 ClSplitterWorkloadTest<armnn::DataType::Float32>();
589 BOOST_AUTO_TEST_CASE(CreateSplitterFloat16Workload)
591 ClSplitterWorkloadTest<armnn::DataType::Float16>();
594 template <typename armnn::DataType DataType>
595 static void ClSplitterConcatTest()
597 // Tests that it is possible to decide which output of the splitter layer
598 // should be lined to which input of the concat layer.
599 // We test that is is possible to specify 0th output
600 // of the splitter to be the 1st input to the concat and the 1st output of the splitter to be 0th input
604 ClWorkloadFactory factory =
605 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
608 CreateSplitterConcatWorkloadTest<ClSplitterWorkload, ClConcatWorkload, DataType>
611 auto wlSplitter = std::move(workloads.first);
612 auto wlConcat = std::move(workloads.second);
614 //Checks that the index of inputs/outputs matches what we declared on InputDescriptor construction.
615 armnn::ClSubTensorHandle* sOut0 = dynamic_cast<armnn::ClSubTensorHandle*>(wlSplitter->GetData().m_Outputs[0]);
616 armnn::ClSubTensorHandle* sOut1 = dynamic_cast<armnn::ClSubTensorHandle*>(wlSplitter->GetData().m_Outputs[1]);
617 armnn::ClSubTensorHandle* mIn0 = dynamic_cast<armnn::ClSubTensorHandle*>(wlConcat->GetData().m_Inputs[0]);
618 armnn::ClSubTensorHandle* mIn1 = dynamic_cast<armnn::ClSubTensorHandle*>(wlConcat->GetData().m_Inputs[1]);
625 //Fliped order of inputs/outputs.
626 bool validDataPointers = (sOut0 == mIn1) && (sOut1 == mIn0);
627 BOOST_TEST(validDataPointers);
630 //Also make sure that the inputs are subtensors of one tensor and outputs are sub tensors of another tensor.
631 bool validSubTensorParents = (mIn0->GetTensor().parent() == mIn1->GetTensor().parent())
632 && (sOut0->GetTensor().parent() == sOut1->GetTensor().parent());
634 BOOST_TEST(validSubTensorParents);
637 BOOST_AUTO_TEST_CASE(CreateSplitterConcatFloatWorkload)
639 ClSplitterConcatTest<armnn::DataType::Float32>();
642 BOOST_AUTO_TEST_CASE(CreateSplitterConcatFloat16Workload)
644 ClSplitterConcatTest<armnn::DataType::Float16>();
648 BOOST_AUTO_TEST_CASE(CreateSingleOutputMultipleInputs)
650 // Test that it is possible to assign multiple (two) different layers to each of the outputs of a splitter layer.
651 // We create a splitter with two outputs. That each of those outputs is used by two different activation layers.
654 ClWorkloadFactory factory =
655 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
657 std::unique_ptr<ClSplitterWorkload> wlSplitter;
658 std::unique_ptr<ClActivationWorkload> wlActiv0_0;
659 std::unique_ptr<ClActivationWorkload> wlActiv0_1;
660 std::unique_ptr<ClActivationWorkload> wlActiv1_0;
661 std::unique_ptr<ClActivationWorkload> wlActiv1_1;
663 CreateSplitterMultipleInputsOneOutputWorkloadTest<ClSplitterWorkload,
664 ClActivationWorkload, armnn::DataType::Float32>(factory, graph, wlSplitter, wlActiv0_0, wlActiv0_1,
665 wlActiv1_0, wlActiv1_1);
667 //Checks that the index of inputs/outputs matches what we declared on InputDescriptor construction.
668 armnn::ClSubTensorHandle* sOut0 = dynamic_cast<armnn::ClSubTensorHandle*>(wlSplitter->GetData().m_Outputs[0]);
669 armnn::ClSubTensorHandle* sOut1 = dynamic_cast<armnn::ClSubTensorHandle*>(wlSplitter->GetData().m_Outputs[1]);
670 armnn::ClSubTensorHandle* activ0_0Im = dynamic_cast<armnn::ClSubTensorHandle*>(wlActiv0_0->GetData().m_Inputs[0]);
671 armnn::ClSubTensorHandle* activ0_1Im = dynamic_cast<armnn::ClSubTensorHandle*>(wlActiv0_1->GetData().m_Inputs[0]);
672 armnn::ClSubTensorHandle* activ1_0Im = dynamic_cast<armnn::ClSubTensorHandle*>(wlActiv1_0->GetData().m_Inputs[0]);
673 armnn::ClSubTensorHandle* activ1_1Im = dynamic_cast<armnn::ClSubTensorHandle*>(wlActiv1_1->GetData().m_Inputs[0]);
678 BOOST_TEST(activ0_0Im);
679 BOOST_TEST(activ0_1Im);
680 BOOST_TEST(activ1_0Im);
681 BOOST_TEST(activ1_1Im);
683 bool validDataPointers = (sOut0 == activ0_0Im) && (sOut0 == activ0_1Im) &&
684 (sOut1 == activ1_0Im) && (sOut1 == activ1_1Im);
686 BOOST_TEST(validDataPointers);
689 #if defined(ARMCOMPUTEREF_ENABLED)
691 // This test unit needs the reference backend, it's not available if the reference backend is not built
693 BOOST_AUTO_TEST_CASE(CreateMemCopyWorkloadsCl)
695 ClWorkloadFactory factory =
696 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
698 CreateMemCopyWorkloads<IClTensorHandle>(factory);
703 template <typename L2NormalizationWorkloadType, typename armnn::DataType DataType>
704 static void ClL2NormalizationWorkloadTest(DataLayout dataLayout)
707 ClWorkloadFactory factory =
708 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
711 CreateL2NormalizationWorkloadTest<L2NormalizationWorkloadType, DataType>(factory, graph, dataLayout);
713 // Checks that inputs/outputs are as we expect them (see definition of CreateNormalizationWorkloadTest).
714 L2NormalizationQueueDescriptor queueDescriptor = workload->GetData();
715 auto inputHandle = boost::polymorphic_downcast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
716 auto outputHandle = boost::polymorphic_downcast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
718 TensorShape inputShape = (dataLayout == DataLayout::NCHW) ? std::initializer_list<unsigned int>({ 5, 20, 50, 67 })
719 : std::initializer_list<unsigned int>({ 5, 50, 67, 20 });
720 TensorShape outputShape = (dataLayout == DataLayout::NCHW) ? std::initializer_list<unsigned int>({ 5, 20, 50, 67 })
721 : std::initializer_list<unsigned int>({ 5, 50, 67, 20 });
723 BOOST_TEST((inputHandle->GetShape() == inputShape));
724 BOOST_TEST((outputHandle->GetShape() == outputShape));
727 BOOST_AUTO_TEST_CASE(CreateL2NormalizationFloatNchwWorkload)
729 ClL2NormalizationWorkloadTest<ClL2NormalizationFloatWorkload, armnn::DataType::Float32>(DataLayout::NCHW);
732 BOOST_AUTO_TEST_CASE(CreateL2NormalizationFloatNhwcWorkload)
734 ClL2NormalizationWorkloadTest<ClL2NormalizationFloatWorkload, armnn::DataType::Float32>(DataLayout::NHWC);
737 BOOST_AUTO_TEST_CASE(CreateL2NormalizationFloat16NchwWorkload)
739 ClL2NormalizationWorkloadTest<ClL2NormalizationFloatWorkload, armnn::DataType::Float16>(DataLayout::NCHW);
742 BOOST_AUTO_TEST_CASE(CreateL2NormalizationFloat16NhwcWorkload)
744 ClL2NormalizationWorkloadTest<ClL2NormalizationFloatWorkload, armnn::DataType::Float16>(DataLayout::NHWC);
747 template <typename LstmWorkloadType>
748 static void ClCreateLstmWorkloadTest()
751 ClWorkloadFactory factory =
752 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
754 auto workload = CreateLstmWorkloadTest<LstmWorkloadType>(factory, graph);
756 LstmQueueDescriptor queueDescriptor = workload->GetData();
757 auto inputHandle = boost::polymorphic_downcast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
758 auto outputHandle = boost::polymorphic_downcast<IClTensorHandle*>(queueDescriptor.m_Outputs[1]);
759 BOOST_TEST(CompareIClTensorHandleShape(inputHandle, { 2, 2 }));
760 BOOST_TEST(CompareIClTensorHandleShape(outputHandle, { 2, 4 }));
763 BOOST_AUTO_TEST_CASE(CreateLSTMWorkloadFloatWorkload)
765 ClCreateLstmWorkloadTest<ClLstmFloatWorkload>();
768 template <typename ResizeWorkloadType, typename armnn::DataType DataType>
769 static void ClResizeWorkloadTest(DataLayout dataLayout)
772 ClWorkloadFactory factory =
773 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
775 auto workload = CreateResizeBilinearWorkloadTest<ResizeWorkloadType, DataType>(factory, graph, dataLayout);
777 auto queueDescriptor = workload->GetData();
779 auto inputHandle = boost::polymorphic_downcast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
780 auto outputHandle = boost::polymorphic_downcast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
784 case DataLayout::NHWC:
785 BOOST_TEST(CompareIClTensorHandleShape(inputHandle, { 2, 4, 4, 3 }));
786 BOOST_TEST(CompareIClTensorHandleShape(outputHandle, { 2, 2, 2, 3 }));
788 case DataLayout::NCHW:
790 BOOST_TEST(CompareIClTensorHandleShape(inputHandle, { 2, 3, 4, 4 }));
791 BOOST_TEST(CompareIClTensorHandleShape(outputHandle, { 2, 3, 2, 2 }));
795 BOOST_AUTO_TEST_CASE(CreateResizeFloat32NchwWorkload)
797 ClResizeWorkloadTest<ClResizeWorkload, armnn::DataType::Float32>(DataLayout::NCHW);
800 BOOST_AUTO_TEST_CASE(CreateResizeFloat16NchwWorkload)
802 ClResizeWorkloadTest<ClResizeWorkload, armnn::DataType::Float16>(DataLayout::NCHW);
805 BOOST_AUTO_TEST_CASE(CreateResizeUint8NchwWorkload)
807 ClResizeWorkloadTest<ClResizeWorkload, armnn::DataType::QuantisedAsymm8>(DataLayout::NCHW);
810 BOOST_AUTO_TEST_CASE(CreateResizeFloat32NhwcWorkload)
812 ClResizeWorkloadTest<ClResizeWorkload, armnn::DataType::Float32>(DataLayout::NHWC);
815 BOOST_AUTO_TEST_CASE(CreateResizeFloat16NhwcWorkload)
817 ClResizeWorkloadTest<ClResizeWorkload, armnn::DataType::Float16>(DataLayout::NHWC);
820 BOOST_AUTO_TEST_CASE(CreateResizeUint8NhwcWorkload)
822 ClResizeWorkloadTest<ClResizeWorkload, armnn::DataType::QuantisedAsymm8>(DataLayout::NHWC);
825 template <typename MeanWorkloadType, typename armnn::DataType DataType>
826 static void ClMeanWorkloadTest()
829 ClWorkloadFactory factory =
830 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
832 auto workload = CreateMeanWorkloadTest<MeanWorkloadType, DataType>(factory, graph);
834 // Checks that inputs/outputs are as we expect them (see definition of CreateMeanWorkloadTest).
835 MeanQueueDescriptor queueDescriptor = workload->GetData();
836 auto inputHandle = boost::polymorphic_downcast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
837 auto outputHandle = boost::polymorphic_downcast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
839 // The first dimension (batch size) in both input and output is singular thus it has been reduced by ACL.
840 BOOST_TEST(CompareIClTensorHandleShape(inputHandle, { 1, 3, 7, 4 }));
841 BOOST_TEST(CompareIClTensorHandleShape(outputHandle, { 1, 4 }));
844 BOOST_AUTO_TEST_CASE(CreateMeanFloat32Workload)
846 ClMeanWorkloadTest<ClMeanWorkload, armnn::DataType::Float32>();
849 BOOST_AUTO_TEST_CASE(CreateMeanFloat16Workload)
851 ClMeanWorkloadTest<ClMeanWorkload, armnn::DataType::Float16>();
854 BOOST_AUTO_TEST_CASE(CreateMeanUint8Workload)
856 ClMeanWorkloadTest<ClMeanWorkload, armnn::DataType::QuantisedAsymm8>();
859 template <typename ConcatWorkloadType, armnn::DataType DataType>
860 static void ClCreateConcatWorkloadTest(std::initializer_list<unsigned int> outputShape,
861 unsigned int concatAxis)
864 ClWorkloadFactory factory =
865 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
867 auto workload = CreateConcatWorkloadTest<ConcatWorkloadType, DataType>(factory, graph, outputShape, concatAxis);
869 ConcatQueueDescriptor queueDescriptor = workload->GetData();
870 auto inputHandle0 = boost::polymorphic_downcast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
871 auto inputHandle1 = boost::polymorphic_downcast<IClTensorHandle*>(queueDescriptor.m_Inputs[1]);
872 auto outputHandle = boost::polymorphic_downcast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
874 BOOST_TEST(CompareIClTensorHandleShape(inputHandle0, { 2, 3, 2, 5 }));
875 BOOST_TEST(CompareIClTensorHandleShape(inputHandle1, { 2, 3, 2, 5 }));
876 BOOST_TEST(CompareIClTensorHandleShape(outputHandle, outputShape));
879 BOOST_AUTO_TEST_CASE(CreateConcatDim0Float32Workload)
881 ClCreateConcatWorkloadTest<ClConcatWorkload, armnn::DataType::Float32>({ 4, 3, 2, 5 }, 0);
884 BOOST_AUTO_TEST_CASE(CreateConcatDim1Float32Workload)
886 ClCreateConcatWorkloadTest<ClConcatWorkload, armnn::DataType::Float32>({ 2, 6, 2, 5 }, 1);
889 BOOST_AUTO_TEST_CASE(CreateConcatDim3Float32Workload)
891 ClCreateConcatWorkloadTest<ClConcatWorkload, armnn::DataType::Float32>({ 2, 3, 2, 10 }, 3);
894 BOOST_AUTO_TEST_CASE(CreateConcatDim0Uint8Workload)
896 ClCreateConcatWorkloadTest<ClConcatWorkload, armnn::DataType::QuantisedAsymm8>({ 4, 3, 2, 5 }, 0);
899 BOOST_AUTO_TEST_CASE(CreateConcatDim1Uint8Workload)
901 ClCreateConcatWorkloadTest<ClConcatWorkload, armnn::DataType::QuantisedAsymm8>({ 2, 6, 2, 5 }, 1);
904 BOOST_AUTO_TEST_CASE(CreateConcatDim3Uint8Workload)
906 ClCreateConcatWorkloadTest<ClConcatWorkload, armnn::DataType::QuantisedAsymm8>({ 2, 3, 2, 10 }, 3);
909 template <typename SpaceToDepthWorkloadType, typename armnn::DataType DataType>
910 static void ClSpaceToDepthWorkloadTest()
913 ClWorkloadFactory factory =
914 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
916 auto workload = CreateSpaceToDepthWorkloadTest<SpaceToDepthWorkloadType, DataType>(factory, graph);
918 SpaceToDepthQueueDescriptor queueDescriptor = workload->GetData();
919 auto inputHandle = boost::polymorphic_downcast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
920 auto outputHandle = boost::polymorphic_downcast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
922 BOOST_TEST(CompareIClTensorHandleShape(inputHandle, { 1, 2, 2, 1 }));
923 BOOST_TEST(CompareIClTensorHandleShape(outputHandle, { 1, 1, 1, 4 }));
926 BOOST_AUTO_TEST_CASE(CreateSpaceToDepthFloat32Workload)
928 ClSpaceToDepthWorkloadTest<ClSpaceToDepthWorkload, armnn::DataType::Float32>();
931 BOOST_AUTO_TEST_CASE(CreateSpaceToDepthFloat16Workload)
933 ClSpaceToDepthWorkloadTest<ClSpaceToDepthWorkload, armnn::DataType::Float16>();
936 BOOST_AUTO_TEST_CASE(CreateSpaceToDepthQAsymm8Workload)
938 ClSpaceToDepthWorkloadTest<ClSpaceToDepthWorkload, armnn::DataType::QuantisedAsymm8>();
941 BOOST_AUTO_TEST_CASE(CreateSpaceToDepthQSymm16Workload)
943 ClSpaceToDepthWorkloadTest<ClSpaceToDepthWorkload, armnn::DataType::QuantisedSymm16>();
946 template <armnn::DataType DataType>
947 static void ClCreateStackWorkloadTest(const std::initializer_list<unsigned int>& inputShape,
948 const std::initializer_list<unsigned int>& outputShape,
950 unsigned int numInputs)
953 ClWorkloadFactory factory =
954 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
956 auto workload = CreateStackWorkloadTest<ClStackWorkload, DataType>(factory,
958 TensorShape(inputShape),
959 TensorShape(outputShape),
963 // Check inputs and output are as expected
964 StackQueueDescriptor queueDescriptor = workload->GetData();
965 for (unsigned int i = 0; i < numInputs; ++i)
967 auto inputHandle = boost::polymorphic_downcast<IClTensorHandle*>(queueDescriptor.m_Inputs[i]);
968 BOOST_TEST(CompareIClTensorHandleShape(inputHandle, inputShape));
970 auto outputHandle = boost::polymorphic_downcast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
971 BOOST_TEST(CompareIClTensorHandleShape(outputHandle, outputShape));
974 BOOST_AUTO_TEST_CASE(CreateStackFloat32Workload)
976 ClCreateStackWorkloadTest<armnn::DataType::Float32>({ 3, 4, 5 }, { 3, 4, 2, 5 }, 2, 2);
979 BOOST_AUTO_TEST_CASE(CreateStackUint8Workload)
981 ClCreateStackWorkloadTest<armnn::DataType::QuantisedAsymm8>({ 3, 4, 5 }, { 3, 4, 2, 5 }, 2, 2);
984 template <typename QuantizedLstmWorkloadType>
985 static void ClCreateQuantizedLstmWorkloadTest()
987 using namespace armnn::armcomputetensorutils;
988 using boost::polymorphic_downcast;
991 ClWorkloadFactory factory =
992 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
994 auto workload = CreateQuantizedLstmWorkloadTest<QuantizedLstmWorkloadType>(factory, graph);
996 QuantizedLstmQueueDescriptor queueDescriptor = workload->GetData();
998 IAclTensorHandle* inputHandle = polymorphic_downcast<IAclTensorHandle*>(queueDescriptor.m_Inputs[0]);
999 BOOST_TEST((inputHandle->GetShape() == TensorShape({2, 2})));
1000 BOOST_TEST((inputHandle->GetDataType() == arm_compute::DataType::QASYMM8));
1002 IAclTensorHandle* cellStateInHandle = polymorphic_downcast<IAclTensorHandle*>(queueDescriptor.m_Inputs[1]);
1003 BOOST_TEST((cellStateInHandle->GetShape() == TensorShape({2, 4})));
1004 BOOST_TEST((cellStateInHandle->GetDataType() == arm_compute::DataType::QSYMM16));
1006 IAclTensorHandle* outputStateInHandle = polymorphic_downcast<IAclTensorHandle*>(queueDescriptor.m_Inputs[2]);
1007 BOOST_TEST((outputStateInHandle->GetShape() == TensorShape({2, 4})));
1008 BOOST_TEST((outputStateInHandle->GetDataType() == arm_compute::DataType::QASYMM8));
1010 IAclTensorHandle* cellStateOutHandle = polymorphic_downcast<IAclTensorHandle*>(queueDescriptor.m_Outputs[0]);
1011 BOOST_TEST((cellStateOutHandle->GetShape() == TensorShape({2, 4})));
1012 BOOST_TEST((cellStateOutHandle->GetDataType() == arm_compute::DataType::QSYMM16));
1014 IAclTensorHandle* outputStateOutHandle = polymorphic_downcast<IAclTensorHandle*>(queueDescriptor.m_Outputs[1]);
1015 BOOST_TEST((outputStateOutHandle->GetShape() == TensorShape({2, 4})));
1016 BOOST_TEST((outputStateOutHandle->GetDataType() == arm_compute::DataType::QASYMM8));
1019 BOOST_AUTO_TEST_CASE(CreateQuantizedLstmWorkload)
1021 ClCreateQuantizedLstmWorkloadTest<ClQuantizedLstmWorkload>();
1024 BOOST_AUTO_TEST_SUITE_END()