onert::backend::xnnpack::ops::ConvolutionLayer Class Reference

#include <ConvolutionLayer.h>

Collaboration diagram for onert::backend::xnnpack::ops::ConvolutionLayer:

Public Member Functions
	ConvolutionLayer (const std::shared_ptr< ExternalContext > external_context)
void	configure (const IPortableTensor *input, const IPortableTensor *kernel, const IPortableTensor *bias, ir::PaddingType padding_type, const uint32_t padding_left, const uint32_t padding_right, const uint32_t padding_top, const uint32_t padding_bottom, const uint32_t stride_width, const uint32_t stride_height, const uint32_t dilation_width_factor, const uint32_t dilation_height_factor, const ir::Activation activation, IPortableTensor *output)
void	run () override
bool	create () override
bool	setup () override
Public Member Functions inherited from onert::backend::xnnpack::ops::Layer
	Layer (const std::shared_ptr< ExternalContext > external_context)
	~Layer ()
void	prepare () override
Public Member Functions inherited from onert::exec::IFunction
virtual	~IFunction ()=default

Additional Inherited Members
Protected Attributes inherited from onert::backend::xnnpack::ops::Layer
xnn_operator_t	_kernel_op
bool	_create
bool	_setup
const std::shared_ptr< ExternalContext >	_external_context

Detailed Description

Definition at line 33 of file ConvolutionLayer.h.

Constructor & Destructor Documentation

ConvolutionLayer()

onert::backend::xnnpack::ops::ConvolutionLayer::ConvolutionLayer

(

const std::shared_ptr< ExternalContext >

external_context

)

Definition at line 29 of file ConvolutionLayer.cc.

  : Layer(external_context), _input(nullptr), _kernel(nullptr), _bias(nullptr), _output(nullptr),
    _padding_type(ir::PaddingType::EXPLICIT), _padding_left(0), _padding_top(0), _padding_right(0),
    _padding_bottom(0), _stride_width(0), _stride_height(0), _dilation_width_factor(1),
    _dilation_height_factor(1), _activation(ir::Activation::NONE)
{
  // DO NOTHING
}

Member Function Documentation

configure()

void onert::backend::xnnpack::ops::ConvolutionLayer::configure	(	const IPortableTensor *	input,
		const IPortableTensor *	kernel,
		const IPortableTensor *	bias,
		ir::PaddingType	padding_type,
		const uint32_t	padding_left,
		const uint32_t	padding_right,
		const uint32_t	padding_top,
		const uint32_t	padding_bottom,
		const uint32_t	stride_width,
		const uint32_t	stride_height,
		const uint32_t	dilation_width_factor,
		const uint32_t	dilation_height_factor,
		const ir::Activation	activation,
		IPortableTensor *	output
	)

Definition at line 38 of file ConvolutionLayer.cc.

{
  _input = input;
  _kernel = kernel;
  _bias = bias;
  _padding_type = padding_type;
  _padding_left = padding_left;
  _padding_right = padding_right;
  _padding_top = padding_top;
  _padding_bottom = padding_bottom;
  _stride_width = stride_width;
  _stride_height = stride_height;
  _dilation_width_factor = dilation_width_factor;
  _dilation_height_factor = dilation_height_factor;
  _activation = activation;
  _output = output;
 
  assert(_activation == ir::Activation::NONE || _activation == ir::Activation::RELU ||
         _activation == ir::Activation::RELU1 || _activation == ir::Activation::RELU6);
}

References onert::ir::NONE, onert::ir::RELU, onert::ir::RELU1, and onert::ir::RELU6.

create()

bool onert::backend::xnnpack::ops::ConvolutionLayer::create ( )

overridevirtual

Implements onert::backend::xnnpack::ops::Layer.

Definition at line 89 of file ConvolutionLayer.cc.

{
  float output_activation_min = 0.f, output_activation_max = 0.f;
  CalculateActivationRange<float>(_activation, &output_activation_min, &output_activation_max);
 
  // NHWC
  // Kernel format is [depth_out, kernel_height, kernel_width, depth_in].
  const auto &kernel_shape = _kernel->getShape();
  uint32_t kernel_height = kernel_shape.dim(1);
  uint32_t kernel_width = kernel_shape.dim(2);
  uint32_t output_channels = kernel_shape.dim(0);
  uint32_t input_channels = kernel_shape.dim(3);
  assert(static_cast<uint32_t>(_input->getShape().dim(3)) == input_channels);
  assert(static_cast<uint32_t>(_output->getShape().dim(3)) == output_channels);
 
  enum xnn_status status = xnn_create_convolution2d_nhwc_f32(
    _padding_top, _padding_right, _padding_bottom, _padding_left, kernel_height, kernel_width,
    _stride_height, _stride_width, _dilation_height_factor, _dilation_width_factor, 1 /* groups */,
    input_channels /* group_input_channels */, output_channels /* group_output_channels */,
    input_channels /* input_channel_stride */, output_channels /* output_channel_stride */,
    reinterpret_cast<const float *>(_kernel->buffer()),
    reinterpret_cast<const float *>(_bias->buffer()), output_activation_min, output_activation_max,
    0, nullptr, nullptr, &_kernel_op);
  if (status != xnn_status_success)
  {
    throw std::runtime_error{"failed to create FP32 Convolution operator"};
  }
  assert(_kernel_op != nullptr);
  return true;
}

References onert::backend::xnnpack::ops::Layer::_kernel_op, onert::backend::ITensor::buffer(), and onert::backend::IPortableTensor::getShape().

run()

void onert::backend::xnnpack::ops::ConvolutionLayer::run ( )

overridevirtual

Implements onert::exec::IFunction.

Definition at line 66 of file ConvolutionLayer.cc.

{
  assert(_external_context && _external_context->getThreadPool());
  if (!_setup)
  {
    _setup = setup();
    assert(_setup);
  }
 
  if (_input->data_type() == OperandType::FLOAT32)
  {
    enum xnn_status status = xnn_run_operator(_kernel_op, _external_context->getThreadPool());
    if (status != xnn_status_success)
    {
      throw std::runtime_error{"failed to run FP32 Convolution operator"};
    }
  }
  else
  {
    throw std::runtime_error{"XNNPACK Conv: unsupported data type"};
  }
}

References onert::backend::xnnpack::ops::Layer::_external_context, onert::backend::xnnpack::ops::Layer::_kernel_op, onert::backend::xnnpack::ops::Layer::_setup, onert::backend::IPortableTensor::data_type(), and setup().

Referenced by package.infer.session::inference().

setup()

bool onert::backend::xnnpack::ops::ConvolutionLayer::setup ( )

overridevirtual

Implements onert::backend::xnnpack::ops::Layer.

Definition at line 120 of file ConvolutionLayer.cc.

{
  if (_input->buffer() == nullptr || _output->buffer() == nullptr)
  {
    // it could be models's input or output
    return false;
  }
 
  uint32_t input_width = _input->getShape().dim(2);
  uint32_t input_height = _input->getShape().dim(1);
  uint32_t batch_size = _input->getShape().dim(0);
  size_t workspace_size = 0;
  size_t workspace_alignment = 0;
  enum xnn_status status = xnn_reshape_convolution2d_nhwc_f32(
    _kernel_op, batch_size, input_height, input_width, &workspace_size, &workspace_alignment,
    nullptr, nullptr, _external_context->getThreadPool());
  if (status != xnn_status_success)
  {
    throw std::runtime_error{"failed to create FP32 DepthwiseConvolution operator"};
  }
 
  std::vector<uint8_t> workspace(workspace_size);
  status = xnn_setup_convolution2d_nhwc_f32(_kernel_op, workspace.data(),
                                            reinterpret_cast<const float *>(_input->buffer()),
                                            reinterpret_cast<float *>(_output->buffer()));
  if (status != xnn_status_success)
  {
    throw std::runtime_error{"failed to create FP32 Convolution operator"};
  }
  return true;
}

References onert::backend::xnnpack::ops::Layer::_external_context, onert::backend::xnnpack::ops::Layer::_kernel_op, onert::backend::ITensor::buffer(), and onert::backend::IPortableTensor::getShape().

Referenced by run().

---

The documentation for this class was generated from the following files:

• runtime/onert/backend/xnnpack/ops/ConvolutionLayer.h
• runtime/onert/backend/xnnpack/ops/ConvolutionLayer.cc