Hello,
I've written a simple reader-writer lock for my own needs and am just after another pair of eyes to identify any issues I may have missed.
The domain this will be used in involves the vast majority being reads with the workload between each read-request being quite significant (ie., there will be little thread-contention)
A few things to note that may or may not be obvious:
#1: A basic lock needs to be aquired for any request (read/write)
#2: Writers are given priority, the "Writers" variable is about pending-writers, not current writers.
[cpp]struct RWLock
{
// Attributes
Byte Writers;
Byte Lock;
Byte Readers;
Byte Unused;
// Methods
Void FASTCALL AquireWrite();
Void FASTCALL AquireRead();
Void FASTCALL ReleaseWrite();
Void FASTCALL ReleaseRead();
};
NAKED Void FASTCALL RWLock::AquireWrite()
{
__asm
{
// Signal readers to wait.
add byte ptr [ecx], 1
// Aquire lock, no readers.
mov edx, 1
ALIGN 16
SPIN:
xor eax, eax
pause
lock cmpxchg word ptr [ecx+1], dx
jnz short SPIN
// Decrement writer-pending count.
sub byte ptr [ecx], 1
// Aquired.
ret
}
}
NAKED Void FASTCALL RWLock::AquireRead()
{
__asm
{
// Aquire lock.
mov edx, 1
ALIGN 16
SPIN:
xor eax, eax
pause
lock cmpxchg word ptr [ecx], dx
jnz short SPIN
// Increment reader count.
lock add byte ptr [ecx+2], 1
// Free lock.
mov byte ptr [ecx+1], 0
// Aquired.
ret
}
}
FORCEINLINE Void FASTCALL RWLock::ReleaseRead()
{
// Decrement reader count.
this->Readers--;
}
FORCEINLINE Void FASTCALL RWLock::ReleaseWrite()
{
// Free lock.
this->Lock = 0;
}[/cpp]
For C-style ('this' omitted for clarity)
[cpp]/*
* AquireWrite()
*/
// Signal readers to wait.
Writers++;
// Aquire lock when no writers or readers are present.
while(Lock != 0 && Readers != 0);
Lock=1;
// Decrement writer-pending count.
Writers--;
/*
* AquireRead()
*/
// Aquire lock when no writers are either present or pending.
while(Writers != 0 && Lock != 0);
Lock=1;
// Increment reader count.
Readers++;
// Free lock
Lock=0;
[/cpp]
Cheers,
Matt.
