[comp.lang.ada] Immediate Reading in Tasks

g_harrison@vger.nsu.edu (George C. Harrison, Norfolk State University) (03/16/91)

Ada teachers and Real-Time types - 

  I'd like some helpful hints about how to handle an "immediate get" type of
procedure in a tasking environment.  By "immediate get" (IGET) I mean the
ability to read a character directly from the keyboard without pressing the
return key.  Some, if not most, implementations of Ada have the ability to do
such a reading albeit indirectly.

Here's the "problem."  

Doing an IGET inside a task generally causes the other tasks to wait until the
user presses a key.  In my real time simulations for my students when they must
act as monitors or interrups it would be nice to have the program run with all
its tasks until a key is pressed (and then read, if necessary).

Do-While Jones in "Ada in Action" proposes a solution similar to the following:

Define a function KEYPRESSED (boolean) and an IGET procedure that only works
when KEYPRESSED is TRUE.  These subroutines call a task which essentially holds
the incoming character as the value of a local [task] variable, setting
KEYPRESSED to true until the character is retrieved from the task.

So another task might do this:

loop
  do_stuff;
  if keypressed then
    iget(ch);
    do_something_with_ch;
  else
    do_something_else;
  end if;
end loop;


I welcome any and all ideas.  I have used the Do-While Jones method, but it
seems to have a lot of overhead.  

George

-- George C. Harrison                              -----------------------
----- Professor of Computer Science                -----------------------
----- Norfolk State University                     -----------------------
----- 2401 Corprew Avenue, Norfolk, Virginia 23504 -----------------------
----- INTERNET:  g_harrison@vger.nsu.edu ---------------------------------

loftus@wpllabs.UUCP (William Loftus) (03/19/91)

In article <739.27e1226c@vger.nsu.edu> g_harrison@vger.nsu.edu (George C. Harrison, Norfolk State University) writes:
>Ada teachers and Real-Time types - 
>
>Do-While Jones in "Ada in Action" proposes a solution similar to the following:
>
>Define a function KEYPRESSED (boolean) and an IGET procedure that only works
>when KEYPRESSED is TRUE.  These subroutines call a task which essentially holds
>the incoming character as the value of a local [task] variable, setting
>KEYPRESSED to true until the character is retrieved from the task.
>
>So another task might do this:
>
>loop
>  do_stuff;
>  if keypressed then
>    iget(ch);
>    do_something_with_ch;
>  else
>    do_something_else;
>  end if;
>end loop;
>
>I welcome any and all ideas.  I have used the Do-While Jones method, but it
>seems to have a lot of overhead.  

It does have a lot of overhead.  In many real-time systems the cost of
executing "keypressed" is too much.  If the call to keypressed is 100ms and
you need to process a user typing (i.e.  ~50 wpm) and other information you
are devoting 1/2 sec/sec to processing keystrokes (these numbers come from
a project that I am currently working on).  Fortunately, keystrokes are
often interrupts, and many Ada systems allow the mapping of interrupts to
task entries.  Using this approach the task (see below for a quick example)
waits (allowing other tasks to execute) for a rendezvous from the system
software and is not constantly polling for keystroke availability.

task Keystroke is
   entry Key (Code : Byte);
end Keystroke;

task body Keystroke is
   Stroke : Byte;
begin
   loop
     accept Key (Code : Byte) do
        Stroke := Code;
     end accept;
     Rest_Of_System.Process_Keystroke (Stroke);
   end loop;
end Keystroke;

--
William Loftus                   (215) 668 3661
WPL Laboratories, Inc.           UUCP: loftus@wpllabs.UUCP
P.O. Box 111                     ARPA: loftus!wpllabs@prc.unisys.com
216 Wynne Lane
Penn Valley, PA 19072            Ada and Unix Software Consultants