Spinlock.c File Reference

This is the implementation for custom spinlock. More...

#include "pch.h"

Functions
BOOLEAN	SpinlockTryLock (volatile LONG *Lock)
	Tries to get the lock otherwise returns.
void	SpinlockLock (volatile LONG *Lock)
	Tries to get the lock and won't return until successfully get the lock.
void	SpinlockInterlockedCompareExchange (LONG volatile *Destination, LONG Exchange, LONG Comperand)
	Interlocked spinlock that tries to change the value and makes sure that it changed the target value.
void	SpinlockLockWithCustomWait (volatile LONG *Lock, unsigned MaximumWait)
	Tries to get the lock and won't return until successfully get the lock.
void	SpinlockUnlock (volatile LONG *Lock)
	Release the lock.
BOOLEAN	SpinlockCheckLock (volatile LONG *Lock)
	Check the lock without changing the state.

Detailed Description

This is the implementation for custom spinlock.

Author

Sina Karvandi (sina@.nosp@m.hype.nosp@m.rdbg..nosp@m.org)

This implementation is derived from Hvpp by Petr Benes

• https://github.com/wbenny/hvpp Based on my benchmarks, this simple implementation beats other (often more complex) spinlock implementations - such as queue spinlocks, ticket spinlocks, MCS locks. The only difference between this implementation and completely naive spinlock is the "backoff".

Also, benefit of this implementation is that we can use it with STL lock guards, e.g.: std::lock_guard.

Look here for more information:

• https://locklessinc.com/articles/locks/
• https://github.com/cyfdecyf/spinlock

Version

0.1

Date

2020-04-10

Copyright

This project is released under the GNU Public License v3.

Function Documentation

SpinlockCheckLock()

BOOLEAN SpinlockCheckLock

(

volatile LONG *

Lock

)

Check the lock without changing the state.

Parameters

LONG	Lock variable

{
    if (*Lock)
    {
        return TRUE;
    }
    else
    {
        return FALSE;
    }
}

SpinlockInterlockedCompareExchange()

void SpinlockInterlockedCompareExchange	(	LONG volatile *	Destination,
		LONG	Exchange,
		LONG	Comperand )

Interlocked spinlock that tries to change the value and makes sure that it changed the target value.

Parameters

Destination	A pointer to the destination value
Exchange	The exchange value
Comperand	The value to compare to Destination

{
    unsigned wait = 1;
 
    while (InterlockedCompareExchange(Destination, Exchange, Comperand) != Comperand)
    {
        for (unsigned i = 0; i < wait; ++i)
        {
            _mm_pause();
        }
 
        //
        // Don't call "pause" too many times. If the wait becomes too big,
        // clamp it to the MaxWait.
        //
 
        if (wait * 2 > MaxWait)
        {
            wait = MaxWait;
        }
        else
        {
            wait = wait * 2;
        }
    }
}

SpinlockLock()

void SpinlockLock

(

volatile LONG *

Lock

)

Tries to get the lock and won't return until successfully get the lock.

Parameters

LONG	Lock variable

{
    unsigned wait = 1;
 
    while (!SpinlockTryLock(Lock))
    {
        for (unsigned i = 0; i < wait; ++i)
        {
            _mm_pause();
        }
 
        //
        // Don't call "pause" too many times. If the wait becomes too big,
        // clamp it to the MaxWait.
        //
 
        if (wait * 2 > MaxWait)
        {
            wait = MaxWait;
        }
        else
        {
            wait = wait * 2;
        }
    }
}

SpinlockLockWithCustomWait()

void SpinlockLockWithCustomWait	(	volatile LONG *	Lock,
		unsigned	MaximumWait )

Tries to get the lock and won't return until successfully get the lock.

Parameters

LONG	Lock variable
LONG	MaxWait Maximum wait (pause) count

{
    unsigned wait = 1;
 
    while (!SpinlockTryLock(Lock))
    {
        for (unsigned i = 0; i < wait; ++i)
        {
            _mm_pause();
        }
 
        //
        // Don't call "pause" too many times. If the wait becomes too big,
        // clamp it to the MaxWait.
        //
 
        if (wait * 2 > MaximumWait)
        {
            wait = MaximumWait;
        }
        else
        {
            wait = wait * 2;
        }
    }
}

SpinlockTryLock()

BOOLEAN SpinlockTryLock

(

volatile LONG *

Lock

)

Tries to get the lock otherwise returns.

Parameters

LONG	Lock variable

Returns

BOOLEAN If it was successful on getting the lock

{
    return (!(*Lock) && !_interlockedbittestandset(Lock, 0));
}

SpinlockUnlock()

void SpinlockUnlock

(

volatile LONG *

Lock

)

Release the lock.

Parameters

LONG	Lock variable

{
    *Lock = 0;
}