1 2 /* This program is a marginally modified copy of 3 drd/tests/annotate_rwlock.c, 4 5 which was originally written by Bart van Assche. 6 7 Unfortunately due to the need to #include helgrind.h instead of 8 drd.h, it can't be an exact copy. 9 */ 10 11 /** 12 * @file annotate_rwlock.c 13 * 14 * @brief Multithreaded test program that triggers various access patterns 15 * without triggering any race conditions using a reader-writer lock 16 * implemented via busy-waiting. Annotations are used to tell DRD 17 * which higher-level rwlock operations are being performed. 18 */ 19 20 21 #define _GNU_SOURCE 1 22 23 #include <assert.h> 24 #include <pthread.h> 25 #include <stdio.h> 26 #include <unistd.h> /* usleep() */ 27 #include "../../config.h" 28 #include "../../helgrind/helgrind.h" 29 30 31 #ifndef HAVE_BUILTIN_ATOMIC 32 #error Sorry, but this test program can only be compiled by a compiler that\ 33 has built-in functions for atomic memory access. 34 #endif 35 36 37 typedef struct { 38 volatile int locked; 39 int writer_count; 40 int reader_count; 41 } rwlock_t; 42 43 44 static rwlock_t s_rwlock; 45 static int s_counter; 46 47 48 static void rwlock_init(rwlock_t* p) 49 { 50 // DRD_IGNORE_VAR(*p); 51 p->locked = 0; 52 p->writer_count = 0; 53 p->reader_count = 0; 54 ANNOTATE_RWLOCK_CREATE(p); 55 } 56 57 static void rwlock_destroy(rwlock_t* p) 58 { 59 ANNOTATE_RWLOCK_DESTROY(p); 60 assert(p->locked == 0); 61 assert(p->writer_count == 0); 62 assert(p->reader_count == 0); 63 } 64 65 static void rwlock_rdlock(rwlock_t* p) 66 { 67 while (1) 68 { 69 while (__sync_val_compare_and_swap(&p->locked, 0, 1) == 1) 70 ; 71 if (p->writer_count == 0) 72 break; 73 #ifdef __APPLE__ 74 /* Darwin doesn't have an implementation of pthread_yield(). */ 75 usleep(100 * 1000); 76 #else 77 sched_yield(); 78 #endif 79 (void) __sync_fetch_and_sub(&p->locked, 1); 80 } 81 p->reader_count++; 82 assert(p->reader_count >= 0); 83 assert(p->writer_count >= 0); 84 assert(p->reader_count == 0 || p->writer_count == 0); 85 (void) __sync_fetch_and_sub(&p->locked, 1); 86 //ANNOTATE_READERLOCK_ACQUIRED(p); 87 ANNOTATE_RWLOCK_ACQUIRED(p, 0); 88 } 89 90 static void rwlock_wrlock(rwlock_t* p) 91 { 92 while (1) 93 { 94 while (__sync_val_compare_and_swap(&p->locked, 0, 1) == 1) 95 ; 96 if (p->reader_count == 0) 97 break; 98 #ifdef __APPLE__ 99 /* Darwin doesn't have an implementation of pthread_yield(). */ 100 usleep(100 * 1000); 101 #else 102 sched_yield(); 103 #endif 104 (void) __sync_fetch_and_sub(&p->locked, 1); 105 } 106 p->writer_count++; 107 assert(p->reader_count >= 0); 108 assert(p->writer_count >= 0); 109 assert(p->reader_count == 0 || p->writer_count == 0); 110 (void) __sync_fetch_and_sub(&p->locked, 1); 111 // ANNOTATE_WRITERLOCK_ACQUIRED(p); 112 ANNOTATE_RWLOCK_ACQUIRED(p, 1); 113 } 114 115 static void rwlock_unlock(rwlock_t* p) 116 { 117 while (__sync_val_compare_and_swap(&p->locked, 0, 1) == 1) 118 ; 119 if (p->reader_count > 0) 120 { 121 p->reader_count--; 122 //ANNOTATE_READERLOCK_RELEASED(p); 123 ANNOTATE_RWLOCK_RELEASED(p, 0); 124 } 125 else 126 { 127 p->writer_count--; 128 //ANNOTATE_WRITERLOCK_RELEASED(p); 129 ANNOTATE_RWLOCK_RELEASED(p, 1); 130 } 131 assert(p->reader_count >= 0); 132 assert(p->writer_count >= 0); 133 assert(p->reader_count == 0 || p->writer_count == 0); 134 (void) __sync_fetch_and_sub(&p->locked, 1); 135 } 136 137 static void* thread_func(void* arg) 138 { 139 int i; 140 int sum = 0; 141 142 for (i = 0; i < 1000; i++) 143 { 144 rwlock_rdlock(&s_rwlock); 145 sum += s_counter; 146 rwlock_unlock(&s_rwlock); 147 rwlock_wrlock(&s_rwlock); 148 s_counter++; 149 rwlock_unlock(&s_rwlock); 150 } 151 152 return 0; 153 } 154 155 int main(int argc, char** argv) 156 { 157 const int thread_count = 10; 158 pthread_t tid[thread_count]; 159 int i; 160 161 rwlock_init(&s_rwlock); 162 for (i = 0; i < thread_count; i++) 163 { 164 pthread_create(&tid[i], 0, thread_func, 0); 165 } 166 167 for (i = 0; i < thread_count; i++) 168 { 169 pthread_join(tid[i], 0); 170 } 171 rwlock_destroy(&s_rwlock); 172 173 fprintf(stderr, "Finished.\n"); 174 175 return 0; 176 } 177
