CSC 145 : Ada Multitasking Assignment: Addendum.


Microsoft's Win32 API contains a thread synchronization mechanism
called an "Event" (read carefully attached photocopies).  An Event is
an object that can be in a "signaled" or "non-signaled" state.  The
operations on an event are to set it to a signaled state (SetEvent),
non-signaled state (ResetEvent), toggle the state in lock-step
(PulseEvent) and lock(), which blocks a thread on an event that's in
the non-signaled state.  This device is similar to the mutex/semaphore
tasks we implemented in Ada.  That is, it can be implemented as a task
whose purpose is to synchronize other tasks.  However, unlike a mutex
or semaphore, these "Event objects" are not used in a symmetrical
manner by threads.  In particular, there are no symmetric calls to
lock and unlock by the threads. 

You are to simulate the Event synchronization mechanism in Ada.  That
is, implement an Ada task or protected type that can be used in the same
way as an event.  The implementation will be roughly similar to the one
for mutexes, but with important differences.  You can use a task or a
protected type.

Please be sure to read the descriptions carefully.  Read section 18.9
of the handout that I gave you.  In particular, you'll need to use the
"requeue" command.  

Note in particular, if the auto-reset feature is on (default) then
e.SetEvent()  will release EXACTLY one waiting thread, not all of them.
Whereas, if the event is to be manually reset, then

  e.SetEvent();
  e.ResetEvent();

will cause ALL waiting threads to be released before the event can be
resetset.  

Hint: you'll need a private entry (see example in section 18.9, but 
don't confuse their "event" with what you're supposed to implement).
That is, the "lock" entry should requeue itself on the private entry
after incrementing a counter that keeps track of how many tasks are
waiting on the event.