1 // Copyright (c) 2022 by Rockchip Electronics Co., Ltd. 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 /*-------------------------------------------
16 Includes
17 -------------------------------------------*/
18 #include "rknn_api.h"
19
20 #include <float.h>
21 #include <stdio.h>
22 #include <stdlib.h>
23 #include <string.h>
24 #include <sys/time.h>
25
26 #define STB_IMAGE_IMPLEMENTATION
27 #include "stb/stb_image.h"
28 #define STB_IMAGE_RESIZE_IMPLEMENTATION
29 #include <stb/stb_image_resize.h>
30
31 #include "cnpy/cnpy.h"
32 using namespace cnpy;
33
34
35 /*-------------------------------------------
36 Functions
37 -------------------------------------------*/
getCurrentTimeUs()38 static inline int64_t getCurrentTimeUs()
39 {
40 struct timeval tv;
41 gettimeofday(&tv, NULL);
42 return tv.tv_sec * 1000000 + tv.tv_usec;
43 }
44
rknn_GetTopN(float * pfProb,float * pfMaxProb,uint32_t * pMaxClass,uint32_t outputCount,uint32_t topNum)45 static int rknn_GetTopN(float* pfProb, float* pfMaxProb, uint32_t* pMaxClass, uint32_t outputCount, uint32_t topNum)
46 {
47 uint32_t i, j;
48 uint32_t top_count = outputCount > topNum ? topNum : outputCount;
49
50 for (i = 0; i < topNum; ++i) {
51 pfMaxProb[i] = -FLT_MAX;
52 pMaxClass[i] = -1;
53 }
54
55 for (j = 0; j < top_count; j++) {
56 for (i = 0; i < outputCount; i++) {
57 if ((i == *(pMaxClass + 0)) || (i == *(pMaxClass + 1)) || (i == *(pMaxClass + 2)) || (i == *(pMaxClass + 3)) ||
58 (i == *(pMaxClass + 4))) {
59 continue;
60 }
61
62 if (pfProb[i] > *(pfMaxProb + j)) {
63 *(pfMaxProb + j) = pfProb[i];
64 *(pMaxClass + j) = i;
65 }
66 }
67 }
68
69 return 1;
70 }
71
dump_tensor_attr(rknn_tensor_attr * attr)72 static void dump_tensor_attr(rknn_tensor_attr* attr)
73 {
74 std::string shape_str = attr->n_dims < 1 ? "" : std::to_string(attr->dims[0]);
75 for (int i = 1; i < attr->n_dims; ++i) {
76 shape_str += ", " + std::to_string(attr->dims[i]);
77 }
78
79 printf(" index=%d, name=%s, n_dims=%d, dims=[%s], n_elems=%d, size=%d, w_stride = %d, size_with_stride=%d, fmt=%s, "
80 "type=%s, qnt_type=%s, "
81 "zp=%d, scale=%f\n",
82 attr->index, attr->name, attr->n_dims, shape_str.c_str(), attr->n_elems, attr->size, attr->w_stride,
83 attr->size_with_stride, get_format_string(attr->fmt), get_type_string(attr->type),
84 get_qnt_type_string(attr->qnt_type), attr->zp, attr->scale);
85 }
86
load_npy(const char * input_path,rknn_tensor_attr * input_attr,int * input_type,int * input_size)87 static unsigned char* load_npy(const char* input_path, rknn_tensor_attr* input_attr, int* input_type, int* input_size)
88 {
89 int req_height = 0;
90 int req_width = 0;
91 int req_channel = 0;
92
93 printf("Loading %s\n", input_path);
94
95 switch (input_attr->fmt) {
96 case RKNN_TENSOR_NHWC:
97 req_height = input_attr->dims[1];
98 req_width = input_attr->dims[2];
99 req_channel = input_attr->dims[3];
100 break;
101 case RKNN_TENSOR_NCHW:
102 req_height = input_attr->dims[2];
103 req_width = input_attr->dims[3];
104 req_channel = input_attr->dims[1];
105 break;
106 case RKNN_TENSOR_UNDEFINED:
107 break;
108 default:
109 printf("meet unsupported layout\n");
110 return NULL;
111 }
112
113 NpyArray npy_data = npy_load(input_path);
114
115 int type_bytes = npy_data.word_size;
116 std::string typeName = npy_data.typeName;
117
118 printf("npy data type:%s\n", typeName.c_str());
119
120 if (typeName == "int8") {
121 *input_type = RKNN_TENSOR_INT8;
122 } else if (typeName == "uint8") {
123 *input_type = RKNN_TENSOR_UINT8;
124 } else if (typeName == "float16") {
125 *input_type = RKNN_TENSOR_FLOAT16;
126 } else if (typeName == "float32") {
127 *input_type = RKNN_TENSOR_FLOAT32;
128 } else if (typeName == "8") {
129 *input_type = RKNN_TENSOR_BOOL;
130 } else if (typeName == "int64") {
131 *input_type = RKNN_TENSOR_INT64;
132 }
133
134 // npy shape = NHWC
135 int npy_shape[4] = {1, 1, 1, 1};
136
137 int start = npy_data.shape.size() == 4 ? 0 : 1;
138 for (size_t i = 0; i < npy_data.shape.size() && i < 4; ++i) {
139 npy_shape[start + i] = npy_data.shape[i];
140 }
141
142 int height = npy_shape[1];
143 int width = npy_shape[2];
144 int channel = npy_shape[3];
145
146 if ((input_attr->fmt != RKNN_TENSOR_UNDEFINED) &&
147 (width != req_width || height != req_height || channel != req_channel)) {
148 printf("npy shape match failed!, (%d, %d, %d) != (%d, %d, %d)\n", height, width, channel, req_height, req_width,
149 req_channel);
150 return NULL;
151 }
152
153 unsigned char* data = (unsigned char*)malloc(npy_data.num_bytes());
154 if (!data) {
155 return NULL;
156 }
157
158 // TODO: copy
159 memcpy(data, npy_data.data<unsigned char>(), npy_data.num_bytes());
160
161 *input_size = npy_data.num_bytes();
162
163 return data;
164 }
165
save_npy(const char * output_path,float * output_data,rknn_tensor_attr * output_attr)166 static void save_npy(const char* output_path, float* output_data, rknn_tensor_attr* output_attr)
167 {
168 std::vector<size_t> output_shape;
169
170 for (uint32_t i = 0; i < output_attr->n_dims; ++i) {
171 output_shape.push_back(output_attr->dims[i]);
172 }
173
174 npy_save<float>(output_path, output_data, output_shape);
175 }
176
177
load_image(const char * image_path,rknn_tensor_attr * input_attr)178 static unsigned char* load_image(const char* image_path, rknn_tensor_attr* input_attr)
179 {
180 int req_height = 0;
181 int req_width = 0;
182 int req_channel = 0;
183
184 switch (input_attr->fmt) {
185 case RKNN_TENSOR_NHWC:
186 req_height = input_attr->dims[1];
187 req_width = input_attr->dims[2];
188 req_channel = input_attr->dims[3];
189 break;
190 case RKNN_TENSOR_NCHW:
191 req_height = input_attr->dims[2];
192 req_width = input_attr->dims[3];
193 req_channel = input_attr->dims[1];
194 break;
195 default:
196 printf("meet unsupported layout\n");
197 return NULL;
198 }
199
200 int height = 0;
201 int width = 0;
202 int channel = 0;
203
204 unsigned char* image_data = stbi_load(image_path, &width, &height, &channel, req_channel);
205 if (image_data == NULL) {
206 printf("load image failed!\n");
207 return NULL;
208 }
209
210 if (width != req_width || height != req_height) {
211 unsigned char* image_resized = (unsigned char*)STBI_MALLOC(req_width * req_height * req_channel);
212 if (!image_resized) {
213 printf("malloc image failed!\n");
214 STBI_FREE(image_data);
215 return NULL;
216 }
217 if (stbir_resize_uint8(image_data, width, height, 0, image_resized, req_width, req_height, 0, channel) != 1) {
218 printf("resize image failed!\n");
219 STBI_FREE(image_data);
220 return NULL;
221 }
222 STBI_FREE(image_data);
223 image_data = image_resized;
224 }
225
226 return image_data;
227 }
228
split(const std::string & str,const std::string & pattern)229 static std::vector<std::string> split(const std::string& str, const std::string& pattern)
230 {
231 std::vector<std::string> res;
232 if (str == "")
233 return res;
234 std::string strs = str + pattern;
235 size_t pos = strs.find(pattern);
236 while (pos != strs.npos) {
237 std::string temp = strs.substr(0, pos);
238 res.push_back(temp);
239 strs = strs.substr(pos + 1, strs.size());
240 pos = strs.find(pattern);
241 }
242 return res;
243 }
244
245 /*-------------------------------------------
246 Main Functions
247 -------------------------------------------*/
main(int argc,char * argv[])248 int main(int argc, char* argv[])
249 {
250 if (argc < 2) {
251 printf("Usage:%s model_path [input_path] [loop_count] [core_mask]\n", argv[0]);
252 return -1;
253 }
254
255 char* model_path = argv[1];
256 std::vector<std::string> input_paths_split;
257 int loop_count = 10;
258 uint32_t core_mask = 1;
259 rknn_context ctx = 0;
260 uint32_t topNum = 5;
261 double total_time = 0;
262
263 if (argc > 2) {
264 char* input_paths = argv[2];
265 input_paths_split = split(input_paths, "#");
266 }
267
268 if (argc > 3) {
269 loop_count = atoi(argv[3]);
270 }
271
272 if (argc > 4) {
273 core_mask = strtoul(argv[4], NULL, 10);
274 }
275
276
277 // Init rknn from model path
278 int ret = rknn_init(&ctx, model_path, 0, 0, NULL);
279
280 if (ret < 0) {
281 printf("rknn_init fail! ret=%d\n", ret);
282 return -1;
283 }
284
285 // Get sdk and driver version
286 rknn_sdk_version sdk_ver;
287 ret = rknn_query(ctx, RKNN_QUERY_SDK_VERSION, &sdk_ver, sizeof(sdk_ver));
288 if (ret != RKNN_SUCC) {
289 printf("rknn_query fail! ret=%d\n", ret);
290 rknn_destroy(ctx);
291 return -1;
292 }
293 printf("rknn_api/rknnrt version: %s, driver version: %s\n", sdk_ver.api_version, sdk_ver.drv_version);
294
295 // Get weight and internal mem size, dma used size
296 rknn_mem_size mem_size;
297 ret = rknn_query(ctx, RKNN_QUERY_MEM_SIZE, &mem_size, sizeof(mem_size));
298 if (ret != RKNN_SUCC) {
299 printf("rknn_query fail! ret=%d\n", ret);
300 rknn_destroy(ctx);
301 return -1;
302 }
303 printf("total weight size: %d, total internal size: %d\n", mem_size.total_weight_size, mem_size.total_internal_size);
304 printf("total dma used size: %zu\n", (size_t)mem_size.total_dma_allocated_size);
305
306 // Get Model Input Output Info
307 rknn_input_output_num io_num;
308 ret = rknn_query(ctx, RKNN_QUERY_IN_OUT_NUM, &io_num, sizeof(io_num));
309 if (ret != RKNN_SUCC) {
310 printf("rknn_query fail! ret=%d\n", ret);
311 rknn_destroy(ctx);
312 return -1;
313 }
314 printf("model input num: %d, output num: %d\n", io_num.n_input, io_num.n_output);
315
316 printf("input tensors:\n");
317 rknn_tensor_attr input_attrs[io_num.n_input];
318 memset(input_attrs, 0, io_num.n_input * sizeof(rknn_tensor_attr));
319 for (uint32_t i = 0; i < io_num.n_input; i++) {
320 input_attrs[i].index = i;
321 // query info
322 ret = rknn_query(ctx, RKNN_QUERY_INPUT_ATTR, &(input_attrs[i]), sizeof(rknn_tensor_attr));
323 if (ret < 0) {
324 printf("rknn_init error! ret=%d\n", ret);
325 rknn_destroy(ctx);
326 return -1;
327 }
328 dump_tensor_attr(&input_attrs[i]);
329 }
330
331 printf("output tensors:\n");
332 rknn_tensor_attr output_attrs[io_num.n_output];
333 memset(output_attrs, 0, io_num.n_output * sizeof(rknn_tensor_attr));
334 for (uint32_t i = 0; i < io_num.n_output; i++) {
335 output_attrs[i].index = i;
336 // query info
337 ret = rknn_query(ctx, RKNN_QUERY_OUTPUT_ATTR, &(output_attrs[i]), sizeof(rknn_tensor_attr));
338 if (ret != RKNN_SUCC) {
339 printf("rknn_query fail! ret=%d\n", ret);
340 rknn_destroy(ctx);
341 return -1;
342 }
343 dump_tensor_attr(&output_attrs[i]);
344 }
345
346 // Get custom string
347 rknn_custom_string custom_string;
348 ret = rknn_query(ctx, RKNN_QUERY_CUSTOM_STRING, &custom_string, sizeof(custom_string));
349 if (ret != RKNN_SUCC) {
350 printf("rknn_query fail! ret=%d\n", ret);
351 rknn_destroy(ctx);
352 return -1;
353 }
354 printf("custom string: %s\n", custom_string.string);
355
356 unsigned char* input_data[io_num.n_input];
357 int input_type[io_num.n_input];
358 int input_layout[io_num.n_input];
359 int input_size[io_num.n_input];
360 rknn_input inputs[io_num.n_input];
361 rknn_output outputs[io_num.n_output];
362
363 for (int i = 0; i < io_num.n_input; i++) {
364 input_data[i] = NULL;
365 input_type[i] = RKNN_TENSOR_UINT8;
366 input_layout[i] = RKNN_TENSOR_NHWC;
367 input_size[i] = input_attrs[i].n_elems * sizeof(uint8_t);
368 }
369
370 if (input_paths_split.size() > 0) {
371 // Load input
372 if (io_num.n_input != input_paths_split.size()) {
373 printf("input missing!, need input number: %d, only get %d inputs\n", io_num.n_input, input_paths_split.size());
374 goto out;
375 }
376 for (int i = 0; i < io_num.n_input; i++) {
377 if (strstr(input_paths_split[i].c_str(), ".npy")) {
378 input_data[i] = load_npy(input_paths_split[i].c_str(), &input_attrs[i], &input_type[i], &input_size[i]);
379 } else {
380 // Load image
381 input_data[i] = load_image(input_paths_split[i].c_str(), &input_attrs[i]);
382 }
383
384 if (!input_data[i]) {
385 goto out;
386 }
387 }
388 } else {
389 for (int i = 0; i < io_num.n_input; i++) {
390 input_data[i] = (unsigned char*)malloc(input_size[i]);
391 memset(input_data[i], 0x00, input_size[i]);
392 }
393 }
394
395
396 memset(inputs, 0, io_num.n_input * sizeof(rknn_input));
397 for (int i = 0; i < io_num.n_input; i++) {
398 inputs[i].index = i;
399 inputs[i].pass_through = 0;
400 inputs[i].type = (rknn_tensor_type)input_type[i];
401 inputs[i].fmt = (rknn_tensor_format)input_layout[i];
402 inputs[i].buf = input_data[i];
403 inputs[i].size = input_size[i];
404 }
405
406 // Set input
407 ret = rknn_inputs_set(ctx, io_num.n_input, inputs);
408 if (ret < 0) {
409 printf("rknn_input_set fail! ret=%d\n", ret);
410 goto out;
411 }
412
413 rknn_set_core_mask(ctx, (rknn_core_mask)core_mask);
414
415 // Warmup
416 printf("Warmup ...\n");
417 for (int i = 0; i < 5; ++i) {
418 int64_t start_us = getCurrentTimeUs();
419 ret = rknn_run(ctx, NULL);
420 int64_t elapse_us = getCurrentTimeUs() - start_us;
421 if (ret < 0) {
422 printf("rknn run error %d\n", ret);
423 goto out;
424 }
425 printf("%4d: Elapse Time = %.2fms, FPS = %.2f\n", i, elapse_us / 1000.f, 1000.f * 1000.f / elapse_us);
426 }
427
428
429 // Run
430 printf("Begin perf ...\n");
431 for (int i = 0; i < loop_count; ++i) {
432 int64_t start_us = getCurrentTimeUs();
433 ret = rknn_run(ctx, NULL);
434 int64_t elapse_us = getCurrentTimeUs() - start_us;
435 if (ret < 0) {
436 printf("rknn run error %d\n", ret);
437 return -1;
438 }
439 total_time += elapse_us / 1000.f;
440 printf("%4d: Elapse Time = %.2fms, FPS = %.2f\n", i, elapse_us / 1000.f, 1000.f * 1000.f / elapse_us);
441 }
442 printf("\nAvg Time %.2fms, Avg FPS = %.3f\n\n", total_time/loop_count, loop_count * 1000.f / total_time);
443
444 // Get output
445 memset(outputs, 0, io_num.n_output * sizeof(rknn_output));
446 for (uint32_t i = 0; i < io_num.n_output; ++i) {
447 outputs[i].want_float = 1;
448 outputs[i].index = i;
449 outputs[i].is_prealloc = 0;
450 }
451
452 ret = rknn_outputs_get(ctx, io_num.n_output, outputs, NULL);
453 if (ret < 0) {
454 printf("rknn_outputs_get fail! ret=%d\n", ret);
455 goto out;
456 }
457
458 // save output
459 for (uint32_t i = 0; i < io_num.n_output; i++) {
460 char output_path[PATH_MAX];
461 memset(output_path, 0x00, sizeof(output_path));
462 sprintf(output_path, "rt_output%d.npy", i);
463 printf("Save output to %s\n", output_path);
464 save_npy(output_path, (float*)outputs[i].buf, &output_attrs[i]);
465 }
466
467 // Get top 5
468 for (uint32_t i = 0; i < io_num.n_output; i++) {
469 uint32_t MaxClass[topNum];
470 float fMaxProb[topNum];
471 float* buffer = (float*)outputs[i].buf;
472 uint32_t sz = outputs[i].size / sizeof(float);
473 int top_count = sz > topNum ? topNum : sz;
474
475 rknn_GetTopN(buffer, fMaxProb, MaxClass, sz, topNum);
476
477 printf("---- Top%d ----\n", top_count);
478 for (int j = 0; j < top_count; j++) {
479 printf("%8.6f - %d\n", fMaxProb[j], MaxClass[j]);
480 }
481 }
482
483 // release outputs
484 ret = rknn_outputs_release(ctx, io_num.n_output, outputs);
485
486 out:
487 // destroy
488 rknn_destroy(ctx);
489
490 for (int i = 0; i < io_num.n_input; i++) {
491 if (input_data[i] != NULL) {
492 free(input_data[i]);
493 }
494 }
495
496 return 0;
497 }
498