1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131
|
/* Ergo, version 3.8.2, a program for linear scaling electronic structure
* calculations.
* Copyright (C) 2023 Elias Rudberg, Emanuel H. Rubensson, Pawel Salek,
* and Anastasia Kruchinina.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
* Primary academic reference:
* Ergo: An open-source program for linear-scaling electronic structure
* calculations,
* Elias Rudberg, Emanuel H. Rubensson, Pawel Salek, and Anastasia
* Kruchinina,
* SoftwareX 7, 107 (2018),
* <http://dx.doi.org/10.1016/j.softx.2018.03.005>
*
* For further information about Ergo, see <http://www.ergoscf.org>.
*/
/** @file barrier.c implements a pthread-compatible barrier. This is
to be used with older pthread implementations that do not provide
barriers. This implementation is applicable only in simple
cases. Check section 7.1.1 of "Programming with POSIX threads" for
a full-blown implementation. In particular, this implementation
does not check for some error conditions, like destroying the
barrier when some threads wait on it. */
#include <errno.h>
#include <pthread.h>
#include "barrier.h"
int
ergo_barrier_init(ergo_barrier_t * barrier,
const void * attr_ignored,
unsigned int count)
{
int r;
/* This may be called only once for given barrier! */
if( (r=pthread_mutex_init(&barrier->barrierMutex, NULL)) ) return r;
if( (r=pthread_cond_init(&barrier->conditionVar, NULL)) ) return r;
barrier->currCount = barrier->initCount = count;
return 0;
}
int
ergo_barrier_destroy(ergo_barrier_t *barrier)
{
int r;
if( (r=pthread_mutex_destroy(&barrier->barrierMutex)) ) return r;
if( (r=pthread_cond_destroy(&barrier->conditionVar)) ) return r;
return 0;
}
int
ergo_barrier_wait(ergo_barrier_t *barrier)
{
int r, ret;
if( (r=pthread_mutex_lock(&barrier->barrierMutex)) ) return r;
if (barrier->currCount == 0)
return EINVAL;
--barrier->currCount;
if(barrier->currCount == 0) { /* I am the retarded one! :) */
++barrier->cycle;
barrier->currCount = barrier->initCount;
if( (r=pthread_cond_broadcast(&barrier->conditionVar)) ) return r;
ret = PTHREAD_BARRIER_SERIAL_THREAD;
} else {
int curCycle = barrier->cycle;
while(barrier->cycle == curCycle) {
if( (r=pthread_cond_wait(&barrier->conditionVar,
&barrier->barrierMutex)) ) return r;
}
ret = 0;
}
if( (r=pthread_mutex_unlock(&barrier->barrierMutex)) ) return r;
return ret;
}
#ifdef TEST
static void* thr(void *p)
{
ergo_barrier_t *b = (ergo_barrier_t*)p;
pthread_t a;
int r;
a = pthread_self();
r = 1 + (((int)a) >> 12) & 0x03; /* this will hopefully be a bit of
a random number */
printf("%x sleeps for %i s\n", (int)a, r);
sleep(r);
printf("%x waits on barrier\n", (int)a);
r = ergo_barrier_wait(b);
printf("%x continues with r=%d\n", (int)a, r);
return NULL;
}
int main(int argc, char *argv)
{
#define THREAD_COUNT 10
pthread_t pid[THREAD_COUNT];
ergo_barrier_t barrier;
int i;
ergo_barrier_init(&barrier, NULL, THREAD_COUNT);
for(i=0; i<THREAD_COUNT; i++)
pthread_create(&pid[i], NULL, thr, &barrier);
for(i=0; i<THREAD_COUNT; i++) {
pthread_join(pid[i], NULL);
}
ergo_barrier_destroy(&barrier);
return 0;
}
#endif /* TEST */
|