diogo/yap-6.3
Archived
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

fix RW_locks for x86 (code from Erlang).

Browse Source
This commit is contained in:
vsc 2010-10-15 01:13:49 +01:00
parent fa42de1025
commit bd502a39ac
1 changed files with 101 additions and 58 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

147
OPTYap/locks_x86.h
View File

@ -7,7 +7,7 @@
** OPTYap extends the Yap Prolog engine to support or-parallel tabling **
** **
** **
** Yap Prolog was developed at University of Porto, Portugal **
** YAP Prolog was developed at University of Porto, Portugal **
** **
************************************************************************/
@ -60,68 +60,111 @@ spin_unlock(spinlock_t *lock)
#define IS_UNLOCKED(LOCK_VAR) ((LOCK_VAR) == 0)
#define UNLOCK(LOCK_VAR) spin_unlock((spinlock_t *)&(LOCK_VAR))
/* This code has been copied from the sources of the Linux kernel */
/* the code that follows has been adapted from the Erlang sources */
/*
* On x86, we implement read-write locks as a 32-bit counter
* with the high bit (sign) being the "contended" bit.
*
* The inline assembly is non-obvious. Think about it.
*
* Changed to use the same technique as rw semaphores. See
* semaphore.h for details. -ben
*/
/* the spinlock helpers are in arch/i386/kernel/semaphore.S */
typedef struct {
volatile int lock;
} rwlock_t;
typedef struct { unsigned long a[100]; } __dummy_lock_t;
#define __dummy_lock(lock) (*(__dummy_lock_t *)(lock))
#define RWLOCK_OFFSET (1<<24)
typedef struct { volatile unsigned int lock; } rwlock_t;
#define RW_LOCK_BIAS 0x01000000
#define RW_LOCK_BIAS_STR "0x01000000"
#define RW_LOCK_UNLOCKED RW_LOCK_BIAS
#define __build_read_lock(rw, helper) \
asm volatile("lock\n" \
"subl $1,(%0)\n\t" \
"js 2f\n" \
"1:\n" \
".section .text.lock,\"ax\"\n" \
"2:\tcall __read_lock_failed\n\t" \
"jmp 1b\n" \
".previous" \
::"a" (rw) : "memory")
#define __build_write_lock(rw, helper) \
asm volatile("lock\n"\
"subl $" RW_LOCK_BIAS_STR ",(%0)\n\t" \
"jnz 2f\n" \
"1:\n" \
".section .text.lock,\"ax\"\n" \
"2:\tcall __write_lock_failed\n\t" \
"jmp 1b\n" \
".previous" \
::"a" (rw) : "memory")
static inline void read_lock(rwlock_t *rw)
static inline void
init_rwlock(rwlock_t *lock)
{
__build_read_lock(rw, "__read_lock_failed");
lock->lock = 0;
}
static inline void write_lock(rwlock_t *rw)
static inline void
read_unlock(rwlock_t *lock)
{
__build_write_lock(rw, "__write_lock_failed");
__asm__ __volatile__(
"lock; decl %0"
: "=m"(lock->lock)
: "m"(lock->lock)
);
}
static inline int
read_trylock(rwlock_t *lock)
{
int tmp;
#define READ_LOCK(X) read_lock(&(X))
#define WRITE_LOCK(X) write_lock(&(X))
tmp = 1;
__asm__ __volatile__(
"lock; xaddl %0, %1"
: "=r"(tmp)
: "m"(lock->lock), "0"(tmp));
/* tmp is now the lock's previous value */
if (__builtin_expect(tmp >= 0, 1))
return 1;
read_unlock(lock);
return 0;
}
#define READ_UNLOCK(rw) asm volatile("lock ; incl %0" :"=m" (__dummy_lock(&(rw))))
#define WRITE_UNLOCK(rw) asm volatile("lock ; addl $" RW_LOCK_BIAS_STR ",%0":"=m" (__dummy_lock(&(rw))))
static inline int
read_is_locked(rwlock_t *lock)
{
return lock->lock < 0;
}
#define INIT_RWLOCK(RW) (RW).lock = RW_LOCK_UNLOCKED
static inline void
read_lock(rwlock_t *lock)
{
for(;;) {
if (__builtin_expect(read_trylock(lock) != 0, 1))
break;
do {
__asm__ __volatile__("rep;nop" : "=m"(lock->lock) : : "memory");
} while (read_is_locked(lock));
}
}
static inline void
write_unlock(rwlock_t *lock)
{
__asm__ __volatile__(
"lock; addl %2,%0"
: "=m"(lock->lock)
: "m"(lock->lock), "i"(RWLOCK_OFFSET));
}
static inline int
write_trylock(rwlock_t *lock)
{
int tmp;
tmp = -RWLOCK_OFFSET;
__asm__ __volatile__(
"lock; xaddl %0, %1"
: "=r"(tmp)
: "m"(lock->lock), "0"(tmp));
/* tmp is now the lock's previous value */
if (__builtin_expect(tmp == 0, 1))
return 1;
write_unlock(lock);
return 0;
}
static inline int
write_is_locked(rwlock_t *lock)
{
return lock->lock != 0;
}
static inline void
write_lock(rwlock_t *lock)
{
for(;;) {
if (__builtin_expect(write_trylock(lock) != 0, 1))
break;
do {
__asm__ __volatile__("rep;nop" : "=m"(lock->lock) : : "memory");
} while (write_is_locked(lock));
}
}
#define INIT_RWLOCK(lock) init_rwlock(&(lock))
#define READ_LOCK(lock) read_lock(&(lock))
#define READ_UNLOCK(lock) read_unlock(&(lock))
#define WRITE_LOCK(lock) write_lock(&(lock))
#define WRITE_UNLOCK(lock) write_unlock(&(lock))