From mboxrd@z Thu Jan  1 00:00:00 1970
X-Spam-Checker-Version: SpamAssassin 3.4.4 (2020-01-24) on polar.synack.me
X-Spam-Level: *
X-Spam-Status: No, score=1.2 required=5.0 tests=BAYES_00,FROM_WORDY,
	INVALID_MSGID autolearn=no autolearn_force=no version=3.4.4
X-Google-Language: ENGLISH,ASCII-7-bit
X-Google-Thread: 103376,fd3a5ba6349a6060
X-Google-Attributes: gid103376,public
From: "Nick Roberts" <Nick.Roberts@dial.pipex.com>
Subject: Re: should I be interested in ada?
Date: 1999/02/19
Message-ID: <7akvan$j5t$1@plug.news.pipex.net>#1/1
X-Deja-AN: 446252438
References: <7a72e6$g55$1@probity.mcc.ac.uk> <36C93BB4.1429@ecs.soton.ac.uk>
 <7afc1o$3mi$2@plug.news.pipex.net> <7afttr$7v3$1@nnrp1.dejanews.com>
 <7aganu$qsc$1@plug.news.pipex.net> <36CC11A1.C7A71642@hercii.mar.lmco.com>
 <7ahkn0$kab$1@plug.news.pipex.net> <36CC6AC0.25DBE56D@erols.com>
 <7aikfp$nhq$3@plug.news.pipex.net> <36CD44CF.A61DAE96@erols.com>
 <7ajrpu$jpq$1@nnrp1.dejanews.com>
X-MimeOLE: Produced By Microsoft MimeOLE V4.72.3110.3
Organization: UUNET WorldCom server (post doesn't reflect views of UUNET
 WorldCom)
Newsgroups: comp.lang.ada
Date: 1999-02-19T00:00:00+00:00
List-Id: <comp.lang.ada>

robert_dewar@my-dejanews.com wrote in message
<7ajrpu$jpq$1@nnrp1.dejanews.com>...
|> Does Ada enforce anti-aliasing rules regarding the global
|> variables?
|
|The anti-aliasing rules are in some respects weaker,
|although in other respects stronger (the stronger typing
|for example allows better aliasing information to be
|built). You can construct artificial examples which give
|a theoretical optimization advantage in either direction.
|How important this is in practice is anyone's guess.


However, I think there are ways in which an Ada compiler could 'get round'
the theoretical advantage that Fortran has (see my other post).

[...]
|However, other aggregate operations in Fortran that imply
|parallelism may not be so easy to model in Ada.


Certainly true, in terms of source text, there are some Fortran constructs
which are not so readily witten in Ada. For example (a simple one!):

   x(1:3,:,1:5) = y(:)

might have to be written in Ada as:

   for i in 1..3 loop
      for j in X'Range(2) loop
         for k in 1..5 loop
            X(i,j,k) := Y(j);
         end loop;
      end loop;
   end loop;

Not nearly so neat or convenient (but, nevertheless, not impractical).

However, an optimising Ada compiler targetting, say, a SIMD machine, would
still be able to vectorise the assignment. This is an 'obvious'
optimisation. For any target, there's no reason why it couldn't produce code
just as good as for the Fortran equivalent.

|> I really am simply courious.  I see many things in Ada
|> which. I find attractive and I want to know about the
|> optimization issues.
|
|Nick proposed that "the high level language is
|theoretically compltely immaterial [to the optimization
|issue]", and that of course is completely wrong.
|
|It is definitely the case that there are various
|theoretical differences, but as always, the difficulty
|with any optimization issues is knowing how much
|difference it will make in practice, and that is
|hard to know. Usually such theoretical differences
|are swamped by other engineering issues, i.e. "other
|things being equal" is a condition that is not  in
|practice easy to meet.


I should have avoided generalising to 'high level languages'. I don't
believe there is any _theoretical_ difference between Fortran 90 and Ada 95,
as regards optimisation. I agree entirely that _are_ differences, in
practice.

Can anyone provide an example (which isn't totally unrealistic?) which shows
an unavoidable optimisation advantage of one language over another?

-------------------------------------
Nick Roberts
-------------------------------------