Data Structures
class	Algorithm

struct	Rule

struct	StridedSliceContext

struct	StridedSliceParams

class	TensorShapeExpander
	Create a higher-rank TensorShape following NumPy broadcasting semantics. More...

Functions
loco::TensorShape	circle_shape (const luci::CircleNode *node)

loco::TensorShape	broadcast_shape (const loco::TensorShape &x, const loco::TensorShape &y)

loco::TensorShape	pad_shape (const loco::TensorShape &input_shape, const luci::CircleNode *paddings)

int	Clamp (const int32_t v, const int32_t lo, const int32_t hi)

int64_t	StartForAxis (const StridedSliceParams &params, const loco::TensorShape &input_shape, int64_t axis)

int64_t	StopForAxis (const StridedSliceParams &params, const loco::TensorShape &input_shape, int64_t axis, int64_t start_for_axis)

StridedSliceParams	BuildStridedSliceParams (StridedSliceContext *op_context)

Variables
const int	kMaxDim = 5

const loco::DataType	S32 = loco::DataType::S32

Function Documentation

◆ broadcast_shape()

loco::TensorShape luci::sinf::broadcast_shape	(	const loco::TensorShape &	x,
		const loco::TensorShape &	y
	)

Definition at line 152 of file CircleShapeInferenceHelper.cpp.

{
  auto x_match = x;
  auto y_match = y;
 
  expand_rank(x_match, y_match);
 
  auto output_shape = expand_dimension(x_match, y_match);
 
  return output_shape;
}

References output_shape.

Referenced by luci::sinf::Algorithm::visit(), luci::sinf::Algorithm::visit(), luci::sinf::Algorithm::visit(), and luci::sinf::Algorithm::visit().

◆ BuildStridedSliceParams()

StridedSliceParams luci::sinf::BuildStridedSliceParams ( StridedSliceContext * op_context )

Definition at line 250 of file CircleStridedSlice.cpp.

{
  StridedSliceParams op_params;
 
  // The ellipsis_mask and new_axis_mask in op_params are not used. Those masks
  // are processed here to update begin_mask, end_mask and the index range.
  op_params.begin_mask = 0;
  op_params.ellipsis_mask = 0;
  op_params.end_mask = 0;
  op_params.new_axis_mask = 0;
  op_params.shrink_axis_mask = 0;
 
  // Count indexes where the new_axis_mask is set but the ellipsis_mask is not.
  loco::TensorShape begin_shape = circle_shape(op_context->begin);
  const int64_t begin_count = static_cast<int64_t>(begin_shape.dim(0).value());
  int64_t num_add_axis = 0;
  for (int64_t i = 0; i < begin_count; ++i)
  {
    if (!((1LL << i) & op_context->params.ellipsis_mask) &&
        ((1LL << i) & op_context->params.new_axis_mask))
    {
      num_add_axis++;
    }
  }
 
  // Calculate the dims of input after adding new axises.
  const int64_t effective_dims = op_context->input_dims + num_add_axis;
 
  // If begin, end and strides are not fully provided, it means Ellipsis should
  // be expanded to multiple dimensions (Ex: for spec [Ellipsis, 2] on a 3D
  // input, the Ellipsis should be applied for the first 2 dimensions). Besides,
  // If the new_axis_mask and the ellipsis_mask are set at the same index, the
  // new_axis_mask will have no effect.
  int64_t effective_ellipsis_mask = 0, effective_new_axis_mask = 0;
  int64_t ellipsis_start_idx = effective_dims, expanded_ellipsis = 0;
  for (int64_t i = 0; i < effective_dims;)
  {
    if ((1LL << i) & op_context->params.ellipsis_mask)
    {
      ellipsis_start_idx = i;
      int64_t ellipsis_end_idx =
        std::max(i + 1, std::min(i + 1 + num_add_axis + op_context->input_dims - begin_count,
                                 effective_dims));
      expanded_ellipsis = ellipsis_end_idx - ellipsis_start_idx - 1;
 
      // Set bit for effective_ellipsis_mask.
      for (; i < ellipsis_end_idx; ++i)
      {
        effective_ellipsis_mask |= (1LL << i);
      }
      continue;
    }
 
    if ((1LL << (i - expanded_ellipsis)) & op_context->params.new_axis_mask)
    {
      effective_new_axis_mask |= (1LL << i);
    }
    ++i;
  }
 
  // Calculate effective_input_shape and its corresponding begin, end, strides.
  loco::TensorShape input_shape = circle_shape(op_context->input);
  int64_t added_ellipsis = 0, added_axises = 0;
  // make sure no overflow
  assert(static_cast<uint32_t>(effective_dims) == effective_dims);
  op_context->effective_input_shape.rank(effective_dims);
 
  for (int64_t i = 0; i < effective_dims; ++i)
  {
    if ((1LL << i) & effective_ellipsis_mask)
    {
      // If ellipsis_mask, set the begin_mask and end_mask at that index.
      added_ellipsis = std::max(int64_t(0), i - ellipsis_start_idx);
      assert(i < 16);
      op_params.begin_mask |= (1LL << i);
      op_params.end_mask |= (1LL << i);
      op_params.strides[i] = 1;
      op_context->effective_input_shape.dim(i) = input_shape.dim(i - added_axises);
    }
    else if ((1LL << i) & effective_new_axis_mask)
    {
      // If new_axis_mask is set, it is equivalent to adding a new dim of 1 to
      // input tensor. Store added shape to effective_input_shape.
      op_params.start_indices[i] = 0;
      op_params.stop_indices[i] = 1;
      op_params.strides[i] = 1;
      op_context->effective_input_shape.dim(i) = loco::Dimension(1);
      added_axises++;
    }
    else if (i >= begin_count + expanded_ellipsis)
    {
      op_params.start_indices[i] = 0;
      op_params.stop_indices[i] = 0;
      op_params.strides[i] = 1;
      assert(i < 16);
      op_params.begin_mask |= (1LL << i);
      op_params.end_mask |= (1LL << i);
      op_context->effective_input_shape.dim(i) = input_shape.dim(i - added_axises);
    }
    else
    {
      const int64_t orig_idx = i - added_ellipsis;
      op_params.start_indices[i] = op_context->begin->at<S32>(orig_idx);
      op_params.stop_indices[i] = op_context->end->at<S32>(orig_idx);
      op_params.strides[i] = op_context->strides->at<S32>(orig_idx);
      if (op_context->params.begin_mask & (1LL << orig_idx))
      {
        assert(i < 16);
        op_params.begin_mask |= (1LL << i);
      }
      if (op_context->params.end_mask & (1LL << orig_idx))
      {
        assert(i < 16);
        op_params.end_mask |= (1LL << i);
      }
      if (op_context->params.shrink_axis_mask & (1LL << orig_idx))
      {
        assert(i < 16);
        op_params.shrink_axis_mask |= (1LL << i);
      }
      op_context->effective_input_shape.dim(i) = input_shape.dim(i - added_axises);
    }
  }
 
  // make sure no overflow
  assert(static_cast<int8_t>(effective_dims) == static_cast<int32_t>(effective_dims));
 
  op_params.start_indices_count = effective_dims;
  op_params.stop_indices_count = effective_dims;
  op_params.strides_count = effective_dims;
 
  return op_params;
}

Referenced by luci::sinf::Algorithm::visit().

◆ circle_shape()

loco::TensorShape luci::sinf::circle_shape ( const luci::CircleNode * node )

Definition at line 143 of file CircleShapeInferenceHelper.cpp.

{
  loco::TensorShape shape;
  shape.rank(node->rank());
  for (uint32_t r = 0; r < node->rank(); ++r)
    shape.dim(r) = node->dim(r);
  return shape;
}

References loco::TensorShape::dim(), and loco::TensorShape::rank().

◆ Clamp()

int luci::sinf::Clamp	(	const int32_t	v,
		const int32_t	lo,
		const int32_t	hi
	)

inline

Definition at line 115 of file CircleStridedSlice.cpp.

{
  LUCI_ASSERT(!(hi < lo), "Clamp hi < lo");
  if (hi < v)
    return hi;
  if (v < lo)
    return lo;
  return v;
}

References LUCI_ASSERT.

Referenced by StartForAxis(), and StopForAxis().

◆ pad_shape()

loco::TensorShape luci::sinf::pad_shape	(	const loco::TensorShape &	input_shape,
		const luci::CircleNode *	paddings
	)

Definition at line 164 of file CircleShapeInferenceHelper.cpp.

{
  const loco::DataType S32 = loco::DataType::S32;
  const loco::DataType S64 = loco::DataType::S64;
 
  // TODO support other data type
  LUCI_ASSERT(paddings->dtype() == S32 || paddings->dtype() == S64, "Support int 32/64 for now");
  if (paddings->rank() != 2)
    INTERNAL_EXN("paddings should be rank 2");
 
  int32_t n = paddings->dim(0).value();
  int32_t v = paddings->dim(1).value();
 
  if (v != 2)
    INTERNAL_EXN("paddings should be [n, 2]");
 
  if (n != int32_t(input_shape.rank()))
    INTERNAL_EXN("paddings [n, 2] should have same value of input rank");
 
  loco::TensorShape output_shape;
 
  output_shape.rank(input_shape.rank());
 
  auto const_padding = dynamic_cast<const luci::CircleConst *>(paddings);
  if (const_padding == nullptr)
    return output_shape;
 
  for (int32_t ni = 0; ni < n; ++ni)
  {
    if (not input_shape.dim(ni).known())
    {
      output_shape.dim(ni).unset();
      continue;
    }
    int32_t idx = ni * 2;
    int value = input_shape.dim(ni).value();
    if (const_padding->dtype() == S32)
    {
      value += const_padding->at<S32>(idx + 0); // left
      value += const_padding->at<S32>(idx + 1); // right
    }
    else
    {
      auto pl = const_padding->at<S64>(idx + 0);
      auto pr = const_padding->at<S64>(idx + 1);
      auto max = static_cast<int64_t>(std::numeric_limits<int32_t>::max());
      auto low = static_cast<int64_t>(std::numeric_limits<int32_t>::lowest());
      LUCI_ASSERT(pl <= max, "paddings is over 32 bit limit");
      LUCI_ASSERT(pl >= low, "paddings is over 32 bit limit");
      LUCI_ASSERT(pr <= max, "paddings is over 32 bit limit");
      LUCI_ASSERT(pr >= low, "paddings is over 32 bit limit");
      value += static_cast<int32_t>(pl); // left
      value += static_cast<int32_t>(pr); // right
    }
    output_shape.dim(ni) = value;
  }
 
  return output_shape;
}

References loco::TensorShape::dim(), INTERNAL_EXN, loco::Dimension::known(), LUCI_ASSERT, output_shape, loco::TensorShape::rank(), S32, and loco::Dimension::value().

Referenced by luci::sinf::Algorithm::visit().

◆ StartForAxis()

int64_t luci::sinf::StartForAxis	(	const StridedSliceParams &	params,
		const loco::TensorShape &	input_shape,
		int64_t	axis
	)

inline

Definition at line 128 of file CircleStridedSlice.cpp.

{
  const auto begin_mask = params.begin_mask;
  const auto *start_indices = params.start_indices;
  const auto *strides = params.strides;
  const int64_t axis_size = static_cast<int64_t>(input_shape.dim(axis).value());
  if (axis_size == 0)
  {
    return 0;
  }
  // Begin with the specified index.
  int64_t start = start_indices[axis];
 
  // begin_mask override
  if (begin_mask & (1LL << axis))
  {
    if (strides[axis] > 0)
    {
      // Forward iteration - use the first element. These values will get
      // clamped below (Note: We could have set them to 0 and axis_size-1, but
      // use lowest() and max() to maintain symmetry with StopForAxis())
      start = std::numeric_limits<int32_t>::lowest();
    }
    else
    {
      // Backward iteration - use the last element.
      start = std::numeric_limits<int32_t>::max();
    }
  }
 
  // Handle negative indices
  if (start < 0)
  {
    start += axis_size;
  }
 
  // Clamping
  if (strides[axis] > 0)
  {
    // Forward iteration
    start = Clamp(start, 0, axis_size);
  }
  else
  {
    // Backward iteration
    start = Clamp(start, -1, axis_size - 1);
  }
 
  return start;
}

References luci::sinf::StridedSliceParams::begin_mask, Clamp(), loco::TensorShape::dim(), luci::sinf::StridedSliceParams::start_indices, luci::sinf::StridedSliceParams::strides, and loco::Dimension::value().

Referenced by luci::sinf::Algorithm::visit().

◆ StopForAxis()

int64_t luci::sinf::StopForAxis	(	const StridedSliceParams &	params,
		const loco::TensorShape &	input_shape,
		int64_t	axis,
		int64_t	start_for_axis
	)

inline

Definition at line 185 of file CircleStridedSlice.cpp.

{
  const auto end_mask = params.end_mask;
  const auto shrink_axis_mask = params.shrink_axis_mask;
  const auto *stop_indices = params.stop_indices;
  const auto *strides = params.strides;
  const int64_t axis_size = static_cast<int64_t>(input_shape.dim(axis).value());
  if (axis_size == 0)
  {
    return 0;
  }
 
  // Begin with the specified index
  const bool shrink_axis = shrink_axis_mask & (1LL << axis);
  int64_t stop = stop_indices[axis];
 
  // When shrinking an axis, the end position does not matter (and can be
  // incorrect when negative indexing is used, see Issue #19260). Always use
  // start_for_axis + 1 to generate a length 1 slice, since start_for_axis has
  // already been adjusted for negative indices.
  if (shrink_axis)
  {
    return start_for_axis + 1;
  }
 
  // end_mask override
  if (end_mask & (1LL << axis))
  {
    if (strides[axis] > 0)
    {
      // Forward iteration - use the last element. These values will get
      // clamped below
      stop = std::numeric_limits<int32_t>::max();
    }
    else
    {
      // Backward iteration - use the first element.
      stop = std::numeric_limits<int32_t>::lowest();
    }
  }
 
  // Handle negative indices
  if (stop < 0)
  {
    stop += axis_size;
  }
 
  // Clamping
  // Because the end index points one past the last element, we need slightly
  // different clamping ranges depending on the direction.
  if (strides[axis] > 0)
  {
    // Forward iteration
    stop = Clamp(stop, 0, axis_size);
  }
  else
  {
    // Backward iteration
    stop = Clamp(stop, -1, axis_size - 1);
  }
 
  return stop;
}

References Clamp(), loco::TensorShape::dim(), luci::sinf::StridedSliceParams::end_mask, luci::sinf::StridedSliceParams::shrink_axis_mask, luci::sinf::StridedSliceParams::stop_indices, luci::sinf::StridedSliceParams::strides, and loco::Dimension::value().

Referenced by luci::sinf::Algorithm::visit().

Variable Documentation

◆ kMaxDim

const int luci::sinf::kMaxDim = 5

Definition at line 58 of file CircleStridedSlice.cpp.

◆ S32

const loco::DataType luci::sinf::S32 = loco::DataType::S32

Definition at line 60 of file CircleStridedSlice.cpp.

Referenced by BuildStridedSliceParams(), pad_shape(), luci::sinf::Algorithm::visit(), and luci::sinf::Algorithm::visit().

Data Structures

Functions

Variables

Function Documentation

◆ broadcast_shape()

◆ BuildStridedSliceParams()

◆ circle_shape()

◆ Clamp()

◆ pad_shape()

◆ StartForAxis()

◆ StopForAxis()

Variable Documentation

◆ kMaxDim

◆ S32