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

[GNA] Fix GNA namespaces (#14920)

Browse Source
This commit is contained in:
Szymon Irzabek 2023-01-09 10:39:17 +01:00 committed by GitHub
parent c7957d8ca6
commit c20c867683
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
5 changed files with 80 additions and 76 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -45,18 +45,18 @@
*/ */
#define LIGHT_DUMP #define LIGHT_DUMP
using gna_convolution_layer::outputFromConv; using ov::intel_gna::gna_convolution_layer::outputFromConv;
using gna_convolution_layer::outputFromPooling; using ov::intel_gna::gna_convolution_layer::outputFromPooling;
namespace ov { namespace ov {
namespace intel_gna { namespace intel_gna {
namespace backend { namespace backend {
void backend::AMIntelDNN::BeginNewWrite(uint32_t index) { void AMIntelDNN::BeginNewWrite(uint32_t index) {
dump_write_index = index; dump_write_index = index;
} }
void backend::AMIntelDNN::Init(memory::GNAMemoryInterface* memoryInterface, void AMIntelDNN::Init(memory::GNAMemoryInterface* memoryInterface,
intel_dnn_number_type_t compute_precision, intel_dnn_number_type_t compute_precision,
float scale_factor) { float scale_factor) {
memory = memoryInterface; memory = memoryInterface;
@ -67,11 +67,11 @@ void backend::AMIntelDNN::Init(memory::GNAMemoryInterface* memoryInterface,
num_active_outputs_ = 0; num_active_outputs_ = 0;
} }
backend::AMIntelDNN::~AMIntelDNN() { AMIntelDNN::~AMIntelDNN() {
component.clear(); component.clear();
} }
void backend::AMIntelDNN::InitActiveList(uint32_t *ptr_active_list) { void AMIntelDNN::InitActiveList(uint32_t *ptr_active_list) {
ptr_active_outputs_ = ptr_active_list; ptr_active_outputs_ = ptr_active_list;
if (ptr_active_list == nullptr) { if (ptr_active_list == nullptr) {
if (component[component.size() - 1].orientation_out == kDnnInterleavedOrientation) { if (component[component.size() - 1].orientation_out == kDnnInterleavedOrientation) {
@ -85,7 +85,7 @@ void backend::AMIntelDNN::InitActiveList(uint32_t *ptr_active_list) {
} }
void backend::AMIntelDNN::InitAffineComponentPrivate(intel_dnn_component_t &comp, void AMIntelDNN::InitAffineComponentPrivate(intel_dnn_component_t &comp,
uint32_t num_rows_in, uint32_t num_rows_in,
uint32_t num_columns, uint32_t num_columns,
uint32_t num_rows_out, uint32_t num_rows_out,
@ -129,7 +129,7 @@ void backend::AMIntelDNN::InitAffineComponentPrivate(intel_dnn_component_t &comp
} }
void backend::AMIntelDNN::InitConvolutional1DComponentPrivate(intel_dnn_component_t &comp, void AMIntelDNN::InitConvolutional1DComponentPrivate(intel_dnn_component_t &comp,
uint32_t num_columns_in, uint32_t num_columns_in,
uint32_t num_columns_out, uint32_t num_columns_out,
uint32_t num_bytes_per_input, uint32_t num_bytes_per_input,
@ -193,7 +193,7 @@ void backend::AMIntelDNN::InitConvolutional1DComponentPrivate(intel_dnn_componen
} }
} }
void backend::AMIntelDNN::InitConvolutional2DComponentPrivate(intel_dnn_component_t& comp, void AMIntelDNN::InitConvolutional2DComponentPrivate(intel_dnn_component_t& comp,
OvGnaTensor inputTensor, OvGnaTensor inputTensor,
OvGnaTensor outputTensor, OvGnaTensor outputTensor,
OvGnaTensor filterTensor, OvGnaTensor filterTensor,
@ -228,7 +228,7 @@ void backend::AMIntelDNN::InitConvolutional2DComponentPrivate(intel_dnn_componen
ptr_outputs = &comp.ptr_outputs; ptr_outputs = &comp.ptr_outputs;
} }
bool backend::AMIntelDNN::isOperationCnnLegacySpecific(const Gna2Operation& op) { bool AMIntelDNN::isOperationCnnLegacySpecific(const Gna2Operation& op) {
// GNA compile target GNA_TARGET_3_0 does not support pooling window < pooling stride // GNA compile target GNA_TARGET_3_0 does not support pooling window < pooling stride
return op.Type == Gna2OperationTypeConvolution && return op.Type == Gna2OperationTypeConvolution &&
op.NumberOfParameters > std::max(PoolStrideParamIdx, PoolWinParamIdx) && op.NumberOfParameters > std::max(PoolStrideParamIdx, PoolWinParamIdx) &&
@ -238,7 +238,7 @@ bool backend::AMIntelDNN::isOperationCnnLegacySpecific(const Gna2Operation& op)
static_cast<Gna2Shape*>(op.Parameters[PoolStrideParamIdx])->Dimensions[0] > static_cast<Gna2Shape*>(op.Parameters[PoolWinParamIdx])->Dimensions[0]; static_cast<Gna2Shape*>(op.Parameters[PoolStrideParamIdx])->Dimensions[0] > static_cast<Gna2Shape*>(op.Parameters[PoolWinParamIdx])->Dimensions[0];
} }
void backend::AMIntelDNN::updateNumberOfOutputsIfPoolingEnabled(Gna2Model& gnaModel, bool useLegacyFormula) { void AMIntelDNN::updateNumberOfOutputsIfPoolingEnabled(Gna2Model& gnaModel, bool useLegacyFormula) {
IE_ASSERT(gnaModel.Operations != nullptr || gnaModel.NumberOfOperations == 0); IE_ASSERT(gnaModel.Operations != nullptr || gnaModel.NumberOfOperations == 0);
for (uint32_t i = 0; i < gnaModel.NumberOfOperations; i++) { for (uint32_t i = 0; i < gnaModel.NumberOfOperations; i++) {
auto& gnaOp = gnaModel.Operations[i]; auto& gnaOp = gnaModel.Operations[i];
@ -271,7 +271,7 @@ void backend::AMIntelDNN::updateNumberOfOutputsIfPoolingEnabled(Gna2Model& gnaMo
} }
} }
void backend::AMIntelDNN::InitMaxpoolComponentPrivate(intel_dnn_component_t &comp, void AMIntelDNN::InitMaxpoolComponentPrivate(intel_dnn_component_t &comp,
std::array<uint32_t, 3> inCHW, std::array<uint32_t, 3> inCHW,
std::array<uint32_t, 3> outCHW, std::array<uint32_t, 3> outCHW,
uint32_t num_bytes_per_input, uint32_t num_bytes_per_input,
@ -302,7 +302,7 @@ void backend::AMIntelDNN::InitMaxpoolComponentPrivate(intel_dnn_component_t &com
} }
} }
void backend::AMIntelDNN::InitCopyComponentPrivate(intel_dnn_component_t &comp, void AMIntelDNN::InitCopyComponentPrivate(intel_dnn_component_t &comp,
intel_dnn_orientation_t orientation, intel_dnn_orientation_t orientation,
uint32_t num_rows_in, uint32_t num_rows_in,
uint32_t num_columns_in, uint32_t num_columns_in,
@ -341,7 +341,7 @@ void backend::AMIntelDNN::InitCopyComponentPrivate(intel_dnn_component_t &comp,
} }
} }
void backend::AMIntelDNN::InitPiecewiseLinearComponentPrivate(intel_dnn_component_t &comp, void AMIntelDNN::InitPiecewiseLinearComponentPrivate(intel_dnn_component_t &comp,
const DnnActivation& function_id, const DnnActivation& function_id,
intel_dnn_orientation_t orientation, intel_dnn_orientation_t orientation,
uint32_t num_rows, uint32_t num_rows,
@ -383,7 +383,7 @@ void backend::AMIntelDNN::InitPiecewiseLinearComponentPrivate(intel_dnn_componen
} }
} }
void backend::AMIntelDNN::InitInterleaveComponentPrivate(intel_dnn_component_t &comp, void AMIntelDNN::InitInterleaveComponentPrivate(intel_dnn_component_t &comp,
uint32_t num_rows_in, uint32_t num_rows_in,
uint32_t num_columns_in, uint32_t num_columns_in,
uint32_t num_bytes_per_input, uint32_t num_bytes_per_input,
@ -412,7 +412,7 @@ void backend::AMIntelDNN::InitInterleaveComponentPrivate(intel_dnn_component_t &
} }
} }
void backend::AMIntelDNN::InitDeinterleaveComponentPrivate(intel_dnn_component_t &comp, void AMIntelDNN::InitDeinterleaveComponentPrivate(intel_dnn_component_t &comp,
uint32_t num_rows_in, uint32_t num_rows_in,
uint32_t num_columns_in, uint32_t num_columns_in,
uint32_t num_bytes_per_input, uint32_t num_bytes_per_input,
@ -441,7 +441,7 @@ void backend::AMIntelDNN::InitDeinterleaveComponentPrivate(intel_dnn_component_t
} }
} }
float backend::AMIntelDNN::OutputScaleFactor(intel_dnn_component_t &comp) { float AMIntelDNN::OutputScaleFactor(intel_dnn_component_t &comp) {
return comp.output_scale_factor; return comp.output_scale_factor;
} }
@ -453,7 +453,7 @@ struct InputEndPoint {
InputEndPoint(int nidx, size_t sz, size_t esize) : idx(nidx), size(sz), num_bytes_per_output(esize) {} InputEndPoint(int nidx, size_t sz, size_t esize) : idx(nidx), size(sz), num_bytes_per_output(esize) {}
}; };
void backend::AMIntelDNN::WriteGraphWizModel(const char *filename) { void AMIntelDNN::WriteGraphWizModel(const char *filename) {
auto & components = component; auto & components = component;
#define IS_AFFINE(k)\ #define IS_AFFINE(k)\
@ -720,7 +720,7 @@ void PrintTensors(std::ofstream& out, T tensors) {
} }
} }
void backend::AMIntelDNN::PrintOffset(std::ofstream& out, const std::string& type, void* ptr) { void AMIntelDNN::PrintOffset(std::ofstream& out, const std::string& type, void* ptr) {
const auto queue = memory->getQueue(ptr); const auto queue = memory->getQueue(ptr);
std::string typeOfRegion = "UNKNOWN_QUEUE"; std::string typeOfRegion = "UNKNOWN_QUEUE";
auto offset = std::numeric_limits<uint32_t>::max(); auto offset = std::numeric_limits<uint32_t>::max();
@ -733,9 +733,9 @@ void backend::AMIntelDNN::PrintOffset(std::ofstream& out, const std::string& typ
<< "0x" << std::setfill('0') << std::setw(8) << std::hex << offset << "\n"; << "0x" << std::setfill('0') << std::setw(8) << std::hex << offset << "\n";
} }
void backend::AMIntelDNN::WriteDnnText(const char *filename, intel_dnn_number_type_t logging_precision) { void AMIntelDNN::WriteDnnText(const char *filename, intel_dnn_number_type_t logging_precision) {
if ((compute_precision_ == kDnnFloat) && (logging_precision == kDnnInt)) { if ((compute_precision_ == kDnnFloat) && (logging_precision == kDnnInt)) {
fprintf(stderr, "Error trying to write floating point DNN as integer in backend::AMIntelDNN::WriteDnnText().\n"); fprintf(stderr, "Error trying to write floating point DNN as integer in AMIntelDNN::WriteDnnText().\n");
fprintf(stderr, " Please convert to integer first.\n"); fprintf(stderr, " Please convert to integer first.\n");
throw -1; throw -1;
} }
@ -1358,7 +1358,7 @@ void backend::AMIntelDNN::WriteDnnText(const char *filename, intel_dnn_number_ty
} }
} }
uint32_t backend::AMIntelDNN::CountLayers() { uint32_t AMIntelDNN::CountLayers() {
uint32_t n = 0; uint32_t n = 0;
for (auto && c : component) { for (auto && c : component) {
if (c.operation == kDnnAffineOp if (c.operation == kDnnAffineOp
@ -1376,7 +1376,7 @@ uint32_t backend::AMIntelDNN::CountLayers() {
return n; return n;
} }
void backend::AMIntelDNN::InitGNAStruct(Gna2Model *gnaModel, const std::string& gnaCompileTarget) { void AMIntelDNN::InitGNAStruct(Gna2Model *gnaModel, const std::string& gnaCompileTarget) {
Gna2Operation * gnaOperation; Gna2Operation * gnaOperation;
if (gnaModel == nullptr) if (gnaModel == nullptr)
THROW_GNA_EXCEPTION << "Invalid input parameter"; THROW_GNA_EXCEPTION << "Invalid input parameter";
@ -1384,12 +1384,12 @@ void backend::AMIntelDNN::InitGNAStruct(Gna2Model *gnaModel, const std::string&
THROW_GNA_EXCEPTION << "InitGNAStruct can't work on preallocated layers array"; THROW_GNA_EXCEPTION << "InitGNAStruct can't work on preallocated layers array";
if (component.empty()) if (component.empty())
THROW_GNA_EXCEPTION << "empty model in backend::AMIntelDNN::InitGNAStruct()"; THROW_GNA_EXCEPTION << "empty model in AMIntelDNN::InitGNAStruct()";
gnaModel->NumberOfOperations = CountLayers(); gnaModel->NumberOfOperations = CountLayers();
gnaModel->Operations = reinterpret_cast<Gna2Operation*>(gnaUserAllocator(gnaModel->NumberOfOperations * sizeof(Gna2Operation))); gnaModel->Operations = reinterpret_cast<Gna2Operation*>(gnaUserAllocator(gnaModel->NumberOfOperations * sizeof(Gna2Operation)));
if (gnaModel->Operations == nullptr) if (gnaModel->Operations == nullptr)
THROW_GNA_EXCEPTION << "out of memory in backend::AMIntelDNN::InitGNAStruct()"; THROW_GNA_EXCEPTION << "out of memory in AMIntelDNN::InitGNAStruct()";
memset(gnaModel->Operations, 0, gnaModel->NumberOfOperations * sizeof(Gna2Operation)); memset(gnaModel->Operations, 0, gnaModel->NumberOfOperations * sizeof(Gna2Operation));
gnaOperation = gnaModel->Operations; gnaOperation = gnaModel->Operations;
for (int i = 0; i < component.size(); i++) { for (int i = 0; i < component.size(); i++) {
@ -1641,7 +1641,7 @@ void backend::AMIntelDNN::InitGNAStruct(Gna2Model *gnaModel, const std::string&
gnaModel->NumberOfOperations = static_cast<uint32_t>(std::distance(gnaModel->Operations, gnaOperation)); gnaModel->NumberOfOperations = static_cast<uint32_t>(std::distance(gnaModel->Operations, gnaOperation));
} }
void backend::AMIntelDNN::DestroyGNAStruct(Gna2Model *gnaModel) { void AMIntelDNN::DestroyGNAStruct(Gna2Model *gnaModel) {
if (gnaModel->Operations != nullptr) { if (gnaModel->Operations != nullptr) {
for (uint32_t i = 0; i < gnaModel->NumberOfOperations; i++) { for (uint32_t i = 0; i < gnaModel->NumberOfOperations; i++) {
switch (gnaModel->Operations[i].Type) { switch (gnaModel->Operations[i].Type) {
@ -1661,7 +1661,7 @@ void backend::AMIntelDNN::DestroyGNAStruct(Gna2Model *gnaModel) {
gnaModel->NumberOfOperations = 0; gnaModel->NumberOfOperations = 0;
} }
void backend::AMIntelDNN::WriteInputAndOutputTextGNA(const Gna2Model & model) { void AMIntelDNN::WriteInputAndOutputTextGNA(const Gna2Model & model) {
#ifdef LIGHT_DUMP #ifdef LIGHT_DUMP
dump::WriteInputAndOutputTextGNAImpl( dump::WriteInputAndOutputTextGNAImpl(
model, model,
@ -1670,7 +1670,7 @@ void backend::AMIntelDNN::WriteInputAndOutputTextGNA(const Gna2Model & model) {
#endif #endif
} }
void backend::AMIntelDNN::WriteInputAndOutputText() { void AMIntelDNN::WriteInputAndOutputText() {
#ifdef LIGHT_DUMP #ifdef LIGHT_DUMP
for (uint32_t i = 0; i < num_components(); i++) { for (uint32_t i = 0; i < num_components(); i++) {
std::stringstream out_file_name; std::stringstream out_file_name;
@ -1766,11 +1766,11 @@ void backend::AMIntelDNN::WriteInputAndOutputText() {
#endif #endif
} }
uint32_t backend::AMIntelDNN::num_components() { uint32_t AMIntelDNN::num_components() {
return static_cast<uint32_t>(component.size()); return static_cast<uint32_t>(component.size());
} }
uint32_t backend::AMIntelDNN::num_gna_layers() { uint32_t AMIntelDNN::num_gna_layers() {
uint32_t num_layers = 0; uint32_t num_layers = 0;
std::set<intel_dnn_operation_t> gna_layers({ kDnnAffineOp, std::set<intel_dnn_operation_t> gna_layers({ kDnnAffineOp,
kDnnDiagonalOp, kDnnDiagonalOp,
@ -1787,27 +1787,27 @@ uint32_t backend::AMIntelDNN::num_gna_layers() {
return num_layers; return num_layers;
} }
uint32_t backend::AMIntelDNN::num_group_in() { uint32_t AMIntelDNN::num_group_in() {
return ((!component.empty()) ? ((component[0].orientation_in == kDnnInterleavedOrientation) return ((!component.empty()) ? ((component[0].orientation_in == kDnnInterleavedOrientation)
? component[0].num_columns_in : component[0].num_rows_in) : 0); ? component[0].num_columns_in : component[0].num_rows_in) : 0);
} }
uint32_t backend::AMIntelDNN::num_group_out() { uint32_t AMIntelDNN::num_group_out() {
return ((!component.empty()) ? ((component[component.size() - 1].orientation_out == kDnnInterleavedOrientation) return ((!component.empty()) ? ((component[component.size() - 1].orientation_out == kDnnInterleavedOrientation)
? component[component.size() - 1].num_columns_out : component[component.size() - ? component[component.size() - 1].num_columns_out : component[component.size() -
1].num_rows_out) : 0); 1].num_rows_out) : 0);
} }
uint32_t backend::AMIntelDNN::num_inputs() { uint32_t AMIntelDNN::num_inputs() {
return component.empty() ? 0 : component[0].num_rows_in; return component.empty() ? 0 : component[0].num_rows_in;
} }
uint32_t backend::AMIntelDNN::num_outputs() { uint32_t AMIntelDNN::num_outputs() {
return (component[component.size() - 1].orientation_out == kDnnInterleavedOrientation) ? component[ return (component[component.size() - 1].orientation_out == kDnnInterleavedOrientation) ? component[
component.size() - 1].num_rows_out : component[component.size() - 1].num_columns_out; component.size() - 1].num_rows_out : component[component.size() - 1].num_columns_out;
} }
std::string backend::AMIntelDNN::getDumpFilePrefix(const std::string& folder) { std::string AMIntelDNN::getDumpFilePrefix(const std::string& folder) {
const char pathSeparator = const char pathSeparator =
#ifdef _WIN32 #ifdef _WIN32
'\\'; '\\';
@ -1817,15 +1817,15 @@ std::string backend::AMIntelDNN::getDumpFilePrefix(const std::string& folder) {
return std::string(".") + pathSeparator + folder + pathSeparator + std::to_string(dump_write_index) + pathSeparator; return std::string(".") + pathSeparator + folder + pathSeparator + std::to_string(dump_write_index) + pathSeparator;
} }
std::string backend::AMIntelDNN::getDumpFilePrefixGNA() { std::string AMIntelDNN::getDumpFilePrefixGNA() {
return getDumpFilePrefix("gna_layers"); return getDumpFilePrefix("gna_layers");
} }
std::string backend::AMIntelDNN::getDumpFolderName() { std::string AMIntelDNN::getDumpFolderName() {
return getDumpFilePrefix("layers"); return getDumpFilePrefix("layers");
} }
std::string backend::AMIntelDNN::getRefFolderName() { std::string AMIntelDNN::getRefFolderName() {
return getDumpFilePrefix("ref_layers"); return getDumpFilePrefix("ref_layers");
} }

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

@ -41,11 +41,13 @@
#include "ops/pwl.hpp" #include "ops/pwl.hpp"
using namespace InferenceEngine; using namespace InferenceEngine;
using namespace std;
using namespace ov::intel_gna;
using namespace ov::intel_gna::frontend; using namespace ov::intel_gna::frontend;
using namespace ov::intel_gna::common; using namespace ov::intel_gna::common;
using namespace memory; using namespace ov::intel_gna::memory;
using namespace std;
namespace ov {
namespace intel_gna {
static bool CheckIFLastComponentIsPrecededByConv2D(const backend::DnnComponents::storage_type& components, static bool CheckIFLastComponentIsPrecededByConv2D(const backend::DnnComponents::storage_type& components,
bool verify_with_pooling = true) { bool verify_with_pooling = true) {
@ -2688,3 +2690,6 @@ GNAGraphCompiler::transposeMatrix(uint8_t* ptr_matrix, size_t element_size, uint
} }
return temp_buffer; return temp_buffer;
} }
} // namespace intel_gna
} // namespace ov

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

@ -13,7 +13,7 @@
namespace ov { namespace ov {
namespace intel_gna { namespace intel_gna {
namespace heaser_2_dot_2 { namespace header_2_dot_2 {
/** /**
* @brief Header version 2.2 * @brief Header version 2.2
@ -119,6 +119,6 @@ struct RuntimeEndPoint {
orientation(orientation) {} orientation(orientation) {}
}; };
} // namespace heaser_2_dot_2 } // namespace header_2_dot_2
} // namespace intel_gna } // namespace intel_gna
} // namespace ov } // namespace ov

60
src/plugins/intel_gna/tests/unit/backend/gna_limitations_test.cpp
View File

@ -13,7 +13,7 @@ using namespace ov::intel_gna::limitations;
using ov::intel_gna::common::kGnaTarget3_0; using ov::intel_gna::common::kGnaTarget3_0;
using ov::intel_gna::common::kGnaTarget3_5; using ov::intel_gna::common::kGnaTarget3_5;
struct GNAcnn2dValidatorTestParam { struct GNACnn2DValidatorTestParam {
std::string target; std::string target;
std::string whatInvalid; std::string whatInvalid;
std::vector<uint32_t> invalid; std::vector<uint32_t> invalid;
@ -49,167 +49,167 @@ const std::vector<uint32_t> kInvaliddH_35 = {0, 2, 2049};
const std::vector<uint32_t> kInvaliddW_30 = {0, 2, 400}; const std::vector<uint32_t> kInvaliddW_30 = {0, 2, 400};
const std::vector<uint32_t> kInvaliddW_35 = {0, 2, 2049}; const std::vector<uint32_t> kInvaliddW_35 = {0, 2, 2049};
const GNAcnn2dValidatorTestParam target_30 { const GNACnn2DValidatorTestParam target_30 {
kGnaTarget3_0, kGnaTarget3_0,
"inH", "inH",
kInvalidH_30, kInvalidH_30,
}; };
const GNAcnn2dValidatorTestParam target_35 { const GNACnn2DValidatorTestParam target_35 {
kGnaTarget3_5, kGnaTarget3_5,
"inH", "inH",
kInvalidH_35, kInvalidH_35,
}; };
const GNAcnn2dValidatorTestParam target_30_inW{ const GNACnn2DValidatorTestParam target_30_inW{
kGnaTarget3_0, kGnaTarget3_0,
"inW", "inW",
kInvalidW_30, kInvalidW_30,
}; };
const GNAcnn2dValidatorTestParam target_35_inW{ const GNACnn2DValidatorTestParam target_35_inW{
kGnaTarget3_5, kGnaTarget3_5,
"inW", "inW",
kInvalidW_35, kInvalidW_35,
}; };
const GNAcnn2dValidatorTestParam target_30_inC{ const GNACnn2DValidatorTestParam target_30_inC{
kGnaTarget3_0, kGnaTarget3_0,
"inC", "inC",
kInvalidC_30, kInvalidC_30,
}; };
const GNAcnn2dValidatorTestParam target_35_inC{ const GNACnn2DValidatorTestParam target_35_inC{
kGnaTarget3_5, kGnaTarget3_5,
"inC", "inC",
kInvalidC_35, kInvalidC_35,
}; };
const GNAcnn2dValidatorTestParam target_30_kH{ const GNACnn2DValidatorTestParam target_30_kH{
kGnaTarget3_0, kGnaTarget3_0,
"kH", "kH",
kInvalidkH_30, kInvalidkH_30,
}; };
const GNAcnn2dValidatorTestParam target_35_kH{ const GNACnn2DValidatorTestParam target_35_kH{
kGnaTarget3_5, kGnaTarget3_5,
"kH", "kH",
kInvalidkH_35, kInvalidkH_35,
}; };
const GNAcnn2dValidatorTestParam target_30_kW{ const GNACnn2DValidatorTestParam target_30_kW{
kGnaTarget3_0, kGnaTarget3_0,
"kW", "kW",
kInvalidkW_30, kInvalidkW_30,
}; };
const GNAcnn2dValidatorTestParam target_35_kW{ const GNACnn2DValidatorTestParam target_35_kW{
kGnaTarget3_5, kGnaTarget3_5,
"kW", "kW",
kInvalidkW_35, kInvalidkW_35,
}; };
const GNAcnn2dValidatorTestParam target_30_kN{ const GNACnn2DValidatorTestParam target_30_kN{
kGnaTarget3_0, kGnaTarget3_0,
"inC", "inC",
kInvalidkN_30, kInvalidkN_30,
}; };
const GNAcnn2dValidatorTestParam target_35_kN{ const GNACnn2DValidatorTestParam target_35_kN{
kGnaTarget3_5, kGnaTarget3_5,
"inC", "inC",
kInvalidkN_35, kInvalidkN_35,
}; };
const GNAcnn2dValidatorTestParam target_30_sH{ const GNACnn2DValidatorTestParam target_30_sH{
kGnaTarget3_0, kGnaTarget3_0,
"sH", "sH",
kInvalidsH_30, kInvalidsH_30,
}; };
const GNAcnn2dValidatorTestParam target_35_sH{ const GNACnn2DValidatorTestParam target_35_sH{
kGnaTarget3_5, kGnaTarget3_5,
"sH", "sH",
kInvalidsH_35, kInvalidsH_35,
}; };
const GNAcnn2dValidatorTestParam target_30_sW{ const GNACnn2DValidatorTestParam target_30_sW{
kGnaTarget3_0, kGnaTarget3_0,
"sW", "sW",
kInvalidsW_30, kInvalidsW_30,
}; };
const GNAcnn2dValidatorTestParam target_35_sW{ const GNACnn2DValidatorTestParam target_35_sW{
kGnaTarget3_5, kGnaTarget3_5,
"sW", "sW",
kInvalidsW_35, kInvalidsW_35,
}; };
const GNAcnn2dValidatorTestParam target_30_dH{ const GNACnn2DValidatorTestParam target_30_dH{
kGnaTarget3_0, kGnaTarget3_0,
"dH", "dH",
kInvaliddH_30, kInvaliddH_30,
}; };
const GNAcnn2dValidatorTestParam target_35_dH{ const GNACnn2DValidatorTestParam target_35_dH{
kGnaTarget3_5, kGnaTarget3_5,
"dH", "dH",
kInvaliddH_35, kInvaliddH_35,
}; };
const GNAcnn2dValidatorTestParam target_30_dW{ const GNACnn2DValidatorTestParam target_30_dW{
kGnaTarget3_0, kGnaTarget3_0,
"dW", "dW",
kInvaliddW_30, kInvaliddW_30,
}; };
const GNAcnn2dValidatorTestParam target_35_dW{ const GNACnn2DValidatorTestParam target_35_dW{
kGnaTarget3_5, kGnaTarget3_5,
"dW", "dW",
kInvaliddW_35, kInvaliddW_35,
}; };
const std::vector<uint32_t> kInvalidpw_30 = {0, 2, 10}; const std::vector<uint32_t> kInvalidpw_30 = {0, 2, 10};
const GNAcnn2dValidatorTestParam target_30_pwH{ const GNACnn2DValidatorTestParam target_30_pwH{
kGnaTarget3_0, kGnaTarget3_0,
"windowH", "windowH",
kInvalidpw_30, kInvalidpw_30,
}; };
const GNAcnn2dValidatorTestParam target_30_pwW{ const GNACnn2DValidatorTestParam target_30_pwW{
kGnaTarget3_0, kGnaTarget3_0,
"windowW", "windowW",
kInvalidpw_30, kInvalidpw_30,
}; };
const std::vector<uint32_t> kInvalidps_30 = {0, 4, 10}; const std::vector<uint32_t> kInvalidps_30 = {0, 4, 10};
const GNAcnn2dValidatorTestParam target_30_psH{ const GNACnn2DValidatorTestParam target_30_psH{
kGnaTarget3_0, kGnaTarget3_0,
"strideH", "strideH",
kInvalidps_30, kInvalidps_30,
}; };
const GNAcnn2dValidatorTestParam target_30_psW{ const GNACnn2DValidatorTestParam target_30_psW{
kGnaTarget3_0, kGnaTarget3_0,
"strideW", "strideW",
kInvalidps_30, kInvalidps_30,
}; };
const std::vector<uint32_t> kInvalidPoolingRange35 = {0, 256}; const std::vector<uint32_t> kInvalidPoolingRange35 = {0, 256};
const GNAcnn2dValidatorTestParam target_35_pwH{ const GNACnn2DValidatorTestParam target_35_pwH{
kGnaTarget3_5, kGnaTarget3_5,
"windowH", "windowH",
kInvalidPoolingRange35, kInvalidPoolingRange35,
}; };
const GNAcnn2dValidatorTestParam target_35_pwW{ const GNACnn2DValidatorTestParam target_35_pwW{
kGnaTarget3_5, kGnaTarget3_5,
"windowW", "windowW",
kInvalidPoolingRange35, kInvalidPoolingRange35,
}; };
const GNAcnn2dValidatorTestParam target_35_psH{ const GNACnn2DValidatorTestParam target_35_psH{
kGnaTarget3_5, kGnaTarget3_5,
"strideH", "strideH",
kInvalidPoolingRange35, kInvalidPoolingRange35,
}; };
const GNAcnn2dValidatorTestParam target_35_psW{ const GNACnn2DValidatorTestParam target_35_psW{
kGnaTarget3_5, kGnaTarget3_5,
"strideW", "strideW",
kInvalidPoolingRange35, kInvalidPoolingRange35,
@ -279,7 +279,7 @@ struct Validatecnn2dParams {
} }
}; };
class GNAcnn2dValidatorTest : public ::testing::TestWithParam<GNAcnn2dValidatorTestParam> { class GNAcnn2dValidatorTest : public ::testing::TestWithParam<GNACnn2DValidatorTestParam> {
protected: protected:
void SetUp() override { void SetUp() override {
validator = cnn2d::AbstractValidator::Create(GetParam().target); validator = cnn2d::AbstractValidator::Create(GetParam().target);

5
src/plugins/intel_gna/tests/unit/gna_get_aligned_split_sizes.cpp
View File

@ -11,8 +11,6 @@
namespace { namespace {
using namespace ov::intel_gna;
using GetAlignedSplitSizesData = std::tuple< using GetAlignedSplitSizesData = std::tuple<
uint32_t, // total size uint32_t, // total size
uint32_t, // maximum split size uint32_t, // maximum split size
@ -29,7 +27,8 @@ const std::vector<GetAlignedSplitSizesData> data = {
TEST(GetAlignedSplitSizesTest, testAlignedSplitSizes) { TEST(GetAlignedSplitSizesTest, testAlignedSplitSizes) {
for (const auto &dataItem : data) { for (const auto &dataItem : data) {
auto sizes = GetAlignedSplitSizes(std::get<0>(dataItem), std::get<1>(dataItem), auto sizes =
ov::intel_gna::GetAlignedSplitSizes(std::get<0>(dataItem), std::get<1>(dataItem),
std::get<2>(dataItem)); std::get<2>(dataItem));
ASSERT_EQ(sizes, std::get<3>(dataItem)); ASSERT_EQ(sizes, std::get<3>(dataItem));
} }