| // (C) Copyright Princeton University 2009 |
| // Written by Christian Bienia |
| // Implementation of pthreads-style barriers based on pthread mutexes |
| // Use to replace pthread barriers on machines that have pthreads but not pthread barriers |
| |
| #ifndef __PARSEC_BARRIER_H_ |
| #define __PARSEC_BARRIER_H_ 1 |
| |
| #include <pthread.h> |
| #include <errno.h> |
| |
| |
| |
| //This code functions as a drop-in replacement for pthread barriers. |
| //Read the documentation for the corresponding pthread_barrier* calls |
| //to understand how this code is used (not all pthread features are implemented) |
| |
| //If defined then macros will be used to redefine the relevant pthread_barrier* |
| //symbols to the equivalent parsec_barrier* symbols. This will make the host code |
| //use the parsec_barrier* replacement calls without the need to touch the source |
| //code (other than including this header file), but it makes it harder to understand |
| //what is going on |
| #define ENABLE_AUTOMATIC_DROPIN |
| |
| //Whether to allow the use of spinning. If enabled then the barrier implementation |
| //will busy-wait on a flag first. After a pre-determined amount of time has passed |
| //without any success it will fall back to waiting on a condition variable. Spinning |
| //will result in unsynchronized memory accesses to the flag. |
| #define ENABLE_SPIN_BARRIER |
| |
| |
| |
| #ifdef ENABLE_AUTOMATIC_DROPIN |
| //Redefine all calls to pthread_barrier* functions in host code by using macros |
| #undef pthread_barrier_t |
| #undef pthread_barrierattr_t |
| #undef pthread_barrier_init |
| #undef pthread_barrier_destroy |
| #undef pthread_barrierattr_init |
| #undef pthread_barrierattr_destroy |
| #undef pthread_barrierattr_getpshared |
| #undef pthread_barrierattr_setpshared |
| #undef pthread_barrier_wait |
| |
| #define pthread_barrier_t parsec_barrier_t |
| #define pthread_barrierattr_t parsec_barrier_t |
| #define pthread_barrier_init(b, a, c) parsec_barrier_init(b, a, c) |
| #define pthread_barrier_destroy(b) parsec_barrier_destroy(b) |
| #define pthread_barrierattr_init(a) parsec_barrierattr_init(a) |
| #define pthread_barrierattr_destroy(a) parsec_barrierattr_destroy(a) |
| #define pthread_barrierattr_getpshared(a) parsec_barrierattr_getpshared(a) |
| #define pthread_barrierattr_setpshared(a) parsec_barrierattr_setpshared(a) |
| #define pthread_barrier_wait(b) parsec_barrier_wait(b) |
| |
| //Do the same with constants |
| #undef PTHREAD_BARRIER_SERIAL_THREAD |
| #undef PTHREAD_PROCESS_SHARED |
| #undef PTHREAD_PROCESS_PRIVATE |
| |
| #define PTHREAD_BARRIER_SERIAL_THREAD PARSEC_BARRIER_SERIAL_THREAD |
| #define PTHREAD_PROCESS_SHARED PARSEC_PROCESS_SHARED |
| #define PTHREAD_PROCESS_PRIVATE PARSEC_PROCESS_PRIVATE |
| #endif //ENABLE_AUTOMATIC_DROPIN |
| |
| |
| |
| typedef int parsec_barrierattr_t; |
| |
| //Type definitions |
| typedef struct { |
| pthread_mutex_t mutex; |
| pthread_cond_t cond; |
| unsigned max; |
| volatile unsigned n; |
| volatile int is_arrival_phase; |
| } parsec_barrier_t; |
| |
| //pthread_barrier_wait can never return EINTR, use that as default value |
| const int PARSEC_BARRIER_SERIAL_THREAD = EINTR; |
| const parsec_barrierattr_t PARSEC_PROCESS_SHARED = 0; |
| const parsec_barrierattr_t PARSEC_PROCESS_PRIVATE = 1; |
| |
| |
| |
| //Barrier initialization & destruction |
| int parsec_barrier_init(parsec_barrier_t *barrier, const parsec_barrierattr_t *attr, unsigned count); |
| int parsec_barrier_destroy(parsec_barrier_t *barrier); |
| |
| //Barrier attribute initialization & destruction |
| int parsec_barrierattr_destroy(parsec_barrierattr_t *attr); |
| int parsec_barrierattr_init(parsec_barrierattr_t *attr); |
| |
| //Barrier attribute modification |
| int parsec_barrierattr_getpshared(const parsec_barrierattr_t *attr, int *pshared); |
| int parsec_barrierattr_setpshared(parsec_barrierattr_t *attr, int pshared); |
| |
| //Barrier usage |
| int parsec_barrier_wait(parsec_barrier_t *barrier); |
| |
| #endif //__PARSEC_BARRIER_H_ |
