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=0.7 required=5.0 tests=BAYES_00,INVALID_DATE, MSGID_SHORT,REPLYTO_WITHOUT_TO_CC autolearn=no autolearn_force=no version=3.4.4 Path: utzoo!utgpu!news-server.csri.toronto.edu!cs.utexas.edu!uunet!seas.gwu.edu!mfeldman From: mfeldman@seas.gwu.edu (Michael Feldman) Newsgroups: comp.lang.ada Subject: Re: Ada Code Efficiency Message-ID: <2780@sparko.gwu.edu> Date: 23 Feb 91 19:47:01 GMT References: <2860@cod.NOSC.MIL> Reply-To: mfeldman@seas.gwu.edu () Organization: The George Washington University, Washington D.C. List-Id: In article <2860@cod.NOSC.MIL> sampson@cod.nosc.mil (Charles H. Sampson) writes: > > I still think that Cray Ada is a good counterexample to the idea that Ada >code is inherently slow. I'll wait for Telesoft to issue an official announce- >ment about the scalar code efficiency, rather than give out the current figure >that Phillipe gave me. I see no reason why the final figure should be much >less than 100%. If constraint checks are suppressed, to let Ada and FORTRAN >compete on equal terms, I would expect it to be so close to 100% that any dif- >ference is insignificant. > Well put. On similar benchmarks I have seen straightforward scalar Ada come very close to what C can do on the same code. (Indeed I have seen claims that for this kind of code, Ada has done _better_ than C). I am very surprised that anyone who halfway understood compilers would claim that unadorned, numerical, scalar code from a language A program would _necessarily_ be slower than the same from from language F. I'd be really delighted to see these claims debunked forever. On a level playing field, there are only X many ways to evaluate a scalar expression. This means turning off constraint checks to level the field. I believe that as compilers get smarter about avoiding unnecessary checks (and the LRM never required unnecessary checks!), and programmers get smarter about just how, when, and where to help the compiler by _selective_ use of pragma SUPPRESS, we're going to see just the right tradeoff between speed and safety. The growing maturity of compilers, users, and managers is really gratifying! How long do you think it'll take for the bulk of the industry to throw away their outdated stereotypes about slow, clunky Ada? It's good to see intelligent debate about what really makes programs slow. It ain't the source language, folks. Mike Feldman