tests: partition name to id function tests
[openafs.git] / tests / rx / event-t.c
1 /* A simple test of the rx event layer */
2
3 #include <afsconfig.h>
4 #include <afs/param.h>
5
6 #include <roken.h>
7 #include <pthread.h>
8
9 #include <tests/tap/basic.h>
10
11 #include "rx/rx_event.h"
12 #include "rx/rx_clock.h"
13
14 #define NUMEVENTS 10000
15
16 /* Mutexes and condvars for the scheduler */
17 static int rescheduled = 0;
18 static pthread_mutex_t eventMutex;
19 static pthread_cond_t eventCond;
20
21 /* Mutexes and condvars for the event list */
22
23 static pthread_mutex_t eventListMutex;
24 struct testEvent {
25     struct rxevent *event;
26     int fired;
27     int cancelled;
28 };
29
30 static struct testEvent events[NUMEVENTS];
31
32 static void
33 reschedule(void)
34 {
35     pthread_mutex_lock(&eventMutex);
36     pthread_cond_signal(&eventCond);
37     rescheduled = 1;
38     pthread_mutex_unlock(&eventMutex);
39     return;
40 }
41
42 static void
43 eventSub(struct rxevent *event, void *arg, void *arg1, int arg2)
44 {
45     struct testEvent *evrecord = arg;
46
47     /*
48      * The eventListMutex protects the contents of fields in the global
49      * 'events' array, including reading/writing evrecord->event.
50      * However, in this test code, we have an additional guarantee that
51      * the events array will remain allocated for the duration of the test,
52      * and as such that it is safe to dereference |evrecord| at all.  In real
53      * application code where the passed args are pointers to allocated data
54      * structures with finite lifetime, the programmer must ensure that the
55      * firing event can safely access these fields (i.e., that the object
56      * lifetime does not permit the object to be destroyed while an event
57      * pointing to it is outstanding or in progress).  The simplest way to
58      * do this (for reference counted objects) is to have the pending event
59      * hold a reference on the pointed-to object. This reference should be
60      * dropped at the end of the event handler or if the event is
61      * (successfully!) cancelled before it fires.  Other strategies are also
62      * possible, such as deferring object destruction until after all pending
63      * events have run or gotten cancelled, noting that the calling code must
64      * take care to allow the event handler to obtain any needed locks and
65      * avoid deadlock.
66      */
67     pthread_mutex_lock(&eventListMutex);
68     if (evrecord->event != NULL)
69         rxevent_Put(&evrecord->event);
70     evrecord->event = NULL;
71     evrecord->fired = 1;
72     pthread_mutex_unlock(&eventListMutex);
73     return;
74 }
75
76 static void
77 reportSub(struct rxevent *event, void *arg, void *arg1, int arg2)
78 {
79     printf("Event fired\n");
80 }
81
82 static void *
83 eventHandler(void *dummy) {
84     struct timespec nextEvent;
85     struct clock cv;
86     struct clock next;
87
88     pthread_mutex_lock(&eventMutex);
89     while (1) {
90         pthread_mutex_unlock(&eventMutex);
91
92         next.sec = 30;
93         next.usec = 0;
94         clock_GetTime(&cv);
95         rxevent_RaiseEvents(&next);
96
97         pthread_mutex_lock(&eventMutex);
98
99         /* If we were rescheduled whilst running the event queue,
100          * process the queue again */
101         if (rescheduled) {
102             rescheduled = 0;
103             continue;
104         }
105
106         clock_Add(&cv, &next);
107         nextEvent.tv_sec = cv.sec;
108         nextEvent.tv_nsec = cv.usec * 1000;
109         pthread_cond_timedwait(&eventCond, &eventMutex, &nextEvent);
110     }
111     pthread_mutex_unlock(&eventMutex);
112
113     return NULL;
114 }
115
116 int
117 main(void)
118 {
119     int when, counter, fail, fired, cancelled;
120     struct clock now, eventTime;
121     struct rxevent *event;
122     pthread_t handler;
123
124     plan(8);
125
126     pthread_mutex_init(&eventMutex, NULL);
127     pthread_cond_init(&eventCond, NULL);
128
129     memset(events, 0, sizeof(events));
130     pthread_mutex_init(&eventListMutex, NULL);
131
132     /* Start up the event system */
133     rxevent_Init(20, reschedule);
134     ok(1, "Started event subsystem");
135
136     clock_GetTime(&now);
137     /* Test for a problem when there is only a single event in the tree */
138     event = rxevent_Post(&now, &now, reportSub, NULL, NULL, 0);
139     ok(event != NULL, "Created a single event");
140     ok(rxevent_Cancel(&event), "Cancelled a single event");
141     rxevent_RaiseEvents(&now);
142     ok(1, "RaiseEvents happened without error");
143
144     ok(pthread_create(&handler, NULL, eventHandler, NULL) == 0,
145        "Created handler thread");
146
147     /* Add a number of random events to fire over the next 3 seconds, but front-loaded
148      * a bit so that we can exercise the cancel/fire race path. */
149
150     for (counter = 0; counter < NUMEVENTS; counter++) {
151         when = random() % 4000;
152         /* Put 1/4 of events "right away" so we cancel them as they fire */
153         if (when >= 3000)
154             when = random() % 5;
155         clock_GetTime(&now);
156         eventTime = now;
157         clock_Addmsec(&eventTime, when);
158         pthread_mutex_lock(&eventListMutex);
159         events[counter].event
160             = rxevent_Post(&eventTime, &now, eventSub, &events[counter], NULL, 0);
161
162         /* A 10% chance that we will schedule another event at the same time */
163         if (counter < (NUMEVENTS - 1) && random() % 10 == 0) {
164              counter++;
165              events[counter].event
166                  = rxevent_Post(&eventTime, &now, eventSub, &events[counter],
167                                 NULL, 0);
168         }
169
170         /* A 25% chance that we will cancel a random event */
171         if (random() % 4 == 0) {
172             int victim = random() % counter;
173
174             if (rxevent_Cancel(&events[victim].event))
175                 events[victim].cancelled = 1;
176         }
177         pthread_mutex_unlock(&eventListMutex);
178     }
179
180     ok(1, "Added %d events", NUMEVENTS);
181
182     sleep(3);
183
184     fired = 0;
185     cancelled = 0;
186     fail = 0;
187     for (counter = 0; counter < NUMEVENTS; counter++) {
188         if (events[counter].fired)
189             fired++;
190         if (events[counter].cancelled)
191             cancelled++;
192         if (events[counter].cancelled && events[counter].fired)
193             fail = 1;
194     }
195     ok(!fail, "Didn't fire any cancelled events");
196     ok(fired+cancelled == NUMEVENTS,
197         "Number of fired and cancelled events sum to correct total");
198
199     return 0;
200 }