rknn c++ api无法连续进行inference，程序会自动终止

为了进行压力测试，使用c++ api进行连续inference的时候，过一段时间程序会自动停止，目前无法找到原因，随后我换成了官方自带的ssd example code，一样会有同样的问题。这是我的代码(在官方代码的基础上，在第251行增加了while loop)：

1. #include <stdio.h>
   
2. #include <stdint.h>
   
3. #include <stdlib.h>
   
4. #include <fstream>
   
5. #include <iostream>
   
6. #include <sys/time.h>
   
7. #include <chrono>
   
8. 
   
9. #include "rknn_api.h"
   
10. #include "opencv2/core/core.hpp"
    
11. #include "opencv2/imgproc/imgproc.hpp"
    
12. #include "opencv2/highgui/highgui.hpp"
    
13. 
    
14. using namespace std;
    
15. using namespace cv;
    
16. using namespace chrono;
    
17. 
    
18. #define NUM_RESULTS         1917
    
19. #define NUM_CLASSES         91
    
20. 
    
21. #define Y_SCALE  10.0f
    
22. #define X_SCALE  10.0f
    
23. #define H_SCALE  5.0f
    
24. #define W_SCALE  5.0f
    
25. 
    
26. Scalar colorArray[10] = {
    
27.         Scalar(139,   0,   0, 255),
    
28.         Scalar(139,   0, 139, 255),
    
29.         Scalar(  0,   0, 139, 255),
    
30.         Scalar(  0, 100,   0, 255),
    
31.         Scalar(139, 139,   0, 255),
    
32.         Scalar(209, 206,   0, 255),
    
33.         Scalar(  0, 127, 255, 255),
    
34.         Scalar(139,  61,  72, 255),
    
35.         Scalar(  0, 255,   0, 255),
    
36.         Scalar(255,   0,   0, 255),
    
37. };
    
38. 
    
39. float MIN_SCORE = 0.4f;
    
40. 
    
41. float NMS_THRESHOLD = 0.45f;
    
42. 
    
43. 
    
44. int loadLabelName(string locationFilename, string* labels) {
    
45.     ifstream fin(locationFilename);
    
46.     string line;
    
47.     int lineNum = 0;
    
48.     while(getline(fin, line))
    
49.     {
    
50.         labels[lineNum] = line;
    
51.         lineNum++;
    
52.     }
    
53.     return 0;
    
54. }
    
55. 
    
56. int loadCoderOptions(string locationFilename, float (*boxPriors)[NUM_RESULTS])
    
57. {
    
58.     const char *d = ", ";
    
59.     ifstream fin(locationFilename);
    
60.     string line;
    
61.     int lineNum = 0;
    
62.     while(getline(fin, line))
    
63.     {
    
64.         char *line_str = const_cast<char *>(line.c_str());
    
65.         char *p;
    
66.         p = strtok(line_str, d);
    
67.         int priorIndex = 0;
    
68.         while (p) {
    
69.             float number = static_cast<float>(atof(p));
    
70.             boxPriors[lineNum][priorIndex++] = number;
    
71.             p=strtok(nullptr, d);
    
72.         }
    
73.         if (priorIndex != NUM_RESULTS) {
    
74.             return -1;
    
75.         }
    
76.         lineNum++;
    
77.     }
    
78.     return 0;
    
79. 
    
80. }
    
81. 
    
82. float CalculateOverlap(float xmin0, float ymin0, float xmax0, float ymax0, float xmin1, float ymin1, float xmax1, float ymax1) {
    
83.     float w = max(0.f, min(xmax0, xmax1) - max(xmin0, xmin1));
    
84.     float h = max(0.f, min(ymax0, ymax1) - max(ymin0, ymin1));
    
85.     float i = w * h;
    
86.     float u = (xmax0 - xmin0) * (ymax0 - ymin0) + (xmax1 - xmin1) * (ymax1 - ymin1) - i;
    
87.     return u <= 0.f ? 0.f : (i / u);
    
88. }
    
89. 
    
90. float expit(float x) {
    
91.     return (float) (1.0 / (1.0 + exp(-x)));
    
92. }
    
93. 
    
94. void decodeCenterSizeBoxes(float* predictions, float (*boxPriors)[NUM_RESULTS]) {
    
95. 
    
96.     for (int i = 0; i < NUM_RESULTS; ++i) {
    
97.         float ycenter = predictions[i*4+0] / Y_SCALE * boxPriors[2][i] + boxPriors[0][i];
    
98.         float xcenter = predictions[i*4+1] / X_SCALE * boxPriors[3][i] + boxPriors[1][i];
    
99.         float h = (float) exp(predictions[i*4 + 2] / H_SCALE) * boxPriors[2][i];
    
100.         float w = (float) exp(predictions[i*4 + 3] / W_SCALE) * boxPriors[3][i];
     
101. 
     
102.         float ymin = ycenter - h / 2.0f;
     
103.         float xmin = xcenter - w / 2.0f;
     
104.         float ymax = ycenter + h / 2.0f;
     
105.         float xmax = xcenter + w / 2.0f;
     
106. 
     
107.         predictions[i*4 + 0] = ymin;
     
108.         predictions[i*4 + 1] = xmin;
     
109.         predictions[i*4 + 2] = ymax;
     
110.         predictions[i*4 + 3] = xmax;
     
111.     }
     
112. }
     
113. 
     
114. int scaleToInputSize(float * outputClasses, int (*output)[NUM_RESULTS], int numClasses)
     
115. {
     
116.     int validCount = 0;
     
117.     // Scale them back to the input size.
     
118.     for (int i = 0; i < NUM_RESULTS; ++i) {
     
119.         float topClassScore = static_cast<float>(-1000.0);
     
120.         int topClassScoreIndex = -1;
     
121. 
     
122.         // Skip the first catch-all class.
     
123.         for (int j = 1; j < numClasses; ++j) {
     
124.             float score = expit(outputClasses[i*numClasses+j]);
     
125.             if (score > topClassScore) {
     
126.                 topClassScoreIndex = j;
     
127.                 topClassScore = score;
     
128.             }
     
129.         }
     
130. 
     
131.         if (topClassScore >= MIN_SCORE) {
     
132.             output[0][validCount] = i;
     
133.             output[1][validCount] = topClassScoreIndex;
     
134.             ++validCount;
     
135.         }
     
136.     }
     
137. 
     
138.     return validCount;
     
139. }
     
140. 
     
141. int nms(int validCount, float* outputLocations, int (*output)[NUM_RESULTS])
     
142. {
     
143.     for (int i=0; i < validCount; ++i) {
     
144.         if (output[0][i] == -1) {
     
145.             continue;
     
146.         }
     
147.         int n = output[0][i];
     
148.         for (int j=i + 1; j<validCount; ++j) {
     
149.             int m = output[0][j];
     
150.             if (m == -1) {
     
151.                 continue;
     
152.             }
     
153.             float xmin0 = outputLocations[n*4 + 1];
     
154.             float ymin0 = outputLocations[n*4 + 0];
     
155.             float xmax0 = outputLocations[n*4 + 3];
     
156.             float ymax0 = outputLocations[n*4 + 2];
     
157. 
     
158.             float xmin1 = outputLocations[m*4 + 1];
     
159.             float ymin1 = outputLocations[m*4 + 0];
     
160.             float xmax1 = outputLocations[m*4 + 3];
     
161.             float ymax1 = outputLocations[m*4 + 2];
     
162. 
     
163.             float iou = CalculateOverlap(xmin0, ymin0, xmax0, ymax0, xmin1, ymin1, xmax1, ymax1);
     
164. 
     
165.             if (iou >= NMS_THRESHOLD) {
     
166.                 output[0][j] = -1;
     
167.             }
     
168.         }
     
169.     }
     
170. 
     
171.     return 0;
     
172. }
     
173. 
     
174. int main(int argc, char** argv)
     
175. {
     
176.     int counter;
     
177.     auto start = high_resolution_clock::now();
     
178.     auto end = high_resolution_clock::now();
     
179.     auto duration = duration_cast<microseconds>(end - start);
     
180.     const char *img_path = "/tmp/road.bmp";
     
181.     const char *model_path = "/tmp/mobilenet_ssd.rknn";
     
182.     const char *label_path = "/tmp/coco_labels_list.txt";
     
183.     const char *box_priors_path = "/tmp/box_priors.txt";
     
184. 
     
185.     const int img_width = 300;
     
186.     const int img_height = 300;
     
187.     const int img_channels = 3;
     
188.     const int input_index = 0;      // node name "Preprocessor/sub"
     
189. 
     
190.     const int output_elems1 = NUM_RESULTS * 4;
     
191.     const uint32_t output_size1 = output_elems1 * sizeof(float);
     
192.     const int output_index1 = 0;    // node name "concat"
     
193. 
     
194.     const int output_elems2 = NUM_RESULTS * NUM_CLASSES;
     
195.     const uint32_t output_size2 = output_elems2 * sizeof(float);
     
196.     const int output_index2 = 1;    // node name "concat_1"
     
197. 
     
198.     // Load image
     
199.     cv::Mat img = cv::imread(img_path, 1);
     
200.     if(!img.data) {
     
201.         printf("cv::imread %s fail!\n", img_path);
     
202.         return -1;
     
203.     }
     
204.     if(img.cols != img_width || img.rows != img_height)
     
205.         cv::resize(img, img, cv::Size(img_width, img_height), (0, 0), (0, 0), cv::INTER_LINEAR);
     
206. 
     
207.     // Load model
     
208.     FILE *fp = fopen(model_path, "rb");
     
209.     if(fp == NULL) {
     
210.         printf("fopen %s fail!\n", model_path);
     
211.         return -1;
     
212.     }
     
213.     fseek(fp, 0, SEEK_END);
     
214.     int model_len = ftell(fp);
     
215.     void *model = malloc(model_len);
     
216.     fseek(fp, 0, SEEK_SET);
     
217.     if(model_len != fread(model, 1, model_len, fp)) {
     
218.         printf("fread %s fail!\n", model_path);
     
219.         free(model);
     
220.         return -1;
     
221.     }
     
222. 
     
223.     // Start Inference
     
224.     rknn_input inputs[1];
     
225.     rknn_output outputs[2];
     
226.     rknn_tensor_attr outputs_attr[2];
     
227. 
     
228.     int ret = 0;
     
229.     rknn_context ctx = 0;
     
230. 
     
231.     ret = rknn_init(&ctx, model, model_len, RKNN_FLAG_PRIOR_MEDIUM);
     
232.     if(ret < 0) {
     
233.         printf("rknn_init fail! ret=%d\n", ret);
     
234.         goto Error;
     
235.     }
     
236. 
     
237.     outputs_attr[0].index = 0;
     
238.     ret = rknn_query(ctx, RKNN_QUERY_OUTPUT_ATTR, &(outputs_attr[0]), sizeof(outputs_attr[0]));
     
239.     if(ret < 0) {
     
240.         printf("rknn_query fail! ret=%d\n", ret);
     
241.         goto Error;
     
242.     }
     
243. 
     
244.     outputs_attr[1].index = 1;
     
245.     ret = rknn_query(ctx, RKNN_QUERY_OUTPUT_ATTR, &(outputs_attr[1]), sizeof(outputs_attr[1]));
     
246.     if(ret < 0) {
     
247.         printf("rknn_query fail! ret=%d\n", ret);
     
248.         goto Error;
     
249.     }
     
250. 
     
251.     while(1){
     
252.       inputs[0].index = input_index;
     
253.       inputs[0].buf = img.data;
     
254.       inputs[0].size = img_width * img_height * img_channels;
     
255.       inputs[0].pass_through = false;
     
256.       inputs[0].type = RKNN_TENSOR_UINT8;
     
257.       inputs[0].fmt = RKNN_TENSOR_NHWC;
     
258.       start = high_resolution_clock::now();
     
259.       ret = rknn_inputs_set(ctx, 1, inputs);
     
260.       if(ret < 0) {
     
261.         printf("rknn_input_set fail! ret=%d\n", ret);
     
262.         goto Error;
     
263.       }
     
264. 
     
265.       ret = rknn_run(ctx, nullptr);
     
266.       if(ret < 0) {
     
267.         printf("rknn_run fail! ret=%d\n", ret);
     
268.         goto Error;
     
269.       }
     
270. 
     
271.       outputs[0].want_float = true;
     
272.       outputs[0].is_prealloc = false;
     
273.       outputs[1].want_float = true;
     
274.       outputs[1].is_prealloc = false;
     
275.       ret = rknn_outputs_get(ctx, 2, outputs, nullptr);
     
276.       if(ret < 0) {
     
277.         printf("rknn_outputs_get fail! ret=%d\n", ret);
     
278.         goto Error;
     
279.       }
     
280.       end = high_resolution_clock::now();
     
281.       duration = duration_cast<microseconds>(end - start);
     
282.       counter += 1;
     
283.       cout << counter << ": run_time: " << duration.count() << endl;
     
284.     }
     
285. 
     
286.     // Process output
     
287.     if(outputs[0].size == outputs_attr[0].n_elems*sizeof(float) && outputs[1].size == outputs_attr[1].n_elems*sizeof(float))
     
288.     {
     
289.         float boxPriors[4][NUM_RESULTS];
     
290.         string labels[91];
     
291. 
     
292.         /* load label and boxPriors */
     
293.         loadLabelName(label_path, labels);
     
294.         loadCoderOptions(box_priors_path, boxPriors);
     
295. 
     
296.         float* predictions = (float*)outputs[0].buf;
     
297.         float* outputClasses = (float*)outputs[1].buf;
     
298. 
     
299.         int output[2][NUM_RESULTS];
     
300. 
     
301.         /* transform */
     
302.         decodeCenterSizeBoxes(predictions, boxPriors);
     
303. 
     
304.         int validCount = scaleToInputSize(outputClasses, output, NUM_CLASSES);
     
305.         printf("validCount: %d\n", validCount);
     
306. 
     
307.         if (validCount < 100) {
     
308.             /* detect nest box */
     
309.             nms(validCount, predictions, output);
     
310. 
     
311.             Mat rgba = imread(img_path, CV_LOAD_IMAGE_UNCHANGED);
     
312.             cv::resize(rgba, rgba, cv::Size(1200, 1200), (0, 0), (0, 0), cv::INTER_LINEAR);
     
313. 
     
314.             /* box valid detect target */
     
315.             for (int i = 0; i < validCount; ++i) {
     
316.                 if (output[0][i] == -1) {
     
317.                     continue;
     
318.                 }
     
319.                 int n = output[0][i];
     
320.                 int topClassScoreIndex = output[1][i];
     
321. 
     
322.                 int x1 = static_cast<int>(predictions[n * 4 + 1] * rgba.cols);
     
323.                 int y1 = static_cast<int>(predictions[n * 4 + 0] * rgba.rows);
     
324.                 int x2 = static_cast<int>(predictions[n * 4 + 3] * rgba.cols);
     
325.                 int y2 = static_cast<int>(predictions[n * 4 + 2] * rgba.rows);
     
326. 
     
327.                 string label = labels[topClassScoreIndex];
     
328. 
     
329.                 std::cout << label << "\t@ (" << x1 << ", " << y1 << ") (" << x2 << ", " << y2 << ")" << "\n";
     
330. 
     
331.                 rectangle(rgba, Point(x1, y1), Point(x2, y2), colorArray[topClassScoreIndex%10], 3);
     
332.                 putText(rgba, label, Point(x1, y1 - 12), 1, 2, Scalar(0, 255, 0, 255));
     
333.             }
     
334.             imwrite("out.jpg", rgba);
     
335.             printf("write out.jpg succ!\n");
     
336.         } else {
     
337.             printf("validCount too much!\n");
     
338.         }
     
339.     }
     
340.     else
     
341.     {
     
342.         printf("rknn_outputs_get fail! get outputs_size = [%d, %d], but expect [%lu, %lu]!\n",
     
343.             outputs[0].size, outputs[1].size, outputs_attr[0].n_elems*sizeof(float), outputs_attr[1].n_elems*sizeof(float));
     
344.     }
     
345. 
     
346.     rknn_outputs_release(ctx, 2, outputs);
     
347. 
     
348.     rknn_perf_run perf_run;
     
349.     ret = rknn_query(ctx, RKNN_QUERY_PERF_RUN, &perf_run, sizeof(perf_run));
     
350.     if(ret < 0) {
     
351.       printf("rknn_query fail! ret=%d\n", ret);
     
352.       goto Error;
     
353.     }
     
354.     printf("perf_run.run_duration = %ld us\n", perf_run.run_duration);
     
355. Error:
     
356.     if(ctx)             rknn_destroy(ctx);
     
357.     if(model)           free(model);
     
358.     if(fp)              fclose(fp);
     
359.     return 0;
     
360. }
     

复制代码

我会每次打印inference消耗的时间，最后三次时间会明显增加，随后提示“Killed”
这是我的部分输出：

1. 4523: run_time: 25540
   
2. 4524: run_time: 25014
   
3. 4525: run_time: 25170
   
4. 4526: run_time: 25620
   
5. 4527: run_time: 25013
   
6. 4528: run_time: 25402
   
7. 4529: run_time: 25137
   
8. 4530: run_time: 25600
   
9. 4531: run_time: 25446
   
10. 4532: run_time: 25686
    
11. 4533: run_time: 39072
    
12. 4534: run_time: 931086
    
13. 4535: run_time: 3565199
    
14. Killed

复制代码

等着更新固件吧

看看系统日志，是不是OOM了？

pecado 发表于 2019-3-9 13:45
看看系统日志，是不是OOM了？

可以的，我看看