Why does Ada compile slower than Python?

Why does Ada compile slower than Python?

[Victor Porton]

Why does Ada compile much slower than Python, even in absence of 
optimization?

We can usually get a Python source files and immediately run it.

But with Ada we would need to wait a considerable amount of time till it 
compiles.

Why?

-- 
Victor Porton - http://portonvictor.org

Why does Ada compile slower than Python?

[Leff Ivanov]

Because it compiles code ahead of time and produce native executable, Python is interpreted language it compiles to bytecode that then executes using virtual machine. Generally speaking ahead of time compiled code has a much better performance than interpreted and even just in time compiled code.

Re: Why does Ada compile slower than Python?

[gautier_niouzes]

Le mardi 3 octobre 2017 01:01:35 UTC+2, Victor Porton a écrit :
> Why does Ada compile much slower than Python, even in absence of 
> optimization?

It depends on the compiler. Some are faster, some are slower...
Probably we are still missing something like Turbo Pascal for that aspect.
I have a funny project (a very incomplete compiler so far) which at least shows that is possible to have a quick build phase...
https://sourceforge.net/projects/hacadacompiler/

G.

Re: Why does Ada compile slower than Python?

[Brian Drummond]

On Mon, 02 Oct 2017 18:11:39 -0700, gautier_niouzes wrote:

> Le mardi 3 octobre 2017 01:01:35 UTC+2, Victor Porton a écrit :
>> Why does Ada compile much slower than Python, even in absence of
>> optimization?
> 
> It depends on the compiler. Some are faster, some are slower...

And the Gnat compiler relies on gcc, which runs hundreds or thousands of 
optimisation passes on the intermediate code before generating an 
executable output.

-- Brian

Re: Why does Ada compile slower than Python?

[bartc]

On 03/10/2017 00:01, Victor Porton wrote:
> Why does Ada compile much slower than Python, even in absence of
> optimization?
> 
> We can usually get a Python source files and immediately run it.
> 
> But with Ada we would need to wait a considerable amount of time till it
> compiles.

What sizes of programs are we talking about here? In terms of numbers of 
lines of code. And how long to you have to wait in each case.

Languages like Python can have a swift byte-code compiler which puts the 
code into memory and then it can start execution immediately, doing any 
dynamic linking on-demand as it runs. But even here, a big program may 
cause noticeable start-up delays.

A static language like Ada may depend on a slow, cumbersome compiler 
like gcc (I think that's how Gnat works; I've never used it), and then 
there is a build process to create an executable. The process may also 
depend on configuration scripts and makefiles. It may have to deal with 
library info (like header files in C) which may dominate the size of 
your application.

Such languages are not really designed for rapid turn-around.

Ada is also rather more complicated, although I'm not sure how much of a 
factor that is.

(I write small compilers for simple languages. My byte-code compilers 
can work at up to 1Mlps (one million lines of code per second). My 
static compilers can generate native code at 0.5Mpls.

So there needn't be a big gulf between the two kinds of languages. It's 
just that mainstream tools tend to be big and slow. While my compilers 
do little optimisation, the difference between mine and something like 
gcc can be well within a factor of two in generated code speed. But my 
compiler can do its job 100 times faster.)

-- 
bartc

Re: Why does Ada compile slower than Python?

[G.B.]

On 03.10.17 15:07, bartc wrote:
> Such languages are not really designed for rapid turn-around.

GNAT, specifically, has modes that are closer to what Python
does. When GNAT "just checks" (-gnatc), or when the programmer
asks for "minimal recompilation" only (-m), these and other
switches will speed things up.
  Separate compilation also reduces the number of units that
need to be compiled again, e.g. when unit B has not changed
but unit A has, then only unit A needs to be compiled.

OTOH, intense checking or compiling Java or Swift in Eclipse or
Xcode  happens at all times, so that one doesn't notice all
the translation work---but the processor does! As Python is
finally getting an optional type system as part of the written
language, not surprisingly, type checking is expensive for this
Python and translation takes more time.

Re: Why does Ada compile slower than Python?

[Randy Brukardt]

[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #1: Type: text/plain, Size: 954 bytes --]

<gautier_niouzes@hotmail.com> wrote in message 
news:3b98f1ee-dbe3-4f1c-bc9c-5169da819133@googlegroups.com...
Le mardi 3 octobre 2017 01:01:35 UTC+2, Victor Porton a écrit :
>> Why does Ada compile much slower than Python, even in absence of
>> optimization?
>
>It depends on the compiler. Some are faster, some are slower...
>Probably we are still missing something like Turbo Pascal for that aspect.

Not really. Janus/Ada has always compiled very fast if optimization is off. 
(The code isn't very good, either, but that's not relevant.) The performance 
was in the same magnitude as early Turbo Pascal (which of course was MUCH 
slower than current compilers of any sort, simply because the machines were 
1000x slower). That shouldn't have changed, the compiler design has changed 
little in intervening years.

Note: Yes, Janus/Ada isn't free, but neither was Turbo Pascal! Why the 
different standards??

                               Randy.

Re: Why does Ada compile slower than Python?

[Victor Porton]

Victor Porton wrote:

> Why does Ada compile much slower than Python, even in absence of
> optimization?
> 
> We can usually get a Python source files and immediately run it.
> 
> But with Ada we would need to wait a considerable amount of time till it
> compiles.
> 
> Why?

Hm,

$ time gnatgcc -c test.adb 

real	0m0.068s
user	0m0.064s
sys	0m0.000s
$ time python3 test.py
XXX


real	0m0.040s
user	0m0.032s
sys	0m0.004s


-- test.adb
with Ada.Text_IO; use Ada.Text_IO;

procedure Test is
begin
   Put_Line("XXX");
end;


# test.py
print("XXX\n");


$ gnatgcc --version
gnatgcc (Debian 7.2.0-8) 7.2.0

According this test (valid only for very short programs) compiling Ada is 
slower only two times.

Maybe I was under a wrong impression, because I got this impression when I 
compiled tens of Ada files in a row and my brain was focused on total 
compilation time rather than compilation time for one file?

Is GNAT really much slower than Python? or was it a false impression?

This issue is quite practical: I am going to build a server which will 
execute (in a secure sandbox) XML converters downloaded from the Web written 
in different interpreted languages. By "interpreted" I mean "compiling 
quickly". Can we agree to count Ada as an interpreted language in this 
sense?

-- 
Victor Porton - http://portonvictor.org

Re: Why does Ada compile slower than Python?

[gautier_niouzes]

> >Probably we are still missing something like Turbo Pascal for that aspect.
> 
> Not really. Janus/Ada has always compiled very fast if optimization is off. 

Good news! Note that I wrote "probably", not "certainly" ;-) ...

Why does Ada compile slower than Python?

[Mace Ayres]

That’s really hard to answer because Ada and Python are so similar. That’s what the instrtuctor told me in my 5 day Python boot camp that promised to get me a high paying job in Silicon Valley. I had thought they were different when I learned that Ada software is used in industrial class systems, say Boeing Aircraft, NASA, General Electric and like, and embedded systems that must be reliable, safe, etc. and simultaneously saw my little 8 year old brother programming a PacMan liked game in Python on his plastic lap stop while sitting on this bed, after teaching himself one morning.

Re: Why does Ada compile slower than Python?

[Andrew Shvets]

On Tuesday, October 3, 2017 at 8:21:59 PM UTC-4, Mace Ayres wrote:
> That’s really hard to answer because Ada and Python are so similar. That’s what the instrtuctor told me in my 5 day Python boot camp that promised to get me a high paying job in Silicon Valley. I had thought they were different when I learned that Ada software is used in industrial class systems, say Boeing Aircraft, NASA, General Electric and like, and embedded systems that must be reliable, safe, etc. and simultaneously saw my little 8 year old brother programming a PacMan liked game in Python on his plastic lap stop while sitting on this bed, after teaching himself one morning.

Mace Ayres, how are Python and Ada similar?  I've written code in both and to me they are night and day.  As great of a language that Python is, I would not use it to write code for an airplane.  And if I needed a small script to automate some tasks, Ada would be the last thing on my mind.

In what way are they similar?

Re: Why does Ada compile slower than Python?

[Andrew Shvets]

On Monday, October 2, 2017 at 7:01:35 PM UTC-4, Victor Porton wrote:
> Why does Ada compile much slower than Python, even in absence of 
> optimization?
> 
> We can usually get a Python source files and immediately run it.
> 
> But with Ada we would need to wait a considerable amount of time till it 
> compiles.
> 
> Why?
> 
> -- 
> Victor Porton - http://portonvictor.org

In an interpreted programming language, you're basically feeding the source into the interpreter and it starts executing it... whereas in a compiled programming language (C/C++, Ada, etc.) you first need to create a binary for the OS to run it...

These are very different notions entirely, it doesn't make sense to compare the two in any way.

Re: Why does Ada compile slower than Python?

[Simon Wright]

Victor Porton <porton@narod.ru> writes:

>  By "interpreted" I mean "compiling quickly".

You're on your own, then.

https://en.wikipedia.org/wiki/Humpty_Dumpty#In_Through_the_Looking-Glass

> Can we agree to count Ada as an interpreted language in this sense?

No!

Re: Why does Ada compile slower than Python?

[gautier_niouzes]

Fortunately, with GNAT, the slow build time is well rewarded by performance. I just have the following real case today at my job:

A certain number-crunching job is a big bottleneck since years. It has been developed as a SQL stored procedure. Then someone has made a Python version (program compiled into an executable). Independently I've made an Ada version. All three programs produce the same result.

SQL    : 12 hours run time - weeks of development work
Python :  3 hours run time - weeks of development work
Ada    : 27 minutes run time - 3 days of development work.

Now the "clou": most of the run time is actually spent loading data via a SQL select instruction. The actual number-crunching in Ada takes 24 *seconds* in total!... Since the loading of data is a "fixed cost" (+/- the same whatever the implementation language) I let as an exercise to figure out the speedup factor of the computation side :-).

G.

Re: Why does Ada compile slower than Python?

[Victor Porton]

gautier_niouzes@hotmail.com wrote:

> Fortunately, with GNAT, the slow build time is well rewarded by
> performance. I just have the following real case today at my job:
> 
> A certain number-crunching job is a big bottleneck since years. It has
> been developed as a SQL stored procedure. Then someone has made a Python
> version (program compiled into an executable). Independently I've made an
> Ada version. All three programs produce the same result.
> 
> SQL    : 12 hours run time - weeks of development work
> Python :  3 hours run time - weeks of development work
> Ada    : 27 minutes run time - 3 days of development work.
> 
> Now the "clou": most of the run time is actually spent loading data via a
> SQL select instruction. The actual number-crunching in Ada takes 24
> *seconds* in total!... Since the loading of data is a "fixed cost" (+/-
> the same whatever the implementation language) I let as an exercise to
> figure out the speedup factor of the computation side :-).

My case is not expected especially computationally intensive. Therefore the 
processing time is expected to depend mostly on compilation time (because I 
am to load software from the Web and run it in a secure sandbox).

Thus the execution time is expected to depend mostly on compilation time, 
not the time of execution itself. (However, I am not sure if this is really 
so, it will be clear when my software will run and tested with some real-
world scenaria.)

I need to take the decision whether Ada compiles fast enough to be used this 
way.

-- 
Victor Porton - http://portonvictor.org

Re: Why does Ada compile slower than Python?

[Blady]

Hello Victor,

Do you have considered using SparForte?
http://sparforte.com

"The computer language that the SparForte shell understands is called AdaScript. Unlike JavaScript, which has no relation to Java, AdaScript is a small subset of the Ada programming language, with additional features related to shell commands and databases.
AdaScript is intended to be "upward compatible" with Ada. AdaScript scripts should run with little difficulty under Ada, but Ada programs may require large changes run under SparForte."

HTH, Pascal.

Le mercredi 4 octobre 2017 18:03:24 UTC+2, Victor Porton a écrit :
> gautier wrote:
> 
> > Fortunately, with GNAT, the slow build time is well rewarded by
> > performance. I just have the following real case today at my job:
> > 
> > A certain number-crunching job is a big bottleneck since years. It has
> > been developed as a SQL stored procedure. Then someone has made a Python
> > version (program compiled into an executable). Independently I've made an
> > Ada version. All three programs produce the same result.
> > 
> > SQL    : 12 hours run time - weeks of development work
> > Python :  3 hours run time - weeks of development work
> > Ada    : 27 minutes run time - 3 days of development work.
> > 
> > Now the "clou": most of the run time is actually spent loading data via a
> > SQL select instruction. The actual number-crunching in Ada takes 24
> > *seconds* in total!... Since the loading of data is a "fixed cost" (+/-
> > the same whatever the implementation language) I let as an exercise to
> > figure out the speedup factor of the computation side :-).
> 
> My case is not expected especially computationally intensive. Therefore the 
> processing time is expected to depend mostly on compilation time (because I 
> am to load software from the Web and run it in a secure sandbox).
> 
> Thus the execution time is expected to depend mostly on compilation time, 
> not the time of execution itself. (However, I am not sure if this is really 
> so, it will be clear when my software will run and tested with some real-
> world scenaria.)
> 
> I need to take the decision whether Ada compiles fast enough to be used this 
> way.
> 
> -- 
> Victor Porton - http://portonvictor.org

Re: Why does Ada compile slower than Python?

[olivermkellogg]

On Tuesday, October 3, 2017 at 11:08:59 PM UTC+2, Victor Porton wrote:
> Victor Porton wrote:
> [...]
> According this test (valid only for very short programs) compiling Ada is 
> slower only two times.
> 
> Maybe I was under a wrong impression, because I got this impression when I 
> compiled tens of Ada files in a row and my brain was focused on total 
> compilation time rather than compilation time for one file?
> 
> Is GNAT really much slower than Python? or was it a false impression?

When compiling many interdependent packages GNAT is definitely slower than it could be. This has to do with the fact that GCC/GNAT can only handle one file at a time. E.g. if you provide 100 files on a single gcc command line then gcc loads and compiles each file separately as though you were providing 100 commands with one file per command.
Some years ago I had started an experiment to add AST (abstract syntax tree) caching to GNAT and had gotten as far as the Ada frontend (GNAT trees); however, the major effort for making this work is in the later stages of the compiler (GNU trees, etc).

Oliver

Re: Why does Ada compile slower than Python?

[Paul Rubin]

olivermkellogg@gmail.com writes:
> if you provide 100 files on a single gcc command line then gcc loads
> and compiles each file separately as though you were providing 100
> commands with one file per command.

Usually you'd use make -j which will do compilation in parallel if you
have a multicore machine.  I use that with C and C++ programs all the
time and it's a big help.  There are even some distributed make programs
that will spin your compilation out across a whole cluster, but I do
most of my stuff on a regular 4-core i7 box.  I don't know the situation
with compiling Ada in parallel.  

As for the compilation speed of Gnat vs Python, you have to remember
that the Python "compiler" (it makes bytecode for a VM) is very simple,
very little optimization, no typechecking, etc.  But Gnat should compile
faster with optimization turned off than with it on, for your debugging
builds.

Re: Why does Ada compile slower than Python?

[Dmitry A. Kazakov]

On 18/10/2017 08:38, Paul Rubin wrote:
> olivermkellogg@gmail.com writes:
>> if you provide 100 files on a single gcc command line then gcc loads
>> and compiles each file separately as though you were providing 100
>> commands with one file per command.
> 
> Usually you'd use make -j which will do compilation in parallel if
> you have a multicore machine.  I use that with C and C++ programs all
> the time and it's a big help.  There are even some distributed make
> programs that will spin your compilation out across a whole cluster,
> but I do most of my stuff on a regular 4-core i7 box.  I don't know
> the situation with compiling Ada in parallel.
Of course both gprbuild and gnatmake support -jN. But one must be 
careful on platforms with many cores and little memory. E.g. on a 
Raspberry Pi you cannot always use all 4 cores. Should you hit the swap 
it will hard freeze. Excessive memory consumption of GNAT surely costs 
performance, just because all these gigabytes of memory must be read and 
written at least once. Another contributor is catastrophic performance 
of GNU linker. It takes about an hour just to link a large stand-alone 
library.

> As for the compilation speed of Gnat vs Python, you have to remember
> that the Python "compiler" (it makes bytecode for a VM) is very simple,
> very little optimization, no typechecking, etc.  But Gnat should compile
> faster with optimization turned off than with it on, for your debugging
> builds.

In my experience optimization does not influence compilation time 
considerably. It takes almost same time to compile with -O0 and -O2.

-- 
Regards,
Dmitry A. Kazakov
http://www.dmitry-kazakov.de

Re: Why does Ada compile slower than Python?

[Björn Lundin]

On 2017-10-18 09:13, Dmitry A. Kazakov wrote:
> Another contributor is catastrophic performance of GNU linker. It takes
> about an hour just to link a large stand-alone library.

He, that is one reason we left ObjectAda (7.2 I think) on Windows 12
years ago.
It could take longer than so to link our executables
With gnat, it was fantastic, linking went down to a couple of minutes.
And still is, even if the exe-size is between 70 and 200 mb
on 32bit Aix (ppc), 32-bit Win (intel) and 64-bit Linux (intel)

How large is your library?
But on the pi - yes it takes quite som time.
But a modern Pi has is roughly the same umpf as a 2002-server,

-- 
--
Björn

Re: Why does Ada compile slower than Python?

[Dmitry A. Kazakov]

On 18/10/2017 09:34, Björn Lundin wrote:

> How large is your library?

400MB on 32-bit Windows

> But on the pi - yes it takes quite som time.
> But a modern Pi has is roughly the same umpf as a 2002-server,

Possibly.

My favorite is ODROID XU4. It is 4-5 times faster with GNAT than 
Raspberry Pi 3.

BTW, disk I/O is not a big factor. It makes little difference if I use 
HDD/SSD (over USB) or SD/eMMC.

P.S. ObjectAda 7.2 was great. Pity that they dropped off.

-- 
Regards,
Dmitry A. Kazakov
http://www.dmitry-kazakov.de

Re: Why does Ada compile slower than Python?

[gautier_niouzes]

> P.S. ObjectAda 7.2 was great. Pity that they dropped off.

ObjectAda 9.x is much better ;-).
Joke apart, they have caught up a lot: containers, dot notation, "raise x with ..." - probably most of the Ada 2005 standard.