From b8181f72b8c7c9132373dbcf7f8709ec2c0f23c0 Mon Sep 17 00:00:00 2001 From: Finn Williams Date: Wed, 7 Apr 2021 10:23:21 +0100 Subject: IVGCVSW-5787 Add/Update Execute() implementations in RefActivationWorkload * Added multithreaded StridedSliceEndToEndTest Signed-off-by: Finn Williams Change-Id: I4579db7b5959e0a22256f1bda00238c22e611dec --- .../test/StridedSliceAsyncEndToEndTest.hpp | 160 ++++++++++++++++++++- 1 file changed, 159 insertions(+), 1 deletion(-) (limited to 'src/backends/backendsCommon') diff --git a/src/backends/backendsCommon/test/StridedSliceAsyncEndToEndTest.hpp b/src/backends/backendsCommon/test/StridedSliceAsyncEndToEndTest.hpp index 66ccdbf1d9..16b10c88ac 100644 --- a/src/backends/backendsCommon/test/StridedSliceAsyncEndToEndTest.hpp +++ b/src/backends/backendsCommon/test/StridedSliceAsyncEndToEndTest.hpp @@ -22,6 +22,100 @@ namespace armnn namespace experimental { +template, typename TOutput = ResolveType > +void AsyncThreadedEndToEndTestImpl(INetworkPtr network, + const std::vector>>& inputTensorData, + const std::vector>>& expectedOutputData, + std::vector backends, + const size_t numberOfInferences, + float tolerance = 0.000001f) +{ + // Create Runtime in which test will run + IRuntime::CreationOptions options; + IRuntimePtr runtime(IRuntime::Create(options)); + + // Optimize the Network + IOptimizedNetworkPtr optNet = Optimize(*network, backends, runtime->GetDeviceSpec()); + + + // Creates AsyncNetwork + NetworkId networkId = 0; + std::string errorMessage; + const INetworkProperties networkProperties(false, false, true); + runtime->LoadNetwork(networkId, std::move(optNet), errorMessage, networkProperties); + + std::vector inputTensorsVec; + std::vector outputTensorsVec; + std::vector>> outputStorageVec; + std::vector> workingMemHandles; + + for (unsigned int i = 0; i < numberOfInferences; ++i) + { + InputTensors inputTensors; + OutputTensors outputTensors; + outputStorageVec.emplace_back(std::map>()); + + inputTensors.reserve(inputTensorData.size()); + for (auto&& it : inputTensorData[i]) + { + inputTensors.push_back({it.first, + ConstTensor(runtime->GetInputTensorInfo(networkId, it.first), it.second.data())}); + } + + outputTensors.reserve(expectedOutputData.size()); + for (auto&& it : expectedOutputData[i]) + { + std::vector out(it.second.size()); + outputStorageVec[i].emplace(it.first, out); + outputTensors.push_back({it.first, + Tensor(runtime->GetOutputTensorInfo(networkId, it.first), + outputStorageVec[i].at(it.first).data())}); + } + + inputTensorsVec.push_back(inputTensors); + outputTensorsVec.push_back(outputTensors); + + workingMemHandles.push_back(runtime->CreateWorkingMemHandle(networkId)); + } + + std::vector threads; + for (unsigned int i = 0; i < numberOfInferences; ++i) + { + // Access the vectors before we do anything multi-threaded + InputTensors& inputTensors = inputTensorsVec[i]; + OutputTensors& outputTensors = outputTensorsVec[i]; + IWorkingMemHandle& workingMemHandle = *workingMemHandles[i].get(); + + threads.emplace_back([&]() + { + // Run the async network + runtime->Execute(workingMemHandle, inputTensors, outputTensors); + }); + } + + for (unsigned int i = 0; i < numberOfInferences; ++i) + { + threads[i].join(); + } + + // Checks the results. + for (unsigned int i = 0; i < numberOfInferences; ++i) + { + for (auto &&it : expectedOutputData[i]) + { + std::vector out = outputStorageVec[i].at(it.first); + for (unsigned int j = 0; j < out.size(); ++j) + { + BOOST_CHECK(Compare(it.second[j], out[j], tolerance) == true); + } + } + } + +} + + + template, typename TOutput = ResolveType > void AsyncEndToEndTestImpl(INetworkPtr network, @@ -169,7 +263,71 @@ void StridedSlicedEndToEndTest(const std::vector& backends) std::map> inputTensorData = {{0, inputData}}; std::map> expectedOutputData = {{0, outputExpected}}; - AsyncEndToEndTestImpl(move(net), inputTensorData, expectedOutputData, backends); + AsyncEndToEndTestImpl(move(net), inputTensorData, expectedOutputData, backends, 1); +} + +template +void StridedSlicedMultiThreadedEndToEndTest(const std::vector& backends) +{ + using namespace armnn; + using T = ResolveType; + + const TensorShape& inputShape = {3, 2, 3, 1}; + const TensorShape& outputShape = {1, 2, 3, 1}; + const std::vector& beginData = {1, 0, 0, 0}; + const std::vector& endData = {2, 2, 3, 1}; + const std::vector& stridesData = {1, 1, 1, 1}; + int beginMask = 0; + int endMask = 0; + int shrinkAxisMask = 0; + int ellipsisMask = 0; + int newAxisMask = 0; + + // Builds up the structure of the network + INetworkPtr net = CreateStridedSliceNetwork(inputShape, + outputShape, + beginData, + endData, + stridesData, + beginMask, + endMask, + shrinkAxisMask, + ellipsisMask, + newAxisMask); + + BOOST_TEST_CHECKPOINT("create a network"); + + // Creates structures for input & output. + std::vector inputData1{ + 1.0f, 1.0f, 1.0f, 2.0f, 2.0f, 2.0f, + + 3.0f, 3.0f, 3.0f, 4.0f, 4.0f, 4.0f, + + 5.0f, 5.0f, 5.0f, 6.0f, 6.0f, 6.0f + }; + + std::vector outputExpected1{ 3.0f, 3.0f, 3.0f, 4.0f, 4.0f, 4.0f }; + + // Creates structures for input & output. + std::vector inputData2{ + 1.0f, 1.0f, 1.0f, 2.0f, 2.0f, 2.0f, + + 8.0f, 8.0f, 8.0f, 7.0f, 7.0f, 7.0f, + + 5.0f, 5.0f, 5.0f, 6.0f, 6.0f, 6.0f + }; + + std::vector outputExpected2{ 8.0f, 8.0f, 8.0f, 7.0f, 7.0f, 7.0f }; + + std::vector>> inputTensors; + std::vector>> outputTensors; + + inputTensors.push_back(std::map> {{0, inputData1}}); + inputTensors.push_back(std::map> {{0, inputData2}}); + outputTensors.push_back(std::map> {{0, outputExpected1}}); + outputTensors.push_back(std::map> {{0, outputExpected2}}); + + AsyncThreadedEndToEndTestImpl(move(net), inputTensors, outputTensors, backends, 2); } } // experimental namespace -- cgit v1.2.1