Subversion Repositories HelenOS

Rev

Rev 2927 | Go to most recent revision | Show entire file | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 2927 Rev 4348
Line 33... Line 33...
33 
#include <proc/thread.h>
 33 
#include <proc/thread.h>
34 
 
 34 
 
35 
#include <synch/waitq.h>
 35 
#include <synch/waitq.h>
36 
#include <synch/semaphore.h>
 36 
#include <synch/semaphore.h>
37 
 
 37 
 
38 
#define AT_ONCE         3
 38 
#define AT_ONCE    3
39 
#define PRODUCERS       50
 39 
#define PRODUCERS  50
40 
#define CONSUMERS       50
 40 
#define CONSUMERS  50
41 
 
 41 
 
42 
static semaphore_t sem;
 42 
static semaphore_t sem;
43 
 
 43 
 
44 
static waitq_t can_start;
 44 
static waitq_t can_start;
45 
static atomic_t items_produced;
 45 
static atomic_t items_produced;
46 
static atomic_t items_consumed;
 46 
static atomic_t items_consumed;
47 
 
 47 
 
48 
static void producer(void *arg)
 48 
static void producer(void *arg)
49 
{
 49 
{
50 
    thread_detach(THREAD); 
 50 
    thread_detach(THREAD);
51 
 
 51 
   
52 
    waitq_sleep(&can_start);
 52 
    waitq_sleep(&can_start);
53 
       
 53 
   
54 
    semaphore_down(&sem);
 54 
    semaphore_down(&sem);
55 
    atomic_inc(&items_produced);
 55 
    atomic_inc(&items_produced);
56 
    thread_usleep(250);
 56 
    thread_usleep(250);
57 
    semaphore_up(&sem);
 57 
    semaphore_up(&sem);
58 
}
 58 
}
59 
 
 59 
 
60 
static void consumer(void *arg)
 60 
static void consumer(void *arg)
61 
{
 61 
{
62 
    thread_detach(THREAD); 
 62 
    thread_detach(THREAD);
63 
   
 63 
   
64 
    waitq_sleep(&can_start);
 64 
    waitq_sleep(&can_start);
65 
   
 65 
   
66 
    semaphore_down(&sem);
 66 
    semaphore_down(&sem);
67 
    atomic_inc(&items_consumed);
 67 
    atomic_inc(&items_consumed);
68 
    thread_usleep(500);
 68 
    thread_usleep(500);
69 
    semaphore_up(&sem);
 69 
    semaphore_up(&sem);
70 
}
 70 
}
71 
 
 71 
 
72 
char * test_semaphore1(bool quiet)
 72 
char *test_semaphore1(void)
73 
{
 73 
{
74 
    int i, j, k;
 74 
    int i, j, k;
75 
    int consumers, producers;
 75 
    int consumers, producers;
76 
   
 76 
   
77 
    waitq_initialize(&can_start);
 77 
    waitq_initialize(&can_start);
78 
    semaphore_initialize(&sem, AT_ONCE);
 78 
    semaphore_initialize(&sem, AT_ONCE);
79 
 
 79 
   
80 
    for (i = 1; i <= 3; i++) {
 80 
    for (i = 1; i <= 3; i++) {
81 
        thread_t *thrd;
 81 
        thread_t *thrd;
82 
 
 82 
       
83 
        atomic_set(&items_produced, 0);
 83 
        atomic_set(&items_produced, 0);
84 
        atomic_set(&items_consumed, 0);
 84 
        atomic_set(&items_consumed, 0);
85 
       
 85 
       
86 
        consumers = i * CONSUMERS;
 86 
        consumers = i * CONSUMERS;
87 
        producers = (4 - i) * PRODUCERS;
 87 
        producers = (4 - i) * PRODUCERS;
88 
       
 88 
       
89 
        printf("Creating %d consumers and %d producers...", consumers, producers);
 89 
        TPRINTF("Creating %d consumers and %d producers...", consumers, producers);
90 
   
 90 
       
91 
        for (j = 0; j < (CONSUMERS + PRODUCERS) / 2; j++) {
 91 
        for (j = 0; j < (CONSUMERS + PRODUCERS) / 2; j++) {
92 
            for (k = 0; k < i; k++) {
 92 
            for (k = 0; k < i; k++) {
93 
                thrd = thread_create(consumer, NULL, TASK, 0, "consumer", false);
 93 
                thrd = thread_create(consumer, NULL, TASK, 0, "consumer", false);
94 
                if (thrd)
 94 
                if (thrd)
95 
                    thread_ready(thrd);
 95 
                    thread_ready(thrd);
96 
                else
 96 
                else
97 
                    printf("could not create consumer %d\n", i);
 97 
                    TPRINTF("could not create consumer %d\n", i);
98 
            }
 98 
            }
99 
            for (k = 0; k < (4 - i); k++) {
 99 
            for (k = 0; k < (4 - i); k++) {
100 
                thrd = thread_create(producer, NULL, TASK, 0, "producer", false);
 100 
                thrd = thread_create(producer, NULL, TASK, 0, "producer", false);
101 
                if (thrd)
 101 
                if (thrd)
102 
                    thread_ready(thrd);
 102 
                    thread_ready(thrd);
103 
                else
 103 
                else
104 
                    printf("could not create producer %d\n", i);
 104 
                    TPRINTF("could not create producer %d\n", i);
105 
            }
 105 
            }
106 
        }
 106 
        }
107 
 
 107 
       
108 
        printf("ok\n");
 108 
        TPRINTF("ok\n");
109 
 
 109 
       
110 
        thread_sleep(1);
 110 
        thread_sleep(1);
111 
        waitq_wakeup(&can_start, WAKEUP_ALL);
 111 
        waitq_wakeup(&can_start, WAKEUP_ALL);
112 
   
 112 
       
113 
        while ((items_consumed.count != consumers) || (items_produced.count != producers)) {
 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);
 114 
            TPRINTF("%d consumers remaining, %d producers remaining\n", consumers - items_consumed.count, producers - items_produced.count);
115 
            thread_sleep(1);
 115 
            thread_sleep(1);
116 
        }
 116 
        }
117 
    }
 117 
    }
118 
   
 118 
   
119 
    return NULL;
 119 
    return NULL;