RE: Question on controlled types

RE: Question on controlled types

[Beard, Frank Randolph CIV]

Well, not exactly nothing.  It initializes J.  In this case, A gets set
to 0 (zero).  The version that causes PROGRAM_ERROR happens because the
Initialize method is called before it has been elaborated.

IIRC, basically the differences are:

--+ Initialize without calling the Initialize procedure.
J : Instrum.Instrum_Type := (Ada.Finalization.Controlled with A=>0);

--+ Call the Initialize procedure.
J : Instrum.Instrum_Type;

--+ Call Finalize for J, copy X, then call Adjust for J.
J := X;

Frank


-----Original Message-----
From: Alex Xela [mailto:xela2@free.fr]

On the following code, what should happen during J variable elaboration?

 - Nothing

 - A call to Adjust.

I tried to find the answer in RM95 but in vain.

My tests on several compilers (and my feeling) were suggesting  : nothing!





--CODE :
begin ----------------------------------------------------------------------
------------------

with Ada.Finalization;

package Instrum is

    type Instrum_Type is new Ada.Finalization.Controlled with

    record

        A : Integer;

    end record;

    procedure Finalize  (O : in out Instrum_Type);

    procedure Adjust  (O : in out Instrum_Type);

    procedure Initialize  (O : in out Instrum_Type);

    J : Instrum.Instrum_Type := ( Ada.Finalization.Controlled with
A=>0);--nothing?

    --J : Instrum.Instrum_Type; --raised PROGRAM_ERROR : access before
elaboration

end Instrum;

--CODE :
end ------------------------------------------------------------------------
------------------

Re: Question on controlled types

[Robert I. Eachus]

Beard, Frank Randolph CIV wrote:

> --+ Initialize without calling the Initialize procedure.
> J : Instrum.Instrum_Type := (Ada.Finalization.Controlled with A=>0);

Does not call the Initialize procedure for Instrum_Type, but does call 
initialization for Ada.Finalization.Controlled, which may do nothing.
(Hey, what do you expect, I am a language lawyer. ;-)

-- 
                                         Robert I. Eachus

"Quality is the Buddha. Quality is scientific reality. Quality is the 
goal of Art. It remains to work these concepts into a practical, 
down-to-earth context, and for this there is nothing more practical or 
down-to-earth than what I have been talking about all along...the repair 
of an old motorcycle."  -- from Zen and the Art of Motorcycle 
Maintenance by Robert Pirsig

Question on Controlled types

[Olivier Scalbert]

Hello,

I am learning controlled types features and I do not understand the 
following thing.

With this code:
-------------------------------------
     Spec
-------------------------------------
with audio; use audio;
with Ada.Finalization; use Ada.Finalization;

package audio.effect is

     type Delay_Line is limited private;

     function Make_Delay_Line (Duration: Duration_Type) return Delay_Line;

private

     type Delay_Line is new Controlled with record
         Duration: Duration_Type;
     end record;

     overriding procedure Initialize(Object: in out Delay_Line);
     overriding procedure Adjust(Object: in out Delay_Line);
     overriding procedure Finalize(Object: in out Delay_Line);

end audio.effect;

-------------------------------------
     Body
-------------------------------------
with Ada.Text_IO; use Ada.Text_IO;

package body audio.effect is

     function Make_Delay_Line(Duration: Duration_Type) return Delay_Line is
         D: Delay_Line;
     begin
         Put_Line("Make_Delay_Line");
         return D;
     end Make_Delay_Line;

     procedure Initialize(Object: in out Delay_Line) is
     begin
         Put_Line("Initialize Delay_Line");
     end;

     procedure Adjust(Object: in out Delay_Line) is
     begin
         Put_Line("Adjust Delay_Line");
     end;

     procedure Finalize(Object: in out Delay_Line) is
     begin
         Put_Line("Finalize Delay_Line");
     end;

end audio.effect;

-------------------------------------
     Test
-------------------------------------
with audio.effect; use audio.effect;

procedure test1 is
     Delay1 : Delay_Line := Make_Delay_Line(Duration => 0.1);
begin
     null;
end test1;

-------------------------------------
     Program output
-------------------------------------
Initialize Delay_Line
Make_Delay_Line
Adjust Delay_Line
Finalize Delay_Line
Finalize Delay_Line

I have two "Finalize(s)" for one "Initialize".
Should I call Initialize from Adjust ?

How to have only one Initialize/Finalize ?

Thanks to help me,

Olivier.

Re: Question on Controlled types

[Dmitry A. Kazakov]

On Sat, 30 May 2009 13:41:41 +0200, Olivier Scalbert wrote:

> I am learning controlled types features and I do not understand the 
> following thing.

[...]

> Initialize Delay_Line
> Make_Delay_Line
> Adjust Delay_Line
> Finalize Delay_Line
> Finalize Delay_Line
> 
> I have two "Finalize(s)" for one "Initialize".

This is a correct behavior.

> Should I call Initialize from Adjust ?

No.
 
> How to have only one Initialize/Finalize ?

You cannot (need not). Here is an interpretation of what happens in your
case:

1. When Make_Delay_Line is called it creates local variable D. This is your
call to Initialize.

2. Then it returns D. For this the content of D is copied into Delay1 of
the caller and Adjust is done. That is your Adjust.

3. Then D is destroyed and Finalize is called. That is your first call to
Finalize.

4. When test1 is completed, Delay1 is destroyed and so the second call to
Finalize happens.

The formula is I + A = F, where I is the number of calls to Initialize, A
is the number of calls to Adjust and F is the number of calls to Finalize.

Note that the compiler has right to optimize some pairs Adjust/Finalize
away or add new ones.

-- 
Regards,
Dmitry A. Kazakov
http://www.dmitry-kazakov.de

Re: Question on Controlled types

[Olivier Scalbert]

Dmitry A. Kazakov wrote:
> On Sat, 30 May 2009 13:41:41 +0200, Olivier Scalbert wrote:
>> Initialize Delay_Line
>> Make_Delay_Line
>> Adjust Delay_Line
>> Finalize Delay_Line
>> Finalize Delay_Line
>>
>> I have two "Finalize(s)" for one "Initialize".
> 
> This is a correct behavior.
> 
>> Should I call Initialize from Adjust ?
> 
> No.
>  
>> How to have only one Initialize/Finalize ?
> 
> You cannot (need not). Here is an interpretation of what happens in your
> case:
> 
> 1. When Make_Delay_Line is called it creates local variable D. This is your
> call to Initialize.
> 
> 2. Then it returns D. For this the content of D is copied into Delay1 of
> the caller and Adjust is done. That is your Adjust.
> 
> 3. Then D is destroyed and Finalize is called. That is your first call to
> Finalize.
> 
> 4. When test1 is completed, Delay1 is destroyed and so the second call to
> Finalize happens.
> 
> The formula is I + A = F, where I is the number of calls to Initialize, A
> is the number of calls to Adjust and F is the number of calls to Finalize.
> 
> Note that the compiler has right to optimize some pairs Adjust/Finalize
> away or add new ones.
> 

Thanks Dmtry.

Inside the Initialize I will later create a (very) large array.
Inside the Finalize I will free this large array.

If I want to use only one instance of Delay_Time, how can I reformulate 
the program to have only one I and one F ?

Olivier

Re: Question on Controlled types

[Olivier Scalbert]

More accurately from the Delay_Line user point of view, I would like to 
be able to:

1- Create a Delay_Line:

Delay1 : Delay_Line := Make_Delay_Line(Duration: Duration_Type); -- here 
the internal large array is created on the heap.

2- Use it (I prefer dot notation!):
Delay1.Set_Input(Input_Signal);
Output_Signal := Delay1.Get_Output();

3- Be able to adjust the duration later:
Delay1.Set_Duration(...); -- here the new array is created, the values 
of the old array are processed and re-injected into the new one and then 
the old array is freed.

4- When Delay1 will end his life, I want the allocated array to be freed.

5- I do not need this:
Delay2 := Delay1;

Olivier

Re: Question on Controlled types

[Robert A Duff]

Olivier Scalbert <olivier.scalbert@algosyn.com> writes:

> 5- I do not need this:
> Delay2 := Delay1;

Then you probably want to make the type limited (e.g. derive from
Limited_Controlled).  You also want to turn on Ada 2005 mode, so
you can do build-in-place function returns.

- Bob

Re: Question on Controlled types

[Olivier Scalbert]

Robert A Duff wrote:
> Olivier Scalbert <olivier.scalbert@algosyn.com> writes:
> 
>> 5- I do not need this:
>> Delay2 := Delay1;
> 
> Then you probably want to make the type limited (e.g. derive from
> Limited_Controlled).  You also want to turn on Ada 2005 mode, so
> you can do build-in-place function returns.
> 
> - Bob

Thank Bob, it starts working now !
I do not know the build-in-place function returns yet.
I have just received my Barnes 2005 yesterday ...
;-)

Olivier

Re: Question on Controlled types

[Robert A Duff]

Olivier Scalbert <olivier.scalbert@algosyn.com> writes:

> Robert A Duff wrote:
>> Olivier Scalbert <olivier.scalbert@algosyn.com> writes:
>>
>>> 5- I do not need this:
>>> Delay2 := Delay1;
>> Then you probably want to make the type limited (e.g. derive from
>> Limited_Controlled).  You also want to turn on Ada 2005 mode, so
>> you can do build-in-place function returns.
>> - Bob
>
> Thank Bob, it starts working now !

You're welcome.

> I do not know the build-in-place function returns yet.

AdaCore's Gems number 10, 11, and 12 talk about this.
They're available here:

http://www.adacore.com/category/developers-center/gems/

> I have just received my Barnes 2005 yesterday ...
> ;-)

The Barnes book is good.

- Bob

Re: Question on Controlled types

[Hibou57 (Yannick Duchêne)]

On 30 mai, 15:27, "Dmitry A. Kazakov" <mail...@dmitry-kazakov.de>
wrote:
> The formula is I + A = F, where I is the number of calls to Initialize, A
> is the number of calls to Adjust and F is the number of calls to Finalize.
>
> Note that the compiler has right to optimize some pairs Adjust/Finalize
> away or add new ones.

So this means that if there was a second assignation of Delay1,
Finalize would be invoked before the copy and the Adjust which will
follow the copy ?

With one single assignation :

1) Delay1 assigned
2) Adjust invoked

3) Finalize invoked

With two assignations:

1) Delay1 assigned
2) Adjust invoked

3) Finalize invoked before copy
4) Delay1 assigned
5) Adjust invoked after copy

6) Finalize invoked

Is that right ?

Re: Question on Controlled types

[Dmitry A. Kazakov]

On Thu, 4 Jun 2009 05:32:59 -0700 (PDT), Hibou57 (Yannick Duch�ne) wrote:

> On 30 mai, 15:27, "Dmitry A. Kazakov" <mail...@dmitry-kazakov.de>
> wrote:
>> The formula is I + A = F, where I is the number of calls to Initialize, A
>> is the number of calls to Adjust and F is the number of calls to Finalize.
>>
>> Note that the compiler has right to optimize some pairs Adjust/Finalize
>> away or add new ones.
> 
> So this means that if there was a second assignation of Delay1,
> Finalize would be invoked before the copy and the Adjust which will
> follow the copy ?

Yes.

Initialization contains a call to either Initialize or Adjust
Assignment contains one call to Finalize and next to Adjust
Finalization contains a call to Finalize

In C++ terms:

Initialize is a part of the "default constructor". Adjust is a part of the
"copy constructor". ":=" is composed out of the "destructor", bitwise copy
and a call to Adjust. The "destructor" calls to Finalize.

-- 
Regards,
Dmitry A. Kazakov
http://www.dmitry-kazakov.de

Re: Question on Controlled types

[Hibou57 (Yannick Duchêne)]

On 4 juin, 16:04, "Dmitry A. Kazakov" <mail...@dmitry-kazakov.de>
wrote:
> > So this means that if there was a second assignation of Delay1,
> > Finalize would be invoked before the copy and the Adjust which will
> > follow the copy ?
>
> Yes.

So this implies that at execution time, distinction can be made
between the first and the next assignement.

How does compilers deals with it ? With a default initialization of
variables ?

Re: Question on Controlled types

[Dmitry A. Kazakov]

On Thu, 4 Jun 2009 07:34:43 -0700 (PDT), Hibou57 (Yannick Duch�ne) wrote:

> On 4 juin, 16:04, "Dmitry A. Kazakov" <mail...@dmitry-kazakov.de>
> wrote:
>>> So this means that if there was a second assignation of Delay1,
>>> Finalize would be invoked before the copy and the Adjust which will
>>> follow the copy ?
>>
>> Yes.
> 
> So this implies that at execution time, distinction can be made
> between the first and the next assignement.

No, initialization is not an assignment. This difference was subtle in Ada
95, but in Ada 2005 is more obvious. Consider a limited type T and the
function Create that "returns" T:

   X : T := Create; -- This is OK, because it is an initialization
begin
   X := Create; -- This is illegal, because it would be an assignment

Further within Create:

function Create return T is
begin
   return X : T [do ... end return]; -- This OK
end Create;

function Create return T is
   X : T;
begin
   return X;  -- This is not OK, because it returns a local
                -- limited object X, which is semantically equivalent
                -- to an assignment
end Create;

-- 
Regards,
Dmitry A. Kazakov
http://www.dmitry-kazakov.de

Re: Question on Controlled types

[Hibou57 (Yannick Duchêne)]

On 4 juin, 17:03, "Dmitry A. Kazakov" <mail...@dmitry-kazakov.de>
wrote:

> No, initialization is not an assignment.

“ Initialization and assignment is treated as a different thing ” :
Ok, this is much more clear to me now, and I like this concept.

Lot of thanks for this great point.

Re: Question on Controlled types

[Randy Brukardt]

"Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de> wrote in message 
news:1oa4b8avzgtos.3ofldt4u0hnh.dlg@40tude.net...
...
> Initialization contains a call to either Initialize or Adjust

<Pedant>Initialization can also come from an aggregate, which doesn't call 
either Initialize or Adjust. (Unless it is copied).</Pedant>

                           Randy.

Re: Question on Controlled types

[christoph.grein]

Delay_Line is not immutably limited, so the initial value in test1 is
not built in place.

>      function Make_Delay_Line(Duration: Duration_Type) return Delay_Line is
>          D: Delay_Line;  -- your initialize here
>      begin
>          Put_Line("Make_Delay_Line");
>          return D;  -- first finalize here for local D ------------------------------------
>      end Make_Delay_Line;
>      Test

> procedure test1 is
>      Delay1 : Delay_Line := Make_Delay_Line(Duration => 0.1);  -- no initialize here
> begin
>      null;  -- second finalize here for Delay1 -------------------------------------------
> end test1;
>
> -------------------------------------
>      Program output
> -------------------------------------
> Initialize Delay_Line
> Make_Delay_Line
> Adjust Delay_Line
> Finalize Delay_Line
> Finalize Delay_Line

So this is OK

Re: Question on controlled types

[christoph.grein]

A more elaborated analysis of what is going on with controlled types/objects can 
be found here:

http://home.t-online.de/home/Christ-Usch.Grein/AdaMagica/Secretive.html

Question on controlled types

[Alex Xela]

On the following code, what should happen during J variable elaboration?

 - Nothing

 - A call to Adjust.

I tried to find the answer in RM95 but in vain.

My tests on several compilers (and my feeling) were suggesting  : nothing!





--CODE :
begin ----------------------------------------------------------------------
------------------

with Ada.Finalization;

package Instrum is

    type Instrum_Type is new Ada.Finalization.Controlled with

    record

        A : Integer;

    end record;

    procedure Finalize  (O : in out Instrum_Type);

    procedure Adjust  (O : in out Instrum_Type);

    procedure Initialize  (O : in out Instrum_Type);

    J : Instrum.Instrum_Type := ( Ada.Finalization.Controlled with
A=>0);--nothing?

    --J : Instrum.Instrum_Type; --raised PROGRAM_ERROR : access before
elaboration

end Instrum;

--CODE :
end ------------------------------------------------------------------------
------------------

Re: Question on controlled types

[Matthew Heaney]

"Alex Xela" <xela2@free.fr> writes:

> On the following code, what should happen during J variable elaboration?
> 
>  - Nothing
> 
>  - A call to Adjust.
> 
> I tried to find the answer in RM95 but in vain.
> 
> My tests on several compilers (and my feeling) were suggesting  : nothing!

Aggregate assignment is handled specially.  For a controlled type, it
means the object must be built in place.

Clearly, no controlled operations can be called, because they haven't
been elaboratated yet.  Hence the special rule for aggregate assignment.

Re: Question on controlled types

[Alex Xela]

[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #1: Type: text/plain, Size: 1761 bytes --]

Thanks, it is what I was expecting (where did you find the answer, in the
RM95?).

The example below is trying to synthesize your answer:



--------------------------------------------------
with Ada.Finalization;
package Instrum is
    type Instrum_Type is new Ada.Finalization.Controlled with
    record
        A : Integer;
    end record;
    procedure Finalize  (O : in out Instrum_Type);
    procedure Adjust  (O : in out Instrum_Type);
    procedure Initialize  (O : in out Instrum_Type);
    J : Instrum.Instrum_Type := ( Ada.Finalization.Controlled with
A=>0);--nothing : OK
    --J : Instrum.Instrum_Type; --raised PROGRAM_ERROR : access before
elaboration : OK
end Instrum;
--------------------------------------------------
with Instrum, Ada.Finalization,Ada.Text_Io;
procedure Test_Instrum is
    I : Instrum.Instrum_Type := Instrum.J; --adjust : OK
    --I : Instrum.Instrum_Type := ( ada.finalization.controlled with
A=>0); --nothing : OK
    --I : Instrum.Instrum_Type; --initialize : OK
begin
    Ada.Text_Io.Put_line("end;");
end Test_Instrum;


"Matthew Heaney" <matthewjheaney@earthlink.net> a �crit dans le message de
news: u8yo4imig.fsf@earthlink.net...
> "Alex Xela" <xela2@free.fr> writes:
>
> > On the following code, what should happen during J variable elaboration?
> >
> >  - Nothing
> >
> >  - A call to Adjust.
> >
> > I tried to find the answer in RM95 but in vain.
> >
> > My tests on several compilers (and my feeling) were suggesting  :
nothing!
>
> Aggregate assignment is handled specially.  For a controlled type, it
> means the object must be built in place.
>
> Clearly, no controlled operations can be called, because they haven't
> been elaboratated yet.  Hence the special rule for aggregate assignment.
>
>
>
>