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;