1 #include "mpp_time.h"
2 #include "mpp_debug.h"
3 #include "mpp_thread.h"
4
5 #include "mpp_task.h"
6 #include "mpp_task_impl.h"
7
8 #define MAX_TASK_LOOP 10000
9
10 static MppTaskQueue input = NULL;
11 static MppTaskQueue output = NULL;
12
task_input(void * arg)13 void *task_input(void *arg)
14 {
15 RK_S32 i;
16 MppTask task = NULL;
17 MPP_RET ret = MPP_OK;
18 MppPort port = mpp_task_queue_get_port(input, MPP_PORT_INPUT);
19 MppFrame frm;
20
21 mpp_frame_init(&frm);
22
23 for (i = 0; i < MAX_TASK_LOOP; i++) {
24 ret = mpp_port_poll(port, MPP_POLL_BLOCK);
25 mpp_assert(ret >= 0);
26
27 ret = mpp_port_dequeue(port, &task);
28 mpp_assert(!ret);
29 mpp_assert(task);
30
31 ret = mpp_port_enqueue(port, task);
32 mpp_assert(!ret);
33 }
34
35 mpp_frame_deinit(&frm);
36
37 (void)arg;
38 return NULL;
39 }
40
task_output(void * arg)41 void *task_output(void *arg)
42 {
43 RK_S32 i;
44 MppTask task = NULL;
45 MPP_RET ret = MPP_OK;
46 MppPort port = mpp_task_queue_get_port(output, MPP_PORT_OUTPUT);
47 MppPacket pkt;
48
49 mpp_packet_init(&pkt, NULL, 0);
50
51 for (i = 0; i < MAX_TASK_LOOP; i++) {
52 ret = mpp_port_poll(port, MPP_POLL_BLOCK);
53 mpp_assert(ret >= 0);
54
55 ret = mpp_port_dequeue(port, &task);
56 mpp_assert(!ret);
57 mpp_assert(task);
58
59 ret = mpp_port_enqueue(port, task);
60 mpp_assert(!ret);
61 }
62
63 mpp_packet_deinit(&pkt);
64
65 (void)arg;
66 return NULL;
67 }
68
task_in_and_out(void * arg)69 void *task_in_and_out(void *arg)
70 {
71 RK_S32 i;
72 MppTask task = NULL;
73 MPP_RET ret = MPP_OK;
74 MppPort port_input = mpp_task_queue_get_port(input, MPP_PORT_INPUT);
75 MppPort port_output = mpp_task_queue_get_port(output, MPP_PORT_OUTPUT);
76
77 for (i = 0; i < MAX_TASK_LOOP; i++) {
78 ret = mpp_port_poll(port_input, MPP_POLL_BLOCK);
79 mpp_assert(ret >= 0);
80
81 ret = mpp_port_dequeue(port_input, &task);
82 mpp_assert(!ret);
83 mpp_assert(task);
84
85 ret = mpp_port_enqueue(port_input, task);
86 mpp_assert(!ret);
87
88
89 ret = mpp_port_poll(port_output, MPP_POLL_BLOCK);
90 mpp_assert(ret >= 0);
91
92 ret = mpp_port_dequeue(port_output, &task);
93 mpp_assert(!ret);
94 mpp_assert(task);
95
96 ret = mpp_port_enqueue(port_output, task);
97 mpp_assert(!ret);
98 }
99
100 (void)arg;
101 return NULL;
102 }
103
task_worker(void * arg)104 void *task_worker(void *arg)
105 {
106 RK_S32 i;
107 MppTask task = NULL;
108 MPP_RET ret = MPP_OK;
109 MppPort port_src = mpp_task_queue_get_port(input, MPP_PORT_OUTPUT);
110 MppPort port_dst = mpp_task_queue_get_port(output, MPP_PORT_INPUT);
111
112 for (i = 0; i < MAX_TASK_LOOP; i++) {
113 ret = mpp_port_poll(port_src, MPP_POLL_BLOCK);
114 mpp_assert(ret >= 0);
115
116 ret = mpp_port_dequeue(port_src, &task);
117 mpp_assert(!ret);
118 mpp_assert(task);
119
120 ret = mpp_port_enqueue(port_src, task);
121 mpp_assert(!ret);
122
123 ret = mpp_port_poll(port_dst, MPP_POLL_BLOCK);
124 mpp_assert(ret >= 0);
125
126 ret = mpp_port_dequeue(port_dst, &task);
127 mpp_assert(!ret);
128 mpp_assert(task);
129
130 ret = mpp_port_enqueue(port_dst, task);
131 mpp_assert(!ret);
132 }
133
134 (void)arg;
135 return NULL;
136 }
137
serial_task(void)138 void serial_task(void)
139 {
140 RK_S32 i;
141 MppTask task = NULL;
142 MPP_RET ret = MPP_OK;
143 MppPort port_ii = mpp_task_queue_get_port(input, MPP_PORT_INPUT);
144 MppPort port_io = mpp_task_queue_get_port(input, MPP_PORT_OUTPUT);
145 MppPort port_oi = mpp_task_queue_get_port(output, MPP_PORT_INPUT);
146 MppPort port_oo = mpp_task_queue_get_port(output, MPP_PORT_OUTPUT);
147
148 for (i = 0; i < MAX_TASK_LOOP; i++) {
149 ret = mpp_port_poll(port_ii, MPP_POLL_BLOCK);
150 mpp_assert(ret >= 0);
151
152 ret = mpp_port_dequeue(port_ii, &task);
153 mpp_assert(!ret);
154 mpp_assert(task);
155
156 ret = mpp_port_enqueue(port_ii, task);
157 mpp_assert(!ret);
158
159
160 ret = mpp_port_poll(port_io, MPP_POLL_BLOCK);
161 mpp_assert(ret >= 0);
162
163 ret = mpp_port_dequeue(port_io, &task);
164 mpp_assert(!ret);
165 mpp_assert(task);
166
167 ret = mpp_port_enqueue(port_io, task);
168 mpp_assert(!ret);
169
170
171 ret = mpp_port_poll(port_oi, MPP_POLL_BLOCK);
172 mpp_assert(ret >= 0);
173
174 ret = mpp_port_dequeue(port_oi, &task);
175 mpp_assert(!ret);
176 mpp_assert(task);
177
178 ret = mpp_port_enqueue(port_oi, task);
179 mpp_assert(!ret);
180
181
182 ret = mpp_port_poll(port_oo, MPP_POLL_BLOCK);
183 mpp_assert(ret >= 0);
184
185 ret = mpp_port_dequeue(port_oo, &task);
186 mpp_assert(!ret);
187 mpp_assert(task);
188
189 ret = mpp_port_enqueue(port_oo, task);
190 mpp_assert(!ret);
191 }
192 }
193
main()194 int main()
195 {
196 RK_S64 time_start, time_end;
197
198 pthread_t thread_input;
199 pthread_t thread_output;
200 pthread_t thread_in_and_out;
201 pthread_t thread_worker;
202 pthread_attr_t attr;
203 void *dummy;
204
205 mpp_log("mpp task test start\n");
206
207 mpp_task_queue_init(&input, NULL, "test_input");
208 mpp_task_queue_init(&output, NULL, "test_output");
209 mpp_task_queue_setup(input, 4);
210 mpp_task_queue_setup(output, 4);
211
212 pthread_attr_init(&attr);
213 pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
214
215 mpp_debug = MPP_DBG_TIMING;
216
217 time_start = mpp_time();
218 pthread_create(&thread_input, &attr, task_input, NULL);
219 pthread_create(&thread_output, &attr, task_output, NULL);
220 pthread_create(&thread_worker, &attr, task_worker, NULL);
221
222 pthread_join(thread_input, &dummy);
223 pthread_join(thread_worker, &dummy);
224 pthread_join(thread_output, &dummy);
225 time_end = mpp_time();
226 mpp_time_diff(time_start, time_end, 0, "3 thread test");
227
228 time_start = mpp_time();
229 pthread_create(&thread_in_and_out, &attr, task_in_and_out, NULL);
230 pthread_create(&thread_worker, &attr, task_worker, NULL);
231
232 pthread_join(thread_in_and_out, &dummy);
233 pthread_join(thread_worker, &dummy);
234 time_end = mpp_time();
235 mpp_time_diff(time_start, time_end, 0, "2 thread test");
236 pthread_attr_destroy(&attr);
237
238 time_start = mpp_time();
239 serial_task();
240 time_end = mpp_time();
241 mpp_time_diff(time_start, time_end, 0, "1 thread test");
242
243 mpp_debug = 0;
244
245 mpp_task_queue_deinit(input);
246 mpp_task_queue_deinit(output);
247
248 mpp_log("mpp task test done\n");
249
250 return 0;
251 }
252
253