diff options
author | Davide Grohmann <davide.grohmann@arm.com> | 2022-08-08 17:30:28 +0200 |
---|---|---|
committer | Davide Grohmann <davide.grohmann@arm.com> | 2022-08-17 09:57:17 +0200 |
commit | ec72e9bc21a6b0c03b424ab882652e96c2b291b4 (patch) | |
tree | b38068925d1b71ae32ae15aed1f9238b351f4d34 /applications | |
parent | 5508acb0c7803769b9bbda08762b232c13272bd9 (diff) | |
download | ethos-u-core-platform-ec72e9bc21a6b0c03b424ab882652e96c2b291b4.tar.gz |
Add first set of tests for the message_handler
Covering inference runs and other utility messages.
Change-Id: I95958a9e5902fde2003c870c78e0b0f2e8cd7968
Diffstat (limited to 'applications')
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 |