IntenseWebs/openvino
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

[GNA] Remove warning suppression, fix all warnings (#17841)

Browse Source 
* Removed /wd4661 suppression which had no effect

* Fixed /wd4018, /wd4099 and /wd4200 (signed/unsigned mismatch)

* Fixed /wd4018, /wd4099 and /wd4200

* Fixed -Wparentheses

* Fixed -Wcomment

* Fixed -Wint-in-bool-context

* Fixed -Wsign-compare
This commit is contained in:
Ryszard Jezierski 2023-06-23 13:07:02 +02:00 committed by GitHub
parent 3c378eb7ac
commit 284ab25f8f
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
57 changed files with 538 additions and 500 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
src/plugins/intel_gna/CMakeLists.txt
View File

@ -14,27 +14,6 @@ if (ENABLE_INTEL_GNA_DEBUG)
add_compile_definitions(GNA_DEBUG)
endif()
if(CMAKE_COMPILER_IS_GNUCC)
ie_add_compiler_flags(-Wno-sign-compare)
ie_add_compiler_flags(-Wno-parentheses)
ie_add_compiler_flags(-Wno-comment)
ie_add_compiler_flags(-Wno-int-in-bool-context)
elseif(OV_COMPILER_IS_CLANG)
ie_add_compiler_flags(-Wno-int-in-bool-context)
elseif(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
# C4267, 4244 issues from mkl-dnn headers conversion from 'XXX' to 'YYY', possible loss of data
ie_add_compiler_flags(/wd4267)
ie_add_compiler_flags(/wd4244)
# '<': signed/unsigned mismatch
ie_add_compiler_flags(/wd4018)
ie_add_compiler_flags(/wd4099)
ie_add_compiler_flags(/wd4200)
# C4661: no suitable definition provided for explicit template instantiation request
ie_add_compiler_flags(/wd4661)
# C4297: function assumed not to throw an exception but does
ie_add_compiler_flags(/wd4297)
endif()
file(GLOB_RECURSE SOURCES
${CMAKE_CURRENT_SOURCE_DIR}/src/*.cpp)

14
src/plugins/intel_gna/src/backend/am_intel_dnn.cpp
View File

@ -509,7 +509,7 @@ void AMIntelDNN::WriteGraphWizModel(const char* filename) {
std::map<void*, InputEndPoint> outputs;
std::set<std::string> layersNames;
auto generate_layer_name = [&](int k) {
auto generate_layer_name = [&](size_t k) {
std::string l;
if (components[k].operation == kDnnPiecewiselinearOp) {
l += intel_dnn_activation_name[components[k].op.pwl.func_id];
@ -574,7 +574,7 @@ void AMIntelDNN::WriteGraphWizModel(const char* filename) {
return l;
};
for (int k = 0; k < components.size(); ++k) {
for (size_t k = 0; k < components.size(); ++k) {
std::string l = generate_layer_name(k);
layersNames.insert(l);
int lidx = static_cast<int>(std::distance(layersNames.begin(), layersNames.find(l)));
@ -602,7 +602,7 @@ void AMIntelDNN::WriteGraphWizModel(const char* filename) {
bool inputConnected = false;
for (int k2 = 0; k2 < components.size(); ++k2) {
for (size_t k2 = 0; k2 < components.size(); ++k2) {
if (k2 == k)
continue;
@ -658,7 +658,7 @@ void AMIntelDNN::WriteGraphWizModel(const char* filename) {
}
if (!inputConnected) {
// searching for TMP connection
size_t tidx = -1;
size_t tidx = std::numeric_limits<size_t>::max();
for (auto&& en : outputs) {
if (intersected(en.first, en.second.size, INPUTS(k))) {
tidx = en.second.idx;
@ -671,7 +671,7 @@ void AMIntelDNN::WriteGraphWizModel(const char* filename) {
}
}
if (tidx == -1) {
if (tidx == std::numeric_limits<size_t>::max()) {
outputs[components[k].ptr_inputs] = InputEndPoint(static_cast<int>(outputs.size()),
sizeofTensor(INPUTS(k)),
components[k].num_bytes_per_input);
@ -681,7 +681,7 @@ void AMIntelDNN::WriteGraphWizModel(const char* filename) {
}
}
for (int k = 0; k < components.size(); ++k) {
for (size_t k = 0; k < components.size(); ++k) {
std::string l = generate_layer_name(k);
int tidx = 0;
@ -1386,7 +1386,7 @@ void AMIntelDNN::InitGNAStruct(Gna2Model* gnaModel) {
THROW_GNA_EXCEPTION << "out of memory in AMIntelDNN::InitGNAStruct()";
memset(gnaModel->Operations, 0, gnaModel->NumberOfOperations * sizeof(Gna2Operation));
gnaOperation = gnaModel->Operations;
for (int i = 0; i < component.size(); i++) {
for (size_t i = 0; i < component.size(); i++) {
log::debug() << "Component + " << i << "=GNA_" << std::distance(gnaModel->Operations, gnaOperation) << "\n";
auto& comp = component[i];

6
src/plugins/intel_gna/src/backend/am_intel_dnn.hpp
View File

@ -272,14 +272,14 @@ public:
}
template <class T>
void AdvanceOperationIfAllApplied(const std::vector<intel_dnn_component_t>& cmp, int i, T*& operation) {
void AdvanceOperationIfAllApplied(const std::vector<intel_dnn_component_t>& cmp, size_t i, T*& operation) {
if (i == cmp.size() - 1 || cmp[i + 1].operation != kDnnPiecewiselinearOp) {
++operation;
}
}
template <class T>
void AdvanceCnnOperationIfAllApplied(const std::vector<intel_dnn_component_t>& cmp, int i, T*& operation) {
void AdvanceCnnOperationIfAllApplied(const std::vector<intel_dnn_component_t>& cmp, size_t i, T*& operation) {
if (i == cmp.size() - 1 ||
((cmp[i + 1].operation != kDnnMaxPoolOp) && (cmp[i + 1].operation != kDnnPiecewiselinearOp))) {
operation++;
@ -287,7 +287,7 @@ public:
}
template <class T>
void AdvancePwlOperationIfAllApplied(const std::vector<intel_dnn_component_t>& cmp, int i, T*& operation) {
void AdvancePwlOperationIfAllApplied(const std::vector<intel_dnn_component_t>& cmp, size_t i, T*& operation) {
if (i == cmp.size() - 1 ||
((cmp[i + 1].operation != kDnnMaxPoolOp) && (cmp[i + 1].operation != kDnnPiecewiselinearOp))) {
operation++;

60
src/plugins/intel_gna/src/backend/gna_limitations.cpp
View File

@ -785,7 +785,8 @@ bool Limitations::is_conv_supported(const std::shared_ptr<ngraph::op::Convolutio
auto check_dilation = [&](size_t filter_dilation_height, size_t filter_stride_width) -> bool {
cnn2d::RangeLimit2D dilation_limit{{kConvDilationHeight, kConvDilationHeight, "dilation height"},
{kConvDilationWidth, kConvDilationWidth, "dilation width"}};
std::string error = dilation_limit.GetErrorOrEmpty(filter_dilation_height, filter_stride_width);
std::string error = dilation_limit.GetErrorOrEmpty(static_cast<uint32_t>(filter_dilation_height),
static_cast<uint32_t>(filter_stride_width));
return cnn2d::AbstractValidator::ValidationSuccesful(is_exception_allowed,
error,
conv_ie->get_friendly_name(),
@ -797,28 +798,28 @@ bool Limitations::is_conv_supported(const std::shared_ptr<ngraph::op::Convolutio
(4 == input_shape.size() && input_shape[2] > 1 && input_shape[3] > 1)) {
pass::helper::ConvData conv_data;
pass::helper::GetConvData(conv_ie, conv_data);
if (gna_convolution_layer::isMappableFrom2DTo1D(conv_data.input_height,
conv_data.input_width,
conv_data.input_channel_count,
conv_data.filter_height,
conv_data.filter_width,
conv_data.filter_stride_height,
conv_data.filter_stride_width)) {
if (gna_convolution_layer::isMappableFrom2DTo1D(static_cast<uint32_t>(conv_data.input_height),
static_cast<uint32_t>(conv_data.input_width),
static_cast<uint32_t>(conv_data.input_channel_count),
static_cast<uint32_t>(conv_data.filter_height),
static_cast<uint32_t>(conv_data.filter_width),
static_cast<uint32_t>(conv_data.filter_stride_height),
static_cast<uint32_t>(conv_data.filter_stride_width))) {
return check_dilation(conv_data.filter_dilation_height, conv_data.filter_dilation_width);
}
if (m_cnn_validator) {
return m_cnn_validator->ValidateCnn2D(conv_ie->get_friendly_name(),
conv_data.input_height,
conv_data.input_width,
conv_data.input_channel_count,
conv_data.filter_height,
conv_data.filter_width,
conv_data.filter_channel_count,
conv_data.filter_stride_height,
conv_data.filter_stride_width,
conv_data.filter_dilation_height,
conv_data.filter_dilation_width,
static_cast<uint32_t>(conv_data.input_height),
static_cast<uint32_t>(conv_data.input_width),
static_cast<uint32_t>(conv_data.input_channel_count),
static_cast<uint32_t>(conv_data.filter_height),
static_cast<uint32_t>(conv_data.filter_width),
static_cast<uint32_t>(conv_data.filter_channel_count),
static_cast<uint32_t>(conv_data.filter_stride_height),
static_cast<uint32_t>(conv_data.filter_stride_width),
static_cast<uint32_t>(conv_data.filter_dilation_height),
static_cast<uint32_t>(conv_data.filter_dilation_width),
OvGnaTypeIntFromBytes(gna_precision.size()),
is_exception_allowed);
}
@ -834,10 +835,10 @@ bool Limitations::is_pooling_supported(const std::shared_ptr<ngraph::opset7::Max
if (m_cnn_validator) {
auto strides = max_pool->get_strides();
return m_cnn_validator->ValidatePooling2D(max_pool->get_friendly_name(),
kernels[0],
kernels[1],
strides[0],
strides[1],
static_cast<uint32_t>(kernels[0]),
static_cast<uint32_t>(kernels[1]),
static_cast<uint32_t>(strides[0]),
static_cast<uint32_t>(strides[1]),
is_exception_allowed);
}
}
@ -944,8 +945,9 @@ bool Limitations::validate_concat_axis(const InferenceEngine::CNNLayerPtr layer,
ptr->GetParamAsInts("order") == std::vector<int32_t>{0, 2, 1} /* NCW to NWC */))));
};
for (auto input_idx = 0; input_idx != concat_layer->insData.size(); input_idx++) {
prev_layer = InferenceEngine::CNNNetPrevLayerSkipCertain(layer, input_idx, isFusableWithConv);
for (size_t input_idx = 0; input_idx != concat_layer->insData.size(); input_idx++) {
prev_layer =
InferenceEngine::CNNNetPrevLayerSkipCertain(layer, static_cast<int>(input_idx), isFusableWithConv);
if (prev_layer && LayerInfo(prev_layer).isConvolution())
return true;
}
@ -975,12 +977,12 @@ bool Limitations::validate_concat_axis(const InferenceEngine::CNNLayerPtr layer,
} else {
concat_all_const_or_inputs = true;
for (auto input_idx = 0; input_idx != concat_layer->insData.size(); input_idx++) {
for (size_t input_idx = 0; input_idx != concat_layer->insData.size(); input_idx++) {
if (concat_layer->insData[input_idx].lock()->getDims()[0] != 1) {
// First we're checking concat input layers
prev_layer = InferenceEngine::CNNNetPrevLayerSkipCertain(
concat_layer,
input_idx,
static_cast<int>(input_idx),
[](InferenceEngine::CNNLayerPtr ptr) {
return LayerInfo(ptr).isNonFunctional() || LayerInfo(ptr).isFakeQuantize();
});
@ -1076,9 +1078,11 @@ bool Limitations::validate_conv_concat_axis(const InferenceEngine::ConcatLayer*
auto concat_axis = concat_layer->_axis;
auto concat_layout = concat_layer->input()->getLayout();
for (auto input_idx = 0; input_idx != concat_layer->insData.size(); input_idx++) {
for (size_t input_idx = 0; input_idx != concat_layer->insData.size(); input_idx++) {
// Supported cases for concatenation of a convolution
prev_layer = InferenceEngine::CNNNetPrevLayerSkipCertain(concat_layer, input_idx, isFusableWithConv);
prev_layer = InferenceEngine::CNNNetPrevLayerSkipCertain(concat_layer,
static_cast<int>(input_idx),
isFusableWithConv);
if (prev_layer && LayerInfo(prev_layer).isConvolution()) {
// Allow concatenation along N axis for non-interleaved primitives
// (currently only convolution)

49
src/plugins/intel_gna/src/backend/make_pwl.cpp
View File

@ -128,24 +128,24 @@ void make_gna_pwl(const DnnActivation& fun,
int16_t y_upper = y_max;
if (fun.fqParams.set) {
x_lower = static_cast<int32_t>(
std::max(FloatToInt64(*fun.fqParams.input_low * 1.25 * in_scale), static_cast<int64_t>(x_lower)));
std::max(DoubleToInt64(*fun.fqParams.input_low * 1.25 * in_scale), static_cast<int64_t>(x_lower)));
x_upper = static_cast<int32_t>(
std::min(FloatToInt64(*fun.fqParams.input_high * 1.25 * in_scale), static_cast<int64_t>(x_upper)));
std::min(DoubleToInt64(*fun.fqParams.input_high * 1.25 * in_scale), static_cast<int64_t>(x_upper)));
// y_lower can be reduced with negative slope
y_lower = static_cast<int32_t>(*fun.fqParams.input_low * 1.25 * out_scale);
y_upper = static_cast<int16_t>(
std::min(FloatToInt32(*fun.fqParams.input_high * 1.25 * out_scale), static_cast<int32_t>(y_upper)));
std::min(DoubleToInt32(*fun.fqParams.input_high * 1.25 * out_scale), static_cast<int32_t>(y_upper)));
} else {
if (x_lower < y_lower * in_scale / out_scale)
x_lower = FloatToInt32(y_lower * in_scale / out_scale);
x_lower = DoubleToInt32(y_lower * in_scale / out_scale);
if (y_lower < x_lower * out_scale / in_scale)
y_lower = FloatToInt16(x_lower * out_scale / in_scale);
y_lower = DoubleToInt16(x_lower * out_scale / in_scale);
}
gna_pwl[0].yBase = std::max(FloatToInt32(y_lower * fun.args.lrelu.negative_slope), static_cast<int32_t>(y_min));
s = gna_slope(fun.args.lrelu.negative_slope, in_scale, out_scale);
gna_pwl[0].xBase = (x_lower & XBASEMASK) | s.slope_scale_index; // zero out the 2 lsb
gna_pwl[0].slope = FloatToInt16(s.slope * s.slope_scale);
gna_pwl[0].slope = DoubleToInt16(s.slope * s.slope_scale);
print_segment((int32_t)(gna_pwl[0].xBase & XBASEMASK) / in_scale,
gna_pwl[0].yBase / out_scale,
@ -154,7 +154,7 @@ void make_gna_pwl(const DnnActivation& fun,
gna_pwl[1].xBase = 0;
gna_pwl[1].yBase = 0;
s = gna_slope(1.0, in_scale, out_scale);
gna_pwl[1].slope = FloatToInt16(s.slope * s.slope_scale);
gna_pwl[1].slope = DoubleToInt16(s.slope * s.slope_scale);
gna_pwl[1].xBase = gna_pwl[1].xBase | s.slope_scale_index;
print_segment(0.0, 0.0, (gna_pwl[1].slope * in_scale) / (out_scale * s.slope_scale));
@ -204,10 +204,11 @@ void make_gna_pwl(const DnnActivation& fun,
int32_t x_upper = INT32_MAX;
int16_t y_lower = y_min;
int16_t y_upper = y_max;
if (kActFakeQuantize && fun.fqParams.set) {
x_lower = std::max(static_cast<int64_t>(*fun.fqParams.input_low * in_scale), static_cast<int64_t>(x_lower));
x_upper =
std::min(static_cast<int64_t>(*fun.fqParams.input_high * in_scale), static_cast<int64_t>(x_upper));
if (fun.fqParams.set) {
x_lower = static_cast<int32_t>(
std::max(static_cast<int64_t>(*fun.fqParams.input_low * in_scale), static_cast<int64_t>(x_lower)));
x_upper = static_cast<int32_t>(
std::min(static_cast<int64_t>(*fun.fqParams.input_high * in_scale), static_cast<int64_t>(x_upper)));
y_lower =
std::max(static_cast<int32_t>(*fun.fqParams.input_low * out_scale), static_cast<int32_t>(y_lower));
y_upper =
@ -217,18 +218,18 @@ void make_gna_pwl(const DnnActivation& fun,
if (fun == kActKaldiLstmClipping) {
if (x_lower < l_bound * in_scale) {
if (y_lower < l_bound * out_scale) {
x_lower = FloatToInt32(l_bound * in_scale);
y_lower = FloatToInt16(l_bound * out_scale);
x_lower = DoubleToInt32(l_bound * in_scale);
y_lower = DoubleToInt16(l_bound * out_scale);
} else {
x_lower = FloatToInt32(y_lower * in_scale / out_scale);
x_lower = DoubleToInt32(y_lower * in_scale / out_scale);
}
}
if (x_upper > u_bound * in_scale) {
if (y_upper > u_bound * out_scale) {
x_upper = FloatToInt32(u_bound * in_scale);
y_upper = FloatToInt16(u_bound * out_scale);
x_upper = DoubleToInt32(u_bound * in_scale);
y_upper = DoubleToInt16(u_bound * out_scale);
} else {
x_upper = FloatToInt32(y_upper * in_scale / out_scale);
x_upper = DoubleToInt32(y_upper * in_scale / out_scale);
}
}
}
@ -242,7 +243,7 @@ void make_gna_pwl(const DnnActivation& fun,
gna_pwl[1].xBase = x_lower & XBASEMASK; // zero out the 2 lsb
gna_pwl[1].yBase = y_lower;
s = gna_slope(1.0, in_scale, out_scale);
gna_pwl[1].slope = FloatToInt16(s.slope * s.slope_scale);
gna_pwl[1].slope = DoubleToInt16(s.slope * s.slope_scale);
gna_pwl[1].xBase = gna_pwl[1].xBase | s.slope_scale_index;
print_segment((int32_t)(gna_pwl[1].xBase & XBASEMASK) / in_scale, gna_pwl[1].yBase / out_scale, 1.0);
@ -263,9 +264,9 @@ void make_gna_pwl(const DnnActivation& fun,
auto n_segments = 2;
if (y_upper > x_upper * out_scale / in_scale)
y_upper = FloatToInt16(x_upper * out_scale / in_scale);
y_upper = DoubleToInt16(x_upper * out_scale / in_scale);
if (x_upper > y_upper * in_scale / out_scale)
x_upper = FloatToInt32(y_upper * in_scale / out_scale);
x_upper = DoubleToInt32(y_upper * in_scale / out_scale);
if (y_upper == y_max) { // saturation at ends - need one more segment
n_segments += 1;
@ -281,14 +282,14 @@ void make_gna_pwl(const DnnActivation& fun,
gna_pwl[i].xBase = (-x_upper) & XBASEMASK; // zero out the 2 lsb
gna_pwl[i].yBase = y_upper;
s = gna_slope(-1.0, in_scale, out_scale);
gna_pwl[i].slope = FloatToInt16(s.slope * s.slope_scale);
gna_pwl[i].slope = DoubleToInt16(s.slope * s.slope_scale);
gna_pwl[i].xBase = gna_pwl[i].xBase | s.slope_scale_index;
print_segment((int32_t)(gna_pwl[i].xBase & XBASEMASK) / in_scale, gna_pwl[i].yBase / out_scale, -1.0);
gna_pwl[i + 1].xBase = 0;
gna_pwl[i + 1].yBase = 0;
s = gna_slope(1.0, in_scale, out_scale);
gna_pwl[i + 1].slope = FloatToInt16(s.slope * s.slope_scale);
gna_pwl[i + 1].slope = DoubleToInt16(s.slope * s.slope_scale);
gna_pwl[i + 1].xBase = gna_pwl[i + 1].xBase | s.slope_scale_index;
print_segment((int32_t)(gna_pwl[i + 1].xBase & XBASEMASK) / in_scale, gna_pwl[i + 1].yBase / out_scale, 1.0);
break;
@ -313,7 +314,7 @@ static T cast_check_overflow(double v, bool round = true) {
return std::numeric_limits<T>::min();
}
return round ? FloatToInt32(v) : static_cast<T>(v);
return round ? DoubleToInt32(v) : static_cast<T>(v);
}
/**
@ -372,7 +373,7 @@ static void make_gna_pwl(const T* m,
s.slope_scale_index;
int16_t ybase = cast_check_overflow<int16_t>(
mul_check_overflow(add_check_overflow(mul_check_overflow(m[i], alpha[i]), b[i]), out_scale));
int16_t slope = cast_check_overflow<int16_t>(mul_check_overflow(s.slope, s.slope_scale));
int16_t slope = cast_check_overflow<int16_t>(mul_check_overflow(s.slope, static_cast<double>(s.slope_scale)));
gna_pwl.push_back({xbase, ybase, slope});
print_segment(alpha[i], add_check_overflow(mul_check_overflow(m[i], alpha[i]), b[i]), m[i]);
}

18
src/plugins/intel_gna/src/backend/pwl_border_values_counter_identity.cpp
View File

@ -41,13 +41,13 @@ BorderValues BorderValuesCounterIdentity::CreateBorderValues(const BorderValues&
int16_t y_lower = default_values.y_lower;
int16_t y_upper = default_values.y_upper;
if (x_lower < y_lower * in_scale / out_scale)
x_lower = common::FloatToInt32(y_lower * in_scale / out_scale);
x_lower = common::DoubleToInt32(y_lower * in_scale / out_scale);
if (x_upper > y_upper * in_scale / out_scale)
x_upper = common::FloatToInt32(y_upper * in_scale / out_scale);
x_upper = common::DoubleToInt32(y_upper * in_scale / out_scale);
if (y_lower < x_lower * out_scale / in_scale)
y_lower = common::FloatToInt16(x_lower * out_scale / in_scale);
y_lower = common::DoubleToInt16(x_lower * out_scale / in_scale);
if (y_upper > x_upper * out_scale / in_scale)
y_upper = common::FloatToInt16(x_upper * out_scale / in_scale);
y_upper = common::DoubleToInt16(x_upper * out_scale / in_scale);
return {x_lower, x_upper, y_lower, y_upper, {default_values.y_lower, default_values.y_upper}};
}
@ -56,10 +56,12 @@ BorderValues BorderValuesCounterIdentity::CreateBorderValuesWithFakeQuantize(
const FakeQuantizeParams& fake_quantize_params,
double in_scale,
double out_scale) {
int32_t x_lower = std::max(static_cast<const int64_t>(*fake_quantize_params.input_low * in_scale),
static_cast<int64_t>(default_values.x_lower));
int32_t x_upper = std::min(static_cast<const int64_t>(*fake_quantize_params.input_high * in_scale),
static_cast<int64_t>(default_values.x_upper));
int32_t x_lower =
static_cast<int32_t>(std::max(static_cast<const int64_t>(*fake_quantize_params.input_low * in_scale),
static_cast<int64_t>(default_values.x_lower)));
int32_t x_upper =
static_cast<int32_t>(std::min(static_cast<const int64_t>(*fake_quantize_params.input_high * in_scale),
static_cast<int64_t>(default_values.x_upper)));
int16_t y_lower = std::max(static_cast<const int32_t>(*fake_quantize_params.input_low * out_scale),
static_cast<int32_t>(default_values.y_lower));
int16_t y_upper = std::min(static_cast<const int32_t>(*fake_quantize_params.input_high * out_scale),

2
src/plugins/intel_gna/src/backend/pwl_tools.cpp
View File

@ -28,7 +28,7 @@ int64_t ComputeSlopeScale(const int32_t x_base) {
PWLSegmentSlope ComputeSlopeForSegment(double slope, double in_scale, double out_scale) {
const auto gna_slope_value = gna_slope(slope, in_scale, out_scale);
auto segment_slope = common::FloatToInt64(gna_slope_value.slope * gna_slope_value.slope_scale);
auto segment_slope = common::DoubleToInt64(gna_slope_value.slope * gna_slope_value.slope_scale);
if (segment_slope > std::numeric_limits<int16_t>::max()) {
segment_slope = std::numeric_limits<int16_t>::max();

4
src/plugins/intel_gna/src/common/graph_utils.hpp
View File

@ -37,7 +37,9 @@ template <typename T>
inline bool get_constant_value(const std::shared_ptr<ngraph::opset8::Constant>& constant, std::vector<double>& values) {
using A = typename ov::element_type_traits<T::value>::value_type;
const auto& v = constant->get_vector<A>();
std::copy(v.begin(), v.end(), std::back_inserter(values));
std::transform(v.begin(), v.end(), std::back_inserter(values), [](A value) {
return static_cast<double>(value);
});
return true;
}

26
src/plugins/intel_gna/src/common/numerical_utils.hpp
View File

@ -12,21 +12,33 @@ namespace ov {
namespace intel_gna {
namespace common {
template <typename T>
inline T FloatToInteger(float a) {
return static_cast<T>((a < 0.0f) ? (a - 0.5f) : (a + 0.5f));
template <typename T, typename U, typename std::enable_if<std::is_floating_point<U>::value>::type* = nullptr>
inline T FloatingToInteger(U a) {
return static_cast<T>((a < 0.0f) ? (a - static_cast<U>(0.5)) : (a + static_cast<U>(0.5)));
}
inline int8_t FloatToInt8(float a) {
return FloatToInteger<int8_t>(a);
return FloatingToInteger<int8_t>(a);
}
inline int16_t FloatToInt16(float a) {
return FloatToInteger<int16_t>(a);
return FloatingToInteger<int16_t>(a);
}
inline int32_t FloatToInt32(float a) {
return FloatToInteger<int32_t>(a);
return FloatingToInteger<int32_t>(a);
}
inline int64_t FloatToInt64(float a) {
return FloatToInteger<int64_t>(a);
return FloatingToInteger<int64_t>(a);
}
inline int8_t DoubleToInt8(double a) {
return FloatingToInteger<int8_t>(a);
}
inline int16_t DoubleToInt16(double a) {
return FloatingToInteger<int16_t>(a);
}
inline int32_t DoubleToInt32(double a) {
return FloatingToInteger<int32_t>(a);
}
inline int64_t DoubleToInt64(double a) {
return FloatingToInteger<int64_t>(a);
}
/**

4
src/plugins/intel_gna/src/descriptions/gna_desc.hpp
View File

@ -31,7 +31,7 @@ struct GnaDesc {
InferenceEngine::Precision tensor_precision = InferenceEngine::Precision::UNSPECIFIED;
// gna specific properties
double scale_factor = kScaleFactorDefault;
float scale_factor = kScaleFactorDefault;
intel_dnn_orientation_t orientation = kDnnUnknownOrientation;
uint32_t num_elements = 0;
uint32_t allocated_size = 0;
@ -42,7 +42,7 @@ struct GnaDesc {
// help methods
uint32_t get_required_size() const {
return num_elements * tensor_precision.size();
return num_elements * static_cast<uint32_t>(tensor_precision.size());
}
uint32_t get_allocated_size() const {

4
src/plugins/intel_gna/src/frontend/layer_quantizer.cpp
View File

@ -36,14 +36,14 @@ InferenceEngine::Blob::Ptr LayerQuantizer::FP32ToPrecisionBlob(InferenceEngine::
auto input_high = 0.0f;
auto output_low = 0.0f;
auto output_high = 0.0f;
auto levels = 1;
uint32_t levels = 1;
if (dst_quant_params.IsStatsSet()) {
input_low = dst_quant_params.GetMinValues(true).front();
input_high = dst_quant_params.GetMaxValues(true).front();
output_low = dst_quant_params.GetMinValues(false).front();
output_high = dst_quant_params.GetMaxValues(false).front();
levels = dst_quant_params.GetLevels();
levels = static_cast<uint32_t>(dst_quant_params.GetLevels());
}
auto f32_value_array = fp32_blob->buffer().as<float*>();

15
src/plugins/intel_gna/src/frontend/model_quantizer.hpp
View File

@ -92,11 +92,12 @@ private:
// We are looking for infinite loop by using algorithm of compute prefix function, complexity O(N)
// (a part of the Knuth–Morris–Pratt algorithm).
std::map<int, int> prefix_function;
int32_t k = inf_loop_history.size();
for (int32_t i = inf_loop_history.size() - 2; i >= 0; i--) {
while (k < inf_loop_history.size() && inf_loop_history[k - 1] != inf_loop_history[i]) {
auto k = static_cast<int>(inf_loop_history.size());
for (int32_t i = static_cast<int32_t>(inf_loop_history.size()) - 2; i >= 0; i--) {
while (k < static_cast<int>(inf_loop_history.size()) &&
inf_loop_history[k - 1] != inf_loop_history[i]) {
auto iter = prefix_function.find(k);
k = iter == prefix_function.end() ? inf_loop_history.size() : iter->second;
k = iter == prefix_function.end() ? static_cast<int>(inf_loop_history.size()) : iter->second;
}
if (inf_loop_history[k - 1] == inf_loop_history[i]) {
@ -127,7 +128,7 @@ private:
log::debug() << "\t " << s << '\n';
}
inf_loop_pattern.clear();
int pattern_len = (inf_loop_history.size() - i) / 2;
auto pattern_len = (static_cast<int>(inf_loop_history.size()) - i) / 2;
log::debug() << "pattern_len: " << pattern_len << '\n';
for (int j = 0; j < pattern_len; j++) {
inf_loop_pattern.emplace_back(inf_loop_history[inf_loop_history.size() - pattern_len + j]);
@ -150,8 +151,8 @@ private:
if (inf_loop_count > 0 &&
((inf_loop_pattern.size() > 0 && (inf_loop_history.size() % inf_loop_pattern.size() == 0)) ||
sf.allLayersProcessed())) {
int32_t history_shift = 0;
int32_t pattern_shift = 0;
size_t history_shift = 0;
size_t pattern_shift = 0;
if (inf_loop_history.size() > inf_loop_pattern.size()) {
history_shift = inf_loop_history.size() - inf_loop_pattern.size();

16
src/plugins/intel_gna/src/frontend/quantization.cpp
View File

@ -92,7 +92,7 @@ void QuantizeWeights<int8_t>(const QuantizationData& data,
auto input_high = 0.0f;
auto output_low = 0.0f;
auto output_high = 0.0f;
size_t levels = 1;
uint32_t levels = 1;
float valueAcc = 0.0f;
const auto min_values_size = data.weights_quant_params.GetMinValues().size();
@ -101,7 +101,7 @@ void QuantizeWeights<int8_t>(const QuantizationData& data,
input_high = data.weights_quant_params.GetMaxValues(true).front();
output_low = data.weights_quant_params.GetMinValues(false).front();
output_high = data.weights_quant_params.GetMaxValues(false).front();
levels = data.weights_quant_params.GetLevels();
levels = static_cast<uint32_t>(data.weights_quant_params.GetLevels());
}
for (size_t row = 0; row < data.num_rows; row++) {
@ -114,8 +114,9 @@ void QuantizeWeights<int8_t>(const QuantizationData& data,
input_high = data.weights_quant_params.GetMaxValues(true).at(idx);
output_low = data.weights_quant_params.GetMinValues(false).at(idx);
output_high = data.weights_quant_params.GetMaxValues(false).at(idx);
levels = data.weights_quant_params.GetLevels();
channel_multiplier = ((input_high - input_low) * data.scale_factor) / (levels - 1);
levels = static_cast<uint32_t>(data.weights_quant_params.GetLevels());
channel_multiplier =
static_cast<uint32_t>(((input_high - input_low) * data.scale_factor) / (levels - 1));
} else {
float scaled_row_max = 0;
for (size_t col = 0; col < data.num_columns; col++) {
@ -126,7 +127,8 @@ void QuantizeWeights<int8_t>(const QuantizationData& data,
}
}
channel_multiplier = (scaled_row_max / static_cast<float>(MAX_VAL_1B_WEIGHT) + 0.5f);
channel_multiplier =
static_cast<uint32_t>((scaled_row_max / static_cast<float>(MAX_VAL_1B_WEIGHT) + 0.5f));
}
if (channel_multiplier > MAX_OUT_MULTIPLIER) {
@ -183,7 +185,7 @@ void QuantizeWeights<int16_t>(const QuantizationData& data,
auto input_high = 0.0f;
auto output_low = 0.0f;
auto output_high = 0.0f;
size_t levels = 1;
uint32_t levels = 1;
const auto min_values_size = data.weights_quant_params.GetMinValues().size();
if (min_values_size > 0) {
@ -191,7 +193,7 @@ void QuantizeWeights<int16_t>(const QuantizationData& data,
input_high = data.weights_quant_params.GetMaxValues(true).front();
output_low = data.weights_quant_params.GetMinValues(false).front();
output_high = data.weights_quant_params.GetMaxValues(false).front();
levels = data.weights_quant_params.GetLevels();
levels = static_cast<uint32_t>(data.weights_quant_params.GetLevels());
}
for (size_t row = 0; row < data.num_rows; row++) {

49
src/plugins/intel_gna/src/frontend/scale_factor_calc.cpp
View File

@ -93,7 +93,7 @@ float ScaleFactorCalculator::selectBestOutputScaleFactors(float inScale,
auto sd = 0.0f;
for (size_t j = 0; j < slopes.size(); ++j) {
auto s = gna_slope(slopes[j], inScale, outScale);
auto slope = FloatToInt16(s.slope * s.slope_scale);
auto slope = DoubleToInt16(s.slope * s.slope_scale);
if (slope < std::numeric_limits<int16_t>::min() || slope > std::numeric_limits<int16_t>::max()) {
sd += std::numeric_limits<int8_t>::max();
continue;
@ -104,7 +104,7 @@ float ScaleFactorCalculator::selectBestOutputScaleFactors(float inScale,
return outScale;
}
sd += pow(testSlope - slopes[j], 2.0);
sd += static_cast<float>(pow(testSlope - slopes[j], 2.0));
}
sd /= slopes.size();
@ -139,7 +139,7 @@ float ScaleFactorCalculator::selectBestWeightsScaleFactors(float inScale,
for (size_t i = 0; i < weightsScales.size(); ++i) {
auto weightScale = weightsScales[i];
auto sd = 0.0;
auto sd = 0.0f;
for (size_t j = 0; j < slopes.size(); ++j) {
auto s = gna_slope(slopes[j], inScale * weightScale, outScale);
auto slope = static_cast<uint32_t>(s.slope * s.slope_scale);
@ -153,7 +153,7 @@ float ScaleFactorCalculator::selectBestWeightsScaleFactors(float inScale,
if (AreFpEq(static_cast<float>(testSlope), static_cast<float>(slopes[j]))) {
return outScale;
}
sd += pow(testSlope - slopes[j], 2.0);
sd += static_cast<float>(pow(testSlope - slopes[j], 2.0));
}
sd /= slopes.size();
@ -233,7 +233,7 @@ bool ScaleFactorCalculator::requantizeInput(InferenceEngine::CNNLayerPtr input,
return false;
}
size_t prevInputIdx = 0;
int prevInputIdx = 0;
auto info = LayerInfo(layer);
auto quantDataForInputLayer = InferenceEngine::getInjectedData<QuantizedLayerParams>(*layer);
if (quantDataForInputLayer->_dst_quant.IsStatsSet()) {
@ -261,7 +261,7 @@ bool ScaleFactorCalculator::requantizeInput(InferenceEngine::CNNLayerPtr input,
if (info.isWeightableIdentity() && !AreFpEq(quantDataForInputLayer->_weights_quant.GetScale(), 1.0f)) {
auto reducer = std::max(1.0f, quantDataForInputLayer->_dst_quant.GetScale() / newOutputScale);
auto newWeightsScale = std::max(1.0f, quantDataForInputLayer->_weights_quant.GetScale() / reducer);
quantDataForInputLayer->_weights_quant.SetScale(static_cast<int32_t>(newWeightsScale));
quantDataForInputLayer->_weights_quant.SetScale(trunc(newWeightsScale));
quantDataForInputLayer->_dst_quant.SetScale(quantDataForInputLayer->_weights_quant.GetScale() *
quantDataForInputLayer->_src_quant.GetScale());
@ -410,7 +410,8 @@ float ScaleFactorCalculator::getActivationScale(InferenceEngine::CNNLayer const*
#endif
} else if (layer.isRelu()) {
// if activation is one from relu family, we need to apply heuristic to avoid activation output overflow
auto limit = (inputsSize == 1 ? std::numeric_limits<int8_t>::max() : std::numeric_limits<int32_t>::max()) - 1;
auto limit = static_cast<uint64_t>(
(inputsSize == 1 ? std::numeric_limits<int8_t>::max() : std::numeric_limits<int32_t>::max()) - 1);
if (static_cast<uint64_t>(result * quantizedParams->_src_quant.GetScale()) > limit) {
result *= 0.5;
@ -596,7 +597,7 @@ bool ScaleFactorCalculator::ScaleFactorPerLayerCNN(InferenceEngine::CNNLayer* cn
IE_THROW() << "Incorrect Layer pointer \n";
}
int inputsSize = GetInputPrecision().size();
int inputsSize = static_cast<int>(GetInputPrecision().size());
LayerInfo layerInfo(*cnnLayer);
// TODO: current approach set input scale factor for true input layer(s) equals to provided factor,
@ -732,7 +733,7 @@ bool ScaleFactorCalculator::ScaleFactorPerLayerCNN(InferenceEngine::CNNLayer* cn
auto flt_buf = blob->buffer().as<float*>();
auto size = blob->size();
for (int i = 0; i < size; i++) {
for (size_t i = 0; i < size; i++) {
auto val = flt_buf[i];
if (val > max_val)
max_val = val;
@ -800,7 +801,7 @@ bool ScaleFactorCalculator::ScaleFactorPerLayerCNN(InferenceEngine::CNNLayer* cn
}
return true;
} else if (layerInfo.isCropAffined()) {
auto weightsScaleFactor = 1;
auto weightsScaleFactor = 1.0f;
quant->_weights_quant.SetScale(weightsScaleFactor);
quant->_src_quant.SetScale(inputQuant->_dst_quant.GetScale());
quant->_dst_quant.SetScale(quant->_weights_quant.GetScale() * quant->_src_quant.GetScale());
@ -881,7 +882,7 @@ bool ScaleFactorCalculator::ScaleFactorPerLayerEltwise(InferenceEngine::EltwiseL
auto error = std::abs(eltwiseWeightsScale - static_cast<int16_t>(eltwiseWeightsScale));
if (error < bestError) {
bestError = error;
bestWeightsScale = i;
bestWeightsScale = static_cast<float>(i);
}
if (AreFpEq(error, 0.0f)) {
@ -923,7 +924,7 @@ bool ScaleFactorCalculator::ScaleFactorPerLayerEltwise(InferenceEngine::EltwiseL
auto weightsReducer = calculateWeightsReducerFromDstStats(quantData->_dst_quant);
if (weightsReducer > initial_weights_reducer_val) {
float newOutputScale = quantParams1->_dst_quant.GetScale() / weightsReducer;
float newOutputScale = static_cast<float>(quantParams1->_dst_quant.GetScale() / weightsReducer);
if (requantizeInput(in1, newOutputScale, result, infiniteLoopCount)) {
return true;
}
@ -950,11 +951,11 @@ bool ScaleFactorCalculator::ScaleFactorPerLayerConcat(InferenceEngine::ConcatLay
auto quantData = InferenceEngine::getInjectedData<QuantizedLayerParams>(*concatLayer);
std::vector<InferenceEngine::CNNLayerPtr> inputLayers;
for (auto input_idx = 0; input_idx != concatLayer->insData.size(); input_idx++) {
for (size_t input_idx = 0; input_idx != concatLayer->insData.size(); input_idx++) {
auto notChangeScaleFactors = [](InferenceEngine::CNNLayerPtr layer) {
return LayerInfo(layer).isNonFunctional() || LayerInfo(layer).isSplit() || LayerInfo(layer).isCopy();
};
auto prev_layer = CNNNetPrevLayerSkipCertain(concatLayer, input_idx, notChangeScaleFactors);
auto prev_layer = CNNNetPrevLayerSkipCertain(concatLayer, static_cast<int>(input_idx), notChangeScaleFactors);
inputLayers.push_back(prev_layer);
}
@ -1112,7 +1113,7 @@ bool ScaleFactorCalculator::ScaleFactorPerLayerConcat(InferenceEngine::ConcatLay
[&restartedLayer, &concatLayer, &layerIdToUpdate](InferenceEngine::CNNLayer* from) {
// aborting UFS once found functional layer, and using only specified input of concat
return make_upstream_order(restartedLayer == nullptr ? from : nullptr,
from == concatLayer ? layerIdToUpdate : -1);
from == concatLayer ? static_cast<int>(layerIdToUpdate) : -1);
});
if (restartedLayer == nullptr) {
@ -1135,9 +1136,10 @@ bool ScaleFactorCalculator::ScaleFactorPerLayerConcat(InferenceEngine::ConcatLay
if (fake_quantized && prevLayer != nullptr &&
(LayerInfo(prevLayer).isConcatAlignFilter() || LayerInfo(prevLayer).isSyntheticScaleShift()) &&
(prevLayer2 == nullptr || LayerInfo(prevLayer2).has8BOr16BOutput())) {
auto weightsScales = generateScaleFactors(min_search_weights_val,
max_search_weights_val,
max_search_weights_val - min_search_weights_val);
auto weightsScales =
generateScaleFactors(min_search_weights_val,
max_search_weights_val,
static_cast<size_t>(max_search_weights_val - min_search_weights_val));
auto prevLayerQuant = InferenceEngine::getInjectedData<QuantizedLayerParams>(*prevLayer);
auto bestWeightsScale = 1.0f;
@ -1196,7 +1198,7 @@ bool ScaleFactorCalculator::ScaleFactorPerLayerWeightable(InferenceEngine::Weigh
}
auto quant = InferenceEngine::getInjectedData<QuantizedLayerParams>(*wl);
int inputsSize = GetInputPrecision().size();
size_t inputsSize = GetInputPrecision().size();
const auto weights_prec = GetWeightsPrecision(LayerInfo(wl), *quant, gna_config);
const auto is_bias_compound = IsBiasCompound(LayerInfo(wl), *quant, gna_config);
auto prevLayer = CNNNetPrevLayer(wl);
@ -1236,8 +1238,9 @@ bool ScaleFactorCalculator::ScaleFactorPerLayerWeightable(InferenceEngine::Weigh
} else {
THROW_GNA_EXCEPTION << "Unsupported weights precision of: " << weights_prec.name();
}
quant->_weights_quant.SetScale(
ScaleFactorForQuantization(wl->_weights->buffer().as<float*>(), scaleRange, wl->_weights->size()));
quant->_weights_quant.SetScale(ScaleFactorForQuantization(wl->_weights->buffer().as<float*>(),
static_cast<float>(scaleRange),
wl->_weights->size()));
if (quant->_weights_quant.GetScale() == -1.0f || (fake_quantized && LayerInfo(wl).isConcatAlignFilter())) {
quant->_weights_quant.SetScale(1.0f);
}
@ -1267,7 +1270,7 @@ bool ScaleFactorCalculator::ScaleFactorPerLayerWeightable(InferenceEngine::Weigh
weights_reducer *= MAX_VAL_2B_FEAT * scaleRange * inDepth / std::numeric_limits<int32_t>::max();
weights_reducer = std::max(1.0, weights_reducer);
}
quant->_weights_quant.SetScale(quant->_weights_quant.GetScale() / weights_reducer);
quant->_weights_quant.SetScale(quant->_weights_quant.GetScale() / static_cast<float>(weights_reducer));
}
double tmp_dst_quant_scale = quant->_weights_quant.GetScale() * quant->_src_quant.GetScale();
@ -1317,7 +1320,7 @@ bool ScaleFactorCalculator::ScaleFactorPerLayerWeightable(InferenceEngine::Weigh
// This correction should be done by POT, but we observed issues with int8 quantization
if (weightsReducer > initial_weights_reducer_val) {
log::warning() << "Potential overload correction issue at layer " << wl->name;
quant->_weights_quant.SetScale(quant->_weights_quant.GetScale() / weightsReducer);
quant->_weights_quant.SetScale(static_cast<float>(quant->_weights_quant.GetScale() / weightsReducer));
}
quant->_dst_quant.SetScale(quant->_weights_quant.GetScale() * quant->_src_quant.GetScale());
}

11
src/plugins/intel_gna/src/gna2_model_export_helper.cpp
View File

@ -13,7 +13,14 @@
#include "gna2-device-api.h"
#include "gna2-model-export-api.h"
#include "gna2-model-suecreek-header.h"
#include "gna2-tlv-writer.h"
#ifdef _MSC_VER
# pragma warning(push)
# pragma warning(disable : 4200)
# include "gna2-tlv-writer.h"
# pragma warning(pop)
#else
# include "gna2-tlv-writer.h"
#endif // _MSC_VER
#include "gna2_model_helper.hpp"
#include "gna_device.hpp"
#include "log/log.hpp"
@ -43,7 +50,7 @@ static std::vector<char> GetStringAsTlv(Gna2TlvType type, const std::string& s)
std::vector<char> vs(s.begin(), s.end());
vs.resize(vs.size() + (4 - vs.size() % 4) % 4, 0);
reinterpret_cast<Gna2TlvRecord*>(record.data())->length = vs.size();
reinterpret_cast<Gna2TlvRecord*>(record.data())->length = static_cast<uint32_t>(vs.size());
record.insert(record.end(), vs.begin(), vs.end());
return record;
}

2
src/plugins/intel_gna/src/gna_device_allocation.hpp
View File

@ -84,7 +84,7 @@ struct GnaAllocation {
}
uint32_t sizeForExport() const {
return ALIGN64(sizeRequested);
return ALIGN64(static_cast<uint32_t>(sizeRequested));
}
private:

2
src/plugins/intel_gna/src/gna_device_interface.hpp
View File

@ -11,7 +11,7 @@
#include "request_status.hpp"
enum Gna2AccelerationMode;
class Gna2Model;
struct Gna2Model;
namespace ov {
namespace intel_gna {

322
src/plugins/intel_gna/src/gna_graph_compiler.cpp
View File

@ -131,7 +131,7 @@ void GNAGraphCompiler::fillConcatConnections(InferenceEngine::CNNLayerPtr layer)
std::string& id = layer->name;
for (size_t i = 0; i < layer->insData.size(); ++i) {
auto ptrConcatLayerInput = CNNNetPrevLayerSkipCertain(layer, i, [](CNNLayerPtr lp) {
auto ptrConcatLayerInput = CNNNetPrevLayerSkipCertain(layer, static_cast<int>(i), [](CNNLayerPtr lp) {
LayerInfo info(lp);
return info.isNonFunctional();
});
@ -182,10 +182,11 @@ void GNAGraphCompiler::fillSplitConnections(InferenceEngine::CNNLayerPtr layer)
size_t padding = 0;
size_t output_layer_size = 0;
for (int j = 0; j != getInputTo(layer->outData[i]).size(); j++) {
auto outFunctionalLayer = CNNNetCheckNextLayerSkipCertain(layer, i, j, true, [](CNNLayerPtr l) {
return LayerInfo(l).isNonFunctional();
});
for (int j = 0; j != static_cast<int>(getInputTo(layer->outData[i]).size()); j++) {
auto outFunctionalLayer =
CNNNetCheckNextLayerSkipCertain(layer, static_cast<int>(i), j, true, [](CNNLayerPtr l) {
return LayerInfo(l).isNonFunctional();
});
if (!outFunctionalLayer.first) {
output_layer_size = InferenceEngine::details::product(begin(layer->outData[i]->getDims()),
@ -543,10 +544,10 @@ void GNAGraphCompiler::finalizeConvolution1DPrimitive(InferenceEngine::CNNLayerP
auto biasPrecision =
convolution._biases ? convolution._biases->getTensorDesc().getPrecision() : outputs->getPrecision();
uint32_t num_bytes_per_input = inputs->getPrecision().size();
uint32_t num_bytes_per_output = outputs->getPrecision().size();
uint32_t num_bytes_per_weight = convolution._weights->getTensorDesc().getPrecision().size();
uint32_t num_bytes_per_bias = biasPrecision.size();
uint32_t num_bytes_per_input = static_cast<uint32_t>(inputs->getPrecision().size());
uint32_t num_bytes_per_output = static_cast<uint32_t>(outputs->getPrecision().size());
uint32_t num_bytes_per_weight = static_cast<uint32_t>(convolution._weights->getTensorDesc().getPrecision().size());
uint32_t num_bytes_per_bias = static_cast<uint32_t>(biasPrecision.size());
float weight_scale_factor = GetScaleFactor(layer, QuantizedDataType::weights);
float output_scale_factor = GetScaleFactor(layer, QuantizedDataType::output);
@ -644,7 +645,7 @@ void GNAGraphCompiler::finalizeConvolution1DPrimitive(InferenceEngine::CNNLayerP
std::size_t offset = 0;
std::vector<uint8_t> padding_zeros(num_conv_kernel_padding * cpSize, 0);
uint8_t* dstPtr = reinterpret_cast<uint8_t*>(data);
for (int i = 0; i < num_filters; i++) {
for (uint32_t i = 0; i < num_filters; i++) {
ie_memcpy(dstPtr + offset,
size - offset,
transposedWeights.data() + single_conv_kernel_size * i * cpSize,
@ -767,8 +768,8 @@ void GNAGraphCompiler::finalizeConvolution2DPrimitive(InferenceEngine::CNNLayerP
ptr_outputs,
ptr_weights,
ptr_biases);
currentComponent.num_bytes_per_input = inputs->getPrecision().size();
currentComponent.num_bytes_per_output = outputs->getPrecision().size();
currentComponent.num_bytes_per_input = static_cast<uint32_t>(inputs->getPrecision().size());
currentComponent.num_bytes_per_output = static_cast<uint32_t>(outputs->getPrecision().size());
if (inputs->getLayout() == InferenceEngine::Layout::NHWC) {
currentComponent.orientation_in = kDnnInterleavedOrientation;
@ -848,8 +849,8 @@ void GNAGraphCompiler::PowerPrimitive(InferenceEngine::CNNLayerPtr layer) {
const uint32_t num_of_inputs_divisor = gna_config.gnaFlags.input_low_precision
? Limitations::kNoOfInputsLowPrecDivisor
: Limitations::kNoOfInputsDivisor;
uint32_t num_rows_in = reshaped_dims[1];
uint32_t num_columns_in = reshaped_dims[0];
uint32_t num_rows_in = static_cast<uint32_t>(reshaped_dims[1]);
uint32_t num_columns_in = static_cast<uint32_t>(reshaped_dims[0]);
uint32_t num_rows_out = num_rows_in;
uint32_t num_columns_out = num_columns_in;
uint32_t num_padding = ALIGN(num_rows_in, num_of_inputs_divisor) - num_rows_in;
@ -867,23 +868,24 @@ void GNAGraphCompiler::PowerPrimitive(InferenceEngine::CNNLayerPtr layer) {
auto quantized = InferenceEngine::getInjectedData<QuantizedLayerParams>(layer);
IE_ASSERT(gna_config.gnaFlags.sw_fp32 ? (quantized == nullptr) : (quantized != nullptr));
dnn->InitAffineComponent(
currentComponent,
num_rows_in + num_padding,
num_columns_in,
num_rows_out + num_padding,
input->getPrecision().size(),
outputs->getPrecision().size(),
// TODO: only fp32 and Int16 tested
quantized == nullptr ? input->getPrecision().size() : (gna_config.gnaFlags.input_low_precision ? 1 : 2),
quantized == nullptr ? input->getPrecision().size() : (gna_config.gnaFlags.input_low_precision ? 1 : 4),
quantized == nullptr ? 1 : quantized->_weights_quant.GetScale(),
quantized == nullptr ? 1 : quantized->_dst_quant.GetScale(),
ptr_inputs,
ptr_outputs,
ptr_weights,
ptr_biases,
true);
dnn->InitAffineComponent(currentComponent,
num_rows_in + num_padding,
num_columns_in,
num_rows_out + num_padding,
static_cast<uint32_t>(input->getPrecision().size()),
static_cast<uint32_t>(outputs->getPrecision().size()),
// TODO: only fp32 and Int16 tested
quantized == nullptr ? static_cast<uint32_t>(input->getPrecision().size())
: (gna_config.gnaFlags.input_low_precision ? 1 : 2),
quantized == nullptr ? static_cast<uint32_t>(input->getPrecision().size())
: (gna_config.gnaFlags.input_low_precision ? 1 : 4),
quantized == nullptr ? 1 : quantized->_weights_quant.GetScale(),
quantized == nullptr ? 1 : quantized->_dst_quant.GetScale(),
ptr_inputs,
ptr_outputs,
ptr_weights,
ptr_biases,
true);
connectOutput(layer, ptr_outputs, num_data_bytes_out);
connectInput(layer, ptr_inputs, num_data_bytes_in, 0, 0);
@ -965,9 +967,9 @@ void GNAGraphCompiler::PowerPrimitive(InferenceEngine::CNNLayerPtr layer) {
orientation,
num_rows_in + num_padding,
num_columns_in,
input->getPrecision().size(),
outputs->getPrecision().size(),
ptr_pwl_segments.size(),
static_cast<uint32_t>(input->getPrecision().size()),
static_cast<uint32_t>(outputs->getPrecision().size()),
static_cast<uint32_t>(ptr_pwl_segments.size()),
output_pwl_scale_factor,
output_pwl_scale_factor,
ptr_pwl_input,
@ -1043,8 +1045,8 @@ void GNAGraphCompiler::PoolingPrimitive(InferenceEngine::CNNLayerPtr layer) {
dnn->InitMaxpoolComponent(currentComponent,
{c_dim_in, h_dim_in, w_dim_in},
{c_dim_out, h_dim_out, w_dim_out},
inputs->getPrecision().size(),
outputs->getPrecision().size(),
static_cast<uint32_t>(inputs->getPrecision().size()),
static_cast<uint32_t>(outputs->getPrecision().size()),
{pooling._kernel[X_AXIS], pooling._kernel[Y_AXIS]},
{pooling._stride[X_AXIS], pooling._stride[Y_AXIS]},
GetScaleFactor(layer, QuantizedDataType::output),
@ -1097,8 +1099,8 @@ void GNAGraphCompiler::CopyPrimitive(InferenceEngine::CNNLayerPtr layer) {
auto outputs = *layer->outData.begin();
auto reshaped_dims = Get2DReshapedData(inputs, Limitations::get_min_batch_to_fit_in_buffer(inputs), 8)->getDims();
uint32_t num_rows_in = reshaped_dims[1];
uint32_t num_columns_in = reshaped_dims[0];
uint32_t num_rows_in = static_cast<uint32_t>(reshaped_dims[1]);
uint32_t num_columns_in = static_cast<uint32_t>(reshaped_dims[0]);
uint32_t num_rows_out = num_rows_in;
uint32_t num_columns_out = num_columns_in;
uint32_t num_padding_out = ALIGN(num_rows_out, 8) - num_rows_out;
@ -1114,8 +1116,8 @@ void GNAGraphCompiler::CopyPrimitive(InferenceEngine::CNNLayerPtr layer) {
num_columns_in,
ALIGN(num_rows_out, 8),
num_columns_out,
inputs->getPrecision().size(),
outputs->getPrecision().size(),
static_cast<uint32_t>(inputs->getPrecision().size()),
static_cast<uint32_t>(outputs->getPrecision().size()),
GetScaleFactor(layer, QuantizedDataType::output),
num_rows_out + num_padding_out,
num_columns_out,
@ -1202,7 +1204,7 @@ void GNAGraphCompiler::ConcatPrimitive(InferenceEngine::CNNLayerPtr layer) {
CNNLayerPtr concatParent;
int it = 0;
for (; it != concatLayerInput->insData.size(); it++) {
for (; it != static_cast<int>(concatLayerInput->insData.size()); it++) {
concatParent = CNNNetPrevLayerSkipCertain(concatLayerInput, it, [](CNNLayerPtr l) {
return LayerInfo(l).isNonFunctional();
});
@ -1210,14 +1212,24 @@ void GNAGraphCompiler::ConcatPrimitive(InferenceEngine::CNNLayerPtr layer) {
break;
}
}
IE_ASSERT(it != concatLayerInput->insData.size());
IE_ASSERT(it != static_cast<int>(concatLayerInput->insData.size()));
auto layerInfo = LayerInfo(concatParent);
// auto layerInfo = LayerInfo(getCreatorLayer(concatLayerInput->insData[it].lock()).lock());
if (layerInfo.isInput()) {
connectInput(layer, &concatLayerInfo.gna_ptr, inputLayer.tensorSize, inputLayer.offset, idx, false);
connectInput(layer,
&concatLayerInfo.gna_ptr,
inputLayer.tensorSize,
static_cast<int32_t>(inputLayer.offset),
static_cast<int>(idx),
false);
concatLayerInfo.input_allocated = true;
} else if (layerInfo.isMemory()) {
connectInput(layer, &concatLayerInfo.gna_ptr, concatLayerInfo.reserved_size, inputLayer.offset, idx, false);
connectInput(layer,
&concatLayerInfo.gna_ptr,
concatLayerInfo.reserved_size,
static_cast<int32_t>(inputLayer.offset),
static_cast<int>(idx),
false);
concatLayerInfo.input_allocated = true;
}
++idx;
@ -1250,7 +1262,11 @@ void GNAGraphCompiler::CropPrimitive(InferenceEngine::CNNLayerPtr layer) {
}
// calculate index idx for connectInput last parameter
connectInput(layer, &cropLayerInfo->second.gna_ptr, cropOutputSizeBytes + cropOffsetBytes, cropOffsetBytes, 0);
connectInput(layer,
&cropLayerInfo->second.gna_ptr,
static_cast<int32_t>(cropOutputSizeBytes + cropOffsetBytes),
static_cast<int>(cropOffsetBytes),
0);
// cases for certain output layers
for (auto&& outLayer : getInputTo(layer->outData.front())) {
@ -1265,10 +1281,12 @@ void GNAGraphCompiler::CropPrimitive(InferenceEngine::CNNLayerPtr layer) {
auto outputs = *layer->outData.begin();
// TODO: add unit tests for 4d crops blobs
uint32_t num_rows_in = InferenceEngine::details::product(begin(inputs->getDims()), end(inputs->getDims()));
uint32_t num_rows_in =
static_cast<uint32_t>(InferenceEngine::details::product(begin(inputs->getDims()), end(inputs->getDims())));
uint32_t num_columns_in = 1;
uint32_t num_rows_out = InferenceEngine::details::product(begin(outputs->getDims()), end(outputs->getDims()));
uint32_t num_rows_out = static_cast<uint32_t>(
InferenceEngine::details::product(begin(outputs->getDims()), end(outputs->getDims())));
const uint32_t num_of_inputs_divisor = gna_config.gnaFlags.input_low_precision
? Limitations::kNoOfInputsLowPrecDivisor
: Limitations::kNoOfInputsDivisor;
@ -1282,22 +1300,22 @@ void GNAGraphCompiler::CropPrimitive(InferenceEngine::CNNLayerPtr layer) {
auto& currentComponent = dnnComponents.addComponent(layer->name, "crop");
auto quantized = InferenceEngine::getInjectedData<QuantizedLayerParams>(layer);
dnn->InitAffineComponent(
currentComponent,
num_rows_in + num_padding,
num_columns_in,
num_rows_out,
inputs->getPrecision().size(),
outputs->getPrecision().size(),
quantized == nullptr ? inputs->getPrecision().size() : (gna_config.gnaFlags.input_low_precision ? 1 : 2),
gna_config.gnaFlags.input_low_precision ? 1 : 4,
GetScaleFactor(layer, QuantizedDataType::weights),
GetScaleFactor(layer, QuantizedDataType::output),
ptr_inputs,
ptr_outputs,
ptr_weights,
ptr_biases,
false);
dnn->InitAffineComponent(currentComponent,
num_rows_in + num_padding,
num_columns_in,
num_rows_out,
static_cast<uint32_t>(inputs->getPrecision().size()),
static_cast<uint32_t>(outputs->getPrecision().size()),
quantized == nullptr ? static_cast<uint32_t>(inputs->getPrecision().size())
: (gna_config.gnaFlags.input_low_precision ? 1 : 2),
gna_config.gnaFlags.input_low_precision ? 1 : 4,
GetScaleFactor(layer, QuantizedDataType::weights),
GetScaleFactor(layer, QuantizedDataType::output),
ptr_inputs,
ptr_outputs,
ptr_weights,
ptr_biases,
false);
size_t num_data_bytes_out =
InferenceEngine::details::product(begin(outputs->getDims()), end(outputs->getDims())) * 4;
@ -1417,23 +1435,24 @@ void GNAGraphCompiler::EltwisePrimitive(InferenceEngine::CNNLayerPtr layer) {
void* ptr_biases = nullptr;
auto& currentComponent = dnnComponents.addComponent(layer->name, "diagonal");
dnn->InitAffineComponent(
currentComponent,
num_rows_in + num_padding,
num_columns_in,
num_rows_out + num_padding,
inputs2Bytes->getPrecision().size(),
outputs->getPrecision().size(),
// TODO: only fp32 and Int16 tested
quantized == nullptr ? inputs2Bytes->getPrecision().size() : (gna_config.gnaFlags.input_low_precision ? 1 : 2),
quantized == nullptr ? inputs4Bytes->getPrecision().size() : (gna_config.gnaFlags.input_low_precision ? 1 : 4),
GetScaleFactor(layer, QuantizedDataType::weights),
GetScaleFactor(layer, QuantizedDataType::output),
ptr_inputs,
ptr_outputs,
ptr_weights,
ptr_biases,
true);
dnn->InitAffineComponent(currentComponent,
num_rows_in + num_padding,
num_columns_in,
num_rows_out + num_padding,
static_cast<uint32_t>(inputs2Bytes->getPrecision().size()),
static_cast<uint32_t>(outputs->getPrecision().size()),
// TODO: only fp32 and Int16 tested
quantized == nullptr ? static_cast<uint32_t>(inputs2Bytes->getPrecision().size())
: (gna_config.gnaFlags.input_low_precision ? 1 : 2),
quantized == nullptr ? static_cast<uint32_t>(inputs4Bytes->getPrecision().size())
: (gna_config.gnaFlags.input_low_precision ? 1 : 4),
GetScaleFactor(layer, QuantizedDataType::weights),
GetScaleFactor(layer, QuantizedDataType::output),
ptr_inputs,
ptr_outputs,
ptr_weights,
ptr_biases,
true);
size_t num_data_bytes_out = num_columns_out * (num_rows_out + num_padding) * outputs->getPrecision().size();
size_t num_data_bytes_in = num_columns_in * (num_rows_in + num_padding) * inputs2Bytes->getPrecision().size();
@ -1521,8 +1540,8 @@ void GNAGraphCompiler::GemmPrimitive(InferenceEngine::CNNLayerPtr layer) {
auto in_dims = input_1->getDims();
auto batch_size = (in_dims.size() == 1) ? 1 : in_dims.front();
uint32_t num_rows_in = InferenceEngine::details::product(in_dims) / batch_size;
uint32_t num_columns_in = batch_size;
uint32_t num_rows_in = static_cast<uint32_t>(InferenceEngine::details::product(in_dims) / batch_size);
uint32_t num_columns_in = static_cast<uint32_t>(batch_size);
const auto out_dims = outputs->getDims();
const auto out_dims_size = ngraph::shape_size(out_dims);
uint32_t num_rows_out = InferenceEngine::GetDimFromBack(out_dims, 1);
@ -1540,10 +1559,10 @@ void GNAGraphCompiler::GemmPrimitive(InferenceEngine::CNNLayerPtr layer) {
num_rows_in + num_padding,
num_columns_in,
num_rows_out,
input1_precision.size(),
outputs->getPrecision().size(),
input2_precision.size(),
quantized == nullptr ? input_2->getPrecision().size() : 4,
static_cast<uint32_t>(input1_precision.size()),
static_cast<uint32_t>(outputs->getPrecision().size()),
static_cast<uint32_t>(input2_precision.size()),
quantized == nullptr ? static_cast<uint32_t>(input_2->getPrecision().size()) : 4,
GetScaleFactor(layer, QuantizedDataType::weights),
GetScaleFactor(layer, QuantizedDataType::output),
ptr_input_1,
@ -1561,9 +1580,9 @@ void GNAGraphCompiler::GemmPrimitive(InferenceEngine::CNNLayerPtr layer) {
connectInput(layer, ptr_input_2, num_data_bytes_in_2, 0, 1);
if (gna_config.gnaFlags.sw_fp32) {
IE_ASSERT(quantized == nullptr);
gnamem->getQueue(REGION_RO)->push_value(layer, ptr_biases, 0.0f, num_rows_out);
gnamem->getQueue(REGION_RO)->push_value(layer, ptr_biases, 0, num_rows_out);
} else {
gnamem->getQueue(REGION_RO)->push_value<int32_t>(layer, ptr_biases, 0.0f, num_rows_out);
gnamem->getQueue(REGION_RO)->push_value<int32_t>(layer, ptr_biases, 0, num_rows_out);
}
}
@ -1593,8 +1612,8 @@ void GNAGraphCompiler::AffinePrimitive(InferenceEngine::CNNLayerPtr layer, bool
: inputs;
auto in_dims = input_data->getDims();
auto batch_size = (in_dims.size() == 1) ? 1 : in_dims.front();
uint32_t num_rows_in = InferenceEngine::details::product(in_dims) / batch_size;
uint32_t num_columns_in = batch_size;
uint32_t num_rows_in = static_cast<uint32_t>(InferenceEngine::details::product(in_dims) / batch_size);
uint32_t num_columns_in = static_cast<uint32_t>(batch_size);
uint32_t num_rows_out = isDiag ? num_rows_in : InferenceEngine::GetDimFromBack(out_dims, 1);
uint32_t num_columns_out = num_columns_in;
uint32_t num_padding = ALIGN(num_rows_in, num_of_inputs_divisor) - num_rows_in;
@ -1629,10 +1648,10 @@ void GNAGraphCompiler::AffinePrimitive(InferenceEngine::CNNLayerPtr layer, bool
num_rows_in + num_padding,
num_columns_in,
num_rows_out + num_padding_out,
inputPrecision.size(),
outputs->getPrecision().size(),
weightable._weights->getTensorDesc().getPrecision().size(),
biasPrecisionSize,
static_cast<uint32_t>(inputPrecision.size()),
static_cast<uint32_t>(outputs->getPrecision().size()),
static_cast<uint32_t>(weightable._weights->getTensorDesc().getPrecision().size()),
static_cast<uint32_t>(biasPrecisionSize),
GetScaleFactor(layer, QuantizedDataType::weights),
GetScaleFactor(layer, QuantizedDataType::output),
ptr_inputs,
@ -1649,8 +1668,8 @@ void GNAGraphCompiler::AffinePrimitive(InferenceEngine::CNNLayerPtr layer, bool
connectOutput(layer, ptr_outputs, num_data_bytes_out);
auto transpose = false;
auto transposedRows = 0;
auto transposedCols = 0;
size_t transposedRows = 0;
size_t transposedCols = 0;
if (0 && connectionInfo.needTransposeWeights) {
// direct order is 0, 1, 2, 3, supported order is only 0,3,2,1 where dim 2 is usually equals to 1
@ -1695,8 +1714,8 @@ void GNAGraphCompiler::AffinePrimitive(InferenceEngine::CNNLayerPtr layer, bool
auto rowOffset = k * transposedRows * transposedCols * wpSize;
auto cbuffer = weightsBuffer + rowOffset;
auto u8Data = reinterpret_cast<uint8_t*>(data) + rowOffset;
for (int j = 0; j < transposedCols; j++) {
for (int i = 0; i < transposedRows; i++) {
for (size_t j = 0; j < transposedCols; j++) {
for (size_t i = 0; i < transposedRows; i++) {
auto offsetWrite = (transposedRows * j + i) * wpSize;
auto offsetRead = (i * transposedCols + j) * wpSize;
if (size < rowOffset + offsetWrite) {
@ -1757,8 +1776,10 @@ void GNAGraphCompiler::FillWeightOfAligningFilter(InferenceEngine::CNNLayerPtr l
auto outputs = *layer->outData.begin();
auto inputs = layer->insData.begin()->lock();
uint32_t num_rows_in = InferenceEngine::details::product(begin(inputs->getDims()), end(inputs->getDims()));
uint32_t num_rows_out = InferenceEngine::details::product(begin(outputs->getDims()), end(outputs->getDims()));
uint32_t num_rows_in =
static_cast<uint32_t>(InferenceEngine::details::product(begin(inputs->getDims()), end(inputs->getDims())));
uint32_t num_rows_out =
static_cast<uint32_t>(InferenceEngine::details::product(begin(outputs->getDims()), end(outputs->getDims())));
if (!ptrWeights) {
THROW_GNA_EXCEPTION << "Weights memory is not allocated!!!";
@ -1770,7 +1791,7 @@ void GNAGraphCompiler::FillWeightOfAligningFilter(InferenceEngine::CNNLayerPtr l
num_rows_out * ALIGN(num_rows_in, 8) * layer->precision.size(),
[=](void* data, size_t size) {
int out = 0;
for (int input = offset; input < num_rows_out + offset; ++input) {
for (size_t input = offset; input < num_rows_out + offset; ++input) {
auto mem_ptr = reinterpret_cast<uint8_t*>(data) + input * layer->precision.size() +
out * ALIGN(num_rows_in, 8) * layer->precision.size();
if (!isQuantized) {
@ -1807,7 +1828,7 @@ void GNAGraphCompiler::ConcatAlignFilterPrimitive(InferenceEngine::CNNLayerPtr l
: Limitations::kNoOfInputsDivisor;
uint32_t num_columns_in = GetDimFromBack(inputs->getDims(), 2);
uint32_t num_rows_out = GetDimFromBack(outputs->getDims(), 1);
uint32_t num_rows_in = filterLayer->_weights->size() / num_rows_out;
uint32_t num_rows_in = static_cast<uint32_t>(filterLayer->_weights->size()) / num_rows_out;
uint32_t num_padding = ALIGN(num_rows_in, num_of_inputs_divisor) - num_rows_in;
auto numRowsPadded = filterLayer->GetParamAsInt("num_rows_padded");
@ -1830,8 +1851,8 @@ void GNAGraphCompiler::ConcatAlignFilterPrimitive(InferenceEngine::CNNLayerPtr l
num_columns_in,
num_rows_copied,
num_columns_in,
inputs->getPrecision().size(),
inputs->getPrecision().size(),
static_cast<uint32_t>(inputs->getPrecision().size()),
static_cast<uint32_t>(inputs->getPrecision().size()),
GetScaleFactor(layer, QuantizedDataType::output),
num_rows_copied,
num_columns_in,
@ -1864,10 +1885,10 @@ void GNAGraphCompiler::ConcatAlignFilterPrimitive(InferenceEngine::CNNLayerPtr l
num_rows_in + num_padding,
num_columns_in,
num_rows_out,
inputs->getPrecision().size(),
outputs->getPrecision().size(),
filterLayer->_weights->getTensorDesc().getPrecision().size(),
biasPrecisionSize,
static_cast<uint32_t>(inputs->getPrecision().size()),
static_cast<uint32_t>(outputs->getPrecision().size()),
static_cast<uint32_t>(filterLayer->_weights->getTensorDesc().getPrecision().size()),
static_cast<uint32_t>(biasPrecisionSize),
GetScaleFactor(layer, QuantizedDataType::weights),
GetScaleFactor(layer, QuantizedDataType::output),
ptr_inputs,
@ -1880,7 +1901,11 @@ void GNAGraphCompiler::ConcatAlignFilterPrimitive(InferenceEngine::CNNLayerPtr l
size_t num_data_bytes_in =
num_columns_in * ALIGN(num_rows_in, num_of_inputs_divisor) * inputs->getPrecision().size();
connectInput(layer, ptr_inputs, num_data_bytes_in, num_rows_copied * inputs->getPrecision().size(), 0);
connectInput(layer,
ptr_inputs,
num_data_bytes_in,
static_cast<int32_t>(num_rows_copied * inputs->getPrecision().size()),
0);
connectOutput(layer, ptr_outputs, num_data_bytes_out);
{
@ -1898,7 +1923,7 @@ void GNAGraphCompiler::ConcatAlignFilterPrimitive(InferenceEngine::CNNLayerPtr l
->push_initializer(layer, ptr_weights, paddedWeightsSize, [=](void* data, size_t size) {
size_t roffset = weights_offset;
size_t woffset = 0;
for (int i = 0; i < num_rows_out && size >= woffset; i++) {
for (uint32_t i = 0; i < num_rows_out && size >= woffset; i++) {
ie_memcpy(reinterpret_cast<uint8_t*>(data) + woffset,
size - woffset,
filterLayer->_weights->cbuffer().as<const uint8_t*>() + roffset,
@ -1943,10 +1968,10 @@ void GNAGraphCompiler::ConvolutionFilterPrimitive(InferenceEngine::CNNLayerPtr l
const auto num_of_inputs_divisor = gna_config.gnaFlags.input_low_precision ? Limitations::kNoOfInputsLowPrecDivisor
: Limitations::kNoOfInputsDivisor;
const uint32_t orginalInputSize =
InferenceEngine::details::product(std::next(inputs->getDims().begin()), inputs->getDims().end());
const uint32_t orginalOutputSize =
InferenceEngine::details::product(std::next(outputs->getDims().begin()), outputs->getDims().end());
const uint32_t orginalInputSize = static_cast<uint32_t>(
InferenceEngine::details::product(std::next(inputs->getDims().begin()), inputs->getDims().end()));
const uint32_t orginalOutputSize = static_cast<uint32_t>(
InferenceEngine::details::product(std::next(outputs->getDims().begin()), outputs->getDims().end()));
if (orginalInputSize != orginalOutputSize) {
THROW_GNA_LAYER_EXCEPTION(filterLayer)
<< "Number in inputs (" << orginalInputSize << ") should be equal to number of outputs ("
@ -1967,22 +1992,23 @@ void GNAGraphCompiler::ConvolutionFilterPrimitive(InferenceEngine::CNNLayerPtr l
auto& currentComponent = dnnComponents.addComponent(layer->name, "affine");
layer->params["num_rows_for_pwl"] = std::to_string(numOutputs);
dnn->InitConvolutional1DComponent(currentComponent,
numInputsFullyPadedAndAligned,
numOutputs,
inputs->getPrecision().size(),
outputs->getPrecision().size(),
filterLayer->_weights->getTensorDesc().getPrecision().size(),
biasPrecision.size(),
numberOfFilters,
filterWidth,
convolutionStride,
GetScaleFactor(layer, QuantizedDataType::weights),
GetScaleFactor(layer, QuantizedDataType::output),
ptr_inputs,
ptr_outputs,
ptr_weights,
ptr_biases);
dnn->InitConvolutional1DComponent(
currentComponent,
numInputsFullyPadedAndAligned,
numOutputs,
static_cast<uint32_t>(inputs->getPrecision().size()),
static_cast<uint32_t>(outputs->getPrecision().size()),
static_cast<uint32_t>(filterLayer->_weights->getTensorDesc().getPrecision().size()),
static_cast<uint32_t>(biasPrecision.size()),
numberOfFilters,
filterWidth,
convolutionStride,
GetScaleFactor(layer, QuantizedDataType::weights),
GetScaleFactor(layer, QuantizedDataType::output),
ptr_inputs,
ptr_outputs,
ptr_weights,
ptr_biases);
size_t num_data_bytes_out =
InferenceEngine::details::product(begin(outputs->getDims()), end(outputs->getDims())) * 4;
@ -2063,7 +2089,7 @@ void GNAGraphCompiler::PWLPrimitive(InferenceEngine::CNNLayerPtr layer) {
if (LayerInfo(prevLayer).isConcatAlignFilter()) {
auto rowsCopiedOffset = prevLayer->GetParamAsInt("rows_copied_offset");
if (rowsCopiedOffset != 0) {
num_rows -= rowsCopiedOffset / outputs->getPrecision().size();
num_rows -= static_cast<uint32_t>(rowsCopiedOffset / outputs->getPrecision().size());
layer->params["output_offset"] = std::to_string(rowsCopiedOffset);
}
} else if (LayerInfo(prevLayer).isConvolutionFilter()) {
@ -2221,9 +2247,9 @@ void GNAGraphCompiler::PWLPrimitive(InferenceEngine::CNNLayerPtr layer) {
orientation,
num_rows,
num_columns,
inputs->getPrecision().size(),
outputs->getPrecision().size(),
ptr_pwl_segments.size(),
static_cast<uint32_t>(inputs->getPrecision().size()),
static_cast<uint32_t>(outputs->getPrecision().size()),
static_cast<uint32_t>(ptr_pwl_segments.size()),
output_pwl_scale_factor,
input_pwl_scale_factor,
ptr_inputs,
@ -2291,10 +2317,10 @@ void GNAGraphCompiler::PermutePrimitive(InferenceEngine::CNNLayerPtr layer) {
} else {
auto& currentComponent = dnnComponents.addComponent(layer->name, "interleave");
dnn->InitInterleaveComponent(currentComponent,
squeezedInputOrder[0],
squeezedInputOrder[1],
inputs->getPrecision().size(),
outputs->getPrecision().size(),
static_cast<uint32_t>(squeezedInputOrder[0]),
static_cast<uint32_t>(squeezedInputOrder[1]),
static_cast<uint32_t>(inputs->getPrecision().size()),
static_cast<uint32_t>(outputs->getPrecision().size()),
GetScaleFactor(layer, QuantizedDataType::output),
ptr_inputs,
ptr_outputs);
@ -2307,10 +2333,10 @@ void GNAGraphCompiler::PermutePrimitive(InferenceEngine::CNNLayerPtr layer) {
} else {
auto& currentComponent = dnnComponents.addComponent(layer->name, "deinterleave");
dnn->InitDeinterleaveComponent(currentComponent,
squeezedInputOrder[0],
squeezedInputOrder[1],
inputs->getPrecision().size(),
outputs->getPrecision().size(),
static_cast<uint32_t>(squeezedInputOrder[0]),
static_cast<uint32_t>(squeezedInputOrder[1]),
static_cast<uint32_t>(inputs->getPrecision().size()),
static_cast<uint32_t>(outputs->getPrecision().size()),
GetScaleFactor(layer, QuantizedDataType::output),
ptr_inputs,
ptr_outputs);
@ -2395,7 +2421,7 @@ void GNAGraphCompiler::connectOutput(InferenceEngine::CNNLayerPtr layer, void* p
log::debug() << "Connecting output " << layer->name << " ...\n";
// in case of Memory Layer it's input allocated in meminput layer
if (layer->outData.size() == 1) {
for (int j = 0; j != getInputTo(layer->outData.front()).size(); j++) {
for (int j = 0; j != static_cast<int>(getInputTo(layer->outData.front()).size()); j++) {
auto isNonFunctional = [](CNNLayerPtr l) {
return LayerInfo(l).isNonFunctional();
};
@ -2537,12 +2563,12 @@ void GNAGraphCompiler::connectOutput(InferenceEngine::CNNLayerPtr layer, void* p
[](CNNLayerPtr l) {
return !LayerInfo(l).isNonFunctional() && !LayerInfo(l).isSplit();
},
concatInputIdx++);
static_cast<int>(concatInputIdx++));
for (auto& rInput : realConcatInputs) {
if (LayerInfo(rInput.first).isInput()) {
inputs[rInput.first->name].allocated_size +=
inputLayer.tensorSize + inputLayer.offset;
static_cast<uint32_t>(inputLayer.tensorSize + inputLayer.offset);
}
if (LayerInfo(rInput.first).isConcat()) {
auto concatLayerInfo = concat_connection.find(rInput.first->name);
@ -2630,7 +2656,7 @@ ConnectionDetails GNAGraphCompiler::connectInput(CNNLayerPtr layer,
static_cast<uint8_t>(0),
num_data_bytes_in);
}
inputs_ptr_->at(prevLayer->name).allocated_size = num_data_bytes_in;
inputs_ptr_->at(prevLayer->name).allocated_size = static_cast<uint32_t>(num_data_bytes_in);
}
if (ALIGN(num_data_bytes_in, gnamem->getDataMemAlignment()) >
ALIGN(inputs_ptr_->at(prevLayer->name).get_allocated_size(), gnamem->getDataMemAlignment())) {
@ -2689,7 +2715,7 @@ ConnectionDetails GNAGraphCompiler::connectInput(CNNLayerPtr layer,
auto res = connectInput(splittingLayer,
ptr,
std::max(splitLayerInfoItem.reserved_size, num_data_bytes_in),
it->offset + offset,
static_cast<int32_t>(it->offset) + offset,
0);
log::debug() << "Connected \n";
return res;
@ -2785,7 +2811,7 @@ void GNAGraphCompiler::Reset() {
void GNAGraphCompiler::printTensorDesc(const std::string& name, const InferenceEngine::TensorDesc& desc) {
log::debug() << name << " layout: " << desc.getLayout() << " shape: ";
for (auto i = 0; i < desc.getDims().size(); i++) {
for (size_t i = 0; i < desc.getDims().size(); i++) {
if (i > 0) {
log::debug() << 'x';
}

6
src/plugins/intel_gna/src/gna_graph_patterns.hpp
View File

@ -343,7 +343,7 @@ inline std::vector<TranspositionInfo> FindTranspositionInfoFromPrevLayers(Infere
}
std::vector<TranspositionInfo> transpositionInfo;
for (int idx = 0; idx < layer->insData.size(); ++idx) {
for (int idx = 0; idx < static_cast<int>(layer->insData.size()); ++idx) {
if (!InferenceEngine::CNNNetHasPrevLayer(layer.get(), idx))
continue;
auto inputLayer = InferenceEngine::CNNNetPrevLayer(layer, idx);
@ -427,8 +427,8 @@ inline std::vector<TranspositionInfo> FindTranspositionInfoFromNextLayers(Infere
size_t crop_offset = 1;
size_t crop_out_size = 1;
bool first_cropped_dim = true;
for (int i = 0; i < crop_layer->axis.size(); ++i) {
if (crop_layer->offset[i] == 0 && crop_layer->dim[i] == in_dims[i])
for (size_t i = 0; i < crop_layer->axis.size(); ++i) {
if (crop_layer->offset[i] == 0 && crop_layer->dim[i] == static_cast<int32_t>(in_dims[i]))
continue;
crop_offset *= first_cropped_dim ? crop_layer->offset[i] : crop_layer->dim[i];
crop_out_size *= crop_layer->dim[i];

29
src/plugins/intel_gna/src/gna_graph_tools.hpp
View File

@ -56,9 +56,9 @@ inline std::vector<int> CNNLayerFindInsDataIdxes(DataPtr sourceData, CNNLayerPtr
if (outLayer.second.get() != layer.get()) {
continue;
}
for (int j = 0; j < layer->insData.size(); j++) {
for (size_t j = 0; j < layer->insData.size(); j++) {
if (areEqualDatas(layer->insData[j].lock(), sourceData)) {
dataIdxes.push_back(j);
dataIdxes.push_back(static_cast<int>(j));
}
}
}
@ -173,12 +173,12 @@ inline std::pair<InferenceEngine::CNNLayerPtr, std::vector<int>> CNNNetCheckNext
int iidx,
bool bOnlyCheck,
const std::function<bool(CNNLayerPtr)>& shouldSkip) {
if (oidx >= layer->outData.size()) {
if (oidx >= static_cast<int>(layer->outData.size())) {
if (bOnlyCheck)
return {nullptr, {}};
THROW_GNA_LAYER_EXCEPTION(layer) << " no next output layer for outdata: " << oidx;
}
if (getInputTo(layer->outData[oidx]).empty() || iidx >= getInputTo(layer->outData[oidx]).size()) {
if (getInputTo(layer->outData[oidx]).empty() || iidx >= static_cast<int>(getInputTo(layer->outData[oidx]).size())) {
if (bOnlyCheck)
return {nullptr, {}};
THROW_GNA_LAYER_EXCEPTION(layer) << " no next output layer for outdata: " << oidx
@ -192,13 +192,13 @@ inline std::pair<InferenceEngine::CNNLayerPtr, std::vector<int>> CNNNetCheckNext
int new_iidx = shouldSkip(outLayer->second) ? 0 : iidx;
while (shouldSkip(outLayer->second)) {
if (outLayer->second->outData.size() <= new_oidx) {
if (static_cast<int>(outLayer->second->outData.size()) <= new_oidx) {
if (bOnlyCheck)
return {nullptr, {}};
THROW_GNA_LAYER_EXCEPTION(outLayer->second) << " no next output layer for outdata: " << new_oidx;
}
if (getInputTo(outLayer->second->outData[new_oidx]).size() <= new_iidx) {
if (static_cast<int>(getInputTo(outLayer->second->outData[new_oidx]).size()) <= new_iidx) {
if (bOnlyCheck)
return {nullptr, {}};
THROW_GNA_LAYER_EXCEPTION(outLayer->second)
@ -229,7 +229,7 @@ inline std::vector<CNNLayerPtr> CNNNetGetAllNextLayersSkipCertain(Layer layer,
std::vector<std::map<std::string, CNNLayerPtr>> start;
if (oDataIdx == -1) {
for (int i = 0; i != layer->outData.size(); i++) {
for (size_t i = 0; i != layer->outData.size(); i++) {
start.push_back(getInputTo(layer->outData[i]));
}
} else {
@ -249,7 +249,7 @@ inline std::vector<CNNLayerPtr> CNNNetGetAllNextLayersSkipCertain(Layer layer,
int startIdx, endIdx;
if (oDataIdx == -1) {
startIdx = 0;
endIdx = layer->outData.size();
endIdx = static_cast<int>(layer->outData.size());
} else {
startIdx = oDataIdx;
endIdx = oDataIdx + 1;
@ -500,14 +500,14 @@ inline DataPtr CNNReplaceDataWithChangedTensorDescription(DataPtr old_data, Tens
getInputTo(new_dataPtr) = getInputTo(old_data);
auto creatorLayer = getCreatorLayer(old_data).lock();
getCreatorLayer(new_dataPtr) = creatorLayer;
size_t idx = -1;
size_t idx = invalid_data_idx;
for (size_t i = 0; i < creatorLayer->outData.size(); i++) {
if (areEqualDatas(old_data, creatorLayer->outData[i])) {
idx = i;
break;
}
}
if (idx == -1)
if (idx == invalid_data_idx)
THROW_GNA_EXCEPTION << "No idx for data was found";
creatorLayer->outData[idx] = new_dataPtr;
@ -571,8 +571,7 @@ inline void CNNNetworkInsertLayer(CNNLayerPtr after,
// located data
for (auto input_port_idx : CNNLayerFindInsDataIdxes(data, input)) {
if (((size_t)inDataIndex != invalid_data_idx && (size_t)inDataIndex == input_port_idx) ||
(size_t)inDataIndex == invalid_data_idx)
if ((inDataIndex == input_port_idx) || inDataIndex == invalid_data_idx)
input->insData[input_port_idx] = layerToInsert->outData.front();
number_of_connections_between_after_n_before++;
}
@ -631,7 +630,7 @@ inline void CNNNetworkInsertLayer(CNNLayerPtr after,
if (!bLocated) {
if (before != nullptr) {
IE_ASSERT(before->insData.size() == 1 ||
inDataIndex != invalid_data_idx && inDataIndex < before->insData.size());
(inDataIndex != invalid_data_idx && inDataIndex < before->insData.size()));
auto prevLayer = after;
for (auto idx = prevLayer->outData.begin(); idx != prevLayer->outData.end(); idx++) {
auto& outputports = getInputTo(*idx);
@ -775,7 +774,7 @@ inline void CNNNetworkRemoveLayer(CNNLayerPtr layer, bool checkDims = true) {
// remove osp->layer connection
for (auto&& outData : getInputTo(osp)) {
for (int i = 0; i < outData.second->insData.size(); i++) {
for (size_t i = 0; i < outData.second->insData.size(); i++) {
auto insData = outData.second->insData[i].lock();
if (!insData) {
IE_THROW() << "Cannot remove layer : " << layer->name << ", its output layer(" << outData.first
@ -886,7 +885,7 @@ inline uint32_t GetDimFromBack(const InferenceEngine::SizeVector& dims, const ui
if (backOffset > dims.size()) {
return 1;
}
const auto indexFromFront = dims.size() - backOffset;
const auto indexFromFront = static_cast<uint32_t>(dims.size()) - backOffset;
return GetDimFromFront(dims, indexFromFront);
}

2
src/plugins/intel_gna/src/gna_infer_request.cpp
View File

@ -111,7 +111,7 @@ bool GNAInferRequest::IsRequestCompleted() {
}
bool GNAInferRequest::SetRequestIndex(uint32_t request_index) {
return _infer_request_idx = request_index;
return (_infer_request_idx = request_index);
}
void GNAInferRequest::ValidateAndConfigureTimeout(int64_t& millis_timeout) {

31
src/plugins/intel_gna/src/gna_plugin.cpp
View File

@ -103,12 +103,13 @@ void GNAPlugin::copyInputData(T* dst,
for (uint32_t j = 0; j < num_vector_elements; j++) {
if (!std::is_same<T, U>::value) {
if (!gnaFlags->input_low_precision) {
dst[j * num_group + i] = ConvertFloatToInt16(src[i * num_vector_elements + j] * scaleFactor);
dst[j * num_group + i] =
static_cast<T>(ConvertFloatToInt16(src[i * num_vector_elements + j] * scaleFactor));
} else {
dst[j * num_group + i] = ConvertFloatToInt8(src[i * num_vector_elements + j] * scaleFactor);
}
} else {
dst[j * num_group + i] = src[i * num_vector_elements + j];
dst[j * num_group + i] = static_cast<T>(src[i * num_vector_elements + j]);
}
}
// pad to meet weight matrix row length requirement
@ -130,7 +131,7 @@ void GNAPlugin::copyInputData(T* dst,
std::memset(ptr_dst_vec, 0, num_vector_stride * sizeof(T));
if (!gnaFlags->input_low_precision) {
for (uint32_t j = 0; j < num_vector_elements; j++) {
ptr_dst_vec[j] = ConvertFloatToInt16(ptr_src_vec[j] * scaleFactor);
ptr_dst_vec[j] = static_cast<T>(ConvertFloatToInt16(ptr_src_vec[j] * scaleFactor));
}
} else {
for (uint32_t j = 0; j < num_vector_elements; j++) {
@ -558,10 +559,10 @@ bool GNAPlugin::TryToInitOutput(const std::string& portName, InferenceEngine::CN
outputs_.at(portName).ptrs.resize(gnaFlags->num_requests);
outputs_.at(portName).orientation = orientation;
outputs_.at(portName).set_precision(numBytesPerElem);
outputs_.at(portName).set_precision(static_cast<uint32_t>(numBytesPerElem));
outputs_.at(portName).scale_factor =
quantized != nullptr ? quantized->_dst_quant.GetScale() : kScaleFactorDefault;
outputs_.at(portName).num_elements = numElem;
outputs_.at(portName).num_elements = static_cast<uint32_t>(numElem);
// binding ptr for first infer request - then others will be setup during relocation
gnamem->getQueue(REGION_AUTO)->bind_ptr(layer, &outputs_.at(portName).ptrs.front(), outputPtr);
@ -963,7 +964,7 @@ void GNAPlugin::LoadNetwork(const CNNNetwork& _network) {
auto model = worker->model();
// relocating all operations data pointers
for (int j = 0; j != model->NumberOfOperations; j++) {
for (uint32_t j = 0; j != model->NumberOfOperations; j++) {
auto& gnaOperation = model->Operations[j];
relocate(const_cast<Gna2Tensor*>(gnaOperation.Operands[0])->Data, gnaOperation.Operands[0]->Data);
relocate(const_cast<Gna2Tensor*>(gnaOperation.Operands[1])->Data, gnaOperation.Operands[1]->Data);
@ -1098,7 +1099,7 @@ void GNAPlugin::DumpXNNToFile() const {
if (config.target->get_effective_compile_target() == target::DeviceVersion::GNA1_0) {
auto dump = gnadevice->dumpXnn(modelId);
dump.header.RwRegionSize = gnamem->getRegionBytes(REGION_SCRATCH);
dump.header.RwRegionSize = static_cast<uint32_t>(gnamem->getRegionBytes(REGION_SCRATCH));
dump.header.InputScalingFactor = inputsDesc.begin()->scale_factor;
dump.header.OutputScalingFactor = outputsDesc.begin()->scale_factor;
dumpStream.write(reinterpret_cast<char*>(&dump.header), sizeof(Gna2ModelSueCreekHeader));
@ -1216,10 +1217,10 @@ uint32_t GNAPlugin::QueueInference(const InferenceEngine::BlobMap& inputs, Infer
input.second->getTensorDesc().getPrecision(),
gnaFlags->sw_fp32 ? kScaleFactorDefault : inputs_ptr_->at(input_name).scale_factor,
inputOrientation,
importedFrames,
targetGroups,
importedElements,
importedElements);
static_cast<uint32_t>(importedFrames),
static_cast<uint32_t>(targetGroups),
static_cast<uint32_t>(importedElements),
static_cast<uint32_t>(importedElements));
if (model) {
Precision output_prc = buff_blob->getTensorDesc().getPrecision();
@ -1312,9 +1313,9 @@ RequestStatus GNAPlugin::WaitFor(uint32_t request_idx, int64_t millisTimeout) {
auto is1D = output_layout == InferenceEngine::Layout::C;
auto isScalar = output_layout == InferenceEngine::Layout::SCALAR;
auto is3D = output_layout == InferenceEngine::Layout::CHW;
auto batchSize = (is1D || isScalar || is3D) ? 1 : dims[0];
auto elementsPerBatch =
isScalar ? 1 : (is1D ? dims.front() : details::product(++std::begin(dims), std::end(dims)));
uint32_t batchSize = static_cast<uint32_t>((is1D || isScalar || is3D) ? 1 : dims[0]);
uint32_t elementsPerBatch = static_cast<uint32_t>(
isScalar ? 1 : (is1D ? dims.front() : details::product(++std::begin(dims), std::end(dims))));
OutputDesc& gna_output_desc = outputs_.at(output_name);
Blob::Ptr gna_output_blob = nullptr;
@ -1522,7 +1523,7 @@ InferenceEngine::IExecutableNetworkInternal::Ptr GNAPlugin::ImportNetwork(std::i
gnamem->commit();
auto model = createModelWrapperForImportNetwork(header.layersCount);
auto model = createModelWrapperForImportNetwork(static_cast<uint32_t>(header.layersCount));
GNAModelSerial::MemoryType mt;
auto serial = GNAModelSerial(&model->object(), mt);

2
src/plugins/intel_gna/src/gna_plugin.hpp
View File

@ -66,7 +66,7 @@ protected:
/**
* @brief size of RW segment without extra memory for parallel execution
*/
uint32_t rwSegmentSize = 0;
size_t rwSegmentSize = 0;
InferenceEngine::InputsDataMap inputs_data_map_; //!< Holds information about network inputs info
InferenceEngine::OutputsDataMap outputs_data_map_; //!< Holds information about network outputs data

2
src/plugins/intel_gna/src/gna_plugin_config.cpp
View File

@ -290,7 +290,7 @@ void Config::AdjustKeyMapValues() {
inputScaleFactors.push_back(kScaleFactorDefault);
}
keyConfigMap[GNA_CONFIG_KEY(SCALE_FACTOR)] = std::to_string(inputScaleFactors[0]);
for (int n = 0; n < inputScaleFactors.size(); n++) {
for (size_t n = 0; n < inputScaleFactors.size(); n++) {
keyConfigMap[GNA_CONFIG_KEY(SCALE_FACTOR) + std::string("_") + std::to_string(n)] =
std::to_string(inputScaleFactors[n]);
}

10
src/plugins/intel_gna/src/gna_tensor_tools.hpp
View File

@ -47,12 +47,12 @@ inline void ConvertTensorFromNCHWToNHWC(size_t precision,
if (transpositionInfoPart.transpose && transpositionInfoPart.num_transpose_rows != 1 &&
transpositionInfoPart.num_transpose_columns != 1) {
if (transpose_rows) {
for (int weightsRowIx = 0; weightsRowIx < rows; ++weightsRowIx) {
for (size_t weightsRowIx = 0; weightsRowIx < rows; ++weightsRowIx) {
auto weightsRowsOffset = weightsRowIx * partSize * precision;
auto cbuffer = buffer + weightsPartOffset + weightsRowsOffset;
auto weights_ptr = transposedWeights.data() + weightsPartOffset + weightsRowsOffset;
for (int colsIx = 0; colsIx < transpositionInfoPart.num_transpose_columns; ++colsIx) {
for (int rowIx = 0; rowIx < transpositionInfoPart.num_transpose_rows; ++rowIx) {
for (size_t colsIx = 0; colsIx < transpositionInfoPart.num_transpose_columns; ++colsIx) {
for (size_t rowIx = 0; rowIx < transpositionInfoPart.num_transpose_rows; ++rowIx) {
auto offsetWrite = (colsIx * transpositionInfoPart.num_transpose_rows + rowIx) * precision;
auto offsetRead =
(transpositionInfoPart.num_transpose_columns * rowIx + colsIx) * precision;
@ -66,8 +66,8 @@ inline void ConvertTensorFromNCHWToNHWC(size_t precision,
} else {
auto cbuffer = buffer + weightsPartOffset;
auto weights_ptr = transposedWeights.data() + weightsPartOffset;
for (int colsIx = 0; colsIx < transpositionInfoPart.num_transpose_columns; ++colsIx) {
for (int rowIx = 0; rowIx < transpositionInfoPart.num_transpose_rows; ++rowIx) {
for (size_t colsIx = 0; colsIx < transpositionInfoPart.num_transpose_columns; ++colsIx) {
for (size_t rowIx = 0; rowIx < transpositionInfoPart.num_transpose_rows; ++rowIx) {
auto offsetWrite =
(colsIx * transpositionInfoPart.num_transpose_rows + rowIx) * columns * precision;
auto offsetRead =

6
src/plugins/intel_gna/src/layers/gna_crop_layer.cpp
View File

@ -21,15 +21,15 @@ SimpleCrop get_crop_params(const std::vector<int32_t>& axis_in,
auto crop_axis_detected = false;
auto cropped_dim_size = total_size_to_crop;
for (int n = 0; n < axis_in.size(); n++) {
for (size_t n = 0; n < axis_in.size(); n++) {
const auto axis = axis_in[n];
if (axis < 0 || axis >= input_dims.size()) {
if (axis < 0 || axis >= static_cast<int32_t>(input_dims.size())) {
log::warning() << "Crop axis outside of input shape size detected.\n";
continue;
}
const auto input_dim = input_dims[axis];
// Skip axis that is untouched
if (offset_in[n] == 0 && dim_in[n] == input_dim) {
if (offset_in[n] == 0 && dim_in[n] == static_cast<int32_t>(input_dim)) {
continue;
}
if (crop_axis_detected) {

10
src/plugins/intel_gna/src/layers/gna_permute.hpp
View File

@ -30,7 +30,7 @@ public:
if (x < 0) {
THROW_GNA_EXCEPTION << "invalid order: element " << x << " should be >= 0";
}
if (x >= counter.size()) {
if (static_cast<size_t>(x) >= counter.size()) {
THROW_GNA_EXCEPTION << "invalid order: element " << x << " should be < " << counter.size();
}
if (counter[x]) {
@ -46,7 +46,7 @@ public:
std::list<cnt_type> permuteCycles;
bool newSeq = false;
for (int i = 0; i != orderVec.size();) {
for (int i = 0; i != static_cast<int>(orderVec.size());) {
// we have this permutation on the list already
if (counter[i]) {
newSeq = false;
@ -62,7 +62,7 @@ public:
}
permuteCycles.back().push_back({i, orderVec[i]});
counter[i] = true;
i = orderVec[i];
i = static_cast<int>(orderVec[i]);
continue;
}
// this dims not permuted
@ -70,7 +70,7 @@ public:
}
for (auto&& cycle : permuteCycles) {
for (int i = 0; i + 1 < cycle.size(); i++) {
for (size_t i = 0; i + 1 < cycle.size(); i++) {
permutes.push_back(cycle[i]);
}
}
@ -134,7 +134,7 @@ inline bool isTrivialPermute(const std::vector<int64_t> order, const std::vector
return false;
}
// check dims in between
for (int j = std::min(transp.first, transp.second) + 1; j < std::max(transp.first, transp.second); j++) {
for (int64_t j = std::min(transp.first, transp.second) + 1; j < std::max(transp.first, transp.second); j++) {
if (input_order_transformed[j] != 1) {
return false;
}

6
src/plugins/intel_gna/src/layers/gna_split_layer.hpp
View File

@ -65,14 +65,14 @@ inline std::vector<uint32_t> GetAlignedSplitSizes(uint32_t totalSize, uint32_t s
// account GNA HW limitations
inline std::pair<int64_t, std::vector<uint32_t>> AlignedSplitSizesPerAxis(InferenceEngine::SizeVector dims) {
std::vector<uint32_t> splitSizes = {};
auto totalElementsSize = InferenceEngine::details::product(std::begin(dims), std::end(dims));
auto totalElementsSize = static_cast<uint32_t>(InferenceEngine::details::product(std::begin(dims), std::end(dims)));
auto firstValuableDim = std::find_if(std::begin(dims), std::end(dims), [](size_t val) {
return val > 1;
});
IE_ASSERT(firstValuableDim != std::end(dims));
auto splittedElementsSize = *firstValuableDim;
auto splittedElementsSize = static_cast<uint32_t>(*firstValuableDim);
auto splittedDimIx = std::distance(std::begin(dims), firstValuableDim);
auto alignment = limitations::Limitations::get_instance()->get_memory_alignment();
auto alignment = static_cast<uint32_t>(limitations::Limitations::get_instance()->get_memory_alignment());
// Split output size should be multiple of device memory alignment to avoid align filters insertion,
// but we need to check if our input size to split exceeds alignment; if not we can always

4
src/plugins/intel_gna/src/log/dump.cpp
View File

@ -432,7 +432,7 @@ inline void DumpCompoundBias(std::ostream& dumpFile, const Gna2Tensor& tensor) {
}
inline void DumpCharArray(std::ostream& dumpFile, const char* carray, size_t count) {
auto i = 0;
size_t i = 0;
while (*(carray + i) != 0 && i < count) {
dumpFile << *(carray + i) << " ";
i++;
@ -494,7 +494,7 @@ void DumpGna2Model(const Gna2Model& gnaModel,
<< " type: " << GetOperandType(operand.Type) << " shape: " << GetSimpleString(operand.Shape)
<< " tag: " << foundName << " offset: " << offset << " size: "
<< Gna2RoundUp(GetGnaShapeSize(operand.Shape, GetTypeByteSize(operand.Type)),
Limitations::get_instance()->get_memory_alignment())
static_cast<uint32_t>(Limitations::get_instance()->get_memory_alignment()))
<< " data: " << operand.Data << " baseAlloc: " << foundPtr << " layout: ";
DumpCharArray(dumpFile, operand.Layout, GNA2_SHAPE_MAXIMUM_NUMBER_OF_DIMENSIONS);

2
src/plugins/intel_gna/src/memory/gna_allocator.hpp
View File

@ -27,7 +27,7 @@ public:
explicit GNAAllocator(std::shared_ptr<GNADeviceHelper> device) : _device(device) {}
uint8_t* allocate(std::size_t n) {
uint32_t granted = 0;
auto result = _device->alloc(n, &granted);
auto result = _device->alloc(static_cast<uint32_t>(n), &granted);
if (result == nullptr || granted == 0) {
throw std::bad_alloc();
}

4
src/plugins/intel_gna/src/memory/gna_mem_requests_queue.hpp
View File

@ -199,7 +199,7 @@ public:
auto size = getSize();
if (ptr >= ptrBegin && ptr < ptrBegin + size) {
auto curOffset = static_cast<uint8_t*>(ptr) - ptrBegin;
return {true, curOffset};
return {true, static_cast<uint32_t>(curOffset)};
}
return {false, 0};
}
@ -260,7 +260,7 @@ public:
// setting offsets
for (auto const& box : boxes) {
_mem_requests[box.id]._offset = memSolver.getOffset(box.id);
_mem_requests[box.id]._offset = memSolver.getOffset(static_cast<int>(box.id));
}
return _size;
} else {

4
src/plugins/intel_gna/src/memory/gna_memory.hpp
View File

@ -153,7 +153,7 @@ public:
return {true, curOffset};
}
const auto size = queuePair.second->getSize();
curOffset += ALIGN(size, _data_alignment);
curOffset += ALIGN(static_cast<uint32_t>(size), static_cast<uint32_t>(_data_alignment));
}
return {false, 0};
}
@ -276,7 +276,7 @@ protected:
ie_memcpy(cptr, cptr_avail_size, re._ptr_in, sz);
} else {
size_t of = 0;
for (int i = 0; i < re._num_elements; i++, of += re._element_size) {
for (size_t i = 0; i < re._num_elements; i++, of += re._element_size) {
std::copy(std::begin(re._data), std::end(re._data), cptr + of);
}
}

4
src/plugins/intel_gna/src/memory/gna_memory_state.cpp
View File

@ -73,7 +73,7 @@ void GNAVariableState::SetState(const InferenceEngine::Blob::Ptr& newState) {
pre_post_processing::ConvertToInt16(static_cast<int16_t*>(state->gna_ptr),
newState->buffer().as<float*>(),
1,
data_elements,
static_cast<uint32_t>(data_elements),
scale_factor);
} else {
THROW_GNA_EXCEPTION
@ -107,7 +107,7 @@ InferenceEngine::Blob::CPtr GNAVariableState::GetState() const {
auto buffer = result_blob->buffer().as<float*>();
auto new_gna_ptr = static_cast<int16_t*>(state->gna_ptr);
for (int i = 0; i < elements; i++) {
for (size_t i = 0; i < elements; i++) {
buffer[i] = new_gna_ptr[i] / scale_factor;
}

2
src/plugins/intel_gna/src/ops/reference/pwl.hpp
View File

@ -42,7 +42,7 @@ void pwl(const T* args, T* out, size_t count, const A* m, const A* b, const A* k
for (size_t i = 0; i < count; i++) {
// knots is one more than segments
size_t segment_index = range_search(args[i], knots, segments_number + 1);
out[i] = m[segment_index] * args[i] + b[segment_index];
out[i] = static_cast<T>(m[segment_index] * args[i] + b[segment_index]);
}
}
} // namespace reference

83
src/plugins/intel_gna/src/optimizer/gna_pass_manager.cpp
View File

@ -486,19 +486,20 @@ void ReorderMaxPoolPass::run() {
void SubstituteSoftSignPass::run() {
OV_ITT_SCOPED_TASK(itt::domains::GNA_LT, "SubstituteSoftSignPass");
// detecting following pattern
// irv7 model: irv10 model:
// a layer a layer
// | \ | \
// abs \ abs \
// | | | |
// | | add |
// | | | |
// power | power |
// \ / \ /
// mul mul
/* detecting following pattern
* irv7 model: irv10 model:
* a layer a layer
* | \ | \
* abs \ abs \
* | | | |
* | | add |
* | | | |
* power | power |
* \ / \ /
* mul mul
*/
auto hasNChildren = [](CNNLayerPtr l, int N) {
auto hasNChildren = [](CNNLayerPtr l, size_t N) {
if (l->outData.size() != 1)
return false;
if (getInputTo(l->outData.front()).size() != N)
@ -775,7 +776,7 @@ void RemovePermutationsNHWCToNCHWPass::run() {
? permute::GetPermuteOrder(InferenceEngine::Layout::NCHW, InferenceEngine::Layout::NHWC)
: std::vector<int32_t>{0, 2, 1};
InferenceEngine::SizeVector new_dims;
for (int i = 0; i < dims.size(); ++i) {
for (size_t i = 0; i < dims.size(); ++i) {
new_dims.push_back(dims[order[i]]);
}
data->setDims(new_dims);
@ -979,9 +980,10 @@ void InsertCopyLayerPass::run() {
}
std::vector<FuncChildrenInfo> results;
for (size_t i = 0; i < getInputTo(currentLayer->outData[0]).size(); ++i) {
auto next_layer = CNNNetGetNextLayerSkipCertain(currentLayer, 0, i, [](CNNLayerPtr origin) {
return false;
}).first;
auto next_layer =
CNNNetGetNextLayerSkipCertain(currentLayer, 0, static_cast<int>(i), [](CNNLayerPtr origin) {
return false;
}).first;
auto result = find_func_layers(next_layer,
currentLayer,
CNNLayerFindInsDataIdxes(currentLayer->outData[0], next_layer)[0]);
@ -1010,7 +1012,7 @@ void InsertCopyLayerPass::run() {
if (parents.find(inputData) != std::end(parents)) {
auto parent = getCreatorLayer(inputData);
IE_ASSERT(parent.lock() != nullptr);
InsertCopyLayer(parent.lock(), l, input_idx, this->getPassManager(), CopyLayerName);
InsertCopyLayer(parent.lock(), l, static_cast<int>(input_idx), this->getPassManager(), CopyLayerName);
} else {
parents.insert(inputData);
}
@ -1105,12 +1107,16 @@ void InsertCopyLayerPass::run() {
size_t memoryIdx = currentCopyIdx;
auto memoryLayer = MemoryLayers[memoryIdx].first;
auto inputIdx = MemoryLayers[memoryIdx].second;
InsertCopyLayer(l, memoryLayer, inputIdx, this->getPassManager(), DelayedCopyLayerName);
InsertCopyLayer(l,
memoryLayer,
static_cast<int>(inputIdx),
this->getPassManager(),
DelayedCopyLayerName);
} else {
size_t concatIdx = currentCopyIdx - MemoryLayers.size();
auto concatLayer = ConcatLayers[concatIdx].first;
auto inputIdx = ConcatLayers[concatIdx].second;
InsertCopyLayer(l, concatLayer, inputIdx, this->getPassManager(), CopyLayerName);
InsertCopyLayer(l, concatLayer, static_cast<int>(inputIdx), this->getPassManager(), CopyLayerName);
}
currentCopyIdx++;
}
@ -1142,7 +1148,11 @@ void InsertCopyLayerPass::run() {
auto inputData = l->insData[inputIdx].lock();
auto parentLayer = getCreatorLayer(inputData);
IE_ASSERT(parentLayer.lock() != nullptr);
InsertCopyLayer(parentLayer.lock(), l, inputIdx, this->getPassManager(), CopyLayerName);
InsertCopyLayer(parentLayer.lock(),
l,
static_cast<int>(inputIdx),
this->getPassManager(),
CopyLayerName);
}
}
}
@ -1202,7 +1212,7 @@ void FlattenTrivialConcatPass::run() {
// Reshape concat inputs
for (size_t input_idx = 0; input_idx != concatLayer->insData.size(); input_idx++) {
auto concatInput = getLayerByIndex(input_idx, concatLayer);
auto concatInput = getLayerByIndex(static_cast<int>(input_idx), concatLayer);
auto tensor = InferenceEngine::TensorDesc(concatInput->getTensorDesc());
tensor.reshape(SizeVector({1, total_sizes[input_idx]}), InferenceEngine::Layout::NC);
@ -1215,7 +1225,7 @@ void FlattenTrivialConcatPass::run() {
}
// Reshape concat outputs back to the original size
for (auto output_idx = 0; output_idx != concatLayer->outData.size(); output_idx++) {
for (size_t output_idx = 0; output_idx != concatLayer->outData.size(); output_idx++) {
auto output = concatLayer->outData[output_idx];
auto output_tensor_copy = TensorDesc(output->getTensorDesc());
@ -1258,7 +1268,7 @@ void InsertConcatAligningFilterPass::run() {
auto concatLayer = info.as<ConcatLayer*>();
IE_ASSERT(concatLayer != nullptr);
for (auto input_idx = 0; input_idx != concatLayer->insData.size(); input_idx++) {
for (auto input_idx = 0; input_idx != static_cast<int>(concatLayer->insData.size()); input_idx++) {
auto getLayerByIndex = [&concatLayer](int idx) {
auto input = concatLayer->insData[idx];
auto lockedInput = input.lock();
@ -1273,7 +1283,7 @@ void InsertConcatAligningFilterPass::run() {
auto outputSize = details::product(++dims.begin(), dims.end()) * Limitations::kBytesPerConcatElement;
auto useAlignFilterIf = [&concatLayer, &getLayerByIndex](int concat_input_idx) {
if (concatLayer->insData.size() <= concat_input_idx)
if (static_cast<int>(concatLayer->insData.size()) <= concat_input_idx)
return false;
auto nextInput = getCreatorLayer(getLayerByIndex(concat_input_idx)).lock();
@ -1330,7 +1340,7 @@ void InsertConcatAligningFilterPass::run() {
std::vector<float> filterWeights(num_rows_out * num_rows_in, 0.f);
auto identityIdx = num_rows_padded * num_rows_in;
for (int i = 0; i != num_rows_in; i++) {
for (size_t i = 0; i != num_rows_in; i++) {
filterWeights[identityIdx] = 1.0f;
identityIdx += num_rows_in + 1;
}
@ -1402,7 +1412,7 @@ void ReorderConcatInputsPass::run() {
return lockedInput;
};
for (auto input_idx = 1; input_idx != concatLayer->insData.size(); input_idx++) {
for (auto input_idx = 1; input_idx != static_cast<int>(concatLayer->insData.size()); input_idx++) {
auto concatInput = getLayerByIndex(input_idx);
auto currConcatLayer = getCreatorLayer(concatInput).lock();
@ -1570,7 +1580,7 @@ void InsertSplitAligningFilterPass::run() {
filterLayer->_out_depth = numberOfFilters;
filterLayer->_stride_x = numberOfFilters;
filterLayer->_stride_y = 1;
filterLayer->_kernel_x = filterSize;
filterLayer->_kernel_x = static_cast<uint32_t>(filterSize);
filterLayer->_kernel_y = 1;
filterLayer->_padding_x = 0;
filterLayer->_padding_y = 0;
@ -1620,7 +1630,7 @@ static InferenceEngine::Blob::Ptr tileBlob(Blob::Ptr& blob, size_t TileTo) {
auto tiledBlob = make_plain_blob(blob->getTensorDesc().getPrecision(), {TileTo});
tiledBlob->allocate();
for (int i = 0; i < (TileTo / weightsElements); ++i) {
for (size_t i = 0; i < (TileTo / weightsElements); ++i) {
ie_memcpy(tiledBlob->buffer().as<uint8_t*>() + i * weightsBytes, weightsBytes, blob->cbuffer(), weightsBytes);
}
return tiledBlob;
@ -1676,7 +1686,7 @@ void EltwiseSplitOverChannelsPass::run() {
split->outData.push_back(data);
}
// replacing connection X->eltwise to X->split
auto oData = CNNLayerFindOutData(l, kThEltwiseInput);
auto oData = CNNLayerFindOutData(l, static_cast<int>(kThEltwiseInput));
oData.second->second = split;
if (sameInputs) {
@ -1864,7 +1874,7 @@ void BreakFusingOfOutputLayersPass::run() {
*/
if (LayerInfo(layer).isPooling())
continue;
for (int output_idx = 0; output_idx < layer->outData.size(); output_idx++) {
for (size_t output_idx = 0; output_idx < layer->outData.size(); output_idx++) {
auto& output = layer->outData[output_idx];
auto& input_to = getInputTo(output);
@ -1952,7 +1962,7 @@ void RemoveSingleInputConcatPass::run() {
auto out = concat->outData[0];
for (auto& out_layer : getInputTo(out)) {
for (int i = 0; i < out_layer.second->insData.size(); i++) {
for (size_t i = 0; i < out_layer.second->insData.size(); i++) {
if (out_layer.second->insData[i].lock() == out) {
out_layer.second->insData[i] = in;
getInputTo(in.lock())[out_layer.second->name] = out_layer.second;
@ -2089,7 +2099,7 @@ void FuseFQIntoWeightsPass::run() {
inputTo = getInputTo(layerBeforeWeightable->outData[0]);
layers_connected_to_fq_count = inputTo.size();
}
for (int index = 0; index < layers_connected_to_fq_count; index++) {
for (int index = 0; index < static_cast<int>(layers_connected_to_fq_count); index++) {
auto weightableLayer =
CNNNetCheckNextLayerSkipCertain(layerBeforeWeightable, 0, index, true, isNonFunctional).first;
if (!weightableLayer || !LayerInfo(weightableLayer).isWeightable()) {
@ -2187,8 +2197,8 @@ void FuseFQIntoWeightsPass::run() {
size_t depth = 1;
intel_dnn_component_t component;
component.num_columns_in = weightDims[1];
component.num_rows_in = weightDims[0];
component.num_columns_in = static_cast<uint32_t>(weightDims[1]);
component.num_rows_in = static_cast<uint32_t>(weightDims[0]);
if (LayerInfo(weightableLayer).isConvolution()) {
depth = (weightDims.size() == 4) ? weightDims[2] * weightDims[3] : 1;
@ -2687,8 +2697,9 @@ void FuseFullyConnectedWithEltwisePass::run() {
CNNLayerPtr eltwise_input = nullptr;
for (size_t i = 0; i < eltwise->insData.size(); i++) {
// Get Eltwise's prev layer and check its kind
auto before_eltwise =
CNNNetHasPrevLayer(eltwise.get(), 0) ? CNNNetPrevLayerSkipCertain(eltwise, i, DoNotSkip) : nullptr;
auto before_eltwise = CNNNetHasPrevLayer(eltwise.get(), 0)
? CNNNetPrevLayerSkipCertain(eltwise, static_cast<int>(i), DoNotSkip)
: nullptr;
if (LayerInfo(before_eltwise).isConst()) {
eltwise_const = before_eltwise;
} else {

3
src/plugins/intel_gna/src/orientation_helper.cpp
View File

@ -40,7 +40,8 @@ void updateModelInputOrientationWithoutConvolution(const InferenceEngine::CNNLay
return;
}
auto columnProduct = std::accumulate(std::next(std::begin(dims)), std::end(dims), 1, std::multiplies<int>());
auto columnProduct =
std::accumulate(std::next(std::begin(dims)), std::end(dims), size_t{1}, std::multiplies<size_t>());
// does not make sense to check if further if any of sizes is equal to 1
// intput will be set to kDnnNonInterleavedOrientation

2
src/plugins/intel_gna/src/pre_post_process/preprocessing.hpp
View File

@ -32,7 +32,7 @@ inline void UnscaleAndCast(T2* ptr_dst,
T1* ptr_int_row = ptr_src + i * num_columns;
T2* ptr_float_row = ptr_dst + i * num_columns;
for (uint32_t j = 0; j < num_columns; j++) {
ptr_float_row[j] = static_cast<T2>(ptr_int_row[j]) / scale_factor;
ptr_float_row[j] = static_cast<T2>(ptr_int_row[j] / scale_factor);
}
}
}

8
src/plugins/intel_gna/src/pre_post_process/transposition_info.cpp
View File

@ -19,8 +19,8 @@ namespace pre_post_processing {
using namespace ov::opset10;
std::shared_ptr<ov::Model> ToProcessModel(const TranspositionInfo& t_info) {
int32_t c_size = t_info.num_transpose_rows;
int32_t hw_size = t_info.num_transpose_columns;
int32_t c_size = static_cast<int32_t>(t_info.num_transpose_rows);
int32_t hw_size = static_cast<int32_t>(t_info.num_transpose_columns);
if (!t_info.transpose) {
return nullptr;
@ -51,7 +51,7 @@ std::shared_ptr<ov::Model> ToProcessModel(const TranspositionInfo& t_info) {
std::shared_ptr<ov::Model> ToProcessModel(const std::vector<TranspositionInfo>& transposes) {
// count transposition parts need to be transposed
int count_transposes = std::count_if(transposes.begin(), transposes.end(), [](TranspositionInfo t_info) {
auto count_transposes = std::count_if(transposes.begin(), transposes.end(), [](TranspositionInfo t_info) {
return t_info.transpose || t_info.num_transpose_rows != 1 || t_info.num_transpose_columns != 1;
});
if (count_transposes == 0) {
@ -63,7 +63,7 @@ std::shared_ptr<ov::Model> ToProcessModel(const std::vector<TranspositionInfo>&
return ToProcessModel(transposes.front());
}
std::vector<int32_t> indices = {};
std::vector<size_t> indices = {};
for (auto& transpose : transposes) {
size_t c_size = transpose.num_transpose_rows;
size_t hw_size = transpose.num_transpose_columns;

2
src/plugins/intel_gna/src/request/worker_factory.cpp
View File

@ -66,7 +66,7 @@ std::vector<std::shared_ptr<Subrequest>> WorkerFactory::createModelSubrequests(
THROW_GNA_EXCEPTION << "device is nullptr";
};
for (int i = 0; i < submodelsNumber; ++i) {
for (uint32_t i = 0; i < submodelsNumber; ++i) {
// this models are needed only temporarily to create configurations
Gna2Model tempModel;
tempModel.NumberOfOperations =

2
src/plugins/intel_gna/src/request/worker_pool_impl.cpp
View File

@ -15,7 +15,7 @@ void WorkerPoolImpl::addModelWorker(std::shared_ptr<Worker> worker) {
if (!worker) {
THROW_GNA_EXCEPTION << "cannot not add nullptr request worker to the pool";
}
worker->setRepresentingIndex(modelWorkers_.size());
worker->setRepresentingIndex(static_cast<uint32_t>(modelWorkers_.size()));
modelWorkers_.push_back(std::move(worker));
}

3
src/plugins/intel_gna/src/runtime/cnn.cpp
View File

@ -78,7 +78,8 @@ void CNNMaxPoolLegacy(intel_dnn_component_t* component,
sum += ptr_inputs[k * in_c + i];
}
ptr_outputs[m * in_c + i] = ov::intel_gna::frontend::SaturationCast<int32_t>(sum, &num_saturate);
ptr_outputs[m * in_c + i] =
ov::intel_gna::frontend::SaturationCast<int32_t>(static_cast<float>(sum), &num_saturate);
m++;
}
if (num_saturate > 0) {

8
src/plugins/intel_gna/src/runtime/floatmath.cpp
View File

@ -9,10 +9,6 @@
#include <cstdint>
#include <cstdio>
#ifdef __cplusplus
extern "C" { // API uses C linkage so that it can be used by C and C++ applications
#endif
#ifdef _NO_MKL_
void cblas_sgemm1(const CBLAS_LAYOUT Layout,
const CBLAS_TRANSPOSE TransA,
@ -195,7 +191,3 @@ void sgemv_split(const uint32_t N,
C[i] = sum;
}
}
#ifdef __cplusplus
} // end extern "C"
#endif

8
src/plugins/intel_gna/src/runtime/floatmath.h
View File

@ -30,10 +30,6 @@ typedef CBLAS_LAYOUT CBLAS_ORDER; /* this for backward compatibility with CBLAS_
# endif // #ifndef _MKL_H_
#endif // #ifdef _NO_MKL_
#ifdef __cplusplus
extern "C" { // API uses C linkage so that it can be used by C and C++ applications
#endif
#ifdef _NO_MKL_
void cblas_sgemm1(const CBLAS_LAYOUT Layout,
const CBLAS_TRANSPOSE TransA,
@ -86,7 +82,3 @@ void sgemv_split(const uint32_t N,
const float* X,
const float* B,
float* C);
#ifdef __cplusplus
}
#endif

16
src/plugins/intel_gna/src/runtime/pwl.cpp
View File

@ -354,7 +354,7 @@ void PwlDesign(const DnnActivation& activation_type,
double pow_domain = x_max - x_min;
ptr_segment[0].xBase = static_cast<int32_t>(INT32_MIN & XBASEMASK); // zero out the 2 lsb
num_segment_size = static_cast<int32_t>(pow_domain * scale_in / (num_segments - 2) + 0.5);
int32_t x_min_scaled = x_min * scale_in + 0.5;
int32_t x_min_scaled = static_cast<int32_t>(x_min * scale_in + 0.5);
int32_t offset = x_min_scaled;
for (uint32_t i = 1; i < num_segments; i++) {
ptr_segment[i].xBase = static_cast<int32_t>(offset & XBASEMASK); // zero out the 2 lsb
@ -377,10 +377,10 @@ void PwlDesign(const DnnActivation& activation_type,
double slope = (valnext - val) / (static_cast<double>(xbasenext - xbase) / scale_in);
auto s = gna_slope(slope, scale_in, scale_out);
ptr_segment[i].slope = FloatToInt16(s.slope * s.slope_scale);
ptr_segment[i].slope = DoubleToInt16(s.slope * s.slope_scale);
ptr_segment[i].xBase = ptr_segment[i].xBase | s.slope_scale_index;
ptr_segment[i].yBase = FloatToInt16(val * scale_out);
ptr_segment[i].yBase = DoubleToInt16(val * scale_out);
log::debug() << (static_cast<int32_t>((ptr_segment[i].xBase & XBASEMASK)) / scale_out) << " "
<< (static_cast<float>((ptr_segment[i].yBase)) / scale_out) << " " << (s.slope / scale_out)
<< "\n";
@ -523,16 +523,16 @@ void PwlApply32(intel_dnn_component_t* component,
}
} break;
case kActFakeQuantize: {
double levels = static_cast<double>(transform->func_id.fqParams.levels);
auto levels = static_cast<uint32_t>(transform->func_id.fqParams.levels);
for (uint32_t i = num_row_start; i <= num_row_end; i++) {
auto inputChannel = transform->func_id.fqParams.inputPerChannel ? i : 0;
auto outputChannel = transform->func_id.fqParams.outputPerChannel ? i : 0;
double input_low = transform->func_id.fqParams.input_low[inputChannel];
double input_high = transform->func_id.fqParams.input_high[inputChannel];
double output_low = transform->func_id.fqParams.output_low[outputChannel];
double output_high = transform->func_id.fqParams.output_high[outputChannel];
float input_low = transform->func_id.fqParams.input_low[inputChannel];
float input_high = transform->func_id.fqParams.input_high[inputChannel];
float output_low = transform->func_id.fqParams.output_low[outputChannel];
float output_high = transform->func_id.fqParams.output_high[outputChannel];
for (uint32_t j = num_col_start; j <= num_col_end; j++) {
auto offset = i * num_columns + j;

42
src/plugins/intel_gna/src/serial/gna_model_serial.cpp
View File

@ -44,8 +44,8 @@ inline void writeBits(const T& obj, std::ostream& os) {
inline void writeString(const std::string& str, std::ostream& os) {
const char* c_str = str.c_str();
const size_t str_len = strlen(c_str) + 1;
writeBits(static_cast<uint32_t>(str_len), os);
const uint32_t str_len = static_cast<uint32_t>(strlen(c_str)) + 1;
writeBits(str_len, os);
writeNBytes(c_str, str_len, os);
}
@ -65,7 +65,7 @@ inline void write_pre_processing_model(const std::shared_ptr<ov::Model>& model,
// write BIN
size_t ir_bin_size = bin_buf.str().size();
writeBits(ir_bin_size, os);
writeNBytes(bin_buf.str().c_str(), ir_bin_size, os);
writeNBytes(bin_buf.str().c_str(), static_cast<uint32_t>(ir_bin_size), os);
}
template <class T>
@ -149,7 +149,7 @@ header_latest::ModelHeader GNAModelSerial::ReadHeader(std::istream& is) {
auto size_of_headers_header = sizeof(header_latest::ModelHeader::gnam) +
sizeof(header_latest::ModelHeader::headerSize) +
sizeof(header_latest::ModelHeader::Version);
if (stream_len > size_of_headers_header) {
if (static_cast<uint32_t>(stream_len) > size_of_headers_header) {
readNBytes(&header, static_cast<uint32_t>(size_of_headers_header), is);
} else {
readNBytes(&header, static_cast<uint32_t>(stream_len), is);
@ -286,7 +286,7 @@ void GNAModelSerial::Import(void* basePointer,
is.exceptions(std::istream::failbit);
// 2. Read inputs names
if (model_header_.version.major == 2) {
for (auto inputIndex = 0; inputIndex < model_header_.nInputs; inputIndex++) {
for (uint32_t inputIndex = 0; inputIndex < model_header_.nInputs; inputIndex++) {
std::string name =
(model_header_.version.minor >= 3) ? readString(is) : std::string("input" + std::to_string(inputIndex));
inputs[name] = InputDesc(name);
@ -294,14 +294,14 @@ void GNAModelSerial::Import(void* basePointer,
// Plugin uses ngraph pre/post-processing function to transpose inputs/outputs starting from version 2.9
if (model_header_.version.minor >= 5 && model_header_.version.minor <= 8) {
// 3. Read transposition input info
for (int inputIx = 0; inputIx < model_header_.nTransposeInputs; ++inputIx) {
for (uint32_t inputIx = 0; inputIx < model_header_.nTransposeInputs; ++inputIx) {
std::string inputName;
std::vector<TranspositionInfo> transpositionInfo;
ImportTranspositionInfo(is, inputName, transpositionInfo);
inputsTranspositionInfo[inputName] = transpositionInfo;
}
// 4. Read transposition output info
for (int outputIx = 0; outputIx < model_header_.nTransposeOutputs; ++outputIx) {
for (uint32_t outputIx = 0; outputIx < model_header_.nTransposeOutputs; ++outputIx) {
std::string outputName;
std::vector<TranspositionInfo> transpositionInfo;
ImportTranspositionInfo(is, outputName, transpositionInfo);
@ -313,7 +313,7 @@ void GNAModelSerial::Import(void* basePointer,
ImportNodes(is, basePointer, inputs);
// 6. Read output names
if (model_header_.version.major == 2) {
for (auto outputIndex = 0; outputIndex < model_header_.nOutputs; outputIndex++) {
for (uint32_t outputIndex = 0; outputIndex < model_header_.nOutputs; outputIndex++) {
std::string name = (model_header_.version.minor >= 3) ? readString(is)
: std::string("output" + std::to_string(outputIndex));
outputs[name] = OutputDesc(name);
@ -386,7 +386,7 @@ void GNAModelSerial::Import(void* basePointer,
pstates_->resize(nStates);
}
for (int i = 0; i != nStates; i++) {
for (uint32_t i = 0; i != nStates; i++) {
void* pSegment;
if (model_header_.version.major == 2) {
if (model_header_.version.minor < 6) {
@ -445,7 +445,7 @@ void GNAModelSerial::Export(const GnaAllocations& allocations, std::ostream& os)
header_latest::RuntimeEndPoint ep;
ep.elements_count = desc.num_elements;
ep.scaleFactor = desc.scale_factor;
ep.element_size = desc.tensor_precision.size();
ep.element_size = static_cast<uint32_t>(desc.tensor_precision.size());
ep.layout = desc.model_layout;
ep.precision = desc.model_precision;
ep.orientation = desc.orientation;
@ -456,9 +456,9 @@ void GNAModelSerial::Export(const GnaAllocations& allocations, std::ostream& os)
}
ep.descriptor_offset = found.second;
// shape
ep.shape.NumberOfDimensions = desc.dims.size();
ep.shape.NumberOfDimensions = static_cast<uint32_t>(desc.dims.size());
for (size_t i = 0; i < ep.shape.NumberOfDimensions; ++i) {
ep.shape.Dimensions[i] = desc.dims[i];
ep.shape.Dimensions[i] = static_cast<uint32_t>(desc.dims[i]);
}
return ep;
};
@ -475,10 +475,10 @@ void GNAModelSerial::Export(const GnaAllocations& allocations, std::ostream& os)
header.gnaMemSize = gnaGraphSize;
header.layersCount = layers.size();
header.nGroup = 1; // just to support the old models
header.nInputs = inputs_.size();
header.nOutputs = outputs_.size();
header.nTransposeInputs = inputs_transpose_info_.size();
header.nTransposeOutputs = outputs_transpose_info_.size();
header.nInputs = static_cast<uint32_t>(inputs_.size());
header.nOutputs = static_cast<uint32_t>(outputs_.size());
header.nTransposeInputs = static_cast<uint32_t>(inputs_transpose_info_.size());
header.nTransposeOutputs = static_cast<uint32_t>(outputs_transpose_info_.size());
// 1. Write header
writeBits(header, os);
// 2. Write input names
@ -584,8 +584,8 @@ void GNAModelSerial::Export(const GnaAllocations& allocations, std::ostream& os)
}
writeBits(found.second, os);
writeBits(reserved_size, os);
const auto nameSize = strlen(name.c_str()) + 1;
writeBits(static_cast<uint32_t>(nameSize), os);
const auto nameSize = static_cast<uint32_t>(strlen(name.c_str()) + 1);
writeBits(nameSize, os);
writeNBytes(name.c_str(), nameSize, os);
writeBits(scale_factor, os);
}
@ -615,7 +615,7 @@ void GNAModelSerial::ImportNodes(std::istream& is, void* base_ptr, T& nodes) {
node.allocated_size = node.get_required_size();
auto inputDims = InferenceEngine::SizeVector();
for (auto i = 0; i < ep.shape.NumberOfDimensions; ++i) {
for (uint32_t i = 0; i < ep.shape.NumberOfDimensions; ++i) {
inputDims.push_back(ep.shape.Dimensions[i]);
}
node.dims = inputDims;
@ -635,7 +635,7 @@ void GNAModelSerial::ImportNodes(std::istream& is, void* base_ptr, T& nodes) {
readBits(ir_bin_size, is);
ov::Tensor ir_bin_tensor(ov::element::u8, ov::Shape({ir_bin_size}));
readNBytes(ir_bin_tensor.data(), ir_bin_size, is);
readNBytes(ir_bin_tensor.data(), static_cast<uint32_t>(ir_bin_size), is);
// restore model
ov::Core core;
@ -654,7 +654,7 @@ void GNAModelSerial::ImportTranspositionInfo(std::istream& is,
readNBytes(&name[0], nameSize, is);
uint32_t transposeFragmentsSize = 0;
readNBits<32>(transposeFragmentsSize, is);
for (int rotFragmIx = 0; rotFragmIx < transposeFragmentsSize; ++rotFragmIx) {
for (uint32_t rotFragmIx = 0; rotFragmIx < transposeFragmentsSize; ++rotFragmIx) {
TranspositionInfo fragmentTranspositionInfo;
readNBytes(&fragmentTranspositionInfo, sizeof(TranspositionInfo), is);
transpositionInfo.push_back(fragmentTranspositionInfo);

2
src/plugins/intel_gna/src/serial/headers/2dot2/gna_model_header.hpp
View File

@ -107,7 +107,7 @@ struct RuntimeEndPoint {
intel_dnn_orientation_t orientation = kDnnUnknownOrientation;
RuntimeEndPoint() = default;
RuntimeEndPoint(double scaleFactor,
RuntimeEndPoint(float scaleFactor,
void* descriptor_ptr,
uint32_t element_size,
uint32_t elements_count,

2
src/plugins/intel_gna/src/serial/headers/2dot5/gna_model_header.hpp
View File

@ -143,7 +143,7 @@ struct RuntimeEndPoint {
intel_dnn_orientation_t orientation = kDnnUnknownOrientation;
RuntimeEndPoint() = default;
RuntimeEndPoint(double scaleFactor,
RuntimeEndPoint(float scaleFactor,
void* descriptor_ptr,
uint32_t element_size,
uint32_t elements_count,

2
src/plugins/intel_gna/src/serial/headers/2dot7/gna_model_header.hpp
View File

@ -174,7 +174,7 @@ struct RuntimeEndPoint {
descriptor_offset = old.descriptor_offset;
InferenceEngine::SizeVector dims = {ngroup, elements_count / ngroup};
shape.NumberOfDimensions = static_cast<uint32_t>(dims.size());
for (auto i = 0; i < dims.size(); i++) {
for (size_t i = 0; i < dims.size(); i++) {
shape.Dimensions[i] = static_cast<uint32_t>(dims[i]);
}
}

6
src/plugins/intel_gna/src/transformations/convert_dwsc_to_scaleshifts.cpp
View File

@ -53,16 +53,16 @@ static std::shared_ptr<ngraph::Node> DecomposeDWSC(std::shared_ptr<ngraph::opset
// Move filter over input performing multiplication and addition (scaleshift), take padding, stride, dilation and
// bias into account
for (int32_t input_position = static_cast<int32_t>(-pads_begin), o = 0; o < output_width;
for (int32_t input_position = static_cast<int32_t>(-pads_begin), o = 0; o < static_cast<int32_t>(output_width);
input_position += static_cast<int32_t>(stride_width), o++) {
std::shared_ptr<ngraph::Node> previous_layer_output, last_layer_output;
int32_t filter_end = static_cast<int32_t>(input_position + filter_width * dilation_width);
bool first = true;
filter_end = filter_end < input_width ? filter_end : static_cast<int32_t>(input_width);
filter_end = filter_end < static_cast<int32_t>(input_width) ? filter_end : static_cast<int32_t>(input_width);
for (int32_t filter_pos = input_position, filter_idx = 0; filter_pos < filter_end;
filter_pos += dilation_width, filter_idx++) {
filter_pos += static_cast<int32_t>(dilation_width), filter_idx++) {
if (filter_pos >= 0) {
auto conv_input_slice =
FlatCrop(flat_input_plane, filter_pos * input_channel_count, input_channel_count);

6
src/plugins/intel_gna/src/transformations/convert_matmul_to_pointwise_convolution.cpp
View File

@ -47,9 +47,9 @@ static std::tuple<bool, uint32_t, uint32_t, uint32_t> VerifyAndGetConvParams(
}
// Check if MatMul or corresponding pointwise convolution are supported by GNA
const uint32_t width = input1_shape.front();
const uint32_t in_channels = input2_shape.back();
const uint32_t out_channels = input2_shape.front();
const uint32_t width = static_cast<uint32_t>(input1_shape.front());
const uint32_t in_channels = static_cast<uint32_t>(input2_shape.back());
const uint32_t out_channels = static_cast<uint32_t>(input2_shape.front());
if (input1_shape.front() <= Limitations::kAffineMaxBatchSize ||
out_channels % Limitations::kConvFiltersNumDivider != 0 || out_channels > Limitations::kConvMaxFiltersNum ||
in_channels > Limitations::kConvFilterMaxSize) {

47
src/plugins/intel_gna/src/transformations/decompose_2d_convolution.cpp
View File

@ -94,16 +94,16 @@ static bool GNA30SupportedConv(const InferenceEngine::Precision& gnaPrecision,
return false;
}
const auto cnnIsValid = cnn2dValidatorPtr->ValidateCnn2D(graph_data.conv->get_friendly_name(),
conv_data.input_height,
conv_data.input_width,
conv_data.input_channel_count,
conv_data.filter_height,
conv_data.filter_width,
conv_data.filter_channel_count,
conv_data.filter_stride_height,
conv_data.filter_stride_width,
conv_data.filter_dilation_height,
conv_data.filter_dilation_width,
static_cast<uint32_t>(conv_data.input_height),
static_cast<uint32_t>(conv_data.input_width),
static_cast<uint32_t>(conv_data.input_channel_count),
static_cast<uint32_t>(conv_data.filter_height),
static_cast<uint32_t>(conv_data.filter_width),
static_cast<uint32_t>(conv_data.filter_channel_count),
static_cast<uint32_t>(conv_data.filter_stride_height),
static_cast<uint32_t>(conv_data.filter_stride_width),
static_cast<uint32_t>(conv_data.filter_dilation_height),
static_cast<uint32_t>(conv_data.filter_dilation_width),
OvGnaTypeIntFromBytes(gnaPrecision.size()),
false);
if (!cnnIsValid) {
@ -112,12 +112,13 @@ static bool GNA30SupportedConv(const InferenceEngine::Precision& gnaPrecision,
if (!graph_data.max_pool) {
return true;
}
const auto poolingValid = cnn2dValidatorPtr->ValidatePooling2D(graph_data.conv->get_friendly_name(),
graph_data.max_pool->get_kernel()[0],
graph_data.max_pool->get_kernel()[1],
graph_data.max_pool->get_strides()[0],
graph_data.max_pool->get_strides()[1],
false);
const auto poolingValid =
cnn2dValidatorPtr->ValidatePooling2D(graph_data.conv->get_friendly_name(),
static_cast<uint32_t>(graph_data.max_pool->get_kernel()[0]),
static_cast<uint32_t>(graph_data.max_pool->get_kernel()[1]),
static_cast<uint32_t>(graph_data.max_pool->get_strides()[0]),
static_cast<uint32_t>(graph_data.max_pool->get_strides()[1]),
false);
return poolingValid;
}
@ -147,13 +148,13 @@ static bool ShouldDecompose(GraphData& graph_data, const ConvData& conv_data) {
if (graph_data.conv_count == 1 &&
(((conv_data.input_height == 1 || conv_data.input_width == 1) && conv_data.filter_dilation_width == 1 &&
conv_data.filter_dilation_height == 1) ||
gna_convolution_layer::isMappableFrom2DTo1D(conv_data.input_height,
conv_data.input_width,
conv_data.input_channel_count,
conv_data.filter_height,
conv_data.filter_width,
conv_data.filter_stride_height,
conv_data.filter_stride_width)))
gna_convolution_layer::isMappableFrom2DTo1D(static_cast<uint32_t>(conv_data.input_height),
static_cast<uint32_t>(conv_data.input_width),
static_cast<uint32_t>(conv_data.input_channel_count),
static_cast<uint32_t>(conv_data.filter_height),
static_cast<uint32_t>(conv_data.filter_width),
static_cast<uint32_t>(conv_data.filter_stride_height),
static_cast<uint32_t>(conv_data.filter_stride_width))))
return false;
return true;

2
src/plugins/intel_gna/src/transformations/decompose_mvn.cpp
View File

@ -47,7 +47,7 @@ static bool ValidateAxes(const std::shared_ptr<opset8::Constant> axes_const, con
}
// Verify supported first axes value
if (axes_value != 2 && axes_value != 2 - mvn_shape_size)
if (axes_value != 2 && axes_value != static_cast<T>(2 - mvn_shape_size))
return false;
return true;

4
src/plugins/intel_gna/src/transformations/insert_copy_layer.cpp
View File

@ -258,7 +258,7 @@ bool HandleMultiConnectedLayerToConcatAndMemory::run_on_model(const std::shared_
std::vector<FuncChildrenInfo> results;
for (auto& child : current_node->output(0).get_target_inputs()) {
auto next_node = std::dynamic_pointer_cast<ngraph::Node>(child.get_node()->shared_from_this());
auto result = find_func_layers(next_node, current_node, child.get_index());
auto result = find_func_layers(next_node, current_node, static_cast<int32_t>(child.get_index()));
results.insert(results.end(), result.begin(), result.end());
}
@ -276,7 +276,7 @@ bool HandleMultiConnectedLayerToConcatAndMemory::run_on_model(const std::shared_
std::vector<FuncChildrenInfo> concat_nodes, memory_nodes;
for (auto& child : input_to) {
auto current_node = std::dynamic_pointer_cast<ngraph::Node>(child.get_node()->shared_from_this());
auto children_info = find_func_layers(current_node, node, child.get_index());
auto children_info = find_func_layers(current_node, node, static_cast<int32_t>(child.get_index()));
for (const auto& child_info : children_info) {
auto child = std::get<1>(child_info);

14
src/plugins/intel_gna/src/transformations/pwl_approximation.cpp
View File

@ -78,7 +78,7 @@ double pivot_search(const details::Function<T>& activation_function,
j = 0;
Delta = 1.0;
for (int i = 0; i < N; i++) {
for (uint32_t i = 0; i < N; i++) {
t[i].push_back(alpha_0 + (static_cast<double>((i + 1)) / static_cast<double>((N + 1))) * (alpha_N - alpha_0));
}
@ -86,7 +86,7 @@ double pivot_search(const details::Function<T>& activation_function,
// Figure 4: Box #2
alpha[0].resize(j + 1);
alpha[0][j] = alpha_0;
for (int i = 1; i < N; i++) {
for (uint32_t i = 1; i < N; i++) {
alpha[i].resize(j + 1);
alpha[i][j] =
(activation_function.get_value(t[i - 1][j]) - activation_function.get_value(t[i][j]) +
@ -98,7 +98,7 @@ double pivot_search(const details::Function<T>& activation_function,
alpha[N][j] = alpha_N;
// Figure 4: Box #3
for (int i = 0; i < N; i++) {
for (uint32_t i = 0; i < N; i++) {
epsilon[i].resize(j + 1);
epsilon[i][j] = sgn * (activation_function.first_derivative(t[i][j]) * (alpha[i][j] - t[i][j]) +
activation_function.get_value(t[i][j]) - activation_function.get_value(alpha[i][j]));
@ -117,7 +117,7 @@ double pivot_search(const details::Function<T>& activation_function,
max_epsilon_prev = max_epsilon;
max_epsilon = std::fabs(epsilon[0][j]);
min_epsilon = std::fabs(epsilon[0][j]);
for (int i = 1; i < N + 1; i++) {
for (uint32_t i = 1; i < N + 1; i++) {
if (std::fabs(epsilon[i][j]) > max_epsilon)
max_epsilon = std::fabs(epsilon[i][j]);
if (std::fabs(epsilon[i][j]) < min_epsilon)
@ -127,7 +127,7 @@ double pivot_search(const details::Function<T>& activation_function,
details::Pwl value;
result.resize(0);
epsilon_final = (max_epsilon + min_epsilon) / 4.0; // Andrzej's modification
for (int i = 0; i < N; i++) {
for (uint32_t i = 0; i < N; i++) {
value.alpha = alpha[i][j];
value.beta = sgn * activation_function.first_derivative(t[i][j]) * (value.alpha - t[i][j]) +
sgn * activation_function.get_value(t[i][j]) - epsilon_final;
@ -164,14 +164,14 @@ double pivot_search(const details::Function<T>& activation_function,
}
// Figure 4: Box #4
for (int i = 0; i < N; i++) {
for (uint32_t i = 0; i < N; i++) {
d[i].resize(j + 1);
d[i][j] = Delta * (epsilon[i + 1][j] - epsilon[i][j]) /
((epsilon[i + 1][j] / (alpha[i + 1][j] - t[i][j])) + (epsilon[i][j] / (t[i][j] - alpha[i][j])));
}
// Figure 4: Box #5
for (int i = 0; i < N; i++) {
for (uint32_t i = 0; i < N; i++) {
t[i].resize(j + 2);
t[i][j + 1] = t[i][j] + d[i][j];
}

22
src/plugins/intel_gna/src/transformations/split_convolution_with_large_buffer_size.cpp
View File

@ -26,14 +26,14 @@ static bool shouldSplitCnn(const ngraph::Output<ngraph::Node>& node) {
IE_ASSERT(convolution != nullptr);
auto& input = convolution->get_input_shape(0);
auto& filters = convolution->get_input_shape(1);
uint32_t width = input.back();
uint32_t in_channels = input.at(1);
auto width = static_cast<uint32_t>(input.back());
auto in_channels = static_cast<uint32_t>(input.at(1));
if (input.size() >= 4 && filters.size() >= 4) {
uint32_t height = input.at(2);
auto kH = filters.at(2);
auto kW = filters.at(3);
auto sH = convolution->get_strides().at(0);
auto sW = convolution->get_strides().at(1);
auto height = static_cast<uint32_t>(input.at(2));
auto kH = static_cast<uint32_t>(filters.at(2));
auto kW = static_cast<uint32_t>(filters.at(3));
auto sH = static_cast<uint32_t>(convolution->get_strides().at(0));
auto sW = static_cast<uint32_t>(convolution->get_strides().at(1));
if (gna_convolution_layer::is3DInputOr2DKernel(height, width, in_channels, kH, kW) &&
!gna_convolution_layer::isMappableFrom2DTo1D(height, width, in_channels, kH, kW, sH, sW)) {
return false;
@ -62,11 +62,11 @@ static bool Convert(std::shared_ptr<ngraph::Node> conv,
return false;
}
auto& input = conv->get_input_shape(0);
uint32_t width = input.back();
uint32_t in_channels = input.at(1);
uint32_t width = static_cast<uint32_t>(input.back());
uint32_t in_channels = static_cast<uint32_t>(input.at(1));
auto split_sizes = GetAlignedSplitSizes(width,
Limitations::kBufferMaxSize / in_channels,
Limitations::get_instance()->get_memory_alignment());
static_cast<uint32_t>(Limitations::get_instance()->get_memory_alignment()));
IE_ASSERT(split_sizes.size() > 1);
std::vector<int64_t> split_sizes_casted(split_sizes.size());
std::transform(std::begin(split_sizes), std::end(split_sizes), std::begin(split_sizes_casted), [](uint32_t size) {
@ -86,7 +86,7 @@ static bool Convert(std::shared_ptr<ngraph::Node> conv,
split_node->set_friendly_name(conv->get_friendly_name() + "/split");
ngraph::OutputVector convOutputs;
std::shared_ptr<ngraph::Node> root_node = fq ? fq : (add ? add : conv);
for (int i = 0; i < split_sizes.size(); ++i) {
for (size_t i = 0; i < split_sizes.size(); ++i) {
std::shared_ptr<ngraph::Node> output =
conv->clone_with_new_inputs({split_node->output(i), conv->input_value(1)});
ngraph::copy_runtime_info(split_node, output);

3
src/plugins/intel_gna/src/transformations/split_eltwise.cpp
View File

@ -26,7 +26,8 @@ inline bool is_eltwise_has_to_be_splitted(const ngraph::Output<ngraph::Node>& no
if (!eltwise)
return false;
auto o_dims = eltwise->get_output_shape(0);
auto total_elem_size = std::accumulate(std::begin(o_dims), std::end(o_dims), 1, std::multiplies<size_t>());
auto total_elem_size =
std::accumulate(std::begin(o_dims), std::end(o_dims), std::size_t{1}, std::multiplies<size_t>());
return (total_elem_size > Limitations::kBufferMaxSize);
}

2
src/plugins/intel_gna/tests/unit/backend/gna_make_pwl_identity.cpp
View File

@ -237,7 +237,7 @@ MakePWLIdentityTestParam createIdentityParamsForScales(double in, double out) {
// check if exception is thrown if division by zero is possible
// check if exception is thrown if scale factor with too big difference are used
const auto x_lower = FloatToInt32(static_cast<double>(std::numeric_limits<int16_t>::min()) * in / out);
const auto x_lower = DoubleToInt32(static_cast<double>(std::numeric_limits<int16_t>::min()) * in / out);
if (slope.value == 0 || x_lower == 0) {
should_throw = true;