Re: Direct Quote from the RM

[anon@anon.org (anon)]

Paragraph of 10 from Design Goal.

  10   No language can avoid the problem of efficiency.  Languages that 
        require over-elaborate compilers, or that lead to the inefficient use 
        of storage or execution time, force these inefficiencies on all 
        machines and on all programs.  Every construct of the language was 
        examined in the light of present implementation techniques.  Any 
        proposed construct whose implementation was unclear or that 
        required excessive machine resources was rejected.

"Any proposed construct whose implementation was unclear or that required 
excessive machine resources was rejected." That statement suggest that 
"gnatmake" in using requires 5 complete programs to be loaded at one time 
just to compile a single routine or package when 3 to 3 will do should be 
rejected!

gnatmake => use in core 5 program.
gnat compile => uses 4 program 3 in core.
gcc -c => uses 3 in core program (gcc which calls gnat1 then calls as).

So using "gcc -c" is the best and is worst "gnatmake".  Of course, this 
can become excessive in execution time if the GNAT system is compiled 
with "-fstack-check".

Defaulting the "-fstack-check" which can not at the movement be remove 
by the "pragma Suppress (Storage_Check);". Leads "to the inefficient use 
of storage or execution time, force these inefficiencies on all machines 
and on all programs." So it too must be rejected!

And there are more places in the RM then just this part. But most people 
I think had skip reading the Intro section.

And as for parallel. The way I write code allows me to compile in parallel 
even though that development design is not support in the RM. But I have 
learned a few trick alone the way that allows this. 

Note: Parallel => I mean the number of complete compilers loaded and 
running in core (no swapper file usage) at the same time. That is on the 
old single-cpu system it was called Concurrency, but with two/four/+ 
cpus that is called Parallel. For example on a system with 4G with 1G 
given to the OS/(user interface), that leave 3G or about 3_000 in core 
compilers if the gcc, gnat1, as, and file/package take less than 1MB in 
size or 1_500 in core compilers if they require 2MB.

And "gnatmake" does not use the Ada Task and to insure "Safety and 
Security" of the code will only allow the compiling of one package at a 
time because of the design of Ada structure. (As someone pointed out).
This is defined also in the RM if you look. 

Note: The "make -jN" or "gnatmake -jN" does not allow multiple 
compilers to be loaded in core at the same time.



In <m2k5ogvxo4.fsf@mac.com>, Simon Wright <simon.j.wright@mac.com> writes:
>anon@anon.org (anon) writes:
>
>>   10   No language can avoid the problem of efficiency.  Languages
>>         that require over-elaborate compilers, or that lead to the
>>         inefficient use of storage or execution time, force these
>>         inefficiencies on all machines and on all programs.
>
>This is the only part of the text you quote that addresses the
>compilation environment. And what it says is, the design of the Ada
>language is such that it does not require over-elaborate compilers,
>and that (once compiled) a program doesn't have to be inefficient.
>
>But there's nothing there that says the compiler itself has to be
>efficient! of course inefficient compilers will be unpopular, but
>that's quite a different matter.