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 ~TestBlobAHWB();
106
107 private:
108 void initialize(uint32_t size);
109 AHardwareBuffer* mAhwb = nullptr;
110 nn::Mapping mMapping;
111 };
112
113 enum class MemoryType { ASHMEM, BLOB_AHWB, DEVICE };
114
115 // Manages the lifetime of memory resources used in an execution.
116 class ExecutionContext {
117 DISALLOW_COPY_AND_ASSIGN(ExecutionContext);
118
119 public:
120 static constexpr uint32_t kInputPoolIndex = 0;
121 static constexpr uint32_t kOutputPoolIndex = 1;
122
123 ExecutionContext() = default;
124
125 // Create HIDL Request from the TestModel struct.
126 Request createRequest(const test_helper::TestModel& testModel,
127 MemoryType memoryType = MemoryType::ASHMEM);
128
129 // After execution, copy out output results from the output memory pool.
130 std::vector<test_helper::TestBuffer> getOutputBuffers(const Request& request) const;
131
132 private:
133 std::unique_ptr<TestMemoryBase> mInputMemory, mOutputMemory;
134 };
135
136 template <typename Type>
137 using Named = std::pair<std::string, Type>;
138
139 template <typename Type>
getName(const Named<Type> & namedData)140 const std::string& getName(const Named<Type>& namedData) {
141 return namedData.first;
142 }
143
144 template <typename Type>
getData(const Named<Type> & namedData)145 const Type& getData(const Named<Type>& namedData) {
146 return namedData.second;
147 }
148
149 std::string gtestCompliantName(std::string name);
150
151 // pretty-print values for error messages
152 ::std::ostream& operator<<(::std::ostream& os, ErrorStatus errorStatus);
153
154 } // namespace aidl::android::hardware::neuralnetworks
155
156 #endif // ANDROID_HARDWARE_NEURALNETWORKS_AIDL_UTILS_H
157