* Benchmark Ada, please
@ 2014-07-04 17:23 Victor Porton
2014-07-05 12:34 ` Guillaume Foliard
0 siblings, 1 reply; 11+ messages in thread
From: Victor Porton @ 2014-07-04 17:23 UTC (permalink / raw)
Somebody, write an Ada benchmark for this comparison of programming
languages:
https://github.com/jesusfv/Comparison-Programming-Languages-Economics
It seems that C++ was the fastest (faster than Fortran), but Ada may be even
faster.
If we succeed, we would advertise Ada as the fastest(!) programming language
(after assembler).
See also:
https://github.com/jesusfv/Comparison-Programming-Languages-Economics/issues/15
--
Victor Porton - http://portonvictor.org
^ permalink raw reply [flat|nested] 11+ messages in thread
* Re: Benchmark Ada, please
2014-07-04 17:23 Benchmark Ada, please Victor Porton
@ 2014-07-05 12:34 ` Guillaume Foliard
2014-07-05 13:00 ` Niklas Holsti
` (2 more replies)
0 siblings, 3 replies; 11+ messages in thread
From: Guillaume Foliard @ 2014-07-05 12:34 UTC (permalink / raw)
Victor Porton wrote:
> Somebody, write an Ada benchmark for this comparison of programming
> languages:
>
> https://github.com/jesusfv/Comparison-Programming-Languages-Economics
Here is it:
---------------------------------------------------------------------
with Ada.Execution_Time;
with Ada.Numerics.Long_Elementary_Functions;
with Ada.Real_Time;
with Ada.Text_IO;
use Ada.Numerics.Long_Elementary_Functions;
use type Ada.Execution_Time.CPU_Time;
procedure Rbc_Ada
is
Grid_Capital_Length : constant := 17820;
Grid_Productivity_Length : constant := 5;
type Grid_Capital_Index is
new Integer range 0 .. Grid_Capital_Length - 1;
type Grid_Productivity_Index is
new Integer range 0 .. Grid_Productivity_Length - 1;
type Grid_Array_Type is
array (Grid_Capital_Index, Grid_Productivity_Index)
of Long_Float;
Null_Grid : constant Grid_Array_Type := (others => (others => 0.0));
-- 1. Calibration
-- Elasticity of output w.r.t. capital
Alpha : constant Long_Float := 0.33333333333;
-- Discount factor
Beta : constant Long_Float := 0.95;
-- Productivity values
Productivities : constant
array (Grid_Productivity_Index)
of Long_Float :=
(0.9792, 0.9896, 1.0000, 1.0106, 1.0212);
-- Transition matrix
Transition : constant
array (Grid_Productivity_Index, Grid_Productivity_Index)
of Long_Float :=
((0.9727, 0.0273, 0.0000, 0.0000, 0.0000),
(0.0041, 0.9806, 0.0153, 0.0000, 0.0000),
(0.0000, 0.0082, 0.9837, 0.0082, 0.0000),
(0.0000, 0.0000, 0.0153, 0.9806, 0.0041),
(0.0000, 0.0000, 0.0000, 0.0273, 0.9727));
-- 2. Steady State
Capital_Steady_State : constant Long_Float :=
(Alpha * Beta) ** (1.0 / (1.0 - Alpha));
Output_Steady_State : constant Long_Float :=
Capital_Steady_State ** Alpha;
Consumption_Steady_State : constant Long_Float :=
Output_Steady_State - Capital_Steady_State;
Grid_Capital_Next_Index : Grid_Capital_Index;
Grid_Capital : array (Grid_Capital_Index) of Long_Float :=
(others => 0.0);
Output : Grid_Array_Type := Null_Grid;
Value_Function : Grid_Array_Type := Null_Grid;
Value_Function_New : Grid_Array_Type := Null_Grid;
Policy_Function : Grid_Array_Type := Null_Grid;
Expected_Value_Function : Grid_Array_Type := Null_Grid;
Max_Difference : Long_Float := 10.0;
Diff : Long_Float;
Diff_High_So_Far : Long_Float;
Tolerance : constant := 0.0000001;
Value_High_So_Far : Long_Float;
Value_Provisional : Long_Float;
Consumption : Long_Float;
Capital_Choice : Long_Float;
Iteration : Integer := 0;
Cpu_Time_Start : Ada.Execution_Time.CPU_Time;
Cpu_Time_End : Ada.Execution_Time.CPU_Time;
begin
Cpu_Time_Start := Ada.Execution_Time.Clock;
Ada.Text_IO.Put_Line
("Output =" & Output_Steady_State'Img
& ", Capital =" & Capital_Steady_State'Img
& ", Consumption =" & Consumption_Steady_State'Img);
-- We generate the grid of capital
for Index in Grid_Capital'Range
loop
Grid_Capital (Index) :=
0.5 * Capital_Steady_State + 0.00001 * Long_Float (Index);
end loop;
-- We pre-build output for each point in the grid
for Productivity_Index in Grid_Productivity_Index
loop
for Capital_Index in Grid_Capital_Index
loop
Output (Capital_Index, Productivity_Index) :=
Productivities (Productivity_Index)
* Grid_Capital (Capital_Index) ** Alpha;
end loop;
end loop;
-- Main iteration
while Max_Difference > Tolerance
loop
for Productivity_Index in Grid_Productivity_Index
loop
for Capital_Index in Grid_Capital_Index
loop
Expected_Value_Function (Capital_Index, Productivity_Index) :=
0.0;
for Productivity_Next_Index in Grid_Productivity_Index
loop
Expected_Value_Function (Capital_Index, Productivity_Index)
:=
Expected_Value_Function (Capital_Index,
Productivity_Index)
+ Transition (Productivity_Index, Productivity_Next_Index)
* Value_Function (Capital_Index, Productivity_Next_Index);
end loop;
end loop;
end loop;
for Productivity_Index in Grid_Productivity_Index
loop
-- We start from previous choice (monotonicity of policy function)
Grid_Capital_Next_Index := 0;
for Capital_Index in Grid_Capital_Index
loop
Value_High_So_Far := -100000.0;
Capital_Choice := Grid_Capital (0);
for Capital_Next_Index in
Grid_Capital_Next_Index .. Grid_Capital_Index'Last
loop
Consumption :=
Output (Capital_Index, Productivity_Index)
- Grid_Capital (Capital_Next_Index);
Value_Provisional :=
(1.0 - Beta) * Log (Consumption)
+ Beta * Expected_Value_Function (Capital_Next_Index,
Productivity_Index);
if Value_Provisional > Value_High_So_Far
then
Value_High_So_Far := Value_Provisional;
Capital_Choice := Grid_Capital (Capital_Next_Index);
Grid_Capital_Next_Index := Capital_Next_Index;
else
exit;
end if;
Value_Function_New (Capital_Index, Productivity_Index) :=
Value_High_So_Far;
Policy_Function (Capital_Index, Productivity_Index) :=
Capital_Choice;
end loop;
end loop;
end loop;
Diff_High_So_Far := -100000.0;
for Productivity_Index in Grid_Productivity_Index
loop
for Capital_Index in Grid_Capital_Index
loop
Diff :=
abs (Value_Function (Capital_Index, Productivity_Index)
- Value_Function_New (Capital_Index,
Productivity_Index));
if Diff > Diff_High_So_Far
then
Diff_High_So_Far := Diff;
end if;
Value_Function (Capital_Index, Productivity_Index)
:= Value_Function_New (Capital_Index, Productivity_Index);
end loop;
end loop;
Max_Difference := Diff_High_So_Far;
Iteration := Iteration + 1;
if Iteration mod 10 = 0 or Iteration = 1
then
Ada.Text_IO.Put_Line ("Iteration =" & Iteration'Img
& ", Sup Diff =" & Max_Difference'Img);
end if;
end loop;
Ada.Text_IO.Put_Line ("Iteration =" & Iteration'Img
& ", Sup Diff =" & Max_Difference'Img);
Ada.Text_IO.New_Line;
Ada.Text_IO.Put_Line ("My check =" & Policy_Function (999, 2)'Img);
Ada.Text_IO.New_Line;
Cpu_Time_End := Ada.Execution_Time.Clock;
Ada.Text_IO.Put_Line
("Elapsed time is ="
& Ada.Real_Time.To_Duration (Cpu_Time_End - Cpu_Time_Start)'Img);
end Rbc_Ada;
---------------------------------------------------------------------
This is mostly a line to line translation from RBC_CPP.cpp. I have
added a few type declarations though.
> It seems that C++ was the fastest (faster than Fortran), but Ada may be
> even faster.
Here are the numbers with GNAT GPL 2014 on a Core2 Q9650 @ 3.00GHz:
$ gnatmake -O3 rbc_ada.adb
$ time ./rbc_ada
...
Elapsed time is = 1.966112682
As for the C++ version:
$ g++ -o testc -O3 RBC_CPP.cpp
$ time ./testc
...
Elapsed time is = 3.12033
So the Ada version is significantly faster. I suppose it is mainly because
the Ada compiler has vectorized more loops than the C++ compiler (add -
ftree-vectorizer-verbose=2 to the above compilation commands to check by
yourself).
> If we succeed, we would advertise Ada as the fastest(!) programming
> language (after assembler).
Feel free to advertise, using this Ada code as you wish.
--
Guillaume Foliard
^ permalink raw reply [flat|nested] 11+ messages in thread
* Re: Benchmark Ada, please
2014-07-05 12:34 ` Guillaume Foliard
@ 2014-07-05 13:00 ` Niklas Holsti
2014-07-05 17:00 ` Guillaume Foliard
2014-07-05 16:33 ` Simon Wright
2014-07-06 17:24 ` Dirk Heinrichs
2 siblings, 1 reply; 11+ messages in thread
From: Niklas Holsti @ 2014-07-05 13:00 UTC (permalink / raw)
On 14-07-05 14:34 , Guillaume Foliard wrote:
> Victor Porton wrote:
>
>> Somebody, write an Ada benchmark for this comparison of programming
>> languages:
>>
>> https://github.com/jesusfv/Comparison-Programming-Languages-Economics
>
> Here is it:
[most of code snipped]
> Cpu_Time_End := Ada.Execution_Time.Clock;
I have a question about this, see below.
> Ada.Text_IO.Put_Line
> ("Elapsed time is ="
> & Ada.Real_Time.To_Duration (Cpu_Time_End - Cpu_Time_Start)'Img);
> end Rbc_Ada;
> ---------------------------------------------------------------------
>
> This is mostly a line to line translation from RBC_CPP.cpp. I have
> added a few type declarations though.
>
>> It seems that C++ was the fastest (faster than Fortran), but Ada may be
>> even faster.
>
> Here are the numbers with GNAT GPL 2014 on a Core2 Q9650 @ 3.00GHz:
>
> $ gnatmake -O3 rbc_ada.adb
> $ time ./rbc_ada
> ...
> Elapsed time is = 1.966112682
>
>
> As for the C++ version:
>
> $ g++ -o testc -O3 RBC_CPP.cpp
> $ time ./testc
> ...
> Elapsed time is = 3.12033
Are you sure that Ada.Execution_Time.Clock gives numbers that can be
compared with the get_cpu_time() function in the C++ version? For a
program running under an OS, it is not evident what should be included
in the "processor time" for a program (program loading, process
creation, interrupts, I/O, page faults, ...).
What did the "time" command output in your tests?
Just to be sure that the claim "Ada is faster" is really motivated.
Which would be very nice.
--
Niklas Holsti
Tidorum Ltd
niklas holsti tidorum fi
. @ .
^ permalink raw reply [flat|nested] 11+ messages in thread
* Re: Benchmark Ada, please
2014-07-05 12:34 ` Guillaume Foliard
2014-07-05 13:00 ` Niklas Holsti
@ 2014-07-05 16:33 ` Simon Wright
2014-07-05 18:25 ` Guillaume Foliard
2014-07-06 17:24 ` Dirk Heinrichs
2 siblings, 1 reply; 11+ messages in thread
From: Simon Wright @ 2014-07-05 16:33 UTC (permalink / raw)
Guillaume Foliard <guifo@wanadoo.fr> writes:
I did much the same as you. I wish I'd started from the F90 version
rather than the C++ one, it's *much* cleaner.
> Here are the numbers with GNAT GPL 2014 on a Core2 Q9650 @ 3.00GHz:
>
> $ gnatmake -O3 rbc_ada.adb
> $ time ./rbc_ada
> ...
> Elapsed time is = 1.966112682
>
>
> As for the C++ version:
>
> $ g++ -o testc -O3 RBC_CPP.cpp
> $ time ./testc
> ...
> Elapsed time is = 3.12033
>
> So the Ada version is significantly faster. I suppose it is mainly because
> the Ada compiler has vectorized more loops than the C++ compiler (add -
> ftree-vectorizer-verbose=2 to the above compilation commands to check by
> yourself).
On Mac OS X (2.5 GHz Intel Core i5) I found the reverse, both with FSF
GCC 4.9.0 and GNAT GPL 2014; C++ took ~ 1s, Ada took ~ 2s.
With GCC 4.9.0, gfortran was approximately the same as C++.
Apple's C++ (Xcode 5.1.1) was approximately the same as GCC's.
-ftree-vectorizer-verbose=2 had no effect with FSF GCC.
^ permalink raw reply [flat|nested] 11+ messages in thread
* Re: Benchmark Ada, please
2014-07-05 13:00 ` Niklas Holsti
@ 2014-07-05 17:00 ` Guillaume Foliard
2014-07-05 18:29 ` Niklas Holsti
0 siblings, 1 reply; 11+ messages in thread
From: Guillaume Foliard @ 2014-07-05 17:00 UTC (permalink / raw)
Hello,
Niklas Holsti wrote:
> On 14-07-05 14:34 , Guillaume Foliard wrote:
>> Here are the numbers with GNAT GPL 2014 on a Core2 Q9650 @ 3.00GHz:
>>
>> $ gnatmake -O3 rbc_ada.adb
>> $ time ./rbc_ada
>> ...
>> Elapsed time is = 1.966112682
>>
>>
>> As for the C++ version:
>>
>> $ g++ -o testc -O3 RBC_CPP.cpp
>> $ time ./testc
>> ...
>> Elapsed time is = 3.12033
>
> Are you sure that Ada.Execution_Time.Clock gives numbers that can be
> compared with the get_cpu_time() function in the C++ version? For a
> program running under an OS, it is not evident what should be included
> in the "processor time" for a program (program loading, process
> creation, interrupts, I/O, page faults, ...).
I did these tests on Linux. On that platform, Ada.Execution_Time.Clock is
merely a call to the POSIX call clock_gettime() (itself a system call under
the hood), with CLOCK_THREAD_CPUTIME_ID as the clock_id parameter. In the
GNAT GPL 2014 environment have a look at lib/gcc/x86_64-pc-linux-
gnu/4.7.4/adainclude/a-exetim.adb to notice that yourself.
Let's now check the differences between clock() and clock_gettime().
Consider the following C program:
#include <time.h>
int main()
{
struct timespec ts;
clock_gettime(CLOCK_THREAD_CPUTIME_ID, &ts);
clock_t c;
c = clock();
}
Compile it and run it with strace:
$ gcc -o test_clock test_clock.c
$ strace ./test_clock
...
clock_gettime(CLOCK_THREAD_CPUTIME_ID, {0, 760910}) = 0
clock_gettime(CLOCK_PROCESS_CPUTIME_ID, {0, 778713}) = 0
...
We can notice that under Linux clock() is in fact a wrapper above
clock_gettime(). So the only difference between Ada.Execution_Time.Clock and
clock() is the clock ID given to clock_gettime(). Thus, as our programs are
not threaded I do not expect any differences between the two.
Moreover in RBC_CPP.cpp, if you rewrite the get_cpu_time() function as
follows:
#include <time.h>
double get_cpu_time(){
struct timespec ts;
clock_gettime(CLOCK_THREAD_CPUTIME_ID, &ts);
return (double)ts.tv_sec + (double)ts.tv_nsec / 1000000000;
}
and run the test again, you will find a value similar to the previous one.
So the timing results from my previous message are consistent.
> What did the "time" command output in your tests?
For the command it is given as argument, "time" reports the elapsed time
("real time"), the CPU time spent in user mode ("user time") and the CPU
time spent in system mode ("sys time"). I just used it to double check the
CPU time values.
> Just to be sure that the claim "Ada is faster" is really motivated.
> Which would be very nice.
I suppose we are now surer than ever.
--
Guillaume Foliard
^ permalink raw reply [flat|nested] 11+ messages in thread
* Re: Benchmark Ada, please
2014-07-05 16:33 ` Simon Wright
@ 2014-07-05 18:25 ` Guillaume Foliard
0 siblings, 0 replies; 11+ messages in thread
From: Guillaume Foliard @ 2014-07-05 18:25 UTC (permalink / raw)
Simon Wright wrote:
> Guillaume Foliard <guifo@wanadoo.fr> writes:
>> So the Ada version is significantly faster. I suppose it is mainly
>> because the Ada compiler has vectorized more loops than the C++ compiler
>> (add - ftree-vectorizer-verbose=2 to the above compilation commands to
>> check by yourself).
>
> On Mac OS X (2.5 GHz Intel Core i5) I found the reverse, both with FSF
> GCC 4.9.0 and GNAT GPL 2014; C++ took ~ 1s, Ada took ~ 2s.
>
> With GCC 4.9.0, gfortran was approximately the same as C++.
>
> Apple's C++ (Xcode 5.1.1) was approximately the same as GCC's.
>
> -ftree-vectorizer-verbose=2 had no effect with FSF GCC.
That's strange, here are my results with GCC FSF 4.9.0:
C++:
Elapsed time is = 3.09426
Ada:
Elapsed time is = 2.111398804
C++ improved a bit, while Ada degraded, still outperforming C++.
Indeed under GCC FSF 4.9.0 the -ftree-vectorizer-verbose does not output any
messages anymore. I have no clue why.
--
Guillaume Foliard
^ permalink raw reply [flat|nested] 11+ messages in thread
* Re: Benchmark Ada, please
2014-07-05 17:00 ` Guillaume Foliard
@ 2014-07-05 18:29 ` Niklas Holsti
2014-07-05 18:44 ` Niklas Holsti
2014-07-05 18:50 ` Guillaume Foliard
0 siblings, 2 replies; 11+ messages in thread
From: Niklas Holsti @ 2014-07-05 18:29 UTC (permalink / raw)
On 14-07-05 20:00 , Guillaume Foliard wrote:
> Hello,
>
> Niklas Holsti wrote:
>> On 14-07-05 14:34 , Guillaume Foliard wrote:
>>> Here are the numbers with GNAT GPL 2014 on a Core2 Q9650 @ 3.00GHz:
>>>
>>> $ gnatmake -O3 rbc_ada.adb
>>> $ time ./rbc_ada
>>> ...
>>> Elapsed time is = 1.966112682
>>>
>>>
>>> As for the C++ version:
>>>
>>> $ g++ -o testc -O3 RBC_CPP.cpp
>>> $ time ./testc
>>> ...
>>> Elapsed time is = 3.12033
>>
>> Are you sure that Ada.Execution_Time.Clock gives numbers that can be
>> compared with the get_cpu_time() function in the C++ version? For a
>> program running under an OS, it is not evident what should be included
>> in the "processor time" for a program (program loading, process
>> creation, interrupts, I/O, page faults, ...).
>
> I did these tests on Linux. On that platform, Ada.Execution_Time.Clock is
> merely a call to the POSIX call clock_gettime() (itself a system call under
> the hood), with CLOCK_THREAD_CPUTIME_ID as the clock_id parameter.
So at least they use the same POSIX library function, good.
> In the
> GNAT GPL 2014 environment have a look at lib/gcc/x86_64-pc-linux-
> gnu/4.7.4/adainclude/a-exetim.adb to notice that yourself.
I believe you. I was asking if you had checked that the two clock
functions are equivalent. I did not mean to criticize.
> Let's now check the differences between clock() and clock_gettime().
> ...
> clock_gettime(CLOCK_THREAD_CPUTIME_ID, {0, 760910}) = 0
> clock_gettime(CLOCK_PROCESS_CPUTIME_ID, {0, 778713}) = 0
> ...
>
> We can notice that under Linux clock() is in fact a wrapper above
> clock_gettime(). So the only difference between Ada.Execution_Time.Clock and
> clock() is the clock ID given to clock_gettime().
So they are not exactly the same.
> Moreover in RBC_CPP.cpp, if you rewrite the get_cpu_time() function as
> follows:
[using CLOCK_THREAD_CPUTIME_ID]
> and run the test again, you will find a value similar to the previous one.
Good. (But I'm not at all sure that I would find similar values on my
host system and my compilers, as demonstrated by other posts in this
thread.)
>
>> What did the "time" command output in your tests?
>
> For the command it is given as argument, "time" reports the elapsed time
> ("real time"), the CPU time spent in user mode ("user time") and the CPU
> time spent in system mode ("sys time"). I just used it to double check the
> CPU time values.
I know well what "time" does; I asked you to show the values it produced
so that we could see that they, too, show Ada to be faster. If you don't
want to do that, that is your right, of course.
>> Just to be sure that the claim "Ada is faster" is really motivated.
>> Which would be very nice.
>
> I suppose we are now surer than ever.
I was not at all sure, for the reasons I gave. I am surer now, thank you.
From other posts it seems that the relative speeds of C++ and Ada for
this benchmark depend on the platform and compiler, which is not very
surprising.
--
Niklas Holsti
Tidorum Ltd
niklas holsti tidorum fi
. @ .
^ permalink raw reply [flat|nested] 11+ messages in thread
* Re: Benchmark Ada, please
2014-07-05 18:29 ` Niklas Holsti
@ 2014-07-05 18:44 ` Niklas Holsti
2014-07-05 18:50 ` Guillaume Foliard
1 sibling, 0 replies; 11+ messages in thread
From: Niklas Holsti @ 2014-07-05 18:44 UTC (permalink / raw)
To Guillaume: an apology and retraction for some text of mine which, on
rereading, is aggressive for no reason:
On 14-07-05 21:29 , Niklas Holsti wrote:
> On 14-07-05 20:00 , Guillaume Foliard wrote:
>> Niklas Holsti wrote:
>>> What did the "time" command output in your tests?
>>
>> For the command it is given as argument, "time" reports the elapsed time
>> ("real time"), the CPU time spent in user mode ("user time") and the CPU
>> time spent in system mode ("sys time"). I just used it to double check the
>> CPU time values.
>
> I know well what "time" does; I asked you to show the values it produced
> so that we could see that they, too, show Ada to be faster. If you don't
> want to do that, that is your right, of course.
I apologize to Guillaume for that aggressive reply of mine. Obviously
Guillame misunderstood my question for "time" output; I had no cause to
become annoyed by that. Sorry, Guillaume.
--
Niklas Holsti
Tidorum Ltd
niklas holsti tidorum fi
. @ .
^ permalink raw reply [flat|nested] 11+ messages in thread
* Re: Benchmark Ada, please
2014-07-05 18:29 ` Niklas Holsti
2014-07-05 18:44 ` Niklas Holsti
@ 2014-07-05 18:50 ` Guillaume Foliard
2014-07-05 19:09 ` Niklas Holsti
1 sibling, 1 reply; 11+ messages in thread
From: Guillaume Foliard @ 2014-07-05 18:50 UTC (permalink / raw)
Niklas Holsti wrote:
>>> On 14-07-05 14:34 , Guillaume Foliard wrote:
>> In the
>> GNAT GPL 2014 environment have a look at lib/gcc/x86_64-pc-linux-
>> gnu/4.7.4/adainclude/a-exetim.adb to notice that yourself.
>
> I believe you. I was asking if you had checked that the two clock
> functions are equivalent. I did not mean to criticize.
Oops, I was not expecting my sentence could be interpreted as if I was
reacting to a critic. Don't worry, no harsh feelings here...
> I know well what "time" does; I asked you to show the values it produced
> so that we could see that they, too, show Ada to be faster. If you don't
> want to do that, that is your right, of course.
Sorry, I misread your question, here are the full outputs:
C++:
$ time ./testc
Output = 0.562731, Capital = 0.178198, Consumption = 0.384533
Iteration = 1, Sup Diff = 0.0527416
Iteration = 10, Sup Diff = 0.0313469
Iteration = 20, Sup Diff = 0.0187035
Iteration = 30, Sup Diff = 0.0111655
Iteration = 40, Sup Diff = 0.00666854
Iteration = 50, Sup Diff = 0.00398429
Iteration = 60, Sup Diff = 0.00238131
Iteration = 70, Sup Diff = 0.00142366
Iteration = 80, Sup Diff = 0.00085134
Iteration = 90, Sup Diff = 0.000509205
Iteration = 100, Sup Diff = 0.000304623
Iteration = 110, Sup Diff = 0.000182265
Iteration = 120, Sup Diff = 0.00010907
Iteration = 130, Sup Diff = 6.52764e-05
Iteration = 140, Sup Diff = 3.90711e-05
Iteration = 150, Sup Diff = 2.33881e-05
Iteration = 160, Sup Diff = 1.40086e-05
Iteration = 170, Sup Diff = 8.39132e-06
Iteration = 180, Sup Diff = 5.02647e-06
Iteration = 190, Sup Diff = 3.0109e-06
Iteration = 200, Sup Diff = 1.80355e-06
Iteration = 210, Sup Diff = 1.08034e-06
Iteration = 220, Sup Diff = 6.47132e-07
Iteration = 230, Sup Diff = 3.87636e-07
Iteration = 240, Sup Diff = 2.32197e-07
Iteration = 250, Sup Diff = 1.39087e-07
Iteration = 257, Sup Diff = 9.71604e-08
My check = 0.146549
Elapsed time is = 3.11317
real 0m3.126s
user 0m3.113s
sys 0m0.003s
Ada:
$ time ./rbc_ada
Output = 5.62731433873177E-01, Capital = 1.78198287391391E-01, Consumption =
3.84533146481786E-01
Iteration = 1, Sup Diff = 5.27415934068824E-02
Iteration = 10, Sup Diff = 3.13469492655827E-02
Iteration = 20, Sup Diff = 1.87034598931961E-02
Iteration = 30, Sup Diff = 1.11655120338747E-02
Iteration = 40, Sup Diff = 6.66854170807507E-03
Iteration = 50, Sup Diff = 3.98429274868262E-03
Iteration = 60, Sup Diff = 2.38131180391221E-03
Iteration = 70, Sup Diff = 1.42365864508598E-03
Iteration = 80, Sup Diff = 8.51339774713189E-04
Iteration = 90, Sup Diff = 5.09205175224792E-04
Iteration = 100, Sup Diff = 3.04623244212099E-04
Iteration = 110, Sup Diff = 1.82264856321224E-04
Iteration = 120, Sup Diff = 1.09069508725246E-04
Iteration = 130, Sup Diff = 6.52764373626491E-05
Iteration = 140, Sup Diff = 3.90710821196461E-05
Iteration = 150, Sup Diff = 2.33880771197681E-05
Iteration = 160, Sup Diff = 1.40086446370757E-05
Iteration = 170, Sup Diff = 8.39131720298258E-06
Iteration = 180, Sup Diff = 5.02647453792804E-06
Iteration = 190, Sup Diff = 3.01089986365355E-06
Iteration = 200, Sup Diff = 1.80355224810302E-06
Iteration = 210, Sup Diff = 1.08034091594877E-06
Iteration = 220, Sup Diff = 6.47131694342384E-07
Iteration = 230, Sup Diff = 3.87636194032481E-07
Iteration = 240, Sup Diff = 2.32196579297295E-07
Iteration = 250, Sup Diff = 1.39087209638511E-07
Iteration = 257, Sup Diff = 9.71603565380619E-08
My check = 1.46549143695695E-01
Elapsed time is = 1.970120151
real 0m1.982s
user 0m1.970s
sys 0m0.004s
> From other posts it seems that the relative speeds of C++ and Ada for
> this benchmark depend on the platform and compiler, which is not very
> surprising.
Indeed, trying with various other compiler versions leads to somewhat
significant differences, mostly caused by the effectiveness of the auto-
vectorization.
--
Guillaume Foliard
^ permalink raw reply [flat|nested] 11+ messages in thread
* Re: Benchmark Ada, please
2014-07-05 18:50 ` Guillaume Foliard
@ 2014-07-05 19:09 ` Niklas Holsti
0 siblings, 0 replies; 11+ messages in thread
From: Niklas Holsti @ 2014-07-05 19:09 UTC (permalink / raw)
On 14-07-05 21:50 , Guillaume Foliard wrote:
> Niklas Holsti wrote:
>>>> On 14-07-05 14:34 , Guillaume Foliard wrote:
>>> In the
>>> GNAT GPL 2014 environment have a look at lib/gcc/x86_64-pc-linux-
>>> gnu/4.7.4/adainclude/a-exetim.adb to notice that yourself.
>>
>> I believe you. I was asking if you had checked that the two clock
>> functions are equivalent. I did not mean to criticize.
>
> Oops, I was not expecting my sentence could be interpreted as if I was
> reacting to a critic. Don't worry, no harsh feelings here...
Nor here.
> Sorry, I misread your question, here are the full outputs:
>
> C++:
>
> $ time ./testc
...
> Elapsed time is = 3.11317
>
>
> real 0m3.126s
> user 0m3.113s
> sys 0m0.003s
>
>
> Ada:
>
> $ time ./rbc_ada
...
> Elapsed time is = 1.970120151
>
> real 0m1.982s
> user 0m1.970s
> sys 0m0.004s
Thanks, that is quite convincing.
--
Niklas Holsti
Tidorum Ltd
niklas holsti tidorum fi
. @ .
^ permalink raw reply [flat|nested] 11+ messages in thread
* Re: Benchmark Ada, please
2014-07-05 12:34 ` Guillaume Foliard
2014-07-05 13:00 ` Niklas Holsti
2014-07-05 16:33 ` Simon Wright
@ 2014-07-06 17:24 ` Dirk Heinrichs
2 siblings, 0 replies; 11+ messages in thread
From: Dirk Heinrichs @ 2014-07-06 17:24 UTC (permalink / raw)
Guillaume Foliard wrote:
> Here are the numbers with GNAT GPL 2014 on a Core2 Q9650 @ 3.00GHz:
Tried it on my (Linux) system, Intel(R) Core(TM) i7-3520M CPU @ 2.90GHz, FSF
Gnat 4.6 as provided by Debian Jessie:
> $ gnatmake -O3 rbc_ada.adb
> $ time ./rbc_ada
> ...
> Elapsed time is = 1.966112682
% gnatmake -O3 Rbc_Ada.adb
% time ./Rbc_Ada
...
Elapsed time is = 1.909959513
./Rbc_Ada 1,91s user 0,00s system 97% cpu 1,972 total
> As for the C++ version:
I used g++ 4.9 on the same system:
> $ g++ -o testc -O3 RBC_CPP.cpp
> $ time ./testc
> ...
> Elapsed time is = 3.12033
% g++ -o testc -O3 RBC_CPP.cpp
% time ./testc
...
Elapsed time is = 2.13568
./testc 2,14s user 0,00s system 99% cpu 2,143 total
> So the Ada version is significantly faster
As you can see, Ada is still faster, but I wouldn't call that significantly
;).
Bye...
Dirk
--
Dirk Heinrichs <dirk.heinrichs@altum.de>
Tel: +49 (0)2471 209385 | Mobil: +49 (0)176 34473913
GPG Public Key CB614542 | Jabber: dirk.heinrichs@altum.de
Sichere Internetkommunikation: http://www.retroshare.org
^ permalink raw reply [flat|nested] 11+ messages in thread
end of thread, other threads:[~2014-07-06 17:24 UTC | newest]
Thread overview: 11+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2014-07-04 17:23 Benchmark Ada, please Victor Porton
2014-07-05 12:34 ` Guillaume Foliard
2014-07-05 13:00 ` Niklas Holsti
2014-07-05 17:00 ` Guillaume Foliard
2014-07-05 18:29 ` Niklas Holsti
2014-07-05 18:44 ` Niklas Holsti
2014-07-05 18:50 ` Guillaume Foliard
2014-07-05 19:09 ` Niklas Holsti
2014-07-05 16:33 ` Simon Wright
2014-07-05 18:25 ` Guillaume Foliard
2014-07-06 17:24 ` Dirk Heinrichs
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox