Robust/src/Runtime/mlp_lock.h

   1 #ifndef ____MLP_LOCK_H__
   2 #define ____MLP_LOCK_H__
   3
   4
   5 #include "runtime.h"
   6
   7 #include <stdlib.h>
   8 #include <stdio.h>
   9 #include <assert.h>
  10
  11 #define __xg(x) ((volatile INTPTR *)(x))
  12
  13 #define CFENCE   asm volatile("":::"memory");
  14 #define MFENCE   asm volatile("mfence":::"memory");
  15
  16 #define LOCK_PREFIX \
  17   ".section .smp_locks,\"a\"\n"   \
  18   "  .align 4\n"                  \
  19   "  .long 661f\n"             /* address */\
  20   ".previous\n"                   \
  21   "661:\n\tlock; "
  22
  23
  24 static inline int atomicincandread(volatile unsigned int *lock) {
  25   int retval=1;
  26   __asm__ __volatile__("lock; xadd %0,%1"
  27                        : "=r"(retval)
  28                        : "m"(*lock), "0"(retval)
  29                        : "memory");
  30   return retval;
  31 }
  32
  33 static inline void atomic_dec(volatile int *v) {
  34   __asm__ __volatile__ (LOCK_PREFIX "decl %0"
  35                         : "+m" (*v));
  36 }
  37
  38 static inline void atomic_inc(volatile int *v) {
  39   __asm__ __volatile__ (LOCK_PREFIX "incl %0"
  40                         : "+m" (*v));
  41 }
  42
  43 // this returns TRUE if the atomic subtraction results in
  44 // a zero value--this way two threads cannot dec a value
  45 // atomically, but then go ahead and both read zero,
  46 // thinking they both are the last decrementer
  47 static inline int atomic_sub_and_test(int i, volatile int *v) {
  48   unsigned char c;
  49
  50   __asm__ __volatile__ (LOCK_PREFIX "subl %2,%0; sete %1"
  51                         : "+m" (*v), "=qm" (c)
  52                         : "ir" (i) : "memory");
  53   return c;
  54 }
  55
  56
  57 static inline void atomic_add(int i, volatile int *v) {
  58   __asm__ __volatile__ (LOCK_PREFIX "addl %1,%0"
  59                         : "+m" (*v)
  60                         : "ir" (i));
  61 }
  62
  63 static inline int LOCKXCHG32(volatile int* ptr, int val){
  64   int retval;
  65   //note: xchgl always implies lock
  66   __asm__ __volatile__("xchgl %0,%1"
  67                        : "=r"(retval)
  68                        : "m"(*ptr), "0"(val)
  69                        : "memory");
  70   return retval;
  71
  72 }
  73
  74
  75 // LOCKXCH atomically does the following:
  76 // INTPTR retval=*ptr;
  77 // *ptr=val;
  78 // return retval
  79 #ifdef BIT64
  80 static inline INTPTR LOCKXCHG(volatile INTPTR * ptr, INTPTR val){
  81   INTPTR retval;
  82   //note: xchgl always implies lock
  83   __asm__ __volatile__("xchgq %0,%1"
  84                        : "=r"(retval)
  85                        : "m"(*ptr), "0"(val)
  86                        : "memory");
  87   return retval;
  88
  89 }
  90 #else
  91 #define LOCKXCHG LOCKXCHG32
  92 #endif
  93
  94 /*
  95 static inline int write_trylock(volatile int *lock) {
  96   int retval=0;
  97   __asm__ __volatile__("xchgl %0,%1"
  98                        : "=r"(retval)
  99                        : "m"(*lock), "0"(retval)
 100                        : "memory");
 101   return retval;
 102 }
 103 */
 104
 105 #ifdef BIT64
 106 static inline INTPTR CAS(volatile void *ptr, unsigned INTPTR old, unsigned INTPTR new){
 107   unsigned INTPTR prev;
 108   __asm__ __volatile__("lock; cmpxchgq %1,%2"
 109                        : "=a"(prev)
 110                        : "r"(new), "m"(*__xg(ptr)), "0"(old)
 111                        : "memory");
 112   return prev;
 113 }
 114
 115 static inline long CAS32(volatile void *ptr, unsigned long old, unsigned long new){
 116   unsigned long prev;
 117   __asm__ __volatile__("lock; cmpxchgl %k1,%2"
 118                        : "=a"(prev)
 119                        : "r"(new), "m"(*__xg(ptr)), "0"(old)
 120                        : "memory");
 121   return prev;
 122 }
 123 #else
 124 static inline long CAS(volatile void *ptr, unsigned long old, unsigned long new){
 125   unsigned long prev;
 126   __asm__ __volatile__("lock; cmpxchgl %k1,%2"
 127                        : "=a"(prev)
 128                        : "r"(new), "m"(*__xg(ptr)), "0"(old)
 129                        : "memory");
 130   return prev;
 131 }
 132 #define CAS32 CAS
 133 #endif
 134
 135
 136 static inline int BARRIER(){
 137   CFENCE;
 138   return 1;
 139 }
 140
 141 static inline int MBARRIER(){
 142   MFENCE;
 143   return 1;
 144 }
 145
 146
 147 #endif // ____MLP_LOCK_H__