http://www.da-soft.com/blogs/anydac-for-delphi-and-rad-studio-xe2.html
RAD Studio XE2
World Tour
At first, the RAD Studio XE2 is
here ! After filtering many marketing
words around the release, you will see, that almost nothing has
been filtered. That is really great Delphi release for many years,
even greater than Delphi 2009 (Unicode) and Delphi 2005 (new IDE).
It is like Delphi 2 (Win32), but even more greater ! Some new
features:
Windows x64 compiler - dcc64.exe;
Mac OS x32 compile - dccosx.exe;
Live Data Binding;
FireMonkey platform.
To learn more about RAD Studio XE2 you are invited to
the
General
There are some major differences between x32
and x64 compilation modes. Actually, some data types behaves
differently. Also, there are some changes and consequences to the
Delphi RTL and base classes. All that may require to review and
update your existing code before compiling it for
x64.
RAD Studio XE2 IDE itself is a 32 bit application. All design
time packages are 32 bit too. You design the application and code
the logic behind the way you are used too. The difference will
start at compiling and may require to set additional options. To
produce x64 application the dcc64.exe is used.
Language,
RTL, VCL Changes
When developing a code you should be aware of the following
differences in language and RTL between Delphi x32 and x64
compiling modes. And also about incorrect expectations.
Integer and Pointer data types. The data type sizes may be
different:
Type
DCC32
DCC64
Integer,
LongWord,
Cardinal
4
4
Int64,
UInt64
8
8
NativeInt,
NativeUInt
4
8
Pointer
4
8
THandle
4
8
Floating point data types. Extended is a synonym to
Double in x64 mode (but see TExtendedX87). The compiler codegen produces SSE2
instructions instead of FPU. That dramatically improves performance
of numeric intensive applications !
Compilers defines. The following symbols (some interesting) are
defined:
DCC32
DCC64
CPU386
CPUX86
WIN32
MSWINDOWS
VER230
UNICODE
CPUX64
WIN64
MSWINDOWS
VER230
UNICODE
Exception handling. Delphi x64 employs different exception
handling mechanisms, than Delphi x32. More about that - Uwe
Schuster Blog, RAD Studio XE2: Win64 exceptions and stack traces
on Win64 (JCL/JVCL 64) and OS X. Delphi x64 has limitation -
maximum 16 levels of nesting exceptions:
try
...
raise
except
on E1: Exception do
try
...
raise
except
on E2: Exception do
// 14 more nested try / except / raise - OK
// 15'th will lead to AV
end;
end;
Calling conventions. Delphi x64 supports only single calling
convention - Microsoft x64 calling convention (first 4 parameters
passed on rcx/xmm0; rdx/xmm1, r8/xmm2, r9/xmm3). All other
conventions, like stdcall, pascal are synonyms for
this one.
In x64 NativeInt / NativeUInt for-loop index variable is more
effective than Integer one:
var
i: NativeInt;
...
for i := 0 to N do ...;
ASM. Well ... x64 ASM is different - all stuffs must be
recoded.
Strings. String, UnicodeString, AnsiString are still limited to
2Gb.
Dynamic arrays. Are limited to 2G of elements on x32 and to 4T
of elements on x64.
TList. Is still limited to 2G of elements. The same applies to
other classes build around TList - TStringList, multiple classes in
System.Contnrs.pas and System.Generics.Collections.pas units,
etc.
TComponent. The Tag property
is NativeInt.
Ohh, yes ... There is no more BDE ! It is left in the 32 bit
world. One more reason to migrate to AnyDAC.
Setting Options
To compile AnyDAC x64 application, you will need to enable x64
platform for the project and make the
platform current. For that:
show "Project Manager";
select "Target Platforms" node;
right click on it and choose "Add Platform";
select 64-bit Windows platform and press OK.
You may optionally check / add / update Library Path for x64
platform. Note, that paths are different for different platforms.
For that:
choose Tools -> Options;
locate Environment Options ->
Delphi Options -> Library;
on the top right combo box choose "64-bit Windows";
adjust paths as needed.
Then you may adjust your project options. For that:
choose Project -> Options;
on the top right combo box choose a right combination of
configuration and platform;
adjust options as
needed.
Compiling
Now you can compile and run your AnyDAC application. All IDE
keyboard shortcuts, menu items are the same as for 32 bit.
To compile in command line you have to use DCC64.EXE compiler.
It has practically the same command line switches as DCC32.EXE. The
default configuration file is DCC64.CFG.
Debugging
Debugging is a bit different. The IDE is 32
bit. An application is 64 bit. So, the IDE does no
longer host the 64 bit debugger. The debugging process is
remote and the dbkw64_16_0.exe
serves as x64 debugging server. To
make that possible you have to enable remote debug
symbols. Hopefully IDE will enable it automatically for pre-XE2
projects. For that:
choose Project -> Options;
on the top right combo box choose "Debug configuration - 64-bit
Windows platform";
locate "Delphi Compiler" ->
"Linking";
mark "Include remote debug symbols" ON.
Running
Not much to say, just to run Task Manager and see that the
application is really 64-bit:
AnyDAC
Availability
AnyDAC for Delphi
Trial and Beta versions 5.0.2 are accessible from there. The final
5.0.3 will be released shortly after RAD Studio XE2 release
date.
AnyDAC beta version is accessible only to registered users with
active AnyDAC subscription.
AnyDAC trial version contains only 32 bit binaries. You can
design and develop your AnyDAC application with trial version as
for x32, as for x64. But to compile and run your applcation, you
will need the full AnyDAC version.
AnyDAC full version may be purchased for $399
from there.
The 1 year subscription allows to purchase AnyDAC
for Delphi today and receive all new versions releasing in 1 year
!
Changes
What we changed in AnyDAC to make it x64 compatible:
were introduced many generic data types to
enable simplified support of x32 and x64 platforms
for Delphi and FPC / Lazarus. For example:
{$IFDEF AnyDAC_64}
{$IFDEF AnyDAC_POSIX}
TADULongInt = UInt64;
{$ELSE}
TADULongInt = LongWord;
{$ENDIF}
{$ELSE}
TADULongInt = LongWord;
{$ENDIF}
{$IFDEF AnyDAC_D12}
TADNativeInt = NativeInt;
{$ELSE}
{$IFDEF AnyDAC_64}
TADNativeInt = Int64;
{$ELSE}
TADNativeInt = Integer;
{$ENDIF}
{$ENDIF}
TADCounter = {$IFDEF AnyDAC_64} Int64 {$ELSE} LongInt {$ENDIF};
reviewed a lot of places with pointer arithmetic. A lot of
changes like the following, from:
Pointer(LongWord(ABuffer) + AOffset)
to
Pointer(TADNativeUInt(ABuffer) + AOffset)
all ASM stuffs were replaced with highly optimized Delphi code.
That will allow later to use AnyDAC on non-Intel platforms
too.
all DBMS API headers translated into uADPhysXxxCLI.pas units
were updated to enable x64 support. For example
uADPhysMySQLCli.pas, from:
MYSQL_FIELD0510 = record
........
length: LongWord; // Width of column
max_length: LongWord; // Max width of selected set
........
end;
to:
my_ulong = TADULongInt;
MYSQL_FIELD0510 = record
........
length: my_ulong; // Width of column
max_length: my_ulong; // Max width of selected set
........
end;
some Integer and LongWord properties were re-typed to Int64 and
UInt64 to enable usage of DBMS x64 features. For example, TADQuery
property:
property RowsAffected: TADCounter read FRowsAffected;
some method parameters used to transfer "generic" data were
re-type like the following, from:
procedure Notify(AKind: TADDatSNotificationKind;
AReason: TADDatSNotificationReason; AParam1, AParam2: LongInt); overload;
to:
procedure Notify(AKind: TADDatSNotificationKind;
AReason: TADDatSNotificationReason; AParam1, AParam2: TADNativeInt); overload;
new driver configuration parameters were added. See details
later in the text.
the environment reporting was updated to diagnose x64 specific
issues.
some other minor changes were made.
DBMS Clients
Most of the DBMS vendors already provide x64 client libraries.
They must be installed to make AnyDAC x64 application working and
connecting to a DB. When x64 client is not installed, and even when
x32 client is installed, then an exception will be raised. More about that.
For example, the Oracle Windows x64 Instant Client may be
downloaded from there. When x64 client is not installed, then
will be raised:
[AnyDAC][Phys][Ora]-1309. OCI is not properly installed on this machine (NOE1/INIT)
AnyDAC SQLite driver supports encryption only in static linking
mode. At moment (5.0.3) in x64 mode only dynamic linking is
supported. So, in x64 mode encryption is not accessible. AnyDAC
installer installs on Windows x64 two sqlite3.dll versions:
x32 into SysWOW64 (v 3.7.7.1);
x64 into System32 (v 3.6.23.1).
Configuring AnyDAC drivers
The AnyDAC driver configuration file format was changed to add
support for Windows x64 and other platforms. Now VendorHome and
VendorLib parameters may have platform specific suffix. And there
may be specified few VendorXxx parameters for different platforms.
More about that.
For example, to configure AnyDAC Firebird driver you may
use:
[IB]
BaseDriverID=IB
VendorLibWin32=E:\ib\fb25\bin\fbclient.dll
VendorLibWin64=E:\ib\fb25_x64\bin\fbclient.dll
Other example for Oracle driver:
[Ora]
BaseDriverID=Ora
VendorHomeWin32=Ora11_32
VendorHomeWin64=Ora11_64
The TADPhysXxxxDriverLink components have only single VendorHome
and VendorLib property versions. These property values will be used
for the compiled platform. The same with VendorHome and VendorLib
parameters without a suffix in driver configuration file. For
example:
ADPhysMySQLDriverLink1.VendorLib :=
{$IFDEF WIN64} 'c:\MySQL\5.5_64\Bin\libmysql.dll' {$ENDIF}
{$IFDEF WIN32} 'c:\MySQL\5.5\Bin\libmysql.dll' {$ENDIF};
Performance
Here are the benchmark results for AnyDAC TADMemTable and
TClientDataSet. The benchmark is performed in x32 and x64 modes on
laptop with AMD Phenom II 1.8GHz, 4Gb and Windows 7 x64. Each test
processes 20k of records.
The x32 results:
The x64 results:
The benchmark shows that x32 code is about 10-30% more faster.
So, for the classic data access applications the x32 is OK. The
similar results we have for the AnyDAC Oracle driver.
Pros and Cons
The benefits an AnyDAC x64 application may get comparing to
x32:
load into memory the BLOB values greater than 2Gb. Worth to
have.
load into memory more than 0.5G of records. Hard to
imagine.
the affected rows count may be more than 4G. Could be.
the total consumed memory may be greater than 2Gb. Could
be.
improved numeric performance. Not for an average AnyDAC app,
really.
The drawbacks are:
slightly less performance.
no SQLite encryption.
Combining all above with the own application needs for x64 will
give you the correct vision - do you need or not the x64.
Conclusion
The x64 support is awaiting for a long time. And finally it is
here ! Should you migrate your applications to x64 or not - depends
on the application requirements.
Great that the Delphi supports more and more platforms ! We at
DA-SOFT Technologies plan to support all the Delphi platforms and
new technologies, like FireMonkey and Live Data Binding.
Further we will discuss the Live Data
Binding. Stay tuned !
More to read