Interfaces, Inlining, and Dispatching

Interfaces, Inlining, and Dispatching

[Jere]

As I am messing around with interface types I am trying to figure 
out some things:

1.  Is it possible for compilers to inline interface procedure 
implementations if the type being used is known at compile time?  
I.E: not using a class wide type or class wide access type to 
invoke the procedure.

2.  If so, do current compilers implement this?

3.  Assuming another part of the code use a separate implementation 
but dispatches from a class wide type or access type, will this 
revoke the inlining in the other code mentioned in question 1?  
I.E. Can the compiler have an inline version for statically 
dispatched procedure calls and a non inline version for dynamically 
dispatched calls?

4.  If so, do current compilers implement this?

Example:

package Some_Interface is
   type Intfc is interface;
   type Intfc_Class_Access is access all Intfc'Class;
   procedure Do_Somethig(Self : in Intfc) is abstract;
end Some_Interface;

package Implementor_1 is
   type Impl is new interface with null record;
   overriding
   procedure Do_Something(Self : in Impl);
end Implementor_1;

package Implementor_2 is
   type Impl is new interface with null record;
   overriding
   procedure Do_Something(Self : in Impl);
end Implementor_2;

procedure Test_Intfc is
   Impl1 : Implementor_1.Impl;
   Impl2 : Implementor_2.Impl;

   Impls : array(1..2) of Some_Interface.Intfc_Class_Access
      := (1 => new Implementor_1.Impl,
          2 => new Implementor_2.Impl);
begin
   -- I think these cannot be inlined in order to do
   -- the dynamic dispatching
   for Ptr of Impls loop
      Ptr.Do_Something;
   end loop;

   -- Can (and does) the compiler inline these 
   -- if they have a small simple implementation
   -- like just calling another private procedure,
   -- or does the dynamic dispatching above prevent the
   -- compiler from making a second inlined version
   -- of these procedures.
   Impl1.Do_Something;  
   Impl2.Do_Something;

end Test_Intfc;


Forgive any typos.  This was typed up just to illustrate the
question.

Thanks!

Re: Interfaces, Inlining, and Dispatching

[G.B.]

On 16.04.17 17:59, Jere wrote:
> As I am messing around with interface types I am trying to figure
> out some things:
>
> 1.  Is it possible for compilers to inline interface procedure
> implementations if the type being used is known at compile time?
> I.E: not using a class wide type or class wide access type to
> invoke the procedure.
>
> 2.  If so, do current compilers implement this?
>
> 3.  Assuming another part of the code use a separate implementation
> but dispatches from a class wide type or access type, will this
> revoke the inlining in the other code mentioned in question 1?
> I.E. Can the compiler have an inline version for statically
> dispatched procedure calls and a non inline version for dynamically
> dispatched calls?
>
> 4.  If so, do current compilers implement this?

Editing the program so that it can be compiled, and then
choosing one of the freely available compilers has answered
questions 3 and 4 for me. I believe that strictly speaking,
an Inline aspect must apply to a subprogram if the compiler
is to remove the call in favor of inlining. I don't see,
both physically by looking at generated code, and logically
by guessing, mostly, that a compiler isn't allowed to translate
a subprogram in ways that preserve the intended semantics.