Re: Where's the Speed?

*To*: mathgroup at smc.vnet.net*Subject*: [mg19814] Re: [mg19764] Where's the Speed?*From*: "Richard Bills" <Richard_Bills at email.msn.com>*Date*: Fri, 17 Sep 1999 01:36:56 -0400*Sender*: owner-wri-mathgroup at wolfram.com

Kevin, You did not give any details about how you implemented the Crank-Nicholson algorithm, or what functions that you used, so it is difficult to help you directly. However, I hope that the following information is helpful. I have implemented finite difference laser thermal modeling code in both Mathematica and C, and I did not experience the drastic speed differential that you describe. Based on my experience, optimized release C code is about 5 to 10 times faster than optimized Mathematica code for data array applications, although the Mathematica numerical results are more accurate since it keeps track of the number of significant digits and checks for indeterminate or out of range values. A more fair comparison would include additional code in the C version for handling precision issues and out of range values. In order to achieve this reasonable performance from Mathematica, I lumped the whole program into one compiled function using Compile[ ]. I also isolated and timed each part of the program, then experimented with different implementations to improve the speed of the function. This can be somewhat laborious, but it still takes orders of magnitude less time to write the whole application (graphics, user interface, other functions, I/O, etc.) in Mathematica than in C. I usually begin development without using Compile or machine precision, then I evolve the design to a more computationally efficient version using Compile once I am confident in the results. Compile uses a virtual machine interpreter. It is interesting to note that Java, which also uses a virtual machine interpreter (JVM), is about 2-3 times slower than optimized release C++ code. Mathematica's virtual machine is a much higher level interpreter and performs numerous precision and result checking, therefore it is not surprising to me that it is roughly 2 to 3 times slower than Java. Incidentally, the speed of the compiler in Mathematica Version 4 has been greatly improved, especially in the area of storage of values into arrays. Compiling also bypasses arbitrary precision math, which can be 25 times slower than machine precision math in Mathematica. For example, compare the computation times of these (on an ancient computer): b1 = Table[i^10 + 7, {i, 100000}]; // Timing (* arbitrary precision math *) {98.59 Second, Null} b1[[100000]] 100000000000000000000000000000000000000000000000007 b2 = Table[N[i]^10. + 7.0, {i, 100000}]; // Timing (* machine precision math *) {3.19 Second, Null} b2[[100000]] 1.*10^60 The C code shown below (Borland Builder 3.0) performs the same computation in 0.7 seconds ( 7 seconds for 10^6 values), and is therefore about 5 times faster than machine precision code in Mathematica. However, this C code does not give the correct result that Mathematica gives. _________________________________________________________________________ #pragma hdrstop #include <condefs.h> #include <time.h> #include <stdio.h> #include <dos.h> #include <math.h> //-------------------------------------------------------------------------- - #pragma argsused int main(int argc, char **argv) { time_t tstart,tend; tstart=time(NULL); double *data = new double[1000000]; for(int i=1; i<=1000000; i++) { data[i-1]=pow(i,10)+7; } tend=time(NULL); printf("computation time: %d\n", tend-tstart); printf("end result: %f\n",data[1000000-1]); int tin; scanf("%d", &tin); return 0; } ____________________________________________________________________ If the computation is replaced with the expression ((i*2.3467) + 7.)/3., the C version is only 4 times faster than Mathematica, which is not bad, all things considered. I think it would be helpful if WRI published a book or technical notes on computational optimization in Mathematica. They are in the best position to do so. Hope that helps. Sincerely, Richard E. Bills Tucson, AZ, USA -----Original Message----- From: Kevin J. McCann <kevin.mccann at jhuapl.edu> To: mathgroup at smc.vnet.net Subject: [mg19814] [mg19764] Where's the Speed? >I have read and heard a lot of hype about Mathematica 4.0 > >"featuring a > New Generation of > Fast Numerics" > >e.g. on www.wri.com . > >However, in the real world it is hard to find anything to get excited about. >I have had several disappointing results from 4.0, here are the latest: > >On a P450/NT I ran a very simple Crank-Nicholson integration of a >one-dimensional quantum free-particle wave-packet with x-dimensioned to 1001 >points and time to 401 points - no error checks or adaptive stepsize, just >plug-and-chug. Runtime under 4.0 was 501 seconds, 3.0 was 480 seconds, but >who's quibbling; however, in FORTRAN this ran in 8 seconds. I don't even >consider this to be "fast numerics", but 501 seconds sure isn't. I would >like to know where all this speed is so I can use some of it, or am I >missing something? > >When I ran the FORTRAN code and then read it into Mathematica, it still was faster >than the Mathematica code alone, although the ReadList I used on the ASCII >file did take some time. When I upped the dimensions to 2001 x 1001, the >FORTRAN ran in about 40 s - most of this is for the output; however, when I >tried to read it in to Mathematica, it took forever, and on the subsequent plot it >bombed the Kernel. I then made the mistake of saving the NB which managed >to acquire an error so that I can't open it anymore - 6 Mb of useless NB! > > > >-- > >Kevin J. McCann >Johns Hopkins University APL > > > > >