omp.h

Go to the documentation of this file.

 
#ifndef __OMP_H
#define __OMP_H
 
#include <stdio.h>
#include <time.h>
#include <unistd.h>
 
typedef enum omp_sched_t {
    omp_sched_static  = 1,
    omp_sched_dynamic = 2,
    omp_sched_guided  = 3,
    omp_sched_auto    = 4
} omp_sched_t;
 
#define omp_sched_monotonic ((omp_sched_t)0x80000000u)
 
typedef enum omp_sync_hint_t {
    omp_sync_hint_none           = 0,
    omp_sync_hint_uncontended    = 1,
    omp_sync_hint_contended      = 2,
    omp_sync_hint_nonspeculative = 4,
    omp_sync_hint_speculative    = 8
} omp_sync_hint_t;
 
typedef omp_sync_hint_t omp_lock_hint_t;
#define omp_lock_hint_none           omp_sync_hint_none
#define omp_lock_hint_uncontended    omp_sync_hint_uncontended
#define omp_lock_hint_contended      omp_sync_hint_contended
#define omp_lock_hint_nonspeculative omp_sync_hint_nonspeculative
#define omp_lock_hint_speculative    omp_sync_hint_speculative
 
#ifdef __CCCC_OMP_THREADED__
 
/* -c=native, -m and -c=generated run parallel regions on real threads; the
   runtime is emitted into the output. */
 
typedef struct {
    void *__impl;
} omp_lock_t;
 
typedef struct {
    void *__impl;
    int   __reserved; /* keeps it a distinct type from omp_lock_t */
} omp_nest_lock_t;
 
int    omp_get_num_threads(void);
int    omp_get_max_threads(void);
int    omp_get_thread_num(void);
int    omp_get_thread_limit(void);
int    omp_in_parallel(void);
int omp_in_final(void);
int    omp_get_num_procs(void);
void   omp_set_num_threads(int n);
void   omp_set_dynamic(int on);
int    omp_get_dynamic(void);
double omp_get_wtime(void);
double omp_get_wtick(void);
void omp_set_schedule(omp_sched_t kind, int chunk);
void omp_get_schedule(omp_sched_t *kind, int *chunk);
 
void omp_init_lock(omp_lock_t *lock);
void omp_destroy_lock(omp_lock_t *lock);
void omp_set_lock(omp_lock_t *lock);
void omp_unset_lock(omp_lock_t *lock);
int  omp_test_lock(omp_lock_t *lock);
 
void omp_init_nest_lock(omp_nest_lock_t *lock);
void omp_destroy_nest_lock(omp_nest_lock_t *lock);
void omp_set_nest_lock(omp_nest_lock_t *lock);
void omp_unset_nest_lock(omp_nest_lock_t *lock);
int  omp_test_nest_lock(omp_nest_lock_t *lock);
 
#else
 
typedef struct {
    int held;
} omp_lock_t;
 
typedef struct {
    int depth;
} omp_nest_lock_t;
 
static inline int omp_get_num_threads(void) { return 1; }
static inline int omp_get_max_threads(void) { return 1; }
static inline int omp_get_thread_num(void) { return 0; }
static inline int omp_get_thread_limit(void) { return 1; }
static inline int omp_in_parallel(void) { return 0; }
static inline int omp_in_final(void) {
    return 0;
}
static inline int omp_get_num_procs(void) {
    long n = sysconf(_SC_NPROCESSORS_ONLN);
    return n > 0 ? (int)n : 1;
}
static inline void omp_set_num_threads(int n) { (void)n; }
static inline void omp_set_dynamic(int on) { (void)on; }
static inline int omp_get_dynamic(void) { return 0; }
 
static inline int *__omp_schedule_icv(void) {
    static int icv[2] = {omp_sched_static, 0};
    return icv;
}
static inline void omp_set_schedule(omp_sched_t kind, int chunk) {
    int k = (int)kind & 0x7fffffff;
    if (k >= omp_sched_static && k <= omp_sched_auto) {
        __omp_schedule_icv()[0] = k;
        __omp_schedule_icv()[1] = chunk;
    }
}
static inline void omp_get_schedule(omp_sched_t *kind, int *chunk) {
    *kind  = (omp_sched_t)__omp_schedule_icv()[0];
    *chunk = __omp_schedule_icv()[1];
}
 
static inline double omp_get_wtime(void) {
    struct timespec ts;
    clock_gettime(CLOCK_MONOTONIC, &ts);
    return (double)ts.tv_sec + (double)ts.tv_nsec * 1e-9;
}
static inline double omp_get_wtick(void) { return 1e-9; }
 
static inline void omp_init_lock(omp_lock_t *lock) { lock->held = 0; }
static inline void omp_destroy_lock(omp_lock_t *lock) { lock->held = 0; }
static inline void omp_set_lock(omp_lock_t *lock) {
    if (lock->held) {
        fputs("omp_set_lock: lock is already held (deadlock)\n", stderr);
        __builtin_trap();
    }
    lock->held = 1;
}
static inline void omp_unset_lock(omp_lock_t *lock) { lock->held = 0; }
static inline int omp_test_lock(omp_lock_t *lock) {
    if (lock->held)
        return 0;
    lock->held = 1;
    return 1;
}
 
static inline void omp_init_nest_lock(omp_nest_lock_t *lock) {
    lock->depth = 0;
}
static inline void omp_destroy_nest_lock(omp_nest_lock_t *lock) {
    lock->depth = 0;
}
static inline void omp_set_nest_lock(omp_nest_lock_t *lock) { lock->depth++; }
static inline void omp_unset_nest_lock(omp_nest_lock_t *lock) {
    if (lock->depth > 0)
        lock->depth--;
}
static inline int omp_test_nest_lock(omp_nest_lock_t *lock) {
    return ++lock->depth;
}
 
#endif /* __CCCC_OMP_THREADED__ */
 
#endif