1 #define ALOG_TAG "rk_list"
2
3 #include <errno.h>
4 #include <string.h>
5 #include <stdlib.h>
6
7 #include "rk_list.h"
8 #include "mpp_log.h"
9
10 //#define _RK_LIST_DEUBG
11 #define _RK_LIST_ERROR
12
13 #ifdef _RK_LIST_DEUBG
14 #define LIST_DEBUG(fmt, ...) mpp_log(fmt, ## __VA_ARGS__)
15 #else
16 #define LIST_DEBUG(fmt, ...) /* not debugging: nothing */
17 #endif
18
19 #ifdef _RK_LIST_ERROR
20 #define LIST_ERROR(fmt, ...) mpp_err(fmt, ## __VA_ARGS__)
21 #else
22 #define LIST_ERROR(fmt, ...)
23 #endif
24
25 typedef struct rk_list_node {
26 rk_list_node* prev;
27 rk_list_node* next;
28 RK_U32 key;
29 RK_S32 size;
30 } rk_list_node;
31
list_node_init(rk_list_node * node)32 static inline void list_node_init(rk_list_node *node)
33 {
34 node->prev = node->next = node;
35 }
36
list_node_init_with_key_and_size(rk_list_node * node,RK_U32 key,RK_S32 size)37 static inline void list_node_init_with_key_and_size(rk_list_node *node, RK_U32 key, RK_S32 size)
38 {
39 list_node_init(node);
40 node->key = key;
41 node->size = size;
42 }
43
create_list(void * data,RK_S32 size,RK_U32 key)44 static rk_list_node* create_list(void *data, RK_S32 size, RK_U32 key)
45 {
46 rk_list_node *node = (rk_list_node*)malloc(sizeof(rk_list_node) + size);
47 if (node) {
48 void *dst = (void*)(node + 1);
49 list_node_init_with_key_and_size(node, key, size);
50 memcpy(dst, data, size);
51 } else {
52 LIST_ERROR("failed to allocate list node");
53 }
54 return node;
55 }
56
_rk_list_add(rk_list_node * _new,rk_list_node * prev,rk_list_node * next)57 static inline void _rk_list_add(rk_list_node * _new, rk_list_node * prev, rk_list_node * next)
58 {
59 next->prev = _new;
60 _new->next = next;
61 _new->prev = prev;
62 prev->next = _new;
63 }
64
rk_list_add(rk_list_node * _new,rk_list_node * head)65 static inline void rk_list_add(rk_list_node *_new, rk_list_node *head)
66 {
67 _rk_list_add(_new, head, head->next);
68 }
69
rk_list_add_tail(rk_list_node * _new,rk_list_node * head)70 static inline void rk_list_add_tail(rk_list_node *_new, rk_list_node *head)
71 {
72 _rk_list_add(_new, head->prev, head);
73 }
74
add_at_head(void * data,RK_S32 size)75 RK_S32 rk_list::add_at_head(void *data, RK_S32 size)
76 {
77 RK_S32 ret = -EINVAL;
78 pthread_mutex_lock(&mutex);
79 if (head) {
80 rk_list_node *node = create_list(data, size, 0);
81 if (node) {
82 rk_list_add(node, head);
83 count++;
84 ret = 0;
85 } else {
86 ret = -ENOMEM;
87 }
88 }
89 pthread_mutex_unlock(&mutex);
90 return ret;
91 }
92
add_at_tail(void * data,RK_S32 size)93 RK_S32 rk_list::add_at_tail(void *data, RK_S32 size)
94 {
95 RK_S32 ret = -EINVAL;
96 pthread_mutex_lock(&mutex);
97 if (head) {
98 rk_list_node *node = create_list(data, size, 0);
99 if (node) {
100 rk_list_add_tail(node, head);
101 count++;
102 ret = 0;
103 } else {
104 ret = -ENOMEM;
105 }
106 }
107 pthread_mutex_unlock(&mutex);
108 return ret;
109 }
110
release_list(rk_list_node * node,void * data,RK_S32 size)111 static void release_list(rk_list_node*node, void *data, RK_S32 size)
112 {
113 void *src = (void*)(node + 1);
114 if (node->size == size) {
115 memcpy(data, src, size);
116 } else {
117 LIST_ERROR("node size check failed when release_list");
118 size = (size < node->size) ? (size) : (node->size);
119 memcpy(data, src, size);
120 }
121 free(node);
122 }
123
_rk_list_del(rk_list_node * prev,rk_list_node * next)124 static inline void _rk_list_del(rk_list_node *prev, rk_list_node *next)
125 {
126 next->prev = prev;
127 prev->next = next;
128 }
129
rk_list_del_init(rk_list_node * node)130 static inline void rk_list_del_init(rk_list_node *node)
131 {
132 _rk_list_del(node->prev, node->next);
133 list_node_init(node);
134 }
135
_list_del_node_no_lock(rk_list_node * node,void * data,RK_S32 size)136 static inline void _list_del_node_no_lock(rk_list_node *node, void *data, RK_S32 size)
137 {
138 rk_list_del_init(node);
139 release_list(node, data, size);
140 }
141
del_at_head(void * data,RK_S32 size)142 RK_S32 rk_list::del_at_head(void *data, RK_S32 size)
143 {
144 RK_S32 ret = -EINVAL;
145 pthread_mutex_lock(&mutex);
146 if (head && count) {
147 _list_del_node_no_lock(head->next, data, size);
148 count--;
149 ret = 0;
150 }
151 pthread_mutex_unlock(&mutex);
152 return ret;
153 }
154
del_at_tail(void * data,RK_S32 size)155 RK_S32 rk_list::del_at_tail(void *data, RK_S32 size)
156 {
157 RK_S32 ret = -EINVAL;
158 pthread_mutex_lock(&mutex);
159 if (head && count) {
160 _list_del_node_no_lock(head->prev, data, size);
161 count--;
162 ret = 0;
163 }
164 pthread_mutex_unlock(&mutex);
165 return ret;
166 }
167
list_is_empty()168 RK_S32 rk_list::list_is_empty()
169 {
170 pthread_mutex_lock(&mutex);
171 RK_S32 ret = (count == 0);
172 pthread_mutex_unlock(&mutex);
173 return ret;
174 }
175
list_size()176 RK_S32 rk_list::list_size()
177 {
178 pthread_mutex_lock(&mutex);
179 RK_S32 ret = count;
180 pthread_mutex_unlock(&mutex);
181 return ret;
182 }
183
add_by_key(void * data,RK_S32 size,RK_U32 * key)184 RK_S32 rk_list::add_by_key(void *data, RK_S32 size, RK_U32 *key)
185 {
186 RK_S32 ret = 0;
187 (void)data;
188 (void)size;
189 (void)key;
190 return ret;
191 }
192
del_by_key(void * data,RK_S32 size,RK_U32 key)193 RK_S32 rk_list::del_by_key(void *data, RK_S32 size, RK_U32 key)
194 {
195 RK_S32 ret = 0;
196 (void)data;
197 (void)size;
198 (void)key;
199 return ret;
200 }
201
202
show_by_key(void * data,RK_U32 key)203 RK_S32 rk_list::show_by_key(void *data, RK_U32 key)
204 {
205 RK_S32 ret = 0;
206 (void)data;
207 (void)key;
208 return ret;
209 }
210
flush()211 RK_S32 rk_list::flush()
212 {
213 pthread_mutex_lock(&mutex);
214 if (head) {
215 while (count) {
216 rk_list_node* node = head->next;
217 rk_list_del_init(node);
218 if (destroy) {
219 destroy((void*)(node + 1));
220 }
221 free(node);
222 count--;
223 }
224 }
225 pthread_mutex_unlock(&mutex);
226 return 0;
227 }
228
rk_list(node_destructor func)229 rk_list::rk_list(node_destructor func)
230 : destroy(NULL),
231 head(NULL),
232 count(0)
233 {
234 pthread_mutexattr_t attr;
235 pthread_mutexattr_init(&attr);
236 pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
237 pthread_mutex_init(&mutex, &attr);
238 pthread_mutexattr_destroy(&attr);
239 destroy = func;
240 head = (rk_list_node*)malloc(sizeof(rk_list_node));
241 if (NULL == head) {
242 LIST_ERROR("failed to allocate list header");
243 } else {
244 list_node_init_with_key_and_size(head, 0, 0);
245 }
246 }
247
~rk_list()248 rk_list::~rk_list()
249 {
250 flush();
251 if (head) free(head);
252 head = NULL;
253 destroy = NULL;
254 pthread_mutex_destroy(&mutex);
255 }
256
257 #if BUILD_RK_LIST_TEST
258 #include "vpu_mem.h"
259 #include <stdio.h>
260 #include <stdlib.h>
261 #include <string.h>
262
263 #define LOOP_RK_LIST 600
264
265 #define COUNT_ADD 100
266 #define COUNT_DEL 99
267
268 static volatile int err = 0;
269
rk_list_fifo_test(rk_list * list_0)270 static int rk_list_fifo_test(rk_list *list_0)
271 {
272 int count;
273 VPUMemLinear_t m;
274 for (count = 0; count < COUNT_ADD; count++) {
275 err |= VPUMallocLinear(&m, 100);
276 if (err) {
277 printf("VPUMallocLinear in rk_list_fifo_test\n");
278 break;
279 }
280 err |= list_0->add_at_head(&m, sizeof(m));
281 if (err) {
282 printf("add_at_head in rk_list_fifo_test\n");
283 break;
284 }
285 }
286
287 if (!err) {
288 for (count = 0; count < COUNT_DEL; count++) {
289 err |= list_0->del_at_tail(&m, sizeof(m));
290 if (err) {
291 printf("del_at_tail in rk_list_fifo_test\n");
292 break;
293 }
294 err |= VPUFreeLinear(&m);
295 if (err) {
296 printf("VPUFreeLinear in rk_list_fifo_test\n");
297 break;
298 }
299 }
300 }
301 return err;
302 }
303
rk_list_filo_test(rk_list * list_0)304 static int rk_list_filo_test(rk_list *list_0)
305 {
306 int count;
307 VPUMemLinear_t m;
308 for (count = 0; count < COUNT_ADD + COUNT_DEL; count++) {
309 if (count & 1) {
310 err |= list_0->del_at_head(&m, sizeof(m));
311 if (err) {
312 printf("del_at_head in rk_list_filo_test\n");
313 break;
314 }
315 err |= VPUFreeLinear(&m);
316 if (err) {
317 printf("VPUFreeLinear in rk_list_fifo_test\n");
318 break;
319 }
320 } else {
321 err |= VPUMallocLinear(&m, 100);
322 if (err) {
323 printf("VPUMallocLinear in rk_list_filo_test\n");
324 break;
325 }
326 err |= list_0->add_at_head(&m, sizeof(m));
327 if (err) {
328 printf("add_at_head in rk_list_fifo_test\n");
329 break;
330 }
331 }
332 }
333
334 return err;
335 }
336
337
rk_list_test_loop_0(void * pdata)338 void *rk_list_test_loop_0(void *pdata)
339 {
340 int i;
341 rk_list *list_0 = (rk_list *)pdata;
342
343 printf("rk_list test 0 loop start\n");
344 for (i = 0; i < LOOP_RK_LIST; i++) {
345 err |= rk_list_filo_test(list_0);
346 if (err) break;
347 }
348
349 if (err) {
350 printf("thread: found vpu mem operation err %d\n", err);
351 } else {
352 printf("thread: test done and found no err\n");
353 }
354 return NULL;
355 }
356
rk_list_test_0()357 int rk_list_test_0()
358 {
359 int i, err = 0;
360 printf("rk_list test 0 FIFO start\n");
361
362 rk_list *list_0 = new rk_list((node_destructor)VPUFreeLinear);
363
364 pthread_t mThread;
365 pthread_attr_t attr;
366 pthread_attr_init(&attr);
367 pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
368
369 pthread_create(&mThread, &attr, rk_list_test_loop_0, (void*)list_0);
370 pthread_attr_destroy(&attr);
371
372 for (i = 0; i < LOOP_RK_LIST; i++) {
373 err |= rk_list_fifo_test(list_0);
374 if (err) break;
375 }
376 if (err) {
377 printf("main : found rk_list operation err %d\n", err);
378 } else {
379 printf("main : test done and found no err\n");
380 }
381
382 void *dummy;
383 pthread_join(mThread, &dummy);
384
385 printf("rk_list test 0 end size %d\n", list_0->list_size());
386 delete list_0;
387 return err;
388 }
389
390 #define TOTAL_RK_LIST_TEST_COUNT 1
391
392 typedef int (*RK_LIST_TEST_FUNC)(void);
393 RK_LIST_TEST_FUNC test_func[TOTAL_RK_LIST_TEST_COUNT] = {
394 rk_list_test_0,
395 };
396
main(int argc,char * argv[])397 int main(int argc, char *argv[])
398 {
399 int i, start = 0, end = 0;
400 if (argc < 2) {
401 end = TOTAL_RK_LIST_TEST_COUNT;
402 } else if (argc == 2) {
403 start = atoi(argv[1]);
404 end = start + 1;
405 } else if (argc == 3) {
406 start = atoi(argv[1]);
407 end = atoi(argv[2]);
408 } else {
409 printf("too many argc %d\n", argc);
410 return -1;
411 }
412 if (start < 0 || start > TOTAL_RK_LIST_TEST_COUNT || end < 0 || end > TOTAL_RK_LIST_TEST_COUNT) {
413 printf("invalid input: start %d end %d\n", start, end);
414 return -1;
415 }
416 for (i = start; i < end; i++) {
417 int err = test_func[i]();
418 if (err) {
419 printf("test case %d return err %d\n", i, err);
420 break;
421 }
422 }
423 return 0;
424 }
425 #endif
426
427