sysdeps/pthread/tst-cond10.c

   1 /* Copyright (C) 2003-2023 Free Software Foundation, Inc.
   2    This file is part of the GNU C Library.
   3
   4    The GNU C Library is free software; you can redistribute it and/or
   5    modify it under the terms of the GNU Lesser General Public
   6    License as published by the Free Software Foundation; either
   7    version 2.1 of the License, or (at your option) any later version.
   8
   9    The GNU C Library is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12    Lesser General Public License for more details.
  13
  14    You should have received a copy of the GNU Lesser General Public
  15    License along with the GNU C Library; if not, see
  16    <https://www.gnu.org/licenses/>.  */
  17
  18 #include <error.h>
  19 #include <pthread.h>
  20 #include <stdbool.h>
  21 #include <stdio.h>
  22 #include <stdlib.h>
  23
  24
  25 #define N 10
  26 #define ROUNDS 100
  27
  28 static pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
  29 static pthread_mutex_t mut = PTHREAD_MUTEX_INITIALIZER;
  30 static pthread_barrier_t bN1;
  31 static pthread_barrier_t b2;
  32
  33
  34 static void *
  35 tf (void *p)
  36 {
  37   if (pthread_mutex_lock (&mut) != 0)
  38     {
  39       puts ("child: 1st mutex_lock failed");
  40       exit (1);
  41     }
  42
  43   int e = pthread_barrier_wait (&b2);
  44   if (e != 0 && e != PTHREAD_BARRIER_SERIAL_THREAD)
  45     {
  46       puts ("child: 1st barrier_wait failed");
  47       exit (1);
  48     }
  49
  50   if (pthread_cond_wait (&cond, &mut) != 0)
  51     {
  52       puts ("child: cond_wait failed");
  53       exit (1);
  54     }
  55
  56   if (pthread_mutex_unlock (&mut) != 0)
  57     {
  58       puts ("child: mutex_unlock failed");
  59       exit (1);
  60     }
  61
  62   e = pthread_barrier_wait (&bN1);
  63   if (e != 0 && e != PTHREAD_BARRIER_SERIAL_THREAD)
  64     {
  65       puts ("child: 2nd barrier_wait failed");
  66       exit (1);
  67     }
  68
  69   return NULL;
  70 }
  71
  72
  73 static int
  74 do_test (void)
  75 {
  76   if (pthread_barrier_init (&bN1, NULL, N + 1) != 0)
  77     {
  78       puts ("barrier_init failed");
  79       exit (1);
  80     }
  81
  82   if (pthread_barrier_init (&b2, NULL, 2) != 0)
  83     {
  84       puts ("barrier_init failed");
  85       exit (1);
  86     }
  87
  88   pthread_attr_t at;
  89
  90   if (pthread_attr_init (&at) != 0)
  91     {
  92       puts ("attr_init failed");
  93       return 1;
  94     }
  95
  96   if (pthread_attr_setstacksize (&at, 1 * 1024 * 1024) != 0)
  97     {
  98       puts ("attr_setstacksize failed");
  99       return 1;
 100     }
 101
 102   int r;
 103   for (r = 0; r < ROUNDS; ++r)
 104     {
 105       printf ("round %d\n", r + 1);
 106
 107       int i;
 108       pthread_t th[N];
 109       for (i = 0; i < N; ++i)
 110         {
 111           if (pthread_create (&th[i], &at, tf, NULL) != 0)
 112             {
 113               puts ("create failed");
 114               exit (1);
 115             }
 116
 117           int e = pthread_barrier_wait (&b2);
 118           if (e != 0 && e != PTHREAD_BARRIER_SERIAL_THREAD)
 119             {
 120               puts ("parent: 1st barrier_wait failed");
 121               exit (1);
 122             }
 123         }
 124
 125       if (pthread_mutex_lock (&mut) != 0)
 126         {
 127           puts ("parent: mutex_lock failed");
 128           exit (1);
 129         }
 130       if (pthread_mutex_unlock (&mut) != 0)
 131         {
 132           puts ("parent: mutex_unlock failed");
 133           exit (1);
 134         }
 135
 136       /* N single signal calls.  Without locking.  This tests that no
 137          signal gets lost.  */
 138       for (i = 0; i < N; ++i)
 139         if (pthread_cond_signal (&cond) != 0)
 140           {
 141             puts ("cond_signal failed");
 142             exit (1);
 143           }
 144
 145       int e = pthread_barrier_wait (&bN1);
 146       if (e != 0 && e != PTHREAD_BARRIER_SERIAL_THREAD)
 147         {
 148           puts ("parent: 2nd barrier_wait failed");
 149           exit (1);
 150         }
 151
 152       for (i = 0; i < N; ++i)
 153         if (pthread_join (th[i], NULL) != 0)
 154           {
 155             puts ("join failed");
 156             exit (1);
 157           }
 158     }
 159
 160   if (pthread_attr_destroy (&at) != 0)
 161     {
 162       puts ("attr_destroy failed");
 163       return 1;
 164     }
 165
 166   return 0;
 167 }
 168
 169
 170 #define TEST_FUNCTION do_test ()
 171 #include "../test-skeleton.c"