saymrwulf/onnxruntime
1
0
Fork 0
mirror of https://github.com/saymrwulf/onnxruntime.git synced 2026-07-24 19:43:35 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Fix Windows x86 compiler warnings in the optimizers project (#6377)

Browse source
This commit is contained in:
Hariharan Seshadri 2021-01-21 07:20:16 +05:30 committed by GitHub
parent 33f60a06d5
commit d9e4795385
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
8 changed files with 23 additions and 24 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
cmake/onnxruntime_optimizer.cmake
View file

@ -30,9 +30,6 @@ add_library(onnxruntime_optimizer ${onnxruntime_optimizer_srcs})
install(DIRECTORY ${PROJECT_SOURCE_DIR}/../include/onnxruntime/core/optimizer DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/onnxruntime/core)
onnxruntime_add_include_to_target(onnxruntime_optimizer onnxruntime_common onnxruntime_framework onnx onnx_proto protobuf::libprotobuf flatbuffers)
if (MSVC AND NOT CMAKE_SIZEOF_VOID_P EQUAL 8)
target_compile_options(onnxruntime_optimizer PRIVATE "/wd4244")
endif()
target_include_directories(onnxruntime_optimizer PRIVATE ${ONNXRUNTIME_ROOT})
if (onnxruntime_ENABLE_TRAINING)
target_include_directories(onnxruntime_optimizer PRIVATE ${ORTTRAINING_ROOT})

1
onnxruntime/contrib_ops/cpu/bert/attention.cc
View file

@ -179,7 +179,6 @@ template <typename T>
Attention<T>::Attention(const OpKernelInfo& info) : OpKernel(info), AttentionCPUBase(info) {
}
template <typename T>
Status Attention<T>::PrePack(const Tensor& weights, int input_idx, bool& is_packed) {
is_packed = false;

8
onnxruntime/core/optimizer/attention_fusion.cc
View file

@ -120,25 +120,25 @@ static NodeArg& MergeQkvWeights(Graph& graph, int64_t hidden_size,
const float* k_weight = k_initializer.data<float>();
const float* v_weight = v_initializer.data<float>();
std::vector<float> result;
result.reserve(element_count);
result.reserve(gsl::narrow<size_t>(element_count));
if (is_matmul) {
MergeMatMulWeights<float>(q_weight, k_weight, v_weight, result, hidden_size);
} else {
MergeWeights<float>(q_weight, k_weight, v_weight, result, hidden_size);
}
initializer.set_raw_data(result.data(), element_count * sizeof(float));
initializer.set_raw_data(result.data(), gsl::narrow<size_t>(element_count) * sizeof(float));
} else { // data_type == ONNX_NAMESPACE::TensorProto_DataType_FLOAT16
const MLFloat16* q_weight = q_initializer.data<MLFloat16>();
const MLFloat16* k_weight = k_initializer.data<MLFloat16>();
const MLFloat16* v_weight = v_initializer.data<MLFloat16>();
std::vector<MLFloat16> result;
result.reserve(element_count);
result.reserve(gsl::narrow<size_t>(element_count));
if (is_matmul) {
MergeMatMulWeights<MLFloat16>(q_weight, k_weight, v_weight, result, hidden_size);
} else {
MergeWeights<MLFloat16>(q_weight, k_weight, v_weight, result, hidden_size);
}
initializer.set_raw_data(result.data(), element_count * sizeof(MLFloat16));
initializer.set_raw_data(result.data(), gsl::narrow<size_t>(element_count) * sizeof(MLFloat16));
}
return graph_utils::AddInitializer(graph, initializer);

9
onnxruntime/core/optimizer/embed_layer_norm_fusion.cc
View file

@ -7,6 +7,7 @@
#include "core/optimizer/utils.h"
#include "core/framework/tensorprotoutils.h"
#include "float.h"
#include "core/common/safeint.h"
#define DEBUG_LOG(x) LOGS(logger, VERBOSE) << x
@ -427,8 +428,8 @@ static bool MatchPositionEmbeddingSubgraph(
template <typename T>
bool CheckEmbeddingData(const T* data, int64_t batch_size, int64_t element_count) {
// check that all batches has same data.
size_t data_length = batch_size * element_count;
for (size_t i = element_count; i < data_length; i++) {
size_t data_length = SafeInt<size_t>(batch_size) * element_count;
for (size_t i = gsl::narrow<size_t>(element_count); i < data_length; i++) {
if (data[i] != data[i % element_count]) {
return false;
}
@ -463,14 +464,14 @@ static NodeArg* ExtractEmbedding(Graph& graph,
return nullptr;
}
initializer.set_raw_data(data, element_count * sizeof(float));
initializer.set_raw_data(data, gsl::narrow<size_t>(element_count) * sizeof(float));
} else { // data_type == ONNX_NAMESPACE::TensorProto_DataType_FLOAT16
const MLFloat16* data = old_initializer.data<MLFloat16>();
if (!CheckEmbeddingData(data, batch_size, element_count)) {
return nullptr;
}
initializer.set_raw_data(data, element_count * sizeof(MLFloat16));
initializer.set_raw_data(data, gsl::narrow<size_t>(element_count) * sizeof(MLFloat16));
}
NodeArg& node_arg = graph_utils::AddInitializer(graph, initializer);

5
onnxruntime/core/optimizer/matmul_transpose_fusion.cc
View file

@ -55,14 +55,15 @@ static Node* GetTransposeNodeFromOutput(Graph& graph, NodeArg& node_arg) {
bool is_trans_on_last_two_dims = true;
for (int64_t i = 0; i < rank - 2; i++) {
if (perms[i] != i) {
if (perms[static_cast<size_t>(i)] != i) {
is_trans_on_last_two_dims = false;
break;
}
}
if (is_trans_on_last_two_dims) {
is_trans_on_last_two_dims = perms[rank - 2] == rank - 1 && perms[rank - 1] == rank - 2;
// rank is atleast 2 (checked above) and so it is safe to cast (rank - 2) and (rank - 1) to size_t
is_trans_on_last_two_dims = perms[static_cast<size_t>(rank - 2)] == rank - 1 && perms[static_cast<size_t>(rank - 1)] == rank - 2;
}
if (!is_trans_on_last_two_dims) {

13
onnxruntime/core/optimizer/nchwc_transformer.cc
View file

@ -369,7 +369,8 @@ void NchwcTransformerImpl::TransformConv(Node& node) {
} else {
Initializer conv_W{*conv_W_tensor_proto, graph_.ModelPath()};
std::vector<float> reordered_filter(conv_W.size() / output_channels * nchwc_output_channels);
int64_t reordered_filter_vec_size = conv_W.size() / output_channels * nchwc_output_channels;
std::vector<float> reordered_filter(gsl::narrow<size_t>(reordered_filter_vec_size));
// Reorder the weights tensor statically.
if (reorder_filter_OIHWBo) {
@ -403,14 +404,14 @@ void NchwcTransformerImpl::TransformConv(Node& node) {
} else {
Initializer conv_B{*conv_B_tensor_proto, graph_.ModelPath()};
std::vector<float> aligned_bias(nchwc_output_channels);
std::vector<float> aligned_bias(gsl::narrow<size_t>(nchwc_output_channels));
std::copy_n(conv_B.data<float>(), output_channels, aligned_bias.data());
ONNX_NAMESPACE::TensorProto nchwc_conv_B_tensor_proto;
nchwc_conv_B_tensor_proto.set_data_type(ONNX_NAMESPACE::TensorProto_DataType_FLOAT);
nchwc_conv_B_tensor_proto.set_name(graph_.GenerateNodeArgName("reorder"));
nchwc_conv_B_tensor_proto.set_raw_data(aligned_bias.data(), nchwc_output_channels * sizeof(float));
nchwc_conv_B_tensor_proto.set_raw_data(aligned_bias.data(), gsl::narrow<size_t>(nchwc_output_channels) * sizeof(float));
nchwc_conv_B_tensor_proto.add_dims(nchwc_output_channels);
@ -747,14 +748,14 @@ void NchwcTransformerImpl::TransformBatchNormalization(Node& node) {
const size_t nchwc_block_size = MlasNchwcGetBlockSize();
const int64_t nchwc_channels = (channels + nchwc_block_size - 1) & ~(nchwc_block_size - 1);
std::vector<float> padded_buffer(nchwc_channels);
std::vector<float> padded_buffer(gsl::narrow<size_t>(nchwc_channels));
std::copy_n(bn_scale.data<float>(), channels, padded_buffer.data());
ONNX_NAMESPACE::TensorProto nchwc_conv_W_tensor_proto;
nchwc_conv_W_tensor_proto.set_data_type(ONNX_NAMESPACE::TensorProto_DataType_FLOAT);
nchwc_conv_W_tensor_proto.set_name(graph_.GenerateNodeArgName("bn_scale"));
nchwc_conv_W_tensor_proto.set_raw_data(padded_buffer.data(), nchwc_channels * sizeof(float));
nchwc_conv_W_tensor_proto.set_raw_data(padded_buffer.data(), gsl::narrow<size_t>(nchwc_channels) * sizeof(float));
nchwc_conv_W_tensor_proto.add_dims(nchwc_channels);
nchwc_conv_W_tensor_proto.add_dims(1);
nchwc_conv_W_tensor_proto.add_dims(1);
@ -767,7 +768,7 @@ void NchwcTransformerImpl::TransformBatchNormalization(Node& node) {
ONNX_NAMESPACE::TensorProto nchwc_conv_B_tensor_proto;
nchwc_conv_B_tensor_proto.set_data_type(ONNX_NAMESPACE::TensorProto_DataType_FLOAT);
nchwc_conv_B_tensor_proto.set_name(graph_.GenerateNodeArgName("bn_B"));
nchwc_conv_B_tensor_proto.set_raw_data(padded_buffer.data(), nchwc_channels * sizeof(float));
nchwc_conv_B_tensor_proto.set_raw_data(padded_buffer.data(), gsl::narrow<size_t>(nchwc_channels) * sizeof(float));
nchwc_conv_B_tensor_proto.add_dims(nchwc_channels);
auto* nchwc_conv_B_arg = &graph_utils::AddInitializer(graph_, nchwc_conv_B_tensor_proto);

4
onnxruntime/core/optimizer/unsqueeze_elimination.cc
View file

@ -17,7 +17,7 @@ Status UnsqueezeElimination::Apply(Graph& graph, Node& node, RewriteRuleEffect&
auto new_name = graph.GenerateNodeArgName("UnsqueezeElimination_" + input_def.Name());
if (!graph_utils::CanReplaceNodeWithInitializer(graph, node, new_name, logger)) {
LOGS(logger, WARNING) << "UnsqueezeElimination cannot remove node " << node.Name();
LOGS(logger, WARNING) << "UnsqueezeElimination cannot remove node " << node.Name();
return Status::OK();
}
@ -40,7 +40,7 @@ Status UnsqueezeElimination::Apply(Graph& graph, Node& node, RewriteRuleEffect&
// Generate new dims.
std::vector<int64_t> new_dims(output_rank, 0);
for (int64_t axis : axes) {
new_dims[axis] = 1;
new_dims[static_cast<size_t>(axis)] = 1;
}
auto begin = tensor_proto.dims().cbegin();

4
onnxruntime/core/optimizer/utils.cc
View file

@ -173,11 +173,11 @@ bool AppendTensorFromInitializer(const Graph& graph, const NodeArg& input_arg, s
const auto data_type = tensor_proto->data_type();
if (data_type == ONNX_NAMESPACE::TensorProto_DataType_INT64) {
const int64_t* val = init_const.data<int64_t>();
data.reserve(data.size() + init_const.size());
data.reserve(data.size() + gsl::narrow<size_t>(init_const.size()));
data.insert(data.end(), val, val + init_const.size());
} else if (data_type == ONNX_NAMESPACE::TensorProto_DataType_INT32) {
const int32_t* val = init_const.data<int32_t>();
data.reserve(data.size() + init_const.size());
data.reserve(data.size() + gsl::narrow<size_t>(init_const.size()));
for (int64_t i = 0; i < init_const.size(); i++) {
data.push_back(static_cast<int64_t>(val[i]));
}