Mercurial > hg > audiostuff

comparison spandsp-0.0.6pre17/tests/queue_tests.c @ 4:26cd8f1ef0b1

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
import spandsp-0.0.6pre17
author Peter Meerwald <pmeerw@cosy.sbg.ac.at>
date Fri, 25 Jun 2010 15:50:58 +0200
parents
children
comparison
equal deleted inserted replaced
3:c6c5a16ce2f2 4:26cd8f1ef0b1
1 /*
2 * SpanDSP - a series of DSP components for telephony
3 *
4 * queue_tests.c
5 *
6 * Written by Steve Underwood <steveu@coppice.org>
7 *
8 * Copyright (C) 2007 Steve Underwood
9 *
10 * All rights reserved.
11 *
12 * This program is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU General Public License version 2, as
14 * published by the Free Software Foundation.
15 *
16 * This program is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU General Public License for more details.
20 *
21 * You should have received a copy of the GNU General Public License
22 * along with this program; if not, write to the Free Software
23 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
24 *
25 * $Id: queue_tests.c,v 1.13 2009/04/11 17:43:04 steveu Exp $
26 */
27
28 /* THIS IS A WORK IN PROGRESS. IT IS NOT FINISHED. */
29
30 /*! \page queue_tests_page Queue tests
31 \section queue_tests_page_sec_1 What does it do?
32 */
33
34 #if defined(HAVE_CONFIG_H)
35 #include <config.h>
36 #endif
37
38 #include <stdlib.h>
39 #include <stdio.h>
40 #include <unistd.h>
41 #include <string.h>
42 #include <assert.h>
43 #include <pthread.h>
44 #include <sched.h>
45
46 //#if defined(WITH_SPANDSP_INTERNALS)
47 #define SPANDSP_EXPOSE_INTERNAL_STRUCTURES
48 //#endif
49
50 #include "spandsp.h"
51
52 #define BUF_LEN 10000
53 #define MSG_LEN 17
54
55 pthread_t thread[2];
56 queue_state_t *queue;
57 volatile int put_oks;
58 volatile int put_misses;
59 volatile int got_oks;
60 volatile int got_misses;
61
62 int total_in;
63 int total_out;
64
65 static void tests_failed(void)
66 {
67 printf("Tests failed\n");
68 exit(2);
69 }
70 /*- End of function --------------------------------------------------------*/
71
72 static void display_queue_pointers(void)
73 {
74 printf("Pointers %d %d %d\n", queue->iptr, queue->optr, queue->len);
75 }
76 /*- End of function --------------------------------------------------------*/
77
78 static void *run_stream_write(void *arg)
79 {
80 uint8_t buf[MSG_LEN];
81 int i;
82 int next;
83
84 printf("Write thread\n");
85 next = 0;
86 for (i = 0; i < MSG_LEN; i++)
87 buf[i] = next;
88 next = (next + 1) & 0xFF;
89 put_oks = 0;
90 put_misses = 0;
91 for (;;)
92 {
93 if (queue_write(queue, buf, MSG_LEN) == MSG_LEN)
94 {
95 for (i = 0; i < MSG_LEN; i++)
96 buf[i] = next;
97 next = (next + 1) & 0xFF;
98 put_oks++;
99 if (put_oks%1000000 == 0)
100 printf("%d puts, %d misses\n", put_oks, put_misses);
101 }
102 else
103 {
104 sched_yield();
105 put_misses++;
106 }
107 }
108 return NULL;
109 }
110 /*- End of function --------------------------------------------------------*/
111
112 static void *run_stream_read(void *arg)
113 {
114 uint8_t buf[MSG_LEN];
115 int i;
116 int len;
117 int next;
118
119 printf("Read thread\n");
120 next = 0;
121 got_oks = 0;
122 got_misses = 0;
123 for (;;)
124 {
125 if ((len = queue_read(queue, buf, MSG_LEN)) >= 0)
126 {
127 if (len != MSG_LEN)
128 {
129 printf("AHH! - len %d\n", len);
130 tests_failed();
131 }
132 for (i = 0; i < len; i++)
133 {
134 if (buf[i] != next)
135 {
136 printf("AHH! - 0x%X 0x%X\n", buf[i], next);
137 tests_failed();
138 }
139 }
140 next = (next + 1) & 0xFF;
141 got_oks++;
142 if (got_oks%1000000 == 0)
143 printf("%d gots, %d misses\n", got_oks, got_misses);
144 }
145 else
146 {
147 sched_yield();
148 got_misses++;
149 }
150 }
151 return NULL;
152 }
153 /*- End of function --------------------------------------------------------*/
154
155 static void threaded_stream_tests(void)
156 {
157 pthread_attr_t attr;
158
159 if ((queue = queue_init(NULL, BUF_LEN, QUEUE_READ_ATOMIC | QUEUE_WRITE_ATOMIC)) == NULL)
160 {
161 printf("Failed to create the queue\n");
162 tests_failed();
163 }
164 pthread_attr_init(&attr);
165 pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
166 if (pthread_create(&thread[0], &attr, run_stream_write, NULL))
167 {
168 printf("Failed to create thread\n");
169 tests_failed();
170 }
171 if (pthread_create(&thread[1], &attr, run_stream_read, NULL))
172 {
173 printf("Failed to create thread\n");
174 tests_failed();
175 }
176 for (;;)
177 {
178 sleep(5);
179 printf("Main thread - %d %d\n", put_oks, got_oks);
180 }
181 queue_free(queue);
182 }
183 /*- End of function --------------------------------------------------------*/
184
185 static void *run_message_write(void *arg)
186 {
187 uint8_t buf[MSG_LEN];
188 int i;
189 int next;
190
191 printf("Write thread\n");
192 next = 0;
193 for (i = 0; i < MSG_LEN; i++)
194 buf[i] = next;
195 next = (next + 1) & 0xFF;
196 put_oks = 0;
197 put_misses = 0;
198 for (;;)
199 {
200 if (queue_write_msg(queue, buf, MSG_LEN) == MSG_LEN)
201 {
202 for (i = 0; i < MSG_LEN; i++)
203 buf[i] = next;
204 next = (next + 1) & 0xFF;
205 put_oks++;
206 if (put_oks%1000000 == 0)
207 printf("%d puts, %d misses\n", put_oks, put_misses);
208 }
209 else
210 {
211 sched_yield();
212 put_misses++;
213 }
214 }
215 return NULL;
216 }
217 /*- End of function --------------------------------------------------------*/
218
219 static void *run_message_read(void *arg)
220 {
221 uint8_t buf[1024];
222 int i;
223 int len;
224 int next;
225
226 printf("Read thread\n");
227 next = 0;
228 got_oks = 0;
229 got_misses = 0;
230 for (;;)
231 {
232 if ((len = queue_read_msg(queue, buf, 1024)) >= 0)
233 {
234 if (len != MSG_LEN)
235 {
236 printf("AHH! - len %d\n", len);
237 tests_failed();
238 }
239 for (i = 0; i < len; i++)
240 {
241 if (buf[i] != next)
242 {
243 printf("AHH! - 0x%X 0x%X\n", buf[i], next);
244 tests_failed();
245 }
246 }
247 next = (next + 1) & 0xFF;
248 got_oks++;
249 if (got_oks%1000000 == 0)
250 printf("%d gots, %d misses\n", got_oks, got_misses);
251 }
252 else
253 {
254 sched_yield();
255 got_misses++;
256 }
257 }
258 return NULL;
259 }
260 /*- End of function --------------------------------------------------------*/
261
262 static void threaded_message_tests(void)
263 {
264 pthread_attr_t attr;
265
266 if ((queue = queue_init(NULL, BUF_LEN, QUEUE_READ_ATOMIC | QUEUE_WRITE_ATOMIC)) == NULL)
267 {
268 printf("Failed to create the queue\n");
269 tests_failed();
270 }
271 pthread_attr_init(&attr);
272 pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
273 if (pthread_create(&thread[0], &attr, run_message_write, NULL))
274 {
275 printf("Failed to create thread\n");
276 tests_failed();
277 }
278 if (pthread_create(&thread[1], &attr, run_message_read, NULL))
279 {
280 printf("Failed to create thread\n");
281 tests_failed();
282 }
283 for (;;)
284 {
285 sleep(5);
286 printf("Main thread - %d %d\n", put_oks, got_oks);
287 }
288 queue_free(queue);
289 }
290 /*- End of function --------------------------------------------------------*/
291
292 static void check_contents(int total_in, int total_out)
293 {
294 if (queue_contents(queue) != (total_in - total_out))
295 {
296 printf("Contents = %d (%d)\n", queue_contents(queue), (total_in - total_out));
297 display_queue_pointers();
298 tests_failed();
299 }
300 if (queue_free_space(queue) != BUF_LEN - (total_in - total_out))
301 {
302 printf("Free space = %d (%d)\n", queue_free_space(queue), BUF_LEN - (total_in - total_out));
303 display_queue_pointers();
304 tests_failed();
305 }
306 }
307 /*- End of function --------------------------------------------------------*/
308
309 static int monitored_queue_write(const uint8_t buf[], int len)
310 {
311 int lenx;
312
313 lenx = queue_write(queue, buf, len);
314 if (lenx >= 0)
315 total_in += lenx;
316 check_contents(total_in, total_out);
317 return lenx;
318 }
319 /*- End of function --------------------------------------------------------*/
320
321 static int monitored_queue_write_byte(const uint8_t buf)
322 {
323 int res;
324
325 if ((res = queue_write_byte(queue, buf)) >= 0)
326 total_in++;
327 check_contents(total_in, total_out);
328 return res;
329 }
330 /*- End of function --------------------------------------------------------*/
331
332 static int monitored_queue_read(uint8_t buf[], int len)
333 {
334 int lenx;
335
336 lenx = queue_read(queue, buf, len);
337 if (lenx >= 0)
338 total_out += lenx;
339 check_contents(total_in, total_out);
340 return lenx;
341 }
342 /*- End of function --------------------------------------------------------*/
343
344 static int monitored_queue_read_byte(void)
345 {
346 int res;
347
348 if ((res = queue_read_byte(queue)) >= 0)
349 total_out++;
350 check_contents(total_in, total_out);
351 return res;
352 }
353 /*- End of function --------------------------------------------------------*/
354
355 static void functional_stream_tests(void)
356 {
357 uint8_t buf[MSG_LEN];
358 int i;
359 int res;
360
361 total_in = 0;
362 total_out = 0;
363
364 for (i = 0; i < MSG_LEN; i++)
365 buf[i] = i;
366 if ((queue = queue_init(NULL, BUF_LEN, QUEUE_READ_ATOMIC | QUEUE_WRITE_ATOMIC)) == NULL)
367 {
368 printf("Failed to create the queue\n");
369 tests_failed();
370 }
371 check_contents(total_in, total_out);
372 /* Half fill the buffer, and check we can get out what we put in. */
373 for (i = 1; i < 5000; i++)
374 {
375 if (monitored_queue_write_byte(i & 0xFF) != 1)
376 {
377 printf("Byte by byte full at %d/%d\n", i, BUF_LEN);
378 tests_failed();
379 }
380 }
381 for (i = 1; i < 5001; i++)
382 {
383 if ((res = monitored_queue_read_byte()) != (i & 0xFF))
384 break;
385 }
386 printf("Byte by byte read breaks at %d (expected %d) - %d\n", i, 5000, res);
387 if (i != 5000)
388 tests_failed();
389 /* Now completely fill the buffer, and we should roll around the end. Check we can
390 get out what we put in. */
391 for (i = 1; i < 20000; i++)
392 {
393 if (monitored_queue_write_byte(i & 0xFF) != 1)
394 break;
395 }
396 printf("Byte by byte full at %d (expected %d)\n", i, 10001);
397 if (i != 10001)
398 tests_failed();
399 for (i = 1; i < 20000; i++)
400 {
401 if ((res = monitored_queue_read_byte()) != (i & 0xFF))
402 break;
403 }
404 printf("Byte by byte read breaks at %d (expected %d) - %d\n", i, 10001, res);
405 if (i != 10001)
406 tests_failed();
407 /* Fill the buffer, checking the contents grow correctly */
408 for (i = 1; i < 1000; i++)
409 {
410 if (monitored_queue_write(buf, MSG_LEN) != MSG_LEN)
411 break;
412 }
413 printf("Full at chunk %d (expected %d)\n", i, BUF_LEN/MSG_LEN + 1);
414 if (i != BUF_LEN/MSG_LEN + 1)
415 tests_failed();
416 if (monitored_queue_write(buf, 5) == 5)
417 {
418 printf("Write of 5 succeeded\n");
419 tests_failed();
420 }
421 if (monitored_queue_write(buf, 4) != 4)
422 {
423 printf("Write of 4 failed\n");
424 tests_failed();
425 }
426 /* Now full. Empty a little, and refill around the end */
427 if (monitored_queue_read(buf, MSG_LEN) != MSG_LEN)
428 {
429 printf("Read failed\n");
430 tests_failed();
431 }
432 if (monitored_queue_write(buf, MSG_LEN) != MSG_LEN)
433 {
434 printf("Write failed\n");
435 tests_failed();
436 }
437 /* Empty completely, checking the contents shrink correctly */
438 for (;;)
439 {
440 if (monitored_queue_read(buf, MSG_LEN) != MSG_LEN)
441 break;
442 }
443 if (monitored_queue_read(buf, 4) != 4)
444 {
445 printf("Read failed\n");
446 tests_failed();
447 }
448 /* Nudge around the buffer */
449 for (i = 1; i < 588; i++)
450 {
451 if (monitored_queue_write(buf, MSG_LEN) != MSG_LEN)
452 {
453 printf("Write failed\n");
454 tests_failed();
455 }
456 if (monitored_queue_read(buf, MSG_LEN) != MSG_LEN)
457 {
458 printf("Read failed\n");
459 tests_failed();
460 }
461 }
462 /* Fill the buffer, checking the contents grow correctly */
463 for (i = 1; i < 1000; i++)
464 {
465 if (monitored_queue_write(buf, MSG_LEN) != MSG_LEN)
466 break;
467 }
468 printf("Full at chunk %d (expected %d)\n", i, BUF_LEN/MSG_LEN + 1);
469 if (i != BUF_LEN/MSG_LEN + 1)
470 tests_failed();
471 display_queue_pointers();
472 if (monitored_queue_read(buf, MSG_LEN) != MSG_LEN)
473 {
474 printf("Read failed\n");
475 tests_failed();
476 }
477 if (monitored_queue_write(buf, MSG_LEN) != MSG_LEN)
478 {
479 printf("Write failed\n");
480 tests_failed();
481 }
482 display_queue_pointers();
483 for (i = 1; i < 5000; i++)
484 {
485 if (monitored_queue_read(buf, MSG_LEN) != MSG_LEN)
486 {
487 printf("Read failed\n");
488 tests_failed();
489 }
490 if (monitored_queue_write(buf, MSG_LEN) != MSG_LEN)
491 {
492 printf("Write failed\n");
493 tests_failed();
494 }
495 }
496 display_queue_pointers();
497 if (monitored_queue_write(buf, 5) == 5)
498 {
499 printf("Write of 5 succeeded\n");
500 tests_failed();
501 }
502 if (monitored_queue_write(buf, 4) != 4)
503 {
504 printf("Write of 4 failed\n");
505 tests_failed();
506 }
507 display_queue_pointers();
508 for (i = 1; i < 5000; i++)
509 {
510 if (monitored_queue_read(buf, MSG_LEN) != MSG_LEN)
511 {
512 printf("Read failed\n");
513 tests_failed();
514 }
515 if (monitored_queue_write(buf, MSG_LEN) != MSG_LEN)
516 {
517 printf("Write failed\n");
518 tests_failed();
519 }
520 }
521 display_queue_pointers();
522 queue_free(queue);
523 }
524 /*- End of function --------------------------------------------------------*/
525
526 static int monitored_queue_write_msg(const uint8_t buf[], int len)
527 {
528 int lenx;
529
530 lenx = queue_write_msg(queue, buf, len);
531 if (lenx >= 0)
532 total_in += lenx + sizeof(uint16_t);
533 check_contents(total_in, total_out);
534 return lenx;
535 }
536 /*- End of function --------------------------------------------------------*/
537
538 static int monitored_queue_read_msg(uint8_t buf[], int len)
539 {
540 int lenx;
541
542 lenx = queue_read_msg(queue, buf, len);
543 if (lenx >= 0)
544 total_out += lenx + sizeof(uint16_t);
545 check_contents(total_in, total_out);
546 return lenx;
547 }
548 /*- End of function --------------------------------------------------------*/
549
550 static void functional_message_tests(void)
551 {
552 uint8_t buf[MSG_LEN];
553 int i;
554 int len;
555
556 total_in = 0;
557 total_out = 0;
558
559 for (i = 0; i < MSG_LEN; i++)
560 buf[i] = i;
561 if ((queue = queue_init(NULL, BUF_LEN, QUEUE_READ_ATOMIC | QUEUE_WRITE_ATOMIC)) == NULL)
562 {
563 printf("Failed to create the queue\n");
564 tests_failed();
565 }
566 check_contents(total_in, total_out);
567 /* Fill the buffer, checking the contents grow correctly */
568 for (i = 1; i < 1000; i++)
569 {
570 if (monitored_queue_write_msg(buf, MSG_LEN) != MSG_LEN)
571 break;
572 }
573 printf("Full at chunk %d (expected %u)\n", i, BUF_LEN/(MSG_LEN + sizeof(uint16_t)) + 1);
574 if (i != BUF_LEN/(MSG_LEN + sizeof(uint16_t)) + 1)
575 tests_failed();
576 if ((len = monitored_queue_write_msg(buf, 5)) == 5)
577 {
578 printf("Write of 5 succeeded\n");
579 tests_failed();
580 }
581 if ((len = monitored_queue_write_msg(buf, 4)) != 4)
582 {
583 printf("Write of 4 failed\n");
584 tests_failed();
585 }
586 /* Now full. Empty a little, and refill around the end */
587 if ((len = monitored_queue_read_msg(buf, MSG_LEN)) != MSG_LEN)
588 {
589 printf("Read failed - %d\n", len);
590 tests_failed();
591 }
592 if ((len = monitored_queue_write_msg(buf, MSG_LEN)) != MSG_LEN)
593 {
594 printf("Write failed - %d\n", len);
595 tests_failed();
596 }
597 /* Empty completely, checking the contents shrink correctly */
598 for (;;)
599 {
600 if ((len = monitored_queue_read_msg(buf, MSG_LEN)) != MSG_LEN)
601 break;
602 }
603 if (len != 4)
604 {
605 printf("Read failed - %d\n", len);
606 tests_failed();
607 }
608 /* We should now have one MSG_LEN message in the buffer */
609 /* Nudge around the buffer */
610 for (i = 1; i < 527; i++)
611 {
612 if ((len = monitored_queue_write_msg(buf, MSG_LEN)) != MSG_LEN)
613 {
614 printf("Write failed - %d\n", len);
615 tests_failed();
616 }
617 if ((len = monitored_queue_read_msg(buf, MSG_LEN)) != MSG_LEN)
618 {
619 printf("Read failed - %d\n", len);
620 tests_failed();
621 }
622 }
623 /* Fill the buffer, checking the contents grow correctly */
624 for (i = 1; i < 1000; i++)
625 {
626 if ((len = monitored_queue_write_msg(buf, MSG_LEN)) != MSG_LEN)
627 break;
628 }
629 printf("Free space = %d (%d)\n", queue_free_space(queue), BUF_LEN - (total_in - total_out));
630 display_queue_pointers();
631 printf("Full at chunk %d (expected %u)\n", i, BUF_LEN/(MSG_LEN + sizeof(uint16_t)));
632 if (i != BUF_LEN/(MSG_LEN + sizeof(uint16_t)))
633 tests_failed();
634 display_queue_pointers();
635
636 if ((len = monitored_queue_read_msg(buf, MSG_LEN)) != MSG_LEN)
637 {
638 printf("Read failed - %d\n", len);
639 tests_failed();
640 }
641 if ((len = monitored_queue_write_msg(buf, MSG_LEN)) != MSG_LEN)
642 {
643 printf("Write failed - %d\n", len);
644 tests_failed();
645 }
646 display_queue_pointers();
647 for (i = 1; i < 5000; i++)
648 {
649 if ((len = monitored_queue_read_msg(buf, MSG_LEN)) != MSG_LEN)
650 {
651 printf("Read failed - %d\n", len);
652 tests_failed();
653 }
654 if ((len = monitored_queue_write_msg(buf, MSG_LEN)) != MSG_LEN)
655 {
656 printf("Write failed - %d\n", len);
657 tests_failed();
658 }
659 }
660 display_queue_pointers();
661 if ((len = monitored_queue_write_msg(buf, 5)) == 5)
662 {
663 printf("Write of 5 succeeded\n");
664 tests_failed();
665 }
666 if ((len = monitored_queue_write_msg(buf, 4)) != 4)
667 {
668 printf("Write of 4 failed\n");
669 tests_failed();
670 }
671 display_queue_pointers();
672 for (i = 1; i < 5000; i++)
673 {
674 if (i == 527)
675 {
676 if ((len = monitored_queue_read_msg(buf, MSG_LEN)) != 4)
677 {
678 printf("Read failed - %d\n", len);
679 tests_failed();
680 }
681 }
682 if ((len = monitored_queue_read_msg(buf, MSG_LEN)) != MSG_LEN)
683 {
684 printf("Read failed - %d\n", len);
685 tests_failed();
686 }
687 if ((len = monitored_queue_write_msg(buf, MSG_LEN)) != MSG_LEN)
688 {
689 printf("Write failed - %d\n", len);
690 tests_failed();
691 }
692 }
693 display_queue_pointers();
694 queue_free(queue);
695 }
696 /*- End of function --------------------------------------------------------*/
697
698 int main(int argc, char *argv[])
699 {
700 int threaded_messages;
701 int threaded_streams;
702 int opt;
703
704 threaded_messages = FALSE;
705 threaded_streams = FALSE;
706 while ((opt = getopt(argc, argv, "ms")) != -1)
707 {
708 switch (opt)
709 {
710 case 'm':
711 threaded_messages = TRUE;
712 break;
713 case 's':
714 threaded_streams = TRUE;
715 break;
716 }
717 }
718
719 /* Test the basic functionality of the queueing code in stream and message modes */
720 printf("Stream mode functional tests\n");
721 functional_stream_tests();
722 printf("Message mode functional tests\n");
723 functional_message_tests();
724
725 /* Run separate write and read threads for a while, to verify there are no locking
726 issues. */
727 if (threaded_streams)
728 {
729 printf("Stream mode threaded tests\n");
730 threaded_stream_tests();
731 }
732 if (threaded_messages)
733 {
734 printf("Message mode threaded tests\n");
735 threaded_message_tests();
736 }
737 return 0;
738 }
739 /*- End of function --------------------------------------------------------*/
740 /*- End of file ------------------------------------------------------------*/

Repositories maintained by Peter Meerwald, pmeerw@pmeerw.net.