nptl/tst-cond10.c

   1 /* Copyright (C) 2003-2018 Free Software Foundation, Inc.
   2    This file is part of the GNU C Library.
   3    Contributed by Ulrich Drepper <drepper@redhat.com>, 2003.
   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
   7    License as published by the Free Software Foundation; either
   8    version 2.1 of the 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; if not, see
  17    <http://www.gnu.org/licenses/>.  */
  18
  19 #include <error.h>
  20 #include <pthread.h>
  21 #include <stdbool.h>
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24
  25
  26 #define N 10
  27 #define ROUNDS 100
  28
  29 static pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
  30 static pthread_mutex_t mut = PTHREAD_MUTEX_INITIALIZER;
  31 static pthread_barrier_t bN1;
  32 static pthread_barrier_t b2;
  33
  34
  35 static void *
  36 tf (void *p)
  37 {
  38   if (pthread_mutex_lock (&mut) != 0)
  39     {
  40       puts ("child: 1st mutex_lock failed");
  41       exit (1);
  42     }
  43
  44   int e = pthread_barrier_wait (&b2);
  45   if (e != 0 && e != PTHREAD_BARRIER_SERIAL_THREAD)
  46     {
  47       puts ("child: 1st barrier_wait failed");
  48       exit (1);
  49     }
  50
  51   if (pthread_cond_wait (&cond, &mut) != 0)
  52     {
  53       puts ("child: cond_wait failed");
  54       exit (1);
  55     }
  56
  57   if (pthread_mutex_unlock (&mut) != 0)
  58     {
  59       puts ("child: mutex_unlock failed");
  60       exit (1);
  61     }
  62
  63   e = pthread_barrier_wait (&bN1);
  64   if (e != 0 && e != PTHREAD_BARRIER_SERIAL_THREAD)
  65     {
  66       puts ("child: 2nd barrier_wait failed");
  67       exit (1);
  68     }
  69
  70   return NULL;
  71 }
  72
  73
  74 static int
  75 do_test (void)
  76 {
  77   if (pthread_barrier_init (&bN1, NULL, N + 1) != 0)
  78     {
  79       puts ("barrier_init failed");
  80       exit (1);
  81     }
  82
  83   if (pthread_barrier_init (&b2, NULL, 2) != 0)
  84     {
  85       puts ("barrier_init failed");
  86       exit (1);
  87     }
  88
  89   pthread_attr_t at;
  90
  91   if (pthread_attr_init (&at) != 0)
  92     {
  93       puts ("attr_init failed");
  94       return 1;
  95     }
  96
  97   if (pthread_attr_setstacksize (&at, 1 * 1024 * 1024) != 0)
  98     {
  99       puts ("attr_setstacksize failed");
 100       return 1;
 101     }
 102
 103   int r;
 104   for (r = 0; r < ROUNDS; ++r)
 105     {
 106       printf ("round %d\n", r + 1);
 107
 108       int i;
 109       pthread_t th[N];
 110       for (i = 0; i < N; ++i)
 111         {
 112           if (pthread_create (&th[i], &at, tf, NULL) != 0)
 113             {
 114               puts ("create failed");
 115               exit (1);
 116             }
 117
 118           int e = pthread_barrier_wait (&b2);
 119           if (e != 0 && e != PTHREAD_BARRIER_SERIAL_THREAD)
 120             {
 121               puts ("parent: 1st barrier_wait failed");
 122               exit (1);
 123             }
 124         }
 125
 126       if (pthread_mutex_lock (&mut) != 0)
 127         {
 128           puts ("parent: mutex_lock failed");
 129           exit (1);
 130         }
 131       if (pthread_mutex_unlock (&mut) != 0)
 132         {
 133           puts ("parent: mutex_unlock failed");
 134           exit (1);
 135         }
 136
 137       /* N single signal calls.  Without locking.  This tests that no
 138          signal gets lost.  */
 139       for (i = 0; i < N; ++i)
 140         if (pthread_cond_signal (&cond) != 0)
 141           {
 142             puts ("cond_signal failed");
 143             exit (1);
 144           }
 145
 146       int e = pthread_barrier_wait (&bN1);
 147       if (e != 0 && e != PTHREAD_BARRIER_SERIAL_THREAD)
 148         {
 149           puts ("parent: 2nd barrier_wait failed");
 150           exit (1);
 151         }
 152
 153       for (i = 0; i < N; ++i)
 154         if (pthread_join (th[i], NULL) != 0)
 155           {
 156             puts ("join failed");
 157             exit (1);
 158           }
 159     }
 160
 161   if (pthread_attr_destroy (&at) != 0)
 162     {
 163       puts ("attr_destroy failed");
 164       return 1;
 165     }
 166
 167   return 0;
 168 }
 169
 170
 171 #define TEST_FUNCTION do_test ()
 172 #include "../test-skeleton.c"