Re: Bounds Check Overhead

[Ludovic Brenta <ludovic@ludovic-brenta.org>]

Rich Townsend <rhdt@barVOIDtol.udel.edu> writes:
> Dick Hendrickson wrote:
>>      Given something like
>>      COMMON I
>>      DO I = 1,10
>>         call something (I)
>>         call something_else()
>>      enddo
>> "something" is not allowed to change it's argument and neither
>> "something" nor "something_else" is allowed to change the variable
>> in common.  This prohibition flows down the entire call tree from
>> these routines.  And that's why it's hard to check.
>
> ...although a lot of the constructs introduced in Fortran 90 help in
> checking -- in particular, if the called subroutines have INTENT()
> on their arguments, then its pretty cut-and-dry whether I will be
> modified or not. Having said that, things like host association can
> muddy the waters somewhat -- but at least you only have to go down
> one level to check if I is being modified.

Then Ada is better in that respect than Fortran.  In Ada, the compiler
has enough knowledge about what subprograms do to their arguments that
it can easily check that loop indexes never change (i.e. you can pass
the loop index as an "in" parameter but not as an "out" or "in out"
parameter).

Also, in Ada, the loop index does not exist outside of the loop.  From
what you said, it seems to me that in Fortran, the loop index still
exists after the loop, and has a well-defined value, but the
programmer can then change it.  Correct?

-- 
Ludovic Brenta.