Compute Library
 21.02
NEGEMM.cpp
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2017-2020 Arm Limited.
3  *
4  * SPDX-License-Identifier: MIT
5  *
6  * Permission is hereby granted, free of charge, to any person obtaining a copy
7  * of this software and associated documentation files (the "Software"), to
8  * deal in the Software without restriction, including without limitation the
9  * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
10  * sell copies of the Software, and to permit persons to whom the Software is
11  * furnished to do so, subject to the following conditions:
12  *
13  * The above copyright notice and this permission notice shall be included in all
14  * copies or substantial portions of the Software.
15  *
16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
22  * SOFTWARE.
23  */
25 
26 #include "arm_compute/core/Error.h"
30 #include "arm_compute/core/Types.h"
35 #include "src/core/CPP/Validate.h"
42 
43 #include <cmath>
44 
46 
47 namespace arm_compute
48 {
49 namespace
50 {
51 AsmGemmInfo init_assembly_metadata(const GEMMInfo &info)
52 {
53  AsmGemmInfo asm_info;
54  asm_info.method = AsmConvMethod::Im2Col;
55  asm_info.reinterpret_input_as_3d = info.reinterpret_input_as_3d();
56  asm_info.depth_output_gemm3d = info.depth_output_gemm3d();
57  asm_info.activation_info = info.activation_info();
58 
59  return asm_info;
60 }
61 } // namespace
62 
63 NEGEMM::NEGEMM(std::shared_ptr<IMemoryManager> memory_manager, IWeightsManager *weights_manager)
64  : _memory_group(memory_manager), _weights_manager(weights_manager), _interleave_kernel(), _transpose_kernel(), _mm_kernel(), _asm_glue(std::make_unique<NEGEMMAssemblyDispatch>()), _ma_kernel(),
65  _alpha_scale_func(nullptr), _add_bias(), _activation_func(), _tmp_a(), _tmp_b(), _tmp_d(), _original_b(nullptr), _run_vector_matrix_multiplication(false), _run_alpha_scale(false),
66  _run_addition(false), _run_bias_addition(false), _run_activation(false), _reshape_b_only_on_first_run(false), _is_prepared(false)
67 {
68 }
69 
70 NEGEMM::~NEGEMM() = default;
71 
72 void NEGEMM::configure(const ITensor *a, const ITensor *b, const ITensor *c, ITensor *d, float alpha, float beta, const GEMMInfo &gemm_info)
73 {
74  ARM_COMPUTE_ERROR_THROW_ON(NEGEMM::validate(a->info(), b->info(), (c != nullptr) ? c->info() : nullptr, d->info(), alpha, beta, gemm_info));
75 
76  const AsmGemmInfo asm_info = init_assembly_metadata(gemm_info);
77  const bool is_c_bias = gemm_info.reshape_b_only_on_first_run();
78  bool run_optimised = bool(NEGEMMAssemblyDispatch::validate(a->info(), b->info(), (is_c_bias && c != nullptr) ? c->info() : nullptr, d->info(), asm_info));
79 
80  // Check if we need to reshape the matrix B only on the first run
81  _is_prepared = false;
82  _reshape_b_only_on_first_run = gemm_info.reshape_b_only_on_first_run();
83  _run_vector_matrix_multiplication = a->info()->dimension(1) < 2;
84  _original_b = b;
85  _run_alpha_scale = alpha != 1.f;
86  _run_bias_addition = c != nullptr && gemm_info.reshape_b_only_on_first_run();
87  _run_addition = beta != 0 && c != nullptr && !gemm_info.reshape_b_only_on_first_run();
88  _run_activation = gemm_info.activation_info().enabled() && (!run_optimised || (run_optimised && !NEGEMMAssemblyDispatch::is_activation_supported(gemm_info.activation_info())));
89 
90  if(run_optimised)
91  {
92  const ITensor *c_to_use = is_c_bias ? c : nullptr;
93  _asm_glue->configure(a, b, c_to_use, d, asm_info);
94  ARM_COMPUTE_ERROR_ON(!_asm_glue->is_configured());
95 
96  // Scale product by alpha
97  if(_run_alpha_scale)
98  {
99  _alpha_scale_func.configure(d, nullptr, ActivationLayerInfo(ActivationLayerInfo::ActivationFunction::LINEAR, alpha, 0.f));
100  }
101  }
102  else
103  {
104  // Pick output tensor in case bias addition should be performed
105  ITensor *gemm_output_to_use = d;
106  if(_run_bias_addition)
107  {
108  gemm_output_to_use = &_tmp_d;
109  _memory_group.manage(&_tmp_d);
110  }
111 
112  _mm_kernel = std::make_unique<NEGEMMMatrixMultiplyKernel>();
113 
114  // Select between GEMV and GEMM
115  if(_run_vector_matrix_multiplication)
116  {
117  // Configure the matrix multiply kernel
118  _mm_kernel->configure(a, b, gemm_output_to_use, alpha, false);
119  }
120  else
121  {
122  TensorShape shape_tmp_a = a->info()->tensor_shape();
123  TensorShape shape_tmp_b = b->info()->tensor_shape();
124 
125  shape_tmp_a.set(0, a->info()->dimension(0) * 4);
126  shape_tmp_a.set(1, std::ceil(a->info()->dimension(1) / 4.0f));
127 
128  const unsigned int transpose_w = 16 / data_size_from_type(b->info()->data_type());
129  shape_tmp_b.set(0, b->info()->dimension(1) * transpose_w);
130  shape_tmp_b.set(1, std::ceil(b->info()->dimension(0) / static_cast<float>(transpose_w)));
131 
132  TensorInfo info_a = a->info()->clone()->set_tensor_shape(shape_tmp_a).set_is_resizable(true);
133  TensorInfo info_b = b->info()->clone()->set_tensor_shape(shape_tmp_b).set_is_resizable(true);
134 
135  _tmp_a.allocator()->init(info_a);
136  _tmp_b.allocator()->init(info_b);
137 
138  // Manage intermediate buffers
139  _memory_group.manage(&_tmp_a);
140  if(!_reshape_b_only_on_first_run)
141  {
142  _memory_group.manage(&_tmp_b);
143  }
144 
145  int m = a->info()->dimension(1);
146  int n = b->info()->dimension(0);
147  int k = a->info()->dimension(0);
148 
149  // Configure interleave kernel
150  _interleave_kernel = std::make_unique<NEGEMMInterleave4x4Kernel>();
151  _interleave_kernel->configure(a, &_tmp_a);
152 
153  // Configure transpose kernel
154  _transpose_kernel = std::make_unique<NEGEMMTranspose1xWKernel>();
155  _transpose_kernel->configure(b, &_tmp_b);
156 
157  // Configure matrix multiplication kernel
158  _mm_kernel->configure(&_tmp_a, &_tmp_b, gemm_output_to_use, alpha, true, GEMMReshapeInfo(m, n, k));
159 
160  // Allocate once the all configure methods have been called
161  _tmp_a.allocator()->allocate();
162  if(!_reshape_b_only_on_first_run)
163  {
164  _tmp_b.allocator()->allocate();
165  }
166  }
167 
168  if(_run_bias_addition)
169  {
170  _add_bias.configure(gemm_output_to_use, c, d, ConvertPolicy::SATURATE);
171  _tmp_d.allocator()->allocate();
172  }
173  }
174 
175  // Configure matrix addition kernel
176  if(_run_addition)
177  {
178  _ma_kernel = std::make_unique<NEGEMMMatrixAdditionKernel>();
179  _ma_kernel->configure(c, d, beta);
180  }
181 
182  // Configure activation
183  const ActivationLayerInfo &activation = gemm_info.activation_info();
184  if(_run_activation)
185  {
186  _activation_func.configure(d, nullptr, activation);
187  }
188 }
189 
190 Status NEGEMM::validate(const ITensorInfo *a, const ITensorInfo *b, const ITensorInfo *c, const ITensorInfo *output, float alpha, float beta, const GEMMInfo &gemm_info)
191 {
192  ARM_COMPUTE_UNUSED(alpha);
193  const bool is_c_bias = gemm_info.reshape_b_only_on_first_run();
194 
199  ARM_COMPUTE_RETURN_ERROR_ON_MSG(a->dimension(0) != b->dimension(1), "The product AB is defined only if the number of columns in A is equal to the number of rows in B");
200  ARM_COMPUTE_RETURN_ERROR_ON_MSG(gemm_info.is_a_reshaped(), "Matrix A already reshaped is not supported");
201  ARM_COMPUTE_RETURN_ERROR_ON_MSG(gemm_info.is_b_reshaped(), "Matrix B already reshaped is not supported");
202  if(a->data_type() != DataType::BFLOAT16)
203  {
205  }
206 
207  if(c != nullptr && !is_c_bias)
208  {
212  ARM_COMPUTE_RETURN_ERROR_ON_MSG(a->dimension(1) != c->dimension(1), "The C matrix must have the same number of rows as the matrix A");
213  ARM_COMPUTE_RETURN_ERROR_ON_MSG(b->dimension(0) != c->dimension(0), "The C matrix must have the same number of columns as the matrix B");
214  }
215 
216  if(output->total_size() != 0)
217  {
218  ARM_COMPUTE_RETURN_ERROR_ON(b->dimension(0) != output->dimension(0));
219  if(gemm_info.depth_output_gemm3d() != 0)
220  {
221  if(gemm_info.reinterpret_input_as_3d())
222  {
223  ARM_COMPUTE_RETURN_ERROR_ON(a->dimension(1) != output->dimension(1));
224  ARM_COMPUTE_RETURN_ERROR_ON(a->dimension(2) != output->dimension(2));
225  }
226  else
227  {
228  ARM_COMPUTE_RETURN_ERROR_ON(a->dimension(1) != output->dimension(1) * output->dimension(2));
229  }
230  }
231  else
232  {
233  ARM_COMPUTE_RETURN_ERROR_ON(a->dimension(1) != output->dimension(1));
234  }
235  }
236 
237  // Check if we need to run the optimized assembly kernel
238  AsmGemmInfo asm_info = init_assembly_metadata(gemm_info);
239  const bool run_optimised = bool(NEGEMMAssemblyDispatch::validate(a, b, is_c_bias ? c : nullptr, output, asm_info));
240 
241  if(!run_optimised)
242  {
243  ARM_COMPUTE_RETURN_ERROR_ON_MSG(gemm_info.reinterpret_input_as_3d(), "NEGEMM cannot reinterpret the input tensor as 3D");
244  ARM_COMPUTE_RETURN_ERROR_ON_MSG(gemm_info.depth_output_gemm3d() != 0, "NEGEMM cannot reinterpret the output tensor as 3D");
245 
246  // Check if the first input tensor is a vector.
247  const bool run_vector_matrix_multiplication = a->dimension(1) < 2;
248  // Check if we need to reshape the matrix A and matrix B
249  const bool run_interleave_transpose = !run_vector_matrix_multiplication && !(gemm_info.reshape_b_only_on_first_run());
250 
251  // Arguments used by GEMMReshapeInfo
252  // If we pass the matrix A and matrix B reshaped to NEGEMMMatrixMultiplyKernel, we need to pass m, n, k, mult_transpose1xW_width and mult_interleave4x4_height to NEGEMMReshapeInfo
253  // in order to know how the matrices have been reshaped
254  const int m = a->dimension(1);
255  const int n = b->dimension(0);
256  const int k = a->dimension(0);
257  int mult_transpose1xW_width = 1;
258  int mult_interleave4x4_height = 1;
259 
260  const GEMMReshapeInfo reshape_info = GEMMReshapeInfo(m, n, k, mult_transpose1xW_width, mult_interleave4x4_height, gemm_info.depth_output_gemm3d());
261 
262  const ITensorInfo *matrix_a_info = a;
263  const ITensorInfo *matrix_b_info = b;
264 
265  TensorInfo tmp_a_info{};
266  TensorInfo tmp_b_info{};
267  TensorInfo tmp_output_info = *output->clone();
268 
269  if(run_interleave_transpose)
270  {
271  matrix_a_info = &tmp_a_info;
272  matrix_b_info = &tmp_b_info;
273 
274  // Validate interleave kernel
275  auto_init_if_empty(tmp_a_info, a->clone()->set_tensor_shape(compute_interleaved_shape(*a, mult_interleave4x4_height, gemm_info.reinterpret_input_as_3d())));
277 
278  // Validate transpose kernel
279  auto_init_if_empty(tmp_b_info, b->clone()->set_tensor_shape(compute_transpose1xW_with_element_size_shape(*b, mult_transpose1xW_width)));
281  }
282 
283  // Validate matrix multiply
284  auto_init_if_empty(tmp_output_info, matrix_a_info->clone()->set_tensor_shape(compute_mm_shape(*matrix_a_info, *matrix_b_info, run_interleave_transpose, reshape_info)));
285  ARM_COMPUTE_RETURN_ON_ERROR(NEGEMMMatrixMultiplyKernel::validate(matrix_a_info, matrix_b_info, &tmp_output_info, alpha, run_interleave_transpose, reshape_info));
286 
287  if(c != nullptr && gemm_info.reshape_b_only_on_first_run())
288  {
290  }
291  }
292 
293  // Validate matrix addition kernel
294  if(beta != 0 && c != nullptr && !is_c_bias)
295  {
297  }
298 
299  // Validate activation
300  const ActivationLayerInfo &activation = gemm_info.activation_info();
301  if(activation.enabled())
302  {
303  ARM_COMPUTE_RETURN_ON_ERROR(NEActivationLayer::validate(output, nullptr, activation));
304  }
305 
306  return Status{};
307 }
308 
310 {
311  prepare();
312 
313  MemoryGroupResourceScope scope_mg(_memory_group);
314 
315  if(_asm_glue->is_configured())
316  {
317  _asm_glue->run();
318  if(_run_alpha_scale)
319  {
320  _alpha_scale_func.run();
321  }
322  }
323  else
324  {
325  if(!_run_vector_matrix_multiplication)
326  {
327  // Run interleave kernel
328  NEScheduler::get().schedule(_interleave_kernel.get(), Window::DimY);
329 
330  if(!_reshape_b_only_on_first_run)
331  {
332  // Run transpose kernel
333  NEScheduler::get().schedule(_transpose_kernel.get(), Window::DimY);
334  }
335  }
336 
337  NEScheduler::get().schedule(_mm_kernel.get(), _run_vector_matrix_multiplication ? Window::DimX : Window::DimY);
338 
339  // Run bias addition kernel
340  if(_run_bias_addition)
341  {
342  _add_bias.run();
343  }
344  }
345 
346  // Run matrix addition kernel
347  if(_run_addition)
348  {
349  NEScheduler::get().schedule(_ma_kernel.get(), Window::DimY);
350  }
351 
352  // Run activation function
353  if(_run_activation)
354  {
355  _activation_func.run();
356  }
357 }
358 
360 {
361  if(!_is_prepared)
362  {
363  const bool original_b_managed_by_weights_manager = _weights_manager && _weights_manager->are_weights_managed(_original_b);
364  if(_asm_glue->is_configured())
365  {
366  if(!original_b_managed_by_weights_manager)
367  {
368  ARM_COMPUTE_ERROR_ON(!_original_b->is_used());
369  }
370 
371  _asm_glue->prepare();
372  if(!original_b_managed_by_weights_manager)
373  {
374  _original_b->mark_as_unused();
375  }
376  }
377  else if(_reshape_b_only_on_first_run && !_run_vector_matrix_multiplication && !_asm_glue->is_configured())
378  {
379  if(!original_b_managed_by_weights_manager)
380  {
381  ARM_COMPUTE_ERROR_ON(!_original_b->is_used());
382  }
383 
384  _tmp_b.allocator()->allocate();
385  NEScheduler::get().schedule(_transpose_kernel.get(), Window::DimY);
386  if(!original_b_managed_by_weights_manager)
387  {
388  _original_b->mark_as_unused();
389  }
390  }
391 
392  _is_prepared = true;
393  }
394 }
395 } // namespace arm_compute
~NEGEMM()
Default destructor.
Shape of a tensor.
Definition: TensorShape.h:39
TensorShape compute_transpose1xW_with_element_size_shape(const ITensorInfo &b, int mult_transpose1xW_width=1)
Calculate the transposed 1xW width element shape.
std::unique_ptr< ITensorInfo > clone() const override
Provide a clone of the current object of class T.
Definition: TensorInfo.cpp:316
static Status validate(const ITensorInfo *input1, const ITensorInfo *input2, const ITensorInfo *output, ConvertPolicy policy, const ActivationLayerInfo &act_info=ActivationLayerInfo())
Static function to check if given info will lead to a valid configuration of NEArithmeticAddition.
#define ARM_COMPUTE_RETURN_ERROR_ON_CPU_F16_UNSUPPORTED(tensor)
Definition: Validate.h:108
void init(const TensorAllocator &allocator, const Coordinates &coords, TensorInfo &sub_info)
Shares the same backing memory with another tensor allocator, while the tensor info might be differen...
bool enabled() const
Check if initialised.
Definition: Types.h:1600
virtual size_t dimension(size_t index) const =0
Return the size of the requested dimension.
#define ARM_COMPUTE_RETURN_ERROR_ON_CPU_BF16_UNSUPPORTED(tensor)
Definition: Validate.h:114
SimpleTensor< float > b
Definition: DFT.cpp:157
GEMM reshape information class.
Definition: Types.h:1831
#define ARM_COMPUTE_RETURN_ON_ERROR(status)
Checks if a status contains an error and returns it.
Definition: Error.h:204
virtual DataType data_type() const =0
Data type used for each element of the tensor.
TensorShape compute_mm_shape(const ITensorInfo &input0, const ITensorInfo &input1, bool is_interleaved_transposed, const GEMMReshapeInfo &reshape_info)
Calculate the matrix multiplication output shape of two tensors.
bool is_used() const
Flags if the tensor is used or not.
Definition: ITensor.cpp:163
static Status validate(const ITensorInfo *input, const ITensorInfo *output, const ActivationLayerInfo &act_info)
[NEActivationLayer snippet]
void run() override
Run the kernels contained in the function.
1 channel, 1 F32 per channel
#define ARM_COMPUTE_ERROR_ON(cond)
If the condition is true then an error message is printed and an exception thrown.
Definition: Error.h:466
Store the tensor&#39;s metadata.
Definition: ITensorInfo.h:40
#define ARM_COMPUTE_ERROR_THROW_ON(status)
Definition: Error.h:455
int depth_output_gemm3d() const
Depth of the output when GEMM output is reinterpreted as 3D tensor.
Definition: Types.h:2082
Status class.
Definition: Error.h:52
#define ARM_COMPUTE_RETURN_ERROR_ON(cond)
If the condition is true, an error is returned.
Definition: Error.h:296
Activation Layer Information class.
Definition: Types.h:1550
Interface for Neon tensor.
Definition: ITensor.h:36
static Status validate(const ITensorInfo *input, const ITensorInfo *output, float beta)
Static function to check if given info will lead to a valid configuration of NEGEMMMatrixAdditionKern...
void configure(const ITensor *input1, const ITensor *input2, ITensor *output, ConvertPolicy policy, const ActivationLayerInfo &act_info=ActivationLayerInfo())
Initialise the kernel&#39;s inputs, output and conversion policy.
TensorShape compute_interleaved_shape(const ITensorInfo &a, int mult_interleave4x4_height=1, bool reinterpret_input_as_3d=false)
Calculate the interleaved shape of an input tensor.
NEGEMM(std::shared_ptr< IMemoryManager > memory_manager=nullptr, IWeightsManager *weights_manager=nullptr)
Constructor.
Definition: NEGEMM.cpp:63
static Status validate(const ITensorInfo *input, const ITensorInfo *output)
Static function to check if given info will lead to a valid configuration of NEGEMMTranspose1xWKernel...
Copyright (c) 2017-2021 Arm Limited.
bool is_b_reshaped() const
Flag which specifies if the matrix B has been reshaped.
Definition: Types.h:2064
1 channel, 1 F16 per channel
TensorAllocator * allocator()
Return a pointer to the tensor&#39;s allocator.
Definition: Tensor.cpp:48
void mark_as_unused() const
Marks a tensor as unused.
Definition: ITensor.cpp:168
void manage(IMemoryManageable *obj) override
Sets a object to be managed by the given memory group.
Definition: MemoryGroup.h:79
16-bit brain floating-point number
bool are_weights_managed(const ITensor *weights)
Check if the weights are managed.
static Status validate(const ITensorInfo *a, const ITensorInfo *b, const ITensorInfo *c, const ITensorInfo *output, float alpha, float beta, const GEMMInfo &gemm_info=GEMMInfo())
Static function to check if given info will lead to a valid configuration of NEGEMM.
Definition: NEGEMM.cpp:190
void run() override
Run the kernels contained in the function.
Definition: NEGEMM.cpp:309
static constexpr size_t DimX
Alias for dimension 0 also known as X dimension.
Definition: Window.h:43
#define ARM_COMPUTE_UNUSED(...)
To avoid unused variables warnings.
Definition: Error.h:152
static bool is_activation_supported(const ActivationLayerInfo &activation)
Checks if activation is supported by the gemm assembly dispatcher.
void run() override
Run the kernels contained in the function.
virtual const TensorShape & tensor_shape() const =0
Size for each dimension of the tensor.
static Status validate(const ITensorInfo *input, const ITensorInfo *output)
Static function to check if given info will lead to a valid configuration of NEGEMMInterleave4x4Kerne...
void allocate() override
Allocate size specified by TensorInfo of CPU memory.
bool auto_init_if_empty(ITensorInfo &info, const TensorShape &shape, int num_channels, DataType data_type, QuantizationInfo quantization_info=QuantizationInfo())
Auto initialize the tensor info (shape, number of channels and data type) if the current assignment i...
virtual std::unique_ptr< T > clone() const =0
Provide a clone of the current object of class T.
virtual ITensorInfo * info() const =0
Interface to be implemented by the child class to return the tensor&#39;s metadata.
size_t data_size_from_type(DataType data_type)
The size in bytes of the data type.
Definition: Utils.h:106
static Status validate(const ITensorInfo *a, const ITensorInfo *b, const ITensorInfo *c, const ITensorInfo *d, const AsmGemmInfo &info)
Indicates whether or not this function can be used to process the given parameters.
bool reinterpret_input_as_3d() const
Flag which specifies if the input tensor has to be reinterpreted as 3D.
Definition: Types.h:2090
Weights manager interface to handle weights transformations.
bool is_a_reshaped() const
Flag which specifies if the matrix A has been reshaped.
Definition: Types.h:2056
static constexpr size_t DimY
Alias for dimension 1 also known as Y dimension.
Definition: Window.h:45
ScaleKernelInfo info(interpolation_policy, default_border_mode, PixelValue(), sampling_policy, false)
Memory group resources scope handling class.
Definition: IMemoryGroup.h:82
virtual size_t total_size() const =0
Returns the total size of the tensor in bytes.
virtual void schedule(ICPPKernel *kernel, const Hints &hints)=0
Runs the kernel in the same thread as the caller synchronously.
#define ARM_COMPUTE_RETURN_ERROR_ON_MISMATCHING_DATA_TYPES(...)
Definition: Validate.h:545
void configure(const ITensor *a, const ITensor *b, const ITensor *c, ITensor *d, float alpha, float beta, const GEMMInfo &gemm_info=GEMMInfo())
Initialise the kernel&#39;s inputs, output.
Definition: NEGEMM.cpp:72
#define ARM_COMPUTE_RETURN_ERROR_ON_DATA_TYPE_CHANNEL_NOT_IN(t, c,...)
Definition: Validate.h:792
void configure(ITensor *input, ITensor *output, ActivationLayerInfo activation_info)
[NEActivationLayer snippet]
void prepare() override
Prepare the function for executing.
Definition: NEGEMM.cpp:359
#define ARM_COMPUTE_RETURN_ERROR_ON_MSG(cond, msg)
If the condition is true, an error is returned.
Definition: Error.h:244
Store the tensor&#39;s metadata.
Definition: TensorInfo.h:45
bool reshape_b_only_on_first_run() const
Flag which specifies if the reshape of matrix B should executed only for the first.
Definition: Types.h:2074
static Status validate(const ITensorInfo *input0, const ITensorInfo *input1, const ITensorInfo *output, float alpha, bool is_interleaved, const GEMMReshapeInfo &reshape_info)
Static function to check if given info will lead to a valid configuration of NEGEMMMatrixMultiplyKern...
GEMM information class.
Definition: Types.h:2003
ActivationLayerInfo activation_info() const
Activation layer to apply after the matrix multiplication.
Definition: Types.h:2154
TensorShape & set(size_t dimension, size_t value, bool apply_dim_correction=true, bool increase_dim_unit=true)
Accessor to set the value of one of the dimensions.
Definition: TensorShape.h:79
static IScheduler & get()
Access the scheduler singleton.
Definition: Scheduler.cpp:94