Difference between revisions of "Avoiding implicit try finally section"

From Free Pascal wiki
(code highlight and category)
m (Text replace - "delphi>" to "syntaxhighlight>")
Line 2: Line 2:
  
 
E.g. procedure like
 
E.g. procedure like
<delphi>procedure P;
+
<syntaxhighlight>procedure P;
 
var  
 
var  
 
   S: AnsiString;
 
   S: AnsiString;
 
begin
 
begin
 
   ... do something with S ...
 
   ... do something with S ...
end;</delphi>
+
end;</syntaxhighlight>
  
 
is actually compiled like  
 
is actually compiled like  
  
<delphi>procedure P;
+
<syntaxhighlight>procedure P;
 
var  
 
var  
 
   S: AnsiString;
 
   S: AnsiString;
Line 19: Line 19:
 
   ... do something with S ...
 
   ... do something with S ...
 
  finally Finalize(S) end;
 
  finally Finalize(S) end;
end;</delphi>
+
end;</syntaxhighlight>
  
 
This is needed, to be sure that reference-count of S will be properly decremented when procedure P will exit with exception. But in some cases this can significantly affect the speed of given code.  
 
This is needed, to be sure that reference-count of S will be properly decremented when procedure P will exit with exception. But in some cases this can significantly affect the speed of given code.  
Line 57: Line 57:
 
* Shows a trick how to avoid implicit try ... finally block (without changing the meaning or safety of the code) in some cases (when you don't need to actually use that AnsiString/Variant/something every time procedure is called but e.g. only if some parameter has some particular value).
 
* Shows a trick how to avoid implicit try ... finally block (without changing the meaning or safety of the code) in some cases (when you don't need to actually use that AnsiString/Variant/something every time procedure is called but e.g. only if some parameter has some particular value).
  
<delphi>{$mode objfpc}{$H+}
+
<syntaxhighlight>{$mode objfpc}{$H+}
  
 
uses
 
uses
Line 109: Line 109:
 
  for i := 0 to TestCount do Foo_Faster(i);
 
  for i := 0 to TestCount do Foo_Faster(i);
 
  Writeln('Time of Foo_Faster: ', Clock - Start);
 
  Writeln('Time of Foo_Faster: ', Clock - Start);
end.</delphi>
+
end.</syntaxhighlight>
  
 
[[Category:Tutorials]]
 
[[Category:Tutorials]]

Revision as of 13:50, 24 March 2012

Sometimes it's useful to know that compiler can wrap some code in implicit try ... finally block. Essentialy this is needed when you use variable of any type that must be initialized / finalized (i.e. standard procedures Initialize() and Finalize() do something meaningful with it), like AnsiStrings or Variants or dynamic arrays. Or (only in FPC earlier than 2004-12-26) resource strings.

E.g. procedure like

procedure P;
var 
  S: AnsiString;
begin
  ... do something with S ...
end;

is actually compiled like

procedure P;
var 
  S: AnsiString;
begin
 Initialize(S);
 try
  ... do something with S ...
 finally Finalize(S) end;
end;

This is needed, to be sure that reference-count of S will be properly decremented when procedure P will exit with exception. But in some cases this can significantly affect the speed of given code.

Here's a link to archived discussion on fpc-devel list regarding this issue, with subject "TList slowness in classes" : http://www.mail-archive.com/fpc-devel@lists.freepascal.org/msg01367.html

Note that ansistring temp vars can be created implicitly. The only real way to be sure what's going on is to read the asm output.

Possible solutions

  • NEW! use {$implicitexceptions off} Make sure however that you use this only on release versions of your program. Debugging can become a problem with that switch especially locating memory leaks and corruption.
  • split of rarely used code that causes an implicit try finally into separate procedures. (you can use procedures in procedures) (verified)
  • use const parameters rather than value parameters. (avoids need to change refcount but temps could still be an issue).
  • use global vars. (have to be careful with reentrency issues here though and temps could still be an issue).
  • use non refcounted types like shortstrings.

RISKS and when to apply

These exception frames are generated for a reason. If you leave them out any exception in that code will leave a memory leak

Recently (2007-10-14 in 2.3.x branch) I added $implicitexceptions to the strutils unit, sysutils will follow if this doesn't raise serious problems. For this, the following approach was followed:

  • A routine that calls a routine that raises exceptions is unsafe. (e.g. strtoint, but not strtointdef)
  • A routine that raises exceptions itself is unsafe.
  • Very large routines are not worth the trouble, because of the risk and low gains (e.g. date formatting routines)
  • Floating point use can raise exceptions that are converted into catchable exceptions by sysutils. I'm not sure if this really is sufficient reason, but I skipped FP using routines initially for this reason.

If you detect problems with these changes please contact Marco.

Demo program

And below is a small demo program that

  • When run, clearly shows that avoiding an implicit try ... finally block can make code a lot faster. When I run this program on my system, I get
Time of Foo_Normal: 141
Time of Foo_Faster: 17
  • Shows a trick how to avoid implicit try ... finally block (without changing the meaning or safety of the code) in some cases (when you don't need to actually use that AnsiString/Variant/something every time procedure is called but e.g. only if some parameter has some particular value).
{$mode objfpc}{$H+}

uses
  {BaseUnix, Unix needed only to implement Clock} BaseUnix, Unix,
  SysUtils;

function Clock: Int64;
var Dummy: tms;
begin
 Clock := FpTimes(Dummy);
end;

procedure Foo_Normal(i: Integer);
var S: string;
begin
 if i = -1 then
 begin
  S := 'Some operation with AnsiString';
  raise Exception.Create(S);
 end;
end;

procedure Foo_Faster(i: Integer);

  procedure RaiseError;
  var S: string;
  begin
   S := 'Some operation with AnsiString';
   raise Exception.Create(S);
  end;

begin
 if i = -1 then RaiseError;
end;

{ Note that when I call Foo_Normal and Foo_ResourceString
  i is always >= 0 so Exception is never actually raised.
  So string constants SNormal and SResString are not really used. }

const
  TestCount = 10000000;
var
  i: Integer;
  Start: Int64;
begin
 Start := Clock;
 for i := 0 to TestCount do Foo_Normal(i);
 Writeln('Time of Foo_Normal: ', Clock - Start);

 Start := Clock;
 for i := 0 to TestCount do Foo_Faster(i);
 Writeln('Time of Foo_Faster: ', Clock - Start);
end.