process blocking

process blocking

[P Hull]

Hi, I know this is possible, but how does one go about having a process (p1)
siezing control of another process (pMain) such that no other process (p2,
p3, .. pn) is able to access pMain? I am guessing you define one channel and
maintain access to this channel? I have no idea how to implement such
blocking.

any help most appreciated

thanks
peter

Re: process blocking

[Stephen Leake]

"P Hull" <p.hull@msw.com> writes:

> Hi, I know this is possible, but how does one go about having a process (p1)
> siezing control of another process (pMain) such that no other process (p2,
> p3, .. pn) is able to access pMain? I am guessing you define one channel and
> maintain access to this channel? I have no idea how to implement such
> blocking.

If you can use an Ada task for your "process", and by "access" you
mean "rendezvous with", then this is a matter of visibility; make sure
task pMain is only visible to task p1. Declaring pMain in a private
child of the package that declares p1 is one way to do this.

However, that is a static solution. If you need to change which tasks
are able to rendezvous with pMain at run time, you'll need a different
mechanism.

If you explain more about why you think you need to do this, there is
probably another way to accomplish it. 

-- 
-- Stephe

Re: process blocking

[P Hull]

> > Hi, I know this is possible, but how does one go about having a process
(p1)
> > siezing control of another process (pMain) such that no other process
(p2,
> > p3, .. pn) is able to access pMain? I am guessing you define one channel
and
> > maintain access to this channel? I have no idea how to implement such
> > blocking.
>
> If you can use an Ada task for your "process", and by "access" you
> mean "rendezvous with", then this is a matter of visibility; make sure
> task pMain is only visible to task p1. Declaring pMain in a private
> child of the package that declares p1 is one way to do this.
>
> However, that is a static solution. If you need to change which tasks
> are able to rendezvous with pMain at run time, you'll need a different
> mechanism.
>
> If you explain more about why you think you need to do this, there is
> probably another way to accomplish it.

Hi thanks for the reply.

Oh i was not looking for a static solution. pMain is visible to all tasks
p1..pn. The first task (i.e. one of p1..pn based upon some timing mechanism)
will rendezvous with pMain and seizes pMain. And once pi has finished
whatever it wants to do with pMain, some other task within p1..pn will then
next rendezvous with pMain and seize it, and once finished .. etc etc

I know this should be simple to implement. Thanks for any help

Peter

Re: process blocking

[Georg Bauhaus]

P Hull <p.hull@msw.com> wrote:
 
: Oh i was not looking for a static solution. pMain is visible to all tasks
: p1..pn. The first task (i.e. one of p1..pn based upon some timing mechanism)
: will rendezvous with pMain and seizes pMain. And once pi has finished
: whatever it wants to do with pMain, some other task within p1..pn will then
: next rendezvous with pMain and seize it, and once finished .. etc etc

is pMail special so that you could hide it behind a protected object?


-- georg

Re: process blocking

[Ludovic Brenta]

"P Hull" writes:
> Oh i was not looking for a static solution. pMain is visible to all
> tasks p1..pn. The first task (i.e. one of p1..pn based upon some
> timing mechanism) will rendezvous with pMain and seizes pMain. And
> once pi has finished whatever it wants to do with pMain, some other
> task within p1..pn will then next rendezvous with pMain and seize
> it, and once finished .. etc etc
>
> I know this should be simple to implement. Thanks for any help

Why does pMain have to be a task?  Could it not be a protected object
instead?  Then, the task pi would call a procedure or entry in the
protected object.  While that procedure or entry is executing, other
tasks that also want to execute a procedure or entry in pMain must
wait.

Here is an example:

protected pMain is
   procedure Seize_And_Do_Whatever;
private
   Protected_Data : Integer;
end pMain;

protected body pMain is
   procedure Seize_And_Do_Whatever is
   begin
      Protected_Data := 42;
   end Seize_And_Do_Whatever;
end pMain;

Now, any task pi can call pMain.Seize_And_Do_Whatever.  The processing
takes place in the task pi; pi is not blocked.  If another task, pj,
wants to call pMain.Seize_And_Do_Whatever, it waits.

See the reference manual section 9.4 for more details.

[1] http://www.adaic.org/standards/ada95.html
[2] http://www.adaic.org/standards/95lrm/html/RM-9-4.html

-- 
Ludovic Brenta.

Re: process blocking

[Steve]

In kinda pseudo-code form:

  If you set up the main process pMain with a loop, something like:

  task pMain is
  begin
    loop
      accept Step1;
      ... some code ...
      accept Step2;
    end loop;
  end pMain;

  Then have the process p1 rendevous with the two in sequence:

    myTask.Step1;
   ... some code ...
    myTask.Step2;

  You should get the described behaviour.

Steve
(The Duck)

"P Hull" <p.hull@msw.com> wrote in message
news:41400af9$1@dnews.tpgi.com.au...
> Hi, I know this is possible, but how does one go about having a process
(p1)
> siezing control of another process (pMain) such that no other process (p2,
> p3, .. pn) is able to access pMain? I am guessing you define one channel
and
> maintain access to this channel? I have no idea how to implement such
> blocking.
>
> any help most appreciated
>
> thanks
> peter
>
>