diff options
author | Davide Grohmann <davide.grohmann@arm.com> | 2022-08-24 17:01:40 +0200 |
---|---|---|
committer | Davide Grohmann <davide.grohmann@arm.com> | 2022-09-08 09:41:00 +0200 |
commit | 6d2e5b7b85573a2b22a4a165400574cff99d4065 (patch) | |
tree | 9f1b0287f9f31a7a75f86a78d8bf1506599eb9bb /tests/run_inference_test.cpp | |
parent | f03642331f1028bdeba1c24bc5d9bd65b42c7603 (diff) | |
download | ethos-u-linux-driver-stack-6d2e5b7b85573a2b22a4a165400574cff99d4065.tar.gz |
Add cancel inference tests
These tests are run with a special custom firmware
Change-Id: I0dfcae1fbaa1287d4b52fd8f6c802bebb5248d3b
Diffstat (limited to 'tests/run_inference_test.cpp')
-rw-r--r-- | tests/run_inference_test.cpp | 164 |
1 files changed, 164 insertions, 0 deletions
diff --git a/tests/run_inference_test.cpp b/tests/run_inference_test.cpp new file mode 100644 index 0000000..94bb499 --- /dev/null +++ b/tests/run_inference_test.cpp @@ -0,0 +1,164 @@ +/* + * Copyright (c) 2022 Arm Limited. + * + * SPDX-License-Identifier: Apache-2.0 + * + * Licensed under the Apache License, Version 2.0 (the License); you may + * not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an AS IS BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include <ethosu.hpp> +#include <uapi/ethosu.h> + +#include <cstring> +#include <iostream> +#include <list> +#include <memory> +#include <sstream> +#include <stdio.h> +#include <string> +#include <unistd.h> + +#include "input.h" +#include "model.h" +#include "output.h" +#include "test_assertions.hpp" + +using namespace EthosU; + +namespace { + +int64_t defaultTimeout = 60000000000; + +void testPing(const Device &device) { + int r; + try { + r = device.ioctl(ETHOSU_IOCTL_PING); + } catch (std::exception &e) { throw TestFailureException("Ping test: ", e.what()); } + + TEST_ASSERT(r == 0); +} + +void testVersion(const Device &device) { + int r; + try { + r = device.ioctl(ETHOSU_IOCTL_VERSION_REQ); + } catch (std::exception &e) { throw TestFailureException("Version test: ", e.what()); } + + TEST_ASSERT(r == 0); +} + +void testCapabilties(const Device &device) { + Capabilities capabilities; + try { + capabilities = device.capabilities(); + } catch (std::exception &e) { throw TestFailureException("Capabilities test: ", e.what()); } + + TEST_ASSERT(capabilities.hwId.architecture > SemanticVersion()); +} + +void testNetworkInfoNotExistentIndex(const Device &device) { + try { + Network(device, 0); + FAIL(); + } catch (Exception &e) { + // good it should have thrown + } catch (std::exception &e) { throw TestFailureException("NetworkInfo no index test: ", e.what()); } +} + +void testNetworkInfoBuffer(const Device &device) { + try { + std::shared_ptr<Buffer> buffer = std::make_shared<Buffer>(device, sizeof(networkModelData)); + buffer->resize(sizeof(networkModelData)); + std::memcpy(buffer->data(), networkModelData, sizeof(networkModelData)); + Network network(device, buffer); + + TEST_ASSERT(network.getIfmDims().size() == 1); + TEST_ASSERT(network.getOfmDims().size() == 1); + } catch (std::exception &e) { throw TestFailureException("NetworkInfo buffer test: ", e.what()); } +} + +void testNetworkInfoUnparsableBuffer(const Device &device) { + try { + auto buffer = std::make_shared<Buffer>(device, sizeof(networkModelData) / 4); + buffer->resize(sizeof(networkModelData) / 4); + std::memcpy(buffer->data(), networkModelData + sizeof(networkModelData) / 4, sizeof(networkModelData) / 4); + + try { + Network network(device, buffer); + FAIL(); + } catch (Exception) { + // good, it should have thrown! + } + } catch (std::exception &e) { throw TestFailureException("NetworkInfo unparsable buffer test: ", e.what()); } +} + +void testRunInferenceBuffer(const Device &device) { + try { + auto networkBuffer = std::make_shared<Buffer>(device, sizeof(networkModelData)); + networkBuffer->resize(sizeof(networkModelData)); + std::memcpy(networkBuffer->data(), networkModelData, sizeof(networkModelData)); + auto network = std::make_shared<Network>(device, networkBuffer); + + std::vector<std::shared_ptr<Buffer>> inputBuffers; + std::vector<std::shared_ptr<Buffer>> outputBuffers; + + auto inputBuffer = std::make_shared<Buffer>(device, sizeof(inputData)); + inputBuffer->resize(sizeof(inputData)); + std::memcpy(inputBuffer->data(), inputData, sizeof(inputData)); + + inputBuffers.push_back(inputBuffer); + outputBuffers.push_back(std::make_shared<Buffer>(device, sizeof(expectedOutputData))); + std::vector<uint8_t> enabledCounters(Inference::getMaxPmuEventCounters()); + + auto inference = std::make_shared<Inference>(network, + inputBuffers.begin(), + inputBuffers.end(), + outputBuffers.begin(), + outputBuffers.end(), + enabledCounters, + false); + + bool timedout = inference->wait(defaultTimeout); + TEST_ASSERT(!timedout); + + InferenceStatus status = inference->status(); + TEST_ASSERT(status == InferenceStatus::OK); + + bool success = inference->cancel(); + TEST_ASSERT(!success); + + TEST_ASSERT(std::memcmp(expectedOutputData, outputBuffers[0]->data(), sizeof(expectedOutputData)) == 0); + + } catch (std::exception &e) { throw TestFailureException("Inference run test: ", e.what()); } +} + +} // namespace + +int main() { + Device device; + + try { + testPing(device); + testVersion(device); + testCapabilties(device); + testNetworkInfoNotExistentIndex(device); + testNetworkInfoBuffer(device); + testNetworkInfoUnparsableBuffer(device); + testRunInferenceBuffer(device); + } catch (TestFailureException &e) { + std::cerr << "Test failure: " << e.what() << std::endl; + return 1; + } + + return 0; +} |