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=-1.3 required=5.0 tests=BAYES_00,INVALID_MSGID
	autolearn=no autolearn_force=no version=3.4.4
X-Google-Language: ENGLISH,ASCII-7-bit
X-Google-Thread: 103376,b4731a3b5d591abd
X-Google-Attributes: gid103376,public
From: Jeff Carter <carter@spam.innocon.com>
Subject: Re: Task Discriminants & Arrays
Date: 1997/05/13
Message-ID: <33787506.41C67EA6@spam.innocon.com>#1/1
X-Deja-AN: 241276019
References: <mheaney-ya023680001305970024550001@news.ni.net>
Organization: Innovative Concepts, Inc.
Newsgroups: comp.lang.ada
Date: 1997-05-13T00:00:00+00:00
List-Id: <comp.lang.ada>


Matthew Heaney wrote:
> 
> One of the nice things about Ada 95 is that I can pass a task an identifier
> by giving the task a discriminant:
> 
> task type T (Id : Positive) is
>    entry E;
> end T;
> 
> O : T (1);
> 
> And then the task knows its own identifier by refering to Id.
> 
> Now suppose I have a task array:
> 
> type Task_Array is array (Positive range <>) of T; -- ???
> 
> O : Task_Array;  -- ???
> 
> It would be really swell if I could give the task object component of the
> array an identifier that is its index position in the array.  Anyone got
> any ideas about how to do this?
> 
> Is there some other technique for allowing the elaborator to assign an id
> to a task object, without using an initialization entry?
> 
> --------------------------------------------------------------------
> Matthew Heaney
> Software Development Consultant
> <mailto:matthew_heaney@acm.org>
> (818) 985-1271

As I understand it, task discriminants were intended to eliminate the
"serial bottleneck" that results from having to call an initialization
entry to provide information like this to task instances. However, as
far as I can tell, it simply complicates matters: You have to declare an
access type designating the task type, make your array type an array of
these access types, then allocate the tasks at runtime:

task type T (Id : Positive) is
   entry E;
end T;

type T_Ptr is access all T;

type A is array (Some_Range) of T_Ptr;

O : A;
...
for I in O'range loop
   O (I) := new T (Id => I);
end loop;

This doesn't seem to be any more readable that the 83 equivalent:

task type T is
   entry Init (Id : in Positive);
   entry E;
end T;

type A is array (Some_Range) of T;

O : A;
...
for I in O'range loop
   O (I).Init (Id => I);
end loop;

The use of discriminants may be more efficient and have less of a serial
bottleneck. I'd be interested to know if this is the case, and if so,
how much of an improvement one gains with various compilers.
-- 
Jeff Carter  PGP:1024/440FBE21
Auntie-spam reply to; try ( carter @ innocon . com )
"Now go away, or I shall taunt you a second time."
Monty Python & the Holy Grail