Will (abstract) Ada code improve over time ?

Will (abstract) Ada code improve over time ?

[Reinert Korsnes]

Hi,

Since Ada code is (supposed to be) on a higher abstraction level
than for example C, does this mean that we can expect
new compilers and hardware over time (10 years ?) will make
a program made in Ada more efficient/faster than a similar C program ?

Has it been put much significance to this point in military
(or other) software development ?  I assume most software
development is made within a time perspective less than
10 years -:)   (though within pure commercial property development,
for example,  investors must think about reselling and hence
value in far future).

I assume the runtime efficiency of programs is a question for
much special niches.  One example could be operative systems.
Linux ?

reinert

Re: Will (abstract) Ada code improve over time ?

[Lutz Donnerhacke]

* Reinert Korsnes wrote:
>Since Ada code is (supposed to be) on a higher abstraction level than for
>example C, does this mean that we can expect new compilers and hardware
>over time (10 years ?) will make a program made in Ada more
>efficient/faster than a similar C program ?

Assuming the same optimizer complexity, it might be true, because Ada
provides more and more precise information to the compiler than C.

>I assume most software development is made within a time perspective less
>than 10 years -:)

This design goal is well known: Such software can be easily identified.

>(though within pure commercial property development, for example,
>investors must think about reselling and hence value in far future).

This is a complete other term: Development time. Ada allows much better
reusability than C. And Ada programms are much faster debugged than C
programms. (Assuming equaly experienced programmers)

>I assume the runtime efficiency of programs is a question for much special
>niches.  One example could be operative systems. Linux ?

Linus tried to convert the kernel to C++ in order to get faster development
cycles due to stronger typing but failed miserably due to compiler errors
and language ambiguity.

Re: Will (abstract) Ada code improve over time ?

[Preben Randhol]

On Wed, 18 Jul 2001 13:34:45 +0200, Reinert Korsnes wrote:
> Hi,
> 
> Since Ada code is (supposed to be) on a higher abstraction level
> than for example C, does this mean that we can expect
> new compilers and hardware over time (10 years ?) will make
> a program made in Ada more efficient/faster than a similar C program ?

As I "see" the future the following keywords will be more important than
a slight improvement in the speed of a running program:

   1. Development Cost 
   2. Maintainability Cost
   3. Reliability

And as I see it, Ada 95 is better equipped to satisfy in all these areas
than C.

-- 
�Don't use C;  In my opinion,  C is a library programming language
 not an app programming language.�  - Owen Taylor (GTK+ developer)

Use Ada 95, a free language. More info at http://www.adapower.com/

Re: Will (abstract) Ada code improve over time ?

[Tomasz Wegrzanowski]

In article <slrn9latb9.46.lutz@taranis.iks-jena.de>, Lutz Donnerhacke wrote:
>>I assume the runtime efficiency of programs is a question for much special
>>niches.  One example could be operative systems. Linux ?
> 
> Linus tried to convert the kernel to C++ in order to get faster development
> cycles due to stronger typing but failed miserably due to compiler errors
> and language ambiguity.

That's not true.
A few 0.x kernels were compiled using c++ compiler, but they
were pure c code, and c++ were used only to catch more errors
on compile-time. It was equivalent of using more -W options.
Linus stopped using c++ compiler, as there was a performance lose,
and advantages weren't that big.

Re: Will (abstract) Ada code improve over time ?

[Tomasz Wegrzanowski]

In article <slrn9lb4lj.5ds.randhol+abuse@kiuk0156.chembio.ntnu.no>, Preben Randhol wrote:
> On Wed, 18 Jul 2001 13:34:45 +0200, Reinert Korsnes wrote:
>> Hi,
>> 
>> Since Ada code is (supposed to be) on a higher abstraction level
>> than for example C, does this mean that we can expect
>> new compilers and hardware over time (10 years ?) will make
>> a program made in Ada more efficient/faster than a similar C program ?
> 
> As I "see" the future the following keywords will be more important than
> a slight improvement in the speed of a running program:
> 
>    1. Development Cost 
>    2. Maintainability Cost
>    3. Reliability
> 
> And as I see it, Ada 95 is better equipped to satisfy in all these areas
> than C.

You know that this is being told from 20 years.

Re: Will (abstract) Ada code improve over time ?

[Ed Falis]

Tomasz Wegrzanowski wrote:

> In article <slrn9lb4lj.5ds.randhol+abuse@kiuk0156.chembio.ntnu.no>, Preben Randhol wrote:
> > On Wed, 18 Jul 2001 13:34:45 +0200, Reinert Korsnes wrote:
>
> > As I "see" the future the following keywords will be more important than
> > a slight improvement in the speed of a running program:
> >
> >    1. Development Cost
> >    2. Maintainability Cost
> >    3. Reliability
> >
> > And as I see it, Ada 95 is better equipped to satisfy in all these areas
> > than C.
>
> You know that this is being told from 20 years.

Yep, and it's still just as true as it was then ;-)

- Ed

Re: Will (abstract) Ada code improve over time ?

[Reinert Korsnes]

Preben Randhol wrote:

> On Wed, 18 Jul 2001 13:34:45 +0200, Reinert Korsnes wrote:
> > Hi,
> >
> > Since Ada code is (supposed to be) on a higher abstraction level
> > than for example C, does this mean that we can expect
> > new compilers and hardware over time (10 years ?) will make
> > a program made in Ada more efficient/faster than a similar C program ?
>
> As I "see" the future the following keywords will be more important than
> a slight improvement in the speed of a running program:
>
>    1. Development Cost
>    2. Maintainability Cost
>    3. Reliability
>
> And as I see it, Ada 95 is better equipped to satisfy in all these areas
> than C.

Yes, there are more interesting questions, but is it some important and
stable
Ada code out there and that we may expect will run faster over time (on new
hardware)
as compared to if it was made in C ?  (and similar: is it some stable C
code
out there and that would run better in the future is it was made in proper
Ada ?).

Do we see some significant new hardware coming and where old stable Ada
code
will have some advantage ?  Parallel processors ?  Distributed processing ?

Processing where time/clock control comes in ?

reinert

>
>
> --
> �Don't use C;  In my opinion,  C is a library programming language
>  not an app programming language.�  - Owen Taylor (GTK+ developer)
>
> Use Ada 95, a free language. More info at http://www.adapower.com/

Re: Will (abstract) Ada code improve over time ?

[Lutz Donnerhacke]

* Tomasz Wegrzanowski wrote:
>In article <slrn9latb9.46.lutz@taranis.iks-jena.de>, Lutz Donnerhacke wrote:
>>>I assume the runtime efficiency of programs is a question for much special
>>>niches.  One example could be operative systems. Linux ?
>> 
>> Linus tried to convert the kernel to C++ in order to get faster development
>> cycles due to stronger typing but failed miserably due to compiler errors
>> and language ambiguity.
>
>That's not true.
>A few 0.x kernels were compiled using c++ compiler, but they
>were pure c code, and c++ were used only to catch more errors
>on compile-time. It was equivalent of using more -W options.
>Linus stopped using c++ compiler, as there was a performance lose,
>and advantages weren't that big.

Thanx for clarification. I do not remember such things very well.

Re: Will (abstract) Ada code improve over time ?

[Jacob Sparre Andersen]

Reinert:

> Yes, there are more interesting questions, but is it some important and
> stable
> Ada code out there and that we may expect will run faster over time (on new
> hardware)
> as compared to if it was made in C ?

I doubt very much that changes in hardware in general will
result in changes in the relative execution speed of Ada and
C programs.

On the other hand, I find it likely that similar investments
in improving compilers will give a larger pay-off for Ada
than for C.

> Do we see some significant new hardware coming and where old stable Ada
> code
> will have some advantage ?  Parallel processors ?  Distributed processing ?

I have a vague memory of reading something about a processor
developed by Eriksson (the launch systems division, I
think), which implemented task switching in a very Ada
friendly way.

Jacob
-- 
Maybe the whole reason human beings came into existence was
because the Earth wanted plastic and couldn't produce it any
other way.

Re: Will (abstract) Ada code improve over time ?

[Corey Ashford]

"Jacob Sparre Andersen" <sparre@nbi.dk> wrote in message news:3B57EFCB.C5EC2F12@nbi.dk...
> Reinert:
>
> > Yes, there are more interesting questions, but is it some important and
> > stable
> > Ada code out there and that we may expect will run faster over time (on new
> > hardware)
> > as compared to if it was made in C ?
>
> I doubt very much that changes in hardware in general will
> result in changes in the relative execution speed of Ada and
> C programs.

[snip]

One major advantage of Ada is built-in threading (i.e. Ada tasks).
As hardware gets more multiprocessing capability, Ada programs written using
tasking will naturally get a performance boost.   Of course, multi-threaded
C programs would get a boost too, but because it's so much easier
for a programmer to write multi-threaded programs in Ada, they will be more
likely to do use multi-threading in Ada than in C.


Corey Ashford
Rational Software Corp. (not speaking for them in any way whatsoever)

Re: Will (abstract) Ada code improve over time ?

[Tomasz Wegrzanowski]

In article <E166E69A95753648BC398E36BE9A3AB81451890D@sus-ma1it06.rational.com>, Corey Ashford wrote:
> One major advantage of Ada is built-in threading (i.e. Ada tasks).
> As hardware gets more multiprocessing capability, Ada programs written using
> tasking will naturally get a performance boost.   Of course, multi-threaded
> C programs would get a boost too, but because it's so much easier
> for a programmer to write multi-threaded programs in Ada, they will be more
> likely to do use multi-threading in Ada than in C.

Not true, because C uses hardware/OS threading model, while Ada uses own
threading model, so unless hardware and OSes will be designed for Ada,
C code will perform better (C code can change threading model if
hardware/OS design changes with no problem).

Re: Will (abstract) Ada code improve over time ?

[AG]

"Tomasz Wegrzanowski" <taw@pb220.legnica.sdi.tpnet.pl> wrote in message
news:9k03ot$2me$3@news.tpi.pl...
> In article
<E166E69A95753648BC398E36BE9A3AB81451890D@sus-ma1it06.rational.com>, Corey
Ashford wrote:
> > One major advantage of Ada is built-in threading (i.e. Ada tasks).
> > As hardware gets more multiprocessing capability, Ada programs written
using
> > tasking will naturally get a performance boost.   Of course,
multi-threaded
> > C programs would get a boost too, but because it's so much easier
> > for a programmer to write multi-threaded programs in Ada, they will be
more
> > likely to do use multi-threading in Ada than in C.
>
> Not true, because C uses hardware/OS threading model, while Ada uses own
> threading model, so unless hardware and OSes will be designed for Ada,
> C code will perform better (C code can change threading model if
> hardware/OS design changes with no problem).

Please note that you said "change threading model". That obviously means at
least
*some* change (I hope you didn't mean that C compiler can do that for you?)
Ada model does *not* require that. And, if you want to use hardware/OS
threading model why not bite the bullet and go Assembler way?

Re: Will (abstract) Ada code improve over time ?

[tmoran]

>C code will perform better (C code can change threading model if
>hardware/OS design changes with no problem).
  In fact all of the C code would have to be gone over to change the
threading model.  Whereas the Ada compiler's RTS would change and the
Ada programs would only need to be relinked to take advantage of the
new, improved hardware/OS.  Which prospect sounds better to you?

Re: Will (abstract) Ada code improve over time ?

[Pascal Obry]

taw@pb220.legnica.sdi.tpnet.pl (Tomasz Wegrzanowski) writes:

> Not true, because C uses hardware/OS threading model, while Ada uses own
> threading model, so unless hardware and OSes will be designed for Ada,
> C code will perform better (C code can change threading model if
> hardware/OS design changes with no problem).

Well Ada threading model is based on the hardware/OS threading model (at least
this is true for many Ada compilers). But of course an Ada compiler work
around all the little differences between OS threading model to give you the
very same behavior under whatever OS you use.

You get it ? In C you have all this work to do by yourself. Are we talking
about portability here ?

Pascal.

-- 

--|------------------------------------------------------
--| Pascal Obry                           Team-Ada Member
--| 45, rue Gabriel Peri - 78114 Magny Les Hameaux FRANCE
--|------------------------------------------------------
--|         http://perso.wanadoo.fr/pascal.obry
--|
--| "The best way to travel is by means of imagination"

Re: Will (abstract) Ada code improve over time ?

[Larry Kilgallen]

In article <9k03ot$2me$3@news.tpi.pl>, taw@pb220.legnica.sdi.tpnet.pl (Tomasz Wegrzanowski) writes:

> Not true, because C uses hardware/OS threading model, while Ada uses own
> threading model, so unless hardware and OSes will be designed for Ada,
> C code will perform better (C code can change threading model if
> hardware/OS design changes with no problem).

You do not know, without looking under the covers (of the documentation)
what tasking _mechanism_ is being used.  Some Ada compilers use that
of the OS/hardware, while other Ada compilers use a tasking _mechanism_
of their own.  Some offer a choice, but regardless of the _mechanism_
used, the _model_ presented by Ada is the same.  The _model_ is where
your program must conform.  With Ada there is only one.

One possible reason for _not_ using the OS/hardware mechanism is the
performance cost of a context switch.  If your compiler offers such
an option, you can make a choice without much human effort.

Re: Will (abstract) Ada code improve over time ?

[Florian Weimer]

taw@pb220.legnica.sdi.tpnet.pl (Tomasz Wegrzanowski) writes:

> Not true, because C uses hardware/OS threading model,

The C standard doesn't specify any threading model at all.  As a
result, many C programmers rely on unspecified and undocumented
compiler behavior, and their program works correctly only with some
specific versions of one compiler.  In addition, large parts of the C
run-time library are complicated to implement efficiently in a
multi-threading environment, at least on some architectures.

With Ada, you don't have to use the tasking features of the language.
I think quite a few projects use their own tasking implementation.  Of
course, and certainly for non-embedded applications, there is hardly a
need to do this nowadays.

Re: Will (abstract) Ada code improve over time ?

[Dale Pontius]

In article <slrn9latb9.46.lutz@taranis.iks-jena.de>,
        lutz@iks-jena.de (Lutz Donnerhacke) writes:
> * Reinert Korsnes wrote:
>>Since Ada code is (supposed to be) on a higher abstraction level than for
>>example C, does this mean that we can expect new compilers and hardware
>>over time (10 years ?) will make a program made in Ada more
>>efficient/faster than a similar C program ?
>
> Assuming the same optimizer complexity, it might be true, because Ada
> provides more and more precise information to the compiler than C.
>
The real issue here is about WHO is trying to make better optimizers?
At present, most real-world compilers are C/C++, which don't furnish
the extra information Ada does. Therefore most optimization work likely
doesn't even concern itself with language hints to the optimizer.

In other words, if work is being done to make Ada optimize better than
C, it would probably become apparent here in c.l.a.

One possible alternative scenario is if C++ is able to give hints to
the optimizer. But in that case, I suspect that using those hints would
be more a matter of either ignoring the noise, (not using the hings) or
trying to pick the usable signal out of the noise.

Dale Pontius

Re: Will (abstract) Ada code improve over time ?

[Florian Weimer]

pontius@btv.ibm.com (Dale Pontius) writes:

> The real issue here is about WHO is trying to make better optimizers?
> At present, most real-world compilers are C/C++, which don't furnish
> the extra information Ada does.

Not too recently, one C compiler has introduced optimizations
involving type-based aliasing analysis, an area where Ada can do much,
much better because writing to strings does not potentially change any
other object in the same scope.

There are other features of Ada which can result in compiler backend
input which is easier to optimize, for example, the true 'for' loop
statement.