} m_Quantization;
};
+using BindingPointInfo = std::pair<armnn::LayerBindingId, armnn::TensorInfo>;
+
template<typename MemoryType>
class BaseTensor
{
namespace armnnCaffeParser
{
-using BindingPointInfo = std::pair<armnn::LayerBindingId, armnn::TensorInfo>;
+using BindingPointInfo = armnn::BindingPointInfo;
class ICaffeParser;
using ICaffeParserPtr = std::unique_ptr<ICaffeParser, void(*)(ICaffeParser* parser)>;
namespace armnnOnnxParser
{
-using BindingPointInfo = std::pair<armnn::LayerBindingId, armnn::TensorInfo>;
+using BindingPointInfo = armnn::BindingPointInfo;
class IOnnxParser;
using IOnnxParserPtr = std::unique_ptr<IOnnxParser, void(*)(IOnnxParser* parser)>;
namespace armnnTfLiteParser
{
-// TODO: revise this: do we really need this for every parser???
-using BindingPointInfo = std::pair<armnn::LayerBindingId, armnn::TensorInfo>;
+using BindingPointInfo = armnn::BindingPointInfo;
class ITfLiteParser;
using ITfLiteParserPtr = std::unique_ptr<ITfLiteParser, void(*)(ITfLiteParser* parser)>;
namespace armnnTfParser
{
-using BindingPointInfo = std::pair<armnn::LayerBindingId, armnn::TensorInfo>;
+using BindingPointInfo = armnn::BindingPointInfo;
class ITfParser;
using ITfParserPtr = std::unique_ptr<ITfParser, void(*)(ITfParser* parser)>;
namespace armnnCaffeParser
{
-using BindingPointInfo = std::pair<armnn::LayerBindingId, armnn::TensorInfo>;
-
class CaffeParserBase: public ICaffeParser
{
public:
const std::map<std::string, std::vector<InputDataType>>& inputData,
const std::map<std::string, std::vector<OutputDataType>>& expectedOutputData)
{
- using BindingPointInfo = std::pair<armnn::LayerBindingId, armnn::TensorInfo>;
-
auto ConvertBindingInfo = [](const armnnDeserializer::BindingPointInfo& bindingInfo)
{
return std::make_pair(bindingInfo.m_BindingId, bindingInfo.m_TensorInfo);
armnn::InputTensors inputTensors;
for (auto&& it : inputData)
{
- BindingPointInfo bindingInfo = ConvertBindingInfo(m_Parser->GetNetworkInputBindingInfo(layersId, it.first));
+ armnn::BindingPointInfo bindingInfo = ConvertBindingInfo(
+ m_Parser->GetNetworkInputBindingInfo(layersId, it.first));
armnn::VerifyTensorInfoDataType(bindingInfo.second, ArmnnInputType);
inputTensors.push_back({ bindingInfo.first, armnn::ConstTensor(bindingInfo.second, it.second.data()) });
}
armnn::OutputTensors outputTensors;
for (auto&& it : expectedOutputData)
{
- BindingPointInfo bindingInfo = ConvertBindingInfo(m_Parser->GetNetworkOutputBindingInfo(layersId, it.first));
+ armnn::BindingPointInfo bindingInfo = ConvertBindingInfo(
+ m_Parser->GetNetworkOutputBindingInfo(layersId, it.first));
armnn::VerifyTensorInfoDataType(bindingInfo.second, ArmnnOutputType);
outputStorage.emplace(it.first, MakeTensor<OutputDataType, NumOutputDimensions>(bindingInfo.second));
outputTensors.push_back(
// Compare each output tensor to the expected values
for (auto&& it : expectedOutputData)
{
- BindingPointInfo bindingInfo = ConvertBindingInfo(m_Parser->GetNetworkOutputBindingInfo(layersId, it.first));
+ armnn::BindingPointInfo bindingInfo = ConvertBindingInfo(
+ m_Parser->GetNetworkOutputBindingInfo(layersId, it.first));
auto outputExpected = MakeTensor<OutputDataType, NumOutputDimensions>(bindingInfo.second, it.second);
BOOST_TEST(CompareTensors(outputExpected, outputStorage[it.first]));
}
namespace armnnOnnxParser
{
-using BindingPointInfo = std::pair<armnn::LayerBindingId, armnn::TensorInfo>;
using ModelPtr = std::unique_ptr<onnx::ModelProto>;
class OnnxParser : public IOnnxParser
const std::map<std::string, std::vector<DataType1>>& inputData,
const std::map<std::string, std::vector<DataType2>>& expectedOutputData)
{
- using BindingPointInfo = std::pair<armnn::LayerBindingId, armnn::TensorInfo>;
-
// Setup the armnn input tensors from the given vectors.
armnn::InputTensors inputTensors;
for (auto&& it : inputData)
{
- BindingPointInfo bindingInfo = m_Parser->GetNetworkInputBindingInfo(subgraphId, it.first);
+ armnn::BindingPointInfo bindingInfo = m_Parser->GetNetworkInputBindingInfo(subgraphId, it.first);
armnn::VerifyTensorInfoDataType(bindingInfo.second, armnnType1);
inputTensors.push_back({ bindingInfo.first, armnn::ConstTensor(bindingInfo.second, it.second.data()) });
}
// Compare each output tensor to the expected values
for (auto&& it : expectedOutputData)
{
- BindingPointInfo bindingInfo = m_Parser->GetNetworkOutputBindingInfo(subgraphId, it.first);
+ armnn::BindingPointInfo bindingInfo = m_Parser->GetNetworkOutputBindingInfo(subgraphId, it.first);
auto outputExpected = MakeTensor<DataType2, NumOutputDimensions>(bindingInfo.second, it.second);
BOOST_TEST(CompareTensors(outputExpected, outputStorage[it.first]));
}
const std::map<std::string, std::vector<DataType1>>& inputData,
const std::map<std::string, std::vector<DataType2>>& expectedOutputData)
{
- using BindingPointInfo = std::pair<armnn::LayerBindingId, armnn::TensorInfo>;
-
// Setup the armnn input tensors from the given vectors.
armnn::InputTensors inputTensors;
for (auto&& it : inputData)
{
- BindingPointInfo bindingInfo = m_Parser->GetNetworkInputBindingInfo(subgraphId, it.first);
+ armnn::BindingPointInfo bindingInfo = m_Parser->GetNetworkInputBindingInfo(subgraphId, it.first);
armnn::VerifyTensorInfoDataType(bindingInfo.second, armnnType1);
inputTensors.push_back({ bindingInfo.first, armnn::ConstTensor(bindingInfo.second, it.second.data()) });
std::map<std::string, std::vector<DataType2>> outputStorage;
for (auto&& it : expectedOutputData)
{
- BindingPointInfo bindingInfo = m_Parser->GetNetworkOutputBindingInfo(subgraphId, it.first);
+ armnn::BindingPointInfo bindingInfo = m_Parser->GetNetworkOutputBindingInfo(subgraphId, it.first);
armnn::VerifyTensorInfoDataType(bindingInfo.second, armnnType2);
std::vector<DataType2> out(it.second.size());
namespace armnnTfParser
{
-using BindingPointInfo = std::pair<armnn::LayerBindingId, armnn::TensorInfo>;
-
class ParsedTfOperation;
using ParsedTfOperationPtr = std::unique_ptr<ParsedTfOperation>;
void ParserPrototxtFixture<TParser>::RunTest(const std::map<std::string, std::vector<float>>& inputData,
const std::map<std::string, std::vector<T>>& expectedOutputData)
{
- using BindingPointInfo = std::pair<armnn::LayerBindingId, armnn::TensorInfo>;
-
// Sets up the armnn input tensors from the given vectors.
armnn::InputTensors inputTensors;
for (auto&& it : inputData)
{
- BindingPointInfo bindingInfo = m_Parser->GetNetworkInputBindingInfo(it.first);
+ armnn::BindingPointInfo bindingInfo = m_Parser->GetNetworkInputBindingInfo(it.first);
inputTensors.push_back({ bindingInfo.first, armnn::ConstTensor(bindingInfo.second, it.second.data()) });
}
armnn::OutputTensors outputTensors;
for (auto&& it : expectedOutputData)
{
- BindingPointInfo bindingInfo = m_Parser->GetNetworkOutputBindingInfo(it.first);
+ armnn::BindingPointInfo bindingInfo = m_Parser->GetNetworkOutputBindingInfo(it.first);
outputStorage.emplace(it.first, MakeTensor<T, NumOutputDimensions>(bindingInfo.second));
outputTensors.push_back(
{ bindingInfo.first, armnn::Tensor(bindingInfo.second, outputStorage.at(it.first).data()) });
// Compares each output tensor to the expected values.
for (auto&& it : expectedOutputData)
{
- BindingPointInfo bindingInfo = m_Parser->GetNetworkOutputBindingInfo(it.first);
+ armnn::BindingPointInfo bindingInfo = m_Parser->GetNetworkOutputBindingInfo(it.first);
if (bindingInfo.second.GetNumElements() != it.second.size())
{
throw armnn::Exception(
namespace InferenceModelInternal
{
-// This needs to go when the armnnCaffeParser, armnnTfParser and armnnTfLiteParser
-// definitions of BindingPointInfo gets consolidated.
-using BindingPointInfo = std::pair<armnn::LayerBindingId, armnn::TensorInfo>;
+using BindingPointInfo = armnn::BindingPointInfo;
using QuantizationParams = std::pair<float,int32_t>;
{
public:
using Params = InferenceModelInternal::Params;
- using BindingPointInfo = InferenceModelInternal::BindingPointInfo;
static armnn::INetworkPtr Create(const Params& params,
- std::vector<BindingPointInfo>& inputBindings,
- std::vector<BindingPointInfo>& outputBindings)
+ std::vector<armnn::BindingPointInfo>& inputBindings,
+ std::vector<armnn::BindingPointInfo>& outputBindings)
{
const std::string& modelPath = params.m_ModelPath;
public:
using IParser = armnnDeserializer::IDeserializer;
using Params = InferenceModelInternal::Params;
- using BindingPointInfo = InferenceModelInternal::BindingPointInfo;
static armnn::INetworkPtr Create(const Params& params,
- std::vector<BindingPointInfo>& inputBindings,
- std::vector<BindingPointInfo>& outputBindings)
+ std::vector<armnn::BindingPointInfo>& inputBindings,
+ std::vector<armnn::BindingPointInfo>& outputBindings)
{
auto parser(IParser::Create());
BOOST_ASSERT(parser);
public:
using IParser = armnnTfLiteParser::ITfLiteParser;
using Params = InferenceModelInternal::Params;
- using BindingPointInfo = InferenceModelInternal::BindingPointInfo;
static armnn::INetworkPtr Create(const Params& params,
- std::vector<BindingPointInfo>& inputBindings,
- std::vector<BindingPointInfo>& outputBindings)
+ std::vector<armnn::BindingPointInfo>& inputBindings,
+ std::vector<armnn::BindingPointInfo>& outputBindings)
{
const std::string& modelPath = params.m_ModelPath;
for (const std::string& inputLayerName : params.m_InputBindings)
{
- BindingPointInfo inputBinding =
+ armnn::BindingPointInfo inputBinding =
parser->GetNetworkInputBindingInfo(params.m_SubgraphId, inputLayerName);
inputBindings.push_back(inputBinding);
}
for (const std::string& outputLayerName : params.m_OutputBindings)
{
- BindingPointInfo outputBinding =
+ armnn::BindingPointInfo outputBinding =
parser->GetNetworkOutputBindingInfo(params.m_SubgraphId, outputLayerName);
outputBindings.push_back(outputBinding);
}
template<typename TContainer>
inline armnn::InputTensors MakeInputTensors(
- const std::vector<InferenceModelInternal::BindingPointInfo>& inputBindings,
+ const std::vector<armnn::BindingPointInfo>& inputBindings,
const std::vector<TContainer>& inputDataContainers)
{
armnn::InputTensors inputTensors;
for (size_t i = 0; i < numInputs; i++)
{
- const InferenceModelInternal::BindingPointInfo& inputBinding = inputBindings[i];
+ const armnn::BindingPointInfo& inputBinding = inputBindings[i];
const TContainer& inputData = inputDataContainers[i];
boost::apply_visitor([&](auto&& value)
template<typename TContainer>
inline armnn::OutputTensors MakeOutputTensors(
- const std::vector<InferenceModelInternal::BindingPointInfo>& outputBindings,
+ const std::vector<armnn::BindingPointInfo>& outputBindings,
std::vector<TContainer>& outputDataContainers)
{
armnn::OutputTensors outputTensors;
for (size_t i = 0; i < numOutputs; i++)
{
- const InferenceModelInternal::BindingPointInfo& outputBinding = outputBindings[i];
+ const armnn::BindingPointInfo& outputBinding = outputBindings[i];
TContainer& outputData = outputDataContainers[i];
boost::apply_visitor([&](auto&& value)
public:
using DataType = TDataType;
using Params = InferenceModelInternal::Params;
- using BindingPointInfo = InferenceModelInternal::BindingPointInfo;
using QuantizationParams = InferenceModelInternal::QuantizationParams;
using TContainer = boost::variant<std::vector<float>, std::vector<int>, std::vector<unsigned char>>;
}
}
- const BindingPointInfo& GetInputBindingInfo(unsigned int inputIndex = 0u) const
+ const armnn::BindingPointInfo& GetInputBindingInfo(unsigned int inputIndex = 0u) const
{
CheckInputIndexIsValid(inputIndex);
return m_InputBindings[inputIndex];
}
- const std::vector<BindingPointInfo>& GetInputBindingInfos() const
+ const std::vector<armnn::BindingPointInfo>& GetInputBindingInfos() const
{
return m_InputBindings;
}
- const BindingPointInfo& GetOutputBindingInfo(unsigned int outputIndex = 0u) const
+ const armnn::BindingPointInfo& GetOutputBindingInfo(unsigned int outputIndex = 0u) const
{
CheckOutputIndexIsValid(outputIndex);
return m_OutputBindings[outputIndex];
}
- const std::vector<BindingPointInfo>& GetOutputBindingInfos() const
+ const std::vector<armnn::BindingPointInfo>& GetOutputBindingInfos() const
{
return m_OutputBindings;
}
armnn::NetworkId m_NetworkIdentifier;
std::shared_ptr<armnn::IRuntime> m_Runtime;
- std::vector<InferenceModelInternal::BindingPointInfo> m_InputBindings;
- std::vector<InferenceModelInternal::BindingPointInfo> m_OutputBindings;
+ std::vector<armnn::BindingPointInfo> m_InputBindings;
+ std::vector<armnn::BindingPointInfo> m_OutputBindings;
bool m_EnableProfiling;
template<typename TContainer>
for (unsigned int k = 0; k < networksCount; ++k)
{
- using BindingPointInfo = InferenceModelInternal::BindingPointInfo;
- std::vector<BindingPointInfo> inputBindings = { networks[k].m_InputBindingInfo };
- std::vector<BindingPointInfo> outputBindings = { networks[k].m_OutputBindingInfo };
+ std::vector<armnn::BindingPointInfo> inputBindings = { networks[k].m_InputBindingInfo };
+ std::vector<armnn::BindingPointInfo> outputBindings = { networks[k].m_OutputBindingInfo };
std::vector<TContainer> inputDataContainers = { testCaseData->m_InputImage };
std::vector<TContainer> outputDataContainers = { outputs[k] };