kernel/test/synch/semaphore1.c

   1 /*
   2  * Copyright (c) 2001-2004 Jakub Jermar
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  *
   9  * - Redistributions of source code must retain the above copyright
  10  *   notice, this list of conditions and the following disclaimer.
  11  * - Redistributions in binary form must reproduce the above copyright
  12  *   notice, this list of conditions and the following disclaimer in the
  13  *   documentation and/or other materials provided with the distribution.
  14  * - The name of the author may not be used to endorse or promote products
  15  *   derived from this software without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  18  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  19  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  20  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  21  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  22  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  23  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27  */
  28
  29 #include <test.h>
  30 #include <arch.h>
  31 #include <atomic.h>
  32 #include <print.h>
  33 #include <proc/thread.h>
  34
  35 #include <synch/waitq.h>
  36 #include <synch/semaphore.h>
  37
  38 #define AT_ONCE                 3
  39 #define PRODUCERS               50
  40 #define CONSUMERS               50
  41
  42 static semaphore_t sem;
  43
  44 static waitq_t can_start;
  45 static atomic_t items_produced;
  46 static atomic_t items_consumed;
  47
  48 static void producer(void *arg)
  49 {
  50         thread_detach(THREAD);
  51
  52         waitq_sleep(&can_start);
  53
  54         semaphore_down(&sem);
  55         atomic_inc(&items_produced);
  56         thread_usleep(250);
  57         semaphore_up(&sem);
  58 }
  59
  60 static void consumer(void *arg)
  61 {
  62         thread_detach(THREAD);
  63
  64         waitq_sleep(&can_start);
  65
  66         semaphore_down(&sem);
  67         atomic_inc(&items_consumed);
  68         thread_usleep(500);
  69         semaphore_up(&sem);
  70 }
  71
  72 char * test_semaphore1(bool quiet)
  73 {
  74         int i, j, k;
  75         int consumers, producers;
  76
  77         waitq_initialize(&can_start);
  78         semaphore_initialize(&sem, AT_ONCE);
  79
  80         for (i = 1; i <= 3; i++) {
  81                 thread_t *thrd;
  82
  83                 atomic_set(&items_produced, 0);
  84                 atomic_set(&items_consumed, 0);
  85
  86                 consumers = i * CONSUMERS;
  87                 producers = (4 - i) * PRODUCERS;
  88
  89                 printf("Creating %d consumers and %d producers...", consumers, producers);
  90
  91                 for (j = 0; j < (CONSUMERS + PRODUCERS) / 2; j++) {
  92                         for (k = 0; k < i; k++) {
  93                                 thrd = thread_create(consumer, NULL, TASK, 0, "consumer", false);
  94                                 if (thrd)
  95                                         thread_ready(thrd);
  96                                 else
  97                                         printf("could not create consumer %d\n", i);
  98                         }
  99                         for (k = 0; k < (4 - i); k++) {
 100                                 thrd = thread_create(producer, NULL, TASK, 0, "producer", false);
 101                                 if (thrd)
 102                                         thread_ready(thrd);
 103                                 else
 104                                         printf("could not create producer %d\n", i);
 105                         }
 106                 }
 107
 108                 printf("ok\n");
 109
 110                 thread_sleep(1);
 111                 waitq_wakeup(&can_start, WAKEUP_ALL);
 112
 113                 while ((items_consumed.count != consumers) || (items_produced.count != producers)) {
 114                         printf("%d consumers remaining, %d producers remaining\n", consumers - items_consumed.count, producers - items_produced.count);
 115                         thread_sleep(1);
 116                 }
 117         }
 118
 119         return NULL;
 120 }