Hello,

The project/benchmark below was compiled with Delphi 2007 (produces 32 bit instructions), and Free Pascal Cross Compiler 2.1.4 Beta for X64 (produces 64 bit instructions ???).

I see no major performance differences ?

I was expecting much better performance from the cross compiler but it's not happening ?

Why is it not happening ?

Doesn't it use true 64 bit instructions ?

(How can I look at the produced assembler instructions ?)

Or is there another reason for it ?

// *** Begin of Benchmark ***
program Project1;
{$APPTYPE CONSOLE}

{

Test simulated large integer (int64) vs native floating point (double) performance

version 0.01 created on 7 february 2008 by Skybuck Flying

My (Skybuck)'s Conclusions are:

1. Simulated ints faster for additions and subtractions than doubles.

2. Simulated ints slower for multiplications and divisions than doubles.

}

uses
SysUtils,

  Windows;

function TestSimulatedInt64Performance : int64;
var
 vIndex : integer;
 a : int64;
 b : int64;
 c : int64;
begin
 a := 0;
 b := 1;
 c := 2;
 for vIndex := 0 to 10 * 1024 * 1024 do
 begin
  // additions faster with simulated int than doubles
  a := a + 1;
  b := b + 1;
  c := c + 1;
  // multiplications slower with simulated int than doubles
  a := a * 5;
  b := b * 5;
  c := c * 5;
  // divisions slower with simulated int than doubles
  a := a div 5;
  b := b div 5;
  c := c div 5;
  a := a + b;
  b := b + c;
  c := c + a;
  // subtractions probably faster just like additions (not really tested :))
  a := a - a;
  b := b - b;
  c := c - c;
 end;
 result := a + b + c;
end;
function TestDoublePerformance : double;
var
 vIndex : integer;
 a : double;
 b : double;
 c : double;
begin
 a := 0;
 b := 1;
 c := 2;
 for vIndex := 0 to 10 * 1024 * 1024 do
 begin
  a := a + 1;
  b := b + 1;
  c := c + 1;
  a := a * 5;
  b := b * 5;
  c := c * 5;
  a := a / 5;
  b := b / 5;
  c := c / 5;
  a := a + b;
  b := b + c;
  c := c + a;
  a := a - a;
  b := b - b;
  c := c - c;
 end;
 result := a + b + c;
end;
var
 Tick1 : int64;
 Tick2 : int64;
 vLoop : integer;
begin
 for vLoop := 1 to 10 do
 begin
  sleep( 1000 );
  QueryPerformanceCounter( Tick1 );
  TestSimulatedInt64Performance;
  QueryPerformanceCounter( Tick2 );
  writeln( 'Simulated Int64 Ticks: ', Tick2-Tick1 );
  sleep( 1000 );
  QueryPerformanceCounter( Tick1 );
  TestDoublePerformance;
  QueryPerformanceCounter( Tick2 );
  writeln( 'Simulated Double Ticks: ', Tick2-Tick1 );
 end;
 readln;
end.
// *** End of Benchmark ***

Bye,
Skybuck.