aboutsummaryrefslogtreecommitdiff
path: root/applications/message_handler/test/test_helpers.hpp
blob: 0440b584568e365ffd451b4914558402391f13cf (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131

/*
 * 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 TEST_HELPERS_H
#define TEST_HELPERS_H

#include <inttypes.h>
#include <stdio.h>

#include "ethosu_core_interface.h"

namespace MessageHandler {

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,
                                                  unsigned char *input_data,
                                                  uint32_t input_data_size,
                                                  uint8_t *output_data,
                                                  uint32_t output_data_size) {
    ethosu_core_inference_req req = {
        user_arg, // user_arg
        1,        // ifm_count
        {         // ifm
         {
             reinterpret_cast<uint32_t>(input_data), // ptr
             input_data_size                         // size
         }},
        1, // ofm_count
        {  // ofm
         {
             reinterpret_cast<uint32_t>(output_data), // ptr
             output_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,
                                                 unsigned char *input_data,
                                                 uint32_t input_data_size,
                                                 uint8_t *output_data,
                                                 uint32_t output_data_size) {
    ethosu_core_inference_req req = {
        user_arg, // user_arg
        1,        // ifm_count
        {         // ifm
         {
             reinterpret_cast<uint32_t>(input_data), // ptr
             input_data_size                         // size
         }},
        1, // ofm_count
        {  // ofm
         {
             reinterpret_cast<uint32_t>(output_data), // ptr
             output_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;
}
} // namespace MessageHandler

#endif