nnfw::ruy Namespace Reference

Namespaces
namespace	ruy_support

Data Structures
class	Conv
struct	ConvParams
struct	FullyConnectedParams
struct	GemmParams
struct	MatrixParams
struct	PaddingValues
class	Shape
struct	UNUSED_ALL

Enumerations
enum class	FusedActivationFunctionType {   kNone = 0 , kRelu6 = 1 , kRelu1 = 2 , kRelu = 3 ,   kTanh = 4 , kSigmoid = 6 }
enum class	PaddingType { kNone = 0 , kSame = 1 , kValid = 2 }
enum class	Order { kColMajor , kRowMajor }
enum class	CachePolicy : std::uint8_t { kNeverCache , kCacheIfLargeSpeedup , kAlwaysCache }
enum class	QuantizationFlavor { kFloatingPoint , kIntegerWithUniformMultiplier , kIntegerWithPerRowMultiplier }

Functions
void	FullyConnected (const FullyConnectedParams &params, const Shape &input_shape, const float *input_data, const Shape &weights_shape, const float *weights_data, const Shape &, const float *optional_bias_data, const Shape &output_shape, float *output_data, ::ruy::Context *ruy_context)
bool	PortableIsZeroVector (const float *vector, int v_size)
int	MatchingDim (const Shape &shape1, int index1, const Shape &shape2, int index2)
template<typename... Args>
int	MatchingDim (const Shape &shape1, int index1, const Shape &shape2, int index2, Args... args)
Shape	GetShape (const std::vector< int32_t > &data)
int	Offset (const Shape &shape, int i0, int i1, int i2, int i3)
int	Offset (const Shape &shape, int *index)
int	FlatSizeSkipDim (const Shape &shape, int skip_dim)
template<typename... Ts>
bool	checkMatching (const Shape &shape, Ts... check_shapes)
template<typename... Ts>
int	MatchingFlatSize (const Shape &shape, Ts... check_shapes)
int	MatchingFlatSizeSkipDim (const Shape &shape, int skip_dim, const Shape &check_shape_0)
int	MatchingFlatSizeSkipDim (const Shape &shape, int skip_dim, const Shape &check_shape_0, const Shape &check_shape_1)
int	MatchingElementsSize (const Shape &shape, const Shape &check_shape_0, const Shape &check_shape_1)
bool	IsZeroVector (const float *vector, int v_size)
template<typename AccumScalar , typename DstScalar , QuantizationFlavor quantization_flavor>
void	ValidateGemmParams (const GemmParams< AccumScalar, DstScalar, quantization_flavor > &params)
CachePolicy	DefaultCachePolicy (bool is_constant_data)
template<typename T >
void	ExtractPatchIntoBufferColumn (const Shape &input_shape, int w, int h, int b, int kheight, int kwidth, int stride_width, int stride_height, int pad_width, int pad_height, int in_width, int in_height, int in_depth, int single_buffer_length, int buffer_id, const T *in_data, T *conv_buffer_data, uint8_t zero_byte)
template<typename T >
void	DilatedIm2col (const ConvParams &params, const Shape &input_shape, const T *input_data, const Shape &filter_shape, const Shape &output_shape, T *im2col_data, const int32_t *zero_bytes, const int zero_bytes_len)
template<typename T >
void	DilatedIm2col (const ConvParams &params, uint8_t zero_byte, const Shape &input_shape, const T *input_data, const Shape &filter_shape, const Shape &output_shape, T *im2col_data)
template<typename T >
void	Im2col (const ConvParams &params, int kheight, int kwidth, uint8_t zero_byte, const Shape &input_shape, const T *input_data, const Shape &output_shape, T *output_data)

Enumeration Type Documentation

CachePolicy

enum class nnfw::ruy::CachePolicy : std::uint8_t

strong

Enumerator
kNeverCache
kCacheIfLargeSpeedup
kAlwaysCache

Definition at line 110 of file Types.h.

{
  kNeverCache,
  kCacheIfLargeSpeedup,
  kAlwaysCache,
};

FusedActivationFunctionType

enum class nnfw::ruy::FusedActivationFunctionType

strong

Enumerator
kNone
kRelu6
kRelu1
kRelu
kTanh
kSigmoid

Definition at line 33 of file Types.h.

{
  kNone = 0,
  kRelu6 = 1,
  kRelu1 = 2,
  kRelu = 3,
  kTanh = 4,
  kSigmoid = 6,
};

Order

enum class nnfw::ruy::Order

strong

Enumerator
kColMajor
kRowMajor

Definition at line 104 of file Types.h.

{
  kColMajor,
  kRowMajor
};

PaddingType

enum class nnfw::ruy::PaddingType

strong

Enumerator
kNone
kSame
kValid

Definition at line 43 of file Types.h.

{
  kNone = 0,
  kSame = 1,
  kValid = 2,
};

QuantizationFlavor

enum class nnfw::ruy::QuantizationFlavor

strong

Enumerator
kFloatingPoint
kIntegerWithUniformMultiplier
kIntegerWithPerRowMultiplier

Definition at line 159 of file Types.h.

{
  // Floating-point Gemm: the accumulators are not multiplied by any
  // 'multiplier'.
  kFloatingPoint,
  // Quantized Gemm using a single multiplier for all accumulators.
  kIntegerWithUniformMultiplier,
  // Quantized Gemm using a separate multipliers for accumulators of each
  // row of the destination matrix. This is what is called 'per-channel'
  // in GemmParams. Here we use the more specific 'per-row' terminology
  // to allow for the possibility of 'per-column' in the future, and to
  // allow for that to be a separate code path in some back-end such as
  // gemmlowp.
  kIntegerWithPerRowMultiplier
};

Function Documentation

checkMatching()

template<typename... Ts>

bool nnfw::ruy::checkMatching ( const Shape &  shape, Ts...  check_shapes  )

inline

Definition at line 269 of file Shape.h.

{
  const Shape check_shapes_array[sizeof...(Ts)] = {std::forward<Ts>(check_shapes)...};
  for (const auto &check_shape : check_shapes_array)
  {
    // Check matching of shapes except the case of that two shapes can be scalar
    if (shape.DimensionsCount() > 1 || check_shape.DimensionsCount() > 1 || shape.FlatSize() != 1 ||
        check_shape.FlatSize() != 1)
    {
      if (shape.DimensionsCount() != check_shape.DimensionsCount())
      {
        return false;
      }
      for (int i = 0; i < shape.DimensionsCount(); ++i)
      {
        if (shape.Dims(i) != check_shape.Dims(i))
        {
          return false;
        }
      }
    }
  }
  return true;
}

References nnfw::ruy::Shape::DimensionsCount(), nnfw::ruy::Shape::Dims(), and nnfw::ruy::Shape::FlatSize().

Referenced by MatchingFlatSize().

DefaultCachePolicy()

CachePolicy nnfw::ruy::DefaultCachePolicy ( bool  is_constant_data )

inline

Definition at line 267 of file Types.h.

{
  return is_constant_data ? CachePolicy::kCacheIfLargeSpeedup : CachePolicy::kNeverCache;
}

References kCacheIfLargeSpeedup, and kNeverCache.

Referenced by FullyConnected().

DilatedIm2col() [1/2]

template<typename T >

void nnfw::ruy::DilatedIm2col	(	const ConvParams &	params,
		const Shape &	input_shape,
		const T *	input_data,
		const Shape &	filter_shape,
		const Shape &	output_shape,
		T *	im2col_data,
		const int32_t *	zero_bytes,
		const int	zero_bytes_len
	)

Definition at line 118 of file Utils.h.

{
  const int stride_width = params.stride_width;
  const int stride_height = params.stride_height;
  const int dilation_width_factor = params.dilation_width_factor;
  const int dilation_height_factor = params.dilation_height_factor;
  const int pad_width = params.padding_values.width;
  const int pad_height = params.padding_values.height;
  assert(input_shape.DimensionsCount() == 4);
  assert(filter_shape.DimensionsCount() == 4);
  assert(output_shape.DimensionsCount() == 4);
 
  // For dilated convolution, the input pixels are not contiguous therefore we
  // can't use the same optimizations as Im2Col(). Though note this code would
  // work fine for the non-dilated case too (though likely a bit slower).
  assert(dilation_width_factor != 1 || dilation_height_factor != 1);
  assert(im2col_data);
  const int batches = MatchingDim(input_shape, 0, output_shape, 0);
  const int input_height = input_shape.Dims(1);
  const int input_width = input_shape.Dims(2);
  const int input_depth = MatchingDim(input_shape, 3, filter_shape, 3);
  const int filter_height = filter_shape.Dims(1);
  const int filter_width = filter_shape.Dims(2);
  const int output_height = output_shape.Dims(1);
  const int output_width = output_shape.Dims(2);
  MatchingDim(output_shape, 3, filter_shape, 0);
 
  // Construct the MxN sized im2col matrix.
  // The rows M, are sub-ordered B x H x W
  const Shape row_shape({1, batches, output_height, output_width});
  // The columns, N, are sub-ordered Kh x Kw x Din
  const Shape col_shape({1, filter_height, filter_width, input_depth});
  // Use dimensions M and N to construct dims for indexing directly into im2col
  const Shape im2col_shape({1, 1, row_shape.FlatSize(), col_shape.FlatSize()});
 
  // Loop through the output rows (B x H x W)
  for (int batch = 0; batch < batches; ++batch)
  {
    const T zero_byte =
      zero_bytes_len > 1 ? static_cast<T>(zero_bytes[batch]) : static_cast<T>(zero_bytes[0]);
    for (int out_y = 0; out_y < output_height; ++out_y)
    {
      for (int out_x = 0; out_x < output_width; ++out_x)
      {
        // Each im2col row is an output pixel. Arrange the input data in this
        // row in an order we can conveniently multiply with the filter data.
        int row_offset = Offset(row_shape, 0, batch, out_y, out_x);
        const int in_x_origin = (out_x * stride_width) - pad_width;
        const int in_y_origin = (out_y * stride_height) - pad_height;
        // Loop through all the pixels of the filter (Kh x Kw)
        for (int filter_y = 0; filter_y < filter_height; ++filter_y)
        {
          const int in_y = in_y_origin + dilation_height_factor * filter_y;
          if ((in_y >= 0) && (in_y < input_height))
          {
            // Filter row is within the input data.
            // Loop through all the filter pixels in this row.
            for (int filter_x = 0; filter_x < filter_width; ++filter_x)
            {
              const int in_x = in_x_origin + dilation_width_factor * filter_x;
              int col_offset = Offset(col_shape, 0, filter_y, filter_x, 0);
              T *dst = im2col_data + Offset(im2col_shape, 0, 0, row_offset, col_offset);
              if ((in_x >= 0) && (in_x < input_width))
              {
                // Filter pixel is within the input, copy the input data.
                T const *src = input_data + Offset(input_shape, batch, in_y, in_x, 0);
                memcpy(dst, src, input_depth * sizeof(T));
              }
              else
              {
                // Filter pixel is outside the input, zero it out.
                memset(dst, zero_byte, input_depth * sizeof(T));
              }
            }
          }
          else
          {
            // Filter row is outside the input, zero out the entire filter row.
            int col_offset = Offset(col_shape, 0, filter_y, 0, 0);
            T *dst = im2col_data + Offset(im2col_shape, 0, 0, row_offset, col_offset);
            memset(dst, zero_byte, filter_width * input_depth * sizeof(T));
          }
        }
      }
    }
  }
}

References nnfw::ruy::ConvParams::dilation_height_factor, nnfw::ruy::ConvParams::dilation_width_factor, nnfw::ruy::Shape::DimensionsCount(), nnfw::ruy::Shape::Dims(), nnfw::ruy::PaddingValues::height, MatchingDim(), Offset(), output_shape, nnfw::ruy::ConvParams::padding_values, nnfw::ruy::ConvParams::stride_height, nnfw::ruy::ConvParams::stride_width, and nnfw::ruy::PaddingValues::width.

DilatedIm2col() [2/2]

template<typename T >

void nnfw::ruy::DilatedIm2col	(	const ConvParams &	params,
		uint8_t	zero_byte,
		const Shape &	input_shape,
		const T *	input_data,
		const Shape &	filter_shape,
		const Shape &	output_shape,
		T *	im2col_data
	)

Definition at line 209 of file Utils.h.

{
  const int32_t zero_point = static_cast<int32_t>(zero_byte);
  DilatedIm2col<T>(params, input_shape, input_data, filter_shape, output_shape, im2col_data,
                   &zero_point, 1);
}

References output_shape.

ExtractPatchIntoBufferColumn()

template<typename T >

void nnfw::ruy::ExtractPatchIntoBufferColumn ( const Shape &  input_shape, int  w, int  h, int  b, int  kheight, int  kwidth, int  stride_width, int  stride_height, int  pad_width, int  pad_height, int  in_width, int  in_height, int  in_depth, int  single_buffer_length, int  buffer_id, const T *  in_data, T *  conv_buffer_data, uint8_t  zero_byte  )

inline

Definition at line 31 of file Utils.h.

{
  assert(input_shape.DimensionsCount() == 4);
  // This chunk of code reshapes all the inputs corresponding to
  // output (b, h, w) to a column vector in conv_buffer(:, buffer_id).
  const int kwidth_times_indepth = kwidth * in_depth;
  const int inwidth_times_indepth = in_width * in_depth;
  const int ih_ungated_start = h * stride_height - pad_height;
  const int ih_ungated_end = (ih_ungated_start + kheight);
  const int ih_end = std::min(ih_ungated_end, in_height);
  const int iw_ungated_start = w * stride_width - pad_width;
  const int iw_ungated_end = (iw_ungated_start + kwidth);
  const int iw_end = std::min(iw_ungated_end, in_width);
  // If the patch is off the edge of the input image, skip writing those rows
  // and columns from the patch into the output array.
  const int h_offset = std::max(0, -ih_ungated_start);
  const int w_offset = std::max(0, -iw_ungated_start);
  const int ih_start = std::max(0, ih_ungated_start);
  const int iw_start = std::max(0, iw_ungated_start);
  const int single_row_num = std::min(kwidth - w_offset, in_width - iw_start) * in_depth;
  const int output_row_offset = (buffer_id * single_buffer_length);
  int out_offset = output_row_offset + (h_offset * kwidth + w_offset) * in_depth;
  int in_offset = Offset(input_shape, b, ih_start, iw_start, 0);
 
  // Express all of the calculations as padding around the input patch.
  const int top_padding = h_offset;
  const int bottom_padding = (ih_ungated_end - ih_end);
  const int left_padding = w_offset;
  const int right_padding = (iw_ungated_end - iw_end);
  assert(single_row_num == ((kwidth - (left_padding + right_padding)) * in_depth));
 
  // Write out zeroes to the elements representing the top rows of the input
  // patch that are off the edge of the input image.
  if (top_padding > 0)
  {
    const int top_row_elements = (top_padding * kwidth * in_depth);
    memset(conv_buffer_data + output_row_offset, zero_byte, (top_row_elements * sizeof(T)));
  }
 
  // If the patch is on the interior of the input image horizontally, just copy
  // over the rows sequentially, otherwise add zero padding at the start or end.
  if ((left_padding == 0) && (right_padding == 0))
  {
    for (int ih = ih_start; ih < ih_end; ++ih)
    {
      memcpy(conv_buffer_data + out_offset, in_data + in_offset, single_row_num * sizeof(T));
      out_offset += kwidth_times_indepth;
      in_offset += inwidth_times_indepth;
    }
  }
  else
  {
    for (int ih = ih_start; ih < ih_end; ++ih)
    {
      if (left_padding > 0)
      {
        const int left_start = (out_offset - (left_padding * in_depth));
        memset(conv_buffer_data + left_start, zero_byte, (left_padding * in_depth * sizeof(T)));
      }
      memcpy(conv_buffer_data + out_offset, in_data + in_offset, single_row_num * sizeof(T));
      if (right_padding > 0)
      {
        const int right_start = (out_offset + single_row_num);
        memset(conv_buffer_data + right_start, zero_byte, (right_padding * in_depth * sizeof(T)));
      }
      out_offset += kwidth_times_indepth;
      in_offset += inwidth_times_indepth;
    }
  }
 
  // If the bottom of the patch falls off the input image, pad the values
  // representing those input rows with zeroes.
  if (bottom_padding > 0)
  {
    const int bottom_row_elements = (bottom_padding * kwidth * in_depth);
    const int bottom_start =
      output_row_offset + ((top_padding + (ih_end - ih_start)) * kwidth * in_depth);
    memset(conv_buffer_data + bottom_start, zero_byte, (bottom_row_elements * sizeof(T)));
  }
}

References nnfw::ruy::Shape::DimensionsCount(), and Offset().

Referenced by Im2col().

FlatSizeSkipDim()

int nnfw::ruy::FlatSizeSkipDim ( const Shape &  shape, int  skip_dim  )

inline

Definition at line 254 of file Shape.h.

{
  const int dims_count = shape.DimensionsCount();
  assert(skip_dim >= 0 && skip_dim < dims_count);
  const auto *dims_data = shape.DimsData();
  int flat_size = 1;
  for (int i = 0; i < dims_count; ++i)
  {
    flat_size *= (i == skip_dim) ? 1 : dims_data[i];
  }
  return flat_size;
}

References nnfw::ruy::Shape::DimensionsCount(), and nnfw::ruy::Shape::DimsData().

Referenced by FullyConnected(), and MatchingFlatSizeSkipDim().

FullyConnected()

void nnfw::ruy::FullyConnected ( const FullyConnectedParams &  params, const Shape &  input_shape, const float *  input_data, const Shape &  weights_shape, const float *  weights_data, const Shape &  , const float *  optional_bias_data, const Shape &  output_shape, float *  output_data, ::ruy::Context *  ruy_context  )

inline

Definition at line 34 of file FullyConnected.h.

{
  const int dims_count = weights_shape.DimensionsCount();
  const int input_rows = weights_shape.Dims(dims_count - 1);
  MatrixParams<float> rhs_params;
  rhs_params.order = Order::kColMajor;
  rhs_params.rows = input_rows;
  rhs_params.cols = input_shape.FlatSize() / input_rows;
  rhs_params.cache_policy = DefaultCachePolicy(params.rhs_cacheable);
  assert(input_shape.FlatSize() == (rhs_params.rows * rhs_params.cols));
  MatrixParams<float> lhs_params;
  lhs_params.order = Order::kRowMajor;
  lhs_params.cols = weights_shape.Dims(dims_count - 1);
  lhs_params.rows = FlatSizeSkipDim(weights_shape, dims_count - 1);
  lhs_params.cache_policy = DefaultCachePolicy(params.lhs_cacheable);
  MatrixParams<float> dst_params;
  dst_params.order = Order::kColMajor;
  dst_params.rows = output_shape.Dims(output_shape.DimensionsCount() - 1);
  dst_params.cols = FlatSizeSkipDim(output_shape, output_shape.DimensionsCount() - 1);
  GemmParams<float, float> gemm_params;
  gemm_params.bias = optional_bias_data;
  gemm_params.clamp_min = params.float_activation_min;
  gemm_params.clamp_max = params.float_activation_max;
 
  // Below code was copied from tflite::cpu_backend_gemm::detail::GemmImplUsingRuy
  ::ruy::Matrix<float> ruy_lhs;
  ::ruy::Matrix<float> ruy_rhs;
  ::ruy::Matrix<float> ruy_dst;
  // Note that cache is always enabled for input and weight tensors
  ruy_support::MakeRuyMatrix(lhs_params, weights_data, &ruy_lhs, true);
  ruy_support::MakeRuyMatrix(rhs_params, input_data, &ruy_rhs, true);
  ruy_support::MakeRuyMatrix(dst_params, output_data, &ruy_dst);
 
  ::ruy::MulParams<float, float> ruy_mul_params;
  ruy_support::MakeRuyMulParams(gemm_params, &ruy_mul_params);
 
  ::ruy::Mul(ruy_lhs, ruy_rhs, ruy_mul_params, ruy_context, &ruy_dst);
}

References nnfw::ruy::GemmParams< AccumScalar, DstScalar, quantization_flavor >::bias, nnfw::ruy::MatrixParams< Scalar >::cache_policy, nnfw::ruy::GemmParams< AccumScalar, DstScalar, quantization_flavor >::clamp_max, nnfw::ruy::GemmParams< AccumScalar, DstScalar, quantization_flavor >::clamp_min, nnfw::ruy::MatrixParams< Scalar >::cols, DefaultCachePolicy(), nnfw::ruy::Shape::DimensionsCount(), nnfw::ruy::Shape::Dims(), nnfw::ruy::Shape::FlatSize(), FlatSizeSkipDim(), nnfw::ruy::FullyConnectedParams::float_activation_max, nnfw::ruy::FullyConnectedParams::float_activation_min, kColMajor, kRowMajor, nnfw::ruy::FullyConnectedParams::lhs_cacheable, nnfw::ruy::ruy_support::MakeRuyMatrix(), nnfw::ruy::ruy_support::MakeRuyMulParams(), nnfw::ruy::MatrixParams< Scalar >::order, output_shape, nnfw::ruy::FullyConnectedParams::rhs_cacheable, and nnfw::ruy::MatrixParams< Scalar >::rows.

Referenced by onert::backend::ruy::ops::FullyConnectedLayer::fullyConnectedFloat32().

GetShape()

Shape nnfw::ruy::GetShape ( const std::vector< int32_t > &  data )

inline

Definition at line 236 of file Shape.h.

{ return Shape(data.size(), data.data()); }

Im2col()

template<typename T >

void nnfw::ruy::Im2col	(	const ConvParams &	params,
		int	kheight,
		int	kwidth,
		uint8_t	zero_byte,
		const Shape &	input_shape,
		const T *	input_data,
		const Shape &	output_shape,
		T *	output_data
	)

Definition at line 219 of file Utils.h.

{
  const int stride_width = params.stride_width;
  const int stride_height = params.stride_height;
  const int pad_width = params.padding_values.width;
  const int pad_height = params.padding_values.height;
  assert(input_shape.DimensionsCount() == 4);
  assert(output_shape.DimensionsCount() == 4);
 
  const int batches = MatchingDim(input_shape, 0, output_shape, 0);
  const int input_depth = input_shape.Dims(3);
  const int input_width = input_shape.Dims(2);
  const int input_height = input_shape.Dims(1);
  const int output_depth = output_shape.Dims(3);
  const int output_width = output_shape.Dims(2);
  const int output_height = output_shape.Dims(1);
 
  int buffer_id = 0;
  // Loop over the output nodes.
  for (int b = 0; b < batches; ++b)
  {
    for (int h = 0; h < output_height; ++h)
    {
      for (int w = 0; w < output_width; ++w)
      {
        ExtractPatchIntoBufferColumn(input_shape, w, h, b, kheight, kwidth, stride_width,
                                     stride_height, pad_width, pad_height, input_width,
                                     input_height, input_depth, output_depth, buffer_id, input_data,
                                     output_data, zero_byte);
        ++buffer_id;
      }
    }
  }
}

References nnfw::ruy::Shape::DimensionsCount(), nnfw::ruy::Shape::Dims(), ExtractPatchIntoBufferColumn(), nnfw::ruy::PaddingValues::height, MatchingDim(), output_shape, nnfw::ruy::ConvParams::padding_values, nnfw::ruy::ConvParams::stride_height, nnfw::ruy::ConvParams::stride_width, and nnfw::ruy::PaddingValues::width.

IsZeroVector()

bool nnfw::ruy::IsZeroVector ( const float *  vector, int  v_size  )

inline

Definition at line 29 of file TensorUtils.h.

{
  return NEON_OR_PORTABLE(IsZeroVector, vector, v_size);
}

References IsZeroVector(), and NEON_OR_PORTABLE.

Referenced by IsZeroVector(), and onert::backend::ruy::ops::FullyConnectedLayer::prepare().

MatchingDim() [1/2]

int nnfw::ruy::MatchingDim ( const Shape &  shape1, int  index1, const Shape &  shape2, int  index2  )

inline

Definition at line 221 of file Shape.h.

{
  assert(shape1.Dims(index1) == shape2.Dims(index2));
  return shape1.Dims(index1);
}

References nnfw::ruy::Shape::Dims().

Referenced by DilatedIm2col(), Im2col(), and MatchingDim().

MatchingDim() [2/2]

template<typename... Args>

int nnfw::ruy::MatchingDim	(	const Shape &	shape1,
		int	index1,
		const Shape &	shape2,
		int	index2,
		Args...	args
	)

Definition at line 229 of file Shape.h.

{
  assert(shape1.Dims(index1) == shape2.Dims(index2));
  return MatchingDim(shape1, index1, args...);
}

References nnfw::ruy::Shape::Dims(), and MatchingDim().

MatchingElementsSize()

int nnfw::ruy::MatchingElementsSize ( const Shape &  shape, const Shape &  check_shape_0, const Shape &  check_shape_1  )

inline

Definition at line 334 of file Shape.h.

{
  const int size_1 = shape.FlatSize();
  [[maybe_unused]] const int size_2 = check_shape_0.FlatSize();
  [[maybe_unused]] const int size_3 = check_shape_1.FlatSize();
  assert(size_1 == size_2);
  assert(size_2 == size_3);
  return size_1;
}

References nnfw::ruy::Shape::FlatSize().

MatchingFlatSize()

template<typename... Ts>

int nnfw::ruy::MatchingFlatSize ( const Shape &  shape, Ts...  check_shapes  )

inline

Definition at line 298 of file Shape.h.

{
  UNUSED_ALL{check_shapes...};
  assert(checkMatching(shape, std::forward<Ts>(check_shapes)...));
  return shape.FlatSize();
}

References checkMatching(), and nnfw::ruy::Shape::FlatSize().

MatchingFlatSizeSkipDim() [1/2]

int nnfw::ruy::MatchingFlatSizeSkipDim ( const Shape &  shape, int  skip_dim, const Shape &  check_shape_0  )

inline

Definition at line 305 of file Shape.h.

{
  const int dims_count = shape.DimensionsCount();
  for (int i = 0; i < dims_count; ++i)
  {
    if (i != skip_dim)
    {
      assert(shape.Dims(i) == check_shape_0.Dims(i));
    }
  }
  return FlatSizeSkipDim(shape, skip_dim);
}

References nnfw::ruy::Shape::DimensionsCount(), nnfw::ruy::Shape::Dims(), and FlatSizeSkipDim().

Referenced by MatchingFlatSizeSkipDim().

MatchingFlatSizeSkipDim() [2/2]

int nnfw::ruy::MatchingFlatSizeSkipDim ( const Shape &  shape, int  skip_dim, const Shape &  check_shape_0, const Shape &  check_shape_1  )

inline

Definition at line 319 of file Shape.h.

{
  const int dims_count = shape.DimensionsCount();
  for (int i = 0; i < dims_count; ++i)
  {
    if (i != skip_dim)
    {
      assert(shape.Dims(i) == check_shape_0.Dims(i));
    }
  }
  return MatchingFlatSizeSkipDim(shape, skip_dim, check_shape_1);
}

References nnfw::ruy::Shape::DimensionsCount(), nnfw::ruy::Shape::Dims(), and MatchingFlatSizeSkipDim().

Offset() [1/2]

int nnfw::ruy::Offset ( const Shape &  shape, int *  index  )

inline

Definition at line 249 of file Shape.h.

{
  return Offset(shape, index[0], index[1], index[2], index[3]);
}

References Offset().

Offset() [2/2]

int nnfw::ruy::Offset ( const Shape &  shape, int  i0, int  i1, int  i2, int  i3  )

inline

Definition at line 238 of file Shape.h.

{
  assert(shape.DimensionsCount() == 4);
  const int *dims_data = shape.DimsDataUpTo4D();
  assert(i0 >= 0 && i0 < dims_data[0]);
  assert(i1 >= 0 && i1 < dims_data[1]);
  assert(i2 >= 0 && i2 < dims_data[2]);
  assert(i3 >= 0 && i3 < dims_data[3]);
  return ((i0 * dims_data[1] + i1) * dims_data[2] + i2) * dims_data[3] + i3;
}

References nnfw::ruy::Shape::DimensionsCount(), and nnfw::ruy::Shape::DimsDataUpTo4D().

Referenced by DilatedIm2col(), ExtractPatchIntoBufferColumn(), and Offset().

PortableIsZeroVector()

bool nnfw::ruy::PortableIsZeroVector ( const float *  vector, int  v_size  )

inline

Definition at line 26 of file PortableTensorUtils.h.

{
  for (int i = 0; i < v_size; ++i)
  {
    if (*vector++ != 0.0f)
      return false;
  }
  return true;
}

ValidateGemmParams()

template<typename AccumScalar , typename DstScalar , QuantizationFlavor quantization_flavor>

void nnfw::ruy::ValidateGemmParams

(

const GemmParams< AccumScalar, DstScalar, quantization_flavor > &

params

)

Definition at line 229 of file Types.h.

{
  // Guard consistency of the quantized multiplier fields.
  if (quantization_flavor == QuantizationFlavor::kFloatingPoint)
  {
    assert(!params.multiplier_fixedpoint);
    assert(!params.multiplier_exponent);
    assert(!params.multiplier_fixedpoint_perchannel);
    assert(!params.multiplier_exponent_perchannel);
  }
  else if (quantization_flavor == QuantizationFlavor::kIntegerWithUniformMultiplier &&
           !std::is_same<DstScalar, int32_t>::value)
  {
    assert(params.multiplier_fixedpoint);
    // Nothing to check about multiplier_exponent
    assert(!params.multiplier_fixedpoint_perchannel);
    assert(!params.multiplier_exponent_perchannel);
  }
  else if (quantization_flavor == QuantizationFlavor::kIntegerWithPerRowMultiplier &&
           !std::is_same<DstScalar, int32_t>::value)
  {
    assert(!params.multiplier_fixedpoint);
    assert(!params.multiplier_exponent);
    assert(params.multiplier_fixedpoint_perchannel);
    assert(params.multiplier_exponent_perchannel);
  }
  else
  {
    // For the get raw accumulator case, we should make sure none of the
    // quantization params are set.
    assert(!params.multiplier_fixedpoint);
    assert(!params.multiplier_exponent);
    assert(!params.multiplier_fixedpoint_perchannel);
    assert(!params.multiplier_exponent_perchannel);
  }
}

References kFloatingPoint, kIntegerWithPerRowMultiplier, and kIntegerWithUniformMultiplier.