test_urcu.c

   1 #include <stdio.h>
   2 #include <pthread.h>
   3 #include <stdlib.h>
   4 #include <string.h>
   5 #include <sys/types.h>
   6 #include <sys/wait.h>
   7 #include <unistd.h>
   8 #include <stdio.h>
   9 #include <assert.h>
  10 #include "urcu.h"
  11
  12 struct test_array {
  13         int a;
  14         int b;
  15         char c[200];
  16 };
  17
  18 static struct test_array *test_rcu_pointer;
  19
  20 #define NR_READ 10
  21 #define NR_WRITE 9
  22
  23
  24 void *thr_reader(void *arg)
  25 {
  26         int qparity, i, j;
  27         struct test_array *local_ptr;
  28
  29         printf("thread %s, thread id : %lu, pid %lu\n",
  30                         "reader", pthread_self(), getpid());
  31         sleep(2);
  32
  33         urcu_register_thread();
  34
  35         for (i = 0; i < 1000; i++) {
  36                 for (j = 0; j < 100000000; j++) {
  37                         qparity = rcu_read_lock();
  38                         local_ptr = rcu_dereference(test_rcu_pointer);
  39                         if (local_ptr) {
  40                                 assert(local_ptr->a == 8);
  41                                 assert(local_ptr->b == 12);
  42                                 assert(local_ptr->c[55] == 2);
  43                         }
  44                         rcu_read_unlock(qparity);
  45                 }
  46         }
  47
  48         urcu_unregister_thread();
  49
  50         return ((void*)1);
  51
  52 }
  53
  54 void *thr_writer(void *arg)
  55 {
  56         int i;
  57         struct test_array *new, *old;
  58
  59         printf("thread %s, thread id : %lu, pid %lu\n",
  60                         "writer", pthread_self(), getpid());
  61         sleep(2);
  62
  63         for (i = 0; i < 100000; i++) {
  64                 rcu_write_lock();
  65                 new = malloc(sizeof(struct test_array));
  66                 old = test_rcu_pointer;
  67                 if (old) {
  68                         assert(old->a == 8);
  69                         assert(old->b == 12);
  70                         assert(old->c[55] == 2);
  71                 }
  72                 new->a = 8;
  73                 new->b = 12;
  74                 new->c[55] = 2;
  75                 old = urcu_publish_content(&test_rcu_pointer, new);
  76                 rcu_write_unlock();
  77                 /* can be done after unlock */
  78                 if (old) {
  79                         old->a = 0;
  80                         old->b = 0;
  81                         old->c[55] = 0;
  82                 }
  83                 free(old);
  84                 usleep(1);
  85         }
  86
  87         return ((void*)2);
  88 }
  89
  90 int main()
  91 {
  92         int err;
  93         pthread_t tid_reader[NR_READ], tid_writer[NR_WRITE];
  94         void *tret;
  95         int i;
  96
  97         for (i = 0; i < NR_READ; i++) {
  98                 err = pthread_create(&tid_reader[i], NULL, thr_reader, NULL);
  99                 if (err != 0)
 100                         exit(1);
 101         }
 102         for (i = 0; i < NR_WRITE; i++) {
 103                 err = pthread_create(&tid_writer[i], NULL, thr_writer, NULL);
 104                 if (err != 0)
 105                         exit(1);
 106         }
 107
 108         sleep(10);
 109
 110         for (i = 0; i < NR_WRITE; i++) {
 111                 err = pthread_join(tid_reader[i], &tret);
 112                 if (err != 0)
 113                         exit(1);
 114         }
 115         for (i = 0; i < NR_WRITE; i++) {
 116                 err = pthread_join(tid_writer[i], &tret);
 117                 if (err != 0)
 118                         exit(1);
 119         }
 120
 121         return 0;
 122 }