Subversion Repositories HelenOS

Rev

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

Rev 3149 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/rwlock.h>
 36 
#include <synch/rwlock.h>
37 
 
 37 
 
38 
#define READERS     50
 38 
#define READERS  50
39 
#define WRITERS     50
 39 
#define WRITERS  50
40 
 
 40 
 
41 
static rwlock_t rwlock;
 41 
static rwlock_t rwlock;
42 
 
 42 
 
43 
static waitq_t can_start;
 43 
static waitq_t can_start;
44 
static atomic_t items_read;
 44 
static atomic_t items_read;
45 
static atomic_t items_written;
 45 
static atomic_t items_written;
46 
 
 46 
 
47 
static void writer(void *arg)
 47 
static void writer(void *arg)
48 
{
 48 
{
49 
    thread_detach(THREAD);
 49 
    thread_detach(THREAD);
50 
 
 50 
   
51 
    waitq_sleep(&can_start);
 51 
    waitq_sleep(&can_start);
52 
 
 52 
   
53 
    rwlock_write_lock(&rwlock);
 53 
    rwlock_write_lock(&rwlock);
54 
    atomic_inc(&items_written);
 54 
    atomic_inc(&items_written);
55 
    rwlock_write_unlock(&rwlock);
 55 
    rwlock_write_unlock(&rwlock);
56 
}
 56 
}
57 
 
 57 
 
58 
static void reader(void *arg)
 58 
static void reader(void *arg)
59 
{
 59 
{
60 
    thread_detach(THREAD);
 60 
    thread_detach(THREAD);
61 
 
 61 
   
62 
    waitq_sleep(&can_start);
 62 
    waitq_sleep(&can_start);
63 
   
 63 
   
64 
    rwlock_read_lock(&rwlock);
 64 
    rwlock_read_lock(&rwlock);
65 
    atomic_inc(&items_read);
 65 
    atomic_inc(&items_read);
66 
    rwlock_read_unlock(&rwlock);
 66 
    rwlock_read_unlock(&rwlock);
67 
}
 67 
}
68 
 
 68 
 
69 
char * test_rwlock5(bool quiet)
 69 
char *test_rwlock5(void)
70 
{
 70 
{
71 
    int i, j, k;
 71 
    int i, j, k;
72 
    long readers, writers;
 72 
    long readers, writers;
73 
   
 73 
   
74 
    waitq_initialize(&can_start);
 74 
    waitq_initialize(&can_start);
75 
    rwlock_initialize(&rwlock);
 75 
    rwlock_initialize(&rwlock);
76 
   
 76 
   
77 
    for (i = 1; i <= 3; i++) {
 77 
    for (i = 1; i <= 3; i++) {
78 
        thread_t *thrd;
 78 
        thread_t *thrd;
79 
 
 79 
       
80 
        atomic_set(&items_read, 0);
 80 
        atomic_set(&items_read, 0);
81 
        atomic_set(&items_written, 0);
 81 
        atomic_set(&items_written, 0);
82 
 
 82 
       
83 
        readers = i * READERS;
 83 
        readers = i * READERS;
84 
        writers = (4 - i) * WRITERS;
 84 
        writers = (4 - i) * WRITERS;
85 
 
 85 
       
86 
        printf("Creating %ld readers and %ld writers...", readers, writers);
 86 
        TPRINTF("Creating %ld readers and %ld writers...", readers, writers);
87 
       
 87 
       
88 
        for (j = 0; j < (READERS + WRITERS) / 2; j++) {
 88 
        for (j = 0; j < (READERS + WRITERS) / 2; j++) {
89 
            for (k = 0; k < i; k++) {
 89 
            for (k = 0; k < i; k++) {
90 
                thrd = thread_create(reader, NULL, TASK, 0, "reader", false);
 90 
                thrd = thread_create(reader, NULL, TASK, 0, "reader", false);
91 
                if (thrd)
 91 
                if (thrd)
92 
                    thread_ready(thrd);
 92 
                    thread_ready(thrd);
93 
                else
 93 
                else
94 
                    printf("Could not create reader %d\n", k);
 94 
                    TPRINTF("Could not create reader %d\n", k);
95 
            }
 95 
            }
96 
            for (k = 0; k < (4 - i); k++) {
 96 
            for (k = 0; k < (4 - i); k++) {
97 
                thrd = thread_create(writer, NULL, TASK, 0, "writer", false);
 97 
                thrd = thread_create(writer, NULL, TASK, 0, "writer", false);
98 
                if (thrd)
 98 
                if (thrd)
99 
                    thread_ready(thrd);
 99 
                    thread_ready(thrd);
100 
                else
 100 
                else
101 
                    printf("Could not create writer %d\n", k);
 101 
                    TPRINTF("Could not create writer %d\n", k);
102 
            }
 102 
            }
103 
        }
 103 
        }
104 
 
 104 
       
105 
        printf("ok\n");
 105 
        TPRINTF("ok\n");
106 
 
 106 
       
107 
        thread_sleep(1);
 107 
        thread_sleep(1);
108 
        waitq_wakeup(&can_start, WAKEUP_ALL);
 108 
        waitq_wakeup(&can_start, WAKEUP_ALL);
109 
   
 109 
       
110 
        while ((items_read.count != readers) || (items_written.count != writers)) {
 110 
        while ((items_read.count != readers) || (items_written.count != writers)) {
111 
            printf("%d readers remaining, %d writers remaining, readers_in=%d\n", readers - items_read.count, writers - items_written.count, rwlock.readers_in);
 111 
            TPRINTF("%d readers remaining, %d writers remaining, readers_in=%d\n", readers - items_read.count, writers - items_written.count, rwlock.readers_in);
112 
            thread_usleep(100000);
 112 
            thread_usleep(100000);
113 
        }
 113 
        }
114 
    }
 114 
    }
115 
   
 115 
   
116 
    return NULL;
 116 
    return NULL;