mutable_layout();\n return shape;\n }();\n return *shape;\n}\n static const Shape* shape = [] {\n static const Shape* shape = [] {\n static const Shape* shape = [] {\n static const Shape* shape = [] {\n static const Shape* shape = [] {\n static const Shape* shape = [] {\n static const Shape* shape = [] {\n static const Shape* shape = [] {\n static const Shape* shape = [] {\n static const Shape* shape = [] {\n static const Shape* shape = [] {\n static const Shape* shape = [] {\n static const Shape* shape = [] {\n static const Shape* shape = [] {\n static const Shape* shape = [] {\n static const Shape* shape = [] {\n static const Shape* shape = [] {\n static const Shape* shape = [] {\n static const Shape* shape = [] {\n static const Shape* shape = [] {\n static const Shape* shape = [] {\n static const Shape* shape = [] {\n static const Shape* shape = [] {\n static const Shape* shape = [] {\nconst Shape& NilShape() {\n static const Shape* shape = new Shape(TUPLE, {}, {}, {});\n return *shape;\n}\nconst Shape* TryInternShape(const Shape& shape) {\n if (shape.IsTuple() && shape.tuple_shapes_size() == 0) {\n return &NilShape();\n }\n if (shape.IsArray() && shape.dimensions_size() == 0 && shape.is_static() &&\n shape.layout().tiles_size() == 0 && shape.layout().memory_space() == 0) {\n return &ScalarShape(shape.element_type());\n }\n return nullptr;\n}\nStrideConfig::StrideConfig(const Shape& source_shape, const Shape& dest_shape,\n absl::Span dimensions)\n : dimensions(dimensions),\n base(dimensions.size(), 0),\n step(dimensions.size(), 1) {\n if (!dimensions.empty()) {\n // Selects the shape with the largest minor dimension as the one upon\n // which to run the tight stride loop.\n if (dimensions[LayoutUtil::Minor(source_shape.layout(), 0)] >=\n dimensions[LayoutUtil::Minor(dest_shape.layout(), 0)]) {\n minor_dimension = LayoutUtil::Minor(source_shape.layout(), 0);\n dest_stride = IndexUtil::GetDimensionStride(dest_shape, minor_dimension);\n } else {\n minor_dimension = LayoutUtil::Minor(dest_shape.layout(), 0);\n source_stride =\n IndexUtil::GetDimensionStride(source_shape, minor_dimension);\n }\n minor_loop_size = dimensions[minor_dimension];\n step[minor_dimension] = minor_loop_size;\n }\n}\nLiteralBase::~LiteralBase() = default;\nconst Shape& LiteralBase::shape() const { return root_piece().subshape(); }\nconst char* LiteralBase::Piece::buffer() const {\n // std::visit is avoided here due to its code size issues.\n if (auto* r = std::get_if(&rep_)) {\n return r->data;\n }\n if (auto* r = std::get_if(&rep_)) {\n return r->data;\n }\n DCHECK(std::holds_alternative(rep_) ||\n std::holds_alternative(rep_));\n return nullptr;\n}\nconst LiteralBase::Piece& LiteralBase::piece(\n const ShapeIndex& shape_index) const {\n const Piece* piece = &root_piece();\n for (const auto i : shape_index) {\n DCHECK_GE(i, 0);\n DCHECK_LT(i, piece->children_size());\n piece = &piece->child(i);\n }\n return *piece;\n}\nstd::ostream& operator<<(std::ostream& out, const Literal& literal) {\n out << literal.ToString();\n return out;\n}\nShape* MutableLiteralBase::mutable_shape_do_not_use() {\n const Shape* const_shape = shape_.get();\n if (!shape_.OwnsPtr()) {\n shape_ = MaybeOwningShapePtr(std::make_unique(*shape_));\n }\n Shape* shape = shape_.get_mutable();\n\n if (shape != const_shape) {\n std::function set_piece_shapes =\n [&set_piece_shapes](const Shape& shape, Piece* piece) {\n piece->set_subshape(&shape);\n if (shape.IsTuple()) {\n for (int i = 0; i < ShapeUtil::TupleElementCount(shape); ++i) {\n const Shape& subshape = shape.tuple_shapes(i);\n set_piece_shapes(subshape, &piece->child(i));\n }\n }\n };\n set_piece_shapes(*shape, &mutable_root_piece());\n }\n return shape;\n}\n [&set_piece_shapes](const Shape& shape, Piece* piece) {\n piece->set_subshape(&shape);\n if (shape.IsTuple()) {\n for (int i = 0; i < ShapeUtil::TupleElementCount(shape); ++i) {\n const Shape& subshape = shape.tuple_shapes(i);\n set_piece_shapes(subshape, &piece->child(i));\n }\n }\n };\nLiteral::Literal() : Literal(NilShape()) {}\nLiteral::Literal(const Shape& shape)\n : Literal(shape, /*allocate_arrays=*/true) {}\nvoid Literal::SetShape(const Shape& shape) {\n Shape shape_storage;\n const Shape* shape_ptr = &shape;\n if (LayoutUtil::HasCustomElementSizeInBits(shape)) {\n shape_storage = shape;\n shape_storage.mutable_layout()->set_element_size_in_bits(0);\n shape_ptr = &shape_storage;\n }\n if (const Shape* intered_shape_ptr = TryInternShape(*shape_ptr)) {\n shape_ = intered_shape_ptr;\n } else {\n shape_ = std::make_unique(*shape_ptr);\n }\n}\nvoid Literal::SetPiece(const Shape& shape, Piece* piece, bool allocate_arrays,\n ArrayValueState leaf_array_value_state) {\n if (shape.IsTuple()) {\n for (const Shape& subshape : shape.tuple_shapes()) {\n Piece child_piece;\n child_piece.set_subshape(&subshape);\n\n SetPiece(subshape, &child_piece, allocate_arrays, leaf_array_value_state);\n\n piece->emplace_back(std::move(child_piece));\n }\n } else if (shape.IsArray()) {\n DCHECK(LayoutUtil::IsDenseArray(shape))\n << \"literal array storage is currently only supported for dense \"\n \"arrays: \"\n << shape;\n piece->set_array_value_state(leaf_array_value_state);\n if (leaf_array_value_state == LiteralBase::ArrayValueState::kKnown &&\n allocate_arrays) {\n piece->AllocateBuffers();\n }\n }\n}\nLiteral::Literal(const Shape& shape, bool allocate_arrays,\n ArrayValueState leaf_array_value_state)\n : MutableLiteralBase() {\n SetShape(shape);\n CHECK(leaf_array_value_state != ArrayValueState::kKnown ||\n LayoutUtil::HasLayout(*shape_));\n root_piece_.set_subshape(shape_.get());\n CHECK(&root_piece_.subshape() == shape_.get());\n\n SetPiece(*shape_, &root_piece_, allocate_arrays, leaf_array_value_state);\n}\nLiteral::~Literal() { DeallocateBuffers(); }\nvoid Literal::DeallocateBuffers() {\n root_piece_.ForEachMutableSubpiece(\n [&](const ShapeIndex& index, Piece* piece) {\n piece->DeallocateBuffers();\n });\n}\nLiteral::Literal(Literal&& other) : MutableLiteralBase() {\n *this = std::move(other);\n}\nLiteral& Literal::operator=(Literal&& other) {\n DCHECK(&other.root_piece_.subshape() == other.shape_.get());\n using std::swap;\n swap(shape_, other.shape_);\n swap(root_piece_, other.root_piece_);\n DCHECK(&root_piece_.subshape() == shape_.get());\n\n return *this;\n}\nLiteral LiteralBase::CreateFromShape(const Shape& shape) {\n Literal literal(shape);\n literal.root_piece_.ForEachMutableSubpiece(\n [&](const ShapeIndex& index, Piece* piece) {\n if (piece->subshape().IsArray()) {\n memset(piece->untyped_data(), 0, piece->size_bytes_dense());\n }\n });\n return literal;\n}\n [&](const ShapeIndex& index, Piece* piece) {\n if (piece->subshape().IsArray()) {\n memset(piece->untyped_data(), 0, piece->size_bytes_dense());\n }\n });\nLiteral LiteralBase::CreateFromShapeWithUnknownLeafArrays(const Shape& shape) {\n Literal literal(shape, /*allocate_arrays=*/false, ArrayValueState::kUnknown);\n return literal;\n}\nLiteral LiteralBase::CreateFromShapeWithUndeterminedLeafArrays(\n const Shape& shape) {\n Literal literal(shape, /*allocate_arrays=*/false,\n ArrayValueState::kUndetermined);\n return literal;\n}\nint32_t LiteralBase::GetDynamicSize(int64_t dim_index) const {\n return GetDynamicSize(dim_index, {});\n}\nint32_t LiteralBase::GetDynamicSize(int64_t dim_index,\n const ShapeIndex& shape_index) const {\n return piece(shape_index).GetDynamicSize(dim_index);\n}\nstd::optional LiteralBase::GetFirstInteger() const {\n if (!primitive_util::IsIntegralType(shape().element_type())) {\n return std::nullopt;\n }\n return primitive_util::IntegralTypeSwitch>(\n [&](auto primitive_type_constant) -> std::optional {\n using NativeT = NativeTypeOf;\n auto first_element = GetFirstElement();\n if constexpr (std::is_same_v) {\n int64_t v = static_cast(first_element);\n if (v < 0) {\n return std::nullopt;\n }\n }\n return first_element;\n },\n shape().element_type());\n}\n [&](auto primitive_type_constant) -> std::optional {\n using NativeT = NativeTypeOf;\n auto first_element = GetFirstElement();\n if constexpr (std::is_same_v) {\n int64_t v = static_cast(first_element);\n if (v < 0) {\n return std::nullopt;\n }\n }\n return first_element;\n },\n [&](auto primitive_type_constant) -> std::optional {\n using NativeT = NativeTypeOf;\n auto first_element = GetFirstElement();\n if constexpr (std::is_same_v) {\n int64_t v = static_cast(first_element);\n if (v < 0) {\n return std::nullopt;\n }\n }\n return first_element;\n },\n [&](auto primitive_type_constant) -> std::optional {\n using NativeT = NativeTypeOf;\n auto first_element = GetFirstElement();\n if constexpr (std::is_same_v) {\n int64_t v = static_cast(first_element);\n if (v < 0) {\n return std::nullopt;\n }\n }\n return first_element;\n },\n [&](auto primitive_type_constant) -> std::optional {\n using NativeT = NativeTypeOf;\n auto first_element = GetFirstElement();\n if constexpr (std::is_same_v) {\n int64_t v = static_cast(first_element);\n if (v < 0) {\n return std::nullopt;\n }\n }\n return first_element;\n },\n [&](auto primitive_type_constant) -> std::optional {\n using NativeT = NativeTypeOf;\n auto first_element = GetFirstElement();\n if constexpr (std::is_same_v) {\n int64_t v = static_cast(first_element);\n if (v < 0) {\n return std::nullopt;\n }\n }\n return first_element;\n },\nvoid LiteralBase::BuildPieceSubtree(const Shape& shape, Piece* piece) {\n CHECK(shape.IsTuple());\n for (int i = 0; i < ShapeUtil::TupleElementCount(shape); ++i) {\n const Shape& subshape = shape.tuple_shapes(i);\n\n Piece child_piece;\n child_piece.set_subshape(&subshape);\n\n if (subshape.IsTuple()) {\n BuildPieceSubtree(subshape, &child_piece);\n }\n\n piece->emplace_back(std::move(child_piece));\n }\n}\nabsl::Status LiteralBase::SerializeToString(std::string* output) const {\n ShapeProto shape_proto = shape().ToProto();\n TF_ASSIGN_OR_RETURN(int64_t size,\n ShapeUtil::SerializedSizeWithProto(shape(), shape_proto));\n output->resize(size);\n return SerializeWithShapeProto(shape_proto, output->data());\n}\nabsl::StatusOr LiteralBase::SerializeAsString() const {\n std::string result;\n TF_RETURN_IF_ERROR(SerializeToString(&result));\n return std::move(result);\n}\nabsl::Status MutableLiteralBase::CopySliceFromInternal(\n const LiteralBase& src_literal, absl::Span src_base,\n absl::Span dest_base, absl::Span copy_size) {\n auto linear_index = [](const Shape& shape,\n absl::Span multi_index) {\n return IndexUtil::MultidimensionalIndexToLinearIndex(shape, multi_index);\n };\n\n // `this->` is needed to workaround MSVC bug: #16882\n NativeT* dest_data = this->data().data();\n const NativeT* src_data = src_literal.data().data();\n if (src_literal.shape().rank() == 0 || shape().rank() == 0) {\n // If any of the two shapes are scalars, just assign the value once.\n TF_RET_CHECK(copy_size.empty());\n dest_data[linear_index(shape(), dest_base)] =\n src_data[linear_index(src_literal.shape(), src_base)];\n } else if (!ShapeUtil::IsZeroElementArray(shape()) &&\n !ShapeUtil::IsZeroElementArray(src_literal.shape()) &&\n absl::c_none_of(copy_size, [](auto d) { return d == 0; })) {\n // Perform copy if none of src, dest and copy_size has dimensions with zero\n // element, otherwise it's a no-op.\n TF_RET_CHECK(src_base.size() == dest_base.size());\n TF_RET_CHECK(src_base.size() == copy_size.size());\n\n // Scan the source from minor, stepping in copy size blocks, then within\n // the index enumeration functor, do a strided copy advancing source index\n // by one (walking through the minor dimension), and destination index by\n // proper stride size at the matching dimension.\n DimensionVector src_indexes(src_base.size(), 0);\n DimensionVector dest_indexes(dest_base.size(), 0);\n StrideConfig stride_config(src_literal.shape(), shape(), copy_size);\n\n auto copy_proc = [&](absl::Span indexes) {\n // Map from multi-dimensional index, to source index.\n std::transform(indexes.begin(), indexes.end(), src_base.begin(),\n src_indexes.begin(), std::plus());\n // Map from multi-dimensional index, to destination index.\n std::transform(indexes.begin(), indexes.end(), dest_base.begin(),\n dest_indexes.begin(), std::plus());\n\n int64_t src_index = linear_index(src_literal.shape(), src_indexes);\n int64_t dest_index = linear_index(shape(), dest_indexes);\n\n StridedCopy(dest_data + dest_index, stride_config.dest_stride,\n src_data + src_index, stride_config.source_stride,\n stride_config.minor_loop_size);\n return true;\n };\n\n ShapeUtil::ForEachIndex(src_literal.shape(), stride_config.base,\n stride_config.dimensions, stride_config.step,\n copy_proc);\n }\n return absl::OkStatus();\n}\nabsl::Status MutableLiteralBase::CopySliceFromInternal(\n const LiteralBase& src_literal, absl::Span src_base,\n absl::Span dest_base, absl::Span copy_size) {\n auto linear_index = [](const Shape& shape,\n absl::Span multi_index) {\n return IndexUtil::MultidimensionalIndexToLinearIndex(shape, multi_index);\n };\n\n // `this->` is needed to workaround MSVC bug: #16882\n NativeT* dest_data = this->data().data();\n const NativeT* src_data = src_literal.data().data();\n if (src_literal.shape().rank() == 0 || shape().rank() == 0) {\n // If any of the two shapes are scalars, just assign the value once.\n TF_RET_CHECK(copy_size.empty());\n dest_data[linear_index(shape(), dest_base)] =\n src_data[linear_index(src_literal.shape(), src_base)];\n } else if (!ShapeUtil::IsZeroElementArray(shape()) &&\n !ShapeUtil::IsZeroElementArray(src_literal.shape()) &&\n absl::c_none_of(copy_size, [](auto d) { return d == 0; })) {\n // Perform copy if none of src, dest and copy_size has dimensions with zero\n // element, otherwise it's a no-op.\n TF_RET_CHECK(src_base.size() == dest_base.size());\n TF_RET_CHECK(src_base.size() == copy_size.size());\n\n // Scan the source from minor, stepping in copy size blocks, then within\n // the index enumeration functor, do a strided copy advancing source index\n // by one (walking through the minor dimension), and destination index by\n // proper stride size at the matching dimension.\n DimensionVector src_indexes(src_base.size(), 0);\n DimensionVector dest_indexes(dest_base.size(), 0);\n StrideConfig stride_config(src_literal.shape(), shape(), copy_size);\n\n auto copy_proc = [&](absl::Span indexes) {\n // Map from multi-dimensional index, to source index.\n std::transform(indexes.begin(), indexes.end(), src_base.begin(),\n src_indexes.begin(), std::plus());\n // Map from multi-dimensional index, to destination index.\n std::transform(indexes.begin(), indexes.end(), dest_base.begin(),\n dest_indexes.begin(), std::plus());\n\n int64_t src_index = linear_index(src_literal.shape(), src_indexes);\n int64_t dest_index = linear_index(shape(), dest_indexes);\n\n StridedCopy(dest_data + dest_index, stride_config.dest_stride,\n src_data + src_index, stride_config.source_stride,\n stride_config.minor_loop_size);\n return true;\n };\n\n ShapeUtil::ForEachIndex(src_literal.shape(), stride_config.base,\n stride_config.dimensions, stride_config.step,\n copy_proc);\n }\n return absl::OkStatus();\n}\nabsl::Status MutableLiteralBase::CopySliceFromInternal(\n const LiteralBase& src_literal, absl::Span src_base,\n absl::Span dest_base, absl::Span copy_size) {\n auto linear_index = [](const Shape& shape,\n absl::Span multi_index) {\n return IndexUtil::MultidimensionalIndexToLinearIndex(shape, multi_index);\n };\n\n // `this->` is needed to workaround MSVC bug: #16882\n NativeT* dest_data = this->data().data();\n const NativeT* src_data = src_literal.data().data();\n if (src_literal.shape().rank() == 0 || shape().rank() == 0) {\n // If any of the two shapes are scalars, just assign the value once.\n TF_RET_CHECK(copy_size.empty());\n dest_data[linear_index(shape(), dest_base)] =\n src_data[linear_index(src_literal.shape(), src_base)];\n } else if (!ShapeUtil::IsZeroElementArray(shape()) &&\n !ShapeUtil::IsZeroElementArray(src_literal.shape()) &&\n absl::c_none_of(copy_size, [](auto d) { return d == 0; })) {\n // Perform copy if none of src, dest and copy_size has dimensions with zero\n // element, otherwise it's a no-op.\n TF_RET_CHECK(src_base.size() == dest_base.size());\n TF_RET_CHECK(src_base.size() == copy_size.size());\n\n // Scan the source from minor, stepping in copy size blocks, then within\n // the index enumeration functor, do a strided copy advancing source index\n // by one (walking through the minor dimension), and destination index by\n // proper stride size at the matching dimension.\n DimensionVector src_indexes(src_base.size(), 0);\n DimensionVector dest_indexes(dest_base.size(), 0);\n StrideConfig stride_config(src_literal.shape(), shape(), copy_size);\n\n auto copy_proc = [&](absl::Span indexes) {\n // Map from multi-dimensional index, to source index.\n std::transform(indexes.begin(), indexes.end(), src_base.begin(),\n src_indexes.begin(), std::plus());\n // Map from multi-dimensional index, to destination index.\n std::transform(indexes.begin(), indexes.end(), dest_base.begin(),\n dest_indexes.begin(), std::plus());\n\n int64_t src_index = linear_index(src_literal.shape(), src_indexes);\n int64_t dest_index = linear_index(shape(), dest_indexes);\n\n StridedCopy(dest_data + dest_index, stride_config.dest_stride,\n src_data + src_index, stride_config.source_stride,\n stride_config.minor_loop_size);\n return true;\n };\n\n ShapeUtil::ForEachIndex(src_literal.shape(), stride_config.base,\n stride_config.dimensions, stride_config.step,\n copy_proc);\n }\n return absl::OkStatus();\n}\nabsl::Status MutableLiteralBase::CopySliceFromInternal(\n const LiteralBase& src_literal, absl::Span src_base,\n absl::Span dest_base, absl::Span copy_size) {\n auto linear_index = [](const Shape& shape,\n absl::Span multi_index) {\n return IndexUtil::MultidimensionalIndexToLinearIndex(shape, multi_index);\n };\n\n // `this->` is needed to workaround MSVC bug: #16882\n NativeT* dest_data = this->data().data();\n const NativeT* src_data = src_literal.data().data();\n if (src_literal.shape().rank() == 0 || shape().rank() == 0) {\n // If any of the two shapes are scalars, just assign the value once.\n TF_RET_CHECK(copy_size.empty());\n dest_data[linear_index(shape(), dest_base)] =\n src_data[linear_index(src_literal.shape(), src_base)];\n } else if (!ShapeUtil::IsZeroElementArray(shape()) &&\n !ShapeUtil::IsZeroElementArray(src_literal.shape()) &&\n absl::c_none_of(copy_size, [](auto d) { return d == 0; })) {\n // Perform copy if none of src, dest and copy_size has dimensions with zero\n // element, otherwise it's a no-op.\n TF_RET_CHECK(src_base.size() == dest_base.size());\n TF_RET_CHECK(src_base.size() == copy_size.size());\n\n // Scan the source from minor, stepping in copy size blocks, then within\n // the index enumeration functor, do a strided copy advancing source index\n // by one (walking through the minor dimension), and destination index by\n // proper stride size at the matching dimension.\n DimensionVector src_indexes(src_base.size(), 0);\n DimensionVector dest_indexes(dest_base.size(), 0);\n StrideConfig stride_config(src_literal.shape(), shape(), copy_size);\n\n auto copy_proc = [&](absl::Span indexes) {\n // Map from multi-dimensional index, to source index.\n std::transform(indexes.begin(), indexes.end(), src_base.begin(),\n src_indexes.begin(), std::plus());\n // Map from multi-dimensional index, to destination index.\n std::transform(indexes.begin(), indexes.end(), dest_base.begin(),\n dest_indexes.begin(), std::plus());\n\n int64_t src_index = linear_index(src_literal.shape(), src_indexes);\n int64_t dest_index = linear_index(shape(), dest_indexes);\n\n StridedCopy(dest_data + dest_index, stride_config.dest_stride,\n src_data + src_index, stride_config.source_stride,\n stride_config.minor_loop_size);\n return true;\n };\n\n ShapeUtil::ForEachIndex(src_literal.shape(), stride_config.base,\n stride_config.dimensions, stride_config.step,\n copy_proc);\n }\n return absl::OkStatus();\n}\nabsl::Status MutableLiteralBase::CopySliceFromInternal(\n const LiteralBase& src_literal, absl::Span src_base,\n absl::Span dest_base, absl::Span copy_size) {\n auto linear_index = [](const Shape& shape,\n absl::Span multi_index) {\n return IndexUtil::MultidimensionalIndexToLinearIndex(shape, multi_index);\n };\n\n // `this->` is needed to workaround MSVC bug: #16882\n NativeT* dest_data = this->data().data();\n const NativeT* src_data = src_literal.data().data();\n if (src_literal.shape().rank() == 0 || shape().rank() == 0) {\n // If any of the two shapes are scalars, just assign the value once.\n TF_RET_CHECK(copy_size.empty());\n dest_data[linear_index(shape(), dest_base)] =\n src_data[linear_index(src_literal.shape(), src_base)];\n } else if (!ShapeUtil::IsZeroElementArray(shape()) &&\n !ShapeUtil::IsZeroElementArray(src_literal.shape()) &&\n absl::c_none_of(copy_size, [](auto d) { return d == 0; })) {\n // Perform copy if none of src, dest and copy_size has dimensions with zero\n // element, otherwise it's a no-op.\n TF_RET_CHECK(src_base.size() == dest_base.size());\n TF_RET_CHECK(src_base.size() == copy_size.size());\n\n // Scan the source from minor, stepping in copy size blocks, then within\n // the index enumeration functor, do a strided copy advancing source index\n // by one (walking through the minor dimension), and destination index by\n // proper stride size at the matching dimension.\n DimensionVector src_indexes(src_base.size(), 0);\n DimensionVector dest_indexes(dest_base.size(), 0);\n StrideConfig stride_config(src_literal.shape(), shape(), copy_size);\n\n auto copy_proc = [&](absl::Span indexes) {\n // Map from multi-dimensional index, to source index.\n std::transform(indexes.begin(), indexes.end(), src_base.begin(),\n src_indexes.begin(), std::plus());\n // Map from multi-dimensional index, to destination index.\n std::transform(indexes.begin(), indexes.end(), dest_base.begin(),\n dest_indexes.begin(), std::plus());\n\n int64_t src_index = linear_index(src_literal.shape(), src_indexes);\n int64_t dest_index = linear_index(shape(), dest_indexes);\n\n StridedCopy(dest_data + dest_index, stride_config.dest_stride,\n src_data + src_index, stride_config.source_stride,\n stride_config.minor_loop_size);\n return true;\n };\n\n ShapeUtil::ForEachIndex(src_literal.shape(), stride_config.base,\n stride_config.dimensions, stride_config.step,\n copy_proc);\n }\n return absl::OkStatus();\n}\nabsl::Status MutableLiteralBase::CopySliceFromInternal(\n const LiteralBase& src_literal, absl::Span src_base,\n absl::Span dest_base, absl::Span copy_size) {\n auto linear_index = [](const Shape& shape,\n absl::Span multi_index) {\n return IndexUtil::MultidimensionalIndexToLinearIndex(shape, multi_index);\n };\n\n // `this->` is needed to workaround MSVC bug: #16882\n NativeT* dest_data = this->data().data();\n const NativeT* src_data = src_literal.data().data();\n if (src_literal.shape().rank() == 0 || shape().rank() == 0) {\n // If any of the two shapes are scalars, just assign the value once.\n TF_RET_CHECK(copy_size.empty());\n dest_data[linear_index(shape(), dest_base)] =\n src_data[linear_index(src_literal.shape(), src_base)];\n } else if (!ShapeUtil::IsZeroElementArray(shape()) &&\n !ShapeUtil::IsZeroElementArray(src_literal.shape()) &&\n absl::c_none_of(copy_size, [](auto d) { return d == 0; })) {\n // Perform copy if none of src, dest and copy_size has dimensions with zero\n // element, otherwise it's a no-op.\n TF_RET_CHECK(src_base.size() == dest_base.size());\n TF_RET_CHECK(src_base.size() == copy_size.size());\n\n // Scan the source from minor, stepping in copy size blocks, then within\n // the index enumeration functor, do a strided copy advancing source index\n // by one (walking through the minor dimension), and destination index by\n // proper stride size at the matching dimension.\n DimensionVector src_indexes(src_base.size(), 0);\n DimensionVector dest_indexes(dest_base.size(), 0);\n StrideConfig stride_config(src_literal.shape(), shape(), copy_size);\n\n auto copy_proc = [&](absl::Span indexes) {\n // Map from multi-dimensional index, to source index.\n std::transform(indexes.begin(), indexes.end(), src_base.begin(),\n src_indexes.begin(), std::plus());\n // Map from multi-dimensional index, to destination index.\n std::transform(indexes.begin(), indexes.end(), dest_base.begin(),\n dest_indexes.begin(), std::plus());\n\n int64_t src_index = linear_index(src_literal.shape(), src_indexes);\n int64_t dest_index = linear_index(shape(), dest_indexes);\n\n StridedCopy(dest_data + dest_index, stride_config.dest_stride,\n src_data + src_index, stride_config.source_stride,\n stride_config.minor_loop_size);\n return true;\n };\n\n ShapeUtil::ForEachIndex(src_literal.shape(), stride_config.base,\n stride_config.dimensions, stride_config.step,\n copy_proc);\n }\n return absl::OkStatus();\n}\nabsl::Status MutableLiteralBase::CopySliceFromInternal(\n const LiteralBase& src_literal, absl::Span src_base,\n absl::Span dest_base, absl::Span copy_size) {\n auto linear_index = [](const Shape& shape,\n absl::Span multi_index) {\n return IndexUtil::MultidimensionalIndexToLinearIndex(shape, multi_index);\n };\n\n // `this->` is needed to workaround MSVC bug: #16882\n NativeT* dest_data = this->data().data();\n const NativeT* src_data = src_literal.data().data();\n if (src_literal.shape().rank() == 0 || shape().rank() == 0) {\n // If any of the two shapes are scalars, just assign the value once.\n TF_RET_CHECK(copy_size.empty());\n dest_data[linear_index(shape(), dest_base)] =\n src_data[linear_index(src_literal.shape(), src_base)];\n } else if (!ShapeUtil::IsZeroElementArray(shape()) &&\n !ShapeUtil::IsZeroElementArray(src_literal.shape()) &&\n absl::c_none_of(copy_size, [](auto d) { return d == 0; })) {\n // Perform copy if none of src, dest and copy_size has dimensions with zero\n // element, otherwise it's a no-op.\n TF_RET_CHECK(src_base.size() == dest_base.size());\n TF_RET_CHECK(src_base.size() == copy_size.size());\n\n // Scan the source from minor, stepping in copy size blocks, then within\n // the index enumeration functor, do a strided copy advancing source index\n // by one (walking through the minor dimension), and destination index by\n // proper stride size at the matching dimension.\n DimensionVector src_indexes(src_base.size(), 0);\n DimensionVector dest_indexes(dest_base.size(), 0);\n StrideConfig stride_config(src_literal.shape(), shape(), copy_size);\n\n auto copy_proc = [&](absl::Span indexes) {\n // Map from multi-dimensional index, to source index.\n std::transform(indexes.begin(), indexes.end(), src_base.begin(),\n src_indexes.begin(), std::plus());\n // Map from multi-dimensional index, to destination index.\n std::transform(indexes.begin(), indexes.end(), dest_base.begin(),\n dest_indexes.begin(), std::plus());\n\n int64_t src_index = linear_index(src_literal.shape(), src_indexes);\n int64_t dest_index = linear_index(shape(), dest_indexes);\n\n StridedCopy(dest_data + dest_index, stride_config.dest_stride,\n src_data + src_index, stride_config.source_stride,\n stride_config.minor_loop_size);\n return true;\n };\n\n ShapeUtil::ForEachIndex(src_literal.shape(), stride_config.base,\n stride_config.dimensions, stride_config.step,\n copy_proc);\n }\n return absl::OkStatus();\n}\nabsl::Status MutableLiteralBase::CopySliceFromInternal(\n const LiteralBase& src_literal, absl::Span src_base,\n absl::Span dest_base, absl::Span copy_size) {\n auto linear_index = [](const Shape& shape,\n absl::Span multi_index) {\n return IndexUtil::MultidimensionalIndexToLinearIndex(shape, multi_index);\n };\n\n // `this->` is needed to workaround MSVC bug: #16882\n NativeT* dest_data = this->data().data();\n const NativeT* src_data = src_literal.data().data();\n if (src_literal.shape().rank() == 0 || shape().rank() == 0) {\n // If any of the two shapes are scalars, just assign the value once.\n TF_RET_CHECK(copy_size.empty());\n dest_data[linear_index(shape(), dest_base)] =\n src_data[linear_index(src_literal.shape(), src_base)];\n } else if (!ShapeUtil::IsZeroElementArray(shape()) &&\n !ShapeUtil::IsZeroElementArray(src_literal.shape()) &&\n absl::c_none_of(copy_size, [](auto d) { return d == 0; })) {\n // Perform copy if none of src, dest and copy_size has dimensions with zero\n // element, otherwise it's a no-op.\n TF_RET_CHECK(src_base.size() == dest_base.size());\n TF_RET_CHECK(src_base.size() == copy_size.size());\n\n // Scan the source from minor, stepping in copy size blocks, then within\n // the index enumeration functor, do a strided copy advancing source index\n // by one (walking through the minor dimension), and destination index by\n // proper stride size at the matching dimension.\n DimensionVector src_indexes(src_base.size(), 0);\n DimensionVector dest_indexes(dest_base.size(), 0);\n StrideConfig stride_config(src_literal.shape(), shape(), copy_size);\n\n auto copy_proc = [&](absl::Span indexes) {\n // Map from multi-dimensional index, to source index.\n std::transform(indexes.begin(), indexes.end(), src_base.begin(),\n src_indexes.begin(), std::plus());\n // Map from multi-dimensional index, to destination index.\n std::transform(indexes.begin(), indexes.end(), dest_base.begin(),\n dest_indexes.begin(), std::plus());\n\n int64_t src_index = linear_index(src_literal.shape(), src_indexes);\n int64_t dest_index = linear_index(shape(), dest_indexes);\n\n StridedCopy(dest_data + dest_index, stride_config.dest_stride,\n src_data + src_index, stride_config.source_stride,\n stride_config.minor_loop_size);\n return true;\n };\n\n ShapeUtil::ForEachIndex(src_literal.shape(), stride_config.base,\n stride_config.dimensions, stride_config.step,\n copy_proc);\n }\n return absl::OkStatus();\n}\nabsl::Status MutableLiteralBase::CopySliceFromInternal(\n const LiteralBase& src_literal, absl::Span src_base,\n absl::Span dest_base, absl::Span copy_size) {\n auto linear_index = [](const Shape& shape,\n absl::Span multi_index) {\n return IndexUtil::MultidimensionalIndexToLinearIndex(shape, multi_index);\n };\n\n // `this->` is needed to workaround MSVC bug: #16882\n NativeT* dest_data = this->data().data();\n const NativeT* src_data = src_literal.data().data();\n if (src_literal.shape().rank() == 0 || shape().rank() == 0) {\n // If any of the two shapes are scalars, just assign the value once.\n TF_RET_CHECK(copy_size.empty());\n dest_data[linear_index(shape(), dest_base)] =\n src_data[linear_index(src_literal.shape(), src_base)];\n } else if (!ShapeUtil::IsZeroElementArray(shape()) &&\n !ShapeUtil::IsZeroElementArray(src_literal.shape()) &&\n absl::c_none_of(copy_size, [](auto d) { return d == 0; })) {\n // Perform copy if none of src, dest and copy_size has dimensions with zero\n // element, otherwise it's a no-op.\n TF_RET_CHECK(src_base.size() == dest_base.size());\n TF_RET_CHECK(src_base.size() == copy_size.size());\n\n // Scan the source from minor, stepping in copy size blocks, then within\n // the index enumeration functor, do a strided copy advancing source index\n // by one (walking through the minor dimension), and destination index by\n // proper stride size at the matching dimension.\n DimensionVector src_indexes(src_base.size(), 0);\n DimensionVector dest_indexes(dest_base.size(), 0);\n StrideConfig stride_config(src_literal.shape(), shape(), copy_size);\n\n auto copy_proc = [&](absl::Span indexes) {\n // Map from multi-dimensional index, to source index.\n std::transform(indexes.begin(), indexes.end(), src_base.begin(),\n src_indexes.begin(), std::plus());\n // Map from multi-dimensional index, to destination index.\n std::transform(indexes.begin(), indexes.end(), dest_base.begin(),\n dest_indexes.begin(), std::plus());\n\n int64_t src_index = linear_index(src_literal.shape(), src_indexes);\n int64_t dest_index = linear_index(shape(), dest_indexes);\n\n StridedCopy(dest_data + dest_index, stride_config.dest_stride,\n src_data + src_index, stride_config.source_stride,\n stride_config.minor_loop_size);\n return true;\n };\n\n ShapeUtil::ForEachIndex(src_literal.shape(), stride_config.base,\n stride_config.dimensions, stride_config.step,\n copy_proc);\n }\n return absl::OkStatus();\n}\nabsl::Status MutableLiteralBase::CopySliceFromInternal(\n const LiteralBase& src_literal, absl::Span src_base,\n absl::Span dest_base, absl::Span copy_size) {\n auto linear_index = [](const Shape& shape,\n absl::Span multi_index) {\n return IndexUtil::MultidimensionalIndexToLinearIndex(shape, multi_index);\n };\n\n // `this->` is needed to workaround MSVC bug: #16882\n NativeT* dest_data = this->data().data();\n const NativeT* src_data = src_literal.data().data();\n if (src_literal.shape().rank() == 0 || shape().rank() == 0) {\n // If any of the two shapes are scalars, just assign the value once.\n TF_RET_CHECK(copy_size.empty());\n dest_data[linear_index(shape(), dest_base)] =\n src_data[linear_index(src_literal.shape(), src_base)];\n } else if (!ShapeUtil::IsZeroElementArray(shape()) &&\n !ShapeUtil::IsZeroElementArray(src_literal.shape()) &&\n absl::c_none_of(copy_size, [](auto d) { return d == 0; })) {\n // Perform copy if none of src, dest and copy_size has dimensions with zero\n // element, otherwise it's a no-op.\n TF_RET_CHECK(src_base.size() == dest_base.size());\n TF_RET_CHECK(src_base.size() == copy_size.size());\n\n // Scan the source from minor, stepping in copy size blocks, then within\n // the index enumeration functor, do a strided copy advancing source index\n // by one (walking through the minor dimension), and destination index by\n // proper stride size at the matching dimension.\n DimensionVector src_indexes(src_base.size(), 0);\n DimensionVector dest_indexes(dest_base.size(), 0);\n StrideConfig stride_config(src_literal.shape(), shape(), copy_size);\n\n auto copy_proc = [&](absl::Span indexes) {\n // Map from multi-dimensional index, to source index.\n std::transform(indexes.begin(), indexes.end(), src_base.begin(),\n src_indexes.begin(), std::plus());\n // Map from multi-dimensional index, to destination index.\n std::transform(indexes.begin(), indexes.end(), dest_base.begin(),\n dest_indexes.begin(), std::plus());\n\n int64_t src_index = linear_index(src_literal.shape(), src_indexes);\n int64_t dest_index = linear_index(shape(), dest_indexes);\n\n StridedCopy(dest_data + dest_index, stride_config.dest_stride,\n src_data + src_index, stride_config.source_stride,\n stride_config.minor_loop_size);\n return true;\n };\n\n ShapeUtil::ForEachIndex(src_literal.shape(), stride_config.base,\n stride_config.dimensions, stride_config.step,\n copy_proc);\n }\n return absl::OkStatus();\n}\nabsl::Status MutableLiteralBase::CopySliceFromInternal(\n const LiteralBase& src_literal, absl::Span src_base,\n absl::Span dest_base, absl::Span copy_size) {\n auto linear_index = [](const Shape& shape,\n absl::Span multi_index) {\n return IndexUtil::MultidimensionalIndexToLinearIndex(shape, multi_index);\n };\n\n // `this->` is needed to workaround MSVC bug: #16882\n NativeT* dest_data = this->data().data();\n const NativeT* src_data = src_literal.data().data();\n if (src_literal.shape().rank() == 0 || shape().rank() == 0) {\n // If any of the two shapes are scalars, just assign the value once.\n TF_RET_CHECK(copy_size.empty());\n dest_data[linear_index(shape(), dest_base)] =\n src_data[linear_index(src_literal.shape(), src_base)];\n } else if (!ShapeUtil::IsZeroElementArray(shape()) &&\n !ShapeUtil::IsZeroElementArray(src_literal.shape()) &&\n absl::c_none_of(copy_size, [](auto d) { return d == 0; })) {\n // Perform copy if none of src, dest and copy_size has dimensions with zero\n // element, otherwise it's a no-op.\n TF_RET_CHECK(src_base.size() == dest_base.size());\n TF_RET_CHECK(src_base.size() == copy_size.size());\n\n // Scan the source from minor, stepping in copy size blocks, then within\n // the index enumeration functor, do a strided copy advancing source index\n // by one (walking through the minor dimension), and destination index by\n // proper stride size at the matching dimension.\n DimensionVector src_indexes(src_base.size(), 0);\n DimensionVector dest_indexes(dest_base.size(), 0);\n StrideConfig stride_config(src_literal.shape(), shape(), copy_size);\n\n auto copy_proc = [&](absl::Span indexes) {\n // Map from multi-dimensional index, to source index.\n std::transform(indexes.begin(), indexes.end(), src_base.begin(),\n src_indexes.begin(), std::plus());\n // Map from multi-dimensional index, to destination index.\n std::transform(indexes.begin(), indexes.end(), dest_base.begin(),\n dest_indexes.begin(), std::plus());\n\n int64_t src_index = linear_index(src_literal.shape(), src_indexes);\n int64_t dest_index = linear_index(shape(), dest_indexes);\n\n StridedCopy(dest_data + dest_index, stride_config.dest_stride,\n src_data + src_index, stride_config.source_stride,\n stride_config.minor_loop_size);\n return true;\n };\n\n ShapeUtil::ForEachIndex(src_literal.shape(), stride_config.base,\n stride_config.dimensions, stride_config.step,\n copy_proc);\n }\n return absl::OkStatus();\n}\nabsl::Status MutableLiteralBase::CopySliceFromInternal(\n const LiteralBase& src_literal, absl::Span src_base,\n absl::Span dest_base, absl::Span copy_size) {\n auto linear_index = [](const Shape& shape,\n absl::Span multi_index) {\n return IndexUtil::MultidimensionalIndexToLinearIndex(shape, multi_index);\n };\n\n // `this->` is needed to workaround MSVC bug: #16882\n NativeT* dest_data = this->data().data();\n const NativeT* src_data = src_literal.data().data();\n if (src_literal.shape().rank() == 0 || shape().rank() == 0) {\n // If any of the two shapes are scalars, just assign the value once.\n TF_RET_CHECK(copy_size.empty());\n dest_data[linear_index(shape(), dest_base)] =\n src_data[linear_index(src_literal.shape(), src_base)];\n } else if (!ShapeUtil::IsZeroElementArray(shape()) &&\n !ShapeUtil::IsZeroElementArray(src_literal.shape()) &&\n absl::c_none_of(copy_size, [](auto d) { return d == 0; })) {\n // Perform copy if none of src, dest and copy_size has dimensions with zero\n // element, otherwise it's a no-op.\n TF_RET_CHECK(src_base.size() == dest_base.size());\n TF_RET_CHECK(src_base.size() == copy_size.size());\n\n // Scan the source from minor, stepping in copy size blocks, then within\n // the index enumeration functor, do a strided copy advancing source index\n // by one (walking through the minor dimension), and destination index by\n // proper stride size at the matching dimension.\n DimensionVector src_indexes(src_base.size(), 0);\n DimensionVector dest_indexes(dest_base.size(), 0);\n StrideConfig stride_config(src_literal.shape(), shape(), copy_size);\n\n auto copy_proc = [&](absl::Span indexes) {\n // Map from multi-dimensional index, to source index.\n std::transform(indexes.begin(), indexes.end(), src_base.begin(),\n src_indexes.begin(), std::plus());\n // Map from multi-dimensional index, to destination index.\n std::transform(indexes.begin(), indexes.end(), dest_base.begin(),\n dest_indexes.begin(), std::plus());\n\n int64_t src_index = linear_index(src_literal.shape(), src_indexes);\n int64_t dest_index = linear_index(shape(), dest_indexes);\n\n StridedCopy(dest_data + dest_index, stride_config.dest_stride,\n src_data + src_index, stride_config.source_stride,\n stride_config.minor_loop_size);\n return true;\n };\n\n ShapeUtil::ForEachIndex(src_literal.shape(), stride_config.base,\n stride_config.dimensions, stride_config.step,\n copy_proc);\n }\n return absl::OkStatus();\n}\nabsl::Status MutableLiteralBase::CopySliceFromInternal(\n const LiteralBase& src_literal, absl::Span src_base,\n absl::Span dest_base, absl::Span copy_size) {\n auto linear_index = [](const Shape& shape,\n absl::Span multi_index) {\n return IndexUtil::MultidimensionalIndexToLinearIndex(shape, multi_index);\n };\n\n // `this->` is needed to workaround MSVC bug: #16882\n NativeT* dest_data = this->data().data();\n const NativeT* src_data = src_literal.data().data();\n if (src_literal.shape().rank() == 0 || shape().rank() == 0) {\n // If any of the two shapes are scalars, just assign the value once.\n TF_RET_CHECK(copy_size.empty());\n dest_data[linear_index(shape(), dest_base)] =\n src_data[linear_index(src_literal.shape(), src_base)];\n } else if (!ShapeUtil::IsZeroElementArray(shape()) &&\n !ShapeUtil::IsZeroElementArray(src_literal.shape()) &&\n absl::c_none_of(copy_size, [](auto d) { return d == 0; })) {\n // Perform copy if none of src, dest and copy_size has dimensions with zero\n // element, otherwise it's a no-op.\n TF_RET_CHECK(src_base.size() == dest_base.size());\n TF_RET_CHECK(src_base.size() == copy_size.size());\n\n // Scan the source from minor, stepping in copy size blocks, then within\n // the index enumeration functor, do a strided copy advancing source index\n // by one (walking through the minor dimension), and destination index by\n // proper stride size at the matching dimension.\n DimensionVector src_indexes(src_base.size(), 0);\n DimensionVector dest_indexes(dest_base.size(), 0);\n StrideConfig stride_config(src_literal.shape(), shape(), copy_size);\n\n auto copy_proc = [&](absl::Span indexes) {\n // Map from multi-dimensional index, to source index.\n std::transform(indexes.begin(), indexes.end(), src_base.begin(),\n src_indexes.begin(), std::plus());\n // Map from multi-dimensional index, to destination index.\n std::transform(indexes.begin(), indexes.end(), dest_base.begin(),\n dest_indexes.begin(), std::plus());\n\n int64_t src_index = linear_index(src_literal.shape(), src_indexes);\n int64_t dest_index = linear_index(shape(), dest_indexes);\n\n StridedCopy(dest_data + dest_index, stride_config.dest_stride,\n src_data + src_index, stride_config.source_stride,\n stride_config.minor_loop_size);\n return true;\n };\n\n ShapeUtil::ForEachIndex(src_literal.shape(), stride_config.base,\n stride_config.dimensions, stride_config.step,\n copy_proc);\n }\n return absl::OkStatus();\n}\nabsl::Status MutableLiteralBase::CopySliceFromInternal(\n const LiteralBase& src_literal, absl::Span src_base,\n absl::Span dest_base, absl::Span copy_size) {\n auto linear_index = [](const Shape& shape,\n absl::Span multi_index) {\n return IndexUtil::MultidimensionalIndexToLinearIndex(shape, multi_index);\n };\n\n // `this->` is needed to workaround MSVC bug: #16882\n NativeT* dest_data = this->data().data();\n const NativeT* src_data = src_literal.data().data();\n if (src_literal.shape().rank() == 0 || shape().rank() == 0) {\n // If any of the two shapes are scalars, just assign the value once.\n TF_RET_CHECK(copy_size.empty());\n dest_data[linear_index(shape(), dest_base)] =\n src_data[linear_index(src_literal.shape(), src_base)];\n } else if (!ShapeUtil::IsZeroElementArray(shape()) &&\n !ShapeUtil::IsZeroElementArray(src_literal.shape()) &&\n absl::c_none_of(copy_size, [](auto d) { return d == 0; })) {\n // Perform copy if none of src, dest and copy_size has dimensions with zero\n // element, otherwise it's a no-op.\n TF_RET_CHECK(src_base.size() == dest_base.size());\n TF_RET_CHECK(src_base.size() == copy_size.size());\n\n // Scan the source from minor, stepping in copy size blocks, then within\n // the index enumeration functor, do a strided copy advancing source index\n // by one (walking through the minor dimension), and destination index by\n // proper stride size at the matching dimension.\n DimensionVector src_indexes(src_base.size(), 0);\n DimensionVector dest_indexes(dest_base.size(), 0);\n StrideConfig stride_config(src_literal.shape(), shape(), copy_size);\n\n auto copy_proc = [&](absl::Span indexes) {\n // Map from multi-dimensional index, to source index.\n std::transform(indexes.begin(), indexes.end(), src_base.begin(),\n src_indexes.begin(), std::plus());\n // Map from multi-dimensional index, to destination index.\n std::transform(indexes.begin(), indexes.end(), dest_base.begin(),\n dest_indexes.begin(), std::plus());\n\n int64_t src_index = linear_index(src_literal.shape(), src_indexes);\n int64_t dest_index = linear_index(shape(), dest_indexes);\n\n StridedCopy(dest_data + dest_index, stride_config.dest_stride,\n src_data + src_index, stride_config.source_stride,\n stride_config.minor_loop_size);\n return true;\n };\n\n ShapeUtil::ForEachIndex(src_literal.shape(), stride_config.base,\n stride_config.dimensions, stride_config.step,\n copy_proc);\n }\n return absl::OkStatus();\n}\nabsl::Status MutableLiteralBase::CopySliceFromInternal(\n const LiteralBase& src_literal, absl::Span src_base,\n absl::Span dest_base, absl::Span copy_size) {\n auto linear_index = [](const Shape& shape,\n absl::Span multi_index) {\n return IndexUtil::MultidimensionalIndexToLinearIndex(shape, multi_index);\n };\n\n // `this->` is needed to workaround MSVC bug: #16882\n NativeT* dest_data = this->data().data();\n const NativeT* src_data = src_literal.data().data();\n if (src_literal.shape().rank() == 0 || shape().rank() == 0) {\n // If any of the two shapes are scalars, just assign the value once.\n TF_RET_CHECK(copy_size.empty());\n dest_data[linear_index(shape(), dest_base)] =\n src_data[linear_index(src_literal.shape(), src_base)];\n } else if (!ShapeUtil::IsZeroElementArray(shape()) &&\n !ShapeUtil::IsZeroElementArray(src_literal.shape()) &&\n absl::c_none_of(copy_size, [](auto d) { return d == 0; })) {\n // Perform copy if none of src, dest and copy_size has dimensions with zero\n // element, otherwise it's a no-op.\n TF_RET_CHECK(src_base.size() == dest_base.size());\n TF_RET_CHECK(src_base.size() == copy_size.size());\n\n // Scan the source from minor, stepping in copy size blocks, then within\n // the index enumeration functor, do a strided copy advancing source index\n // by one (walking through the minor dimension), and destination index by\n // proper stride size at the matching dimension.\n DimensionVector src_indexes(src_base.size(), 0);\n DimensionVector dest_indexes(dest_base.size(), 0);\n StrideConfig stride_config(src_literal.shape(), shape(), copy_size);\n\n auto copy_proc = [&](absl::Span indexes) {\n // Map from multi-dimensional index, to source index.\n std::transform(indexes.begin(), indexes.end(), src_base.begin(),\n src_indexes.begin(), std::plus());\n // Map from multi-dimensional index, to destination index.\n std::transform(indexes.begin(), indexes.end(), dest_base.begin(),\n dest_indexes.begin(), std::plus());\n\n int64_t src_index = linear_index(src_literal.shape(), src_indexes);\n int64_t dest_index = linear_index(shape(), dest_indexes);\n\n StridedCopy(dest_data + dest_index, stride_config.dest_stride,\n src_data + src_index, stride_config.source_stride,\n stride_config.minor_loop_size);\n return true;\n };\n\n ShapeUtil::ForEachIndex(src_literal.shape(), stride_config.base,\n stride_config.dimensions, stride_config.step,\n copy_proc);\n }\n return absl::OkStatus();\n}\nabsl::Status MutableLiteralBase::CopySliceFromInternal(\n const LiteralBase& src_literal, absl::Span src_base,\n absl::Span dest_base, absl::Span copy_size) {\n auto linear_index = [](const Shape& shape,\n absl::Span multi_index) {\n return IndexUtil::MultidimensionalIndexToLinearIndex(shape, multi_index);\n };\n\n // `this->` is needed to workaround MSVC bug: #16882\n NativeT* dest_data = this->data().data();\n const NativeT* src_data = src_literal.data().data();\n if (src_literal.shape().rank() == 0 || shape().rank() == 0) {\n // If any of the two shapes are scalars, just assign the value once.\n TF_RET_CHECK(copy_size.empty());\n dest_data[linear_index(shape(), dest_base)] =\n src_data[linear_index(src_literal.shape(), src_base)];\n } else if (!ShapeUtil::IsZeroElementArray(shape()) &&\n !ShapeUtil::IsZeroElementArray(src_literal.shape()) &&\n absl::c_none_of(copy_size, [](auto d) { return d == 0; })) {\n // Perform copy if none of src, dest and copy_size has dimensions with zero\n // element, otherwise it's a no-op.\n TF_RET_CHECK(src_base.size() == dest_base.size());\n TF_RET_CHECK(src_base.size() == copy_size.size());\n\n // Scan the source from minor, stepping in copy size blocks, then within\n // the index enumeration functor, do a strided copy advancing source index\n // by one (walking through the minor dimension), and destination index by\n // proper stride size at the matching dimension.\n DimensionVector src_indexes(src_base.size(), 0);\n DimensionVector dest_indexes(dest_base.size(), 0);\n StrideConfig stride_config(src_literal.shape(), shape(), copy_size);\n\n auto copy_proc = [&](absl::Span indexes) {\n // Map from multi-dimensional index, to source index.\n std::transform(indexes.begin(), indexes.end(), src_base.begin(),\n src_indexes.begin(), std::plus());\n // Map from multi-dimensional index, to destination index.\n std::transform(indexes.begin(), indexes.end(), dest_base.begin(),\n dest_indexes.begin(), std::plus());\n\n int64_t src_index = linear_index(src_literal.shape(), src_indexes);\n int64_t dest_index = linear_index(shape(), dest_indexes);\n\n StridedCopy(dest_data + dest_index, stride_config.dest_stride,\n src_data + src_index, stride_config.source_stride,\n stride_config.minor_loop_size);\n return true;\n };\n\n ShapeUtil::ForEachIndex(src_literal.shape(), stride_config.base,\n stride_config.dimensions, stride_config.step,\n copy_proc);\n }\n return absl::OkStatus();\n}\nabsl::Status MutableLiteralBase::CopySliceFromInternal(\n const LiteralBase& src_literal, absl::Span src_base,\n absl::Span dest_base, absl::Span copy_size) {\n auto linear_index = [](const Shape& shape,\n absl::Span multi_index) {\n return IndexUtil::MultidimensionalIndexToLinearIndex(shape, multi_index);\n };\n\n // `this->` is needed to workaround MSVC bug: #16882\n NativeT* dest_data = this->data().data();\n const NativeT* src_data = src_literal.data().data();\n if (src_literal.shape().rank() == 0 || shape().rank() == 0) {\n // If any of the two shapes are scalars, just assign the value once.\n TF_RET_CHECK(copy_size.empty());\n dest_data[linear_index(shape(), dest_base)] =\n src_data[linear_index(src_literal.shape(), src_base)];\n } else if (!ShapeUtil::IsZeroElementArray(shape()) &&\n !ShapeUtil::IsZeroElementArray(src_literal.shape()) &&\n absl::c_none_of(copy_size, [](auto d) { return d == 0; })) {\n // Perform copy if none of src, dest and copy_size has dimensions with zero\n // element, otherwise it's a no-op.\n TF_RET_CHECK(src_base.size() == dest_base.size());\n TF_RET_CHECK(src_base.size() == copy_size.size());\n\n // Scan the source from minor, stepping in copy size blocks, then within\n // the index enumeration functor, do a strided copy advancing source index\n // by one (walking through the minor dimension), and destination index by\n // proper stride size at the matching dimension.\n DimensionVector src_indexes(src_base.size(), 0);\n DimensionVector dest_indexes(dest_base.size(), 0);\n StrideConfig stride_config(src_literal.shape(), shape(), copy_size);\n\n auto copy_proc = [&](absl::Span indexes) {\n // Map from multi-dimensional index, to source index.\n std::transform(indexes.begin(), indexes.end(), src_base.begin(),\n src_indexes.begin(), std::plus());\n // Map from multi-dimensional index, to destination index.\n std::transform(indexes.begin(), indexes.end(), dest_base.begin(),\n dest_indexes.begin(), std::plus());\n\n int64_t src_index = linear_index(src_literal.shape(), src_indexes);\n int64_t dest_index = linear_index(shape(), dest_indexes);\n\n StridedCopy(dest_data + dest_index, stride_config.dest_stride,\n src_data + src_index, stride_config.source_stride,\n stride_config.minor_loop_size);\n return true;\n };\n\n ShapeUtil::ForEachIndex(src_literal.shape(), stride_config.base,\n stride_config.dimensions, stride_config.step,\n copy_proc);\n }\n return absl::OkStatus();\n}\nabsl::Status MutableLiteralBase::CopySliceFromInternal(\n const LiteralBase& src_literal, absl::Span src_base,\n absl::Span dest_base, absl::Span copy_size) {\n auto linear_index = [](const Shape& shape,\n absl::Span multi_index) {\n return IndexUtil::MultidimensionalIndexToLinearIndex(shape, multi_index);\n };\n\n // `this->` is needed to workaround MSVC bug: #16882\n NativeT* dest_data = this->data().data();\n const NativeT* src_data = src_literal.data().data();\n if (src_literal.shape().rank() == 0 || shape().rank() == 0) {\n // If any of the two shapes are scalars, just assign the value once.\n TF_RET_CHECK(copy_size.empty());\n dest_data[linear_index(shape(), dest_base)] =\n src_data[linear_index(src_literal.shape(), src_base)];\n } else if (!ShapeUtil::IsZeroElementArray(shape()) &&\n !ShapeUtil::IsZeroElementArray(src_literal.shape()) &&\n absl::c_none_of(copy_size, [](auto d) { return d == 0; })) {\n // Perform copy if none of src, dest and copy_size has dimensions with zero\n // element, otherwise it's a no-op.\n TF_RET_CHECK(src_base.size() == dest_base.size());\n TF_RET_CHECK(src_base.size() == copy_size.size());\n\n // Scan the source from minor, stepping in copy size blocks, then within\n // the index enumeration functor, do a strided copy advancing source index\n // by one (walking through the minor dimension), and destination index by\n // proper stride size at the matching dimension.\n DimensionVector src_indexes(src_base.size(), 0);\n DimensionVector dest_indexes(dest_base.size(), 0);\n StrideConfig stride_config(src_literal.shape(), shape(), copy_size);\n\n auto copy_proc = [&](absl::Span indexes) {\n // Map from multi-dimensional index, to source index.\n std::transform(indexes.begin(), indexes.end(), src_base.begin(),\n src_indexes.begin(), std::plus());\n // Map from multi-dimensional index, to destination index.\n std::transform(indexes.begin(), indexes.end(), dest_base.begin(),\n dest_indexes.begin(), std::plus());\n\n int64_t src_index = linear_index(src_literal.shape(), src_indexes);\n int64_t dest_index = linear_index(shape(), dest_indexes);\n\n StridedCopy(dest_data + dest_index, stride_config.dest_stride,\n src_data + src_index, stride_config.source_stride,\n stride_config.minor_loop_size);\n return true;\n };\n\n ShapeUtil::ForEachIndex(src_literal.shape(), stride_config.base,\n stride_config.dimensions, stride_config.step,\n copy_proc);\n }\n return absl::OkStatus();\n}\nabsl::Status MutableLiteralBase::CopySliceFromInternal(\n const LiteralBase& src_literal, absl::Span src_base,\n absl::Span dest_base, absl::Span copy_size) {\n auto linear_index = [](const Shape& shape,\n absl::Span multi_index) {\n return IndexUtil::MultidimensionalIndexToLinearIndex(shape, multi_index);\n };\n\n // `this->` is needed to workaround MSVC bug: #16882\n NativeT* dest_data = this->data().data();\n const NativeT* src_data = src_literal.data().data();\n if (src_literal.shape().rank() == 0 || shape().rank() == 0) {\n // If any of the two shapes are scalars, just assign the value once.\n TF_RET_CHECK(copy_size.empty());\n dest_data[linear_index(shape(), dest_base)] =\n src_data[linear_index(src_literal.shape(), src_base)];\n } else if (!ShapeUtil::IsZeroElementArray(shape()) &&\n !ShapeUtil::IsZeroElementArray(src_literal.shape()) &&\n absl::c_none_of(copy_size, [](auto d) { return d == 0; })) {\n // Perform copy if none of src, dest and copy_size has dimensions with zero\n // element, otherwise it's a no-op.\n TF_RET_CHECK(src_base.size() == dest_base.size());\n TF_RET_CHECK(src_base.size() == copy_size.size());\n\n // Scan the source from minor, stepping in copy size blocks, then within\n // the index enumeration functor, do a strided copy advancing source index\n // by one (walking through the minor dimension), and destination index by\n // proper stride size at the matching dimension.\n DimensionVector src_indexes(src_base.size(), 0);\n DimensionVector dest_indexes(dest_base.size(), 0);\n StrideConfig stride_config(src_literal.shape(), shape(), copy_size);\n\n auto copy_proc = [&](absl::Span indexes) {\n // Map from multi-dimensional index, to source index.\n std::transform(indexes.begin(), indexes.end(), src_base.begin(),\n src_indexes.begin(), std::plus());\n // Map from multi-dimensional index, to destination index.\n std::transform(indexes.begin(), indexes.end(), dest_base.begin(),\n dest_indexes.begin(), std::plus());\n\n int64_t src_index = linear_index(src_literal.shape(), src_indexes);\n int64_t dest_index = linear_index(shape(), dest_indexes);\n\n StridedCopy(dest_data + dest_index, stride_config.dest_stride,\n src_data + src_index, stride_config.source_stride,\n stride_config.minor_loop_size);\n return true;\n };\n\n ShapeUtil::ForEachIndex(src_literal.shape(), stride_config.base,\n stride_config.dimensions, stride_config.step,\n copy_proc);\n }\n return absl::OkStatus();\n}\nabsl::Status MutableLiteralBase::CopySliceFromInternal(\n const LiteralBase& src_literal, absl::Span src_base,\n absl::Span dest_base, absl::Span copy_size) {\n auto linear_index = [](const Shape& shape,\n absl::Span multi_index) {\n return IndexUtil::MultidimensionalIndexToLinearIndex(shape, multi_index);\n };\n\n // `this->` is needed to workaround MSVC bug: #16882\n NativeT* dest_data = this->data().data();\n const NativeT* src_data = src_literal.data().data();\n if (src_literal.shape().rank() == 0 || shape().rank() == 0) {\n // If any of the two shapes are scalars, just assign the value once.\n TF_RET_CHECK(copy_size.empty());\n dest_data[linear_index(shape(), dest_base)] =\n src_data[linear_index(src_literal.shape(), src_base)];\n } else if (!ShapeUtil::IsZeroElementArray(shape()) &&\n !ShapeUtil::IsZeroElementArray(src_literal.shape()) &&\n absl::c_none_of(copy_size, [](auto d) { return d == 0; })) {\n // Perform copy if none of src, dest and copy_size has dimensions with zero\n // element, otherwise it's a no-op.\n TF_RET_CHECK(src_base.size() == dest_base.size());\n TF_RET_CHECK(src_base.size() == copy_size.size());\n\n // Scan the source from minor, stepping in copy size blocks, then within\n // the index enumeration functor, do a strided copy advancing source index\n // by one (walking through the minor dimension), and destination index by\n // proper stride size at the matching dimension.\n DimensionVector src_indexes(src_base.size(), 0);\n DimensionVector dest_indexes(dest_base.size(), 0);\n StrideConfig stride_config(src_literal.shape(), shape(), copy_size);\n\n auto copy_proc = [&](absl::Span indexes) {\n // Map from multi-dimensional index, to source index.\n std::transform(indexes.begin(), indexes.end(), src_base.begin(),\n src_indexes.begin(), std::plus());\n // Map from multi-dimensional index, to destination index.\n std::transform(indexes.begin(), indexes.end(), dest_base.begin(),\n dest_indexes.begin(), std::plus());\n\n int64_t src_index = linear_index(src_literal.shape(), src_indexes);\n int64_t dest_index = linear_index(shape(), dest_indexes);\n\n StridedCopy(dest_data + dest_index, stride_config.dest_stride,\n src_data + src_index, stride_config.source_stride,\n stride_config.minor_loop_size);\n return true;\n };\n\n ShapeUtil::ForEachIndex(src_literal.shape(), stride_config.base,\n stride_config.dimensions, stride_config.step,\n copy_proc);\n }\n return absl::OkStatus();\n}\nabsl::Status MutableLiteralBase::CopySliceFromInternal(\n const LiteralBase& src_literal, absl::Span src_base,\n absl::Span dest_base, absl::Span copy_size) {\n auto linear_index = [](const Shape& shape,\n absl::Span multi_index) {\n return IndexUtil::MultidimensionalIndexToLinearIndex(shape, multi_index);\n };\n\n // `this->` is needed to workaround MSVC bug: #16882\n NativeT* dest_data = this->data().data();\n const NativeT* src_data = src_literal.data().data();\n if (src_literal.shape().rank() == 0 || shape().rank() == 0) {\n // If any of the two shapes are scalars, just assign the value once.\n TF_RET_CHECK(copy_size.empty());\n dest_data[linear_index(shape(), dest_base)] =\n src_data[linear_index(src_literal.shape(), src_base)];\n } else if (!ShapeUtil::IsZeroElementArray(shape()) &&\n !ShapeUtil::IsZeroElementArray(src_literal.shape()) &&\n absl::c_none_of(copy_size, [](auto d) { return d == 0; })) {\n // Perform copy if none of src, dest and copy_size has dimensions with zero\n // element, otherwise it's a no-op.\n TF_RET_CHECK(src_base.size() == dest_base.size());\n TF_RET_CHECK(src_base.size() == copy_size.size());\n\n // Scan the source from minor, stepping in copy size blocks, then within\n // the index enumeration functor, do a strided copy advancing source index\n // by one (walking through the minor dimension), and destination index by\n // proper stride size at the matching dimension.\n DimensionVector src_indexes(src_base.size(), 0);\n DimensionVector dest_indexes(dest_base.size(), 0);\n StrideConfig stride_config(src_literal.shape(), shape(), copy_size);\n\n auto copy_proc = [&](absl::Span indexes) {\n // Map from multi-dimensional index, to source index.\n std::transform(indexes.begin(), indexes.end(), src_base.begin(),\n src_indexes.begin(), std::plus());\n // Map from multi-dimensional index, to destination index.\n std::transform(indexes.begin(), indexes.end(), dest_base.begin(),\n dest_indexes.begin(), std::plus());\n\n int64_t src_index = linear_index(src_literal.shape(), src_indexes);\n int64_t dest_index = linear_index(shape(), dest_indexes);\n\n StridedCopy(dest_data + dest_index, stride_config.dest_stride,\n src_data + src_index, stride_config.source_stride,\n stride_config.minor_loop_size);\n return true;\n };\n\n ShapeUtil::ForEachIndex(src_literal.shape(), stride_config.base,\n stride_config.dimensions, stride_config.step,\n copy_proc);\n }\n return absl::OkStatus();\n}\nabsl::Status MutableLiteralBase::CopySliceFromInternal(\n const LiteralBase& src_literal, absl::Span src_base,\n absl::Span dest_base, absl::Span copy_size) {\n auto linear_index = [](const Shape& shape,\n absl::Span multi_index) {\n return IndexUtil::MultidimensionalIndexToLinearIndex(shape, multi_index);\n };\n\n // `this->` is needed to workaround MSVC bug: #16882\n NativeT* dest_data = this->data().data();\n const NativeT* src_data = src_literal.data().data();\n if (src_literal.shape().rank() == 0 || shape().rank() == 0) {\n // If any of the two shapes are scalars, just assign the value once.\n TF_RET_CHECK(copy_size.empty());\n dest_data[linear_index(shape(), dest_base)] =\n src_data[linear_index(src_literal.shape(), src_base)];\n } else if (!ShapeUtil::IsZeroElementArray(shape()) &&\n !ShapeUtil::IsZeroElementArray(src_literal.shape()) &&\n absl::c_none_of(copy_size, [](auto d) { return d == 0; })) {\n // Perform copy if none of src, dest and copy_size has dimensions with zero\n // element, otherwise it's a no-op.\n TF_RET_CHECK(src_base.size() == dest_base.size());\n TF_RET_CHECK(src_base.size() == copy_size.size());\n\n // Scan the source from minor, stepping in copy size blocks, then within\n // the index enumeration functor, do a strided copy advancing source index\n // by one (walking through the minor dimension), and destination index by\n // proper stride size at the matching dimension.\n DimensionVector src_indexes(src_base.size(), 0);\n DimensionVector dest_indexes(dest_base.size(), 0);\n StrideConfig stride_config(src_literal.shape(), shape(), copy_size);\n\n auto copy_proc = [&](absl::Span indexes) {\n // Map from multi-dimensional index, to source index.\n std::transform(indexes.begin(), indexes.end(), src_base.begin(),\n src_indexes.begin(), std::plus());\n // Map from multi-dimensional index, to destination index.\n std::transform(indexes.begin(), indexes.end(), dest_base.begin(),\n dest_indexes.begin(), std::plus());\n\n int64_t src_index = linear_index(src_literal.shape(), src_indexes);\n int64_t dest_index = linear_index(shape(), dest_indexes);\n\n StridedCopy(dest_data + dest_index, stride_config.dest_stride,\n src_data + src_index, stride_config.source_stride,\n stride_config.minor_loop_size);\n return true;\n };\n\n ShapeUtil::ForEachIndex(src_literal.shape(), stride_config.base,\n stride_config.dimensions, stride_config.step,\n copy_proc);\n }\n return absl::OkStatus();\n}\nabsl::Status MutableLiteralBase::CopySliceFromInternal(\n const LiteralBase& src_literal, absl::Span src_base,\n absl::Span dest_base, absl::Span copy_size) {\n auto linear_index = [](const Shape& shape,\n absl::Span multi_index) {\n return IndexUtil::MultidimensionalIndexToLinearIndex(shape, multi_index);\n };\n\n // `this->` is needed to workaround MSVC bug: #16882\n NativeT* dest_data = this->data().data();\n const NativeT* src_data = src_literal.data().data();\n if (src_literal.shape().rank() == 0 || shape().rank() == 0) {\n // If any of the two shapes are scalars, just assign the value once.\n TF_RET_CHECK(copy_size.empty());\n dest_data[linear_index(shape(), dest_base)] =\n src_data[linear_index(src_literal.shape(), src_base)];\n } else if (!ShapeUtil::IsZeroElementArray(shape()) &&\n !ShapeUtil::IsZeroElementArray(src_literal.shape()) &&\n absl::c_none_of(copy_size, [](auto d) { return d == 0; })) {\n // Perform copy if none of src, dest and copy_size has dimensions with zero\n // element, otherwise it's a no-op.\n TF_RET_CHECK(src_base.size() == dest_base.size());\n TF_RET_CHECK(src_base.size() == copy_size.size());\n\n // Scan the source from minor, stepping in copy size blocks, then within\n // the index enumeration functor, do a strided copy advancing source index\n // by one (walking through the minor dimension), and destination index by\n // proper stride size at the matching dimension.\n DimensionVector src_indexes(src_base.size(), 0);\n DimensionVector dest_indexes(dest_base.size(), 0);\n StrideConfig stride_config(src_literal.shape(), shape(), copy_size);\n\n auto copy_proc = [&](absl::Span indexes) {\n // Map from multi-dimensional index, to source index.\n std::transform(indexes.begin(), indexes.end(), src_base.begin(),\n src_indexes.begin(), std::plus());\n // Map from multi-dimensional index, to destination index.\n std::transform(indexes.begin(), indexes.end(), dest_base.begin(),\n dest_indexes.begin(), std::plus());\n\n int64_t src_index = linear_index(src_literal.shape(), src_indexes);\n int64_t dest_index = linear_index(shape(), dest_indexes);\n\n StridedCopy(dest_data + dest_index, stride_config.dest_stride,\n src_data + src_index, stride_config.source_stride,\n stride_config.minor_loop_size);\n return true;\n };\n\n ShapeUtil::ForEachIndex(src_literal.shape(), stride_config.base,\n stride_config.dimensions, stride_config.step,\n copy_proc);\n }\n return absl::OkStatus();\n}\nabsl::Status MutableLiteralBase::CopySliceFromInternal(\n const LiteralBase& src_literal, absl::Span src_base,\n absl::Span dest_base, absl::Span copy_size) {\n auto linear_index = [](const Shape& shape,\n absl::Span