digitalmars.D - try-catch exception handling speed should be improved!.
- Lord Syl (86/86) May 22 2004 Hey, I just made a quick test, in order to see method calls' speed.
- Ilya Minkov (10/14) May 22 2004 No, speed of try/catch shouldn't be improved. The main guideline for
- Roel Mathys (5/25) May 22 2004 I would phrase it like this: performance isn't the prime objective of
- Lord Syl (8/17) May 22 2004 You didn't take into account that, although the "absolute" difference is...
- Norbert Nemec (5/17) May 22 2004 Sure? If I understand the code correctly, it measures the time of the
- Lord Syl (5/9) May 22 2004 You got it :) . The code measures the setup time, as it's important, spe...
- Matthew (4/90) May 22 2004 AFAIK, D's exceptions are layered on top of the Win32 SEH, whereas Java ...
- Walter (8/8) May 22 2004 There is some overhead in a function added if exception 'catcher' code
- Phill (27/113) May 23 2004 I used the same code and I got a different result than you, which follow...
Hey, I just made a quick test, in order to see method calls' speed.
When I compared the results to Java's, I found interesting that Java (running
via JVM) had beaten D in the Try-Catch exception handling speed area, while
running slow as hell in the rest.
Here are the results:
<[D] 500 Million Calls speed test >>
TryCatched - 13750 ms
!TryCatched - 1933 ms
Directly - 1292 ms
Compiler version is 0.90, with commandline -O -release -inline
<[Java] 500 Million Calls speed test >>
TryCatched - 10926 ms
!TryCatched - 4406 ms
Directly - 4597 ms
Using Java VM v1.50 beta from Sun
Tests were done on a Duron 800(6x133) processor with 640Mb 266Mhz RAM under
Windows XP.
[D source code]
import std.date;
int main (char[][] args)
{
int i, j=-42;
long START_TC=getUTCtime();
for (i=0; i<500000000; i++) j=TCcall(i);
long END_TC=getUTCtime();
long START=getUTCtime();
for (i=0; i<500000000; i++) j=Ccall(i);
long END=getUTCtime();
long start=getUTCtime();
for(i=0; i<500000000; i++) j=i+4;
long end=getUTCtime();
printf("(TryCatched) Elapsed (ms) : %d\n",(END_TC-START_TC));
printf("(!TryCatched) Elapsed (ms) : %d\n",(END-START));
printf("(Directly) Elapsed (ms) : %d\n",(end-start));
return 0;
}
static final int TCcall(int I)
{
try
{
I+=4;
return I;
}
catch(Error e) { return I; }
}
static final int Ccall(int I)
{
I+=4;
return I;
}
[Java code]
public class PointlessSpeedTest
{
public static void main (String[] args)
{
int i, j=-42;
long START_TC=System.currentTimeMillis();
for (i=0; i<500000000; i++) j=TCcall(i);
long END_TC=System.currentTimeMillis();
long START=System.currentTimeMillis();
for (i=0; i<500000000; i++) j=Ccall(i);
long END=System.currentTimeMillis();
long start=System.currentTimeMillis();
for(i=0; i<500000000; i++) j=i+4;
long end=System.currentTimeMillis();
System.out.println("(TryCatched) Elapsed: "+(END_TC-START_TC)+" ms");
System.out.println("(!TryCatched) Elapsed: "+(END-START)+" ms");
System.out.println("(Directly) Elapsed: "+(end-start)+" ms");
}
private static int TCcall(int I)
{
try
{
I+=4;
return I;
}
catch(Exception ex) { return I; }
}
private static int Ccall(int I)
{
I+=4;
return I;
}
}
May 22 2004
Lord Syl schrieb:Hey, I just made a quick test, in order to see method calls' speed. When I compared the results to Java's, I found interesting that Java (running via JVM) had beaten D in the Try-Catch exception handling speed area, while running slow as hell in the rest.No, speed of try/catch shouldn't be improved. The main guideline for implementation of exception handling is that it should slow down the normal run of the program - i.e. without exceptions being thrown - as little as possible. And your test tells me rather that DigitalMars implementation succeeds in that well. And well, 1/3 difference is not important - exceptions can take even much longer time to process depending on circumstances and should not be used in performance sensitive code. It's a tradeoff which was made wisely. -eye
May 22 2004
Roel Mathys <roel.mathys yucom.be> Ilya Minkov wrote:Lord Syl schrieb:I would phrase it like this: performance isn't the prime objective of exception handling, but I don't see an issue in it being optimized performance wise rmHey, I just made a quick test, in order to see method calls' speed. When I compared the results to Java's, I found interesting that Java (running via JVM) had beaten D in the Try-Catch exception handling speed area, while running slow as hell in the rest.No, speed of try/catch shouldn't be improved. The main guideline for implementation of exception handling is that it should slow down the normal run of the program - i.e. without exceptions being thrown - as little as possible. And your test tells me rather that DigitalMars implementation succeeds in that well. And well, 1/3 difference is not important - exceptions can take even much longer time to process depending on circumstances and should not be used in performance sensitive code. It's a tradeoff which was made wisely. -eye
May 22 2004
In article <c8ne2r$i2l$1 digitaldaemon.com>, Ilya Minkov says...No, speed of try/catch shouldn't be improved. The main guideline for implementation of exception handling is that it should slow down the normal run of the program - i.e. without exceptions being thrown - as little as possible. And your test tells me rather that DigitalMars implementation succeeds in that well. And well, 1/3 difference is not important - exceptions can take even much longer time to process depending on circumstances and should not be used in performance sensitive code. It's a tradeoff which was made wisely. -eyeYou didn't take into account that, although the "absolute" difference is a 30%, the other results were there for something. According to those results, the (exception handled)/(non-exception handled) proportion in Java is around 250%, while D shows there a 700%, so some improvement is possible there. At all, one of the points of exception handling is to avoid the need to use "defensive code" to improve readability and increase performance.
May 22 2004
Ilya Minkov wrote:Lord Syl schrieb:Sure? If I understand the code correctly, it measures the time of the try/catch block *without throwing exceptions*, which would mean, that the DM compiler really does not follow your "main guideline". Of course "throw" need not be optimized for speed, but try/catch should not cost that much!Hey, I just made a quick test, in order to see method calls' speed. When I compared the results to Java's, I found interesting that Java (running via JVM) had beaten D in the Try-Catch exception handling speed area, while running slow as hell in the rest.No, speed of try/catch shouldn't be improved. The main guideline for implementation of exception handling is that it should slow down the normal run of the program - i.e. without exceptions being thrown - as little as possible. And your test tells me rather that DigitalMars implementation succeeds in that well.
May 22 2004
In article <c8nnp6$uil$3 digitaldaemon.com>, Norbert Nemec says...Sure? If I understand the code correctly, it measures the time of the try/catch block *without throwing exceptions*, which would mean, that the DM compiler really does not follow your "main guideline". Of course "throw" need not be optimized for speed, but try/catch should not cost that much!You got it :) . The code measures the setup time, as it's important, specially for system apps, that if a set of methods which are called continuously are written using exception handling, if there is no error on the data they receive (no exception is caused) then it isn't slowed down too much.
May 22 2004
AFAIK, D's exceptions are layered on top of the Win32 SEH, whereas Java does
not.
Check out http://www.windevnet.com/wdn/webextra/2003/0313/
"Lord Syl" <Lord_member pathlink.com> wrote in message
news:c8ncf8$g3r$1 digitaldaemon.com...
Hey, I just made a quick test, in order to see method calls' speed.
When I compared the results to Java's, I found interesting that Java (running
via JVM) had beaten D in the Try-Catch exception handling speed area, while
running slow as hell in the rest.
Here are the results:
<[D] 500 Million Calls speed test >>
TryCatched - 13750 ms
!TryCatched - 1933 ms
Directly - 1292 ms
Compiler version is 0.90, with commandline -O -release -inline
<[Java] 500 Million Calls speed test >>
TryCatched - 10926 ms
!TryCatched - 4406 ms
Directly - 4597 ms
Using Java VM v1.50 beta from Sun
Tests were done on a Duron 800(6x133) processor with 640Mb 266Mhz RAM under
Windows XP.
[D source code]
import std.date;
int main (char[][] args)
{
int i, j=-42;
long START_TC=getUTCtime();
for (i=0; i<500000000; i++) j=TCcall(i);
long END_TC=getUTCtime();
long START=getUTCtime();
for (i=0; i<500000000; i++) j=Ccall(i);
long END=getUTCtime();
long start=getUTCtime();
for(i=0; i<500000000; i++) j=i+4;
long end=getUTCtime();
printf("(TryCatched) Elapsed (ms) : %d\n",(END_TC-START_TC));
printf("(!TryCatched) Elapsed (ms) : %d\n",(END-START));
printf("(Directly) Elapsed (ms) : %d\n",(end-start));
return 0;
}
static final int TCcall(int I)
{
try
{
I+=4;
return I;
}
catch(Error e) { return I; }
}
static final int Ccall(int I)
{
I+=4;
return I;
}
[Java code]
public class PointlessSpeedTest
{
public static void main (String[] args)
{
int i, j=-42;
long START_TC=System.currentTimeMillis();
for (i=0; i<500000000; i++) j=TCcall(i);
long END_TC=System.currentTimeMillis();
long START=System.currentTimeMillis();
for (i=0; i<500000000; i++) j=Ccall(i);
long END=System.currentTimeMillis();
long start=System.currentTimeMillis();
for(i=0; i<500000000; i++) j=i+4;
long end=System.currentTimeMillis();
System.out.println("(TryCatched) Elapsed: "+(END_TC-START_TC)+" ms");
System.out.println("(!TryCatched) Elapsed: "+(END-START)+" ms");
System.out.println("(Directly) Elapsed: "+(end-start)+" ms");
}
private static int TCcall(int I)
{
try
{
I+=4;
return I;
}
catch(Exception ex) { return I; }
}
private static int Ccall(int I)
{
I+=4;
return I;
}
}
May 22 2004
There is some overhead in a function added if exception 'catcher' code exists. This is necessary in order to be compatible with Win32 structured exception handling. The linux version, however, does not have such overhead since it is based on static tables (though there is extra overhead based on the need to use EBP as a frame pointer). I think your sample code overstates the overhead, as it compares with a trivial function that can be optimized into two instructions, which is not at all typical of functions which need to generate exception frames.
May 22 2004
I used the same code and I got a different result than you, which follows: C:\Documents and Settings\me.ME\Desktop>javac PointlessSpeedTest.java C:\Documents and Settings\me.ME\Desktop>java PointlessSpeedTest (TryCatched) Elapsed: 5227 ms (!TryCatched) Elapsed: 1913 ms (Directly) Elapsed: 1973 ms C:\Documents and Settings\me.ME\Desktop>dmd -O -release -inline test.d c:\dmd\bin\..\..\dm\bin\link.exe test,,,user32+kernel32/noi; C:\Documents and Settings\me.ME\Desktop>test (TryCatched) Elapsed (ms) : 6410 (!TryCatched) Elapsed (ms) : 911 (Directly) Elapsed (ms) : 611 I have WinXP pro with 256 megs ram and an Athlon 2100. I will add that when I used to use Java, I used try catch to my advantage, It saves hassles trying to get the length of an array for example, and you dont need to check the bounds at all, so its a bit faster in loops. But with D's speed and the fantastic foreach it has, none of this is necessary. Phill. "Lord Syl" <Lord_member pathlink.com> wrote in message news:c8ncf8$g3r$1 digitaldaemon.com...Hey, I just made a quick test, in order to see method calls' speed. When I compared the results to Java's, I found interesting that Java(runningvia JVM) had beaten D in the Try-Catch exception handling speed area,whilerunning slow as hell in the rest. Here are the results: <[D] 500 Million Calls speed test >> TryCatched - 13750 ms !TryCatched - 1933 ms Directly - 1292 ms Compiler version is 0.90, with commandline -O -release -inline <[Java] 500 Million Calls speed test >> TryCatched - 10926 ms !TryCatched - 4406 ms Directly - 4597 ms Using Java VM v1.50 beta from Sun Tests were done on a Duron 800(6x133) processor with 640Mb 266Mhz RAMunderWindows XP. [D source code] import std.date; int main (char[][] args) { int i, j=-42; long START_TC=getUTCtime(); for (i=0; i<500000000; i++) j=TCcall(i); long END_TC=getUTCtime(); long START=getUTCtime(); for (i=0; i<500000000; i++) j=Ccall(i); long END=getUTCtime(); long start=getUTCtime(); for(i=0; i<500000000; i++) j=i+4; long end=getUTCtime(); printf("(TryCatched) Elapsed (ms) : %d\n",(END_TC-START_TC)); printf("(!TryCatched) Elapsed (ms) : %d\n",(END-START)); printf("(Directly) Elapsed (ms) : %d\n",(end-start)); return 0; } static final int TCcall(int I) { try { I+=4; return I; } catch(Error e) { return I; } } static final int Ccall(int I) { I+=4; return I; } [Java code] public class PointlessSpeedTest { public static void main (String[] args) { int i, j=-42; long START_TC=System.currentTimeMillis(); for (i=0; i<500000000; i++) j=TCcall(i); long END_TC=System.currentTimeMillis(); long START=System.currentTimeMillis(); for (i=0; i<500000000; i++) j=Ccall(i); long END=System.currentTimeMillis(); long start=System.currentTimeMillis(); for(i=0; i<500000000; i++) j=i+4; long end=System.currentTimeMillis(); System.out.println("(TryCatched) Elapsed: "+(END_TC-START_TC)+" ms"); System.out.println("(!TryCatched) Elapsed: "+(END-START)+" ms"); System.out.println("(Directly) Elapsed: "+(end-start)+" ms"); } private static int TCcall(int I) { try { I+=4; return I; } catch(Exception ex) { return I; } } private static int Ccall(int I) { I+=4; return I; } }
May 23 2004