/usr/include/mpich2/primitives/opa_by_lock.h is in libmpich2-dev 1.4.1-1ubuntu1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
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 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 | /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */
/*
* (C) 2008 by Argonne National Laboratory.
* See COPYRIGHT in top-level directory.
*/
#ifndef OPA_BY_LOCK_H_INCLUDED
#define OPA_BY_LOCK_H_INCLUDED
/* FIXME For now we rely on pthreads for our IPC locks. This is fairly
portable, although it is obviously not 100% portable. Some day when we
refactor the OPA_Process_locks code we should be able to use that again. */
#if defined(OPA_HAVE_PTHREAD_H)
#include <pthread.h>
/* defined in opa_primitives.c */
extern pthread_mutex_t *OPA_emulation_lock;
/* FIXME these make less sense now that OPA is not inside of MPICH2. Is there a
simpler name/scheme that could be used here instead? [goodell@ 2009-02-19] */
#define OPA_IPC_SINGLE_CS_ENTER(msg) \
do { \
OPA_assert(OPA_emulation_lock); \
pthread_mutex_lock(OPA_emulation_lock); \
} while (0)
#define OPA_IPC_SINGLE_CS_EXIT(msg) \
do { \
OPA_assert(OPA_emulation_lock); \
pthread_mutex_unlock(OPA_emulation_lock); \
} while (0)
typedef struct { volatile int v; } OPA_int_t;
typedef struct { int * volatile v; } OPA_ptr_t;
#define OPA_INT_T_INITIALIZER(val_) { (val_) }
#define OPA_PTR_T_INITIALIZER(val_) { (val_) }
/*
Emulated atomic primitives
--------------------------
These are versions of the atomic primitives that emulate the proper behavior
via the use of an inter-process lock. For more information on their
individual behavior, please see the comment on the corresponding top level
function.
In general, these emulated primitives should _not_ be used. Most algorithms
can be more efficiently implemented by putting most or all of the algorithm
inside of a single critical section. These emulated primitives exist to
ensure that there is always a fallback if no machine-dependent version of a
particular operation has been defined. They also serve as a very readable
reference for the exact semantics of our OPA_* ops.
*/
static _opa_inline int OPA_load_int(_opa_const OPA_int_t *ptr)
{
int retval;
OPA_IPC_SINGLE_CS_ENTER("atomic_add");
retval = ptr->v;
OPA_IPC_SINGLE_CS_EXIT("atomic_add");
return retval;
}
static _opa_inline void OPA_store_int(OPA_int_t *ptr, int val)
{
OPA_IPC_SINGLE_CS_ENTER("atomic_add");
ptr->v = val;
OPA_IPC_SINGLE_CS_EXIT("atomic_add");
}
static _opa_inline void *OPA_load_ptr(_opa_const OPA_ptr_t *ptr)
{
int *retval;
OPA_IPC_SINGLE_CS_ENTER("atomic_add");
retval = ptr->v;
OPA_IPC_SINGLE_CS_EXIT("atomic_add");
return retval;
}
static _opa_inline void OPA_store_ptr(OPA_ptr_t *ptr, void *val)
{
OPA_IPC_SINGLE_CS_ENTER("atomic_add");
ptr->v = val;
OPA_IPC_SINGLE_CS_EXIT("atomic_add");
}
static _opa_inline void OPA_add_int(OPA_int_t *ptr, int val)
{
OPA_IPC_SINGLE_CS_ENTER("atomic_add");
ptr->v += val;
OPA_IPC_SINGLE_CS_EXIT("atomic_add");
}
static _opa_inline void *OPA_cas_ptr(OPA_ptr_t *ptr, int *oldv, int *newv)
{
int *prev;
OPA_IPC_SINGLE_CS_ENTER("atomic_cas");
prev = ptr->v;
if (prev == oldv) {
ptr->v = newv;
}
OPA_IPC_SINGLE_CS_EXIT("atomic_cas");
return prev;
}
static _opa_inline int OPA_cas_int(OPA_int_t *ptr, int oldv, int newv)
{
int prev;
OPA_IPC_SINGLE_CS_ENTER("atomic_cas");
prev = ptr->v;
if (prev == oldv) {
ptr->v = newv;
}
OPA_IPC_SINGLE_CS_EXIT("atomic_cas");
return prev;
}
static _opa_inline int OPA_decr_and_test_int(OPA_int_t *ptr)
{
int new_val;
OPA_IPC_SINGLE_CS_ENTER("atomic_decr_and_test");
new_val = --(ptr->v);
OPA_IPC_SINGLE_CS_EXIT("atomic_decr_and_test");
return (0 == new_val);
}
static _opa_inline void OPA_decr_int(OPA_int_t *ptr)
{
OPA_IPC_SINGLE_CS_ENTER("atomic_decr");
--(ptr->v);
OPA_IPC_SINGLE_CS_EXIT("atomic_decr");
}
static _opa_inline int OPA_fetch_and_add_int(OPA_int_t *ptr, int val)
{
int prev;
OPA_IPC_SINGLE_CS_ENTER("atomic_fetch_and_add");
prev = ptr->v;
ptr->v += val;
OPA_IPC_SINGLE_CS_EXIT("atomic_fetch_and_add");
return prev;
}
static _opa_inline int OPA_fetch_and_decr_int(OPA_int_t *ptr)
{
int prev;
OPA_IPC_SINGLE_CS_ENTER("atomic_fetch_and_decr");
prev = ptr->v;
--(ptr->v);
OPA_IPC_SINGLE_CS_EXIT("atomic_fetch_and_decr");
return prev;
}
static _opa_inline int OPA_fetch_and_incr_int(OPA_int_t *ptr)
{
int prev;
OPA_IPC_SINGLE_CS_ENTER("atomic_fetch_and_incr");
prev = ptr->v;
++(ptr->v);
OPA_IPC_SINGLE_CS_EXIT("atomic_fetch_and_incr");
return prev;
}
static _opa_inline void OPA_incr_int(OPA_int_t *ptr)
{
OPA_IPC_SINGLE_CS_ENTER("atomic_incr");
++(ptr->v);
OPA_IPC_SINGLE_CS_EXIT("atomic_incr");
}
static _opa_inline void *OPA_swap_ptr(OPA_ptr_t *ptr, void *val)
{
int *prev;
OPA_IPC_SINGLE_CS_ENTER("atomic_swap_ptr");
prev = ptr->v;
ptr->v = val;
OPA_IPC_SINGLE_CS_EXIT("atomic_swap_ptr");
return prev;
}
static _opa_inline int OPA_swap_int(OPA_int_t *ptr, int val)
{
int prev;
OPA_IPC_SINGLE_CS_ENTER("atomic_swap_int");
prev = ptr->v;
ptr->v = val;
OPA_IPC_SINGLE_CS_EXIT("atomic_swap_int");
return (int)prev;
}
/* lock/unlock provides barrier */
#define OPA_write_barrier() do {} while (0)
#define OPA_read_barrier() do {} while (0)
#define OPA_read_write_barrier() do {} while (0)
#endif /* defined(OPA_HAVE_PTHREAD_H) */
#endif /* !defined(OPA_BY_LOCK_H_INCLUDED) */
|