1 /*
2 * Copyright (C) 2021 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #ifndef ANDROID_HARDWARE_NEURALNETWORKS_AIDL_UTILS_H
18 #define ANDROID_HARDWARE_NEURALNETWORKS_AIDL_UTILS_H
19
20 #include <android-base/logging.h>
21 #include <android/hardware_buffer.h>
22 #include <gtest/gtest.h>
23
24 #include <algorithm>
25 #include <iosfwd>
26 #include <string>
27 #include <utility>
28 #include <vector>
29
30 #include <aidl/android/hardware/neuralnetworks/IDevice.h>
31 #include <aidl/android/hardware/neuralnetworks/Memory.h>
32 #include <aidl/android/hardware/neuralnetworks/Operand.h>
33 #include <aidl/android/hardware/neuralnetworks/OperandType.h>
34 #include <aidl/android/hardware/neuralnetworks/Priority.h>
35 #include <aidl/android/hardware/neuralnetworks/Request.h>
36
37 #include <TestHarness.h>
38 #include <nnapi/SharedMemory.h>
39
40 namespace aidl::android::hardware::neuralnetworks {
41
42 namespace nn = ::android::nn;
43
44 inline constexpr Priority kDefaultPriority = Priority::MEDIUM;
45
46 inline constexpr Timing kNoTiming = {.timeOnDeviceNs = -1, .timeInDriverNs = -1};
47 inline constexpr int64_t kNoDeadline = -1;
48 inline constexpr int64_t kOmittedTimeoutDuration = -1;
49 inline constexpr int64_t kNoDuration = -1;
50 inline const std::vector<uint8_t> kEmptyCacheToken(IDevice::BYTE_SIZE_OF_CACHE_TOKEN);
51
52 // Returns the amount of space needed to store a value of the specified type.
53 //
54 // Aborts if the specified type is an extension type or OEM type.
55 uint32_t sizeOfData(OperandType type);
56
57 // Returns the amount of space needed to store a value of the dimensions and
58 // type of this operand. For a non-extension, non-OEM tensor with unspecified
59 // rank or at least one unspecified dimension, returns zero.
60 //
61 // Aborts if the specified type is an extension type or OEM type.
62 uint32_t sizeOfData(const Operand& operand);
63
64 // Convenience class to manage the lifetime of memory resources.
65 class TestMemoryBase {
66 DISALLOW_COPY_AND_ASSIGN(TestMemoryBase);
67
68 public:
69 TestMemoryBase() = default;
70 virtual ~TestMemoryBase() = default;
getPointer()71 uint8_t* getPointer() const { return mPtr; }
getAidlMemory()72 const Memory* getAidlMemory() const { return &mAidlMemory; }
73
74 protected:
75 uint8_t* mPtr = nullptr;
76 Memory mAidlMemory;
77 bool mIsValid = false;
78 };
79
80 class TestAshmem : public TestMemoryBase {
81 public:
82 // If aidlReadonly is true, getAidlMemory will return a sAIDL memory with readonly access;
83 // otherwise, the sAIDL memory has read-write access. This only affects the sAIDL memory.
84 // getPointer will always return a valid address with read-write access.
85 static std::unique_ptr<TestAshmem> create(uint32_t size, bool aidlReadonly = false);
86
87 // Prefer TestAshmem::create.
88 // The constructor calls initialize, which constructs the memory resources. This is a workaround
89 // that gtest macros cannot be used directly in a constructor.
TestAshmem(uint32_t size,bool aidlReadonly)90 TestAshmem(uint32_t size, bool aidlReadonly) { initialize(size, aidlReadonly); }
91
92 private:
93 void initialize(uint32_t size, bool aidlReadonly);
94 nn::Mapping mMappedMemory;
95 };
96
97 class TestBlobAHWB : public TestMemoryBase {
98 public:
99 static std::unique_ptr<TestBlobAHWB> create(uint32_t size);
100
101 // Prefer TestBlobAHWB::create.
102 // The constructor calls initialize, which constructs the memory resources. This is a
103 // workaround that gtest macros cannot be used directly in a constructor.
TestBlobAHWB(uint32_t size)104 TestBlobAHWB(uint32_t size) { initialize(size); }
105
106 private:
107 void initialize(uint32_t size);
108 nn::SharedMemory mMemory;
109 nn::Mapping mMapping;
110 };
111
112 enum class MemoryType { ASHMEM, BLOB_AHWB, DEVICE };
113
114 // Manages the lifetime of memory resources used in an execution.
115 class ExecutionContext {
116 DISALLOW_COPY_AND_ASSIGN(ExecutionContext);
117
118 public:
119 static constexpr uint32_t kInputPoolIndex = 0;
120 static constexpr uint32_t kOutputPoolIndex = 1;
121
122 ExecutionContext() = default;
123
124 // Create HIDL Request from the TestModel struct.
125 Request createRequest(const test_helper::TestModel& testModel,
126 MemoryType memoryType = MemoryType::ASHMEM);
127
128 // After execution, copy out output results from the output memory pool.
129 std::vector<test_helper::TestBuffer> getOutputBuffers(const Request& request) const;
130
131 private:
132 std::unique_ptr<TestMemoryBase> mInputMemory, mOutputMemory;
133 };
134
135 template <typename Type>
136 using Named = std::pair<std::string, Type>;
137
138 template <typename Type>
getName(const Named<Type> & namedData)139 const std::string& getName(const Named<Type>& namedData) {
140 return namedData.first;
141 }
142
143 template <typename Type>
getData(const Named<Type> & namedData)144 const Type& getData(const Named<Type>& namedData) {
145 return namedData.second;
146 }
147
148 std::string gtestCompliantName(std::string name);
149
150 // pretty-print values for error messages
151 ::std::ostream& operator<<(::std::ostream& os, ErrorStatus errorStatus);
152
153 } // namespace aidl::android::hardware::neuralnetworks
154
155 #endif // ANDROID_HARDWARE_NEURALNETWORKS_AIDL_UTILS_H
156