nptl/tst-rwlock9.c

   1 /* Test program for timedout read/write lock functions.
   2    Copyright (C) 2000, 2003 Free Software Foundation, Inc.
   3    Contributed by Ulrich Drepper <drepper@redhat.com>, 2000.
   4
   5    The GNU C Library is free software; you can redistribute it and/or
   6    modify it under the terms of the GNU Lesser General Public License as
   7    published by the Free Software Foundation; either version 2.1 of the
   8    License, or (at your option) any later version.
   9
  10    The GNU C Library is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13    Lesser General Public License for more details.
  14
  15    You should have received a copy of the GNU Lesser General Public
  16    License along with the GNU C Library; see the file COPYING.LIB.  If
  17    not, see <http://www.gnu.org/licenses/>.  */
  18
  19 #include <errno.h>
  20 #include <error.h>
  21 #include <pthread.h>
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <time.h>
  25 #include <unistd.h>
  26 #include <sys/time.h>
  27
  28
  29 #define NWRITERS 15
  30 #define WRITETRIES 10
  31 #define NREADERS 15
  32 #define READTRIES 15
  33
  34 #define TIMEOUT 1000000
  35 #define DELAY   1000000
  36
  37 #ifndef INIT
  38 # define INIT PTHREAD_RWLOCK_WRITER_NONRECURSIVE_INITIALIZER_NP
  39 #endif
  40
  41 static pthread_rwlock_t lock = INIT;
  42
  43
  44 static void *
  45 writer_thread (void *nr)
  46 {
  47   struct timespec ts;
  48   struct timespec delay;
  49   int n;
  50
  51   delay.tv_sec = 0;
  52   delay.tv_nsec = DELAY;
  53
  54   for (n = 0; n < WRITETRIES; ++n)
  55     {
  56       int e;
  57       do
  58         {
  59           struct timeval tv;
  60           (void) gettimeofday (&tv, NULL);
  61           TIMEVAL_TO_TIMESPEC (&tv, &ts);
  62
  63           ts.tv_nsec += 2 * TIMEOUT;
  64           if (ts.tv_nsec >= 1000000000)
  65             {
  66               ts.tv_nsec -= 1000000000;
  67               ++ts.tv_sec;
  68             }
  69
  70           printf ("writer thread %ld tries again\n", (long int) nr);
  71
  72           e = pthread_rwlock_timedwrlock (&lock, &ts);
  73           if (e != 0 && e != ETIMEDOUT)
  74             {
  75               puts ("timedwrlock failed");
  76               exit (1);
  77             }
  78         }
  79       while (e == ETIMEDOUT);
  80
  81       printf ("writer thread %ld succeeded\n", (long int) nr);
  82
  83       nanosleep (&delay, NULL);
  84
  85       if (pthread_rwlock_unlock (&lock) != 0)
  86         {
  87           puts ("unlock for writer failed");
  88           exit (1);
  89         }
  90
  91       printf ("writer thread %ld released\n", (long int) nr);
  92     }
  93
  94   return NULL;
  95 }
  96
  97
  98 static void *
  99 reader_thread (void *nr)
 100 {
 101   struct timespec ts;
 102   struct timespec delay;
 103   int n;
 104
 105   delay.tv_sec = 0;
 106   delay.tv_nsec = DELAY;
 107
 108   for (n = 0; n < READTRIES; ++n)
 109     {
 110       int e;
 111       do
 112         {
 113           struct timeval tv;
 114           (void) gettimeofday (&tv, NULL);
 115           TIMEVAL_TO_TIMESPEC (&tv, &ts);
 116
 117           ts.tv_nsec += TIMEOUT;
 118           if (ts.tv_nsec >= 1000000000)
 119             {
 120               ts.tv_nsec -= 1000000000;
 121               ++ts.tv_sec;
 122             }
 123
 124           printf ("reader thread %ld tries again\n", (long int) nr);
 125
 126           e = pthread_rwlock_timedrdlock (&lock, &ts);
 127           if (e != 0 && e != ETIMEDOUT)
 128             {
 129               puts ("timedrdlock failed");
 130               exit (1);
 131             }
 132         }
 133       while (e == ETIMEDOUT);
 134
 135       printf ("reader thread %ld succeeded\n", (long int) nr);
 136
 137       nanosleep (&delay, NULL);
 138
 139       if (pthread_rwlock_unlock (&lock) != 0)
 140         {
 141           puts ("unlock for reader failed");
 142           exit (1);
 143         }
 144
 145       printf ("reader thread %ld released\n", (long int) nr);
 146     }
 147
 148   return NULL;
 149 }
 150
 151
 152 static int
 153 do_test (void)
 154 {
 155   pthread_t thwr[NWRITERS];
 156   pthread_t thrd[NREADERS];
 157   int n;
 158   void *res;
 159
 160   /* Make standard error the same as standard output.  */
 161   dup2 (1, 2);
 162
 163   /* Make sure we see all message, even those on stdout.  */
 164   setvbuf (stdout, NULL, _IONBF, 0);
 165
 166   for (n = 0; n < NWRITERS; ++n)
 167     if (pthread_create (&thwr[n], NULL, writer_thread,
 168                         (void *) (long int) n) != 0)
 169       {
 170         puts ("writer create failed");
 171         exit (1);
 172       }
 173
 174   for (n = 0; n < NREADERS; ++n)
 175     if (pthread_create (&thrd[n], NULL, reader_thread,
 176                         (void *) (long int) n) != 0)
 177       {
 178         puts ("reader create failed");
 179         exit (1);
 180       }
 181
 182   /* Wait for all the threads.  */
 183   for (n = 0; n < NWRITERS; ++n)
 184     if (pthread_join (thwr[n], &res) != 0)
 185       {
 186         puts ("writer join failed");
 187         exit (1);
 188       }
 189   for (n = 0; n < NREADERS; ++n)
 190     if (pthread_join (thrd[n], &res) != 0)
 191       {
 192         puts ("reader join failed");
 193         exit (1);
 194       }
 195
 196   return 0;
 197 }
 198
 199 #undef TIMEOUT
 200 #define TIMEOUT 30
 201 #define TEST_FUNCTION do_test ()
 202 #include "../test-skeleton.c"