The tyranny of simple tests

Last TMonitor post I promise (well, if until the ‘hotfix’ for TMonitor.Wait gets forgotten about…): it seems TMonitor’s apparent slowness in uncontended scenarios as discussed in my previous post is less than it first appeared. In fact, by tweaking my original test, I can now get it to perform faster than TCriticalSection so long as more than one thread is created. Credit for this discovery must go to commentator Krystian over at Eric Grange’s blog – specifically, the problem with TMonitor’s apparent performance was primarily a function of it needing to dynamically allocate a small bit of memory for its own state, which when several TMonitor’s are intialised in quick succesion leads them to allocate memory in the same processor cache line. Ensure the TMonitor is initialised up front though, along with something else getting allocated at the same time, and the problem goes away.

While this has TMonitor now besting TCriticalSection, TRTLCriticalSection still comes out on top: quite simply, even though TCriticalSection could barely be any lighter, the simple fact of it being a class ‘kills’ its performance. This is then aggrevated by the fact its Enter and Leave methods are inlined to call the virtual Acquire and Release rather than vice versa. OK, other things being equal it should be the other way round, but really…

Anyhow, onto the revised test: since there were complaints about me using TCountdownEvent and TStopwatch, I’ve replaced them with direct API calls. While TStringList and indeed the VCL are nonetheless perfectively acceptable (?), I’ve nonetheless kept the test program as a console application. However, I’ve taken memory deallocation out of the picture by freeing the thread classes explicitly (explicit memory allocation was already not tested for given I created the thread classes before timing started). So, without further ado, here’s the new code:

program TMonitorVsTCriticalSectionV2;

{$APPTYPE CONSOLE}

uses
  Windows,
  SysUtils,
  Classes,
  SyncObjs;

type
  TTestThread = class(TThread)
  strict private
    FSomeHeapData: IInterface;
  public
    constructor Create; virtual;
  end;

  TTestThreadClass = class of TTestThread;

constructor TTestThread.Create;
begin
  inherited Create(True);
  FSomeHeapData := TInterfaceList.Create;
end;

procedure RunTest(const TestName: string; ThreadCount: Integer;
  ThreadClass: TTestThreadClass);
var
  I: Integer;
  Threads: array of TThread;
  ThreadHandles: array of THandle;
  StartCounts, EndCounts, CountsFreq: Int64;
begin
  SetLength(ThreadHandles, ThreadCount);
  SetLength(Threads, ThreadCount);
  for I := 0 to ThreadCount - 1 do
  begin
    Threads[I] := ThreadClass.Create;
    ThreadHandles[I] := Threads[I].Handle;
  end;
  QueryPerformanceCounter(StartCounts);
  for I := 0 to ThreadCount - 1 do
    Threads[I].Start;
  WaitForMultipleObjects(ThreadCount, @ThreadHandles[0], True, INFINITE);
  QueryPerformanceCounter(EndCounts);
  QueryPerformanceFrequency(CountsFreq);
  //free the threads explicitly to take memory deallocation out of the equation
  for I := 0 to ThreadCount - 1 do
    Threads[I].Free;
  Writeln(TestName, ' ', ThreadCount, ' thread(s) took ',
    Round((EndCounts - StartCounts) * 1000 / CountsFreq), 'ms');
end;

const
  CountdownFrom = $FFFFFF; //increase if necessary...
  MaxThreads = 10;

type
  TCriticalSectionThread = class(TTestThread)
  protected
    FCriticalSection: TCriticalSection;
    procedure Execute; override;
  public
    constructor Create; override;
    destructor Destroy; override;
  end;

  TCriticalSectionThreadNoVirt = class(TCriticalSectionThread)
  protected
    procedure Execute; override;
  end;

  TMonitorThread = class(TTestThread)
  protected
    procedure Execute; override;
  public
    constructor Create; override;
  end;

  TRTLCriticalSectionThread = class(TTestThread)
  strict private
    FCriticalSection: TRTLCriticalSection;
  protected
    procedure Execute; override;
  public
    constructor Create; override;
    destructor Destroy; override;
  end;

  TRTLCriticalSectionThreadDynAlloc = class(TTestThread)
  strict private
    FCriticalSection: PRTLCriticalSection;
  protected
    procedure Execute; override;
  public
    constructor Create; override;
    destructor Destroy; override;
  end;

constructor TCriticalSectionThread.Create;
begin
  inherited Create;
  FCriticalSection := TCriticalSection.Create;
end;

destructor TCriticalSectionThread.Destroy;
begin
  FCriticalSection.Free;
  inherited Destroy;
end;

procedure TCriticalSectionThread.Execute;
var
  Counter: Integer;
begin
  Counter := CountdownFrom;
  repeat
    FCriticalSection.Enter;
    try
      Dec(Counter);
    finally
      FCriticalSection.Leave;
    end;
  until (Counter <= 0);
end;

type
  TCSAccess = class(TCriticalSection);

procedure TCriticalSectionThreadNoVirt.Execute;
var
  Counter: Integer;
begin
  Counter := CountdownFrom;
  repeat
    TCSAccess(FCriticalSection).FSection.Enter;
    try
      Dec(Counter);
    finally
      TCSAccess(FCriticalSection).FSection.Leave;
    end;
  until (Counter <= 0);
end;

constructor TMonitorThread.Create;
begin
  inherited;
  //force our monitor to be initialised
  TMonitor.Enter(Self);
  TMonitor.Exit(Self);
end;

procedure TMonitorThread.Execute;
var
  Counter: Integer;
begin
  Counter := CountdownFrom;
  repeat
    TMonitor.Enter(Self);
    try
      Dec(Counter);
    finally
      TMonitor.Exit(Self);
    end;
  until (Counter <= 0);
end;

constructor TRTLCriticalSectionThread.Create;
begin
  inherited Create;
  InitializeCriticalSection(FCriticalSection);
end;

destructor TRTLCriticalSectionThread.Destroy;
begin
  DeleteCriticalSection(FCriticalSection);
  inherited Destroy;
end;

procedure TRTLCriticalSectionThread.Execute;
var
  Counter: Integer;
begin
  Counter := CountdownFrom;
  repeat
    FCriticalSection.Enter;
    try
      Dec(Counter);
    finally
      FCriticalSection.Leave;
    end;
  until (Counter <= 0);
end;

constructor TRTLCriticalSectionThreadDynAlloc.Create;
begin
  inherited Create;
  New(FCriticalSection);
  InitializeCriticalSection(FCriticalSection^);
end;

destructor TRTLCriticalSectionThreadDynAlloc.Destroy;
begin
  DeleteCriticalSection(FCriticalSection^);
  Dispose(FCriticalSection);
  inherited Destroy;
end;

procedure TRTLCriticalSectionThreadDynAlloc.Execute;
var
  Counter: Integer;
begin
  Counter := CountdownFrom;
  repeat
    FCriticalSection.Enter;
    try
      Dec(Counter);
    finally
      FCriticalSection.Leave;
    end;
  until (Counter <= 0);
end;

var
  I, J: Integer;
begin
  for I := 1 to 3 do
  begin
    Writeln('*** ROUND ', I, ' ***');
    for J := 1 to MaxThreads do
    begin
      RunTest('TMonitor                               ',
        J, TMonitorThread);
      RunTest('TCriticalSection                       ',
        J, TCriticalSectionThread);
      RunTest('TCriticalSection (avoid virtual calls) ',
        J, TCriticalSectionThreadNoVirt);
      RunTest('TRTLCriticalSection (New/Dispose)      ',
        J, TRTLCriticalSectionThreadDynAlloc);
      RunTest('TRTLCriticalSection                    ',
        J, TRTLCriticalSectionThread);
      WriteLn;
    end;
  end;
  Write('Press ENTER to exit...');
  ReadLn;
end.

As said, for two or more threads, I now consistently get TMonitor to both outperform TCriticalSection and not exhibit the weirdness it did in my original test – instead, said weirdness is transposed to TCriticalSection. However, as before, using TRTLCriticalSection directly performs best by far.

Since everyone likes definite conclusions, I guess I can only conclude by saying this: you should avoid virtual method calls at the very least, and preferably classes too. Indeed, even dynamic memory allocations should be verbotten – stick to locals and opaque (or at least semi-opaque) records whose data are allocated for you by the Windows API. Sounds about right, eh?