Subversion Repositories HelenOS

Rev

Rev 4348 | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
1 jermar 1
/*
2071 jermar 2
 * Copyright (c) 2001-2004 Jakub Jermar
1 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>
1104 jermar 31
#include <atomic.h>
1 jermar 32
#include <print.h>
33
#include <proc/thread.h>
34
#include <arch/types.h>
35
#include <arch/context.h>
205 jermar 36
#include <context.h>
1 jermar 37
 
38
#include <synch/waitq.h>
39
#include <synch/rwlock.h>
40
#include <synch/synch.h>
623 jermar 41
#include <synch/spinlock.h>
1 jermar 42
 
4348 svoboda 43
#define READERS  50
44
#define WRITERS  50
1 jermar 45
 
2053 decky 46
static atomic_t thread_count;
1 jermar 47
static rwlock_t rwlock;
2029 decky 48
static atomic_t threads_fault;
1 jermar 49
 
2024 decky 50
SPINLOCK_INITIALIZE(rw_lock);
1 jermar 51
 
52
static waitq_t can_start;
53
 
2022 decky 54
static uint32_t seed = 0xdeadbeef;
1 jermar 55
 
2022 decky 56
static uint32_t random(uint32_t max)
1 jermar 57
{
1780 jermar 58
    uint32_t rc;
4348 svoboda 59
 
60
    spinlock_lock(&rw_lock);
1 jermar 61
    rc = seed % max;
4341 svoboda 62
    seed = (((seed << 2) ^ (seed >> 2)) * 487) + rc;
2024 decky 63
    spinlock_unlock(&rw_lock);
1 jermar 64
    return rc;
65
}
66
 
2022 decky 67
static void writer(void *arg)
1 jermar 68
{
69
    int rc, to;
1658 vana 70
    thread_detach(THREAD);
1 jermar 71
    waitq_sleep(&can_start);
4348 svoboda 72
 
1 jermar 73
    to = random(40000);
2053 decky 74
 
4348 svoboda 75
    TPRINTF("cpu%u, tid %" PRIu64 " w+ (%d)\n", CPU->id, THREAD->tid, to);
2053 decky 76
 
1 jermar 77
    rc = rwlock_write_lock_timeout(&rwlock, to);
78
    if (SYNCH_FAILED(rc)) {
4348 svoboda 79
        TPRINTF("cpu%u, tid %" PRIu64 " w!\n", CPU->id, THREAD->tid);
2053 decky 80
        atomic_dec(&thread_count);
1 jermar 81
        return;
2028 decky 82
    }
2053 decky 83
 
4348 svoboda 84
    TPRINTF("cpu%u, tid %" PRIu64 " w=\n", CPU->id, THREAD->tid);
85
 
2029 decky 86
    if (rwlock.readers_in) {
4348 svoboda 87
        TPRINTF("Oops.\n");
2029 decky 88
        atomic_inc(&threads_fault);
2053 decky 89
        atomic_dec(&thread_count);
2029 decky 90
        return;
91
    }
4348 svoboda 92
 
1 jermar 93
    thread_usleep(random(1000000));
4348 svoboda 94
 
2029 decky 95
    if (rwlock.readers_in) {
4348 svoboda 96
        TPRINTF("Oops.\n");
2029 decky 97
        atomic_inc(&threads_fault);
2053 decky 98
        atomic_dec(&thread_count);
2029 decky 99
        return;
100
    }
4348 svoboda 101
 
1 jermar 102
    rwlock_write_unlock(&rwlock);
2053 decky 103
 
4348 svoboda 104
    TPRINTF("cpu%u, tid %" PRIu64 " w-\n", CPU->id, THREAD->tid);
2053 decky 105
    atomic_dec(&thread_count);
1 jermar 106
}
107
 
2022 decky 108
static void reader(void *arg)
1 jermar 109
{
110
    int rc, to;
1658 vana 111
    thread_detach(THREAD);
1 jermar 112
    waitq_sleep(&can_start);
113
 
114
    to = random(2000);
2053 decky 115
 
4348 svoboda 116
    TPRINTF("cpu%u, tid %" PRIu64 " r+ (%d)\n", CPU->id, THREAD->tid, to);
2053 decky 117
 
1 jermar 118
    rc = rwlock_read_lock_timeout(&rwlock, to);
119
    if (SYNCH_FAILED(rc)) {
4348 svoboda 120
        TPRINTF("cpu%u, tid %" PRIu64 " r!\n", CPU->id, THREAD->tid);
2053 decky 121
        atomic_dec(&thread_count);
1 jermar 122
        return;
123
    }
2053 decky 124
 
4348 svoboda 125
    TPRINTF("cpu%u, tid %" PRIu64 " r=\n", CPU->id, THREAD->tid);
2053 decky 126
 
1 jermar 127
    thread_usleep(30000);
128
    rwlock_read_unlock(&rwlock);
2053 decky 129
 
4348 svoboda 130
    TPRINTF("cpu%u, tid %" PRIu64 " r-\n", CPU->id, THREAD->tid);
2053 decky 131
    atomic_dec(&thread_count);
1 jermar 132
}
133
 
4348 svoboda 134
char *test_rwlock4(void)
1 jermar 135
{
136
    context_t ctx;
2053 decky 137
    uint32_t i;
1 jermar 138
 
139
    waitq_initialize(&can_start);
140
    rwlock_initialize(&rwlock);
2029 decky 141
    atomic_set(&threads_fault, 0);
1 jermar 142
 
2053 decky 143
    uint32_t rd = random(7) + 1;
144
    uint32_t wr = random(5) + 1;
145
 
146
    atomic_set(&thread_count, rd + wr);
147
 
2028 decky 148
    thread_t *thrd;
149
 
150
    context_save(&ctx);
4691 svoboda 151
    TPRINTF("sp=%#x, readers_in=%" PRIs "\n", ctx.sp, rwlock.readers_in);
4348 svoboda 152
    TPRINTF("Creating %" PRIu32 " readers\n", rd);
2028 decky 153
 
2053 decky 154
    for (i = 0; i < rd; i++) {
2042 decky 155
        thrd = thread_create(reader, NULL, TASK, 0, "reader", false);
2028 decky 156
        if (thrd)
157
            thread_ready(thrd);
4348 svoboda 158
        else
159
            TPRINTF("Could not create reader %" PRIu32 "\n", i);
2028 decky 160
    }
2053 decky 161
 
4348 svoboda 162
    TPRINTF("Creating %" PRIu32 " writers\n", wr);
163
 
2053 decky 164
    for (i = 0; i < wr; i++) {
2042 decky 165
        thrd = thread_create(writer, NULL, TASK, 0, "writer", false);
2028 decky 166
        if (thrd)
167
            thread_ready(thrd);
4348 svoboda 168
        else
169
            TPRINTF("Could not create writer %" PRIu32 "\n", i);
2028 decky 170
    }
171
 
172
    thread_usleep(20000);
173
    waitq_wakeup(&can_start, WAKEUP_ALL);
174
 
2053 decky 175
    while (atomic_get(&thread_count) > 0) {
4348 svoboda 176
        TPRINTF("Threads left: %ld\n", atomic_get(&thread_count));
2053 decky 177
        thread_sleep(1);
178
    }
179
 
2029 decky 180
    if (atomic_get(&threads_fault) == 0)
181
        return NULL;
182
 
183
    return "Test failed";
1 jermar 184
}