Re: Exception handling overhead?

[anon@anon.org (anon)]

You must disable the compiler default Range checking, like:


  function Element( B : Buffer; Index : Positive ) return Character is

    begin
      declare
        -- Temporary disable system checks

        pragma Suppress ( Range_Check ) ;
      begin
        if Index > Ada.Strings.Unbounded.Length ( B.Internal_String ) then
          raise Bad_Index ;
        end if ;
      end ;
    return Ada.Strings.Unbounded.Element ( B.Internal_String, Index ) ;
  end Element ;


In <Xns9BF75019363FApcc482719gmailcom@198.186.192.137>, "Peter C. Chapin" <pcc482719@gmail.com> writes:
>Hello!
>
>I'm creating a type intended to represent lines of editable text. It 
>will provide some specialized services and is not intended to be a 
>general purpose string type. At the moment I'm wrapping the type 
>Ada.Strings.Unbounded.Unbounded_String (I'm really using Wide_Strings, 
>but I don't think that's important right now). I may want to change that 
>underlying implementation in the future so I don't want to directly 
>expose my current choice to my clients. Thus I'm providing some 
>subprograms that do some minor things and then just forward to 
>subprograms in Ada.Strings.Unbounded.
>
>My question is about exceptions. To avoid exposing my implementation 
>choice and to give me more control in the long run I've defined my own 
>exception for (as an example) an out of bounds access:
>
>Bad_Index : exception;
>
>Naturally I want to raise this exception if the client tries to access a 
>character not in my buffer. This leads to two possibilities.
>
>function Element(B : Buffer; Index : Positive) return Character is
>begin
>  if Index > Ada.Strings.Unbounded.Length(B.Internal_String) then
>    raise Bad_Index;
>  end if;
>  return Ada.Strings.Unbounded.Element(B.Internal_String, Index);
>end Element;
>
>This entails two checks on the index value: the one I'm doing and the 
>one being done inside Ada.Strings.Unbounded.Element. Another approach is
>
>function Element(B : Buffer; Index : Positive) return Character is
>begin
>  return Ada.Strings.Unbounded.Element(B.Internal_String, Index);
>exception
>  when Ada.Strings.Index_Error =>
>    raise Bad_Index;
>end Element;
>
>This lets the check exist in only one place but it invokes the machinery 
>of exception handling.
>
>Now I know that in C++ there are implementation methods that allow zero 
>execution time overhead in the case when an exception is not thrown (at 
>the expense of increasing executable size and making thrown exceptions 
>slower). Compilers are not required to use such methods, of course, but 
>I know of at least one that does... or that can if the right options are 
>selected. I'm wondering about how this might work in Ada. Does Ada admit 
>such implementation methods? If so, do compilers commonly use them? From 
>a raw performance point of view which of the two approaches above would 
>be "better?"
>
>For the record... I understand that in my application it probably 
>doesn't matter much either way. I also understand that the answer is 
>likely to be very compiler specific. This is mostly a question of 
>academic interest.
>
>Thanks!
>
>Peter