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 32... Line 32...
32 
#include <print.h>
 32 
#include <print.h>
33 
#include <proc/thread.h>
 33 
#include <proc/thread.h>
34 
 
 34 
 
35 
#include <synch/rwlock.h>
 35 
#include <synch/rwlock.h>
36 
 
 36 
 
37 
#define THREADS 4
 37 
#define THREADS  4
38 
 
 38 
 
39 
static atomic_t thread_count;
 39 
static atomic_t thread_count;
40 
static rwlock_t rwlock;
 40 
static rwlock_t rwlock;
41 
static bool sh_quiet;
 - 
 
42 
 
 41 
 
43 
static void reader(void *arg)
 42 
static void reader(void *arg)
44 
{
 43 
{
45 
    thread_detach(THREAD);
 44 
    thread_detach(THREAD);
46 
   
 45 
   
47 
    if (!sh_quiet)
 - 
 
48 
        printf("cpu%u, tid %" PRIu64 ": trying to lock rwlock for reading....\n", CPU->id, THREAD->tid);
 46 
    TPRINTF("cpu%u, tid %" PRIu64 ": trying to lock rwlock for reading....\n", CPU->id, THREAD->tid);
49 
   
 47 
   
50 
    rwlock_read_lock(&rwlock);
 48 
    rwlock_read_lock(&rwlock);
51 
    rwlock_read_unlock(&rwlock);
 49 
    rwlock_read_unlock(&rwlock);
52 
   
 50 
   
53 
    if (!sh_quiet) {
 - 
 
54 
        printf("cpu%u, tid %" PRIu64 ": success\n", CPU->id, THREAD->tid);         
 51 
    TPRINTF("cpu%u, tid %" PRIu64 ": success\n", CPU->id, THREAD->tid);
55 
        printf("cpu%u, tid %" PRIu64 ": trying to lock rwlock for writing....\n", CPU->id, THREAD->tid);       
 52 
    TPRINTF("cpu%u, tid %" PRIu64 ": trying to lock rwlock for writing....\n", CPU->id, THREAD->tid);
56 
    }
 53 
   
57 
 
 - 
 
58 
    rwlock_write_lock(&rwlock);
 54 
    rwlock_write_lock(&rwlock);
59 
    rwlock_write_unlock(&rwlock);
 55 
    rwlock_write_unlock(&rwlock);
60 
   
 56 
   
61 
    if (!sh_quiet)
 - 
 
62 
        printf("cpu%u, tid %" PRIu64 ": success\n", CPU->id, THREAD->tid);
 57 
    TPRINTF("cpu%u, tid %" PRIu64 ": success\n", CPU->id, THREAD->tid);
63 
   
 58 
   
64 
    atomic_dec(&thread_count);
 59 
    atomic_dec(&thread_count);
65 
}
 60 
}
66 
 
 61 
 
67 
char * test_rwlock3(bool quiet)
 62 
char *test_rwlock3(void)
68 
{
 63 
{
69 
    int i;
 64 
    int i;
70 
    thread_t *thrd;
 65 
    thread_t *thrd;
71 
    sh_quiet = quiet;
 - 
 
72 
   
 66 
   
73 
    atomic_set(&thread_count, THREADS);
 67 
    atomic_set(&thread_count, THREADS);
74 
   
 68 
   
75 
    rwlock_initialize(&rwlock);
 69 
    rwlock_initialize(&rwlock);
76 
    rwlock_write_lock(&rwlock);
 70 
    rwlock_write_lock(&rwlock);
77 
   
 71 
   
78 
    for (i = 0; i < THREADS; i++) {
 72 
    for (i = 0; i < THREADS; i++) {
79 
        thrd = thread_create(reader, NULL, TASK, 0, "reader", false);
 73 
        thrd = thread_create(reader, NULL, TASK, 0, "reader", false);
80 
        if (thrd)
 74 
        if (thrd)
81 
            thread_ready(thrd);
 75 
            thread_ready(thrd);
82 
        else if (!quiet)
 76 
        else
83 
            printf("Could not create reader %d\n", i);
 77 
            TPRINTF("Could not create reader %d\n", i);
84 
    }
 78 
    }
85 
 
 79 
   
86 
    thread_sleep(1);
 80 
    thread_sleep(1);
87 
    rwlock_write_unlock(&rwlock);
 81 
    rwlock_write_unlock(&rwlock);
88 
   
 82 
   
89 
    while (atomic_get(&thread_count) > 0) {
 83 
    while (atomic_get(&thread_count) > 0) {
90 
        if (!quiet)
 - 
 
91 
            printf("Threads left: %ld\n", atomic_get(&thread_count));
 84 
        TPRINTF("Threads left: %ld\n", atomic_get(&thread_count));
92 
        thread_sleep(1);
 85 
        thread_sleep(1);
93 
    }
 86 
    }
94 
   
 87 
   
95 
    return NULL;
 88 
    return NULL;
96 
}
 89 
}