rk3588-game
/
android13
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
android13/external/android-nn-driver/test/Concat.cpp

498 lines
18 KiB
C++
Raw Blame History

//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "DriverTestHelpers.hpp"
#include "TestTensor.hpp"
#include "../1.0/HalPolicy.hpp"
#include <boost/test/unit_test.hpp>
#include <boost/test/data/test_case.hpp>
#include <array>
#include <log/log.h>
BOOST_AUTO_TEST_SUITE(ConcatTests)
using namespace android::hardware;
using namespace driverTestHelpers;
using namespace armnn_driver;
using HalPolicy = hal_1_0::HalPolicy;
namespace
{
#ifndef ARMCOMPUTECL_ENABLED
static const std::array<armnn::Compute, 1> COMPUTE_DEVICES = {{ armnn::Compute::CpuRef }};
#else
static const std::array<armnn::Compute, 2> COMPUTE_DEVICES = {{ armnn::Compute::CpuRef, armnn::Compute::GpuAcc }};
#endif
void
ConcatTestImpl(const std::vector<const TestTensor*> & inputs,
int32_t concatAxis,
const TestTensor & expectedOutputTensor,
armnn::Compute computeDevice,
V1_0::ErrorStatus expectedPrepareStatus=V1_0::ErrorStatus::NONE,
V1_0::ErrorStatus expectedExecStatus=V1_0::ErrorStatus::NONE)
{
std::unique_ptr<ArmnnDriver> driver = std::make_unique<ArmnnDriver>(DriverOptions(computeDevice));
HalPolicy::Model model{};
hidl_vec<uint32_t> modelInputIds;
modelInputIds.resize(inputs.size()+1);
for (uint32_t i = 0; i<inputs.size(); ++i)
{
modelInputIds[i] = i;
AddInputOperand<HalPolicy>(model, inputs[i]->GetDimensions());
}
modelInputIds[inputs.size()] = inputs.size(); // add an id for the axis too
AddIntOperand<HalPolicy>(model, concatAxis);
AddOutputOperand<HalPolicy>(model, expectedOutputTensor.GetDimensions());
// make the concat operation
model.operations.resize(1);
model.operations[0].type = HalPolicy::OperationType::CONCATENATION;
model.operations[0].inputs = modelInputIds;
model.operations[0].outputs = hidl_vec<uint32_t>{static_cast<uint32_t>(inputs.size()+1)};
// make the prepared model
V1_0::ErrorStatus prepareStatus=V1_0::ErrorStatus::NONE;
android::sp<V1_0::IPreparedModel> preparedModel = PrepareModelWithStatus(model,
*driver,
prepareStatus,
expectedPrepareStatus);
BOOST_TEST(prepareStatus == expectedPrepareStatus);
if (prepareStatus != V1_0::ErrorStatus::NONE)
{
// prepare failed, we cannot continue
return;
}
BOOST_TEST(preparedModel.get() != nullptr);
if (preparedModel.get() == nullptr)
{
// don't spoil other tests if prepare failed
return;
}
// construct the request
hidl_vec<RequestArgument> inputArguments;
hidl_vec<RequestArgument> outputArguments;
inputArguments.resize(inputs.size());
outputArguments.resize(1);
// the request's memory pools will follow the same order as
// the inputs
for (uint32_t i = 0; i<inputs.size(); ++i)
{
DataLocation inloc = {};
inloc.poolIndex = i;
inloc.offset = 0;
inloc.length = inputs[i]->GetNumElements() * sizeof(float);
RequestArgument input = {};
input.location = inloc;
input.dimensions = inputs[i]->GetDimensions();
inputArguments[i] = input;
}
// and an additional memory pool is needed for the output
{
DataLocation outloc = {};
outloc.poolIndex = inputs.size();
outloc.offset = 0;
outloc.length = expectedOutputTensor.GetNumElements() * sizeof(float);
RequestArgument output = {};
output.location = outloc;
output.dimensions = expectedOutputTensor.GetDimensions();
outputArguments[0] = output;
}
// make the request based on the arguments
V1_0::Request request = {};
request.inputs = inputArguments;
request.outputs = outputArguments;
// set the input data
for (uint32_t i = 0; i<inputs.size(); ++i)
{
AddPoolAndSetData(inputs[i]->GetNumElements(),
request,
inputs[i]->GetData());
}
// add memory for the output
android::sp<IMemory> outMemory = AddPoolAndGetData<float>(expectedOutputTensor.GetNumElements(), request);
float* outdata = static_cast<float*>(static_cast<void*>(outMemory->getPointer()));
// run the execution
ARMNN_ASSERT(preparedModel.get() != nullptr);
auto execStatus = Execute(preparedModel, request, expectedExecStatus);
BOOST_TEST(execStatus == expectedExecStatus);
if (execStatus == V1_0::ErrorStatus::NONE)
{
// check the result if there was no error
const float * expectedOutput = expectedOutputTensor.GetData();
for (unsigned int i=0; i<expectedOutputTensor.GetNumElements();++i)
{
BOOST_TEST(outdata[i] == expectedOutput[i]);
}
}
}
} // namespace <anonymous>
BOOST_DATA_TEST_CASE(SimpleConcatAxis0, COMPUTE_DEVICES)
{
int32_t axis = 0;
TestTensor aIn{armnn::TensorShape{1,1,1,1},{0}};
TestTensor bIn{armnn::TensorShape{1,1,1,1},{1}};
TestTensor cIn{armnn::TensorShape{1,1,1,1},{2}};
TestTensor expected{armnn::TensorShape{3,1,1,1},{0,1,2}};
ConcatTestImpl({&aIn, &bIn, &cIn}, axis, expected, sample);
}
BOOST_DATA_TEST_CASE(ConcatAxis0_NoInterleave, COMPUTE_DEVICES)
{
int32_t axis = 0;
TestTensor aIn{armnn::TensorShape{2,1,2,1},{0, 1,
2, 3}};
TestTensor bIn{armnn::TensorShape{3,1,2,1},{4, 5,
6, 7,
8, 9}};
TestTensor cIn{armnn::TensorShape{1,1,2,1},{10, 11}};
TestTensor expected{armnn::TensorShape{6,1,2,1},{0, 1,
2, 3,
4, 5,
6, 7,
8, 9,
10, 11}};
ConcatTestImpl({&aIn, &bIn, &cIn}, axis, expected, sample);
}
BOOST_DATA_TEST_CASE(SimpleConcatAxis1, COMPUTE_DEVICES)
{
int32_t axis = 1;
TestTensor aIn{armnn::TensorShape{1,1,1,1},{0}};
TestTensor bIn{armnn::TensorShape{1,1,1,1},{1}};
TestTensor cIn{armnn::TensorShape{1,1,1,1},{2}};
TestTensor expected{armnn::TensorShape{1,3,1,1},{0,1,2}};
ConcatTestImpl({&aIn, &bIn, &cIn}, axis, expected, sample);
}
BOOST_DATA_TEST_CASE(ConcatAxis1_NoInterleave, COMPUTE_DEVICES)
{
int32_t axis = 1;
TestTensor aIn{armnn::TensorShape{1,2,2,1},{0, 1,
2, 3}};
TestTensor bIn{armnn::TensorShape{1,3,2,1},{4, 5,
6, 7,
8, 9}};
TestTensor cIn{armnn::TensorShape{1,1,2,1},{10, 11}};
TestTensor expected{armnn::TensorShape{1,6,2,1},{0, 1,
2, 3,
4, 5,
6, 7,
8, 9,
10, 11}};
ConcatTestImpl({&aIn, &bIn, &cIn}, axis, expected, sample);
}
BOOST_DATA_TEST_CASE(SimpleConcatAxis1_DoInterleave, COMPUTE_DEVICES)
{
int32_t axis = 1;
TestTensor aIn{armnn::TensorShape{2,2,1,1},{0, 1,
2, 3}};
TestTensor bIn{armnn::TensorShape{2,3,1,1},{4, 5, 6,
7, 8, 9}};
TestTensor cIn{armnn::TensorShape{2,1,1,1},{10,
11}};
TestTensor expected{armnn::TensorShape{2,6,1,1},{0, 1, 4, 5, 6, 10,
2, 3, 7, 8, 9, 11}};
ConcatTestImpl({&aIn, &bIn, &cIn}, axis, expected, sample);
}
BOOST_DATA_TEST_CASE(SimpleConcatAxis2, COMPUTE_DEVICES)
{
int32_t axis = 2;
TestTensor aIn{armnn::TensorShape{1,1,1,1},{0}};
TestTensor bIn{armnn::TensorShape{1,1,1,1},{1}};
TestTensor cIn{armnn::TensorShape{1,1,1,1},{2}};
TestTensor expected{armnn::TensorShape{1,1,3,1},{0,1,2}};
ConcatTestImpl({&aIn, &bIn, &cIn}, axis, expected, sample);
}
BOOST_DATA_TEST_CASE(ConcatAxis2_NoInterleave, COMPUTE_DEVICES)
{
int32_t axis = 2;
TestTensor aIn{armnn::TensorShape{1,1,2,2},{0, 1,
2, 3}};
TestTensor bIn{armnn::TensorShape{1,1,3,2},{4, 5,
6, 7,
8, 9}};
TestTensor cIn{armnn::TensorShape{1,1,1,2},{10, 11}};
TestTensor expected{armnn::TensorShape{1,1,6,2},{0, 1,
2, 3,
4, 5,
6, 7,
8, 9,
10, 11}};
ConcatTestImpl({&aIn, &bIn, &cIn}, axis, expected, sample);
}
BOOST_DATA_TEST_CASE(SimpleConcatAxis2_DoInterleave, COMPUTE_DEVICES)
{
int32_t axis = 2;
TestTensor aIn{armnn::TensorShape{1,2,2,1},{0, 1,
2, 3}};
TestTensor bIn{armnn::TensorShape{1,2,3,1},{4, 5, 6,
7, 8, 9}};
TestTensor cIn{armnn::TensorShape{1,2,1,1},{10,
11}};
TestTensor expected{armnn::TensorShape{1,2,6,1},{0, 1, 4, 5, 6, 10,
2, 3, 7, 8, 9, 11}};
ConcatTestImpl({&aIn, &bIn, &cIn}, axis, expected, sample);
}
BOOST_DATA_TEST_CASE(SimpleConcatAxis3, COMPUTE_DEVICES)
{
int32_t axis = 3;
TestTensor aIn{armnn::TensorShape{1,1,1,1},{0}};
TestTensor bIn{armnn::TensorShape{1,1,1,1},{1}};
TestTensor cIn{armnn::TensorShape{1,1,1,1},{2}};
TestTensor expected{armnn::TensorShape{1,1,1,3},{0,1,2}};
ConcatTestImpl({&aIn, &bIn, &cIn}, axis, expected, sample);
}
BOOST_DATA_TEST_CASE(SimpleConcatAxis3_DoInterleave, COMPUTE_DEVICES)
{
int32_t axis = 3;
TestTensor aIn{armnn::TensorShape{1,1,2,2},{0, 1,
2, 3}};
TestTensor bIn{armnn::TensorShape{1,1,2,3},{4, 5, 6,
7, 8, 9}};
TestTensor cIn{armnn::TensorShape{1,1,2,1},{10,
11}};
TestTensor expected{armnn::TensorShape{1,1,2,6},{0, 1, 4, 5, 6, 10,
2, 3, 7, 8, 9, 11}};
ConcatTestImpl({&aIn, &bIn, &cIn}, axis, expected, sample);
}
BOOST_DATA_TEST_CASE(AxisTooBig, COMPUTE_DEVICES)
{
int32_t axis = 4;
TestTensor aIn{armnn::TensorShape{1,1,1,1},{0}};
TestTensor bIn{armnn::TensorShape{1,1,1,1},{0}};
// The axis must be within the range of [-rank(values), rank(values))
// see: https://www.tensorflow.org/api_docs/python/tf/concat
TestTensor uncheckedOutput{armnn::TensorShape{1,1,1,1},{0}};
V1_0::ErrorStatus expectedParserStatus = V1_0::ErrorStatus::GENERAL_FAILURE;
ConcatTestImpl({&aIn, &bIn}, axis, uncheckedOutput, sample, expectedParserStatus);
}
BOOST_DATA_TEST_CASE(AxisTooSmall, COMPUTE_DEVICES)
{
int32_t axis = -5;
TestTensor aIn{armnn::TensorShape{1,1,1,1},{0}};
TestTensor bIn{armnn::TensorShape{1,1,1,1},{0}};
// The axis must be within the range of [-rank(values), rank(values))
// see: https://www.tensorflow.org/api_docs/python/tf/concat
TestTensor uncheckedOutput{armnn::TensorShape{1,1,1,1},{0}};
V1_0::ErrorStatus expectedParserStatus = V1_0::ErrorStatus::GENERAL_FAILURE;
ConcatTestImpl({&aIn, &bIn}, axis, uncheckedOutput, sample, expectedParserStatus);
}
BOOST_DATA_TEST_CASE(TooFewInputs, COMPUTE_DEVICES)
{
int32_t axis = 0;
TestTensor aIn{armnn::TensorShape{1,1,1,1},{0}};
// We need at least two tensors to concatenate
V1_0::ErrorStatus expectedParserStatus = V1_0::ErrorStatus::GENERAL_FAILURE;
ConcatTestImpl({&aIn}, axis, aIn, sample, expectedParserStatus);
}
BOOST_DATA_TEST_CASE(MismatchedInputDimensions, COMPUTE_DEVICES)
{
int32_t axis = 3;
TestTensor aIn{armnn::TensorShape{1,1,2,2},{0, 1,
2, 3}};
TestTensor bIn{armnn::TensorShape{1,1,2,3},{4, 5, 6,
7, 8, 9}};
TestTensor mismatched{armnn::TensorShape{1,1,1,1},{10}};
TestTensor expected{armnn::TensorShape{1,1,2,6},{0, 1, 4, 5, 6, 10,
2, 3, 7, 8, 9, 11}};
// The input dimensions must be compatible
V1_0::ErrorStatus expectedParserStatus = V1_0::ErrorStatus::GENERAL_FAILURE;
ConcatTestImpl({&aIn, &bIn, &mismatched}, axis, expected, sample, expectedParserStatus);
}
BOOST_DATA_TEST_CASE(MismatchedInputRanks, COMPUTE_DEVICES)
{
int32_t axis = 2;
TestTensor aIn{armnn::TensorShape{1,1,2},{0,1}};
TestTensor bIn{armnn::TensorShape{1,1},{4}};
TestTensor expected{armnn::TensorShape{1,1,3},{0,1,4}};
// The input dimensions must be compatible
V1_0::ErrorStatus expectedParserStatus = V1_0::ErrorStatus::GENERAL_FAILURE;
ConcatTestImpl({&aIn, &bIn}, axis, expected, sample, expectedParserStatus);
}
BOOST_DATA_TEST_CASE(MismatchedOutputDimensions, COMPUTE_DEVICES)
{
int32_t axis = 3;
TestTensor aIn{armnn::TensorShape{1,1,2,2},{0, 1,
2, 3}};
TestTensor bIn{armnn::TensorShape{1,1,2,3},{4, 5, 6,
7, 8, 9}};
TestTensor cIn{armnn::TensorShape{1,1,2,1},{10,
11}};
TestTensor mismatched{armnn::TensorShape{1,1,6,2},{0, 1, 4, 5, 6, 10,
2, 3, 7, 8, 9, 11}};
// The input and output dimensions must be compatible
V1_0::ErrorStatus expectedParserStatus = V1_0::ErrorStatus::GENERAL_FAILURE;
ConcatTestImpl({&aIn, &bIn, &cIn}, axis, mismatched, sample, expectedParserStatus);
}
BOOST_DATA_TEST_CASE(MismatchedOutputRank, COMPUTE_DEVICES)
{
int32_t axis = 3;
TestTensor aIn{armnn::TensorShape{1,1,2,2},{0, 1,
2, 3}};
TestTensor bIn{armnn::TensorShape{1,1,2,3},{4, 5, 6,
7, 8, 9}};
TestTensor cIn{armnn::TensorShape{1,1,2,1},{10,
11}};
TestTensor mismatched{armnn::TensorShape{6,2},{0, 1, 4, 5, 6, 10,
2, 3, 7, 8, 9, 11}};
// The input and output ranks must match
V1_0::ErrorStatus expectedParserStatus = V1_0::ErrorStatus::GENERAL_FAILURE;
ConcatTestImpl({&aIn, &bIn, &cIn}, axis, mismatched, sample, expectedParserStatus);
}
BOOST_DATA_TEST_CASE(ValidNegativeAxis, COMPUTE_DEVICES)
{
// this is the same as 3
// see: https://www.tensorflow.org/api_docs/python/tf/concat
int32_t axis = -1;
TestTensor aIn{armnn::TensorShape{1,1,2,2},{0, 1,
2, 3}};
TestTensor bIn{armnn::TensorShape{1,1,2,3},{4, 5, 6,
7, 8, 9}};
TestTensor cIn{armnn::TensorShape{1,1,2,1},{10,
11}};
TestTensor expected{armnn::TensorShape{1,1,2,6},{0, 1, 4, 5, 6, 10,
2, 3, 7, 8, 9, 11}};
ConcatTestImpl({&aIn, &bIn, &cIn}, axis, expected, sample);
}
BOOST_DATA_TEST_CASE(SimpleConcatAxisZero3D, COMPUTE_DEVICES)
{
int32_t axis = 0;
TestTensor aIn{armnn::TensorShape{1,1,1},{0}};
TestTensor bIn{armnn::TensorShape{1,1,1},{1}};
TestTensor cIn{armnn::TensorShape{1,1,1},{2}};
TestTensor expected{armnn::TensorShape{3,1,1},{0,1,2}};
ConcatTestImpl({&aIn, &bIn, &cIn}, axis, expected, sample);
}
BOOST_DATA_TEST_CASE(SimpleConcatAxisOne3D, COMPUTE_DEVICES)
{
int32_t axis = 1;
TestTensor aIn{armnn::TensorShape{1,1,1},{0}};
TestTensor bIn{armnn::TensorShape{1,1,1},{1}};
TestTensor cIn{armnn::TensorShape{1,1,1},{2}};
TestTensor expected{armnn::TensorShape{1,3,1},{0,1,2}};
ConcatTestImpl({&aIn, &bIn, &cIn}, axis, expected, sample);
}
BOOST_DATA_TEST_CASE(SimpleConcatAxisTwo3D, COMPUTE_DEVICES)
{
int32_t axis = 2;
TestTensor aIn{armnn::TensorShape{1,1,1},{0}};
TestTensor bIn{armnn::TensorShape{1,1,1},{1}};
TestTensor cIn{armnn::TensorShape{1,1,1},{2}};
TestTensor expected{armnn::TensorShape{1,1,3},{0,1,2}};
ConcatTestImpl({&aIn, &bIn, &cIn}, axis, expected, sample);
}
BOOST_DATA_TEST_CASE(SimpleConcatAxisZero2D, COMPUTE_DEVICES)
{
int32_t axis = 0;
TestTensor aIn{armnn::TensorShape{1,1},{0}};
TestTensor bIn{armnn::TensorShape{1,1},{1}};
TestTensor cIn{armnn::TensorShape{1,1},{2}};
TestTensor expected{armnn::TensorShape{3,1},{0,1,2}};
ConcatTestImpl({&aIn, &bIn, &cIn}, axis, expected, sample);
}
BOOST_DATA_TEST_CASE(SimpleConcatAxisOne2D, COMPUTE_DEVICES)
{
int32_t axis = 1;
TestTensor aIn{armnn::TensorShape{1,1},{0}};
TestTensor bIn{armnn::TensorShape{1,1},{1}};
TestTensor cIn{armnn::TensorShape{1,1},{2}};
TestTensor expected{armnn::TensorShape{1,3},{0,1,2}};
ConcatTestImpl({&aIn, &bIn, &cIn}, axis, expected, sample);
}
BOOST_DATA_TEST_CASE(SimpleConcatAxisZero1D, COMPUTE_DEVICES)
{
int32_t axis = 0;
TestTensor aIn{armnn::TensorShape{1},{0}};
TestTensor bIn{armnn::TensorShape{1},{1}};
TestTensor cIn{armnn::TensorShape{1},{2}};
TestTensor expected{armnn::TensorShape{3},{0,1,2}};
ConcatTestImpl({&aIn, &bIn, &cIn}, axis, expected, sample);
}
BOOST_AUTO_TEST_SUITE_END()
Reference in New Issue View Git Blame Copy Permalink