Ada Compilers

Ada Compilers

[David Rasmussen]

What is the best free Ada compiler available?

I know that question is probably silly and will get me redirected to the 
faq. Still, I would like to hear _people's_ opinion, instead of the 
usual "we can't say what's best, that's relative".

More importantly, what do the free compilers lack in contrast to the 
commercial ones?

Also, how portable is typical Ada, and how good is code generation 
compared to C++ on the same platform (typically)?

/David

Re: Ada Compilers

[Marin David Condic]

"David Rasmussen" <david.rasmussen@gmx.spam.egg.sausage.and.spam.net> wrote
in message news:3CE2AF22.2060208@gmx.spam.egg.sausage.and.spam.net...
> What is the best free Ada compiler available?

AFAIK, there are only two that are free. ObjectAda (which comes in a limited
version as a kind of "trial" size) and GNAT. Of the two, GNAT is generally
used more because it is not limited - its the full-up production quality
compiler.

There are also some that could be considered "cheap" (money-wise). RR
Software and ObjectAda have versions that are priced within the reach of an
average hobbyist.

>
> I know that question is probably silly and will get me redirected to the
> faq.

See: http://www.adapower.com/ for more info. (Including the FAQ)

Look under "Links" for Ada compilers and vendors. Also under Resources.


Still, I would like to hear _people's_ opinion, instead of the
> usual "we can't say what's best, that's relative".
>
For the record: "we can't say what's best, that's relative". :-) It truly
is, because it depends on what you want to do with it. If you want a
recommendation about what is "best" for a hobbyist with a PC and Windows who
just wants to learn Ada for general purpose software development, I'd say
that GNAT is probably best. You can't beat its price/performance ratio! But
the issue can become immediately sticky the moment you start introducing
other variables - type of application, host/target hardware,
embedded/realtime, required level of support, etc.


> More importantly, what do the free compilers lack in contrast to the
> commercial ones?
>
The free compilers generally won't supply you with any support for the money
you aren't paying. However, if you need support, there are ways to get it -
you just have to open up your wallet. You also won't have the kinds of
selection of targets and such that for-money compilers typically can
provide. You also won't get all of the available tools or the
latest/greatest versions of things either. You get what you pay for - should
be pretty obvious, eh?


> Also, how portable is typical Ada, and how good is code generation
> compared to C++ on the same platform (typically)?
>
Ada is extremely portable. You have to know something about how to make code
portable since you can always hook yourself into platform dependencies no
matter what language you're given. Ada is generally more portable than C++
because compilers have to run a validation suite & AFAIK, most C++ compilers
aren't being validated against the latest standard. (Lots of known variance
between the different compilers and the standard.) I have ported large apps
a number of times between Alpha/VMS, Sun/Unix and PC/Windows & had
surprisingly few problems - often requiring nothing more than a recompile.
But then again, I *knew* I'd have to port so I wasn't hooked into platform
dependencies - or had them isolated where the problems would be minimized.

Quality of code generation? You can't compare this. Its been discussed here
many times. The *language* doesn't determine the quality of code generation.
The *implementation* does. Some compilers are better than others - and
that's all you can hope to compare. (For example: "How good is this version
of the GNAT Ada compiler on a PC versus that version of the MSVC++ compiler
for the PC given this specific collection of algorithms/code?")

That said, there is nothing inherent in Ada that would make it less
efficient than C/C++. Many implementations of Ada generate code that is as
good or better than many implementations of C/C++ for equivalent programs.
So don't worry that Ada is going to somehow or other be "slow". You have to
pick a quality compiler that produces good code for the types of algorithms
you usually write and you have to know the language/implementation well so
that you can get the most out of it.

MDC
--
Marin David Condic
Senior Software Engineer
Pace Micro Technology Americas    www.pacemicro.com
Enabling the digital revolution
e-Mail:    marin.condic@pacemicro.com

Re: Ada Compilers

[Jacob Sparre Andersen]

David Rasmussen wrote:

> What is the best free Ada compiler available?

I don't know, but GCC appears to be the most popular one.

> More importantly, what do the free compilers lack in contrast to the
> commercial ones?

Cost. ;-)

> Also, how portable is typical Ada,

Very portable. When I make data processing programs they can
usually work on OS/2 and at least a few different Unix'es
without any changes. For big projects (>100,000 lines of
code) it is my impression that less than 0.1% of the code
lines will have to be changed.

> and how good is code generation
> compared to C++ on the same platform (typically)?

It is kind of hard to say, but on thing to be aware of right
now is that GCC/Ada still primarily is distributed as GCC
2.8, whereas GCC/C++ primarily is distributed as GCC 3.0,
i.e. with a newer and supposedly better code generator. Once
GCC/Ada is also distributed based on the official GNU CVS
this difference will disappear.

Jacob
-- 
Growing older is compulsory. Growing up isn't.

Re: Ada Compilers

[Marin David Condic]

"Jacob Sparre Andersen" <sparre@nbi.dk> wrote in message
news:3CE2C8FD.CDD0E75B@nbi.dk...
> David Rasmussen wrote:
>
> > More importantly, what do the free compilers lack in contrast to the
> > commercial ones?
>
> Cost. ;-)
>

It occurs to me that the OP may have been wondering if the free compilers
don't implement as much of the language as do the commercial ones. If that's
the question, then it is important to observe that GNAT does implement the
whole language. ObjectAda implements the full language as well, but I have
not examined the free version to know if part of the limitations are lack of
some features. I'd suspect the limits are not with respect to supported
language features.

Otherwise, its going to come down to add-on tools, support, updates, etc.
What do you want/need beyond the ability to translate Ada source into
executable programs?

MDC
--
Marin David Condic
Senior Software Engineer
Pace Micro Technology Americas    www.pacemicro.com
Enabling the digital revolution
e-Mail:    marin.condic@pacemicro.com

Re: Ada Compilers

[Pascal Obry]

Jacob Sparre Andersen <sparre@nbi.dk> writes:

> David Rasmussen wrote:
> 
> > What is the best free Ada compiler available?
> 
> I don't know, but GCC appears to be the most popular one.

Well the Ada compiler part of GCC is named GNAT (GNU/Ada).

> > More importantly, what do the free compilers lack in contrast to the
> > commercial ones?
> 
> Cost. ;-)

Note that there is only one free (speech) Ada compiler, and it is the single
Ada compiler to implement all Ada annexes.

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"
--|
--| gpg --keyserver wwwkeys.pgp.net --recv-key C1082595

Re: Ada Compilers

[Kai Schuelke]

----- Original Message -----
From: "Pascal Obry" <p.obry@wanadoo.fr>
Newsgroups: comp.lang.ada
Sent: Wednesday, May 15, 2002 11:38 PM
Subject: Re: Ada Compilers


> Note that there is only one free (speech) Ada compiler, and it is the
single
> Ada compiler to implement all Ada annexes.

Hello,

could you please explain whats the difference to the Aonix compiler? Or
which annexes the other compilers didn't implement? I am just a beginner but
my first impression was that Aonix produced more "reliable" results. But
thats just a feeling.

Good night

Kai Schuelke

Re: Ada Compilers

[Preben Randhol]

On Thu, 16 May 2002 00:35:35 +0200, Kai Schuelke wrote:
> could you please explain whats the difference to the Aonix compiler? Or
> which annexes the other compilers didn't implement? I am just a beginner but
> my first impression was that Aonix produced more "reliable" results. But
                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Why do you think that?

> thats just a feeling.

Preben

Re: Ada Compilers

[Dmitry A. Kazakov]

On Thu, 16 May 2002 00:35:35 +0200, "Kai Schuelke"
<kai.schuelke@gmx.net> wrote:

>could you please explain whats the difference to the Aonix compiler? Or
>which annexes the other compilers didn't implement?

I believe it just limits the number of compilation units to 30.

>I am just a beginner but
>my first impression was that Aonix produced more "reliable" results. But
>thats just a feeling.

It does some things better and some worse than GNAT. It is nice to
have both, because in case of a compilation error messages from GNAT
and from Aonix nicely complement each other. (:-))

---
Regards,
Dmitry Kazakov
www.dmitry-kazakov.de

Re: Ada Compilers

[Martin Dowie]

"Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de> wrote in message
news:jg17eu40v2r1vbnep19bd9i97e4qg5cfco@4ax.com...
> On Thu, 16 May 2002 00:35:35 +0200, "Kai Schuelke"
> <kai.schuelke@gmx.net> wrote:
>
> >could you please explain whats the difference to the Aonix compiler? Or
> >which annexes the other compilers didn't implement?
>
> I believe it just limits the number of compilation units to 30.

v7.2.1 SE is:

<= 35 units
<= 20 tasks
<= 2000 lines per 'compilation' (I think they actually mean compilation
unit)
<= 550 lines per 'Java compilation'

non-commercial use only, not validated.

Re: Ada Compilers

[Ted Dennison]

"Kai Schuelke" <kai.schuelke@gmx.net> wrote in message news:<3ce2e29f.0@news.unibw-muenchen.de>...
> ----- Original Message -----
> From: "Pascal Obry" <p.obry@wanadoo.fr>
> Newsgroups: comp.lang.ada
> Sent: Wednesday, May 15, 2002 11:38 PM
> Subject: Re: Ada Compilers
> 
> 
> > Note that there is only one free (speech) Ada compiler, and it is the
>  single
> > Ada compiler to implement all Ada annexes.

> could you please explain whats the difference to the Aonix compiler? Or
> which annexes the other compilers didn't implement? I am just a beginner but
> my first impression was that Aonix produced more "reliable" results. But
> thats just a feeling.

Well, I certianly can't explain why you'd think its results are more
"reliable", unless this is some new meaning to the word of which I am
unaccustomed. :-)

The free (no cost) downloadable Aonix compiler doesn't support the
distributed system annex. There might be some more annexes it doesn't
have either, but nothing that would impair a beginner's ability to
program on Windows. It main drawback is that it is crippleware. Once
your program gets past a certian size, the compiler will refuse to
compile it. If you are just playing around with little programs, you
aren't likely to hit that limit though. If you do, you can fix that by
going out and purchasing the full version, which I understand is not
too much more expensive than VisualC++. Not a bad deal at all really.

The Gnu Ada compiler is free in terms of freedom; it, and thus its
users, are not in thrall to any one vendor or person. (See
http://www.gnu.org/philosophy/free-sw.html for more about what "Free
Software" is all about). It is not crippled in any real way, and I
believe implements *all* the annexes. Its main drawback for some is
that its IDE doesn't resemble the VisualC++ IDE, which a lot of newbie
programmers get lost without. If you are comfortable (or want to learn
to become comfortable) with Emacs, then this is probably the free
compiler for you. Apparently a VC++ style IDE is on the way too.


-- 
T.E.D. 
Home     -  mailto:dennison@telepath.com (Yahoo: Ted_Dennison)
Homepage -  http://www.telepath.com/dennison/Ted/TED.html (down)

Re: Ada Compilers

[Robert Dewar]

dennison@telepath.com (Ted Dennison) wrote in message news:<4519e058.0205160706.52667440@posting.google.com>...
> If you are comfortable (or want to learn
> to become comfortable) with Emacs, then this is probably 
> the free compiler for you. Apparently a VC++ style IDE is 
> on the way too.

I think that Ted is giving dubious advice here. I would not
advise a beginner to plunge into EMACS. Instead the obvious
IDE to use is AdaGIDE which is specifically intended for
use by beginners learning Ada (but is sufficiently powerful
to support large projects).

Re: Ada Compilers

[Ted Dennison]

dewar@gnat.com (Robert Dewar) wrote in message news:<5ee5b646.0205161722.18eacc4b@posting.google.com>...
> dennison@telepath.com (Ted Dennison) wrote in message news:<4519e058.0205160706.52667440@posting.google.com>...
> > If you are comfortable (or want to learn
> > to become comfortable) with Emacs, then this is probably 
> > the free compiler for you. Apparently a VC++ style IDE is 
> > on the way too.
> 
> I think that Ted is giving dubious advice here. I would not
> advise a beginner to plunge into EMACS. Instead the obvious

Two things here:

1) I was advising nothing of the sort, which should have been quite
clear from the text you quoted. I was only giving an option
conditioned on whether the poster wants to use Emacs or not. There is
no text in my message on whether that's advisable or not. There's a
good reason for that, which is...

2) The poster never claimed to be a beginner with programming in
general, just with Ada. You could be right when you assume the former,
but that information was not presented for our consideration.


-- 
T.E.D. 
Home     -  mailto:dennison@telepath.com (Yahoo: Ted_Dennison)
Homepage -  http://www.telepath.com/dennison/Ted/TED.html (down)

Re: Ada Compilers

[Robert Dewar]

dennison@telepath.com (Ted Dennison) wrote in message news:<4519e058.0205160706.52667440@posting.google.com>...
> Apparently a VC++ style IDE is on the way too.

Not sure what Ted is talking about here. If you are talking
about the GNAT Programming System (GPS), please be assured that
copying Microsoft was *not* a design criterion :-)

Re: Ada Compilers

[Pascal Obry]

"Kai Schuelke" <kai.schuelke@gmx.net> writes:

> > Note that there is only one free (speech) Ada compiler, and it is the
> single
> > Ada compiler to implement all Ada annexes.
> 
> Hello,
> 
> could you please explain whats the difference to the Aonix compiler? Or

First ObjectAda has a free (beer) version but it is not a free (speech)
compiler. You can't access ObjectAda sources.

> which annexes the other compilers didn't implement? I am just a beginner but

For example Annexe E, but there is others. GNAT implements all of them. Check
Aonix web site for the list of annexes they implement.

> my first impression was that Aonix produced more "reliable" results. But
> thats just a feeling.

This is just feeling I would say. I think that all compilers have their set of
problems.

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"
--|
--| gpg --keyserver wwwkeys.pgp.net --recv-key C1082595

Re: Ada Compilers

[Kai Schuelke]

Hello,

what made me feel that Aonix is more "standard" was a combination of some
minor experiences we made at our Ada school and what the teachers said about
Aonix vs. Gnat (we used both). I can use the full license of Aonix, so that
I didn't see it's limitations.

What I really like about Aonix is the IDE (esp. the GUI-Builder) but thats
not really a compiler issue, but I have to admit that the Gnat error
messages were more helpful than the Aonix ones.

My feeling was intended to be a comment form a beginners point of view, but
no conclusion after years of experience.

ReadU

Kai Schuelke

Re: Ada Compilers

[Robert Dewar]

"Kai Schuelke" <kai.schuelke@gmx.net> wrote in message news:<3ce3ff73.0@news.unibw-muenchen.de>...

> what made me feel that Aonix is more "standard" was a
> combination of some minor experiences we made at our Ada > school

At this stage all the Ada 95 compilers that are available
are sufficiently conformant to the standard that it is
VERY unlikely that beginning students would run into any
discrepancies in any compiler, so these "minor experiences"
were probably misinterpreted.

Re: [off-topic] "free"

[Wes Groleau]

> First ObjectAda has a free (beer) version but it is not a free (speech)
> compiler. You can't access ObjectAda sources.

If the bartender gives you a key to the brewery, which kind of "free" is
that?  :-)

-- 
Wes Troll, Oh!
http://freepages.humor.rootsweb.com/~wgroleau

Re: [off-topic] "free"

[Preben Randhol]

On Fri, 17 May 2002 08:38:35 -0500, Wes Groleau wrote:
> 
>> First ObjectAda has a free (beer) version but it is not a free (speech)
>> compiler. You can't access ObjectAda sources.
> 
> If the bartender gives you a key to the brewery, which kind of "free" is
> that?  :-)

Open Source ;-)

Preben

Re: Ada Compilers

[Fraser Wilson]

Jacob Sparre Andersen <sparre@nbi.dk> writes:

> It is kind of hard to say, but on thing to be aware of right
> now is that GCC/Ada still primarily is distributed as GCC
> 2.8, whereas GCC/C++ primarily is distributed as GCC 3.0,
> i.e. with a newer and supposedly better code generator.

Ah, timing is everything.  Apparently GCC 3.1 has just been released
(http://gcc.gnu.org/gcc-3.1/), and GNAT is one of the official front
ends: http://gcc.gnu.org/frontends.html

I guess it contains GNAT 3.14p, but it's a bit hard to tell from the
web page.

Fraser.

Re: Ada Compilers

[Florian Weimer]

newsfraser@blancolioni.org (Fraser Wilson) writes:

[GCC 3.1]

> I guess it contains GNAT 3.14p,

No, it comes with a different version of the front end and the GNAT
tools.  There are quite a few additional features, AFAIK.

Re: Ada Compilers

[Florian Weimer]

David Rasmussen <david.rasmussen@gmx.spam.egg.sausage.and.spam.net> writes:

> More importantly, what do the free compilers lack in contrast to the
> commercial ones?

GNAT lacks unimplemented annexes in contrast to proprietary compilers?
(GNAT is a commercial compiler, too, so you probably mean something 
else.)

> Also, how portable is typical Ada, and how good is code generation
> compared to C++ on the same platform (typically)?

That's easy in the case of GNAT: identical for equivalent programs.
Both GNU compilers share the same code generator.

Re: Ada Compilers

[Marin David Condic]

True, but misleading. GNAT and GNU C/C++ may all share the same back end &
hence produce similar code for similar input programs, but that in no way
says anything about how good the code is compared to some other compiler
that works for either Ada, C or C++. Its theoretically possible that the gcc
backend might generate really crappy code and hence Ada and C++ are equally
bad. What does that tell you about the relative efficiency of Ada or C++?

This is why its totally useless to ask the question "How does Ada compare
against C++ for efficiency...?" The best we can answer is that the Ada
standard doesn't impose anything that is inherently inefficient for the
semantic content delivered and the rest is a matter of comparing one
compiler against another. There are efficient implementations of both Ada
and C++. There are also bad implementations of both languages. We *really*
need to educate developers (who *should* know this by the time they leave
college!) that languages aren't "slow" - only implementations are.

MDC
--
Marin David Condic
Senior Software Engineer
Pace Micro Technology Americas    www.pacemicro.com
Enabling the digital revolution
e-Mail:    marin.condic@pacemicro.com


"Florian Weimer" <fw@deneb.enyo.de> wrote in message
news:878z6kq4rr.fsf@deneb.enyo.de...
>
> That's easy in the case of GNAT: identical for equivalent programs.
> Both GNU compilers share the same code generator.

Re: Ada Compilers

[David Rasmussen]

Marin David Condic wrote:
> True, but misleading. GNAT and GNU C/C++ may all share the same back end &
> hence produce similar code for similar input programs, but that in no way
> says anything about how good the code is compared to some other compiler
> that works for either Ada, C or C++. Its theoretically possible that the gcc
> backend might generate really crappy code and hence Ada and C++ are equally
> bad. What does that tell you about the relative efficiency of Ada or C++?
> 
> This is why its totally useless to ask the question "How does Ada compare
> against C++ for efficiency...?" The best we can answer is that the Ada
> standard doesn't impose anything that is inherently inefficient for the
> semantic content delivered and the rest is a matter of comparing one
> compiler against another. There are efficient implementations of both Ada
> and C++. There are also bad implementations of both languages. We *really*
> need to educate developers (who *should* know this by the time they leave
> college!) that languages aren't "slow" - only implementations are.
> 

I know that, of course. My question was of a more pragmatic nature. Most 
languages (ML, Lisp, Java etc.) could have compilers that created as 
good code on a given platform (say x86), as the best C compilers for the 
same platform. But in real life, this is not at all the case. So my 
question was if, in practice, most Ada compilers generate code that is 
comparable to, say, C++ compilers. The question makes a lot of pragmatic 
sense.

/David

Re: Ada Compilers

[Jacob Sparre Andersen]

David Rasmussen wrote:

> So my
> question was if, in practice, most Ada compilers generate code that is
> comparable to, say, C++ compilers.

I haven't had time to compare the GCC 3.1 Ada and C++
compilers yet, but last time I compared the front-ends, the
Ada front-end was clearly better at optimising than the C++
one.

Jacob
-- 
Sk�ne Sj�lland Linux User Group - http://www.sslug.dk/
N�ste m�de: Foredragsaften p� Lunds Tekniske H�gskola.
Torsdag den 30. maj 2002 p�/i Lund, LTH, E:2116.

Re: Ada Compilers

[Marin David Condic]

Well, from a purely *practical* standpoint (realizing that we are talking
about existing implementations rather than either the language or any
particular compiler) we might say this: Most popular Ada implementations are
generating code that is pretty efficient in comparison to most other
compiled languages. You won't discover that your basic workstation/PC
application programmed in Ada is somehow bog-slow in comparison to the same
thing in some other language typically used for the same application.

Now a few caveats: If you truly have a time-critical application, you'd best
conduct a timing study with algorithms typical of the application at hand.
Compilers (even for the same language) can have a good deal of variance in
terms of the code they generate for different operations. Be sure that when
timing any Ada code, that you either *really* know what you're doing or that
you are working with the vendor to get the best possible optimization. (Its
easy to compile with all runtime checking in place and/or by using
constructs unwisely and discovering you have pretty slow code. Quite often
throwing a few compiler switches, or including a few pragmas or otherwise
tweaking things a bit, you get really nice code. But you need to know...)

There are some Ada implementations for some targets that are extremely
highly optimizing and will do a wonderful job of producing highly efficient
code. Remember that Ada was originally invented for embedded, real time
apps, so it is possible to find very efficient compilers. However, that
isn't saying there are highly efficient compilers for all platforms and
targets. It also isn't saying that they will be efficient for the algorithms
you intend to use. Compiler timing studies are *very* complex to get right.
(I've been through a couple of serious ones) But its the only way to get any
truly useful information.

MDC
--
Marin David Condic
Senior Software Engineer
Pace Micro Technology Americas    www.pacemicro.com
Enabling the digital revolution
e-Mail:    marin.condic@pacemicro.com


"David Rasmussen" <david.rasmussen@gmx.spam.egg.sausage.and.spam.net> wrote
in message news:3CE58053.2020809@gmx.spam.egg.sausage.and.spam.net...
>
> I know that, of course. My question was of a more pragmatic nature. Most
> languages (ML, Lisp, Java etc.) could have compilers that created as
> good code on a given platform (say x86), as the best C compilers for the
> same platform. But in real life, this is not at all the case. So my
> question was if, in practice, most Ada compilers generate code that is
> comparable to, say, C++ compilers. The question makes a lot of pragmatic
> sense.
>

Re: Ada Compilers

[Greg Bek]

As a compiler vendor I'd just like to echo MDC's comments.
Don't just use standard benchmarks, use your application or
portions of it for testing performance.  Benchmarks like
the PIWG's are not sufficiently sophisticated to properly
perform timing of null loops etc.

Ada compilers have many advantages over languages like C/C++
in that the compiler has greater visibility into the rest of
a user program.  An Ada compiler can automatically inline
code across multiple levels of subprogram call, C/C++ have
difficulty doing this as any called subprogram is usually
compiled into a different object module.  This means that
C/C++ must perform a call/return where the Ada code may
have the call/return (and associated prolog/epilog, stack
check) eliminated.

Our compiler (Rational Apex), performs this kind of inlining
as well as loop unrolling etc.  Another very useful technique
is "value propagation", this is where the compiler tracks the
range of values taken by an object.  Knowing the possible
range of values means that the compiler can eliminate 
constraint checks that are not needed.  This can have some
very disconcerting side affects for the unwary.

If the compiler determines that a section of code has no
side affects (ie: no exceptions can be raised), and that the
results of that section of code are not used, then it 
eliminates all of the code.   The PIWG henessey benchmark
is an example of code that suffers because of this. The
large matrix multiplication contained within the benchmark
is eliminated as the matracies are populated with small-ish
values, the compiler concludes that the range of the resulting
sum of products will never overflow.  It then discovers that
the resulting matrix is never used, so it throws out the entire 
matrix multiplication.  The surrounding timing loop is now 
timing a null operation.

Modern compilers are very good at producing optimized code
under most circumstances.

However there are some subtle issues with Ada that can 
prevent getting the best code possible.  The best example
of this is using controlled objects within your program.
Controlled types require the compiler to generate invisible
code that makes sure any objects are properly finalized when
a scope is exited.

When compiling a routine that uses a class wide type the
compiler may not know whether controlled types are used 
to extend the base type, so it must be pessimistic and 
generate finalization code that may never be called.

If you don't have controlled objects and your compiler has a 
mechanism for optimizing accordingly, then use that mechanism
(switch, library directive, configuration pragma).

As always your milage will vary.

Greg Bek
-------------------------------------------
Greg Bek  mailto:gab@rational.com
Product Manager, Rational Apex Family
Rational Software
-------------------------------------------

Re: Ada Compilers

[Robert Dewar]

gab@rational.com (Greg Bek) wrote in message news:<afb6d339.0205211331.30124c52@posting.google.com>...

> sum of products will never overflow.  It then discovers that
> the resulting matrix is never used, so it throws out the entire 
> matrix multiplication.  The surrounding timing loop is now 
> timing a null operation.

Right, in one case where GNAT was being compared with another
compiler on this test, both versions were testing the time for
this null loop, and because of an oddity, GNAT took longer. 
So we fixed it and then it took shorter. Wonderful, but nothing
at all to do with the intent of the test. The PIWG tests are
very poorly written from this point of view.

Re: Ada Compilers

[Marin David Condic]

"Greg Bek" <gab@rational.com> wrote in message
news:afb6d339.0205211331.30124c52@posting.google.com...
> As a compiler vendor I'd just like to echo MDC's comments.
> Don't just use standard benchmarks, use your application or
> portions of it for testing performance.  Benchmarks like
> the PIWG's are not sufficiently sophisticated to properly
> perform timing of null loops etc.
>
Thanks for the echo. Call me "Marin" - everyone else does. :-)

Artificial benchmarks may tell you something but it is *much* better to use
typical segments of your own apps to try to evaluate performance. Some apps
do lots of data motion, others do lots of comparisons, others do specific
kinds of math, etc. Any given compiler might, for example, generate *really*
tight code for linear equations, but generate slow code for data motion.
Vendors can't do everything, so they spend time optimizing particular
aspects of their products & you'll see as a result that perfectly fine
compilers will have considerable variance in what they come up with for
different applications.


> Ada compilers have many advantages over languages like C/C++
> in that the compiler has greater visibility into the rest of
> a user program.  An Ada compiler can automatically inline
> code across multiple levels of subprogram call, C/C++ have
> difficulty doing this as any called subprogram is usually
> compiled into a different object module.  This means that
> C/C++ must perform a call/return where the Ada code may
> have the call/return (and associated prolog/epilog, stack
> check) eliminated.
>
And of course, as every year goes by in the life of a compiler, more and
more optimizations are found. Every day, in every way, they're getting
better and better. :-) The Ada vendors certainly do have advantages over
some other more popular languages because of how well the language was
designed and the information content of the language being so high.


>
> Modern compilers are very good at producing optimized code
> under most circumstances.
>
We should remember to keep this in perspective too. When I was building
avionics systems, extremely aggressive optimization and really compact, fast
code were life-and-death issues for the projects. I use Ada now mostly for
PC-ish applications and performance is not nearly so critical. What matters
then are other sorts of creature comforts. (development tools, libraries,
etc.) The caveat being that when shopping for a compiler, you need to ask
about what is important for the intended project and not necessarily buy an
avionics-quality compiler just because you are obsessed with speed.

Of course, if someone can give me *everything* for *nothing* I'd be really
thrilled. But I won't hold my breath. :-)


> However there are some subtle issues with Ada that can
> prevent getting the best code possible.  The best example
> of this is using controlled objects within your program.
> Controlled types require the compiler to generate invisible
> code that makes sure any objects are properly finalized when
> a scope is exited.
>
If high performance is an issue for your apps, you need to *really*
understand the language or you can generate inefficient code and be
wondering why. You often have to experiment with alternate ways of
accomplishing the same thing to find the one that fools the compiler into
generating the code you want. I recall once dealing with initialization of
some records where expressing it one way caused the compiler to go off
making a bunch of subroutine calls, but doing it another way we got a single
move of a constant in memory. Know the language and experiment!


>
> As always your milage will vary.
>

Absolutely. And don't besmirch compiler X because it doesn't optimize your
code as nicely as compiler Y. It may optimize someone else's code better
and/or there is a good chance you don't know what you're talking about. :-)

MDC
--
Marin David Condic
Senior Software Engineer
Pace Micro Technology Americas    www.pacemicro.com
Enabling the digital revolution
e-Mail:    marin.condic@pacemicro.com

Re: Ada Compilers

[John R. Strohm]

I'd be VERY interested in seeing a fairly detailed example on this
particular item.

Part of the GLOBAL thrust of what I'm doing is gearing myself up on Ada95,
with the idea in the back of my head of tackling some things that are
typically done in C/C++, and seeing if I can learn enough along the way to
replicate your results in a different domain area: 2x productivity, 1/4x
defect density.

Gotta do something to pass the time between job interviews and mailing out
resumes and such.

(The argument is something like this:  "Now, we all know that there really
aren't any silver bullets, right?  There really aren't any magic wands you
can wave, that will just like magic give you 2x productivity improvement and
1/4x defect density, right?  We all know that, don't we?  Well, what if
there was one?  Suppose there WAS such a wand, such a super secret magic
bullet, that really would let you tackle your current project with half as
many cars in the parking lot, that would let you write only 1/4 as many bug
reports and bug fix reports and retest reports.  If such a wand really did
exist, would you ignore it, throw it away, bury it in a landfill and post
armed guards 24/7 around it, or would you grab it and wave it for all you
were worth?")

"Marin David Condic" <dont.bother.mcondic.auntie.spam@[acm.org> wrote in
message news:acg7rd$15g$1@nh.pace.co.uk...
> If high performance is an issue for your apps, you need to *really*
> understand the language or you can generate inefficient code and be
> wondering why. You often have to experiment with alternate ways of
> accomplishing the same thing to find the one that fools the compiler into
> generating the code you want. I recall once dealing with initialization of
> some records where expressing it one way caused the compiler to go off
> making a bunch of subroutine calls, but doing it another way we got a
single
> move of a constant in memory. Know the language and experiment!

Re: Ada Compilers

[Marin David Condic]

"John R. Strohm" <strohm@airmail.net> wrote in message
news:2AEB9D17A335FB6F.78506B6494B0AFF3.EE290620571FE224@lp.airnews.net...
> I'd be VERY interested in seeing a fairly detailed example on this
> particular item.
>
What item? The initialization thing? Its been a really long time so I don't
remember exactly what we did. We were using the XD-Ada compiler for the
Mil-Std-1750a. (Might also have been true of the MC680x0 target as well, but
I didn't test it on that path.) IIRC, we had a record type that was
initialized by default values. When you declared an object of that type, the
compiler generated subroutine calls for it to get it initialized. It was
causing speed problems, so we tinkered. Initializing it with an aggregate
instead (no default initial values for the type) got us down to the one-word
data move we wanted. Or maybe it was the other way around. :-) It *was* a
long time ago. But it illustrates that you can get very different code to
accomplish the same goal, so you really have to know your compiler, etc.


> Part of the GLOBAL thrust of what I'm doing is gearing myself up on Ada95,
> with the idea in the back of my head of tackling some things that are
> typically done in C/C++, and seeing if I can learn enough along the way to
> replicate your results in a different domain area: 2x productivity, 1/4x
> defect density.
>
You have to be real careful because there is always that all-important
caveat: YOUR MILEAGE MAY VARY!!! :-) In this particular realm, we had a very
specialized process and unlike most projects, we were frequently building
essentially the same thing over and over again. The kinds of errors we
encountered were really peculiar to the specific problem domain and wouldn't
necessarily apply across the board. Hence the productivity and defect rates
may not be anywhere near what someone else in another problem space would
realize. (You might even do better? Who knows?) Also, since we were
measuring a live process that was going on over maybe more than 10 years,
you didn't exactly have laboratory-grade isolation of just the language.
Other things were going on at the same time, so its hard to credit just Ada
for the improvements & have strong confidence that you could reproduce the
same result in another environment just by injecting a new language.


> Gotta do something to pass the time between job interviews and mailing out
> resumes and such.
>
I feel your pain. :-) Giving some thought to re-entering the fray once again
myself. Not a prospect I relish, but sometimes its the thing to do. Good
luck with it and I hope you find something where you can use & promote Ada.


> (The argument is something like this:  "Now, we all know that there really
> aren't any silver bullets, right?  There really aren't any magic wands you
> can wave, that will just like magic give you 2x productivity improvement
and
> 1/4x defect density, right?  We all know that, don't we?  Well, what if
> there was one?  Suppose there WAS such a wand, such a super secret magic
> bullet, that really would let you tackle your current project with half as
> many cars in the parking lot, that would let you write only 1/4 as many
bug
> reports and bug fix reports and retest reports.  If such a wand really did
> exist, would you ignore it, throw it away, bury it in a landfill and post
> armed guards 24/7 around it, or would you grab it and wave it for all you
> were worth?")
>

I understand and possibly agree - to a point. Its just that a lot more is
going to go into productivity and defects than just the language. Its that
bind of "All Other Things Being Equal" - which is almost never the case.
Sure, Ada (in the abstract sense) is better for building reliable software
quickly than is C. But what if C decides to cheat? If C gives you some huge
library of stuff that gets you 75% of the way out the door right now and
that library has been used/debugged extensively, and there is no equivalent
for Ada, will not C win? Or if the project is fairly short term and the
staff already knows C++ extensively and knows nothing about Ada, can Ada
win?

I believe Ada is better based on the evidence I've seen over the years. Its
just that the competition is seldom on an even playing field. The way around
that is for Ada to create its own playing field where the other languages
are at a disadvantage. We don't have to be "fair" or "nice" about it either,
do we? :-)

MDC
--
Marin David Condic
Senior Software Engineer
Pace Micro Technology Americas    www.pacemicro.com
Enabling the digital revolution
e-Mail:    marin.condic@pacemicro.com

Re: Ada Compilers

[Ted Dennison]

"John R. Strohm" <strohm@airmail.net> wrote in message news:<2AEB9D17A335FB6F.78506B6494B0AFF3.EE290620571FE224@lp.airnews.net>...
> (The argument is something like this:  "Now, we all know that there really
> aren't any silver bullets, right?  There really aren't any magic wands you
> can wave, that will just like magic give you 2x productivity improvement and
> 1/4x defect density, right?  We all know that, don't we?  Well, what if
> there was one?  Suppose there WAS such a wand, such a super secret magic

For the record, to qualify as Brooks' famous "Silver Bullet", you
would have to have something that would improve things by a factor of
10, not just 2 or 4. Ada provides a package that is pretty close to
what Brooks termed a "Brass Bullet" in his essay "No Silver Bullet,
Refired". He was talking about OO languages in general, but C++ and
Smalltalk were used as examples. I'd say Rational's numbers prove his
argument nicely.

Re: Ada Compilers

[Larry Kilgallen]

In article <2AEB9D17A335FB6F.78506B6494B0AFF3.EE290620571FE224@lp.airnews.net>, "John R. Strohm" <strohm@airmail.net> writes:

> (The argument is something like this:  "Now, we all know that there really
> aren't any silver bullets, right?  There really aren't any magic wands you
> can wave, that will just like magic give you 2x productivity improvement and
> 1/4x defect density, right?

Depending on your present circumstance, there may be a silver bullet
that will give you those benefits.

But there is no silver bullet that will give _everyone_ those benefits
(irrespective of present circumstance).

Re: Ada Compilers

[Steve Doiel]

"David Rasmussen" <david.rasmussen@gmx.spam.egg.sausage.and.spam.net> wrote
in message news:3CE2AF22.2060208@gmx.spam.egg.sausage.and.spam.net...
> What is the best free Ada compiler available?

GNAT

> I know that question is probably silly and will get me redirected to the
> faq. Still, I would like to hear _people's_ opinion, instead of the
> usual "we can't say what's best, that's relative".
>
> More importantly, what do the free compilers lack in contrast to the
> commercial ones?

If you're just talking compiler, Gnat actually provides more than some of
the proprietary ones.

> Also, how portable is typical Ada, and how good is code generation
> compared to C++ on the same platform (typically)?

Portability: Excellent
Code generation: Very Good.  If you're comparing with free C++, Excellent.

>
> /David
>

Re: Ada Compilers

[Preben Randhol]

On Wed, 15 May 2002 20:55:30 +0200, David Rasmussen wrote:
> What is the best free Ada compiler available?

GNAT

available for Linux, Solaris, Windows, MacOS (there is a port worked on
by individuals)

GNAT will also be part of GCC.

> More importantly, what do the free compilers lack in contrast to the 
> commercial ones?

Nothing.

> Also, how portable is typical Ada, and how good is code generation 
> compared to C++ on the same platform (typically)?

Ada code is much more portible and if you use the libraries GNAT
supplies for interacting with the IO etc.. a recompile should be all you
need to do from one system to another. 

What do you mean how good is code generation?

More info is here why you should choose Ada over say C++:

   http://www.adapower.com/what.html

Preben Randhol ------------------- http://www.pvv.org/~randhol/ --
                 �For me, Ada95 puts back the joy in programming.�

Re: Ada Compilers

[Preben Randhol]

On Thu, 16 May 2002 10:33:34 +0000 (UTC), Preben Randhol wrote:
> On Wed, 15 May 2002 20:55:30 +0200, David Rasmussen wrote:
>> What is the best free Ada compiler available?
> 
> GNAT
> 
> available for Linux, Solaris, Windows, MacOS (there is a port worked on
> by individuals)

and many other systems.
-- 
Preben Randhol ------------------- http://www.pvv.org/~randhol/ --
                 �For me, Ada95 puts back the joy in programming.�

Re: Ada Compilers

[David Rasmussen]

Preben Randhol wrote:
> 
> What do you mean how good is code generation?
> 

I mean how good is the generated machine code on various CPU's (x86 for 
instance) with typical Ada compilers as compared with typical C++ compilers?

Re: Ada Compilers

[Preben Randhol]

On Thu, 16 May 2002 13:25:22 +0200, David Rasmussen wrote:
> Preben Randhol wrote:
>> 
>> What do you mean how good is code generation?
>> 
> 
> I mean how good is the generated machine code on various CPU's (x86 for 
> instance) with typical Ada compilers as compared with typical C++ compilers?
> 

Why? The important question is how good is the quality of the software
produced with Ada compared to C++.

Preben

Re: Ada Compilers

[David Rasmussen]

Preben Randhol wrote:
> On Thu, 16 May 2002 13:25:22 +0200, David Rasmussen wrote:
> 
>>Preben Randhol wrote:
>>
>>>What do you mean how good is code generation?
>>>
>>
>>I mean how good is the generated machine code on various CPU's (x86 for 
>>instance) with typical Ada compilers as compared with typical C++ compilers?
>>
> 
> 
> Why? The important question is how good is the quality of the software
> produced with Ada compared to C++.
> 
> Preben

No. For some applications, timewise performance is critical, and when 
you have chosen the design and improved the algorthms used as much as 
possible, you still want the fastest code possible. The quality of the 
software is of course paramount always, but if runtime performance is 
also an all-important criterion (but portability etc. also is, so you 
can't use assembler), it will be important to you how good the generated 
code is. It is for me, even if safety, correctness etc. is equally 
important.

/David

Re: Ada Compilers

[Steve Doiel]

"David Rasmussen" <david.rasmussen@gmx.spam.egg.sausage.and.spam.net> wrote
in message news:3CE3B32D.9080309@gmx.spam.egg.sausage.and.spam.net...
[snip]
> For some applications, timewise performance is critical, and when
> you have chosen the design and improved the algorthms used as much as
> possible, you still want the fastest code possible. The quality of the
> software is of course paramount always, but if runtime performance is
> also an all-important criterion (but portability etc. also is, so you
> can't use assembler), it will be important to you how good the generated
> code is. It is for me, even if safety, correctness etc. is equally
> important.

I believe you will find that the performance of Ada matches or exceeds the
performance of C++ if you turn off runtime checks.  Since C++ does not have
these checks there is no compartive disadvantage to turning off the checks.
There is however the advantage that you can turn on the checks during
testing.  In many cases performance cost of runtime checks are low and they
are left enabled for delivered software.

> /David
>

Re: Ada Compilers

[David Rasmussen]

Steve Doiel wrote:
> "David Rasmussen" <david.rasmussen@gmx.spam.egg.sausage.and.spam.net> wrote
> in message news:3CE3B32D.9080309@gmx.spam.egg.sausage.and.spam.net...
> [snip]
> 
>>For some applications, timewise performance is critical, and when
>>you have chosen the design and improved the algorthms used as much as
>>possible, you still want the fastest code possible. The quality of the
>>software is of course paramount always, but if runtime performance is
>>also an all-important criterion (but portability etc. also is, so you
>>can't use assembler), it will be important to you how good the generated
>>code is. It is for me, even if safety, correctness etc. is equally
>>important.
> 
> 
> I believe you will find that the performance of Ada matches or exceeds the
> performance of C++ if you turn off runtime checks.  Since C++ does not have
> these checks there is no compartive disadvantage to turning off the checks.
> There is however the advantage that you can turn on the checks during
> testing.  In many cases performance cost of runtime checks are low and they
> are left enabled for delivered software.
> 

Cool. That was what I was looking for.

/David

Re: Ada Compilers

[Preben Randhol]

On Thu, 16 May 2002 15:25:01 +0200, David Rasmussen wrote:
> 
> No. For some applications, timewise performance is critical, and when 
> you have chosen the design and improved the algorthms used as much as 
> possible, you still want the fastest code possible. The quality of the 
> software is of course paramount always, but if runtime performance is 
> also an all-important criterion (but portability etc. also is, so you 
> can't use assembler), it will be important to you how good the generated 
> code is. It is for me, even if safety, correctness etc. is equally 
> important.

I agree with you. The reason I commented your question was that a lot of
people asking this question, but are not reflected as you seem to be.
People believe that the speed of the application is the most important
factor. This is generally not the case at all. At least when making
user applications. The user will loose far more time from program
crashes than that a program uses 2ms more to open a dialog.

Preben
-- 

Re: Ada Compilers

[Ted Dennison]

David Rasmussen <david.rasmussen@gmx.spam.egg.sausage.and.spam.net> wrote in message news:<3CE3B32D.9080309@gmx.spam.egg.sausage.and.spam.net>...
> No. For some applications, timewise performance is critical, and when 
> you have chosen the design and improved the algorthms used as much as 
> possible, you still want the fastest code possible. The quality of the 
> software is of course paramount always, but if runtime performance is 
> also an all-important criterion (but portability etc. also is, so you 
> can't use assembler), it will be important to you how good the generated 
> code is. It is for me, even if safety, correctness etc. is equally 
> important.


One thing I should mention here is that the Aonix compiler has *no*
compiler optimization options. Gnat and GCC have oodles of them. When
I asked Aonix about this, I was told that they do some optimization
(eg: peephole -type stuff) by default. But if you are into tweeking
optimization options on your compiler, I think you will be far happier
with Gnat.

-- 
T.E.D. 
Home     -  mailto:dennison@telepath.com (Yahoo: Ted_Dennison)
Homepage -  http://www.telepath.com/dennison/Ted/TED.html

Re: Ada Compilers

[Marin David Condic]

Not entirely fair. It is perfectly fair to ask about the quality of code
generation for specific language implementations. Efficiency is a reasonable
concern - sometimes a *critical* concern such as when dealing with hard
realtime constraints.

The best answer is that there are very good, highly optimizing Ada compilers
that can produce code every bit as tight as the best C/C++ compilers for
similar programs. The caveat is that you can *only* talk about specific
compilers and targets - not about the language in general. For example, (as
observed elsewhere) the GNAT compiler and the GCC C/C++ compilers share the
same back end & generate pretty much identical code for identical programs
of different languages. Is GCC a "good" compiler for the x86 PC? Most people
think so. Hence, GNAT is going to be just as efficient - sometimes even
moreso - than C or C++ going through the GCC compiler. Are there *better*
compilers out there than GCC/GNAT? Maybe - for a given platform - and for
given algorithms/applications - and some of them will compile Ada while
other compile C or C++ or Fortran or who knows what. If efficiency is a
critical concern, the only hope is to conduct timing studies comparing
different implementations for the problems at hand. If efficiency is just a
casual concern, then rest asured that there are implementations of Ada that
are Good Enough.

MDC
--
Marin David Condic
Senior Software Engineer
Pace Micro Technology Americas    www.pacemicro.com
Enabling the digital revolution
e-Mail:    marin.condic@pacemicro.com


"Preben Randhol" <randhol+abuse@pvv.org> wrote in message
news:slrnae79li.oe.randhol+abuse@kiuk0156.chembio.ntnu.no...
> On Thu, 16 May 2002 13:25:22 +0200, David Rasmussen wrote:
> >
> > I mean how good is the generated machine code on various CPU's (x86 for
> > instance) with typical Ada compilers as compared with typical C++
compilers?
> >
>
> Why? The important question is how good is the quality of the software
> produced with Ada compared to C++.
>

Re: Ada Compilers

[Preben Randhol]

On Thu, 16 May 2002 09:30:09 -0400, Marin David Condic wrote:
> Not entirely fair. It is perfectly fair to ask about the quality of code
> generation for specific language implementations. Efficiency is a reasonable
> concern - sometimes a *critical* concern such as when dealing with hard
> realtime constraints.

Yes, read my followup that explains why I asked.

Preben

Re: Ada Compilers

[Pascal Obry]

Preben Randhol <randhol+abuse@pvv.org> writes:

> On Wed, 15 May 2002 20:55:30 +0200, David Rasmussen wrote:
> > What is the best free Ada compiler available?
> 
> GNAT
> 
> available for Linux, Solaris, Windows, MacOS (there is a port worked on
> by individuals)
> 
> GNAT will also be part of GCC.
       ^^^^^^^^^^^^
       is 

GCC 3.1 has been released yesterday :)

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"
--|
--| gpg --keyserver wwwkeys.pgp.net --recv-key C1082595

Re: Ada Compilers

[Ted Dennison]

Pascal Obry <p.obry@wanadoo.fr> wrote in message news:<uvg9ot481.fsf@wanadoo.fr>...
> Preben Randhol <randhol+abuse@pvv.org> writes:
> 
> GCC 3.1 has been released yesterday :)

Cool! Forget Morrowind, I know what I'll be playing with tonight. :-)

I forget...do we have a good official place to put precompiled binaries?

-- 
T.E.D. 
Home     -  mailto:dennison@telepath.com (Yahoo: Ted_Dennison)
Homepage -  http://www.telepath.com/dennison/Ted/TED.html

Re: Ada Compilers

[Pascal Obry]

dennison@telepath.com (Ted Dennison) writes:

> I forget...do we have a good official place to put precompiled binaries?

What about AdaPower (http://www.adapower.com/) ? We already have pages for
Linux and Machintosh, what about a new section about GNAT 5.0 binaries ?

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"
--|
--| gpg --keyserver wwwkeys.pgp.net --recv-key C1082595

Re: Ada Compilers

[Simon Wright]

Pascal Obry <p.obry@wanadoo.fr> writes:

> What about AdaPower (http://www.adapower.com/) ? We already have pages for
> Linux and Machintosh, what about a new section about GNAT 5.0 binaries ?

I don't think 5.0 is right?, gnatls -v now says

  GNATLS 3.1 (20020501) Copyright 1997-2001 Free Software Foundation, Inc.

(don't know why the (c) date hasn't changed!)

I think the original 3.1 is so long ago that no one is going to care a
lot about the overloading. Or was it 3.01?!

Re: Ada Compilers

[Pascal Obry]

Simon Wright <simon@pushface.org> writes:

> Pascal Obry <p.obry@wanadoo.fr> writes:
> 
> > What about AdaPower (http://www.adapower.com/) ? We already have pages for
> > Linux and Machintosh, what about a new section about GNAT 5.0 binaries ?
> 
> I don't think 5.0 is right?, gnatls -v now says
> 
>   GNATLS 3.1 (20020501) Copyright 1997-2001 Free Software Foundation, Inc.

Right, I was confused, this is GNAT 3.1 on the FSF GCC tree.

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"
--|
--| gpg --keyserver wwwkeys.pgp.net --recv-key C1082595

Re: Ada Compilers

[David Botton]

I would be happy to host any binaries. Please e-mail me directly when any
one is ready to upload and I will give them directions and make the page
available.

David Botton


"Pascal Obry" <p.obry@wanadoo.fr> wrote in message
news:ur8kau4gc.fsf@wanadoo.fr...
>
> dennison@telepath.com (Ted Dennison) writes:
>
> > I forget...do we have a good official place to put precompiled binaries?
>
> What about AdaPower (http://www.adapower.com/) ? We already have pages for
> Linux and Machintosh, what about a new section about GNAT 5.0 binaries ?
>
> Pascal.

Re: Ada Compilers

[Preben Randhol]

On 17 May 2002 08:11:53 -0700, Ted Dennison wrote:
> Pascal Obry <p.obry@wanadoo.fr> wrote in message news:<uvg9ot481.fsf@wanadoo.fr>...
>> Preben Randhol <randhol+abuse@pvv.org> writes:
>> 
>> GCC 3.1 has been released yesterday :)

Oh, I didn't say this. I didn't know this at all.

Preben

Re: Ada Compilers

[Jerry van Dijk]

dennison@telepath.com (Ted Dennison) writes:

> I forget...do we have a good official place to put precompiled binaries?

Yes, it's now part of the mingw project on sourceforge.

-- 
--  Jerry van Dijk   | email: jvandyk@attglobal.net
--  Leiden, Holland  | web:   users.ncrvnet.nl/gmvdijk

Re: Ada Compilers

[Ted Dennison]

Jerry van Dijk <jvandyk@attglobal.net> wrote in message news:<wk3cwpviph.fsf@attglobal.net>...
> dennison@telepath.com (Ted Dennison) writes:
> 
> > I forget...do we have a good official place to put precompiled binaries?
> 
> Yes, it's now part of the mingw project on sourceforge.

But that's only for Win32 precompiled binaries. Even if every platform
has its own official place for precompiled binaries, I'd think it
would be good for the Ada community to have one place where they are
all mirrored, no?

I know David has kindly offered his site up, so that's a good option.

To my mind, the most logical place would be on the GNUAda website
(http://www.gnuada.org/ ). Is that not the kind of thing it was
created for?


-- 
T.E.D.
Home     -  mailto:dennison@telepath.com (Yahoo: Ted_Dennison)
Homepage -  http://www.telepath.com/dennison/Ted/TED.html

Re: Ada Compilers

[Jerry van Dijk]

dennison@telepath.com (Ted Dennison) writes:

> > Yes, it's now part of the mingw project on sourceforge.
> 
> But that's only for Win32 precompiled binaries. Even if every platform
> has its own official place for precompiled binaries, I'd think it
> would be good for the Ada community to have one place where they are
> all mirrored, no?

The mingw project is the only place to get the properly patched native Win32
binaries. A link should be easy :-) As I said before, the real issue is the 
Win32 support (binding, tools) and things like the debugger and packaging.

-- 
--  Jerry van Dijk   | email: jvandyk@attglobal.net
--  Leiden, Holland  | web:   users.ncrvnet.nl/gmvdijk

Ada compilers

[arkavae]

It is not clear for me what are the differents avaliables Ada compilers (except for GNAT) ? Is there an other company like Adacore producing Ada compilers ?

Re: Ada compilers

[Niklas Holsti]

On 12-11-24 17:55 , arkavae@gmail.com wrote:
> It is not clear for me what are the differents avaliables Ada
> compilers (except for GNAT) ? Is there an other company like
> Adacore producing Ada compilers ?

See http://www.adaic.org/ada-resources/ and in particular
http://www.adaic.org/ada-resources/pro-tools-services/.

AFAIK the only free/no-cost compiler is GNAT, but RR Software (link on
the page above) provides a low-cost compiler. Other compiler vendors
linked on the "pro tools" page are, AFAIK, Atego, DDC-I, Green Hills,
Irvine Compiler, and possibly (but perhaps no longer) OC Systems.

-- 
Niklas Holsti
Tidorum Ltd
niklas holsti tidorum fi
      .      @       .

Re: Ada compilers

[Gautier write-only]

On 24 nov, 16:55, arka...@gmail.com wrote:
> It is not clear for me what are the differents avaliables Ada compilers (except for GNAT) ? Is there an other company like Adacore producing Ada compilers ?

Hi.

Here is a list - not sure if complete...
http://unzip-ada.sf.net/#adacomp

Cheers
_________________________
Gautier's Ada programming
http://gautiersblog.blogspot.com/search/label/Ada
NB: follow the above link for a valid e-mail address

ADA compilers

[Patty]

I am trying to find an ADA compiler for ADA83 for a Pentium/RedHat
Enterprise Linux 3 operating system platform, but have not been able to
locate one so far. Anyone know of one??

Re: ADA compilers

[Pascal Obry]

"Patty" <patricia.l.addiss@honeywell.com> writes:

> I am trying to find an ADA compiler for ADA83 for a Pentium/RedHat
> Enterprise Linux 3 operating system platform, but have not been able to
> locate one so far. Anyone know of one??

Why Ada83, are you porting an application ?

Have a look at GNAT. Part of GCC and commercial support available from
AdaCore. http://www.adacore.com. I'm sure there is some other compilers
for GNU/Linux I'll let other answer...

Pascal.

-- 

--|------------------------------------------------------
--| Pascal Obry                           Team-Ada Member
--| 45, rue Gabriel Peri - 78114 Magny Les Hameaux FRANCE
--|------------------------------------------------------
--|              http://www.obry.net
--| "The best way to travel is by means of imagination"
--|
--| gpg --keyserver wwwkeys.pgp.net --recv-key C1082595

Re: ADA compilers

[Patty]

Yes, we are trying to port an existing application.  I have looked at
GNAT, but they only have ADA95.

Re: ADA compilers

[Dmitry A. Kazakov]

On 3 Jun 2005 12:12:01 -0700, Patty wrote:

> Yes, we are trying to port an existing application.

Egh, how to port Ada 83 to Ada 95 without Ada 95?

>  I have looked at GNAT, but they only have ADA95.

1. There should be no problem to port Ada 83 code to Ada 95.
Incompatibilities are rather minor.

2. AFAIK, GNAT has "-gnat83" switch for Ada 83 legacy code.

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

Re: ADA compilers

[Björn Lundin]

2005-06-03 kl. 21.21 skrev Dmitry A. Kazakov:

> On 3 Jun 2005 12:12:01 -0700, Patty wrote:
>
>> Yes, we are trying to port an existing application.
>
> Egh, how to port Ada 83 to Ada 95 without Ada 95?

Porting to another OS perhaps?

The OP is looking for and ADA compiler for linux, not an Ada 95 
compiler.

/Björn

Björn Lundin
bnl at spray dot se

Re: ADA compilers

[Jeff C]

Patty wrote:
> Yes, we are trying to port an existing application.  I have looked at
> GNAT, but they only have ADA95.
> 

The issues involved with an update from Ada 83 to Ada 95 are <<= any 
issues you will run into with simply porting code from one compiler/os 
to another.

If the existing code makes use of a lot of vendor specific packages and 
it does not encapsulate it well, this will be a bit of work.

In any case if I were doing a bid (and I've done lots of them) the port 
from Ada 83 to Ada 95 would probably not even how up in the last digit 
compared to any other issues associated with the port.


What can be a bit more difficult (situation I have been in for a long 
time) is when you need the same (or mostly the same) codebase to be 
backwards compatible with the old compiler for some time. The only 
trouble in this case is just verifying from time to time that you did 
not "leak" any ada 95 features into your code base.

In any case I've got about 150K SLOC of Ada 83 that I also use with an 
Ada 95 compiler (with Ada 83 being the primary compiler still for a 
variety of reasons) and I've only got 1 file that is branched to make 
the Ada 83 work with the Ada 95 compiler because it is Ada 95 (note 
there are 5 or 6 other branched files but these are branched due to some 
vendor specific library issues or other areas that are due to vendor 
differences and not Ada language revision differences).

Re: ADA compilers

[Keith Thompson]

"Patty" <patricia.l.addiss@honeywell.com> writes:
> Yes, we are trying to port an existing application.  I have looked at
> GNAT, but they only have ADA95.

Most valid Ada 83 programs are valid Ada 95 programs with the same
semantics.  Most of the exceptions (such as using new keywords as
identifiers) are easy to fix.

Try compiling the application with GNAT (or with any Ada 95 compiler).
You're likely to run into more problems going from one compiler to
another than going from Ada 83 to Ada 95, especially if the program
uses any compiler-specific features -- and you're going to have to fix
those problems anyway.

Since Ada 83 compilers are, for the most part, no longer being
maintained, you might not be able to find one that works with a newer
operating system.

-- 
Keith Thompson (The_Other_Keith) kst-u@mib.org  <http://www.ghoti.net/~kst>
San Diego Supercomputer Center             <*>  <http://users.sdsc.edu/~kst>
We must do something.  This is something.  Therefore, we must do this.

Re: ADA compilers

[Björn Lundin]

2005-06-03 kl. 21.12 skrev Patty:

> Yes, we are trying to port an existing application.  I have looked at
> GNAT, but they only have ADA95.
>
We have ported a fairly large system from Ada83 to Ada 95 (Ie using an 
Ada 95 compiler on Ada83 code)
with hardly no problems. The things to watch out for is if you have 
variable names that
are the same as the new reserved words that Ada 95 brings. Ie you cant 
have a variable called 'aliased' since
that is a reserved word now.

We are using Gnat now, and had troble with some applications due to 
circular dependencies,
with the resukt that the Gnat compiler refused to link the application. 
The 'difficult' application contained heavy
use of tasking, in combination of a great deal of generic packages. The 
old compiler said OK, and so did other
Ada 95 compilers. Minor rewrite solved it.

A BIG difference with Gnat and other compilers are the way the Ada 
library a
is handled. We used it a lot, having several libraries in the same 
level, but not able to see each other.
ie
global
     level2-1
     level2-2
        level3
     level2-3

where the ones on level2 could all see global, but not each other. 
Level3 could see level2-2 and global but not the others

Of course, having different packages, with the same name, in all 
level2's is common in our system.
Tcl-script reading flat file'repository' based on current working 
directory, and
use of environment variables ADA_INCLUDE_PATH and ADA_OBJECT_PATH made
it possible to make it work, without having to use several projectfiles.

This was the
biggest challege

Then of course, packages using vendors spcifics, as how to get the 
command line, tasking policies
etc will differ.

Another thing to watch out for, if tasking is inviolved, is how the old 
compiler created tasks.
Is it run by the os like threads or locally in the runtime? This 
changes the way you can interact
with blocking io. We got a big boost using Gnat, because it made it 
possible to use
blocking io, instead of polling.

This was on Aix, but compiled and linked and tested (very very little) 
on Linux and mac os X as well

/Björn

Björn Lundin
bnl at spray dot se

Re: ADA compilers

[Jeffrey Carter]

Patty wrote:
> Yes, we are trying to port an existing application.  I have looked at
> GNAT, but they only have ADA95.

I have used GNAT to develop Ada-83 code. In fact, I had to do so again 
only a couple of weeks ago. The -gnat83 switch turns GNAT into an Ada-83 
compiler.

Note that it's Ada, a woman's name, not the American Dental Association.

-- 
Jeff Carter
"Oh Lord, bless this thy hand grenade, that with it thou
mayst blow thine enemies to tiny bits, in thy mercy."
Monty Python and the Holy Grail
24

Re: ADA compilers

[Martin Krischik]

Patty wrote:

> I am trying to find an ADA compiler for ADA83 for a Pentium/RedHat
> Enterprise Linux 3 operating system platform, but have not been able to
> locate one so far. Anyone know of one??

Well you can use gnat with the "-gnat83" option.

Martin

-- 
mailto://krischik@users.sourceforge.net
Ada programming at: http://ada.krischik.com

Re: Ada Compilers

[David Humphris]

 > > > One thing I should mention here is that the Aonix compiler has *no*
 > > > compiler optimization options. Gnat and GCC have oodles of them. When
 > > > I asked Aonix about this, I was told that they do some optimization
 > > > (eg: peephole -type stuff) by default.
 > >
 > > This used to be the case for ObjectAda for Windows however this has
 > > been rectified a couple of releases ago. 7.2.1 introduced the optimizer
 > > on the Windows platform.
 >
 > I was unaware of that. Thanks for the clarification. Has the freely
 > downloadable "Special Edition" been so updated? That's the compiler we
 > were actually talking about.

Yes they are available with 7.2.1 Special Edition on WIndows.

David Humphris.

Re: Ada Compilers

[Ted Dennison]

David Humphris <dhumphris@aonix.co.uk> wrote in message news:<mailman.1021886521.4259.comp.lang.ada@ada.eu.org>...
> > One thing I should mention here is that the Aonix compiler has *no*
>  > compiler optimization options. Gnat and GCC have oodles of them. When
>  > I asked Aonix about this, I was told that they do some optimization
>  > (eg: peephole -type stuff) by default.
> 
> This used to be the case for ObjectAda for Windows however this has
> been rectified a couple of releases ago.  7.2.1 introduced the optimizer
> on the Windows platform.

I was unaware of that. Thanks for the clarification. Has the freely
downloadable "Special Edition" been so updated? That's the compiler we
were actually talking about.

-- 
T.E.D.
Home     -  mailto:dennison@telepath.com (Yahoo: Ted_Dennison)
Homepage -  http://www.telepath.com/dennison/Ted/TED.html

Ada Compilers

[Nathan A. Barclay]

The project I'm working on at work is looking into switching from Ada 83 to
Ada 95, and I've been trying to get an idea of how the different Ada 95
compilers compare.  Specifically, the compilers we're considering are GNAT
with Ada Core Technologies' support, Aonix's ObjectAda, Green Hills
Software's Ada compiler, and MAYBE Rational Apex Ada (although it's probably
too expensive).  If anyone has any thoughts on how the compilers compare (or
on related questions, e.g. something they especially like or dislike about
one of them), I'd love to hear them.  We're looking specifically at Sun
Sparc/Solaris systems, but thoughts stemming from other platforms might be
useful too, if not to me then maybe to others.

Re: Ada Compilers

[bklungle]

I can give you our current experiences. Yours may vary based on usage.

We are using Verdix Ada 83 on AIX (RS6k), Green Hills Ada 83 on AIX (RS6k)
cross targeted to the Rad-Hard RS6k with VxWorks, Green Hills Ada 83 on
Sparc/Solaris self targeted for debugging prior to using the cross compiler,
GNAT Ada95 on Dual P6/180 running Linux, GNAT Ada95 on IRIX 5.3 SGI Indigo2.
Another company we subcontract to is using Rational Apex C++ on SGI Indigo2.
Overall, the majority of the programmers prefer the GNAT Ada 95. If you go
this route, definitely grab ACT support. They have some excellent extended
tools and VERY knowledgable people who are willing to help, not like some
who take your money and return nothing.
To date, Rational Apex C++ is having trouble for as yet unknown reasons.
Again, experiences vary.

cheers...bob

Nathan A. Barclay wrote in message ...
>
>
>The project I'm working on at work is looking into switching from Ada 83 to
>Ada 95, and I've been trying to get an idea of how the different Ada 95
>compilers compare.  Specifically, the compilers we're considering are GNAT
>with Ada Core Technologies' support, Aonix's ObjectAda, Green Hills
>Software's Ada compiler, and MAYBE Rational Apex Ada (although it's
probably
>too expensive).  If anyone has any thoughts on how the compilers compare
(or
>on related questions, e.g. something they especially like or dislike about
>one of them), I'd love to hear them.  We're looking specifically at Sun
>Sparc/Solaris systems, but thoughts stemming from other platforms might be
>useful too, if not to me then maybe to others.
>
>
>

ADA Compilers

[A REILLY]

I'm currently a student at Portsmouth University, studying Computer
Science and I'm interested in obtaining a decent ADA 95 Compiler.  If
anyone knows where I can get one (Cheap) please let me know.

Cheers Andy :-)

Re: ADA Compilers

[Jon S Anthony]

In article <4q24t4$fdn@newsbf02.news.aol.com> areilly@aol.com (A REILLY) writes:

> I'm currently a student at Portsmouth University, studying Computer
> Science and I'm interested in obtaining a decent ADA 95 Compiler.  If
> anyone knows where I can get one (Cheap) please let me know.

ftp cs.nyu.edu, in /pub/gnat

There you will find the following (among other stuff)

emacs-ada-mode-2.12.tar.gz*
emx09b-gnat-os2-bin-disk1.zip*
emx09b-gnat-os2-bin-disk2.zip*
ez2load/
features*
gdb/
gnat-3.01-bin-m68k-next-nextstep3.tar.gz*
gnat-3.01-linuxaout.README
gnat-3.01-linuxaout.tar.gz*
gnat-3.01-mips-dec-ultrix4.3-bin.tar.gz*
gnat-3.03-hppa-bin.tar.gz*
gnat-3.03-i386-next-nextstep3-bin.tar.gz*
gnat-3.03-unknown-i386-solaris2.4-README
gnat-3.03-unknown-i386-solaris2.4-bin.tar.gz*
gnat-3.04-i386-unknown-netbsd1.1-README*
gnat-3.04-i386-unknown-netbsd1.1.tar.gz*
gnat-3.04-i486-linux-elf-bin.tar.gz*
gnat-3.04-src-netbsd.diff.gz*
gnat-3.05-alpha-dec-osf3.2-bin.tar.gz*
gnat-3.05-i486-linux-elf-bin.tar.gz*
gnat-3.05-mips-sgi-irix5.3-bin.tar.gz*
gnat-3.05-os2-bin-disk1.zip*
gnat-3.05-os2-bin-disk2.zip*
gnat-3.05-os2-bin-disk3.zip*
gnat-3.05-rs6000-ibm-aix3.2-bin.tar.gz*
gnat-3.05-sparc-sun-solaris2.4-bin.tar.gz*
gnat-3.05-sparc-sun-sunos4.1.3-bin.tar.gz*
gnat-3.05-src-update.tar.gz*
gnat-3.05-src.tar.gz*
gnat-dos-readme
gnat-windows95-readme*
win95/

> 
> Cheers Andy :-)

Cheers!

/Jon
-- 
Jon Anthony
Organon Motives, Inc.
1 Williston Road, Suite 4
Belmont, MA 02178

617.484.3383
jsa@organon.com

Ada Compilers.

[David Leslie Garrard]

Iam looking for an ada compiler that runs under unix and is distributed
under a GNU type distribution.

DLG

ADA COMPILERS

[douglassalter@ajpo.sei.cmu.edu,]

Could you please sent a list of validated ADA compilers to
 dsalter@BCGUNT.AF.MIL - DDN address 26.7.0.13. We are especially interested
any WANG ADA compilers.

ADA compilers

[John Ostlund]

Anyone know of any ADA compilers for a PC and/or SUN workstations???

(any ADA interpreters available?)

Please reply to: OSTLUND@SRC.Honeywell.com

      Thanks in advance, John.

Ada Promises

[Doug Schmidt]

In article <7053@hubcap.clemson.edu>, billwolf%hazel (William Thomas Wolfe, 2847 ) writes:
>   This has been a property of some early Ada *compilers*, but is
>   not a property of the Ada *language*.  

I basically agree with this in principle, though Ganapathi and
Mendal's IEEE Computer article from February 1989 points out several
areas where the Ada's semantics of reordering operations restricts
code motion and strength reduction.  I'd assume that this penalizes
Ada on certain RISC processors since it limits the degree of
instruction scheduling possible.

>   Fortunately, compiler
>   technology is now capable of delivering tight, efficient Ada
>   object code, better than that being produced by C compilers.

Ironically, Ganapathi and Mendal conclude their article by stating
that:
 
  Use of the following Ada capabilities may hinder optimizations currently
  implemented in most Ada compilers:
  
  * exceptions
  * generic units
  * private and limited private types in package definitions
  * naming and modularity of package definitions, and
  * tasking

In other words, just about every major feature that differentiates Ada
from Modula 2 or Pascal exacts a penalty on optimization.  This is a
realistic and understandable phenomenon (C/C++ certainly contain their
share of features that disrupt optimization), but it also makes me
wonder just exactly what you mean with your claim that Ada compilers
produce better code than C compilers.

To avoid misunderstanding, can you please cite *specific* examples
(especially references to publically available literature) to support
your claim?  For example:

1. Precisely which Ada compilers produce better code than which C compilers?
   Not all compilers are created equal...

2. What are the benchmarks and where can they be obtained?  If, in
   order to generate good code, Ada programmers must limit themselves to
   a `Pascal subset' of the language exactly what advantages have
   accrued?

3. What are the hardware/OS platforms and what are the relative costs
   between the Ada and C compilers/environments?  After all, it is
   unfair to compare a $500,000 Rational Ada environment against
   a $120 copy of Turbo C on MS DOS ;-).

Without independently verifiable, empirical evidence it is difficult
to make an informed choice on this issue.  In the words of R. P.
Feynman:

  The fundamental principle of science, the definition almost, is this:
  the sole test of the validity of any idea is experiment.

Additional proof would greatly increase my confidence that Ada is more than
just another `promising' language (pun intended!).

thanks,

  Doug
--
Master Swordsman speak of humility;             | schmidt@ics.uci.edu (ARPA)
Philosophers speak of truth;                    | office: (714) 856-4034
Saints and wisemen speak of the Tao of no doubt;
The moon, sun, and sea speaks for itself. -- Hiroshi Hamada

Re: Ada compilers

[William Thomas Wolfe, 2847]

From schmidt@zola.ics.uci.edu (Doug Schmidt):
>>   Fortunately, compiler
>>   technology is now capable of delivering tight, efficient Ada
>>   object code, better than that being produced by C compilers.
> 
> 1. Precisely which Ada compilers produce better code than 
>    which C compilers? Not all compilers are created equal...

   The Telesoft TeleGen2 compiler, vs. all available C compilers,
   as of circa October 1988; contact Telesoft for details, since 
   the statement was made at the Telesoft User's Group meeting at
   the Tri-Ada '88 conference.  

> 2. What are the benchmarks and where can they be obtained?  If, in
>    order to generate good code, Ada programmers must limit themselves to
>    a `Pascal subset' of the language exactly what advantages have
>    accrued?

   I seem to recall "Dhrystone", among others, being cited.  There 
   were no limitations on the use of the Ada language.
 
> 3. What are the hardware/OS platforms and what are the relative costs
>    between the Ada and C compilers/environments?  After all, it is
>    unfair to compare a $500,000 Rational Ada environment against
>    a $120 copy of Turbo C on MS DOS ;-).

   I think the comparison might have focused on Sun workstations,
   but I'm by no means positive.  In any event, the point of contact is:

      TeleSoft, 5959 Cornerstone Court West, San Diego, CA, 92121-9891

   There were several articles in the Proceedings of Tri-Ada '88
   which considered at length the sophisticated optimization techniques
   which went into the TeleGen2 compiler; that might also be a good source. 
 
   There has been a new release of the TeleGen2 compiler since October 
   1988, and undoubtedly new releases of C compilers as well, so it 
   would probably be best to contact TeleSoft directly at the above 
   address for the most recent competitive statistics.  
    

   Bill Wolfe, wtwolfe@hubcap.clemson.edu

Re: Ada Compilers

[Robert Cousins]

I, too, am seeking information on validate ADA compilers.
The machine I am interested in is a 386 under Everex Unix (will
run Interactive binaries also).  Does anyone have any info?

Thankx

Robert Cousins
Speaking for myself alone.

Ada Compilers

[Kelvin W. Edwards]

I am seeking some information on validated Ada compilers for
use on any of the following computers:

	Commodore Amiga
	Apple MacIntosh
	SGI Iris 4D Series
	Sun MicroSystems (preferrably under SunOS3.4 or higher)

In particular,  does such a compiler exist and, if so, what are the 
hardware/software requirements for it ?  Also, does it have a 
good working environment ?  Any helpful experience you could pass on 
would also be appreciated.  Thanks in advance.

	Sincerely,
		 kelvin edwards

ada compilers

[Kjartan R. Gudmundsson]

I would like to know about Ada compilers for HP 9000/840 running HP-UX,
and for 386 unix boxes, (ibm ps/2-70). Please tell me about the compilers
you know of.

		thanks
###############################################################################
#                                     #                                       #
#	Kjartan R. Gudmundsson        # 
#	Raudalaek 12                  # 
#	105 Reykjavik                 #     Internet:  kjartan@rhi.hi.is      #
#       Iceland                       #     uucp:  ...mcvax!hafro!rhi!kjartan #
#                                     #                                       #
###############################################################################