libmpich-dev 3.2-6build1 / usr / include / mpich / primitives / opa_unsafe.h

This file is indexed.

/usr/include/mpich/primitives/opa_unsafe.h is in libmpich-dev 3.2-6build1.

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
/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */
/*
 *  (C) 2008 by Argonne National Laboratory.
 *      See COPYRIGHT in top-level directory.
 */

#ifndef OPA_UNSAFE_H_INCLUDED
#define OPA_UNSAFE_H_INCLUDED

/* NOTE: These types intentionally do not use volatile in order to provide even
 * better performance.  If a good use case for having unsafe operations with
 * volatile types comes up, we can make two definitions that are conditional on
 * something sort of like NDEBUG. [goodell@ 2009-08-18] */
typedef struct { int v;  } OPA_int_t;
typedef struct { int *v; } OPA_ptr_t;

#define OPA_INT_T_INITIALIZER(val_) { (val_) }
#define OPA_PTR_T_INITIALIZER(val_) { (val_) }

/*
    Unsafe Primitives
    -----------------

    These are versions of the atomic primitives that emulate the single-threaded
    behavior of the primitives but do not attempt to provide any safety against
    concurrent use.  The primary use case for this implementation is to avoid
    overhead without code changes in client libraries and applications that have
    been compiled for single-threaded use only.  They might also be useful for
    testing (and testing of tests) in some cases.

    Thanks to Josh Haberman for inspiring this primitives implementation.
*/

static _opa_inline int OPA_load_int(const OPA_int_t *ptr)
{
    int retval;
    retval = ptr->v;
    return retval;
}

static _opa_inline void OPA_store_int(OPA_int_t *ptr, int val)
{
    ptr->v = val;
}

static _opa_inline void *OPA_load_ptr(const OPA_ptr_t *ptr)
{
    int *retval;
    retval = ptr->v;
    return retval;
}

static _opa_inline void OPA_store_ptr(OPA_ptr_t *ptr, void *val)
{
    ptr->v = val;
}

/* no barrier needed, not even a compiler barrier */
#define OPA_load_acquire_int(ptr_)       OPA_load_int((ptr_))
#define OPA_store_release_int(ptr_,val_) OPA_store_int((ptr_),(val_))
#define OPA_load_acquire_ptr(ptr_)       OPA_load_ptr((ptr_))
#define OPA_store_release_ptr(ptr_,val_) OPA_store_ptr((ptr_),(val_))

static _opa_inline void OPA_add_int(OPA_int_t *ptr, int val)
{
    ptr->v += val;
}

static _opa_inline void *OPA_cas_ptr(OPA_ptr_t *ptr, int *oldv, int *newv)
{
    int *prev;
    prev = ptr->v;
    if (prev == oldv) {
        ptr->v = newv;
    }
    return prev;
}

static _opa_inline int OPA_cas_int(OPA_int_t *ptr, int oldv, int newv)
{
    int prev;
    prev = ptr->v;
    if (prev == oldv) {
        ptr->v = newv;
    }
    return prev;
}

static _opa_inline int OPA_decr_and_test_int(OPA_int_t *ptr)
{
    int new_val;
    new_val = --(ptr->v);
    return (0 == new_val);
}

static _opa_inline void OPA_decr_int(OPA_int_t *ptr)
{
    --(ptr->v);
}

static _opa_inline int OPA_fetch_and_add_int(OPA_int_t *ptr, int val)
{
    int prev;
    prev = ptr->v;
    ptr->v += val;
    return prev;
}

static _opa_inline int OPA_fetch_and_decr_int(OPA_int_t *ptr)
{
    int prev;
    prev = ptr->v;
    --(ptr->v);
    return prev;
}

static _opa_inline int OPA_fetch_and_incr_int(OPA_int_t *ptr)
{
    int prev;
    prev = ptr->v;
    ++(ptr->v);
    return prev;
}

static _opa_inline void OPA_incr_int(OPA_int_t *ptr)
{
    ++(ptr->v);
}

static _opa_inline void *OPA_swap_ptr(OPA_ptr_t *ptr, void *val)
{
    int *prev;
    prev = ptr->v;
    ptr->v = val;
    return prev;
}

static _opa_inline int OPA_swap_int(OPA_int_t *ptr, int val)
{
    int prev;
    prev = ptr->v;
    ptr->v = val;
    return (int)prev;
}

/* null barriers */
#define OPA_write_barrier()      do {} while (0)
#define OPA_read_barrier()       do {} while (0)
#define OPA_read_write_barrier() do {} while (0)
#define OPA_compiler_barrier()   do {} while (0)

#endif /* !defined(OPA_UNSAFE_H_INCLUDED) */

APT Browse - Built by Thomas Orozco.