saymrwulf/onnxruntime
1
0
Fork 0
mirror of https://github.com/saymrwulf/onnxruntime.git synced 2026-07-30 20:18:08 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Cjian/c4244 round 6 (#13663)

Browse source 
### Description
Fix round 6 



### Motivation and Context
<!-- - Why is this change required? What problem does it solve?
- If it fixes an open issue, please link to the issue here. -->
This commit is contained in:
Jian Chen 2022-11-16 16:26:11 -05:00 committed by GitHub
parent 2efd2878ab
commit 8442d9df2c
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
29 changed files with 240 additions and 189 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
cmake/onnxruntime_providers.cmake
View file

@ -242,9 +242,9 @@ endif()
if (MSVC)
target_compile_options(onnxruntime_providers PRIVATE "/bigobj")
if(NOT CMAKE_SIZEOF_VOID_P EQUAL 8)
target_compile_options(onnxruntime_providers PRIVATE "/wd4244")
endif()
# if(NOT CMAKE_SIZEOF_VOID_P EQUAL 8)
# target_compile_options(onnxruntime_providers PRIVATE "/wd4244")
# endif()
endif()
onnxruntime_add_include_to_target(onnxruntime_providers onnxruntime_common onnxruntime_framework onnx onnx_proto ${PROTOBUF_LIB} flatbuffers)

4
onnxruntime/contrib_ops/cpu/activations.h
View file

@ -4,9 +4,11 @@
#pragma once
#include "core/common/common.h"
#include "core/common/narrow.h"
#include "core/framework/op_kernel.h"
#include "core/util/math_cpuonly.h"
#include "core/mlas/inc/mlas.h"
#include "core/platform/threadpool.h"
#include <unsupported/Eigen/SpecialFunctions>
#include "core/providers/cpu/element_wise_ranged_transform.h"
@ -120,7 +122,7 @@ class QuickGelu : public OpKernel {
p_output[i] = p_input[i] * alpha_;
}
MlasComputeLogistic(p_output, p_output, count);
MlasComputeLogistic(p_output, p_output, onnxruntime::narrow<size_t>(count));
for (int64_t i = 0; i < count; i++) {
p_output[i] = p_input[i] * p_output[i];

4
onnxruntime/contrib_ops/cpu/quantization/qlinear_softmax.cc
View file

@ -93,7 +93,7 @@ QLinearSoftmax::QLinearSoftmax(const OpKernelInfo& info)
int64_t reduce_size = opset_ < OPSET13 ? input_shape.SizeFromDimension(axis_) : input_shape[axis_];
// reduce_size could be negative if input-shape has a dynamic axis
if (reduce_size > 0) {
BuildLookupTableIfFixed(info, fixed_lookup_table_, reduce_size, is_signed_);
BuildLookupTableIfFixed(info, fixed_lookup_table_, onnxruntime::narrow<size_t>(reduce_size), is_signed_);
}
}
}
@ -112,7 +112,7 @@ Status QLinearSoftmax::Compute(OpKernelContext* ctx) const {
auto* Y = ctx->Output(0, X_shape);
concurrency::ThreadPool* thread_pool = ctx->GetOperatorThreadPool();
const size_t D = opset_ < OPSET13 ? X_shape.SizeFromDimension(axis) : X_shape[axis];
const size_t D = onnxruntime::narrow<size_t>(opset_ < OPSET13 ? X_shape.SizeFromDimension(onnxruntime::narrow<size_t>(axis)) : X_shape[onnxruntime::narrow<size_t>(axis)]);
EXP_OUT_DTYPE tmp_lookup_table[256];
gsl::span<const EXP_OUT_DTYPE> lookup_table = GetLookupTable(ctx, tmp_lookup_table, D);

2
onnxruntime/contrib_ops/cpu/unique.cc
View file

@ -47,7 +47,7 @@ Status Unique<float>::Compute(OpKernelContext* ctx) const {
// used originally for float uniqueness, is this correct?
using IndexingMap = InlinedHashMap<float, ElementData>;
IndexingMap mapped_indices;
mapped_indices.reserve(num_elements);
mapped_indices.reserve(onnxruntime::narrow<size_t>(num_elements));
// processing
for (int64_t i = 0; i < num_elements; ++i) {

12
onnxruntime/core/providers/cpu/math/einsum_utils/einsum_typed_compute_processor.cc
View file

@ -2,7 +2,7 @@
// Licensed under the MIT License.
#include "einsum_typed_compute_processor.h"
#include "core/common/narrow.h"
#include "core/common/span_utils.h"
namespace onnxruntime {
@ -199,7 +199,10 @@ std::unique_ptr<Tensor> EinsumTypedComputeProcessor<T>::PairwiseOperandProcess(c
left_permutation.reserve(lro.size() + lo.size() + reduce_dims.size() + ro.size());
left_permutation.insert(left_permutation.end(), lro.begin(), lro.end());
left_permutation.insert(left_permutation.end(), lo.begin(), lo.end());
left_permutation.insert(left_permutation.end(), reduce_dims.begin(), reduce_dims.end());
// left_permutation.insert(left_permutation.end(), reduce_dims.begin(), reduce_dims.end());
for(auto & a : reduce_dims){
left_permutation.push_back(onnxruntime::narrow<size_t>(a));
}
left_permutation.insert(left_permutation.end(), ro.begin(), ro.end());
if (EinsumOp::IsTransposeRequired(current_left ? current_left->Shape().NumDimensions() : left_dims.size(),
left_permutation)) {
@ -224,7 +227,10 @@ std::unique_ptr<Tensor> EinsumTypedComputeProcessor<T>::PairwiseOperandProcess(c
InlinedVector<size_t> right_permutation;
right_permutation.reserve(lro.size() + lo.size() + reduce_dims.size() + ro.size());
right_permutation.insert(right_permutation.end(), lro.begin(), lro.end());
right_permutation.insert(right_permutation.end(), reduce_dims.begin(), reduce_dims.end());
// right_permutation.insert(right_permutation.end(), reduce_dims.begin(), reduce_dims.end());
for(auto & a : reduce_dims){
right_permutation.push_back(onnxruntime::narrow<size_t>(a));
}
right_permutation.insert(right_permutation.end(), ro.begin(), ro.end());
right_permutation.insert(right_permutation.end(), lo.begin(), lo.end());
if (EinsumOp::IsTransposeRequired(current_right ? current_right->Shape().GetDims().size() : right_dims.size(),

2
onnxruntime/core/providers/cpu/reduction/reduction_ops.cc
View file

@ -626,7 +626,7 @@ FastReduceKind OptimizeShapeForFastReduce(gsl::span<const int64_t> input_shape,
if (reduce[onnxruntime::narrow<size_t>(i)]) {
fast_axes.push_back(onnxruntime::narrow<int64_t>(fast_shape.size()));
}
fast_shape.push_back(input_shape[i]);
fast_shape.push_back(input_shape[onnxruntime::narrow<size_t>(i)]);
}
}
if (fast_shape.size() == 1) {

4
onnxruntime/core/providers/cpu/signal/dft.cc
View file

@ -251,7 +251,7 @@ static Status discrete_fourier_transform(OpKernelContext* ctx, const Tensor* X,
if (r == static_cast<size_t>(axis)) {
continue;
}
cumulative_packed_stride /= X_shape[onnxruntime::narrow<size_t>(r)];
cumulative_packed_stride /= onnxruntime::narrow<size_t>(X_shape[r]);
auto index = temp / cumulative_packed_stride;
temp -= (index * cumulative_packed_stride);
X_offset += index * SafeInt<size_t>(X_shape.SizeFromDimension(r + 1)) / complex_input_factor;
@ -265,7 +265,7 @@ static Status discrete_fourier_transform(OpKernelContext* ctx, const Tensor* X,
if (r == static_cast<size_t>(axis)) {
continue;
}
cumulative_packed_stride /= X_shape[onnxruntime::narrow<size_t>(r)];
cumulative_packed_stride /= onnxruntime::narrow<size_t>(X_shape[r]);
auto index = temp / cumulative_packed_stride;
temp -= (index * cumulative_packed_stride);
Y_offset += index * SafeInt<size_t>(Y_shape.SizeFromDimension(r + 1)) / 2;

34
onnxruntime/core/providers/cpu/tensor/gather_nd.cc
View file

@ -1,6 +1,6 @@
// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License.
#include <core/common/safeint.h>
#include "gather_nd.h"
#include "core/platform/threadpool.h"
@ -64,13 +64,13 @@ Status GatherNDBase::PrepareForCompute(const TensorShape& input_shape, const Ten
const auto num_slice_dims = indices_shape[indices_shape.NumDimensions() - 1];
const auto num_slices = indices_shape.SizeToDimension(indices_shape.NumDimensions() - 1);
const auto slice_size = input_shape.SizeFromDimension(batch_dims_ + num_slice_dims);
const auto num_batches = input_shape.SizeToDimension(batch_dims_);
const auto input_batch_stride = input_shape.SizeFromDimension(batch_dims_);
const auto slice_size = input_shape.SizeFromDimension(SafeInt<size_t>(batch_dims_) + num_slice_dims);
const auto num_batches = input_shape.SizeToDimension(SafeInt<size_t>(batch_dims_));
const auto input_batch_stride = input_shape.SizeFromDimension(SafeInt<size_t>(batch_dims_));
const auto num_slices_per_batch = num_slices / num_batches;
std::vector<int64_t> sizes_from_slice_dims(num_slice_dims);
std::vector<int64_t> sizes_from_slice_dims(onnxruntime::narrow<size_t>(num_slice_dims));
for (int64_t i = 0; i < num_slice_dims; ++i) {
sizes_from_slice_dims[i] = input_shape.SizeFromDimension(batch_dims_ + i + 1);
sizes_from_slice_dims[onnxruntime::narrow<size_t>(i)] = input_shape.SizeFromDimension(SafeInt<size_t>(batch_dims_) + i + 1);
}
int64_t err_index = 0;
@ -78,18 +78,18 @@ Status GatherNDBase::PrepareForCompute(const TensorShape& input_shape, const Ten
p.element_count_per_slice = slice_size;
p.bytes_per_slice = p.element_bytes * p.element_count_per_slice;
const auto* indices_data = indices_tensor->Data<Tind>();
p.slice_offsets.assign(num_slices, 0LL);
p.slice_offsets.assign(onnxruntime::narrow<size_t>(num_slices), 0LL);
// Compute the element_offset
auto lambda = [&](int64_t slice_idx) {
const size_t batch_idx = slice_idx / num_slices_per_batch;
const size_t input_base_offset = batch_idx * input_batch_stride;
const size_t batch_idx = onnxruntime::narrow<size_t>(slice_idx / num_slices_per_batch);
const size_t input_base_offset = batch_idx * SafeInt<size_t>(input_batch_stride);
const auto* const slice_indices = indices_data + slice_idx * num_slice_dims;
size_t relative_slice_offset = 0;
for (int64_t dim_idx = 0; dim_idx < num_slice_dims; ++dim_idx) {
int64_t index = static_cast<int64_t>(slice_indices[dim_idx]);
const auto upper_limit = input_shape[batch_dims_ + dim_idx];
const auto upper_limit = input_shape[SafeInt<size_t>(batch_dims_) + dim_idx];
const auto lower_limit = -upper_limit;
if (index < lower_limit || index >= upper_limit) {
err_index = index;
@ -97,14 +97,14 @@ Status GatherNDBase::PrepareForCompute(const TensorShape& input_shape, const Ten
}
if (index < 0) index += upper_limit;
relative_slice_offset += index * sizes_from_slice_dims[dim_idx];
relative_slice_offset += SafeInt<size_t>(index) * sizes_from_slice_dims[onnxruntime::narrow<size_t>(dim_idx)];
}
p.slice_offsets[slice_idx] = static_cast<uint64_t>(input_base_offset) + relative_slice_offset;
p.slice_offsets[onnxruntime::narrow<size_t>(slice_idx)] = static_cast<uint64_t>(input_base_offset) + relative_slice_offset;
};
concurrency::ThreadPool::TryParallelFor(
tp, num_slices, static_cast<double>(num_slice_dims),
tp, onnxruntime::narrow<size_t>(num_slices), static_cast<double>(num_slice_dims),
[&lambda](ptrdiff_t first, ptrdiff_t last) {
for (int slice_idx = static_cast<int>(first), end = static_cast<int>(last); slice_idx < end; ++slice_idx) {
lambda(slice_idx);
@ -143,7 +143,7 @@ Status GatherND::Compute(OpKernelContext* context) const {
}
std::vector<int64_t> shape(indices_shape.GetDims().begin(), indices_shape.GetDims().end() - 1);
shape.insert(shape.end(), input_shape.GetDims().begin() + last_indices_dimension,
shape.insert(shape.end(), input_shape.GetDims().begin() + onnxruntime::narrow<std::ptrdiff_t>(last_indices_dimension),
input_shape.GetDims().end());
auto* output_tensor = context->Output(0, TensorShape(std::move(shape)));
@ -178,8 +178,8 @@ Status GatherND::Compute(OpKernelContext* context) const {
Status GatherND::GatherNumber(const Prepare& p, concurrency::ThreadPool* tp) const {
auto lambda = [&](int64_t slice_idx) {
memcpy(p.output_base + slice_idx * p.bytes_per_slice, p.input_base + p.slice_offsets[slice_idx] * p.element_bytes,
p.bytes_per_slice);
memcpy(p.output_base + slice_idx * p.bytes_per_slice, p.input_base + p.slice_offsets[onnxruntime::narrow<size_t>(slice_idx)] * p.element_bytes,
onnxruntime::narrow<size_t>(p.bytes_per_slice));
};
concurrency::ThreadPool::TryParallelFor(
tp, p.slice_offsets.size(), static_cast<double>(p.bytes_per_slice),
@ -195,7 +195,7 @@ Status GatherND::GatherString(const Prepare& p, concurrency::ThreadPool* tp) con
auto lambda = [&](int64_t slice_idx) {
const int64_t slice_base_offset = slice_idx * p.element_count_per_slice;
for (int64_t j = 0; j < static_cast<int64_t>(p.element_count_per_slice); ++j) {
p.output_str_base[slice_base_offset + j] = p.input_str_base[p.slice_offsets[slice_idx] + j];
p.output_str_base[slice_base_offset + j] = p.input_str_base[p.slice_offsets[onnxruntime::narrow<size_t>(slice_idx)] + j];
}
};
concurrency::ThreadPool::TryParallelFor(

2
onnxruntime/core/providers/cpu/tensor/grid_sample.cc
View file

@ -172,7 +172,7 @@ Status GridSample<T>::Compute(OpKernelContext* context) const {
for (int64_t n = 0; n < N; n++) {
const T* grid_data = grid->Data<T>() + n * (H_out * W_out) * 2;
concurrency::ThreadPool::TrySimpleParallelFor(
tp, C,
tp, onnxruntime::narrow<std::ptrdiff_t>(C),
[&](std::ptrdiff_t c) {
const T* X_data = input->Data<T>() + (n * C + c) * (H_in * W_in);
T* Y_data = Y.MutableData<T>() + (n * C + c) * (H_out * W_out);

3
onnxruntime/core/providers/cpu/tensor/identity_op.h
View file

@ -8,6 +8,7 @@
#pragma warning(disable : 4996)
#endif
#include "core/common/common.h"
#include "core/common/narrow.h"
#ifdef _MSC_VER
#pragma warning(pop)
#endif
@ -54,7 +55,7 @@ class IdentityOp final : public OpKernel {
//If source and target pointers are not equal, we need to copy the data.
if (target != source) {
if (!X->IsDataTypeString()) {
memcpy(target, source, shape.Size() * X_type->Size());
memcpy(target, source, SafeInt<size_t>(shape.Size()) * X_type->Size());
} else {
// handle std::string
const auto* src = X->Data<std::string>();

2
onnxruntime/core/providers/cpu/tensor/isinf.cc
View file

@ -74,7 +74,7 @@ struct ComputeDispatchTarget {
});
} else {
// all false
memset(output_data, false, total_items);
memset(output_data, false, onnxruntime::narrow<size_t>(total_items));
}
}
};

2
onnxruntime/core/providers/cpu/tensor/isnan.cc
View file

@ -62,7 +62,7 @@ Status IsNaN<MLFloat16>::Compute(OpKernelContext* context) const {
auto& Y = *context->Output(0, dims);
EigenMap<bool>(Y) =
ConstEigenVectorMap<Eigen::half>(static_cast<const Eigen::half*>(static_cast<const void*>(X_data)), shape_size)
ConstEigenVectorMap<Eigen::half>(static_cast<const Eigen::half*>(static_cast<const void*>(X_data)), onnxruntime::narrow<size_t>(shape_size))
.array()
.isNaN();

12
onnxruntime/core/providers/cpu/tensor/mean_variance_normalization.h
View file

@ -2,7 +2,7 @@
// Licensed under the MIT License.
#pragma once
#include <core/common/safeint.h>
#include "core/common/common.h"
#include "core/framework/op_kernel.h"
#include "core/util/math_cpuonly.h"
@ -45,18 +45,18 @@ class MeanVarianceNormalization_0 : public OpKernel {
mean.setZero();
var.setZero();
ConstEigenArrayMap<T> X_arr(Xdata, sample_size, N * C);
ConstEigenArrayMap<T> X_arr(Xdata, onnxruntime::narrow<std::ptrdiff_t>(sample_size), SafeInt<ptrdiff_t>(N) * C);
for (int nc = 0; nc < N * C; ++nc) {
mean(nc % C) += X_arr.col(nc).sum();
}
mean /= gsl::narrow_cast<T>(N * sample_size);
for (int64_t nc = 0; nc < N * C; ++nc) {
var(nc % C) += (X_arr.col(nc) - mean(nc % C)).matrix().squaredNorm();
var(onnxruntime::narrow<std::ptrdiff_t>(nc % C)) += (X_arr.col(onnxruntime::narrow<std::ptrdiff_t>(nc)) - mean(onnxruntime::narrow<std::ptrdiff_t>(nc % C))).matrix().squaredNorm();
}
var /= gsl::narrow_cast<T>(N * sample_size);
Eigen::Array<T, Eigen::Dynamic, 1> inv_std;
EigenArrayMap<T> Y_arr(Ydata, sample_size, N * C);
EigenArrayMap<T> Y_arr(Ydata, onnxruntime::narrow<std::ptrdiff_t>(sample_size), SafeInt<ptrdiff_t>(N) * C);
if (across_channels_) {
// m_c = sum(m_i) / n
@ -79,13 +79,13 @@ class MeanVarianceNormalization_0 : public OpKernel {
// inv_std = 1
for (int64_t nc = 0; nc < N * C; ++nc) {
// y = (x - mean)
Y_arr.col(nc) = (X_arr.col(nc) - mean(nc % C));
Y_arr.col(onnxruntime::narrow<std::ptrdiff_t>(nc)) = (X_arr.col(onnxruntime::narrow<std::ptrdiff_t>(nc)) - mean(onnxruntime::narrow<std::ptrdiff_t>(nc % C)));
}
} else {
inv_std = var.sqrt().inverse();
for (int64_t nc = 0; nc < N * C; ++nc) {
// y = (x - mean) * (inv_std)
Y_arr.col(nc) = (X_arr.col(nc) - mean(nc % C)) * inv_std(nc % C);
Y_arr.col(onnxruntime::narrow<std::ptrdiff_t>(nc)) = (X_arr.col(onnxruntime::narrow<std::ptrdiff_t>(nc)) - mean(onnxruntime::narrow<std::ptrdiff_t>(nc % C))) * inv_std(onnxruntime::narrow<std::ptrdiff_t>(nc % C));
}
}
}

10
onnxruntime/core/providers/cpu/tensor/nonzero_op.cc
View file

@ -5,7 +5,7 @@
#include <cassert>
#include <vector>
#include <core/common/safeint.h>
#include "core/util/math_cpuonly.h"
namespace onnxruntime {
@ -59,10 +59,10 @@ Status NonZero<T>::Compute(OpKernelContext* context) const {
const auto& X_shape = X->Shape();
assert(X_shape.Size() >= 0);
const Eigen::Index coordinate_size = X_shape.IsScalar() ? 1 : X_shape.NumDimensions();
const Eigen::Index coordinate_size = X_shape.IsScalar() ? 1 : onnxruntime::narrow<Eigen::Index>(X_shape.NumDimensions());
std::vector<int64_t> non_zero_indices_buffer{};
// reserve enough space for indices for every element of X
non_zero_indices_buffer.reserve(X_shape.Size() * coordinate_size);
non_zero_indices_buffer.reserve(SafeInt<size_t>(X_shape.Size()) * coordinate_size);
const T* data = X->Data<T>();
@ -87,7 +87,7 @@ Status NonZero<T>::Compute(OpKernelContext* context) const {
}
};
for (size_t i = 0, end = X_shape.Size(); i < end; ++i) {
for (size_t i = 0, end = onnxruntime::narrow<size_t>(X_shape.Size()); i < end; ++i) {
const T& value = *data++;
if (value != T{}) {
non_zero_indices_buffer.insert(non_zero_indices_buffer.end(),
@ -98,7 +98,7 @@ Status NonZero<T>::Compute(OpKernelContext* context) const {
}
}
const Eigen::Index num_non_zero_values = non_zero_indices_buffer.size() / coordinate_size;
const Eigen::Index num_non_zero_values = onnxruntime::narrow<Eigen::Index>(non_zero_indices_buffer.size()) / coordinate_size;
// transpose result for output
ConstEigenMatrixMapRowMajor<int64_t> non_zero_indices_matrix{

4
onnxruntime/core/providers/cpu/tensor/onehot.cc
View file

@ -102,7 +102,7 @@ Status PrepareOutputShape(const Tensor* indices, const int64_t depth_val, const
prefix_dim_size = 1;
for (int64_t i = 0; i < true_axis; ++i) {
prefix_dim_size *= indices_dims[i];
prefix_dim_size *= indices_dims[onnxruntime::narrow<size_t>(i)];
}
suffix_dim_size = indices_shape.Size() / prefix_dim_size;
@ -180,7 +180,7 @@ Status OneHotOp<in_type, out_type, depth_type>::Compute(OpKernelContext* p_op_ke
const auto* indices_data = indices->Data<in_type>();
const auto indices_size = indices->Shape().Size();
std::vector<in_type> adjusted_indices;
adjusted_indices.reserve(indices_size);
adjusted_indices.reserve(onnxruntime::narrow<size_t>(indices_size));
for (int64_t i = 0; i < indices_size; ++i) {
if (indices_data[i] < 0)
adjusted_indices.push_back(indices_data[i] + static_cast<in_type>(depth_val));

56
onnxruntime/core/providers/cpu/tensor/pad.cc
View file

@ -283,9 +283,9 @@ static Status PadImpl(OpKernelContext* ctx,
// Reshape padding
size_t new_dims_count = reshaped_input_dims.size();
size_t inner_axis = new_dims_count - 1;
size_t inner_no_pad_size = output_dims[inner_axis] > 0
size_t inner_no_pad_size = onnxruntime::narrow<size_t>(output_dims[inner_axis] > 0
? reshaped_input_dims[inner_axis] / output_dims[inner_axis]
: 0;
: 0);
PadsVector reshaped_pad(2 * new_dims_count), reshaped_slice(2 * new_dims_count);
ReshapePads(pads, data_rank, new_dims_count, inner_no_pad_size, reshaped_pad);
ReshapePads(slices, data_rank, new_dims_count, inner_no_pad_size, reshaped_slice);
@ -327,7 +327,7 @@ static Status PadImpl(OpKernelContext* ctx,
// Initial skip, sum up the begin padding on each axis
for (size_t i = 0; i < new_dims_count; i++)
alignSkip += reshaped_pad[i] * output_pitches[i];
alignSkip += SafeInt<size_t>(reshaped_pad[i] )* output_pitches[i];
ExtentAxisCounters input_counters(input_extents);
@ -344,21 +344,21 @@ static Status PadImpl(OpKernelContext* ctx,
int64_t prePad = reshaped_pad[inner_axis];
int64_t postPad = reshaped_pad[inner_axis + new_dims_count];
PadAxisConstant(axisStart - prePad, value, prePad);
PadAxisConstant(output, value, postPad);
PadAxisConstant(axisStart - prePad, value, onnxruntime::narrow<size_t>(prePad));
PadAxisConstant(output, value, onnxruntime::narrow<size_t>(postPad));
output += postPad;
alignSkip = prePad;
alignSkip = onnxruntime::narrow<size_t>(prePad);
}
// Calculate the size of the next block of padding (skipping over the innermost axis since that's already done)
while (input_counters.Increment()) {
ptrdiff_t inner_pitch = output_pitches[input_counters.Axis()];
ptrdiff_t inner_pitch = onnxruntime::narrow<std::ptrdiff_t>(output_pitches[input_counters.Axis()]);
T* axisStart = output - inner_pitch * input_extents[input_counters.Axis()];
int64_t prePad = reshaped_pad[input_counters.Axis()];
int64_t postPad = reshaped_pad[input_counters.Axis() + new_dims_count];
PadAxisConstant(axisStart - prePad * inner_pitch, value, prePad * inner_pitch);
PadAxisConstant(output, value, postPad * inner_pitch);
PadAxisConstant(axisStart - prePad * inner_pitch, value, SafeInt<std::ptrdiff_t>(prePad) * inner_pitch);
PadAxisConstant(output, value, SafeInt<ptrdiff_t>(postPad) * inner_pitch);
output += inner_pitch * postPad;
alignSkip += inner_pitch * prePad;
alignSkip += inner_pitch * SafeInt<size_t>(prePad);
}
}
break;
@ -376,27 +376,27 @@ static Status PadImpl(OpKernelContext* ctx,
int64_t prePad = reshaped_pad[inner_axis];
int64_t postPad = reshaped_pad[inner_axis + new_dims_count];
if (inner_no_pad_size == 1) {
PadAxisConstant(axisStart - prePad, *axisStart, prePad);
PadAxisConstant(output, *(output - 1), postPad);
PadAxisConstant(axisStart - prePad, *axisStart, onnxruntime::narrow<size_t>(prePad));
PadAxisConstant(output, *(output - 1), onnxruntime::narrow<size_t>(postPad));
} else {
// When inner_most axis(es) do not need pad, above PadAxisConstant() do not fit for Edge mode.
// Also general loop below after handling first pad axis with non-pad axis works fine.
PadAxis(axisStart - prePad, axisStart, 1, -ptrdiff_t(inner_no_pad_size), inner_no_pad_size, pads[inner_axis]);
PadAxis(output, output - inner_no_pad_size, 1, -ptrdiff_t(inner_no_pad_size), inner_no_pad_size, pads[inner_axis + data_rank]);
PadAxis(axisStart - prePad, axisStart, 1, -ptrdiff_t(inner_no_pad_size), inner_no_pad_size, onnxruntime::narrow<size_t>(pads[inner_axis]));
PadAxis(output, output - inner_no_pad_size, 1, -ptrdiff_t(inner_no_pad_size), inner_no_pad_size, onnxruntime::narrow<size_t>(pads[inner_axis + data_rank]));
}
output += postPad;
alignSkip = prePad;
alignSkip = onnxruntime::narrow<size_t>(prePad);
}
// Calculate the size of the next block of padding (skipping over the innermost axis since that's already done)
while (input_counters.Increment()) {
ptrdiff_t inner_pitch = output_pitches[input_counters.Axis()];
ptrdiff_t inner_pitch = onnxruntime::narrow<std::ptrdiff_t>(output_pitches[input_counters.Axis()]);
T* axisStart = output - inner_pitch * input_extents[input_counters.Axis()];
int64_t prePad = reshaped_pad[input_counters.Axis()];
int64_t postPad = reshaped_pad[input_counters.Axis() + new_dims_count];
PadAxis(axisStart - prePad * inner_pitch, axisStart, 1, -inner_pitch, inner_pitch, prePad);
PadAxis(output, output - inner_pitch, 1, -inner_pitch, inner_pitch, postPad);
PadAxis(axisStart - prePad * inner_pitch, axisStart, 1, -inner_pitch, inner_pitch, onnxruntime::narrow<size_t>(prePad));
PadAxis(output, output - inner_pitch, 1, -inner_pitch, inner_pitch, onnxruntime::narrow<size_t>(postPad));
output += inner_pitch * postPad;
alignSkip += inner_pitch * prePad;
alignSkip += inner_pitch * SafeInt<size_t>(prePad);
}
}
break;
@ -414,27 +414,27 @@ static Status PadImpl(OpKernelContext* ctx,
int64_t prePad = reshaped_pad[inner_axis];
int64_t postPad = reshaped_pad[inner_axis + new_dims_count];
if (inner_no_pad_size == 1) {
PadInnermostAxis(axisStart - prePad, axisStart + prePad, -1 /* inputDelta */, prePad);
PadInnermostAxis(output, output - 2, -1 /* inputDelta */, postPad);
PadInnermostAxis(axisStart - prePad, axisStart + prePad, -1 /* inputDelta */, onnxruntime::narrow<size_t>(prePad));
PadInnermostAxis(output, output - 2, -1 /* inputDelta */, onnxruntime::narrow<size_t>(postPad));
} else {
// When inner_most axis(es) do not need pad, Above PadInnermostAxis() do not fit for Reflect mode.
PadAxis(axisStart - prePad, axisStart + prePad, 1, -ptrdiff_t(inner_no_pad_size * 2), inner_no_pad_size, pads[inner_axis]);
PadAxis(output, output - 2 * inner_no_pad_size, 1, -ptrdiff_t(inner_no_pad_size * 2), inner_no_pad_size, pads[inner_axis + data_rank]);
PadAxis(axisStart - prePad, axisStart + prePad, 1, -ptrdiff_t(inner_no_pad_size * 2), inner_no_pad_size, onnxruntime::narrow<size_t>(pads[inner_axis]));
PadAxis(output, output - 2 * inner_no_pad_size, 1, -ptrdiff_t(inner_no_pad_size * 2), inner_no_pad_size, onnxruntime::narrow<size_t>(pads[inner_axis + data_rank]));
}
output += postPad;
alignSkip = prePad;
alignSkip = onnxruntime::narrow<size_t>(prePad);
}
// Calculate the size of the next block of padding (skipping over the innermost axis since that's already done)
while (input_counters.Increment()) {
ptrdiff_t inner_pitch = output_pitches[input_counters.Axis()];
ptrdiff_t inner_pitch = onnxruntime::narrow<std::ptrdiff_t>(output_pitches[input_counters.Axis()]);
T* axisStart = output - inner_pitch * input_extents[input_counters.Axis()];
int64_t prePad = reshaped_pad[input_counters.Axis()];
int64_t postPad = reshaped_pad[input_counters.Axis() + new_dims_count];
PadAxis(axisStart - prePad * inner_pitch, axisStart + prePad * inner_pitch, 1, -inner_pitch * 2,
inner_pitch, prePad);
PadAxis(output, output - 2 * inner_pitch, 1, -inner_pitch * 2, inner_pitch, postPad);
inner_pitch, onnxruntime::narrow<size_t>(prePad));
PadAxis(output, output - 2 * inner_pitch, 1, -inner_pitch * 2, inner_pitch, onnxruntime::narrow<size_t>(postPad));
output += inner_pitch * postPad;
alignSkip += inner_pitch * prePad;
alignSkip += inner_pitch * SafeInt<size_t>(prePad);
}
}
break;

8
onnxruntime/core/providers/cpu/tensor/reverse_sequence.cc
View file

@ -146,9 +146,9 @@ static Status ReverseSequenceImpl(const Tensor& X,
}
for (int64_t j = 0; j < seq_len; j++) {
gsl::span<const T> src = inputs.subspan(input_offset(max_seq_len, batch_size, input_size, i, j), input_size);
gsl::span<const T> src = inputs.subspan(onnxruntime::narrow<size_t>(input_offset(max_seq_len, batch_size, input_size, i, j)), onnxruntime::narrow<size_t>(input_size));
gsl::span<T> dest = inputs_reverse.subspan(
reversed_output_offset(max_seq_len, batch_size, input_size, i, j, seq_len), input_size);
onnxruntime::narrow<size_t>(reversed_output_offset(max_seq_len, batch_size, input_size, i, j, seq_len)), onnxruntime::narrow<size_t>(input_size));
// Use gsl::copy instead of std::copy() to allow compiler to optimize the code
gsl::copy(src, dest);
@ -156,8 +156,8 @@ static Status ReverseSequenceImpl(const Tensor& X,
for (int64_t j = seq_len; j < max_seq_len; j++) {
const auto offset = input_offset(max_seq_len, batch_size, input_size, i, j);
gsl::span<const T> src = inputs.subspan(offset, input_size);
gsl::span<T> dest = inputs_reverse.subspan(offset, input_size);
gsl::span<const T> src = inputs.subspan(onnxruntime::narrow<size_t>(offset), onnxruntime::narrow<size_t>(input_size));
gsl::span<T> dest = inputs_reverse.subspan(onnxruntime::narrow<size_t>(offset), onnxruntime::narrow<size_t>(input_size));
// Use gsl::copy instead of std::copy() to allow compiler to optimize the code
gsl::copy(src, dest);

26
onnxruntime/core/providers/cpu/tensor/scatter_nd.cc
View file

@ -83,7 +83,7 @@ Status ScatterND::ValidateShapes(
// Part 2: The shape of the update tensor after indices rank - 1 (inclusive)
// should match the shape of the input tensor after `last_indice_dimension`
if (input_shape.Slice(last_indice_dimension) != update_shape.Slice(indice_rank - 1)) {
if (input_shape.Slice(onnxruntime::narrow<size_t>(last_indice_dimension)) != update_shape.Slice(indice_rank - 1)) {
return true;
}
@ -144,17 +144,17 @@ Status PrepareForCompute(OpKernelContext* context, Prepare<TData>& p) {
}
}
std::vector<int64_t> element_counts(last_indice_dimension, 0LL); // Number of elements for each input dimension
std::vector<int64_t> element_counts(onnxruntime::narrow<size_t>(last_indice_dimension), 0LL); // Number of elements for each input dimension
TensorPitches input_strides(input_shape);
for (int64_t i = 0; i < last_indice_dimension; ++i) {
element_counts[i] = input_strides[i];
element_counts[onnxruntime::narrow<size_t>(i)] = input_strides[onnxruntime::narrow<size_t>(i)];
}
p.element_to_copy = input_shape.SizeFromDimension(last_indice_dimension);
p.element_to_copy = input_shape.SizeFromDimension(onnxruntime::narrow<size_t>(last_indice_dimension));
const int64_t* indice_offset = indice_tensor->Data<int64_t>();
auto offset_count = indice_shape.Size() / last_indice_dimension; // Times to copy
p.element_offsets.assign(offset_count, 0LL);
p.element_offsets.assign(onnxruntime::narrow<size_t>(offset_count), 0LL);
p.input_base = update_tensor->Data<TData>();
p.output_base = output_tensor->MutableData<TData>();
@ -164,18 +164,18 @@ Status PrepareForCompute(OpKernelContext* context, Prepare<TData>& p) {
auto indice = *(indice_offset + i * last_indice_dimension + j);
if (indice >= 0) {
if (indice >= input_shape[j]) {
if (indice >= input_shape[onnxruntime::narrow<size_t>(j)]) {
return ORT_MAKE_STATUS(ONNXRUNTIME, INVALID_ARGUMENT, "invalid indice found, indice = ", indice);
}
} else {
if (indice < -input_shape[j]) {
if (indice < -input_shape[onnxruntime::narrow<size_t>(j)]) {
return ORT_MAKE_STATUS(ONNXRUNTIME, INVALID_ARGUMENT, "invalid indice found, indice = ", indice);
} else {
indice += input_shape[j];
indice += input_shape[onnxruntime::narrow<size_t>(j)];
}
}
p.element_offsets[i] += indice * element_counts[j];
p.element_offsets[onnxruntime::narrow<size_t>(i)] += indice * element_counts[onnxruntime::narrow<size_t>(j)];
}
}
return Status::OK();
@ -184,7 +184,7 @@ Status PrepareForCompute(OpKernelContext* context, Prepare<TData>& p) {
template <class T>
struct Func_Copy_ND {
void operator()(T* a, const T* b, uint64_t element_to_copy) const {
memcpy(a, b, element_to_copy * sizeof(T));
memcpy(a, b, SafeInt<size_t>(element_to_copy) * sizeof(T));
}
};
@ -274,14 +274,14 @@ struct ScatterNDDispatchTarget {
case ScatterND::Reduction::Add: {
auto func = Func_Add_ND<TData>();
func(
prepare.output_base + prepare.element_offsets[i],
prepare.output_base + prepare.element_offsets[onnxruntime::narrow<size_t>(i)],
prepare.input_base + i * prepare.element_to_copy,
prepare.element_to_copy);
} break;
case ScatterND::Reduction::Mul: {
auto func = Func_Mul_ND<TData>();
func(
prepare.output_base + prepare.element_offsets[i],
prepare.output_base + prepare.element_offsets[onnxruntime::narrow<size_t>(i)],
prepare.input_base + i * prepare.element_to_copy,
prepare.element_to_copy);
} break;
@ -289,7 +289,7 @@ struct ScatterNDDispatchTarget {
case ScatterND::Reduction::None: {
auto func = Func_Copy_ND<TData>();
func(
prepare.output_base + prepare.element_offsets[i],
prepare.output_base + prepare.element_offsets[onnxruntime::narrow<size_t>(i)],
prepare.input_base + i * prepare.element_to_copy,
prepare.element_to_copy);
} break;

3
onnxruntime/core/providers/cpu/tensor/shape_op.h
View file

@ -5,6 +5,7 @@
#ifndef SHARED_PROVIDER
#include "core/common/common.h"
#include "core/common/narrow.h"
#include "core/framework/op_kernel.h"
#endif
@ -54,7 +55,7 @@ class Shape final : public OpKernel {
Tensor* output = context->Output(0, {slice_length < 0 ? 0 : slice_length});
if (slice_length > 0) {
input_shape.CopyDims(output->MutableData<int64_t>(), true_start, slice_length);
input_shape.CopyDims(output->MutableData<int64_t>(), onnxruntime::narrow<size_t>(true_start), onnxruntime::narrow<size_t>(slice_length));
}
}

37
onnxruntime/core/providers/cpu/tensor/slice_helper.h
View file

@ -6,6 +6,7 @@
#pragma once
#include "core/providers/cpu/tensor/slice_compute_metadata.h"
#include "core/common/inlined_containers.h"
#include "core/common/narrow.h"
#include "core/framework/ort_stl_allocator.h"
namespace onnxruntime {
@ -45,26 +46,26 @@ inline Status PrepareForComputeHelper(const gsl::span<const int64_t>& raw_starts
if (!p.second)
return Status(common::ONNXRUNTIME, common::INVALID_ARGUMENT, "'axes' has duplicates");
const auto dim_value = compute_metadata.input_dimensions_[axis];
const auto dim_value = compute_metadata.input_dimensions_[onnxruntime::narrow<size_t>(axis)];
// process start
auto start = raw_starts[axis_index];
if (start < 0)
start += dim_value;
compute_metadata.starts_[axis] = std::clamp(start, int64_t{0}, dim_value);
compute_metadata.starts_[onnxruntime::narrow<size_t>(axis)] = std::clamp(start, int64_t{0}, dim_value);
// process end
auto end = raw_ends[axis_index];
if (end < 0)
end += dim_value;
compute_metadata.ends_[axis] = std::clamp(end, int64_t{0}, dim_value);
compute_metadata.ends_[onnxruntime::narrow<size_t>(axis)] = std::clamp(end, int64_t{0}, dim_value);
// find output dim value for this axis
const auto temp = compute_metadata.ends_[axis] - compute_metadata.starts_[axis];
const auto temp = compute_metadata.ends_[onnxruntime::narrow<size_t>(axis)] - compute_metadata.starts_[onnxruntime::narrow<size_t>(axis)];
if (temp < 0)
compute_metadata.output_dims_[axis] = 0;
compute_metadata.output_dims_[onnxruntime::narrow<size_t>(axis)] = 0;
else
compute_metadata.output_dims_[axis] = temp;
compute_metadata.output_dims_[onnxruntime::narrow<size_t>(axis)] = temp;
}
return Status::OK();
@ -103,7 +104,7 @@ inline Status PrepareForComputeHelper(const gsl::span<const int64_t>& raw_starts
auto p = unique_axes.insert(axis);
if (!p.second)
return Status(common::ONNXRUNTIME, common::INVALID_ARGUMENT, "'axes' has duplicates");
const auto dim_value = compute_metadata.input_dimensions_[axis];
const auto dim_value = compute_metadata.input_dimensions_[onnxruntime::narrow<size_t>(axis)];
// process step
auto step = axis_index < raw_steps.size() ? raw_steps[axis_index] : 1;
@ -112,10 +113,10 @@ inline Status PrepareForComputeHelper(const gsl::span<const int64_t>& raw_starts
if (dim_value == 0) {
// shape with empty dim. only output_dims_ matters but set everything for completeness
compute_metadata.steps_[axis] = step;
compute_metadata.starts_[axis] = 0;
compute_metadata.ends_[axis] = 0;
compute_metadata.output_dims_[axis] = 0;
compute_metadata.steps_[onnxruntime::narrow<size_t>(axis)] = step;
compute_metadata.starts_[onnxruntime::narrow<size_t>(axis)] = 0;
compute_metadata.ends_[onnxruntime::narrow<size_t>(axis)] = 0;
compute_metadata.output_dims_[onnxruntime::narrow<size_t>(axis)] = 0;
continue;
}
@ -123,16 +124,16 @@ inline Status PrepareForComputeHelper(const gsl::span<const int64_t>& raw_starts
// as long as the clamped value is >= the size of the dimension a single step will push us past the end
step = std::clamp(step, -dim_value, dim_value);
compute_metadata.steps_[axis] = step;
compute_metadata.steps_[onnxruntime::narrow<size_t>(axis)] = step;
// process start
auto start = raw_starts[axis_index];
if (start < 0)
start += dim_value;
if (step < 0)
compute_metadata.starts_[axis] = std::clamp(start, int64_t{0}, dim_value - 1);
compute_metadata.starts_[onnxruntime::narrow<size_t>(axis)] = std::clamp(start, int64_t{0}, dim_value - 1);
else
compute_metadata.starts_[axis] = std::clamp(start, int64_t{0}, dim_value);
compute_metadata.starts_[onnxruntime::narrow<size_t>(axis)] = std::clamp(start, int64_t{0}, dim_value);
// process end
auto end = raw_ends[axis_index];
@ -151,14 +152,14 @@ inline Status PrepareForComputeHelper(const gsl::span<const int64_t>& raw_starts
end = std::clamp(end, int64_t{0}, dim_value);
}
compute_metadata.ends_[axis] = end;
compute_metadata.ends_[onnxruntime::narrow<size_t>(axis)] = end;
// find output dim value for this axis
const auto temp = static_cast<int64_t>(ceil(1.0 * (compute_metadata.ends_[axis] - compute_metadata.starts_[axis]) / step));
const auto temp = static_cast<int64_t>(ceil(1.0 * (compute_metadata.ends_[onnxruntime::narrow<size_t>(axis)] - compute_metadata.starts_[onnxruntime::narrow<size_t>(axis)]) / step));
if (temp < 0)
compute_metadata.output_dims_[axis] = 0;
compute_metadata.output_dims_[onnxruntime::narrow<size_t>(axis)] = 0;
else
compute_metadata.output_dims_[axis] = temp;
compute_metadata.output_dims_[onnxruntime::narrow<size_t>(axis)] = temp;
}
return Status::OK();

60
onnxruntime/core/providers/cpu/tensor/space_depth_ops.cc
View file

@ -107,13 +107,31 @@ Status SpaceToDepth::Compute(OpKernelContext* context) const {
std::array<Eigen::DenseIndex, IntermediateTensorRank> permutation{{0, 3, 5, 1, 2, 4}};
if (input.IsDataType<float>()) {
SpaceDepthOpCpuImpl<float>(input, output, permutation, batch,
input_depth, input_height / blocksize_, blocksize_, input_width / blocksize_, blocksize_,
blocksize_, blocksize_, input_depth, input_height / blocksize_, input_width / blocksize_);
SpaceDepthOpCpuImpl<float>(input, output, permutation,
onnxruntime::narrow<ptrdiff_t>(batch),
onnxruntime::narrow<std::ptrdiff_t>(input_depth),
onnxruntime::narrow<std::ptrdiff_t>(input_height / blocksize_),
onnxruntime::narrow<std::ptrdiff_t>(blocksize_),
onnxruntime::narrow<std::ptrdiff_t>(input_width / blocksize_),
onnxruntime::narrow<std::ptrdiff_t>(blocksize_),
onnxruntime::narrow<ptrdiff_t>(blocksize_),
onnxruntime::narrow<ptrdiff_t>(blocksize_),
onnxruntime::narrow<std::ptrdiff_t>(input_depth),
onnxruntime::narrow<std::ptrdiff_t>(input_height / blocksize_),
onnxruntime::narrow<std::ptrdiff_t>(input_width / blocksize_));
} else if (input.IsDataType<double>()) {
SpaceDepthOpCpuImpl<double>(input, output, permutation, batch,
input_depth, input_height / blocksize_, blocksize_, input_width / blocksize_, blocksize_,
blocksize_, blocksize_, input_depth, input_height / blocksize_, input_width / blocksize_);
SpaceDepthOpCpuImpl<double>(input, output, permutation,
onnxruntime::narrow<ptrdiff_t>(batch),
onnxruntime::narrow<std::ptrdiff_t>(input_depth),
onnxruntime::narrow<std::ptrdiff_t>(input_height / blocksize_),
onnxruntime::narrow<std::ptrdiff_t>(blocksize_),
onnxruntime::narrow<std::ptrdiff_t>(input_width / blocksize_),
onnxruntime::narrow<std::ptrdiff_t>(blocksize_),
onnxruntime::narrow<ptrdiff_t>(blocksize_),
onnxruntime::narrow<ptrdiff_t>(blocksize_),
onnxruntime::narrow<std::ptrdiff_t>(input_depth),
onnxruntime::narrow<std::ptrdiff_t>(input_height / blocksize_),
onnxruntime::narrow<std::ptrdiff_t>(input_width / blocksize_));
} else {
// user will not see this as the kernel doesn't claim support for types other than float and double
return ORT_MAKE_STATUS(ONNXRUNTIME, FAIL, "Unsupported input type in SpaceToDepth op: ", input.DataType());
@ -153,13 +171,31 @@ Status DepthToSpace::Compute(OpKernelContext* context) const {
: std::array<Eigen::DenseIndex, IntermediateTensorRank>{{0, 1, 4, 2, 5, 3}};
if (input.IsDataType<float>()) {
SpaceDepthOpCpuImpl<float>(input, output, permutation, batch,
dim1, blocksize_, dim3, input_height, input_width,
input_depth / blocksize_ / blocksize_, input_height, blocksize_, input_width, blocksize_);
SpaceDepthOpCpuImpl<float>(input, output, permutation,
onnxruntime::narrow<std::ptrdiff_t>(batch),
onnxruntime::narrow<std::ptrdiff_t>(dim1),
onnxruntime::narrow<std::ptrdiff_t>(blocksize_),
onnxruntime::narrow<std::ptrdiff_t>(dim3),
onnxruntime::narrow<std::ptrdiff_t>(input_height),
onnxruntime::narrow<std::ptrdiff_t>(input_width),
onnxruntime::narrow<std::ptrdiff_t>(input_depth / blocksize_ / blocksize_),
onnxruntime::narrow<std::ptrdiff_t>(input_height),
onnxruntime::narrow<std::ptrdiff_t>(blocksize_),
onnxruntime::narrow<std::ptrdiff_t>(input_width),
onnxruntime::narrow<std::ptrdiff_t>(blocksize_));
} else if (input.IsDataType<double>()) {
SpaceDepthOpCpuImpl<double>(input, output, permutation, batch,
dim1, blocksize_, dim3, input_height, input_width,
input_depth / blocksize_ / blocksize_, input_height, blocksize_, input_width, blocksize_);
SpaceDepthOpCpuImpl<double>(input, output, permutation,
onnxruntime::narrow<std::ptrdiff_t>(batch),
onnxruntime::narrow<std::ptrdiff_t>(dim1),
onnxruntime::narrow<std::ptrdiff_t>(blocksize_),
onnxruntime::narrow<std::ptrdiff_t>(dim3),
onnxruntime::narrow<std::ptrdiff_t>(input_height),
onnxruntime::narrow<std::ptrdiff_t>(input_width),
onnxruntime::narrow<std::ptrdiff_t>(input_depth / blocksize_ / blocksize_),
onnxruntime::narrow<std::ptrdiff_t>(input_height),
onnxruntime::narrow<std::ptrdiff_t>(blocksize_),
onnxruntime::narrow<std::ptrdiff_t>(input_width),
onnxruntime::narrow<std::ptrdiff_t>(blocksize_));
} else {
// user will not see this as the kernel doesn't claim support for types other than float and double
return ORT_MAKE_STATUS(ONNXRUNTIME, FAIL, "Unsupported input type in DepthToSpace op: ", input.DataType());

11
onnxruntime/core/providers/cpu/tensor/split.cc
View file

@ -1,6 +1,7 @@
// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License.
#include <core/common/safeint.h>
#include "core/providers/cpu/tensor/split.h"
#include "core/common/gsl.h"
@ -57,13 +58,13 @@ Status SplitBase::PrepareForCompute(const TensorShape& input_shape, int num_outp
auto input_dims = input_shape.GetDims();
const auto num_dimensions = gsl::narrow_cast<int64_t>(input_shape.NumDimensions());
axis = HandleNegativeAxis(axis_, num_dimensions); // handle negative and enforce axis is valid
const int64_t split_dim_size = input_dims[axis];
const int64_t split_dim_size = input_dims[onnxruntime::narrow<size_t>(axis)];
before_dims = narrow<int>(input_shape.SizeToDimension(axis));
after_dims_including_split_axis = narrow<int>(input_shape.SizeFromDimension(axis));
before_dims = narrow<int>(input_shape.SizeToDimension(onnxruntime::narrow<size_t>(axis)));
after_dims_including_split_axis = narrow<int>(input_shape.SizeFromDimension(onnxruntime::narrow<size_t>(axis)));
after_dims_excluding_split = (axis + 1 == num_dimensions)
? 1 // we multiply by this value so must be 1 not 0
: narrow<int>(input_shape.SizeFromDimension(axis + 1));
: narrow<int>(input_shape.SizeFromDimension(SafeInt<size_t>(axis) + 1));
if (split_sizes.empty()) {
// equal split based on number of outputs
@ -166,7 +167,7 @@ Status Split::ComputeImpl(OpKernelContext& context, const Tensor& input) const {
for (int i = 0; i < num_outputs; ++i) {
// update size of dimension for axis we're splitting on
auto split_size = narrow<int>(split_sizes[i]);
output_dimensions[axis] = split_size;
output_dimensions[onnxruntime::narrow<size_t>(axis)] = split_size;
Tensor* output = context.Output(i, TensorShape{output_dimensions});
T* output_data = output->MutableData<T>();

18
onnxruntime/core/providers/cpu/tensor/transpose.cc
View file

@ -147,7 +147,7 @@ static void DoTransposeImpl(int64_t num_axes, gsl::span<const int64_t> target_di
const uint8_t* source, uint8_t* target, size_t element_size) {
size_t blocksize = num_elts_in_block * element_size;
MultiIndex mindex;
IncrementIndexAndComputeOffsetSetup(mindex, num_axes, target_dims, stride, element_size);
IncrementIndexAndComputeOffsetSetup(mindex, onnxruntime::narrow<size_t>(num_axes), target_dims, stride, element_size);
const uint8_t* local_source = source;
for (size_t i = 0; i < num_blocks; ++i) {
@ -163,7 +163,7 @@ static void DoTransposeImpl(int64_t num_axes, gsl::span<const int64_t> target_di
const std::string* source, std::string* target) {
ORT_ENFORCE(num_axes > 0, "Transpose not implemented for empty tensors.");
MultiIndex mindex;
IncrementIndexAndComputeOffsetSetup(mindex, num_axes, target_dims, stride, 1);
IncrementIndexAndComputeOffsetSetup(mindex, onnxruntime::narrow<size_t>(num_axes), target_dims, stride, 1);
const std::string* local_source = source;
for (size_t i = 0; i < num_blocks; ++i) {
@ -187,7 +187,7 @@ static bool TypedDoTransposeEltWise(int64_t num_axes, gsl::span<const int64_t> t
if (enabled) {
MultiIndex mindex;
IncrementIndexAndComputeOffsetSetup(mindex, num_axes, target_dims, stride, sizeof(T));
IncrementIndexAndComputeOffsetSetup(mindex, onnxruntime::narrow<size_t>(num_axes), target_dims, stride, sizeof(T));
const uint8_t* local_source = source;
uint8_t* target_end = target + sizeof(T) * num_blocks;
@ -235,7 +235,7 @@ static void DoTransposeEltWise(int64_t num_axes, gsl::span<const int64_t> target
const gsl::span<const size_t>& stride, const std::string* source, std::string* target) {
ORT_ENFORCE(num_axes > 0, "Transpose not implemented for empty tensors.");
MultiIndex mindex;
IncrementIndexAndComputeOffsetSetup(mindex, num_axes, target_dims, stride, 1);
IncrementIndexAndComputeOffsetSetup(mindex, onnxruntime::narrow<size_t>(num_axes), target_dims, stride, 1);
// index used to iterate over target iteration-space
const std::string* local_source = source;
@ -261,7 +261,7 @@ static Status DoUntypedTranspose(const gsl::span<const size_t>& permutations, co
for (size_t i = 0; i < rank; i++) {
size_t inpdim = permutations[i];
if (inpdim + 1 < rank)
stride[i] = input_shape.SizeFromDimension(inpdim + 1);
stride[i] = onnxruntime::narrow<size_t>(input_shape.SizeFromDimension(inpdim + 1));
else
stride[i] = 1;
}
@ -273,13 +273,13 @@ static Status DoUntypedTranspose(const gsl::span<const size_t>& permutations, co
size_t prefix_blocksize = 1; // product of dimensions in the prefix
bool is_suffix = true;
for (int64_t i = rank - 1; i >= 0; --i) {
int64_t input_axis = permutations[i];
for (int64_t i = SafeInt<int64_t>(rank) - 1; i >= 0; --i) {
int64_t input_axis = onnxruntime::narrow<int64_t>(permutations[onnxruntime::narrow<size_t>(i)]);
if (is_suffix && (input_axis == i)) {
suffix_blocksize *= static_cast<size_t>(input_dims[input_axis]);
suffix_blocksize *= static_cast<size_t>(input_dims[onnxruntime::narrow<size_t>(input_axis)]);
} else {
is_suffix = false;
prefix_blocksize *= static_cast<size_t>(input_dims[input_axis]);
prefix_blocksize *= static_cast<size_t>(input_dims[onnxruntime::narrow<size_t>(input_axis)]);
++num_axes_in_prefix;
}
}

15
onnxruntime/core/providers/cpu/tensor/trilu.cc
View file

@ -7,6 +7,7 @@
#include "Eigen/src/Core/Map.h"
#include "trilu.h"
#include <functional>
#include <core/common/safeint.h>
using namespace onnxruntime::common;
@ -39,12 +40,12 @@ static Status TriluImpl(const Tensor* X, Tensor* Y, int64_t k_val, bool up) {
int64_t X_num_dims = static_cast<int64_t>(X_shape.NumDimensions());
const auto* X_data = reinterpret_cast<const T*>(X->DataRaw());
int64_t matrix_h = static_cast<int64_t>(X_shape[X_num_dims - 2]);
int64_t matrix_w = static_cast<int64_t>(X_shape[X_num_dims - 1]);
int64_t matrix_h = static_cast<int64_t>(X_shape[SafeInt<size_t>(X_num_dims) - 2]);
int64_t matrix_w = static_cast<int64_t>(X_shape[SafeInt<size_t>(X_num_dims) - 1]);
int64_t batch_size = 1;
for (int64_t i = 0; i < X_num_dims - 2; ++i) {
batch_size *= X_shape[i];
batch_size *= X_shape[onnxruntime::narrow<size_t>(i)];
}
int64_t num_matrix_elems = matrix_h * matrix_w;
@ -53,8 +54,8 @@ static Status TriluImpl(const Tensor* X, Tensor* Y, int64_t k_val, bool up) {
auto X_batch_data = X_data + (b * num_matrix_elems);
auto Y_batch_data = Y_data + (b * num_matrix_elems);
auto input_mat = ConstEigenMatrixMapRowMajor<T>(X_batch_data, matrix_h, matrix_w);
auto output_mat = EigenMatrixMapRowMajor<T>(Y_batch_data, matrix_h, matrix_w);
auto input_mat = ConstEigenMatrixMapRowMajor<T>(X_batch_data, onnxruntime::narrow<std::ptrdiff_t>(matrix_h), onnxruntime::narrow<std::ptrdiff_t>(matrix_w));
auto output_mat = EigenMatrixMapRowMajor<T>(Y_batch_data, onnxruntime::narrow<std::ptrdiff_t>(matrix_h), onnxruntime::narrow<std::ptrdiff_t>(matrix_w));
if (X_batch_data != Y_batch_data) {
output_mat = input_mat;
@ -64,14 +65,14 @@ static Status TriluImpl(const Tensor* X, Tensor* Y, int64_t k_val, bool up) {
int64_t start_i = k_val > 0 ? 0 : 1 - k_val;
for (int64_t i = start_i; i < matrix_h; i++) {
for (int64_t j = 0; j < i + k_val && j < matrix_w; j++) {
output_mat(i, j) = 0;
output_mat(onnxruntime::narrow<std::ptrdiff_t>(i), onnxruntime::narrow<std::ptrdiff_t>(j)) = 0;
}
}
} else {
int64_t end_i = std::min(matrix_h, matrix_w - k_val);
for (int64_t i = 0; i < end_i; i++) {
for (int64_t j = std::max(static_cast<int64_t>(0), i + k_val + 1); j < matrix_w; j++) {
output_mat(i, j) = 0;
output_mat(onnxruntime::narrow<std::ptrdiff_t>(i), onnxruntime::narrow<std::ptrdiff_t>(j)) = 0;
}
}
}

64
onnxruntime/core/providers/cpu/tensor/unique.cc
View file

@ -2,8 +2,8 @@
// Licensed under the MIT License.
#include "core/providers/cpu/tensor/unique.h"
#include <map>
#include <core/common/safeint.h>
#include "core/common/gsl.h"
#include "core/framework/op_kernel_type_control_utils.h"
#include "core/providers/common.h"
@ -116,10 +116,10 @@ class Subtensor {
Subtensor(const gsl::span<const T>& data, const TensorShape& subtensor_shape,
int64_t axis, int64_t n_axis, int64_t idx) {
// rows and columns for the slice along axis, flattened to 2D by merging the dimensions before and after the axis
int64_t columns = subtensor_shape.SizeFromDimension(axis);
int64_t rows = subtensor_shape.SizeToDimension(axis);
items_.reserve(rows * columns);
size_t cur_data = idx * columns; // offset into data for first row of slice
int64_t columns = subtensor_shape.SizeFromDimension(onnxruntime::narrow<size_t>(axis));
int64_t rows = subtensor_shape.SizeToDimension(onnxruntime::narrow<size_t>(axis));
items_.reserve(SafeInt<size_t>(rows) * columns);
size_t cur_data = SafeInt<size_t>(idx) * columns; // offset into data for first row of slice
for (int r = 0; r < rows; ++r) {
for (int c = 0; c < columns; ++c) {
@ -127,7 +127,7 @@ class Subtensor {
items_.push_back(data[cur_data + c]);
}
cur_data += columns * n_axis;
cur_data += SafeInt<size_t>(columns) * n_axis;
}
}
@ -169,14 +169,14 @@ static void CreateFlattenedOutput(OpKernelContext& context,
auto unsorted_idx = offsets_iter->second;
auto output_idx = sorted ? i : unsorted_idx;
Y_data[output_idx] = offsets_iter->first;
Y_data[onnxruntime::narrow<size_t>(output_idx)] = offsets_iter->first;
if (indices_out) {
indices_data[output_idx] = indices[unsorted_idx].front();
indices_data[onnxruntime::narrow<size_t>(output_idx)] = indices[onnxruntime::narrow<size_t>(unsorted_idx)].front();
}
if (counts) {
counts_data[output_idx] = indices[unsorted_idx].size();
counts_data[onnxruntime::narrow<size_t>(output_idx)] = indices[onnxruntime::narrow<size_t>(unsorted_idx)].size();
}
}
@ -184,14 +184,14 @@ static void CreateFlattenedOutput(OpKernelContext& context,
if (sorted) {
// need to convert unsorted entries in the inverse index to their sorted values
std::vector<int64_t> unsorted_to_sorted;
unsorted_to_sorted.resize(num_unique);
unsorted_to_sorted.resize(onnxruntime::narrow<size_t>(num_unique));
int64_t sorted_idx = 0;
for (const auto& offset : offsets) {
unsorted_to_sorted[offset.second] = sorted_idx++;
unsorted_to_sorted[onnxruntime::narrow<size_t>(offset.second)] = sorted_idx++;
}
for (size_t i = 0, end = inverse_index.size(); i < end; ++i) {
inverse_indices_data[i] = unsorted_to_sorted[inverse_index[i]];
inverse_indices_data[onnxruntime::narrow<size_t>(i)] = unsorted_to_sorted[onnxruntime::narrow<size_t>(inverse_index[i])];
}
} else {
for (size_t i = 0, end = inverse_index.size(); i < end; ++i) {
@ -212,8 +212,8 @@ static void CreateOutput(OpKernelContext& context,
int64_t num_unique = static_cast<int64_t>(indices.size());
// rows and columns for the slice along axis, flattened to 2D by merging the dimensions before and after the axis
int64_t num_cols = subtensor_shape.SizeFromDimension(axis);
int64_t num_rows = subtensor_shape.SizeToDimension(axis);
int64_t num_cols = subtensor_shape.SizeFromDimension(onnxruntime::narrow<size_t>(axis));
int64_t num_rows = subtensor_shape.SizeToDimension(onnxruntime::narrow<size_t>(axis));
auto subtensor_dims = subtensor_shape.GetDims();
std::vector<int64_t> Y_dims;
@ -222,7 +222,7 @@ static void CreateOutput(OpKernelContext& context,
if (i == axis)
Y_dims.push_back(num_unique);
else
Y_dims.push_back(subtensor_dims[i]);
Y_dims.push_back(subtensor_dims[onnxruntime::narrow<size_t>(i)]);
}
Tensor& Y = *context.Output(0, TensorShape(std::move(Y_dims)));
@ -255,23 +255,23 @@ static void CreateOutput(OpKernelContext& context,
for (int64_t row = 0; row < num_rows; ++row) {
// copy num_cols items from entries to output
if (std::is_same<T, std::string>::value) {
std::copy(item, item + num_cols, &Y_data[out_offset]);
std::copy(item, item + onnxruntime::narrow<size_t>(num_cols), &Y_data[onnxruntime::narrow<size_t>(out_offset)]);
} else {
std::copy_n(item, num_cols, &Y_data[out_offset]);
std::copy_n(item, onnxruntime::narrow<size_t>(num_cols), &Y_data[onnxruntime::narrow<size_t>(out_offset)]);
}
item += num_cols;
item += onnxruntime::narrow<size_t>(num_cols);
out_offset += num_unique * num_cols;
}
assert(item == items.cend());
if (indices_out) {
indices_data[output_idx] = indices[unsorted_idx].front();
indices_data[onnxruntime::narrow<size_t>(output_idx)] = indices[onnxruntime::narrow<size_t>(unsorted_idx)].front();
}
if (counts) {
counts_data[output_idx] = indices[unsorted_idx].size();
counts_data[onnxruntime::narrow<size_t>(output_idx)] = indices[onnxruntime::narrow<size_t>(unsorted_idx)].size();
}
}
@ -279,14 +279,14 @@ static void CreateOutput(OpKernelContext& context,
if (sorted) {
// need to convert unsorted entries in the inverse index to their sorted values
std::vector<int64_t> unsorted_to_sorted;
unsorted_to_sorted.resize(num_unique);
unsorted_to_sorted.resize(onnxruntime::narrow<size_t>(num_unique));
int64_t sorted_idx = 0;
for (const auto& offset : offsets) {
unsorted_to_sorted[offset.second] = sorted_idx++;
unsorted_to_sorted[onnxruntime::narrow<size_t>(offset.second)] = sorted_idx++;
}
for (size_t i = 0, end = inverse_index.size(); i < end; ++i) {
inverse_indices_data[i] = unsorted_to_sorted[inverse_index[i]];
inverse_indices_data[i] = unsorted_to_sorted[onnxruntime::narrow<size_t>(inverse_index[i])];
}
} else {
for (size_t i = 0, end = inverse_index.size(); i < end; ++i) {
@ -316,16 +316,16 @@ Status Unique::ComputeImpl(OpKernelContext& context) const {
int64_t num_unique = 0;
for (int64_t i = 0, end = input.Shape().Size(); i < end; ++i) {
auto entry = offsets.find(data[i]);
auto entry = offsets.find(data[onnxruntime::narrow<size_t>(i)]);
if (entry == offsets.end()) {
offsets[data[i]] = num_unique;
offsets[data[onnxruntime::narrow<size_t>(i)]] = num_unique;
inverse_index.push_back({num_unique});
indices.push_back({i});
++num_unique;
} else {
size_t indices_idx = entry->second;
size_t indices_idx = onnxruntime::narrow<size_t>(entry->second);
indices[indices_idx].push_back(i);
inverse_index.push_back(indices_idx);
inverse_index.push_back(onnxruntime::narrow<int64_t>(indices_idx));
}
}
@ -336,9 +336,9 @@ Status Unique::ComputeImpl(OpKernelContext& context) const {
const int64_t axis = HandleNegativeAxis(axis_, input_dims);
std::vector<int64_t> subtensor_dims;
subtensor_dims.reserve(input_dims);
subtensor_dims.reserve(onnxruntime::narrow<size_t>(input_dims));
for (int64_t i = 0; i < input_dims; ++i) {
subtensor_dims.push_back(i == axis ? 1 : input_shape[i]);
subtensor_dims.push_back(i == axis ? 1 : input_shape[onnxruntime::narrow<size_t>(i)]);
}
TensorShape subtensor_shape(std::move(subtensor_dims));
@ -351,7 +351,7 @@ Status Unique::ComputeImpl(OpKernelContext& context) const {
inverse_index.reserve(data.size());
int64_t num_unique = 0;
int64_t n_axis = input_shape[axis];
int64_t n_axis = input_shape[onnxruntime::narrow<size_t>(axis)];
for (int64_t i = 0; i < n_axis; ++i) {
Subtensor<T> s(data, subtensor_shape, axis, n_axis, i);
@ -363,9 +363,9 @@ Status Unique::ComputeImpl(OpKernelContext& context) const {
indices.push_back({i});
++num_unique;
} else {
size_t indices_idx = entry->second;
size_t indices_idx = onnxruntime::narrow<size_t>(entry->second);
indices[indices_idx].push_back(i);
inverse_index.push_back(indices_idx);
inverse_index.push_back(onnxruntime::narrow<int64_t>(indices_idx));
}
}

6
onnxruntime/core/providers/cpu/tensor/unsqueeze.cc
View file

@ -62,12 +62,12 @@ Status UnsqueezeBase::PrepareCompute(OpKernelContext* ctx, Prepare& p) const {
// Set all axes indices to 1 in output_dims and check for duplicates
for (int64_t axis : axes) {
// Valid axis range is [0, output_rank - 1]
axis = HandleNegativeAxis(axis, output_dims.size());
axis = HandleNegativeAxis(axis, onnxruntime::narrow<int64_t>(output_dims.size()));
if (axis < 0 || axis >= static_cast<int64_t>(output_dims.size()))
return Status(ONNXRUNTIME, INVALID_ARGUMENT, "'axes' has an out of range axis");
if (output_dims[axis] != 0)
if (output_dims[onnxruntime::narrow<size_t>(axis)] != 0)
return Status(ONNXRUNTIME, INVALID_ARGUMENT, "'axes' has a duplicate axis");
output_dims[axis] = 1;
output_dims[onnxruntime::narrow<size_t>(axis)] = 1;
}
// Now fill in the zero entries with the existing shape

4
onnxruntime/core/providers/cpu/tensor/upsample.cc
View file

@ -66,7 +66,7 @@ static std::vector<int64_t> UpsampleNearestSetupRank1InputMapping(
bool extrapolation_enabled,
const GetOriginalCoordinateFunc& get_original_coordinate,
const GetNearestPixelFunc& get_nearest_pixel) {
std::vector<int64_t> input_mapping(length_resized);
std::vector<int64_t> input_mapping(onnxruntime::narrow<size_t>(length_resized));
for (int64_t output_dim0_idx = 0; output_dim0_idx < length_resized; ++output_dim0_idx) {
float original_0_idx = get_original_coordinate(static_cast<float>(output_dim0_idx),
@ -234,7 +234,7 @@ static Status UpsampleNearestImpl(const T* input,
return Status::OK();
}
std::vector<int64_t> output_dim_counter(n_dim);
std::vector<int64_t> output_dim_counter(onnxruntime::narrow<size_t>(n_dim));
for (int64_t dim_idx = 0; dim_idx < n_dim; dim_idx++) {
input_idx += input_mappings[narrow<size_t>(dim_idx)][0 /* output_dim_counter[narrow<size_t>(dim_idx)] */];
}

10
onnxruntime/core/providers/cpu/tensor/upsamplebase.h
View file

@ -5,6 +5,8 @@
#include <string>
#include <vector>
#include <core/common/safeint.h>
#include <core/common/narrow.h>
#ifndef SHARED_PROVIDER
#include "core/framework/op_kernel.h"
#endif
@ -318,17 +320,17 @@ class UpsampleBase {
int64_t scales_size = scale->Shape().Size();
ORT_ENFORCE(scales_size > 0, "scales size should be greater than 0.");
if (scales.empty()) {
scales.resize(scales_size);
scales.resize(onnxruntime::narrow<size_t>(scales_size));
}
memcpy(scales.data(), scale_data, scales_size * sizeof(float));
memcpy(scales.data(), scale_data, SafeInt<size_t>(scales_size) * sizeof(float));
ScalesValidation(scales, mode_);
}
void ParseRoiData(const Tensor* roi, std::vector<float>& roi_array) const {
int64_t roi_size = roi->Shape().Size();
if (roi_size > 0) {
roi_array.resize(roi_size);
memcpy(roi_array.data(), roi->Data<float>(), roi_size * sizeof(float));
roi_array.resize(onnxruntime::narrow<size_t>(roi_size));
memcpy(roi_array.data(), roi->Data<float>(), SafeInt<size_t>(roi_size) * sizeof(float));
}
}

8
onnxruntime/core/util/qmath.h
View file

@ -5,7 +5,7 @@
#include "core/mlas/inc/mlas.h"
#include "core/platform/threadpool.h"
#include "core/common/narrow.h"
#include <cmath>
namespace onnxruntime {
@ -51,12 +51,12 @@ void GetQuantizationParameter(const float* data, int64_t num_of_elements, float&
std::ptrdiff_t block_size;
std::ptrdiff_t num_blocks;
if (concurrency::ThreadPool::ShouldParallelize(thread_pool) && num_of_elements > granularity) {
block_size = (num_of_elements + MAX_DEGREE_OF_PAR_FOR_MINMAX - 1) / MAX_DEGREE_OF_PAR_FOR_MINMAX;
block_size = onnxruntime::narrow<std::ptrdiff_t>((num_of_elements + MAX_DEGREE_OF_PAR_FOR_MINMAX - 1) / MAX_DEGREE_OF_PAR_FOR_MINMAX);
block_size = (block_size + granularity - 1) / granularity * granularity;
num_blocks = (num_of_elements + block_size - 1) / block_size;
num_blocks = onnxruntime::narrow<std::ptrdiff_t>((num_of_elements + block_size - 1) / block_size);
} else {
num_blocks = 1;
block_size = num_of_elements;
block_size = onnxruntime::narrow<std::ptrdiff_t>(num_of_elements);
}
for (int i = 0; i < num_blocks; i++) {