xref: /aosp_15_r20/external/armnn/src/backends/backendsCommon/test/layerTests/BatchMatMulTestImpl.cpp (revision 89c4ff92f2867872bb9e2354d150bf0c8c502810) 
1 //
2 // Copyright © 2022 Arm Ltd and Contributors. All rights reserved.
3 // SPDX-License-Identifier: MIT
4 //
5 
6 #include "BatchMatMulTestImpl.hpp"
7 
8 #include <armnn/backends/IBackendInternal.hpp>
9 #include <armnn/backends/Workload.hpp>
10 #include <armnn/backends/WorkloadData.hpp>
11 #include <armnn/backends/WorkloadFactory.hpp>
12 
13 #include <armnnTestUtils/WorkloadTestUtils.hpp>
14 #include <armnnUtils/QuantizeHelper.hpp>
15 #include <armnnTestUtils/TensorCopyUtils.hpp>
16 #include <armnn/Optional.hpp>
17 
18 
19 template<armnn::DataType ArmnnType, typename T, std::size_t NumDims>
BatchMatMulTestImpl(armnn::IWorkloadFactory & workloadFactory,const armnn::IBackendInternal::IMemoryManagerSharedPtr & memoryManager,const armnn::ITensorHandleFactory & tensorHandleFactory,armnn::BatchMatMulDescriptor descriptor,const std::vector<T> & inputX,const std::vector<T> & inputY,const std::vector<T> & outputExpected,const armnn::TensorInfo & inputXInfo,const armnn::TensorInfo & inputYInfo,const armnn::TensorInfo & outputInfo)20 LayerTestResult<T, NumDims> BatchMatMulTestImpl(
21     armnn::IWorkloadFactory& workloadFactory,
22     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
23     const armnn::ITensorHandleFactory& tensorHandleFactory,
24     armnn::BatchMatMulDescriptor descriptor,
25     const std::vector<T>& inputX,
26     const std::vector<T>& inputY,
27     const std::vector<T>& outputExpected,
28     const armnn::TensorInfo& inputXInfo,
29     const armnn::TensorInfo& inputYInfo,
30     const armnn::TensorInfo& outputInfo)
31 {
32     std::vector<T> outputActual(outputInfo.GetNumElements());
33 
34     std::unique_ptr<armnn::ITensorHandle> inputXHandle = tensorHandleFactory.CreateTensorHandle(inputXInfo);
35     std::unique_ptr<armnn::ITensorHandle> inputYHandle = tensorHandleFactory.CreateTensorHandle(inputYInfo);
36     std::unique_ptr<armnn::ITensorHandle> outputHandle = tensorHandleFactory.CreateTensorHandle(outputInfo);
37 
38     armnn::BatchMatMulQueueDescriptor queueDescriptor;
39     queueDescriptor.m_Parameters = descriptor;
40     armnn::WorkloadInfo workloadInfo;
41 
42     AddInputToWorkload(queueDescriptor, workloadInfo, inputXInfo, inputXHandle.get());
43     AddInputToWorkload(queueDescriptor, workloadInfo, inputYInfo, inputYHandle.get());
44     AddOutputToWorkload(queueDescriptor, workloadInfo, outputInfo, outputHandle.get());
45 
46     auto workload = workloadFactory.CreateWorkload(armnn::LayerType::BatchMatMul, queueDescriptor, workloadInfo);
47 
48     inputXHandle->Allocate();
49     inputYHandle->Allocate();
50     outputHandle->Allocate();
51 
52     CopyDataToITensorHandle(inputXHandle.get(), inputX.data());
53     CopyDataToITensorHandle(inputYHandle.get(), inputY.data());
54 
55     workload->PostAllocationConfigure();
56     ExecuteWorkload(*workload, memoryManager);
57 
58     CopyDataFromITensorHandle(outputActual.data(), outputHandle.get());
59 
60     return LayerTestResult<T, NumDims>(outputActual,
61                                        outputExpected,
62                                        outputHandle->GetShape(),
63                                        outputInfo.GetShape());
64 }
65 
66 template<armnn::DataType ArmnnType, typename T>
BatchMatMul2DSimpleTest(armnn::IWorkloadFactory & workloadFactory,const armnn::IBackendInternal::IMemoryManagerSharedPtr & memoryManager,const armnn::ITensorHandleFactory & tensorHandleFactory)67 LayerTestResult<T, 2> BatchMatMul2DSimpleTest(
68     armnn::IWorkloadFactory& workloadFactory,
69     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
70     const armnn::ITensorHandleFactory& tensorHandleFactory)
71 {
72     auto descriptor = armnn::BatchMatMulDescriptor(); // Arbitrary layout with no transpose/adjointing
73 
74     float qScale = 1.0f;
75     int32_t qOffset = 0;
76 
77     armnn::TensorInfo inputXInfo({2,2}, ArmnnType, qScale, qOffset);
78     armnn::TensorInfo inputYInfo({2,2}, ArmnnType, qScale, qOffset);
79     armnn::TensorInfo outputInfo({2,2}, ArmnnType, qScale, qOffset);
80 
81     std::vector<T> inputX = armnnUtils::QuantizedVector<T>({
82        1, 2,
83        3, 4
84     }, qScale, qOffset);
85 
86     std::vector<T> inputY = armnnUtils::QuantizedVector<T>({
87         5, 6,
88         7, 8
89     }, qScale, qOffset);
90 
91     std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({
92         19, 22,
93         43, 50
94     }, qScale, qOffset);
95 
96     return BatchMatMulTestImpl<ArmnnType, T, 2>(workloadFactory,
97                                              memoryManager,
98                                              tensorHandleFactory,
99                                              descriptor,
100                                              inputX,
101                                              inputY,
102                                              outputExpected,
103                                              inputXInfo,
104                                              inputYInfo,
105                                              outputInfo);
106 }
107 
108 template LayerTestResult<armnn::ResolveType<armnn::DataType::BFloat16>, 2>
109 BatchMatMul2DSimpleTest<armnn::DataType::BFloat16>(
110     armnn::IWorkloadFactory& workloadFactory,
111     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
112     const armnn::ITensorHandleFactory& tensorHandleFactory);
113 
114 template LayerTestResult<armnn::ResolveType<armnn::DataType::Float32>, 2>
115 BatchMatMul2DSimpleTest<armnn::DataType::Float32>(
116     armnn::IWorkloadFactory& workloadFactory,
117     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
118     const armnn::ITensorHandleFactory& tensorHandleFactory);
119 
120 template LayerTestResult<armnn::ResolveType<armnn::DataType::Float16>, 2>
121 BatchMatMul2DSimpleTest<armnn::DataType::Float16>(
122     armnn::IWorkloadFactory& workloadFactory,
123     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
124     const armnn::ITensorHandleFactory& tensorHandleFactory);
125 
126 template LayerTestResult<armnn::ResolveType<armnn::DataType::QAsymmS8>, 2>
127 BatchMatMul2DSimpleTest<armnn::DataType::QAsymmS8>(
128     armnn::IWorkloadFactory& workloadFactory,
129     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
130     const armnn::ITensorHandleFactory& tensorHandleFactory);
131 
132 template LayerTestResult<armnn::ResolveType<armnn::DataType::QAsymmU8>, 2>
133 BatchMatMul2DSimpleTest<armnn::DataType::QAsymmU8>(
134     armnn::IWorkloadFactory& workloadFactory,
135     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
136     const armnn::ITensorHandleFactory& tensorHandleFactory);
137 
138 template LayerTestResult<armnn::ResolveType<armnn::DataType::QSymmS16>, 2>
139 BatchMatMul2DSimpleTest<armnn::DataType::QSymmS16>(
140     armnn::IWorkloadFactory& workloadFactory,
141     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
142     const armnn::ITensorHandleFactory& tensorHandleFactory);
143 
144 template<armnn::DataType ArmnnType, typename T>
BatchMatMul3DSimpleTest(armnn::IWorkloadFactory & workloadFactory,const armnn::IBackendInternal::IMemoryManagerSharedPtr & memoryManager,const armnn::ITensorHandleFactory & tensorHandleFactory)145 LayerTestResult<T, 3> BatchMatMul3DSimpleTest(
146     armnn::IWorkloadFactory& workloadFactory,
147     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
148     const armnn::ITensorHandleFactory& tensorHandleFactory)
149 {
150     auto descriptor = armnn::BatchMatMulDescriptor(); // Arbitrary layout with no transpose/adjointing
151 
152     float qScale = 1.0f;
153     int32_t qOffset = 0;
154 
155     armnn::TensorInfo inputXInfo({1,2,2}, ArmnnType, qScale, qOffset);
156     armnn::TensorInfo inputYInfo({1,2,2}, ArmnnType, qScale, qOffset);
157     armnn::TensorInfo outputInfo({1,2,2}, ArmnnType, qScale, qOffset);
158 
159     std::vector<T> inputX = armnnUtils::QuantizedVector<T>({
160        1, 2,
161        3, 4
162     }, qScale, qOffset);
163 
164     std::vector<T> inputY = armnnUtils::QuantizedVector<T>({
165         5, 6,
166         7, 8
167     }, qScale, qOffset);
168 
169     std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({
170         19, 22,
171         43, 50
172     }, qScale, qOffset);
173 
174     return BatchMatMulTestImpl<ArmnnType, T, 3>(workloadFactory,
175                                                 memoryManager,
176                                                 tensorHandleFactory,
177                                                 descriptor,
178                                                 inputX,
179                                                 inputY,
180                                                 outputExpected,
181                                                 inputXInfo,
182                                                 inputYInfo,
183                                                 outputInfo);
184 }
185 
186 template LayerTestResult<armnn::ResolveType<armnn::DataType::BFloat16>, 3>
187 BatchMatMul3DSimpleTest<armnn::DataType::BFloat16>(
188     armnn::IWorkloadFactory& workloadFactory,
189     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
190     const armnn::ITensorHandleFactory& tensorHandleFactory);
191 
192 template LayerTestResult<armnn::ResolveType<armnn::DataType::Float32>, 3>
193 BatchMatMul3DSimpleTest<armnn::DataType::Float32>(
194     armnn::IWorkloadFactory& workloadFactory,
195     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
196     const armnn::ITensorHandleFactory& tensorHandleFactory);
197 
198 template LayerTestResult<armnn::ResolveType<armnn::DataType::Float16>, 3>
199 BatchMatMul3DSimpleTest<armnn::DataType::Float16>(
200     armnn::IWorkloadFactory& workloadFactory,
201     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
202     const armnn::ITensorHandleFactory& tensorHandleFactory);
203 
204 template LayerTestResult<armnn::ResolveType<armnn::DataType::QAsymmS8>, 3>
205 BatchMatMul3DSimpleTest<armnn::DataType::QAsymmS8>(
206     armnn::IWorkloadFactory& workloadFactory,
207     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
208     const armnn::ITensorHandleFactory& tensorHandleFactory);
209 
210 template LayerTestResult<armnn::ResolveType<armnn::DataType::QAsymmU8>, 3>
211 BatchMatMul3DSimpleTest<armnn::DataType::QAsymmU8>(
212     armnn::IWorkloadFactory& workloadFactory,
213     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
214     const armnn::ITensorHandleFactory& tensorHandleFactory);
215 
216 template LayerTestResult<armnn::ResolveType<armnn::DataType::QSymmS16>, 3>
217 BatchMatMul3DSimpleTest<armnn::DataType::QSymmS16>(
218     armnn::IWorkloadFactory& workloadFactory,
219     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
220     const armnn::ITensorHandleFactory& tensorHandleFactory);
221 
222 template<armnn::DataType ArmnnType, typename T>
BatchMatMulNCHWSimpleTest(armnn::IWorkloadFactory & workloadFactory,const armnn::IBackendInternal::IMemoryManagerSharedPtr & memoryManager,const armnn::ITensorHandleFactory & tensorHandleFactory)223 LayerTestResult<T, 4> BatchMatMulNCHWSimpleTest(
224     armnn::IWorkloadFactory& workloadFactory,
225     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
226     const armnn::ITensorHandleFactory& tensorHandleFactory)
227 {
228     auto descriptor = armnn::BatchMatMulDescriptor(); // Default arbitrary layout is treated the same as NCHW
229 
230     float qScale = 1.0f;
231     int32_t qOffset = 0;
232 
233     armnn::TensorInfo inputXInfo({1,1,2,2}, ArmnnType, qScale, qOffset);
234     armnn::TensorInfo inputYInfo({1,1,2,2}, ArmnnType, qScale, qOffset);
235     armnn::TensorInfo outputInfo({1,1,2,2}, ArmnnType, qScale, qOffset);
236 
237     std::vector<T> inputX = armnnUtils::QuantizedVector<T>({
238        1, 2,
239        3, 4
240     }, qScale, qOffset);
241 
242     std::vector<T> inputY = armnnUtils::QuantizedVector<T>({
243         5, 6,
244         7, 8
245     }, qScale, qOffset);
246 
247     std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({
248         19, 22,
249         43, 50
250     }, qScale, qOffset);
251 
252     return BatchMatMulTestImpl<ArmnnType, T, 4>(workloadFactory,
253                                                 memoryManager,
254                                                 tensorHandleFactory,
255                                                 descriptor,
256                                                 inputX,
257                                                 inputY,
258                                                 outputExpected,
259                                                 inputXInfo,
260                                                 inputYInfo,
261                                                 outputInfo);
262 }
263 
264 template LayerTestResult<armnn::ResolveType<armnn::DataType::BFloat16>, 4>
265 BatchMatMulNCHWSimpleTest<armnn::DataType::BFloat16>(
266     armnn::IWorkloadFactory& workloadFactory,
267     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
268     const armnn::ITensorHandleFactory& tensorHandleFactory);
269 
270 template LayerTestResult<armnn::ResolveType<armnn::DataType::Float32>, 4>
271 BatchMatMulNCHWSimpleTest<armnn::DataType::Float32>(
272     armnn::IWorkloadFactory& workloadFactory,
273     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
274     const armnn::ITensorHandleFactory& tensorHandleFactory);
275 
276 template LayerTestResult<armnn::ResolveType<armnn::DataType::Float16>, 4>
277 BatchMatMulNCHWSimpleTest<armnn::DataType::Float16>(
278     armnn::IWorkloadFactory& workloadFactory,
279     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
280     const armnn::ITensorHandleFactory& tensorHandleFactory);
281 
282 template LayerTestResult<armnn::ResolveType<armnn::DataType::QAsymmS8>, 4>
283 BatchMatMulNCHWSimpleTest<armnn::DataType::QAsymmS8>(
284     armnn::IWorkloadFactory& workloadFactory,
285     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
286     const armnn::ITensorHandleFactory& tensorHandleFactory);
287 
288 template LayerTestResult<armnn::ResolveType<armnn::DataType::QAsymmU8>, 4>
289 BatchMatMulNCHWSimpleTest<armnn::DataType::QAsymmU8>(
290     armnn::IWorkloadFactory& workloadFactory,
291     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
292     const armnn::ITensorHandleFactory& tensorHandleFactory);
293 
294 template LayerTestResult<armnn::ResolveType<armnn::DataType::QSymmS16>, 4>
295 BatchMatMulNCHWSimpleTest<armnn::DataType::QSymmS16>(
296     armnn::IWorkloadFactory& workloadFactory,
297     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
298     const armnn::ITensorHandleFactory& tensorHandleFactory);
299 
300 template<armnn::DataType ArmnnType, typename T>
BatchMatMulNHWCSimpleTest(armnn::IWorkloadFactory & workloadFactory,const armnn::IBackendInternal::IMemoryManagerSharedPtr & memoryManager,const armnn::ITensorHandleFactory & tensorHandleFactory)301 LayerTestResult<T, 4> BatchMatMulNHWCSimpleTest(
302     armnn::IWorkloadFactory& workloadFactory,
303     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
304     const armnn::ITensorHandleFactory& tensorHandleFactory)
305 {
306     auto descriptor = armnn::BatchMatMulDescriptor(false,
307                                                    false,
308                                                    false,
309                                                    false,
310                                                    armnn::DataLayout::NHWC,
311                                                    armnn::DataLayout::NHWC);
312 
313     float qScale = 1.0f;
314     int32_t qOffset = 0;
315 
316     armnn::TensorInfo inputXInfo({1,2,2,1}, ArmnnType, qScale, qOffset);
317     armnn::TensorInfo inputYInfo({1,2,2,1}, ArmnnType, qScale, qOffset);
318     armnn::TensorInfo outputInfo({1,2,2,1}, ArmnnType, qScale, qOffset);
319 
320     std::vector<T> inputX = armnnUtils::QuantizedVector<T>({
321        1, 2,
322        3, 4
323     }, qScale, qOffset);
324 
325     std::vector<T> inputY = armnnUtils::QuantizedVector<T>({
326         5, 6,
327         7, 8
328     }, qScale, qOffset);
329 
330     std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({
331         19, 22,
332         43, 50
333     }, qScale, qOffset);
334 
335     return BatchMatMulTestImpl<ArmnnType, T, 4>(workloadFactory,
336                                                 memoryManager,
337                                                 tensorHandleFactory,
338                                                 descriptor,
339                                                 inputX,
340                                                 inputY,
341                                                 outputExpected,
342                                                 inputXInfo,
343                                                 inputYInfo,
344                                                 outputInfo);
345 }
346 
347 template LayerTestResult<armnn::ResolveType<armnn::DataType::BFloat16>, 4>
348 BatchMatMulNHWCSimpleTest<armnn::DataType::BFloat16>(
349     armnn::IWorkloadFactory& workloadFactory,
350     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
351     const armnn::ITensorHandleFactory& tensorHandleFactory);
352 
353 template LayerTestResult<armnn::ResolveType<armnn::DataType::Float32>, 4>
354 BatchMatMulNHWCSimpleTest<armnn::DataType::Float32>(
355     armnn::IWorkloadFactory& workloadFactory,
356     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
357     const armnn::ITensorHandleFactory& tensorHandleFactory);
358 
359 template LayerTestResult<armnn::ResolveType<armnn::DataType::Float16>, 4>
360 BatchMatMulNHWCSimpleTest<armnn::DataType::Float16>(
361     armnn::IWorkloadFactory& workloadFactory,
362     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
363     const armnn::ITensorHandleFactory& tensorHandleFactory);
364 
365 template LayerTestResult<armnn::ResolveType<armnn::DataType::QAsymmS8>, 4>
366 BatchMatMulNHWCSimpleTest<armnn::DataType::QAsymmS8>(
367     armnn::IWorkloadFactory& workloadFactory,
368     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
369     const armnn::ITensorHandleFactory& tensorHandleFactory);
370 
371 template LayerTestResult<armnn::ResolveType<armnn::DataType::QAsymmU8>, 4>
372 BatchMatMulNHWCSimpleTest<armnn::DataType::QAsymmU8>(
373     armnn::IWorkloadFactory& workloadFactory,
374     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
375     const armnn::ITensorHandleFactory& tensorHandleFactory);
376 
377 template LayerTestResult<armnn::ResolveType<armnn::DataType::QSymmS16>, 4>
378 BatchMatMulNHWCSimpleTest<armnn::DataType::QSymmS16>(
379     armnn::IWorkloadFactory& workloadFactory,
380     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
381     const armnn::ITensorHandleFactory& tensorHandleFactory);
382 
383 template<armnn::DataType ArmnnType, typename T>
BatchMatMul3DBatchTest(armnn::IWorkloadFactory & workloadFactory,const armnn::IBackendInternal::IMemoryManagerSharedPtr & memoryManager,const armnn::ITensorHandleFactory & tensorHandleFactory)384 LayerTestResult<T, 3> BatchMatMul3DBatchTest(
385     armnn::IWorkloadFactory& workloadFactory,
386     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
387     const armnn::ITensorHandleFactory& tensorHandleFactory)
388 {
389     auto descriptor = armnn::BatchMatMulDescriptor(); // Arbitrary layout with no transpose/adjointing
390 
391     float qScale = 1.0f;
392     int32_t qOffset = 0;
393 
394     armnn::TensorInfo inputXInfo({2,2,2}, ArmnnType, qScale, qOffset);
395     armnn::TensorInfo inputYInfo({2,2,2}, ArmnnType, qScale, qOffset);
396     armnn::TensorInfo outputInfo({2,2,2}, ArmnnType, qScale, qOffset);
397 
398     std::vector<T> inputX = armnnUtils::QuantizedVector<T>({
399        1, 2,
400        3, 4,
401 
402        9, 10,
403        11, 12
404     }, qScale, qOffset);
405 
406     std::vector<T> inputY = armnnUtils::QuantizedVector<T>({
407         5, 6,
408         7, 8,
409 
410         13, 14,
411         15, 16
412     }, qScale, qOffset);
413 
414     std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({
415         19, 22,
416         43, 50,
417 
418         267, 286,
419         323, 346
420     }, qScale, qOffset);
421 
422     return BatchMatMulTestImpl<ArmnnType, T, 3>(workloadFactory,
423                                                 memoryManager,
424                                                 tensorHandleFactory,
425                                                 descriptor,
426                                                 inputX,
427                                                 inputY,
428                                                 outputExpected,
429                                                 inputXInfo,
430                                                 inputYInfo,
431                                                 outputInfo);
432 }
433 
434 template LayerTestResult<armnn::ResolveType<armnn::DataType::BFloat16>, 3>
435 BatchMatMul3DBatchTest<armnn::DataType::BFloat16>(
436     armnn::IWorkloadFactory& workloadFactory,
437     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
438     const armnn::ITensorHandleFactory& tensorHandleFactory);
439 
440 template LayerTestResult<armnn::ResolveType<armnn::DataType::Float32>, 3>
441 BatchMatMul3DBatchTest<armnn::DataType::Float32>(
442     armnn::IWorkloadFactory& workloadFactory,
443     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
444     const armnn::ITensorHandleFactory& tensorHandleFactory);
445 
446 template LayerTestResult<armnn::ResolveType<armnn::DataType::Float16>, 3>
447 BatchMatMul3DBatchTest<armnn::DataType::Float16>(
448     armnn::IWorkloadFactory& workloadFactory,
449     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
450     const armnn::ITensorHandleFactory& tensorHandleFactory);
451 
452 template LayerTestResult<armnn::ResolveType<armnn::DataType::QAsymmS8>, 3>
453 BatchMatMul3DBatchTest<armnn::DataType::QAsymmS8>(
454     armnn::IWorkloadFactory& workloadFactory,
455     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
456     const armnn::ITensorHandleFactory& tensorHandleFactory);
457 
458 template LayerTestResult<armnn::ResolveType<armnn::DataType::QAsymmU8>, 3>
459 BatchMatMul3DBatchTest<armnn::DataType::QAsymmU8>(
460     armnn::IWorkloadFactory& workloadFactory,
461     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
462     const armnn::ITensorHandleFactory& tensorHandleFactory);
463 
464 template LayerTestResult<armnn::ResolveType<armnn::DataType::QSymmS16>, 3>
465 BatchMatMul3DBatchTest<armnn::DataType::QSymmS16>(
466     armnn::IWorkloadFactory& workloadFactory,
467     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
468     const armnn::ITensorHandleFactory& tensorHandleFactory);
469 
470 template<armnn::DataType ArmnnType, typename T>
BatchMatMul3DBroadcastTest(armnn::IWorkloadFactory & workloadFactory,const armnn::IBackendInternal::IMemoryManagerSharedPtr & memoryManager,const armnn::ITensorHandleFactory & tensorHandleFactory)471 LayerTestResult<T, 3> BatchMatMul3DBroadcastTest(
472     armnn::IWorkloadFactory& workloadFactory,
473     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
474     const armnn::ITensorHandleFactory& tensorHandleFactory)
475 {
476     auto descriptor = armnn::BatchMatMulDescriptor(); // Arbitrary layout with no transpose/adjointing
477 
478     float qScale = 1.0f;
479     int32_t qOffset = 0;
480 
481     armnn::TensorInfo inputXInfo({2,2,2}, ArmnnType, qScale, qOffset);
482     armnn::TensorInfo inputYInfo({1,2,2}, ArmnnType, qScale, qOffset);
483     armnn::TensorInfo outputInfo({2,2,2}, ArmnnType, qScale, qOffset);
484 
485     std::vector<T> inputX = armnnUtils::QuantizedVector<T>({
486        1, 2,
487        3, 4,
488 
489        9, 10,
490        11, 12
491     }, qScale, qOffset);
492 
493     std::vector<T> inputY = armnnUtils::QuantizedVector<T>({
494         13, 14,
495         15, 16
496     }, qScale, qOffset);
497 
498     std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({
499         43, 46,
500         99, 106,
501 
502         267, 286,
503         323, 346
504     }, qScale, qOffset);
505 
506     return BatchMatMulTestImpl<ArmnnType, T, 3>(workloadFactory,
507                                                 memoryManager,
508                                                 tensorHandleFactory,
509                                                 descriptor,
510                                                 inputX,
511                                                 inputY,
512                                                 outputExpected,
513                                                 inputXInfo,
514                                                 inputYInfo,
515                                                 outputInfo);
516 }
517 
518 template LayerTestResult<armnn::ResolveType<armnn::DataType::BFloat16>, 3>
519 BatchMatMul3DBroadcastTest<armnn::DataType::BFloat16>(
520     armnn::IWorkloadFactory& workloadFactory,
521     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
522     const armnn::ITensorHandleFactory& tensorHandleFactory);
523 
524 template LayerTestResult<armnn::ResolveType<armnn::DataType::Float32>, 3>
525 BatchMatMul3DBroadcastTest<armnn::DataType::Float32>(
526     armnn::IWorkloadFactory& workloadFactory,
527     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
528     const armnn::ITensorHandleFactory& tensorHandleFactory);
529 
530 template LayerTestResult<armnn::ResolveType<armnn::DataType::Float16>, 3>
531 BatchMatMul3DBroadcastTest<armnn::DataType::Float16>(
532     armnn::IWorkloadFactory& workloadFactory,
533     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
534     const armnn::ITensorHandleFactory& tensorHandleFactory);
535 
536 template LayerTestResult<armnn::ResolveType<armnn::DataType::QAsymmS8>, 3>
537 BatchMatMul3DBroadcastTest<armnn::DataType::QAsymmS8>(
538     armnn::IWorkloadFactory& workloadFactory,
539     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
540     const armnn::ITensorHandleFactory& tensorHandleFactory);
541 
542 template LayerTestResult<armnn::ResolveType<armnn::DataType::QAsymmU8>, 3>
543 BatchMatMul3DBroadcastTest<armnn::DataType::QAsymmU8>(
544     armnn::IWorkloadFactory& workloadFactory,
545     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
546     const armnn::ITensorHandleFactory& tensorHandleFactory);
547 
548 template LayerTestResult<armnn::ResolveType<armnn::DataType::QSymmS16>, 3>
549 BatchMatMul3DBroadcastTest<armnn::DataType::QSymmS16>(
550     armnn::IWorkloadFactory& workloadFactory,
551     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
552     const armnn::ITensorHandleFactory& tensorHandleFactory);
553 
554 template<armnn::DataType ArmnnType, typename T>
BatchMatMul3D2DBroadcastTest(armnn::IWorkloadFactory & workloadFactory,const armnn::IBackendInternal::IMemoryManagerSharedPtr & memoryManager,const armnn::ITensorHandleFactory & tensorHandleFactory)555 LayerTestResult<T, 3> BatchMatMul3D2DBroadcastTest(
556     armnn::IWorkloadFactory& workloadFactory,
557     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
558     const armnn::ITensorHandleFactory& tensorHandleFactory)
559 {
560     auto descriptor = armnn::BatchMatMulDescriptor(); // Arbitrary layout with no transpose/adjointing
561 
562     float qScale = 1.0f;
563     int32_t qOffset = 0;
564 
565     armnn::TensorInfo inputXInfo({2,2,2}, ArmnnType, qScale, qOffset);
566     armnn::TensorInfo inputYInfo({2,2}, ArmnnType, qScale, qOffset);
567     armnn::TensorInfo outputInfo({2,2,2}, ArmnnType, qScale, qOffset);
568 
569     std::vector<T> inputX = armnnUtils::QuantizedVector<T>({
570        1, 2,
571        3, 4,
572 
573        9, 10,
574        11, 12
575     }, qScale, qOffset);
576 
577     std::vector<T> inputY = armnnUtils::QuantizedVector<T>({
578         13, 14,
579         15, 16
580     }, qScale, qOffset);
581 
582     std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({
583         43, 46,
584         99, 106,
585 
586         267, 286,
587         323, 346
588     }, qScale, qOffset);
589 
590     return BatchMatMulTestImpl<ArmnnType, T, 3>(workloadFactory,
591                                                 memoryManager,
592                                                 tensorHandleFactory,
593                                                 descriptor,
594                                                 inputX,
595                                                 inputY,
596                                                 outputExpected,
597                                                 inputXInfo,
598                                                 inputYInfo,
599                                                 outputInfo);
600 }
601 
602 template LayerTestResult<armnn::ResolveType<armnn::DataType::BFloat16>, 3>
603 BatchMatMul3D2DBroadcastTest<armnn::DataType::BFloat16>(
604     armnn::IWorkloadFactory& workloadFactory,
605     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
606     const armnn::ITensorHandleFactory& tensorHandleFactory);
607 
608 template LayerTestResult<armnn::ResolveType<armnn::DataType::Float32>, 3>
609 BatchMatMul3D2DBroadcastTest<armnn::DataType::Float32>(
610     armnn::IWorkloadFactory& workloadFactory,
611     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
612     const armnn::ITensorHandleFactory& tensorHandleFactory);
613 
614 template LayerTestResult<armnn::ResolveType<armnn::DataType::Float16>, 3>
615 BatchMatMul3D2DBroadcastTest<armnn::DataType::Float16>(
616     armnn::IWorkloadFactory& workloadFactory,
617     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
618     const armnn::ITensorHandleFactory& tensorHandleFactory);
619 
620 template LayerTestResult<armnn::ResolveType<armnn::DataType::QAsymmS8>, 3>
621 BatchMatMul3D2DBroadcastTest<armnn::DataType::QAsymmS8>(
622     armnn::IWorkloadFactory& workloadFactory,
623     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
624     const armnn::ITensorHandleFactory& tensorHandleFactory);
625 
626 template LayerTestResult<armnn::ResolveType<armnn::DataType::QAsymmU8>, 3>
627 BatchMatMul3D2DBroadcastTest<armnn::DataType::QAsymmU8>(
628     armnn::IWorkloadFactory& workloadFactory,
629     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
630     const armnn::ITensorHandleFactory& tensorHandleFactory);
631 
632 template LayerTestResult<armnn::ResolveType<armnn::DataType::QSymmS16>, 3>
633 BatchMatMul3D2DBroadcastTest<armnn::DataType::QSymmS16>(
634     armnn::IWorkloadFactory& workloadFactory,
635     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
636     const armnn::ITensorHandleFactory& tensorHandleFactory);
637 
638 template<armnn::DataType ArmnnType, typename T>
BatchMatMulNDHWCNHWCTest(armnn::IWorkloadFactory & workloadFactory,const armnn::IBackendInternal::IMemoryManagerSharedPtr & memoryManager,const armnn::ITensorHandleFactory & tensorHandleFactory)639 LayerTestResult<T, 5> BatchMatMulNDHWCNHWCTest(
640     armnn::IWorkloadFactory& workloadFactory,
641     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
642     const armnn::ITensorHandleFactory& tensorHandleFactory)
643 {
644     auto descriptor = armnn::BatchMatMulDescriptor(false,
645                                                    false,
646                                                    false,
647                                                    false,
648                                                    armnn::DataLayout::NDHWC,
649                                                    armnn::DataLayout::NHWC);
650 
651     float qScale = 1.0f;
652     int32_t qOffset = 0;
653 
654     armnn::TensorInfo inputXInfo({1,1,2,2,2}, ArmnnType, qScale, qOffset);
655     armnn::TensorInfo inputYInfo({1,2,2,2}, ArmnnType, qScale, qOffset);
656     armnn::TensorInfo outputInfo({1,1,2,2,2}, ArmnnType, qScale, qOffset);
657 
658     std::vector<T> inputX = armnnUtils::QuantizedVector<T>({
659         1, 20,
660         3, 22,
661 
662         2, 21,
663         4, 23
664     }, qScale, qOffset);
665 
666     std::vector<T> inputY = armnnUtils::QuantizedVector<T>({
667         5, 24,
668         7, 26,
669 
670         6, 25,
671         8, 27
672     }, qScale, qOffset);
673 
674     std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({
675        23, 1030,
676        31, 1114,
677 
678        34, 1079,
679        46, 1167
680     }, qScale, qOffset);
681 
682     return BatchMatMulTestImpl<ArmnnType, T, 5>(workloadFactory,
683                                                 memoryManager,
684                                                 tensorHandleFactory,
685                                                 descriptor,
686                                                 inputX,
687                                                 inputY,
688                                                 outputExpected,
689                                                 inputXInfo,
690                                                 inputYInfo,
691                                                 outputInfo);
692 }
693 
694 template LayerTestResult<armnn::ResolveType<armnn::DataType::BFloat16>, 5>
695 BatchMatMulNDHWCNHWCTest<armnn::DataType::BFloat16>(
696     armnn::IWorkloadFactory& workloadFactory,
697     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
698     const armnn::ITensorHandleFactory& tensorHandleFactory);
699 
700 template LayerTestResult<armnn::ResolveType<armnn::DataType::Float32>, 5>
701 BatchMatMulNDHWCNHWCTest<armnn::DataType::Float32>(
702     armnn::IWorkloadFactory& workloadFactory,
703     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
704     const armnn::ITensorHandleFactory& tensorHandleFactory);
705 
706 template LayerTestResult<armnn::ResolveType<armnn::DataType::Float16>, 5>
707 BatchMatMulNDHWCNHWCTest<armnn::DataType::Float16>(
708     armnn::IWorkloadFactory& workloadFactory,
709     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
710     const armnn::ITensorHandleFactory& tensorHandleFactory);
711 
712 template LayerTestResult<armnn::ResolveType<armnn::DataType::QAsymmS8>, 5>
713 BatchMatMulNDHWCNHWCTest<armnn::DataType::QAsymmS8>(
714     armnn::IWorkloadFactory& workloadFactory,
715     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
716     const armnn::ITensorHandleFactory& tensorHandleFactory);
717 
718 template LayerTestResult<armnn::ResolveType<armnn::DataType::QAsymmU8>, 5>
719 BatchMatMulNDHWCNHWCTest<armnn::DataType::QAsymmU8>(
720     armnn::IWorkloadFactory& workloadFactory,
721     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
722     const armnn::ITensorHandleFactory& tensorHandleFactory);
723 
724 template LayerTestResult<armnn::ResolveType<armnn::DataType::QSymmS16>, 5>
725 BatchMatMulNDHWCNHWCTest<armnn::DataType::QSymmS16>(
726     armnn::IWorkloadFactory& workloadFactory,
727     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
728     const armnn::ITensorHandleFactory& tensorHandleFactory);
729 
730 template<armnn::DataType ArmnnType, typename T>
BatchMatMul2DTinyTest(armnn::IWorkloadFactory & workloadFactory,const armnn::IBackendInternal::IMemoryManagerSharedPtr & memoryManager,const armnn::ITensorHandleFactory & tensorHandleFactory)731 LayerTestResult<T, 2> BatchMatMul2DTinyTest(
732     armnn::IWorkloadFactory& workloadFactory,
733     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
734     const armnn::ITensorHandleFactory& tensorHandleFactory)
735 {
736     auto descriptor = armnn::BatchMatMulDescriptor(); // Arbitrary layout with no transpose/adjointing
737 
738     float qScale = 1.0f;
739     int32_t qOffset = 0;
740 
741     armnn::TensorInfo inputXInfo({1,1}, ArmnnType, qScale, qOffset);
742     armnn::TensorInfo inputYInfo({1,1}, ArmnnType, qScale, qOffset);
743     armnn::TensorInfo outputInfo({1,1}, ArmnnType, qScale, qOffset);
744 
745     std::vector<T> inputX = armnnUtils::QuantizedVector<T>({
746        3
747     }, qScale, qOffset);
748 
749     std::vector<T> inputY = armnnUtils::QuantizedVector<T>({
750         5
751     }, qScale, qOffset);
752 
753     std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({
754         15
755     }, qScale, qOffset);
756 
757     return BatchMatMulTestImpl<ArmnnType, T, 2>(workloadFactory,
758                                              memoryManager,
759                                              tensorHandleFactory,
760                                              descriptor,
761                                              inputX,
762                                              inputY,
763                                              outputExpected,
764                                              inputXInfo,
765                                              inputYInfo,
766                                              outputInfo);
767 }
768 
769 template LayerTestResult<armnn::ResolveType<armnn::DataType::BFloat16>, 2>
770 BatchMatMul2DTinyTest<armnn::DataType::BFloat16>(
771     armnn::IWorkloadFactory& workloadFactory,
772     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
773     const armnn::ITensorHandleFactory& tensorHandleFactory);
774 
775 template LayerTestResult<armnn::ResolveType<armnn::DataType::Float32>, 2>
776 BatchMatMul2DTinyTest<armnn::DataType::Float32>(
777     armnn::IWorkloadFactory& workloadFactory,
778     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
779     const armnn::ITensorHandleFactory& tensorHandleFactory);
780 
781 template LayerTestResult<armnn::ResolveType<armnn::DataType::Float16>, 2>
782 BatchMatMul2DTinyTest<armnn::DataType::Float16>(
783     armnn::IWorkloadFactory& workloadFactory,
784     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
785     const armnn::ITensorHandleFactory& tensorHandleFactory);
786 
787 template LayerTestResult<armnn::ResolveType<armnn::DataType::QAsymmS8>, 2>
788 BatchMatMul2DTinyTest<armnn::DataType::QAsymmS8>(
789     armnn::IWorkloadFactory& workloadFactory,
790     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
791     const armnn::ITensorHandleFactory& tensorHandleFactory);
792 
793 template LayerTestResult<armnn::ResolveType<armnn::DataType::QAsymmU8>, 2>
794 BatchMatMul2DTinyTest<armnn::DataType::QAsymmU8>(
795     armnn::IWorkloadFactory& workloadFactory,
796     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
797     const armnn::ITensorHandleFactory& tensorHandleFactory);
798 
799 template LayerTestResult<armnn::ResolveType<armnn::DataType::QSymmS16>, 2>
800 BatchMatMul2DTinyTest<armnn::DataType::QSymmS16>(
801     armnn::IWorkloadFactory& workloadFactory,
802     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
803     const armnn::ITensorHandleFactory& tensorHandleFactory);
804 
805 template<armnn::DataType ArmnnType, typename T>
BatchMatMul3DNonSquareTest(armnn::IWorkloadFactory & workloadFactory,const armnn::IBackendInternal::IMemoryManagerSharedPtr & memoryManager,const armnn::ITensorHandleFactory & tensorHandleFactory)806 LayerTestResult<T, 3> BatchMatMul3DNonSquareTest(
807     armnn::IWorkloadFactory& workloadFactory,
808     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
809     const armnn::ITensorHandleFactory& tensorHandleFactory)
810 {
811     auto descriptor = armnn::BatchMatMulDescriptor(); // Arbitrary layout with no transpose/adjointing
812 
813     float qScale = 1.0f;
814     int32_t qOffset = 0;
815 
816     armnn::TensorInfo inputXInfo({2,5,3}, ArmnnType, qScale, qOffset);
817     armnn::TensorInfo inputYInfo({2,3,4}, ArmnnType, qScale, qOffset);
818     armnn::TensorInfo outputInfo({2,5,4}, ArmnnType, qScale, qOffset);
819 
820     std::vector<T> inputX = armnnUtils::QuantizedVector<T>({
821        8, 8, 4,
822        6, 1, 3,
823        8, 8, 3,
824        8, 9, 8,
825        5, 4, 4,
826 
827        1, 8, 5,
828        7, 1, 1,
829        8, 7, 9,
830        3, 2, 7,
831        8, 5, 3
832     }, qScale, qOffset);
833 
834     std::vector<T> inputY = armnnUtils::QuantizedVector<T>({
835         6, 2, 3, 2,
836         6, 2, 2, 8,
837         3, 7, 8, 1,
838 
839         7, 2, 9, 5,
840         2, 3, 1, 3,
841         2, 7, 7, 5
842     }, qScale, qOffset);
843 
844     std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({
845         108, 60, 72, 84,
846         51, 35, 44, 23,
847         105, 53, 64, 83,
848         126, 90, 106, 96,
849         66, 46, 55, 46,
850 
851         33, 61, 52, 54,
852         53, 24, 71, 43,
853         88, 100, 142, 106,
854         39, 61, 78, 56,
855         72, 52, 98, 70
856     }, qScale, qOffset);
857 
858     return BatchMatMulTestImpl<ArmnnType, T, 3>(workloadFactory,
859                                                 memoryManager,
860                                                 tensorHandleFactory,
861                                                 descriptor,
862                                                 inputX,
863                                                 inputY,
864                                                 outputExpected,
865                                                 inputXInfo,
866                                                 inputYInfo,
867                                                 outputInfo);
868 }
869 
870 template LayerTestResult<armnn::ResolveType<armnn::DataType::BFloat16>, 3>
871 BatchMatMul3DNonSquareTest<armnn::DataType::BFloat16>(
872     armnn::IWorkloadFactory& workloadFactory,
873     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
874     const armnn::ITensorHandleFactory& tensorHandleFactory);
875 
876 template LayerTestResult<armnn::ResolveType<armnn::DataType::Float32>, 3>
877 BatchMatMul3DNonSquareTest<armnn::DataType::Float32>(
878     armnn::IWorkloadFactory& workloadFactory,
879     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
880     const armnn::ITensorHandleFactory& tensorHandleFactory);
881 
882 template LayerTestResult<armnn::ResolveType<armnn::DataType::Float16>, 3>
883 BatchMatMul3DNonSquareTest<armnn::DataType::Float16>(
884     armnn::IWorkloadFactory& workloadFactory,
885     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
886     const armnn::ITensorHandleFactory& tensorHandleFactory);
887 
888 template LayerTestResult<armnn::ResolveType<armnn::DataType::QAsymmS8>, 3>
889 BatchMatMul3DNonSquareTest<armnn::DataType::QAsymmS8>(
890     armnn::IWorkloadFactory& workloadFactory,
891     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
892     const armnn::ITensorHandleFactory& tensorHandleFactory);
893 
894 template LayerTestResult<armnn::ResolveType<armnn::DataType::QAsymmU8>, 3>
895 BatchMatMul3DNonSquareTest<armnn::DataType::QAsymmU8>(
896     armnn::IWorkloadFactory& workloadFactory,
897     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
898     const armnn::ITensorHandleFactory& tensorHandleFactory);
899 
900 template LayerTestResult<armnn::ResolveType<armnn::DataType::QSymmS16>, 3>
901 BatchMatMul3DNonSquareTest<armnn::DataType::QSymmS16>(
902     armnn::IWorkloadFactory& workloadFactory,
903     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
904     const armnn::ITensorHandleFactory& tensorHandleFactory);
905 
906 template<armnn::DataType ArmnnType, typename T>
BatchMatMul2DTranspSimpleTest(armnn::IWorkloadFactory & workloadFactory,const armnn::IBackendInternal::IMemoryManagerSharedPtr & memoryManager,const armnn::ITensorHandleFactory & tensorHandleFactory)907 LayerTestResult<T, 2> BatchMatMul2DTranspSimpleTest(
908     armnn::IWorkloadFactory& workloadFactory,
909     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
910     const armnn::ITensorHandleFactory& tensorHandleFactory)
911 {
912     auto descriptor = armnn::BatchMatMulDescriptor(true,
913                                                    false,
914                                                    false,
915                                                    false);
916 
917     float qScale = 1.0f;
918     int32_t qOffset = 0;
919 
920     armnn::TensorInfo inputXInfo({2,3}, ArmnnType, qScale, qOffset);
921     armnn::TensorInfo inputYInfo({2,3}, ArmnnType, qScale, qOffset);
922     armnn::TensorInfo outputInfo({3,3}, ArmnnType, qScale, qOffset);
923 
924     std::vector<T> inputX = armnnUtils::QuantizedVector<T>({
925         1, 2, 3,
926         4, 5, 6
927     }, qScale, qOffset);
928 
929     std::vector<T> inputY = armnnUtils::QuantizedVector<T>({
930         7, 8, 9,
931         10, 11, 12
932     }, qScale, qOffset);
933 
934     std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({
935         47, 52, 57,
936         64, 71, 78,
937         81, 90, 99
938     }, qScale, qOffset);
939 
940     return BatchMatMulTestImpl<ArmnnType, T, 2>(workloadFactory,
941                                                 memoryManager,
942                                                 tensorHandleFactory,
943                                                 descriptor,
944                                                 inputX,
945                                                 inputY,
946                                                 outputExpected,
947                                                 inputXInfo,
948                                                 inputYInfo,
949                                                 outputInfo);
950 }
951 
952 template LayerTestResult<armnn::ResolveType<armnn::DataType::BFloat16>, 2>
953 BatchMatMul2DTranspSimpleTest<armnn::DataType::BFloat16>(
954     armnn::IWorkloadFactory& workloadFactory,
955     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
956     const armnn::ITensorHandleFactory& tensorHandleFactory);
957 
958 template LayerTestResult<armnn::ResolveType<armnn::DataType::Float32>, 2>
959 BatchMatMul2DTranspSimpleTest<armnn::DataType::Float32>(
960     armnn::IWorkloadFactory& workloadFactory,
961     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
962     const armnn::ITensorHandleFactory& tensorHandleFactory);
963 
964 template LayerTestResult<armnn::ResolveType<armnn::DataType::Float16>, 2>
965 BatchMatMul2DTranspSimpleTest<armnn::DataType::Float16>(
966     armnn::IWorkloadFactory& workloadFactory,
967     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
968     const armnn::ITensorHandleFactory& tensorHandleFactory);
969 
970 template LayerTestResult<armnn::ResolveType<armnn::DataType::QAsymmS8>, 2>
971 BatchMatMul2DTranspSimpleTest<armnn::DataType::QAsymmS8>(
972     armnn::IWorkloadFactory& workloadFactory,
973     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
974     const armnn::ITensorHandleFactory& tensorHandleFactory);
975 
976 template LayerTestResult<armnn::ResolveType<armnn::DataType::QAsymmU8>, 2>
977 BatchMatMul2DTranspSimpleTest<armnn::DataType::QAsymmU8>(
978     armnn::IWorkloadFactory& workloadFactory,
979     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
980     const armnn::ITensorHandleFactory& tensorHandleFactory);
981 
982 template LayerTestResult<armnn::ResolveType<armnn::DataType::QSymmS16>, 2>
983 BatchMatMul2DTranspSimpleTest<armnn::DataType::QSymmS16>(
984     armnn::IWorkloadFactory& workloadFactory,
985     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
986     const armnn::ITensorHandleFactory& tensorHandleFactory);
987 
988 template<armnn::DataType ArmnnType, typename T>
BatchMatMul2DAdjointSimpleTest(armnn::IWorkloadFactory & workloadFactory,const armnn::IBackendInternal::IMemoryManagerSharedPtr & memoryManager,const armnn::ITensorHandleFactory & tensorHandleFactory)989 LayerTestResult<T, 2> BatchMatMul2DAdjointSimpleTest(
990     armnn::IWorkloadFactory& workloadFactory,
991     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
992     const armnn::ITensorHandleFactory& tensorHandleFactory)
993 {
994     auto descriptor = armnn::BatchMatMulDescriptor(false,
995                                                    false,
996                                                    true,
997                                                    false);
998 
999     float qScale = 1.0f;
1000     int32_t qOffset = 0;
1001 
1002     armnn::TensorInfo inputXInfo({3,3}, ArmnnType, qScale, qOffset);
1003     armnn::TensorInfo inputYInfo({3,3}, ArmnnType, qScale, qOffset);
1004     armnn::TensorInfo outputInfo({3,3}, ArmnnType, qScale, qOffset);
1005 
1006     std::vector<T> inputX = armnnUtils::QuantizedVector<T>({
1007         3, 1, 1,
1008         1, 3, -1,
1009         2, 4, 1
1010     }, qScale, qOffset);
1011 
1012     std::vector<T> inputY = armnnUtils::QuantizedVector<T>({
1013         1, 0, 0,
1014         0, 1, 0,
1015         0, 0, 1
1016     }, qScale, qOffset);
1017 
1018     std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({
1019         7, 3, -4,
1020         -3, 1, 4,
1021         -2, -10, 8
1022     }, qScale, qOffset);
1023 
1024     switch (ArmnnType)
1025     {
1026         case armnn::DataType::QAsymmU8:
1027             outputExpected = armnnUtils::QuantizedVector<T>({
1028                 3, 3, 0,
1029                 0, 1, 1,
1030                 0, 0, 8
1031             }, qScale, qOffset);
1032             break;
1033         default:
1034             break;
1035     }
1036 
1037     return BatchMatMulTestImpl<ArmnnType, T, 2>(workloadFactory,
1038                                                 memoryManager,
1039                                                 tensorHandleFactory,
1040                                                 descriptor,
1041                                                 inputX,
1042                                                 inputY,
1043                                                 outputExpected,
1044                                                 inputXInfo,
1045                                                 inputYInfo,
1046                                                 outputInfo);
1047 }
1048 
1049 template LayerTestResult<armnn::ResolveType<armnn::DataType::BFloat16>, 2>
1050 BatchMatMul2DAdjointSimpleTest<armnn::DataType::BFloat16>(
1051     armnn::IWorkloadFactory& workloadFactory,
1052     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1053     const armnn::ITensorHandleFactory& tensorHandleFactory);
1054 
1055 template LayerTestResult<armnn::ResolveType<armnn::DataType::Float32>, 2>
1056 BatchMatMul2DAdjointSimpleTest<armnn::DataType::Float32>(
1057     armnn::IWorkloadFactory& workloadFactory,
1058     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1059     const armnn::ITensorHandleFactory& tensorHandleFactory);
1060 
1061 template LayerTestResult<armnn::ResolveType<armnn::DataType::Float16>, 2>
1062 BatchMatMul2DAdjointSimpleTest<armnn::DataType::Float16>(
1063     armnn::IWorkloadFactory& workloadFactory,
1064     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1065     const armnn::ITensorHandleFactory& tensorHandleFactory);
1066 
1067 template LayerTestResult<armnn::ResolveType<armnn::DataType::QAsymmS8>, 2>
1068 BatchMatMul2DAdjointSimpleTest<armnn::DataType::QAsymmS8>(
1069     armnn::IWorkloadFactory& workloadFactory,
1070     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1071     const armnn::ITensorHandleFactory& tensorHandleFactory);
1072 
1073 template LayerTestResult<armnn::ResolveType<armnn::DataType::QAsymmU8>, 2>
1074 BatchMatMul2DAdjointSimpleTest<armnn::DataType::QAsymmU8>(
1075     armnn::IWorkloadFactory& workloadFactory,
1076     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1077     const armnn::ITensorHandleFactory& tensorHandleFactory);
1078 
1079 template LayerTestResult<armnn::ResolveType<armnn::DataType::QSymmS16>, 2>
1080 BatchMatMul2DAdjointSimpleTest<armnn::DataType::QSymmS16>(
1081     armnn::IWorkloadFactory& workloadFactory,
1082     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1083     const armnn::ITensorHandleFactory& tensorHandleFactory);
1084 
1085 template<armnn::DataType ArmnnType, typename T>
BatchMatMulNHWCParamsTest(armnn::IWorkloadFactory & workloadFactory,const armnn::IBackendInternal::IMemoryManagerSharedPtr & memoryManager,const armnn::ITensorHandleFactory & tensorHandleFactory)1086 LayerTestResult<T, 4> BatchMatMulNHWCParamsTest(
1087     armnn::IWorkloadFactory& workloadFactory,
1088     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1089     const armnn::ITensorHandleFactory& tensorHandleFactory)
1090 {
1091     auto descriptor = armnn::BatchMatMulDescriptor(false,
1092                                                    true,
1093                                                    true,
1094                                                    false,
1095                                                    armnn::DataLayout::NHWC,
1096                                                    armnn::DataLayout::NHWC);
1097 
1098     float qScale = 1.0f;
1099     int32_t qOffset = 0;
1100 
1101     armnn::TensorInfo inputXInfo({1,4,4,2}, ArmnnType, qScale, qOffset);
1102     armnn::TensorInfo inputYInfo({2,2,4,1}, ArmnnType, qScale, qOffset);
1103     armnn::TensorInfo outputInfo({2,4,2,2}, ArmnnType, qScale, qOffset);
1104 
1105     std::vector<T> inputX = armnnUtils::QuantizedVector<T>({
1106        1, -3, 1, 4, 4, 9, 1, 2,
1107        2, 4, 2, 2, 10, 7, 6, -5,
1108        3, 8, 9, 9, 21, 1, 17, 7,
1109        5, 11, 11, 8, 29, 3, 23, 6
1110     }, qScale, qOffset);
1111 
1112     std::vector<T> inputY = armnnUtils::QuantizedVector<T>({
1113         1, 2, 3, 4,
1114         5, 6, 7, 8,
1115 
1116         9, 10, 11, 12,
1117         13, 14, 15, 16
1118     }, qScale, qOffset);
1119 
1120     std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({
1121         28, 625, 140, 585,
1122         8, 110, -8, 1662,
1123         -24, 401, -120, 921,
1124         12, 131, 108, -501,
1125 
1126         252, 545, 364, 505,
1127         -24, 3214, -40, 4766,
1128         -216, 1441, -312, 1961,
1129         204, -1133, 300, -1765
1130     }, qScale, qOffset);
1131 
1132     switch (ArmnnType)
1133     {
1134         case armnn::DataType::QAsymmU8:
1135             outputExpected = armnnUtils::QuantizedVector<T>({
1136                 28, 80, 140, 80,
1137                 8, 45, 0, 255,
1138                 0, 18, 0, 18,
1139                 12, 0, 108, 0,
1140 
1141                 252, 80, 255, 80,
1142                 0, 255, 0, 255,
1143                 0, 18, 0, 18,
1144                 204, 0, 255, 0
1145             }, qScale, qOffset);
1146             break;
1147         default:
1148             break;
1149     }
1150 
1151     return BatchMatMulTestImpl<ArmnnType, T, 4>(workloadFactory,
1152                                                 memoryManager,
1153                                                 tensorHandleFactory,
1154                                                 descriptor,
1155                                                 inputX,
1156                                                 inputY,
1157                                                 outputExpected,
1158                                                 inputXInfo,
1159                                                 inputYInfo,
1160                                                 outputInfo);
1161 }
1162 
1163 template LayerTestResult<armnn::ResolveType<armnn::DataType::BFloat16>, 4>
1164 BatchMatMulNHWCParamsTest<armnn::DataType::BFloat16>(
1165     armnn::IWorkloadFactory& workloadFactory,
1166     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1167     const armnn::ITensorHandleFactory& tensorHandleFactory);
1168 
1169 template LayerTestResult<armnn::ResolveType<armnn::DataType::Float32>, 4>
1170 BatchMatMulNHWCParamsTest<armnn::DataType::Float32>(
1171     armnn::IWorkloadFactory& workloadFactory,
1172     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1173     const armnn::ITensorHandleFactory& tensorHandleFactory);
1174 
1175 template LayerTestResult<armnn::ResolveType<armnn::DataType::Float16>, 4>
1176 BatchMatMulNHWCParamsTest<armnn::DataType::Float16>(
1177     armnn::IWorkloadFactory& workloadFactory,
1178     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1179     const armnn::ITensorHandleFactory& tensorHandleFactory);
1180 
1181 template LayerTestResult<armnn::ResolveType<armnn::DataType::QAsymmS8>, 4>
1182 BatchMatMulNHWCParamsTest<armnn::DataType::QAsymmS8>(
1183     armnn::IWorkloadFactory& workloadFactory,
1184     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1185     const armnn::ITensorHandleFactory& tensorHandleFactory);
1186 
1187 template LayerTestResult<armnn::ResolveType<armnn::DataType::QAsymmU8>, 4>
1188 BatchMatMulNHWCParamsTest<armnn::DataType::QAsymmU8>(
1189     armnn::IWorkloadFactory& workloadFactory,
1190     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1191     const armnn::ITensorHandleFactory& tensorHandleFactory);
1192 
1193 template LayerTestResult<armnn::ResolveType<armnn::DataType::QSymmS16>, 4>
1194 BatchMatMulNHWCParamsTest<armnn::DataType::QSymmS16>(
1195     armnn::IWorkloadFactory& workloadFactory,
1196     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1197     const armnn::ITensorHandleFactory& tensorHandleFactory);