← Back to branch summary

~ubuntu-branches/ubuntu/warty/openafs/warty

« back to all changes in this revision

Viewing changes to src/WINNT/client_osi/basic.c

  • Committer: Bazaar Package Importer
  • Author(s): Sam Hartman
  • Date: 2004-01-10 16:37:33 UTC
  • Revision ID: james.westby@ubuntu.com-20040110163733-jvr0n1uahshlb1uu
Tags: upstream-1.2.11
Import upstream version 1.2.11

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/WINNT/client_osi/basic.c
 
1
/* 
 
2
 * Copyright (C) 1998, 1989 Transarc Corporation - All rights reserved
 
3
 *
 
4
 * (C) COPYRIGHT IBM CORPORATION 1987, 1988
 
5
 * LICENSED MATERIALS - PROPERTY OF IBM
 
6
 *
 
7
 */
 
8
 
 
9
/* Copyright (C) 1994 Cazamar Systems, Inc. */
 
10
 
 
11
 
 
12
#include <afs/param.h>
 
13
#include <afs/stds.h>
 
14
 
 
15
#include "windows.h"
 
16
#include <string.h>
 
17
#include "main.h"
 
18
#include "basic.h"
 
19
#include "osi.h"
 
20
 
 
21
#define OSI_MOD1LOOPS   15000
 
22
#define OSI_MOD2LOOPS   10000
 
23
 
 
24
/* global variables for the test */
 
25
osi_mutex_t main_aMutex;        /* mutex controlling access to a */
 
26
long a;                         /* variable a */
 
27
 
 
28
osi_rwlock_t main_bRWLock;      /* rwlock controlling access to b */
 
29
long b;                         /* variable b itself */
 
30
 
 
31
osi_rwlock_t main_doneRWLock;   /* lock for done */
 
32
int done;                       /* count of done dudes */
 
33
 
 
34
osi_log_t *main_logp;           /* global log */
 
35
 
 
36
/* unlocked stat counters */
 
37
long m1Loops;
 
38
long m2Loops;
 
39
long s1Loops;
 
40
long s2Loops;
 
41
long s2Events;
 
42
 
 
43
unsigned long main_Mod1(void *parm)
 
44
{
 
45
        long i;
 
46
        for(i=0; i<OSI_MOD1LOOPS; i++) {
 
47
                lock_ObtainMutex(&main_aMutex);
 
48
                osi_Log0(main_logp, "mod1");
 
49
                lock_ObtainWrite(&main_bRWLock);
 
50
                a -= 52;
 
51
                Sleep(0);
 
52
                b += 52;
 
53
                osi_assert(a+b == 100);
 
54
                Sleep(0);
 
55
                lock_ReleaseWrite(&main_bRWLock);
 
56
                Sleep(0);
 
57
                lock_ReleaseMutex(&main_aMutex);
 
58
                Sleep(0);
 
59
                m1Loops = i;
 
60
                osi_Log1(main_logp, "mod1 done, %d", m1Loops);
 
61
        }
 
62
        lock_ObtainWrite(&main_doneRWLock);
 
63
        done++;
 
64
        Sleep(0);
 
65
        lock_ReleaseWrite(&main_doneRWLock);
 
66
        return 0;
 
67
}
 
68
 
 
69
unsigned long main_Mod2(void *parm)
 
70
{
 
71
        long i;
 
72
        for(i=0; i<OSI_MOD2LOOPS; i++) {
 
73
                osi_Log0(main_logp, "mod2");
 
74
                lock_ObtainMutex(&main_aMutex);
 
75
                lock_ObtainWrite(&main_bRWLock);
 
76
                a += 3;
 
77
                Sleep(0);
 
78
                b -= 3;
 
79
                osi_assert(a+b == 100);
 
80
                Sleep(0);
 
81
                lock_ReleaseWrite(&main_bRWLock);
 
82
                Sleep(0);
 
83
                lock_ReleaseMutex(&main_aMutex);
 
84
                Sleep(0);
 
85
                m2Loops = i;
 
86
                osi_Log4(main_logp, "mod2 done, %d %d %d %d", m2Loops, 2, 3, 4);
 
87
        }
 
88
        lock_ObtainWrite(&main_doneRWLock);
 
89
        done++;
 
90
        Sleep(0);
 
91
        lock_ReleaseWrite(&main_doneRWLock);
 
92
        return 0;
 
93
}
 
94
 
 
95
unsigned long main_Scan1(unsigned long parm)
 
96
{
 
97
        while (1) {
 
98
                osi_Log0(main_logp, "scan1");
 
99
                /* check to see if we're done */
 
100
                lock_ObtainRead(&main_doneRWLock);
 
101
                lock_AssertRead(&main_doneRWLock);
 
102
                if (done >= 2) break;
 
103
                lock_ReleaseRead(&main_doneRWLock);
 
104
 
 
105
                /* check state for consistency */
 
106
                lock_ObtainMutex(&main_aMutex);
 
107
                lock_AssertMutex(&main_aMutex);
 
108
                Sleep(0);
 
109
                lock_ObtainRead(&main_bRWLock);
 
110
                Sleep(0);
 
111
                osi_assert(a+b == 100);
 
112
                lock_ReleaseRead(&main_bRWLock);
 
113
                Sleep(0);
 
114
                lock_ReleaseMutex(&main_aMutex);
 
115
 
 
116
                /* get a read lock here to test people getting stuck on RW lock alone */
 
117
                lock_ObtainRead(&main_bRWLock);
 
118
                Sleep(0);
 
119
                lock_ReleaseRead(&main_bRWLock);
 
120
                
 
121
                s1Loops++;
 
122
                
 
123
                osi_Log2(main_logp, "scan1 done %d %d", s1Loops, 2);
 
124
        }
 
125
        lock_ReleaseRead(&main_doneRWLock);
 
126
        lock_ObtainWrite(&main_doneRWLock);
 
127
        lock_AssertWrite(&main_doneRWLock);
 
128
        done++;
 
129
        lock_ReleaseWrite(&main_doneRWLock);
 
130
        return 0;
 
131
}
 
132
 
 
133
unsigned long main_Scan2(unsigned long parm)
 
134
{
 
135
        while (1) {
 
136
                osi_Log0(main_logp, "scan2");
 
137
                /* check to see if we're done */
 
138
                lock_ObtainRead(&main_doneRWLock);
 
139
                lock_AssertAny(&main_doneRWLock);
 
140
                if (done >= 2) break;
 
141
                lock_ReleaseRead(&main_doneRWLock);
 
142
 
 
143
                /* check state for consistency without locks */
 
144
                if (a+b != 100) s2Events++;
 
145
 
 
146
                /* and record that we went around again */
 
147
                s2Loops++;
 
148
 
 
149
                /* give others a chance */
 
150
                Sleep(0);
 
151
                osi_Log3(main_logp, "scan2 done %d %d %d", s2Loops, 2, 3);
 
152
        }
 
153
        lock_ReleaseRead(&main_doneRWLock);
 
154
        lock_ObtainWrite(&main_doneRWLock);
 
155
        lock_AssertAny(&main_doneRWLock);
 
156
        done++;
 
157
        lock_ReleaseWrite(&main_doneRWLock);
 
158
        return 0;
 
159
}
 
160
 
 
161
main_BasicTest(HANDLE hWnd)
 
162
{
 
163
        long mod1ID;
 
164
        long mod2ID;
 
165
        long scan1ID;
 
166
        long scan2ID;
 
167
        HANDLE mod1Handle;
 
168
        HANDLE mod2Handle;
 
169
        HANDLE scan1Handle;
 
170
        HANDLE scan2Handle;
 
171
        long localDone;
 
172
 
 
173
        osi_Init();
 
174
        
 
175
        if (main_logp == NULL) {
 
176
                main_logp = osi_LogCreate("basic", 0);
 
177
                osi_LogEnable(main_logp);
 
178
                osi_SetStatLog(main_logp);
 
179
        }
 
180
        
 
181
        /* create three processes, two modifiers and one scanner.  The scanner
 
182
         * checks that the basic invariants are being maintained, while the
 
183
         * modifiers modify the global variables, maintaining certain invariants
 
184
         * by using locks.
 
185
         *
 
186
         * The invariant is that global variables a and b total 100.
 
187
         */
 
188
        a = 100;
 
189
        b = 0;
 
190
        done = 0;
 
191
        
 
192
        lock_InitializeRWLock(&main_doneRWLock, "done lock");
 
193
        lock_InitializeRWLock(&main_bRWLock, "b lock");
 
194
        lock_InitializeMutex(&main_aMutex, "a mutex");
 
195
 
 
196
        mod1Handle = CreateThread((SECURITY_ATTRIBUTES *) 0, 0,
 
197
                (LPTHREAD_START_ROUTINE) main_Mod1, 0, 0, &mod1ID);
 
198
        if (mod1Handle == NULL) return -1;
 
199
 
 
200
        mod2Handle = CreateThread((SECURITY_ATTRIBUTES *) 0, 0,
 
201
                (LPTHREAD_START_ROUTINE) main_Mod2, 0, 0, &mod2ID);
 
202
        if (mod2Handle == NULL) return -2;
 
203
 
 
204
        scan1Handle = CreateThread((SECURITY_ATTRIBUTES *) 0, 0,
 
205
                (LPTHREAD_START_ROUTINE) main_Scan1, 0, 0, &scan1ID);
 
206
        if (scan1Handle== NULL) return -2;
 
207
 
 
208
        scan2Handle = CreateThread((SECURITY_ATTRIBUTES *) 0, 0,
 
209
                (LPTHREAD_START_ROUTINE) main_Scan2, 0, 0, &scan2ID);
 
210
        if (scan2Handle== NULL) return -2;
 
211
 
 
212
        /* start running check daemon */
 
213
        while (1) {
 
214
                Sleep(1000);
 
215
                wsprintf(main_screenText[1], "Mod1 iteration %d", m1Loops);
 
216
                wsprintf(main_screenText[2], "Mod2 iteration %d", m2Loops);
 
217
                wsprintf(main_screenText[3], "Scan1 iteration %d", s1Loops);
 
218
                wsprintf(main_screenText[4], "Scan2 iteration %d, %d opportunites seen",
 
219
                        s2Loops, s2Events);
 
220
                main_ForceDisplay(hWnd);
 
221
 
 
222
                /* copy out count of # of dudes finished */
 
223
                lock_ObtainRead(&main_doneRWLock);
 
224
                localDone = done;
 
225
                lock_ReleaseRead(&main_doneRWLock);
 
226
 
 
227
                /* right now, we're waiting for 4 threads */
 
228
                if (localDone == 4) break;
 
229
        }
 
230
        
 
231
        wsprintf(main_screenText[0], "Test done.");
 
232
        main_ForceDisplay(hWnd);
 
233
 
 
234
        /* done, release and finalize all locks */
 
235
        lock_FinalizeRWLock(&main_doneRWLock);
 
236
        lock_FinalizeRWLock(&main_bRWLock);
 
237
        lock_FinalizeMutex(&main_aMutex);
 
238
 
 
239
        /* finally clean up thread handles */
 
240
        CloseHandle(mod1Handle);
 
241
        CloseHandle(mod2Handle);
 
242
        CloseHandle(scan1Handle);
 
243
        CloseHandle(scan2Handle);
 
244
 
 
245
        return 0;
 
246
}