BorlandTalk.com

Lee_Nover · Guest

hi
I've done my first little ASM project and would like some guides
it's a spinlock object that acquires/releases a lock
the Acquire method with a backoff is not yet implemented in asm

any insight will be much appreciated

tnx!

unit SpinLock;
{
#==============================================================================
# Name: SpinLock.pas
# Author: Istvan Agoston <Lee_Nover@delphi-si.com>
# Created: 2007-03-25
# Last Change: 2007-03-25
# Version: 1.0

# Description:

A scalable atomic lock

http://www.intel.com/cd/ids/developer/asmo-na/eng/dc/threading/333935..htm

# Warnings and/or special considerations:

Source code in this file is subject to the license specified below.

#==============================================================================
The contents of this file are subject to the Mozilla Public License
Version 1.1 (the "License"); you may not use this file except in compliance
with the License. You may obtain a copy of the License at
http://www.mozilla.org/MPL/

Software distributed under the License is distributed on an "AS IS" basis,
WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for
the specific language governing rights and limitations under the License.

The Original Code is 'SpinLock.pas'.

The Initial Developer of the Original Code is 'Istvan Agoston'.

Contributor(s): None.

#==============================================================================}

{$DEFINE ASM}

interface

type
TSpinLock = class(TObject)
private
FOwner: Cardinal;
FSleepAmount: Cardinal;
public
constructor Create(const SleepAmount: Cardinal = 0);
destructor Destroy; override;
procedure Acquire; overload;
function Acquire(TryCount: Cardinal): Boolean; overload;
procedure Release;
end;

implementation

uses Windows;

{ compares CompareValue and Target and returns the initial value of Target
if they're equal, Target is set to NewVal }
function LockCmpxchg(CompareVal, NewVal: Cardinal; var Target: Cardinal): Cardinal;
asm
lock cmpxchg [ecx], edx
end;

constructor TSpinLock.Create(const SleepAmount: Cardinal = 0);
begin
inherited Create;
FSleepAmount := SleepAmount;
end;

destructor TSpinLock.Destroy;
begin
FOwner := 0;
inherited;
end;

procedure TSpinLock.Acquire;
{$IFNDEF ASM}
var
LOwner: Cardinal;
LLock: Cardinal;
begin
LLock := GetCurrentThreadId;
// if not owned, set ourself as owner
LOwner := LockCmpxchg(0, LLock, FOwner);
// if the lock is owned by some other thread
while (LOwner <> 0) and (LOwner <> LLock) do
begin
Sleep(FSleepAmount);
LOwner := LockCmpxchg(0, LLock, FOwner);
end;
{$ELSE}
asm
// store Self in edx
mov edx, eax
// get thread id
mov ecx, fs:[$00000018]
mov ecx,[ecx+$24]
// clear eax for comparison to 0
xor eax, eax
// if owner equals 0 then safely exchange it with our thread id
lock cmpxchg [edx].FOwner, ecx
// if previously not owned then exit
jz @@exit
cmp eax, ecx
// if the owner is our threadid then exit (recursive locks)
jz @@exit

@@waitloop:
// spin on a volatile read
cmp [edx].FOwner, 0
jz @@trylock
// save our registers because sleep modifies them
push edx
push ecx
// Sleep is stdcall and accepts params on the stack, we push FSleepAmount as timeout
push FSleepAmount
call Windows.Sleep
pop ecx
pop edx
jmp @@waitloop

@@trylock:
xor eax, eax
// lock
lock cmpxchg [edx].FOwner, ecx
// if lock not successfull then reenter the loop
jnz @@waitloop

@@exit:
nop
{$ENDIF}
end;

function TSpinLock.Acquire(TryCount: Cardinal): Boolean;
var
LOwner: Cardinal;
LLock: Cardinal;
begin
LLock := GetCurrentThreadId;
// if not owned, set ourself as owner
LOwner := LockCmpxchg(0, LLock, FOwner);
// if the lock is owned by some other thread
while (LOwner <> 0) and (LOwner <> LLock) and (TryCount > 0) do
begin
Dec(TryCount);
Sleep(FSleepAmount);
LOwner := LockCmpxchg(0, LLock, FOwner);
end;

Result := TryCount > 0;
end;

procedure TSpinLock.Release;
{$IFNDEF ASM}
var
LLock: Cardinal;
begin
LLock := GetCurrentThreadId;
LockCmpxchg(LLock, 0, FOwner);
{$ELSE}
asm
// store self in edx
mov edx, eax
// get thread id
mov eax, fs:[$00000018]
mov eax,[eax+$24]
// clear ecx for reseting the lock if ecx equals owner
xor ecx, ecx
// if owner equals our thread id then safely exchange owner with 0
lock cmpxchg [edx].FOwner, ecx
{$ENDIF}
end;

end.

Lee_Nover · Guest

Robert Marquardt · Guest

Lee_Nover wrote:

Henri Gourvest · Guest

many thanks :)

Lee_Nover a écrit :

John Herbster · Guest

"Henri Gourvest" <x (AT) x (DOT) com> wrote

Lee_Nover · Guest

Robert Marquardt · Guest

Lee_Nover wrote:

Lee_Nover · Guest

Lee_Nover · Guest

Lee_Nover · Guest

Davy Landman · Guest

Hi,

I just wanted to say thanks for the nice code!

allready using it in a project of mine..

:)

Lee_Nover · Guest

Primoz Gabrijelcic · Guest

Lee_Nover wrote:

Freddy · Guest

In short, when would I use a spinlock instead of a critical section?
Or should I simply replace each critical-section with a spinlock?

My target is multi-processor (2 min), video cache access by multiple clients
etc..

Any guidance?

Thanks,
Freddy

"Primoz Gabrijelcic" <primoz (AT) gabrijelcic (DOT) org> wrote in message
news:46095b75 (AT) newsgroups (DOT) borland.com...

Lee_Nover · Guest