myvtm/libtoolkit/spinlock.h

#ifndef __SPINLOCK_H__
#define __SPINLOCK_H__

#pragma once

#include "config.h"

#if _WIN32
  #include <intrin.h>
#endif
#include <assert.h>
#include <winpr/interlocked.h>

#ifdef __cplusplus
extern "C" {
#endif

typedef volatile LONG lock_t[1];

#define FASTLOCK_INIT()	{0}

// non-reentrance

static __inline void fastlock_init(lock_t l)
{
	l[0] = 0;
}

TOOLKIT_API void fastlock_enter(lock_t l);

static __inline void fastlock_leave(lock_t l)
{
	_ReadWriteBarrier();
	InterlockedExchange(l, 0);
}

static __inline void fastlock_term(lock_t l)
{
	assert(l[0] == 0);
}

/* spin lock, note: reentrance!!! 
 * 11 1111 1111
 */

#define DEFAULT_SPIN_COUNT	0x3ff

// because zero is invalid thread id, so when a thread retrieve the lock 
// _value is set to the thread's id. 
typedef struct spinlock_t {
	volatile DWORD _value; 
	volatile DWORD _reentrance;
}spinlock_t;



static __inline void spinlock_init(spinlock_t *plock) 
{
	plock->_value = 0;
	plock->_reentrance = 0;
}

/**
 * enter lock
 * @param spin_count -1 use default
 */
TOOLKIT_API void spinlock_enter(volatile spinlock_t *sl, int spin_count);

/**
 * leave lock
 */
TOOLKIT_API void spinlock_leave(volatile spinlock_t *sl);



union rw_spinlock_barrier {
	struct {
		unsigned int readerCount    : 32 / 2;
		unsigned int writerCount    : 32 / 2 - 1;
		unsigned int writerActive   : 1 ;
	};
	unsigned int         nAtomic			;
};

typedef volatile struct rw_spinlock_s {
	union rw_spinlock_barrier barrier;
}rw_spinlock_t;

static __inline void rw_spinlock_init(rw_spinlock_t *rwlock)
{
	rwlock->barrier.nAtomic = 0;
}

// John M. Mellor-Crummey, Michael L. Scott "Scalable Reader-Writer Synchronization for Shared-Memory Multiprocessors", 1991

TOOLKIT_API void rw_spinlock_read_lock(rw_spinlock_t *rwlock);
TOOLKIT_API void rw_spinlock_read_unlock(rw_spinlock_t *rwlock);
TOOLKIT_API void rw_spinlock_write_lock(rw_spinlock_t *rwlock);
TOOLKIT_API void rw_spinlock_write_unlock(rw_spinlock_t *rwlock);

static __inline int rw_spinlock_is_reading(rw_spinlock_t *rwlock)
{
	return rwlock->barrier.readerCount != 0;
}

static __inline int rw_spinlock_is_writing(rw_spinlock_t *rwlock)
{
	return rwlock->barrier.writerActive == 1 ;
}

#ifdef __cplusplus
} // extern "C" {
#endif

#endif //__SPINLOCK_H__