protothread/protothread_lock.c at master · LarryRuane/protothread · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
/**************************************************************/
/* PROTOTHREAD_LOCK.C */
/* Copyright (c) 2008, Larry Ruane, LeftHand Networks Inc. */
/* See license.txt */
/* Reader-writer (shared-exclusive) locks */
/**************************************************************/
#include <string.h>
#include <assert.h>

#include "protothread_lock.h"

void
pt_lock_init(pt_lock_t *lock)
{
    memset(lock, 0, sizeof(*lock)) ;
}

/* start as many requests as possible
 */
static void
pt_lock_update(pt_lock_t *lock)
{
    pt_lock_env_t *pt_lock_env ;

    if (lock->waiting == NULL) {
        /* nothing to do */
        return ;
    }

    pt_lock_env = lock->waiting ;
    switch (pt_lock_env->state) {
    case PT_LOCK_READ:
        if (lock->nwriters) {
            assert(lock->nwriters == 1) ;
            return ;
        }
        /* start the first or additional readers */
        while (lock->waiting) {
            pt_lock_env = lock->waiting ;
            if (pt_lock_env->state != PT_LOCK_READ) {
                break ;
            }
            lock->nreaders ++ ;
            lock->waiting = pt_lock_env->next ;
            pt_lock_env->state = PT_LOCK_READING ;
            pt_broadcast(pt_get_pt(pt_lock_env), pt_lock_env) ;
        }
        break ;
    case PT_LOCK_WRITE:
        if (lock->nreaders || lock->nwriters) {
            break ;
        }
        lock->nwriters ++ ;
        lock->waiting = pt_lock_env->next ;
        pt_lock_env->state = PT_LOCK_WRITING ;
        pt_broadcast(pt_get_pt(pt_lock_env), pt_lock_env) ;
        break ;
    case PT_LOCK_READING:
    case PT_LOCK_WRITING:
        /* this request is already active! */
        assert(0) ;
    }
}

pt_t pt_lock_acquire_read_f(pt_lock_env_t *c, pt_lock_t *lock)
{
    pt_resume(c) ;
    c->next = lock->waiting ;
    lock->waiting = c ;
    c->state = PT_LOCK_READ ;
    pt_lock_update(lock) ;
    while (c->state == PT_LOCK_READ) {
        pt_wait(c, c) ;
    }
    assert(c->state == PT_LOCK_READING) ;
    return PT_DONE ;
}

void pt_lock_release_read(pt_lock_env_t *c, pt_lock_t *lock)
{
    assert(c->state == PT_LOCK_READING) ;
    assert(!lock->nwriters) ;
    assert(lock->nreaders) ;
    lock->nreaders -- ;
    pt_lock_update(lock) ;
}

pt_t pt_lock_acquire_write_f(pt_lock_env_t *c, pt_lock_t *lock)
{
    pt_resume(c) ;
    c->next = lock->waiting ;
    lock->waiting = c ;
    c->state = PT_LOCK_WRITE ;
    pt_lock_update(lock) ;
    while (c->state == PT_LOCK_WRITE) {
        pt_wait(c, c) ;
    }
    assert(c->state == PT_LOCK_WRITING) ;
    return PT_DONE ;
}

void pt_lock_release_write(pt_lock_env_t *c, pt_lock_t *lock)
{
    assert(c->state == PT_LOCK_WRITING) ;
    assert(!lock->nreaders) ;
    assert(lock->nwriters == 1) ;
    lock->nwriters -- ;
    pt_lock_update(lock) ;
}