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
132
133
134
135
|
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// See LICENSE file in the project root for full license information.
//
#pragma once
#ifndef LOG_TAG
#define LOG_TAG "ArmnnDriverTests"
#endif // LOG_TAG
#include "../ArmnnDriver.hpp"
#include <iosfwd>
namespace android
{
namespace hardware
{
namespace neuralnetworks
{
namespace V1_0
{
std::ostream& operator<<(std::ostream& os, ErrorStatus stat);
} // namespace android::hardware::neuralnetworks::V1_0
} // namespace android::hardware::neuralnetworks
} // namespace android::hardware
} // namespace android
namespace driverTestHelpers
{
std::ostream& operator<<(std::ostream& os, android::hardware::neuralnetworks::V1_0::ErrorStatus stat);
struct ExecutionCallback : public IExecutionCallback
{
ExecutionCallback() : mNotified(false) {}
Return<void> notify(ErrorStatus status) override;
/// wait until the callback has notified us that it is done
Return<void> wait();
private:
// use a mutex and a condition variable to wait for asynchronous callbacks
std::mutex mMutex;
std::condition_variable mCondition;
// and a flag, in case we are notified before the wait call
bool mNotified;
};
class PreparedModelCallback : public IPreparedModelCallback
{
public:
PreparedModelCallback()
: m_ErrorStatus(ErrorStatus::NONE)
, m_PreparedModel()
{ }
~PreparedModelCallback() override { }
Return<void> notify(ErrorStatus status,
const android::sp<IPreparedModel>& preparedModel) override;
ErrorStatus GetErrorStatus() { return m_ErrorStatus; }
android::sp<IPreparedModel> GetPreparedModel() { return m_PreparedModel; }
private:
ErrorStatus m_ErrorStatus;
android::sp<IPreparedModel> m_PreparedModel;
};
hidl_memory allocateSharedMemory(int64_t size);
android::sp<IMemory> AddPoolAndGetData(uint32_t size, Request& request);
void AddPoolAndSetData(uint32_t size, Request& request, const float* data);
void AddOperand(Model& model, const Operand& op);
void AddIntOperand(Model& model, int32_t value);
template<typename T>
OperandType TypeToOperandType();
template<>
OperandType TypeToOperandType<float>();
template<>
OperandType TypeToOperandType<int32_t>();
template<typename T>
void AddTensorOperand(Model& model, hidl_vec<uint32_t> dimensions, T* values)
{
uint32_t totalElements = 1;
for (uint32_t dim : dimensions)
{
totalElements *= dim;
}
DataLocation location = {};
location.offset = model.operandValues.size();
location.length = totalElements * sizeof(T);
Operand op = {};
op.type = TypeToOperandType<T>();
op.dimensions = dimensions;
op.lifetime = OperandLifeTime::CONSTANT_COPY;
op.location = location;
model.operandValues.resize(model.operandValues.size() + location.length);
for (uint32_t i = 0; i < totalElements; i++)
{
*(reinterpret_cast<T*>(&model.operandValues[location.offset]) + i) = values[i];
}
AddOperand(model, op);
}
void AddInputOperand(Model& model, hidl_vec<uint32_t> dimensions);
void AddOutputOperand(Model& model, hidl_vec<uint32_t> dimensions);
android::sp<IPreparedModel> PrepareModel(const Model& model,
armnn_driver::ArmnnDriver& driver);
android::sp<IPreparedModel> PrepareModelWithStatus(const Model& model,
armnn_driver::ArmnnDriver& driver,
ErrorStatus & prepareStatus,
ErrorStatus expectedStatus=ErrorStatus::NONE);
ErrorStatus Execute(android::sp<IPreparedModel> preparedModel,
const Request& request,
ErrorStatus expectedStatus=ErrorStatus::NONE);
android::sp<ExecutionCallback> ExecuteNoWait(android::sp<IPreparedModel> preparedModel,
const Request& request);
} // namespace driverTestHelpers
|
