RE: Protected Type Question.

RE: Protected Type Question.

[Beard, Frank]

The task (3) combination was more common, but I also had other
task combinations hang.  I don't think the program is crashing.
Each of the tasks have "when others" exception handlers that log,
and nothing is showing up.

Pragma Atomic and Volatile were a shot in the dark.  I didn't 
really think it would make a difference.

We're running on NT 4.0 with Service Pack 5.

If you think of anything else, let me know.
Thanks.

Frank

-----Original Message-----
From: tmoran@acm.org [mailto:tmoran@acm.org]
Sent: Monday, December 11, 2000 10:40 PM
To: comp.lang.ada@ada.eu.org
Subject: Re: Protected Type Question.


That semaphore code should work, and certainly shouldn't hang.  Is there
any possible significance to the fact both your examples show task (3)
as the one that does a RELEASE but never gets to RELEASED?  Are you
sure the program is hanging, and not crashing and somehow hanging
during the attempted crash?
  Pragmas Atomic and Volatile should certainly not be necessary.  The
whole point is that only one task at a time can execute the entries
or procedures in, and thus access or change the value of data
(Busy, in this case) of, a protected object.
_______________________________________________
comp.lang.ada mailing list
comp.lang.ada@ada.eu.org
http://ada.eu.org/mailman/listinfo/comp.lang.ada

protected type question

[shoko]

i have the following package:

generic
   type Message is private; 
package Broadcasts is
   protected      type Broadcast is 
      procedure Send(This_Message : in Message); 
      procedure Send_all(This_Message : in Message); 
      entry wait(A_Message :    out Message ); 
   private
      Message_Arrived:Boolean:=False;
      The_Message:Message;
   end  Broadcast ;
end   Broadcasts ;
---------------------------------------------------------------- 

package body Broadcasts  is
   protected body Broadcast is
      entry wait(A_Message : out Message ) when Message_Arrived is 
      begin
         if wait'Count=0 then
            Message_Arrived:=False;
         end if;
            A_Message:=The_Message;
      end  wait;

      procedure Send (This_Message : in     Message ) is 
      begin
         if wait'Count>0 then
            Message_Arrived:=True;
            The_Message:=This_Message;
         end if;
      end Send;
      
      procedure send_all(This_Message : in     Message )is
      begin
          Message_Arrived:=True;
          The_Message:=This_Message;
      end send_all;
   end Broadcast ;
end   Broadcasts;
 ---------------------------------------------------------------- 

in the main procedure i am trying to create a task
1.I get compiltaion error:"wait" not decllared in "str_broadcasts"
what am i doing wrong?

2.In the broadcasts package i use send all procedure that will free
all waiting tasks is this is the right way?


 
with broadcasts;
with Ada.Strings.Unbounded;
use  Ada.Strings.Unbounded;

procedure main_broadcast is
   
  subtype message is  Unbounded_String; 
  package str_broadcasts is new broadcasts(message);
  a:message :=To_Unbounded_String("hello");
  
   TASK messages;
   
   task body messages is
      m:message;
   begin
      loop
          str_broadcasts.wait(a);<-- compilation error
      end loop;   
   end messages;
begin
   
   null;
end main_broadcast;

Re: protected type question

[James Rogers]

shoko2004@hotmail.com (shoko) wrote in 
news:4948f537.0401031258.62a7cdc7@posting.google.com:

> i have the following package:
> 
> generic
>    type Message is private; 
> package Broadcasts is
>    protected      type Broadcast is 
>       procedure Send(This_Message : in Message); 
>       procedure Send_all(This_Message : in Message); 
>       entry wait(A_Message :    out Message ); 
>    private
>       Message_Arrived:Boolean:=False;
>       The_Message:Message;
>    end  Broadcast ;
> end   Broadcasts ;
> ---------------------------------------------------------------- 
> 
> package body Broadcasts  is
>    protected body Broadcast is
>       entry wait(A_Message : out Message ) when Message_Arrived is 
>       begin
>          if wait'Count=0 then
>             Message_Arrived:=False;
>          end if;
>             A_Message:=The_Message;
>       end  wait;
> 
>       procedure Send (This_Message : in     Message ) is 
>       begin
>          if wait'Count>0 then
>             Message_Arrived:=True;
>             The_Message:=This_Message;
>          end if;
>       end Send;
>       
>       procedure send_all(This_Message : in     Message )is
>       begin
>           Message_Arrived:=True;
>           The_Message:=This_Message;
>       end send_all;
>    end Broadcast ;
> end   Broadcasts;
>  ---------------------------------------------------------------- 
> 
> in the main procedure i am trying to create a task
> 1.I get compiltaion error:"wait" not decllared in "str_broadcasts"
> what am i doing wrong?
> 
> 2.In the broadcasts package i use send all procedure that will free
> all waiting tasks is this is the right way?
> 
> 
>  
> with broadcasts;
> with Ada.Strings.Unbounded;
> use  Ada.Strings.Unbounded;
> 
> procedure main_broadcast is
>    
>   subtype message is  Unbounded_String; 
>   package str_broadcasts is new broadcasts(message);
>   a:message :=To_Unbounded_String("hello");
    buffer : str_broadcasts.broadcast;
>   
>    TASK messages;
>    
>    task body messages is
>       m:message;
>    begin
>       loop
>           str_broadcasts.wait(a);<-- compilation error
            buffer.wait(a);
>       end loop;   
>    end messages;
> begin
>    
>    null;
> end main_broadcast;
> 

str_broadcasts is the name of the instantiated package.
str_broadcasts.broadcast is the name of the protected
type. You need to make an instance of that protected
type. My addition creates an instance named "buffer".

Jim Rogers

Re: protected type question

[Robert I. Eachus]

shoko wrote:

> i have the following package:
...
> in the main procedure i am trying to create a task
> 1.I get compilation error:"wait" not decllared in "str_broadcasts"
> what am i doing wrong?
> 
> 2.In the broadcasts package i use send all procedure that will free
> all waiting tasks is this is the right way?

This should say:

>    task body messages is
>       m:message;
>    begin
>       loop
>           str_broadcasts.broadcast.wait(a);
>       end loop;   
>    end messages;
...
-- 
                                           Robert I. Eachus

"The war on terror is a different kind of war, waged capture by capture, 
cell by cell, and victory by victory. Our security is assured by our 
perseverance and by our sure belief in the success of liberty." -- 
George W. Bush

RE: Protected Type Question.

[Beard, Frank]

I took Robert's advice and changed the Delete
and New_String methods back to protected
operations, and the program no longer hangs.

Frank

-----Original Message-----
From: Robert Dewar [mailto:robert_dewar@my-deja.com]

>  18   Certain language-defined subprograms are potentially
>  blocking.  ... When not specified as potentially blocking,
>  a language-defined subprogram is nonblocking.
>
>Unchecked_Deallocation is not specified as potentially blocking.
>

RE: Protected Type Question.

[Beard, Frank]

> One of the other dangers of semaphores
> is that you can forget to claim or release, causing
> chaos, or indeed forget both, resulting in race
> conditions. By synchronizing at a higher
> structural level, these dangers are avoided.

I'm well aware of the danger, and I totally
agree that when at all possible the synchronization
should be done at a higher level.  That's exactly
the way it is done in other parts of our code.
The only reason I'm trying the "semaphore" approach
here is I was told on the ObjectAda list-server that
Unchecked_Deallocation is potentially blocking,
so it shouldn't be called from within a protected
type.  Delete and New_String used to be protected
operations.  The Delete code contains calls to a
garbage collector (with a limit).  When the limit
is reached, Unchecked_Deallocation is called.
If it is true, that it is potentially blocking,
then I have to go with the "semaphore" 
approach, or use another task (which I was
trying to avoid).

Is Unchecked_Deallocation, or "new" for that
matter, potentially blocking?

> I just made the
> technical comment that semaphores are NOT the
> preferred form of task synchronization these
> days, and to use protected types to implement
> semaphores is definitely an example of
> abstraction inversion. These are hardly
> contentious points of view :-)

I'm not trying to use semaphores for task
synchronization in the classic sense, only to
protect the garbage collector.  The tasks pass
messages through the system using protected queues.
The Get and Put methods are protected operations.
The Input task receives a message, parses it, determines
where it goes, and places it on the respective 
protected queue.  Each of the different processing
tasks handle a different type of message.  If
any of the processing tasks determine that a
message contains errors, they place the erred message
on the protected Error_Queue for the Error_Task.
The Error_Task interacts with a special table in the
database where messages are corrected by an operator
through a GUI and sent back into the system.
Once an erred message is corrected it is processed
or placed on the Output_Buffer where the Output_Task
sends it back out through the network.

It just so happens that every task in the system,
either directly or through calls to other classes,
uses the Byte_String_Class to build or process
the message objects that also happens to contain
byte strings as components.  Byte_String_Class is
just a class that contains a Byte_String_Object
which is just a fancy pointer to a Byte_Array
that is used for all kinds of stuff.  The same
way you would use Ada.Strings.Unbounded
Unbounded_String.  It just happens to also be
a component of the message object.

And before anyone asks why we are not using
Unbounded_String, it is because we are trying to
figure out why Unbounded_String started failing.
Unbounded_Strings are released by setting them
to Null_String.  There was no protected type 
involved (unless Unbounded_String is also a
protected type).  The tasks were using the
Unbounded_Strings, then setting them to Null_String.
Somewhere along the line, after running for a
long time, the Unbounded_Strings suddenly have
residual data in them, as if the memory was 
picked up before the runtime cleared it.
So, I was looking for a way to switch to our
dynamic string class, which I know needs 
protection.

I hope this makes things clearer.
Any help is greatly appreciated.

Frank

RE: Protected Type Question.

[Robert Dewar]

In article
<B6A1A9B09E52D31183ED00A0C9E0888C469935@nctswashxchg.nctswash.na
vy.mil>,
  comp.lang.ada@ada.eu.org wrote:

> I'm well aware of the danger, and I totally
> agree that when at all possible the synchronization
> should be done at a higher level.  That's exactly
> the way it is done in other parts of our code.
> The only reason I'm trying the "semaphore" approach
> here is I was told on the ObjectAda list-server that
> Unchecked_Deallocation is potentially blocking,
> so it shouldn't be called from within a protected
> type.

This is a serious bug in ObjectAda if the allegation
is correct. An implementation is NOT permitted to
make arbitrary things PB, as per the statement in the
RM:

  18   Certain language-defined subprograms are potentially
  blocking.  ... When not specified as potentially blocking,
  a language-defined subprogram is nonblocking.

Unchecked_Deallocation is not specified as potentially blocking.

> If it is true, that it is potentially blocking,
> then I have to go with the "semaphore"
> approach, or use another task (which I was
> trying to avoid).

Well you are trying to work around a compiler bug here, so
that is definitely always awkward.

> Is Unchecked_Deallocation, or "new" for that
> matter, potentially blocking?

No.

> And before anyone asks why we are not using
> Unbounded_String, it is because we are trying to
> figure out why Unbounded_String started failing.
> Unbounded_Strings are released by setting them
> to Null_String.  There was no protected type
> involved (unless Unbounded_String is also a
> protected type).  The tasks were using the
> Unbounded_Strings, then setting them to Null_String.
> Somewhere along the line, after running for a
> long time, the Unbounded_Strings suddenly have
> residual data in them, as if the memory was
> picked up before the runtime cleared it.

Sounds like another bug unless I misunderstand your
description. And by the way, the original report is
of a bug in the run-time, since there is no reason
why the use of simple minded semaphores of this kind
should not work (we are discussing disadvantages of
this approach, but it is not the case that one of
the disadvantages is complete malfunction :-)

Sounds like you need to contact the vendor for
support here, things are not working the way they
should from your descriptions.

Robert Dewar


Sent via Deja.com http://www.deja.com/
Before you buy.

Re: Protected Type Question.

[tmoran]

That semaphore code should work, and certainly shouldn't hang.  Is there
any possible significance to the fact both your examples show task (3)
as the one that does a RELEASE but never gets to RELEASED?  Are you
sure the program is hanging, and not crashing and somehow hanging
during the attempted crash?
  Pragmas Atomic and Volatile should certainly not be necessary.  The
whole point is that only one task at a time can execute the entries
or procedures in, and thus access or change the value of data
(Busy, in this case) of, a protected object.

RE: Protected Type Question.

[Beard, Frank]

Robert,

Am I supposed to say thanks for this?

Since the only positive statement was
"Certainly this should work fine", I
guess I'm compelled to follow it up
with some questions since you didn't
offer anything more useful.

Concerning your comment
"and is very poor programming style".
Since it is taken directly from the LRM,
are you saying the LRM is written in
poor programming style?  The fact that I
split it into a package spec and body
is poor programming style?  Elaborate
please.

Concerning, "though of course no one would
use it in the form given (it is obviously
subject to priority inversion".  Our system
is a message correction system that is not
required to be real-time, other than it can't
be too slow.  All our tasks are at the same
priority so there isn't any inversion.  But
for argument's sake, lets say I need this type
of "semaphore" for protecting critical regions
within a system that contains prioritized tasks.
What would be your suggestion for "correcting"
the form so that is not subject to priority
inversion and bad programming style? 

I usually go out of my way to give someone
something useful.  I haven't done it much 
here yet because I'm new to the list.  But,
it rubs me the wrong way to get an answer
that is not only terse, but somewhat
condescending as well.  If you're going to
make such statements, offer a solution.
Something positive.  A way to correct it.
"Here's a better way".  Something.

I don't want insults, I want assistance.  If
I can offer something to someone less 
experienced or less knowledgeable, I try to do
so, and hopefully with a little more mercy.

Anyone can say something is lousy, but few
can offer a better way.  Which one are you?
Which one do you want to be?

If bashing is what I want, I'll become a C++
programmer and slam Ada for no good reason.

Frank

PS.
If that's not the way you meant your response,
I take it all back. ;-)

-----Original Message-----
From: Robert Dewar [mailto:robert_dewar@my-deja.com]
Sent: Monday, December 11, 2000 10:57 AM
To: comp.lang.ada@ada.eu.org
Subject: Re: Protected Type Question.

Certainly this should work fine, though of course no one would
use it in the form given (it is obviously subject to priority
inversion, and is very poor programming style).


Sent via Deja.com http://www.deja.com/
Before you buy.
_______________________________________________
comp.lang.ada mailing list
comp.lang.ada@ada.eu.org
http://ada.eu.org/mailman/listinfo/comp.lang.ada

RE: Protected Type Question.

[Robert Dewar]

In article
<B6A1A9B09E52D31183ED00A0C9E0888C469931@nctswashxchg.nctswash.na
vy.mil>,
  comp.lang.ada@ada.eu.org wrote:
> Concerning your comment
> "and is very poor programming style".
> Since it is taken directly from the LRM,
> are you saying the LRM is written in
> poor programming style?  The fact that I
> split it into a package spec and body
> is poor programming style?  Elaborate
> please.

The example in the RM is intended to illustrate
the semantics of protected types. Since everyone
is assumed to be familiar with simple semaphores
(even though they are a deprecated form of
synchronization), this example is good for the
purpose of illustration, but that does not mean
that you should assume this code is useful in
a given situation. The examples in the RM are
all for the purposes of helping people understand
the syntax and semantics of Ada, they are not
intended as suggestions for what you should
actually write in programs.

> Concerning, "though of course no one would
> use it in the form given (it is obviously
> subject to priority inversion".  Our system
> is a message correction system that is not
> required to be real-time, other than it can't
> be too slow.  All our tasks are at the same
> priority so there isn't any inversion.  But
> for argument's sake, lets say I need this type
> of "semaphore" for protecting critical regions
> within a system that contains prioritized tasks.
> What would be your suggestion for "correcting"
> the form so that is not subject to priority
> inversion and bad programming style?

Well there are many many ways to organize task
synchronization. Most likely if you have no
real time requirements, you can use classical
rendezvous style and end up with something
that is FAR safer and easier to read and
maintain. One of the other dangers of semaphores
is that you can forget to claim or release, causing
chaos, or indeed forget both, resulting in race
conditions. By synchronizing at a higher
structural level, these dangers are avoided.

Any good Ada book will discuss the general
topic of synchronization and design. Burns and
Welling is a useful source of more detailed

> design suggestions, but there are many sources.
> I don't want insults, I want assistance.  If
> I can offer something to someone less
> experienced or less knowledgeable, I try to do
> so, and hopefully with a little more mercy.

No one is insulting anyone, I just made the
technical comment that semaphores are NOT the
preferred form of task synchronization these
days, and to use protected types to implement
semaphores is definitely an example of
abstraction inversion. These are hardly
contentious points of view :-)

> Anyone can say something is lousy, but few
> can offer a better way.  Which one are you?
> Which one do you want to be?

There is no way to answer to how you should
do things, given that you gave no hint at all
of what your problem structure is. You would
have done better using some of your energy in
writing your long answer to describe what your
problem is!

We can't offer help if we don't know what you
are trying to do.




Sent via Deja.com http://www.deja.com/
Before you buy.

Protected Type Question

[Bill Pritchett]

I have a question regarding protected types.  Specifically, I've been trying to figure out
how to pin a protected object to a specific memory location.  The two ways I have tried are as 
follows:

  procedure Test is

    protected type Sensor (Sensor_Address : System.Address) is
      function Get_Value return Integer;
    private
      The_Sensor : Integer;
      for The_Sensor'Address use Sensor_Address;
    end Sensor;
    ...
    Sensor1 : Sensor(..);
  begin
    ...
  end Test;

GNAT bombs on this incorrectly stating 'missing "end Sensor"' which throws the rest of the 
compilation out of whack.  I'm pretty sure this is NOT legal anyway.

The second alternative is this

  procedure Test is

     protected type Sensor is
       function Get_Value return Integer;
     private
       The_Sensor : Integer;
     end Sensor;
     ...
     Sensor1 : Sensor;
     for Sensor1'Address use ...;

  begin
   ...
  end Test;

This compiles.  When I execute this it bombs (partly because I have no clue of what's at the 
address I give it).  My question is what does the address (Sensor1'Address) represent?  Is it the 
address to the object as a whole or to The_Sensor (what I want)?  If it is to the object as a 
whole, then how does one specify a particular address for a protected object?  Is it possible 
directly?

Thanks,
Bill Pritchett
CACI, Inc.

Re: Protected Type Question

[Robert Dewar]

Bill said

"  procedure Test is

    protected type Sensor (Sensor_Address : System.Address) is
      function Get_Value return Integer;
    private
      The_Sensor : Integer;
      for The_Sensor'Address use Sensor_Address;
    end Sensor;
    ...
    Sensor1 : Sensor(..);
  begin
    ...
  end Test;

GNAT bombs on this incorrectly stating 'missing "end Sensor"' which throws the r
est of the
compilation out of whack.  I'm pretty sure this is NOT legal anyway."

The latest version of GNAT says

     8.       for The_Sensor'Address use Sensor_Address;
              |
        >>> representation clause not allows in protected definition

which is a little politer! But the point GNAT makes is right, and as Bill
suspected, his first attempt is illegal.

THe second attempt is legal, but it places the entire object at the
given address, including locks etc.

A much better approach is to define the variable OUTSIDE the protected
object, and just use the procted object aas a lock.