| /* |
| * 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. |
| */ |
| |
| /**************************************************************************** |
| * Includes |
| ****************************************************************************/ |
| |
| #include "FreeRTOS.h" |
| #include "queue.h" |
| #include "semphr.h" |
| #include "task.h" |
| |
| #include <inttypes.h> |
| #include <stdio.h> |
| |
| #include "ethosu_core_interface.h" |
| #include "indexed_networks.hpp" |
| #include "input.h" |
| #include "message_client.hpp" |
| #include "message_handler.hpp" |
| #include "message_queue.hpp" |
| #include "networks.hpp" |
| #include "output.h" |
| |
| #include <mailbox.hpp> |
| #include <mhu_dummy.hpp> |
| |
| /* Disable semihosting */ |
| __asm(".global __use_no_semihosting\n\t"); |
| |
| using namespace EthosU; |
| using namespace MessageHandler; |
| |
| /**************************************************************************** |
| * Defines |
| ****************************************************************************/ |
| |
| #define TEST_ASSERT(v) \ |
| do { \ |
| if (!(v)) { \ |
| fprintf(stderr, "%s:%d ERROR test failed: '%s'\n", __FILE__, __LINE__, #v); \ |
| exit(1); \ |
| } \ |
| } while (0) |
| |
| // TensorArena static initialisation |
| constexpr size_t arenaSize = TENSOR_ARENA_SIZE; |
| |
| __attribute__((section(".bss.tensor_arena"), aligned(16))) uint8_t tensorArena[arenaSize]; |
| |
| // Message queue from remote host |
| __attribute__((section("ethosu_core_in_queue"))) MessageQueue::Queue<1000> inputMessageQueue; |
| |
| // Message queue to remote host |
| __attribute__((section("ethosu_core_out_queue"))) MessageQueue::Queue<1000> outputMessageQueue; |
| |
| namespace { |
| Mailbox::MHUDummy mailbox; |
| } // namespace |
| |
| /**************************************************************************** |
| * Application |
| ****************************************************************************/ |
| namespace { |
| |
| struct TaskParams { |
| TaskParams() : |
| messageNotify(xSemaphoreCreateBinary()), |
| inferenceInputQueue(std::make_shared<Queue<ethosu_core_inference_req>>()), |
| inferenceOutputQueue(xQueueCreate(5, sizeof(ethosu_core_inference_rsp))), |
| networks(std::make_shared<WithIndexedNetworks>()) {} |
| |
| SemaphoreHandle_t messageNotify; |
| // Used to pass inference requests to the inference runner task |
| std::shared_ptr<Queue<ethosu_core_inference_req>> inferenceInputQueue; |
| // Queue for message responses to the remote host |
| QueueHandle_t inferenceOutputQueue; |
| // Networks provider |
| std::shared_ptr<Networks> networks; |
| }; |
| |
| void inferenceTask(void *pvParameters) { |
| printf("Starting inference task\n"); |
| TaskParams *params = reinterpret_cast<TaskParams *>(pvParameters); |
| |
| InferenceHandler process(tensorArena, |
| arenaSize, |
| params->inferenceInputQueue, |
| params->inferenceOutputQueue, |
| params->messageNotify, |
| params->networks); |
| |
| process.run(); |
| } |
| |
| void messageTask(void *pvParameters) { |
| printf("Starting message task\n"); |
| TaskParams *params = reinterpret_cast<TaskParams *>(pvParameters); |
| |
| IncomingMessageHandler process(*inputMessageQueue.toQueue(), |
| *outputMessageQueue.toQueue(), |
| mailbox, |
| params->inferenceInputQueue, |
| params->inferenceOutputQueue, |
| params->messageNotify, |
| params->networks); |
| process.run(); |
| } |
| |
| ethosu_core_network_info_req networkInfoIndexedRequest(uint64_t user_arg, uint32_t index) { |
| ethosu_core_network_info_req req = {user_arg, // user_arg |
| { // network |
| ETHOSU_CORE_NETWORK_INDEX, // type |
| {{ |
| index, // index |
| 0 // ignored padding of union |
| }}}}; |
| return req; |
| } |
| |
| ethosu_core_network_info_req networkInfoBufferRequest(uint64_t user_arg, unsigned char *ptr, uint32_t ptr_size) { |
| ethosu_core_network_info_req req = {user_arg, // user_arg |
| { // network |
| ETHOSU_CORE_NETWORK_BUFFER, // type |
| {{ |
| reinterpret_cast<uint32_t>(ptr), // ptr |
| ptr_size // size |
| }}}}; |
| return req; |
| } |
| |
| ethosu_core_network_info_rsp networkInfoResponse(uint64_t user_arg) { |
| ethosu_core_network_info_rsp rsp = { |
| user_arg, // user_arg |
| "Vela Optimised", // description |
| 1, // ifm_count |
| {/* not comparable */}, // ifm_sizes |
| 1, // ofm_count |
| {/* not comparable */}, // ofm_sizes |
| ETHOSU_CORE_STATUS_OK // status |
| }; |
| return rsp; |
| } |
| |
| ethosu_core_inference_req |
| inferenceIndexedRequest(uint64_t user_arg, uint32_t index, uint8_t *data, uint32_t data_size) { |
| ethosu_core_inference_req req = { |
| user_arg, // user_arg |
| 1, // ifm_count |
| { // ifm: |
| { |
| reinterpret_cast<uint32_t>(&inputData[0]), // ptr |
| sizeof(inputData) // size |
| }}, |
| 1, // ofm_count |
| { // ofm |
| { |
| reinterpret_cast<uint32_t>(data), // ptr |
| data_size // size |
| }}, |
| { // network |
| ETHOSU_CORE_NETWORK_INDEX, // type |
| {{ |
| index, // index |
| 0 // ignored padding of union |
| }}}, |
| {0, 0, 0, 0, 0, 0, 0, 0}, // pmu_event_config |
| 0 // pmu_cycle_counter_enable |
| }; |
| return req; |
| } |
| |
| ethosu_core_inference_req |
| inferenceBufferRequest(uint64_t user_arg, unsigned char *ptr, uint32_t ptr_size, uint8_t *data, uint32_t data_size) { |
| ethosu_core_inference_req req = { |
| user_arg, // user_arg |
| 1, // ifm_count |
| { // ifm: |
| { |
| reinterpret_cast<uint32_t>(&inputData[0]), // ptr |
| sizeof(inputData) // size |
| }}, |
| 1, // ofm_count |
| { // ofm |
| { |
| reinterpret_cast<uint32_t>(data), // ptr |
| data_size // size |
| }}, |
| { // network |
| ETHOSU_CORE_NETWORK_BUFFER, // type |
| {{ |
| reinterpret_cast<uint32_t>(ptr), // ptr |
| ptr_size // size |
| }}}, |
| {0, 0, 0, 0, 0, 0, 0, 0}, // pmu_event_config |
| 0 // pmu_cycle_counter_enable |
| }; |
| return req; |
| } |
| |
| void testPing(MessageClient client) { |
| TEST_ASSERT(client.sendInputMessage(ETHOSU_CORE_MSG_PING)); |
| TEST_ASSERT(client.waitAndReadOutputMessage(ETHOSU_CORE_MSG_PONG)); |
| } |
| |
| void testVersion(MessageClient client) { |
| ethosu_core_msg_version ver; |
| TEST_ASSERT(client.sendInputMessage(ETHOSU_CORE_MSG_VERSION_REQ)); |
| TEST_ASSERT(client.waitAndReadOutputMessage(ETHOSU_CORE_MSG_VERSION_RSP, ver)); |
| |
| TEST_ASSERT(ver.major == ETHOSU_CORE_MSG_VERSION_MAJOR); |
| TEST_ASSERT(ver.minor == ETHOSU_CORE_MSG_VERSION_MINOR); |
| TEST_ASSERT(ver.patch == ETHOSU_CORE_MSG_VERSION_PATCH); |
| } |
| |
| void readCapabilities(ethosu_core_msg_capabilities_rsp &rsp) { |
| #ifdef ETHOSU |
| struct ethosu_driver_version version; |
| ethosu_get_driver_version(&version); |
| |
| struct ethosu_hw_info info; |
| struct ethosu_driver *drv = ethosu_reserve_driver(); |
| ethosu_get_hw_info(drv, &info); |
| ethosu_release_driver(drv); |
| |
| rsp.version_status = info.version.version_status; |
| rsp.version_minor = info.version.version_minor; |
| rsp.version_major = info.version.version_major; |
| rsp.product_major = info.version.product_major; |
| rsp.arch_patch_rev = info.version.arch_patch_rev; |
| rsp.arch_minor_rev = info.version.arch_minor_rev; |
| rsp.arch_major_rev = info.version.arch_major_rev; |
| rsp.driver_patch_rev = version.patch; |
| rsp.driver_minor_rev = version.minor; |
| rsp.driver_major_rev = version.major; |
| rsp.macs_per_cc = info.cfg.macs_per_cc; |
| rsp.cmd_stream_version = info.cfg.cmd_stream_version; |
| rsp.custom_dma = info.cfg.custom_dma; |
| #endif |
| } |
| |
| void testCapabilities(MessageClient client) { |
| const uint64_t fake_user_arg = 42; |
| ethosu_core_capabilities_req req = {fake_user_arg}; |
| ethosu_core_msg_capabilities_rsp expected_rsp; |
| ethosu_core_msg_capabilities_rsp rsp; |
| |
| readCapabilities(expected_rsp); |
| expected_rsp.user_arg = req.user_arg; |
| |
| TEST_ASSERT(client.sendInputMessage(ETHOSU_CORE_MSG_CAPABILITIES_REQ, req)); |
| TEST_ASSERT(client.waitAndReadOutputMessage(ETHOSU_CORE_MSG_CAPABILITIES_RSP, rsp)); |
| |
| TEST_ASSERT(expected_rsp.version_status == rsp.version_status); |
| TEST_ASSERT(expected_rsp.version_minor == rsp.version_minor); |
| TEST_ASSERT(expected_rsp.version_major == rsp.version_major); |
| TEST_ASSERT(expected_rsp.product_major == rsp.product_major); |
| TEST_ASSERT(expected_rsp.arch_patch_rev == rsp.arch_patch_rev); |
| TEST_ASSERT(expected_rsp.arch_minor_rev == rsp.arch_minor_rev); |
| TEST_ASSERT(expected_rsp.arch_major_rev == rsp.arch_major_rev); |
| TEST_ASSERT(expected_rsp.driver_patch_rev == rsp.driver_patch_rev); |
| TEST_ASSERT(expected_rsp.driver_minor_rev == rsp.driver_minor_rev); |
| TEST_ASSERT(expected_rsp.driver_major_rev == rsp.driver_major_rev); |
| TEST_ASSERT(expected_rsp.macs_per_cc == rsp.macs_per_cc); |
| TEST_ASSERT(expected_rsp.cmd_stream_version == rsp.cmd_stream_version); |
| TEST_ASSERT(expected_rsp.custom_dma == rsp.custom_dma); |
| |
| #ifdef ETHOSU |
| TEST_ASSERT(rsp.version_status > 0); |
| TEST_ASSERT(rsp.product_major > 0); |
| TEST_ASSERT(rsp.arch_major_rev > 0 || rsp.arch_minor_rev > 0 || rsp.arch_patch_rev > 0); |
| TEST_ASSERT(rsp.driver_major_rev > 0 || rsp.driver_minor_rev > 0 || rsp.driver_patch_rev > 0); |
| TEST_ASSERT(rsp.macs_per_cc > 0); |
| #endif |
| } |
| |
| void testNetworkInfoIndex(MessageClient client) { |
| const uint64_t fake_user_arg = 42; |
| const uint32_t network_index = 0; |
| ethosu_core_network_info_req req = networkInfoIndexedRequest(fake_user_arg, network_index); |
| ethosu_core_network_info_rsp rsp; |
| ethosu_core_network_info_rsp expected_rsp = networkInfoResponse(fake_user_arg); |
| |
| TEST_ASSERT(client.sendInputMessage(ETHOSU_CORE_MSG_NETWORK_INFO_REQ, req)); |
| TEST_ASSERT(client.waitAndReadOutputMessage(ETHOSU_CORE_MSG_NETWORK_INFO_RSP, rsp)); |
| |
| TEST_ASSERT(expected_rsp.user_arg == rsp.user_arg); |
| TEST_ASSERT(std::strncmp(expected_rsp.desc, rsp.desc, sizeof(rsp.desc)) == 0); |
| TEST_ASSERT(expected_rsp.ifm_count == rsp.ifm_count); |
| TEST_ASSERT(expected_rsp.ofm_count == rsp.ofm_count); |
| TEST_ASSERT(expected_rsp.status == rsp.status); |
| } |
| |
| void testNetworkInfoNonExistantIndex(MessageClient client) { |
| const uint64_t fake_user_arg = 42; |
| const uint32_t network_index = 1; |
| ethosu_core_network_info_req req = networkInfoIndexedRequest(fake_user_arg, network_index); |
| ethosu_core_network_info_rsp rsp; |
| |
| TEST_ASSERT(client.sendInputMessage(ETHOSU_CORE_MSG_NETWORK_INFO_REQ, req)); |
| TEST_ASSERT(client.waitAndReadOutputMessage(ETHOSU_CORE_MSG_NETWORK_INFO_RSP, rsp)); |
| |
| TEST_ASSERT(fake_user_arg == rsp.user_arg); |
| TEST_ASSERT(ETHOSU_CORE_STATUS_ERROR == rsp.status); |
| } |
| |
| void testNetworkInfoBuffer(MessageClient client) { |
| const uint64_t fake_user_arg = 42; |
| uint32_t size = sizeof(Model0::networkModelData); |
| unsigned char *ptr = Model0::networkModelData; |
| ethosu_core_network_info_req req = networkInfoBufferRequest(fake_user_arg, ptr, size); |
| ethosu_core_network_info_rsp rsp; |
| ethosu_core_network_info_rsp expected_rsp = networkInfoResponse(fake_user_arg); |
| |
| TEST_ASSERT(client.sendInputMessage(ETHOSU_CORE_MSG_NETWORK_INFO_REQ, req)); |
| TEST_ASSERT(client.waitAndReadOutputMessage(ETHOSU_CORE_MSG_NETWORK_INFO_RSP, rsp)); |
| |
| TEST_ASSERT(expected_rsp.user_arg == rsp.user_arg); |
| TEST_ASSERT(std::strncmp(expected_rsp.desc, rsp.desc, sizeof(rsp.desc)) == 0); |
| TEST_ASSERT(expected_rsp.ifm_count == rsp.ifm_count); |
| TEST_ASSERT(expected_rsp.ofm_count == rsp.ofm_count); |
| TEST_ASSERT(expected_rsp.status == rsp.status); |
| } |
| |
| void testNetworkInfoUnparsableBuffer(MessageClient client) { |
| const uint64_t fake_user_arg = 42; |
| uint32_t size = sizeof(Model0::networkModelData) / 4; |
| unsigned char *ptr = Model0::networkModelData + size; |
| ethosu_core_network_info_req req = networkInfoBufferRequest(fake_user_arg, ptr, size); |
| ethosu_core_network_info_rsp rsp; |
| |
| TEST_ASSERT(client.sendInputMessage(ETHOSU_CORE_MSG_NETWORK_INFO_REQ, req)); |
| TEST_ASSERT(client.waitAndReadOutputMessage(ETHOSU_CORE_MSG_NETWORK_INFO_RSP, rsp)); |
| |
| TEST_ASSERT(42 == rsp.user_arg); |
| TEST_ASSERT(ETHOSU_CORE_STATUS_ERROR == rsp.status); |
| } |
| |
| void testInferenceRunIndex(MessageClient client) { |
| const uint64_t fake_user_arg = 42; |
| const uint32_t network_index = 0; |
| uint8_t data[sizeof(expectedOutputData)]; |
| ethosu_core_inference_req req = inferenceIndexedRequest(fake_user_arg, network_index, data, sizeof(data)); |
| ethosu_core_inference_rsp rsp; |
| |
| TEST_ASSERT(client.sendInputMessage(ETHOSU_CORE_MSG_INFERENCE_REQ, req)); |
| TEST_ASSERT(client.waitAndReadOutputMessage(ETHOSU_CORE_MSG_INFERENCE_RSP, rsp)); |
| |
| TEST_ASSERT(req.user_arg == rsp.user_arg); |
| TEST_ASSERT(rsp.ofm_count == 1); |
| TEST_ASSERT(std::memcmp(expectedOutputData, data, sizeof(expectedOutputData)) == 0); |
| TEST_ASSERT(rsp.status == ETHOSU_CORE_STATUS_OK); |
| TEST_ASSERT(rsp.pmu_cycle_counter_enable == req.pmu_cycle_counter_enable); |
| TEST_ASSERT(std::memcmp(rsp.pmu_event_config, req.pmu_event_config, sizeof(req.pmu_event_config)) == 0); |
| } |
| |
| void testInferenceRunNonExistingIndex(MessageClient client) { |
| const uint64_t fake_user_arg = 42; |
| const uint32_t network_index = 1; |
| uint8_t data[sizeof(expectedOutputData)]; |
| ethosu_core_inference_req req = inferenceIndexedRequest(fake_user_arg, network_index, data, sizeof(data)); |
| ethosu_core_inference_rsp rsp; |
| |
| TEST_ASSERT(client.sendInputMessage(ETHOSU_CORE_MSG_INFERENCE_REQ, req)); |
| TEST_ASSERT(client.waitAndReadOutputMessage(ETHOSU_CORE_MSG_INFERENCE_RSP, rsp)); |
| |
| TEST_ASSERT(req.user_arg == rsp.user_arg); |
| TEST_ASSERT(rsp.status == ETHOSU_CORE_STATUS_ERROR); |
| } |
| |
| void testInferenceRunBuffer(MessageClient client) { |
| const uint64_t fake_user_arg = 42; |
| uint32_t network_size = sizeof(Model0::networkModelData); |
| unsigned char *network_ptr = Model0::networkModelData; |
| uint8_t data[sizeof(expectedOutputData)]; |
| ethosu_core_inference_req req = |
| inferenceBufferRequest(fake_user_arg, network_ptr, network_size, data, sizeof(data)); |
| ethosu_core_inference_rsp rsp; |
| |
| TEST_ASSERT(client.sendInputMessage(ETHOSU_CORE_MSG_INFERENCE_REQ, req)); |
| TEST_ASSERT(client.waitAndReadOutputMessage(ETHOSU_CORE_MSG_INFERENCE_RSP, rsp)); |
| |
| TEST_ASSERT(req.user_arg == rsp.user_arg); |
| TEST_ASSERT(rsp.ofm_count == 1); |
| TEST_ASSERT(std::memcmp(expectedOutputData, data, sizeof(expectedOutputData)) == 0); |
| TEST_ASSERT(rsp.status == ETHOSU_CORE_STATUS_OK); |
| TEST_ASSERT(rsp.pmu_cycle_counter_enable == req.pmu_cycle_counter_enable); |
| TEST_ASSERT(std::memcmp(rsp.pmu_event_config, req.pmu_event_config, sizeof(req.pmu_event_config)) == 0); |
| } |
| |
| void testInferenceRunUnparsableBuffer(MessageClient client) { |
| const uint64_t fake_user_arg = 42; |
| uint32_t network_size = sizeof(Model0::networkModelData) / 4; |
| unsigned char *network_ptr = Model0::networkModelData + network_size; |
| uint8_t data[sizeof(expectedOutputData)]; |
| ethosu_core_inference_req req = |
| inferenceBufferRequest(fake_user_arg, network_ptr, network_size, data, sizeof(data)); |
| ethosu_core_inference_rsp rsp; |
| |
| TEST_ASSERT(client.sendInputMessage(ETHOSU_CORE_MSG_INFERENCE_REQ, req)); |
| TEST_ASSERT(client.waitAndReadOutputMessage(ETHOSU_CORE_MSG_INFERENCE_RSP, rsp)); |
| |
| TEST_ASSERT(req.user_arg == rsp.user_arg); |
| TEST_ASSERT(rsp.status == ETHOSU_CORE_STATUS_ERROR); |
| } |
| |
| void testSequentiallyQueuedInferenceRuns(MessageClient client) { |
| int runs = 5; |
| uint8_t data[runs][sizeof(expectedOutputData)]; |
| const uint64_t fake_user_arg = 42; |
| const uint32_t network_index = 0; |
| ethosu_core_inference_req req; |
| ethosu_core_inference_rsp rsp[runs]; |
| |
| for (int i = 0; i < runs; i++) { |
| vTaskDelay(150); |
| |
| req = inferenceIndexedRequest(fake_user_arg + i, network_index, data[i], sizeof(expectedOutputData)); |
| TEST_ASSERT(client.sendInputMessage(ETHOSU_CORE_MSG_INFERENCE_REQ, req)); |
| } |
| |
| for (int i = 0; i < runs; i++) { |
| TEST_ASSERT(client.waitAndReadOutputMessage(ETHOSU_CORE_MSG_INFERENCE_RSP, rsp[i])); |
| TEST_ASSERT(uint64_t(fake_user_arg + i) == rsp[i].user_arg); |
| TEST_ASSERT(rsp[i].ofm_count == 1); |
| TEST_ASSERT(std::memcmp(expectedOutputData, data[i], sizeof(expectedOutputData)) == 0); |
| TEST_ASSERT(rsp[i].status == ETHOSU_CORE_STATUS_OK); |
| TEST_ASSERT(rsp[i].pmu_cycle_counter_enable == req.pmu_cycle_counter_enable); |
| TEST_ASSERT(std::memcmp(rsp[i].pmu_event_config, req.pmu_event_config, sizeof(req.pmu_event_config)) == 0); |
| } |
| } |
| |
| void clientTask(void *) { |
| printf("Starting client task\n"); |
| |
| MessageClient client(*inputMessageQueue.toQueue(), *outputMessageQueue.toQueue(), mailbox); |
| |
| vTaskDelay(50); |
| |
| testPing(client); |
| testVersion(client); |
| testCapabilities(client); |
| testNetworkInfoIndex(client); |
| testNetworkInfoNonExistantIndex(client); |
| testNetworkInfoBuffer(client); |
| testNetworkInfoUnparsableBuffer(client); |
| testInferenceRunIndex(client); |
| testInferenceRunNonExistingIndex(client); |
| testInferenceRunBuffer(client); |
| testInferenceRunUnparsableBuffer(client); |
| testSequentiallyQueuedInferenceRuns(client); |
| |
| exit(0); |
| } |
| |
| /* |
| * Keep task parameters as global data as FreeRTOS resets the stack when the |
| * scheduler is started. |
| */ |
| TaskParams taskParams; |
| |
| } // namespace |
| |
| // FreeRTOS application. NOTE: Additional tasks may require increased heap size. |
| int main() { |
| BaseType_t ret; |
| |
| if (!mailbox.verifyHardware()) { |
| printf("Failed to verify mailbox hardware\n"); |
| return 1; |
| } |
| |
| // Task for handling incoming /outgoing messages from the remote host |
| ret = xTaskCreate(messageTask, "messageTask", 1024, &taskParams, 2, nullptr); |
| if (ret != pdPASS) { |
| printf("Failed to create 'messageTask'\n"); |
| return ret; |
| } |
| |
| ret = xTaskCreate(inferenceTask, "inferenceTask", 8 * 1024, &taskParams, 3, nullptr); |
| if (ret != pdPASS) { |
| printf("Failed to create 'inferenceTask'\n"); |
| return ret; |
| } |
| |
| // Task for handling incoming /outgoing messages from the remote host |
| ret = xTaskCreate(clientTask, "clientTask", 1024, nullptr, 2, nullptr); |
| if (ret != pdPASS) { |
| printf("Failed to create 'messageTask'\n"); |
| return ret; |
| } |
| |
| // Start Scheduler |
| vTaskStartScheduler(); |
| |
| return 1; |
| } |