#include <MirrorPad.h>

Collaboration diagram for luci_interpreter::kernels::MirrorPad:

[legend]

Public Member Functions
	MirrorPad (const Tensor input, const Tensor paddings, Tensor *output, const MirrorPadParams &params)

const Tensor *	input () const

const Tensor *	paddings () const

Tensor *	output () const

void	configure () override

void	execute () const override

Public Member Functions inherited from luci_interpreter::KernelWithParams< MirrorPadParams >
const MirrorPadParams &	params () const

Public Member Functions inherited from luci_interpreter::Kernel
virtual	~Kernel ()=default

const std::vector< const Tensor * > &	getInputTensors () const

const std::vector< Tensor * > &	getOutputTensors () const

Additional Inherited Members
Protected Member Functions inherited from luci_interpreter::KernelWithParams< MirrorPadParams >
	KernelWithParams (std::vector< const Tensor * > inputs, std::vector< Tensor * > outputs, const MirrorPadParams &params)

Protected Member Functions inherited from luci_interpreter::Kernel
	Kernel (std::vector< const Tensor * > inputs, std::vector< Tensor * > outputs)

Protected Attributes inherited from luci_interpreter::KernelWithParams< MirrorPadParams >
const MirrorPadParams	_params

Protected Attributes inherited from luci_interpreter::Kernel
const std::vector< const Tensor * >	_inputs

const std::vector< Tensor * >	_outputs

Detailed Description

Definition at line 28 of file MirrorPad.h.

Constructor & Destructor Documentation

◆ MirrorPad()

luci_interpreter::kernels::MirrorPad::MirrorPad	(	const Tensor *	input,
		const Tensor *	paddings,
		Tensor *	output,
		const MirrorPadParams &	params
	)

Definition at line 29 of file MirrorPad.cpp.

  : KernelWithParams<MirrorPadParams>({input, paddings}, {output}, params)
{
}

References input(), and paddings().

Member Function Documentation

◆ configure()

void luci_interpreter::kernels::MirrorPad::configure ( )

overridevirtual

Implements luci_interpreter::Kernel.

Definition at line 35 of file MirrorPad.cpp.

{
  const Shape &input_shape = input()->shape();
  const int num_dims = input_shape.num_dims();
 
  if (num_dims > 4)
    throw std::runtime_error("Unsupported number of dimensions.");
 
  LUCI_INTERPRETER_CHECK(output()->element_type() == input()->element_type());
  LUCI_INTERPRETER_CHECK(paddings()->element_type() == DataType::S32);
  // Paddings shape should be [N, 2].
  LUCI_INTERPRETER_CHECK(paddings()->shape().num_dims() == 2);
  LUCI_INTERPRETER_CHECK(paddings()->shape().dim(0) == num_dims);
  LUCI_INTERPRETER_CHECK(paddings()->shape().dim(1) == 2);
 
  Shape output_shape(num_dims);
  const auto *paddings_data = getTensorData<int32_t>(paddings());
  for (int i = 0; i < num_dims; ++i)
  {
    const int32_t padding_before = paddings_data[i * 2];
    const int32_t padding_after = paddings_data[i * 2 + 1];
    LUCI_INTERPRETER_CHECK(padding_before >= 0 && padding_after >= 0);
    output_shape.dim(i) = input_shape.dim(i) + padding_before + padding_after;
  }
 
  output()->resize(output_shape);
}

References luci_interpreter::Shape::dim(), input(), LUCI_INTERPRETER_CHECK, luci_interpreter::Shape::num_dims(), output(), output_shape, paddings(), luci_interpreter::Tensor::resize(), and luci_interpreter::Tensor::shape().

◆ execute()

void luci_interpreter::kernels::MirrorPad::execute ( ) const

overridevirtual

Implements luci_interpreter::Kernel.

Definition at line 147 of file MirrorPad.cpp.

{
  const Tensor &t_input = *input();
  const Tensor &t_paddings = *paddings();
  Tensor &t_output = *output();
 
  const auto offset = params().mode != MirrorPadMode::REFLECT ? 0 : 1;
  const auto input_dims = t_input.shape().num_dims();
  const auto output_size = t_output.shape().num_elements();
 
  int output_dims_num_elements[5];
  int input_dims_num_elements[5];
  int32_t input_shape_dim[5];
 
  for (int i = 0; i < input_dims; i++)
  {
    output_dims_num_elements[i] = 1;
    input_dims_num_elements[i] = 1;
    input_shape_dim[i] = t_input.shape().dim(i);
  }
 
  for (int i = input_dims - 2; i >= 0; i--)
  {
    output_dims_num_elements[i] = output_dims_num_elements[i + 1] * t_output.shape().dim(i + 1);
    input_dims_num_elements[i] = input_dims_num_elements[i + 1] * t_input.shape().dim(i + 1);
  }
 
  switch (t_input.element_type())
  {
    case DataType::FLOAT32:
      eval(t_paddings.element_type(), t_paddings.data<uint8_t>(), input_shape_dim,
           output_dims_num_elements, input_dims_num_elements, t_input.data<float>(),
           t_output.data<float>(), offset, input_dims, output_size);
      break;
 
    case DataType::U8:
      eval(t_paddings.element_type(), t_paddings.data<uint8_t>(), input_shape_dim,
           output_dims_num_elements, input_dims_num_elements, t_input.data<uint8_t>(),
           t_output.data<uint8_t>(), offset, input_dims, output_size);
      break;
 
    default:
      throw std::runtime_error("luci-intp MirrorPad Unsupported type.");
  }
}