1 /* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
2
3 Licensed under the Apache License, Version 2.0 (the "License");
4 you may not use this file except in compliance with the License.
5 You may obtain a copy of the License at
6
7 http://www.apache.org/licenses/LICENSE-2.0
8
9 Unless required by applicable law or agreed to in writing, software
10 distributed under the License is distributed on an "AS IS" BASIS,
11 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 See the License for the specific language governing permissions and
13 limitations under the License.
14 ==============================================================================*/
15 #include "tensorflow/lite/nnapi/nnapi_handler.h"
16
17 #include <cstdint>
18 #include <cstdio>
19
20 #include <gmock/gmock.h>
21 #include <gtest/gtest.h>
22 #include "tensorflow/lite/nnapi/nnapi_implementation.h"
23
24 namespace tflite {
25 namespace nnapi {
26
27 using testing::Eq;
28 using testing::Ne;
29 using testing::NotNull;
30
31 void ExpectEquals(const NnApi& left, const NnApi& right);
32
33 class NnApiHandlerTest : public ::testing::Test {
34 protected:
~NnApiHandlerTest()35 ~NnApiHandlerTest() override { NnApiHandler::Instance()->Reset(); }
36 };
37
TEST_F(NnApiHandlerTest,ShouldAlterNnApiInstanceBehaviour)38 TEST_F(NnApiHandlerTest, ShouldAlterNnApiInstanceBehaviour) {
39 const NnApi* nnapi = NnApiImplementation();
40
41 const auto device_count_stub = [](uint32_t* device_count) -> int {
42 *device_count = 999;
43 return ANEURALNETWORKS_NO_ERROR;
44 };
45
46 NnApiHandler::Instance()->StubGetDeviceCountWith(device_count_stub);
47
48 ASSERT_THAT(nnapi->ANeuralNetworks_getDeviceCount, NotNull());
49
50 uint32_t device_count = 0;
51 nnapi->ANeuralNetworks_getDeviceCount(&device_count);
52 EXPECT_THAT(device_count, Eq(999));
53 }
54
TEST_F(NnApiHandlerTest,ShouldRestoreNnApiToItsOriginalValueWithReset)55 TEST_F(NnApiHandlerTest, ShouldRestoreNnApiToItsOriginalValueWithReset) {
56 NnApi nnapi_orig_copy = *NnApiImplementation();
57
58 auto device_count_override = [](uint32_t* device_count) -> int {
59 *device_count = 777;
60 return ANEURALNETWORKS_NO_ERROR;
61 };
62
63 NnApiHandler::Instance()->StubGetDeviceCountWith(device_count_override);
64
65 EXPECT_THAT(nnapi_orig_copy.ANeuralNetworks_getDeviceCount,
66 Ne(NnApiImplementation()->ANeuralNetworks_getDeviceCount));
67
68 NnApiHandler::Instance()->Reset();
69
70 ExpectEquals(nnapi_orig_copy, *NnApiImplementation());
71 }
72
73 int (*device_count_ptr)(uint32_t*);
TEST_F(NnApiHandlerTest,ShouldSupportPassthroughCalls)74 TEST_F(NnApiHandlerTest, ShouldSupportPassthroughCalls) {
75 const NnApi* nnapi = NnApiImplementation();
76 device_count_ptr = nnapi->ANeuralNetworks_getDeviceCount;
77
78 NnApiHandler::Instance()->StubGetDeviceCountWith(
79 [](uint32_t* device_count) -> int {
80 return NnApiPassthroughInstance()->ANeuralNetworks_getDeviceCount ==
81 device_count_ptr;
82 });
83
84 uint32_t device_count = 0;
85 EXPECT_THAT(nnapi->ANeuralNetworks_getDeviceCount(&device_count), Eq(1));
86 }
87
TEST_F(NnApiHandlerTest,ShouldSetNnApiMembersToNullAsPerSdkVersion_NNAPI11)88 TEST_F(NnApiHandlerTest, ShouldSetNnApiMembersToNullAsPerSdkVersion_NNAPI11) {
89 auto* handler = NnApiHandler::Instance();
90
91 // Setting non null values for nnapi functions
92 handler->SetNnapiSupportedDevice("devvice", 1000);
93 handler->GetSupportedOperationsForDevicesReturns<1>();
94 handler->CompilationCreateForDevicesReturns<1>();
95 handler->ExecutionComputeReturns<1>();
96 handler->MemoryCreateFromFdReturns<1>();
97
98 handler->SetAndroidSdkVersion(28, /*set_unsupported_ops_to_null=*/true);
99
100 const NnApi* nnapi = NnApiImplementation();
101
102 using ::testing::IsNull;
103
104 EXPECT_THAT(nnapi->ANeuralNetworks_getDeviceCount, IsNull());
105 EXPECT_THAT(nnapi->ANeuralNetworks_getDevice, IsNull());
106 EXPECT_THAT(nnapi->ANeuralNetworksDevice_getName, IsNull());
107 EXPECT_THAT(nnapi->ANeuralNetworksDevice_getVersion, IsNull());
108 EXPECT_THAT(nnapi->ANeuralNetworksDevice_getFeatureLevel, IsNull());
109 EXPECT_THAT(nnapi->ANeuralNetworksDevice_getType, IsNull());
110 EXPECT_THAT(nnapi->ANeuralNetworksModel_getSupportedOperationsForDevices,
111 IsNull());
112 EXPECT_THAT(nnapi->ANeuralNetworksCompilation_createForDevices, IsNull());
113 EXPECT_THAT(nnapi->ANeuralNetworksCompilation_setCaching, IsNull());
114 EXPECT_THAT(nnapi->ANeuralNetworksExecution_compute, IsNull());
115 EXPECT_THAT(nnapi->ANeuralNetworksExecution_getOutputOperandRank, IsNull());
116 EXPECT_THAT(nnapi->ANeuralNetworksExecution_getOutputOperandDimensions,
117 IsNull());
118 EXPECT_THAT(nnapi->ANeuralNetworksBurst_create, IsNull());
119 EXPECT_THAT(nnapi->ANeuralNetworksBurst_free, IsNull());
120 EXPECT_THAT(nnapi->ANeuralNetworksExecution_burstCompute, IsNull());
121 EXPECT_THAT(nnapi->ANeuralNetworksMemory_createFromAHardwareBuffer, IsNull());
122 EXPECT_THAT(nnapi->ANeuralNetworksExecution_setMeasureTiming, IsNull());
123 EXPECT_THAT(nnapi->ANeuralNetworksExecution_getDuration, IsNull());
124 EXPECT_THAT(nnapi->ANeuralNetworksDevice_getExtensionSupport, IsNull());
125 EXPECT_THAT(nnapi->ANeuralNetworksModel_getExtensionOperandType, IsNull());
126 EXPECT_THAT(nnapi->ANeuralNetworksModel_getExtensionOperationType, IsNull());
127 EXPECT_THAT(nnapi->ANeuralNetworksModel_setOperandExtensionData, IsNull());
128 }
129
TEST_F(NnApiHandlerTest,ShouldSetNnApiMembersToNullAsPerSdkVersion_NNAPI10)130 TEST_F(NnApiHandlerTest, ShouldSetNnApiMembersToNullAsPerSdkVersion_NNAPI10) {
131 auto* handler = NnApiHandler::Instance();
132
133 // Setting non null values for nnapi functions
134 handler->SetNnapiSupportedDevice("devvice", 1000);
135 handler->GetSupportedOperationsForDevicesReturns<1>();
136 handler->CompilationCreateForDevicesReturns<1>();
137 handler->ExecutionComputeReturns<1>();
138 handler->MemoryCreateFromFdReturns<1>();
139
140 handler->SetAndroidSdkVersion(27, /*set_unsupported_ops_to_null=*/true);
141
142 const NnApi* nnapi = NnApiImplementation();
143
144 using ::testing::IsNull;
145
146 EXPECT_THAT(nnapi->ANeuralNetworks_getDeviceCount, IsNull());
147 EXPECT_THAT(nnapi->ANeuralNetworks_getDevice, IsNull());
148 EXPECT_THAT(nnapi->ANeuralNetworksDevice_getName, IsNull());
149 EXPECT_THAT(nnapi->ANeuralNetworksDevice_getVersion, IsNull());
150 EXPECT_THAT(nnapi->ANeuralNetworksDevice_getFeatureLevel, IsNull());
151 EXPECT_THAT(nnapi->ANeuralNetworksDevice_getType, IsNull());
152 EXPECT_THAT(nnapi->ANeuralNetworksModel_getSupportedOperationsForDevices,
153 IsNull());
154 EXPECT_THAT(nnapi->ANeuralNetworksCompilation_createForDevices, IsNull());
155 EXPECT_THAT(nnapi->ANeuralNetworksCompilation_setCaching, IsNull());
156 EXPECT_THAT(nnapi->ANeuralNetworksExecution_compute, IsNull());
157 EXPECT_THAT(nnapi->ANeuralNetworksExecution_getOutputOperandRank, IsNull());
158 EXPECT_THAT(nnapi->ANeuralNetworksExecution_getOutputOperandDimensions,
159 IsNull());
160 EXPECT_THAT(nnapi->ANeuralNetworksBurst_create, IsNull());
161 EXPECT_THAT(nnapi->ANeuralNetworksBurst_free, IsNull());
162 EXPECT_THAT(nnapi->ANeuralNetworksExecution_burstCompute, IsNull());
163 EXPECT_THAT(nnapi->ANeuralNetworksMemory_createFromAHardwareBuffer, IsNull());
164 EXPECT_THAT(nnapi->ANeuralNetworksExecution_setMeasureTiming, IsNull());
165 EXPECT_THAT(nnapi->ANeuralNetworksExecution_getDuration, IsNull());
166 EXPECT_THAT(nnapi->ANeuralNetworksDevice_getExtensionSupport, IsNull());
167 EXPECT_THAT(nnapi->ANeuralNetworksModel_getExtensionOperandType, IsNull());
168 EXPECT_THAT(nnapi->ANeuralNetworksModel_getExtensionOperationType, IsNull());
169 EXPECT_THAT(nnapi->ANeuralNetworksModel_setOperandExtensionData, IsNull());
170
171 EXPECT_THAT(nnapi->ANeuralNetworksModel_relaxComputationFloat32toFloat16,
172 IsNull());
173 }
174
ExpectEquals(const NnApi & left,const NnApi & right)175 void ExpectEquals(const NnApi& left, const NnApi& right) {
176 #define EXPECT_NNAPI_MEMBER_EQ(name) EXPECT_EQ(left.name, right.name)
177
178 EXPECT_NNAPI_MEMBER_EQ(nnapi_exists);
179 EXPECT_NNAPI_MEMBER_EQ(android_sdk_version);
180 EXPECT_NNAPI_MEMBER_EQ(ANeuralNetworksMemory_createFromFd);
181 EXPECT_NNAPI_MEMBER_EQ(ANeuralNetworksMemory_free);
182 EXPECT_NNAPI_MEMBER_EQ(ANeuralNetworksModel_create);
183 EXPECT_NNAPI_MEMBER_EQ(ANeuralNetworksModel_free);
184 EXPECT_NNAPI_MEMBER_EQ(ANeuralNetworksModel_finish);
185 EXPECT_NNAPI_MEMBER_EQ(ANeuralNetworksModel_addOperand);
186 EXPECT_NNAPI_MEMBER_EQ(ANeuralNetworksModel_setOperandValue);
187 EXPECT_NNAPI_MEMBER_EQ(
188 ANeuralNetworksModel_setOperandSymmPerChannelQuantParams);
189 EXPECT_NNAPI_MEMBER_EQ(ANeuralNetworksModel_setOperandValueFromMemory);
190 EXPECT_NNAPI_MEMBER_EQ(ANeuralNetworksModel_addOperation);
191 EXPECT_NNAPI_MEMBER_EQ(ANeuralNetworksModel_identifyInputsAndOutputs);
192 EXPECT_NNAPI_MEMBER_EQ(ANeuralNetworksModel_relaxComputationFloat32toFloat16);
193 EXPECT_NNAPI_MEMBER_EQ(ANeuralNetworksCompilation_create);
194 EXPECT_NNAPI_MEMBER_EQ(ANeuralNetworksCompilation_free);
195 EXPECT_NNAPI_MEMBER_EQ(ANeuralNetworksCompilation_setPreference);
196 EXPECT_NNAPI_MEMBER_EQ(ANeuralNetworksCompilation_finish);
197 EXPECT_NNAPI_MEMBER_EQ(ANeuralNetworksExecution_create);
198 EXPECT_NNAPI_MEMBER_EQ(ANeuralNetworksExecution_free);
199 EXPECT_NNAPI_MEMBER_EQ(ANeuralNetworksExecution_setInput);
200 EXPECT_NNAPI_MEMBER_EQ(ANeuralNetworksExecution_setInputFromMemory);
201 EXPECT_NNAPI_MEMBER_EQ(ANeuralNetworksExecution_setOutput);
202 EXPECT_NNAPI_MEMBER_EQ(ANeuralNetworksExecution_setOutputFromMemory);
203 EXPECT_NNAPI_MEMBER_EQ(ANeuralNetworksExecution_startCompute);
204 EXPECT_NNAPI_MEMBER_EQ(ANeuralNetworksEvent_wait);
205 EXPECT_NNAPI_MEMBER_EQ(ANeuralNetworksEvent_free);
206 EXPECT_NNAPI_MEMBER_EQ(ASharedMemory_create);
207 EXPECT_NNAPI_MEMBER_EQ(ANeuralNetworks_getDeviceCount);
208 EXPECT_NNAPI_MEMBER_EQ(ANeuralNetworks_getDevice);
209 EXPECT_NNAPI_MEMBER_EQ(ANeuralNetworksDevice_getName);
210 EXPECT_NNAPI_MEMBER_EQ(ANeuralNetworksDevice_getVersion);
211 EXPECT_NNAPI_MEMBER_EQ(ANeuralNetworksDevice_getFeatureLevel);
212 EXPECT_NNAPI_MEMBER_EQ(ANeuralNetworksDevice_getType);
213 EXPECT_NNAPI_MEMBER_EQ(ANeuralNetworksModel_getSupportedOperationsForDevices);
214 EXPECT_NNAPI_MEMBER_EQ(ANeuralNetworksCompilation_createForDevices);
215 EXPECT_NNAPI_MEMBER_EQ(ANeuralNetworksCompilation_setCaching);
216 EXPECT_NNAPI_MEMBER_EQ(ANeuralNetworksExecution_compute);
217 EXPECT_NNAPI_MEMBER_EQ(ANeuralNetworksExecution_getOutputOperandRank);
218 EXPECT_NNAPI_MEMBER_EQ(ANeuralNetworksExecution_getOutputOperandDimensions);
219 EXPECT_NNAPI_MEMBER_EQ(ANeuralNetworksBurst_create);
220 EXPECT_NNAPI_MEMBER_EQ(ANeuralNetworksBurst_free);
221 EXPECT_NNAPI_MEMBER_EQ(ANeuralNetworksExecution_burstCompute);
222 EXPECT_NNAPI_MEMBER_EQ(ANeuralNetworksMemory_createFromAHardwareBuffer);
223 EXPECT_NNAPI_MEMBER_EQ(ANeuralNetworksExecution_setMeasureTiming);
224 EXPECT_NNAPI_MEMBER_EQ(ANeuralNetworksExecution_getDuration);
225
226 #undef EXPECT_NNAPI_MEMBER_EQ
227 }
228
229 } // namespace nnapi
230 } // namespace tflite
231