Add first set of tests for the message_handler

Covering inference runs and other utility messages.

Change-Id: I95958a9e5902fde2003c870c78e0b0f2e8cd7968

7 files changed, 550 insertions, 9 deletions

diff --git a/applications/message_handler/CMakeLists.txt b/applications/message_handler/CMakeLists.txt
index 8d4ef54..6928c2d 100644
--- a/applications/message_handler/CMakeLists.txt
+++ b/applications/message_handler/CMakeLists.txt
@@ -32,6 +32,7 @@ set(MESSAGE_HANDLER_ARENA_SIZE 2000000 CACHE STRING "Total size of all message h
 math(EXPR TENSOR_ARENA_SIZE "${MESSAGE_HANDLER_ARENA_SIZE} / ${NUM_ARENAS}")
 
 add_subdirectory(lib)
+add_subdirectory(test)
 
 set(MESSAGE_HANDLER_MODEL_0 "" CACHE STRING "Path to built in model 0")
 set(MESSAGE_HANDLER_MODEL_1 "" CACHE STRING "Path to built in model 1")
diff --git a/applications/message_handler/indexed_networks/indexed_networks.hpp b/applications/message_handler/indexed_networks/indexed_networks.hpp
index 0b6d62a..d37ddba 100644
--- a/applications/message_handler/indexed_networks/indexed_networks.hpp
+++ b/applications/message_handler/indexed_networks/indexed_networks.hpp
@@ -65,29 +65,29 @@ public:
         switch (index) {
 #if defined(MODEL_0)
         case 0:
-            data = reinterpret_cast<void *>(Model0::networkModel);
-            size = sizeof(Model0::networkModel);
+            data = reinterpret_cast<void *>(Model0::networkModelData);
+            size = sizeof(Model0::networkModelData);
             break;
 #endif
 
 #if defined(MODEL_1)
         case 1:
-            data = reinterpret_cast<void *>(Model1::networkModel);
-            size = sizeof(Model1::networkModel);
+            data = reinterpret_cast<void *>(Model1::networkModelData);
+            size = sizeof(Model1::networkModelData);
             break;
 #endif
 
 #if defined(MODEL_2)
         case 2:
-            data = reinterpret_cast<void *>(Model2::networkModel);
-            size = sizeof(Model2::networkModel);
+            data = reinterpret_cast<void *>(Model2::networkModelData);
+            size = sizeof(Model2::networkModelData);
             break;
 #endif
 
 #if defined(MODEL_3)
         case 3:
-            data = reinterpret_cast<void *>(Model3::networkModel);
-            size = sizeof(Model3::networkModel);
+            data = reinterpret_cast<void *>(Model3::networkModelData);
+            size = sizeof(Model3::networkModelData);
             break;
 #endif
 
diff --git a/applications/message_handler/indexed_networks/network_template.hpp b/applications/message_handler/indexed_networks/network_template.hpp
index 353d7d3..a477b84 100644
--- a/applications/message_handler/indexed_networks/network_template.hpp
+++ b/applications/message_handler/indexed_networks/network_template.hpp
@@ -18,6 +18,6 @@
 
 #include <stdint.h>
 
-__attribute__((section(".sram.data"), aligned(16))) uint8_t networkModel[] = {
+__attribute__((section(".sram.data"), aligned(16))) uint8_t networkModelData[] = {
     /* Add network model here */
 };
diff --git a/applications/message_handler/test/CMakeLists.txt b/applications/message_handler/test/CMakeLists.txt
new file mode 100644
index 0000000..44fd471
--- /dev/null
+++ b/applications/message_handler/test/CMakeLists.txt
@@ -0,0 +1,50 @@
+#
+# 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.
+#
+
+set(TEST_MESSAGE_HANDLER_MODEL_0 "model.h" CACHE STRING "Path to built in model 0")
+set(TEST_MESSAGE_HANDLER_MODEL_1 "" CACHE STRING "Path to built in model 1")
+set(TEST_MESSAGE_HANDLER_MODEL_2 "" CACHE STRING "Path to built in model 2")
+set(TEST_MESSAGE_HANDLER_MODEL_3 "" CACHE STRING "Path to built in model 3")
+
+if(TARGET ethosu_core_driver)
+    file(GLOB models LIST_DIRECTORIES true "${CMAKE_CURRENT_SOURCE_DIR}/../../baremetal/models/${ETHOSU_TARGET_NPU_CONFIG}/*")
+endif()
+
+foreach(model ${models})
+    get_filename_component(modelname ${model} NAME)
+    ethosu_add_executable_test(message_handler_test_${modelname}
+        SOURCES
+        main.cpp
+        message_client.cpp
+        LIBRARIES
+        message_handler_lib
+        freertos_kernel
+        ethosu_mhu_dummy)
+
+    target_include_directories(message_handler_test_${modelname} PRIVATE
+        ../indexed_networks
+        ${model}
+        ${LINUX_DRIVER_STACK_PATH}/kernel)
+
+    target_compile_definitions(message_handler_test_${modelname} PRIVATE
+        TENSOR_ARENA_SIZE=${MESSAGE_HANDLER_ARENA_SIZE}
+        $<$<BOOL:${TEST_MESSAGE_HANDLER_MODEL_0}>:MODEL_0=${TEST_MESSAGE_HANDLER_MODEL_0}>
+        $<$<BOOL:${TEST_MESSAGE_HANDLER_MODEL_1}>:MODEL_1=${TEST_MESSAGE_HANDLER_MODEL_1}>
+        $<$<BOOL:${TEST_MESSAGE_HANDLER_MODEL_2}>:MODEL_2=${TEST_MESSAGE_HANDLER_MODEL_2}>
+        $<$<BOOL:${TEST_MESSAGE_HANDLER_MODEL_3}>:MODEL_3=${TEST_MESSAGE_HANDLER_MODEL_3}>)
+endforeach()
diff --git a/applications/message_handler/test/main.cpp b/applications/message_handler/test/main.cpp
new file mode 100644
index 0000000..0d88611
--- /dev/null
+++ b/applications/message_handler/test/main.cpp
@@ -0,0 +1,345 @@
+/*
+ * 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)
+
+// Nr. of tasks to process inferences with, reserves driver & runs inference (Normally 1 per NPU, but not a must)
+#if defined(ETHOSU) && defined(ETHOSU_NPU_COUNT) && ETHOSU_NPU_COUNT > 0
+constexpr size_t NUM_PARALLEL_TASKS = ETHOSU_NPU_COUNT;
+#else
+constexpr size_t NUM_PARALLEL_TASKS = 1;
+#endif
+
+// TensorArena static initialisation
+constexpr size_t arenaSize = TENSOR_ARENA_SIZE;
+
+__attribute__((section(".bss.tensor_arena"), aligned(16))) uint8_t tensorArena[NUM_PARALLEL_TASKS][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(10, 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;
+};
+
+struct InferenceTaskParams {
+    TaskParams *taskParams;
+    uint8_t *arena;
+};
+
+void inferenceTask(void *pvParameters) {
+    printf("Starting inference task\n");
+    InferenceTaskParams *params = reinterpret_cast<InferenceTaskParams *>(pvParameters);
+
+    InferenceHandler process(params->arena,
+                             arenaSize,
+                             params->taskParams->inferenceInputQueue,
+                             params->taskParams->inferenceOutputQueue,
+                             params->taskParams->messageNotify,
+                             params->taskParams->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();
+}
+
+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_major > 0 || rsp.version_minor > 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 testNetworkInfo(MessageClient client) {
+    const uint64_t fake_user_arg     = 42;
+    ethosu_core_network_info_req req = {fake_user_arg,              // user_arg
+                                        {                           // network
+                                         ETHOSU_CORE_NETWORK_INDEX, // type
+                                         {{
+                                             0, // index
+                                             0  // ignored padding of union
+                                         }}}};
+    ethosu_core_network_info_rsp rsp;
+    ethosu_core_network_info_rsp expected_rsp = {
+        req.user_arg,           // user_arg
+        "Vela Optimised",       // description
+        1,                      // ifm_count
+        {/* not comparable */}, // ifm_sizes
+        1,                      // ofm_count
+        {/* not comparable */}, // ofm_sizes
+        0                       // status
+    };
+
+    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 testInferenceRun(MessageClient client) {
+    uint8_t data[sizeof(expectedOutputData)];
+    const uint64_t fake_user_arg  = 42;
+    ethosu_core_inference_req req = {
+        fake_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[0]), // ptr
+             sizeof(data)                          // size
+         }},
+        {                           // network
+         ETHOSU_CORE_NETWORK_INDEX, // type
+         {{
+             0, // index
+             0  // ignored padding of union
+         }}},
+        {0, 0, 0, 0, 0, 0, 0, 0}, // pmu_event_config
+        0                         // pmu_cycle_counter_enable
+    };
+    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 clientTask(void *) {
+    printf("Starting client task\n");
+
+    MessageClient client(*inputMessageQueue.toQueue(), *outputMessageQueue.toQueue(), mailbox);
+
+    vTaskDelay(10);
+
+    testPing(client);
+    testVersion(client);
+    testCapabilities(client);
+    testNetworkInfo(client);
+    testInferenceRun(client);
+
+    exit(0);
+}
+
+/*
+ * Keep task parameters as global data as FreeRTOS resets the stack when the
+ * scheduler is started.
+ */
+TaskParams taskParams;
+InferenceTaskParams infParams[NUM_PARALLEL_TASKS];
+
+} // 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;
+    }
+
+    // One inference task for each NPU
+    for (size_t n = 0; n < NUM_PARALLEL_TASKS; n++) {
+        infParams[n].taskParams = &taskParams;
+        infParams[n].arena      = reinterpret_cast<uint8_t *>(&tensorArena[n]);
+        ret                     = xTaskCreate(inferenceTask, "inferenceTask", 8 * 1024, &infParams[n], 3, nullptr);
+        if (ret != pdPASS) {
+            printf("Failed to create 'inferenceTask%d'\n", n);
+            return ret;
+        }
+    }
+
+    // Task for handling incoming /outgoing messages from the remote host
+    ret = xTaskCreate(clientTask, "clientTask", 512, nullptr, 2, nullptr);
+    if (ret != pdPASS) {
+        printf("Failed to create 'messageTask'\n");
+        return ret;
+    }
+
+    // Start Scheduler
+    vTaskStartScheduler();
+
+    return 1;
+}
diff --git a/applications/message_handler/test/message_client.cpp b/applications/message_handler/test/message_client.cpp
new file mode 100644
index 0000000..4209564
--- /dev/null
+++ b/applications/message_handler/test/message_client.cpp
@@ -0,0 +1,91 @@
+/*
+ * 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 "FreeRTOS.h"
+#include "task.h"
+
+#include "ethosu_core_interface.h"
+#include "message_client.hpp"
+
+using namespace EthosU;
+
+namespace MessageHandler {
+
+MessageClient::MessageClient(EthosU::ethosu_core_queue &_inputMessageQueue,
+                             EthosU::ethosu_core_queue &_outputMessageQueue,
+                             Mailbox::Mailbox &_mailbox) :
+    input(_inputMessageQueue),
+    output(_outputMessageQueue), mailbox(_mailbox) {}
+
+bool MessageClient::sendInputMessage(const uint32_t type, const void *src, uint32_t length) {
+    if (!input.write(type, src, length)) {
+        printf("ERROR: Msg: Failed to write ping request. No mailbox message sent\n");
+        return false;
+    }
+
+    mailbox.sendMessage();
+    mailbox.handleMessage();
+    return true;
+}
+
+bool MessageClient::waitAndReadOutputMessage(const uint32_t expected_type, uint8_t *dst, uint32_t length) {
+    constexpr TickType_t delay    = pdMS_TO_TICKS(2);
+    constexpr TickType_t deadline = pdMS_TO_TICKS(/* 1 minute */ 60 * 1000 * 1000);
+    struct ethosu_core_msg msg;
+
+    TickType_t totalDelay = 0;
+    while (output.available() == 0) {
+        vTaskDelay(delay);
+        totalDelay += delay;
+        if (totalDelay >= deadline) {
+            return false;
+        }
+    }
+
+    if (!output.read(msg)) {
+        printf("ERROR: Failed to read msg header\n");
+        return false;
+    }
+
+    if (msg.magic != ETHOSU_CORE_MSG_MAGIC) {
+        printf("ERROR: Invalid Magic\n");
+        return false;
+    }
+
+    if (msg.type != expected_type) {
+        printf("ERROR: Wrong message type\n");
+        return false;
+    }
+
+    if (msg.length != length) {
+        printf("ERROR: Wrong message size\n");
+        return false;
+    }
+
+    if (length == 0) {
+        return true;
+    }
+
+    if (!output.read(dst, length)) {
+        printf("ERROR: Failed to read msg payload\n");
+        return false;
+    }
+
+    return true;
+}
+} // namespace MessageHandler
diff --git a/applications/message_handler/test/message_client.hpp b/applications/message_handler/test/message_client.hpp
new file mode 100644
index 0000000..e90843b
--- /dev/null
+++ b/applications/message_handler/test/message_client.hpp
@@ -0,0 +1,54 @@
+/*
+ * 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.
+ */
+
+#ifndef MESSAGE_CLIENT_H
+#define MESSAGE_CLIENT_H
+
+#include <inttypes.h>
+#include <stdio.h>
+
+#include "message_queue.hpp"
+#include <mailbox.hpp>
+
+namespace MessageHandler {
+
+class MessageClient {
+public:
+    MessageClient(EthosU::ethosu_core_queue &inputMessageQueue,
+                  EthosU::ethosu_core_queue &outputMessageQueue,
+                  Mailbox::Mailbox &mailbox);
+
+    template <typename T>
+    bool sendInputMessage(const uint32_t type, const T &src) {
+        return sendInputMessage(type, reinterpret_cast<const uint8_t *>(&src), sizeof(src));
+    }
+    bool sendInputMessage(const uint32_t type, const void *src = nullptr, uint32_t length = 0);
+    template <typename T>
+    bool waitAndReadOutputMessage(const uint32_t expected_type, T &dst) {
+        return waitAndReadOutputMessage(expected_type, reinterpret_cast<uint8_t *>(&dst), sizeof(dst));
+    }
+    bool waitAndReadOutputMessage(const uint32_t expected_type, uint8_t *dst = nullptr, uint32_t length = 0);
+
+private:
+    MessageQueue::QueueImpl input;
+    MessageQueue::QueueImpl output;
+    Mailbox::Mailbox &mailbox;
+};
+} // namespace MessageHandler
+
+#endif