Re: Read-write mutex sometimes fails on deadlock

[Robert Eachus <rieachus@comcast.net>]

On Saturday, October 28, 2017 at 4:02:33 PM UTC-4, pascal....@gmail.com wrote:
> Hi,
> 
> [long post because it includes the full sources and output, sorry]
> 
> I have a package that implements several kinds of mutexes, including a
> read-write mutex. Here is the full source (spec and body) with only the
> read-write part.

You got started down the wrong road and never turned around.  The right abstraction for this in Ada is a protected object.  A typical mutex looks like:

protected type Mutex is
   entry Write(D: in Data):
   function Read return Data;
private
   The_Data: Data := No_Data;
end Mutex;

protected body Mutex is
   entry Write (D: in Data) is
   begin
      The_Data := D;
      Some_Data := True;
      Print(D);
      delay 0.1;
   end Write;

   function Read return Data is
      return The_Data;
   end Read;
end Mutex;

The choice of type Data, the value No_Data and the procedure Print is left to the reader.  If you want to insure that calls to Print(D) are sequentialized, you can wrap it in its own protected object:

protected Writer is
  procedure Write (D: in Data);
end Writer;

protected body Writer is 
  procedure Write(D: in Data) is
  begin
    -- do some output
  end Write;
end Writer;

Now you can use Write to do some formatting of your output and be sure even if it is called by your tasks outside the Mutex, for example your tasks could print the data read.

There are thousands of useful patterns in Ada using protected objects or protected values.  For example, you could allow exactly one reader after a Write, but allow two successive Writes.  Or you could stack up reads before the first write, etc.