ACKNOWLEDGEMENT

We are grateful to Ian Pyle for his valuable comments on a draft of this book. APPENDIX A

Task Initialisation in Highly Parallel Systems

In many applications it is necessary for a task to know its identity so that, for example, resource allocation mechanisms can be implemented reliably. Unfortunately as an Ada task cannot be initialised at the time of creation, a rendezvous must be used to pass identification data to those tasks that require it. With multiprocessor systems this initialisation phase can be a source of inefficiency as it is, essentially, a sequential activity. In this appendix we present Bums' algorithm 42 for initialising tasks in highly parallel systems. Each task is presented in an initial rendezvous with a range (B..T) of identities of uninitialised tasks. The task initialises its own identity to the top element (T) of the range. Following the rendezvous, the task splits its given range in two and passes the top half to another uninitialised task. It then repeats the process on the bottom half; i.e. it splits it in two, passes the top half on, and so on. Eventually the bottom half will consist of a single identity (top = base) and, having passed this identity on, the task will have completed its initialisation role. It is easy to see that the time taken to initialise all the tasks depends logarithmically on the number of tasks. Thus over ten thousand tasks can be initialised within 14 rendezvous times. 108 A REVIEW OF ADA TASKLNG

procedure main is

max : constant := ~oo; --number of tasks to be created subtype task_range is integer range 0 .. max; task type TK is entry initialise(B,T : task_range); end TK; set : array(task_range) of TK; base, new_base : task_range; top : integer range task_range~first-! .o task_range'last;

task body TK is my_number : task_range; -- other declarations begin declare base,new_base : task_range; top : integer range task_range'first-i oo task_range'last; begin accept initialise(B,T : task_range) do my_number := T; base := B; end initialise; top := my_number - i; while top >= base loop new_base :: (top + base)/2; set(top).initialise(new_base,top); --top half of remaining group top := new_base - I; end loop; end;

end TK; APPENDIX A 109

begin top :: task_range'last; base := task_range'first; while top >= base loop new_base := (top + base)/2; set(top).initialise(new_base,top); --top half of remaining group top := new_base - i; end loop; end main; APPENDIX B

Asynchronous Agents

Normal inter-task communication is synchronous. This appendix contains generic packages to implement asynchronous send and receive operations. It also gives an examples of their use. First the asynchronous send:

generic type mess is private; with procedure destination(m : mess); package no_wait_send is task type agent is entry forward(m : mess); end agent; type agt is access agent; end no_wait_send;

package body no_wait_send is task body agent is temp : mess; begin accept forward(m : mess) do temp := m; end; destination(temp); end agent; end no_wait_send;

The generic package provides a task which stores a single message (for the client that created it) and passes on this message by calling the procedure destination which is 112 A REVIEW OF ADA TASKING provided as a generic parameter. A simple example of use is a main program calling (indirectly) the entry 'request' in the task 'server':

with no_wait_send; procedure main is type message is new integer; task server is entry request(m : message); end server; package messenger is new no_wait_send(mess => message, destination => server.request); use messenger; phidippides : agz := new agent; m : message; task body server is separate; begin -- obtain value for m phidippides.forward(m); -- continue execution end main;

The following package implements an asynchronous receive. APPENDIX B 113

generic type mess is private; package mailbox is task type agent is entry deposit(m : mess); entry collect(m : out mess); end agent; type agt is access agent; end mailbox;

package body mailbox is task body agent is temp : mess; begin accept deposit(m : mess) do temp := m; end; accept collect(m : out mess) do m := temp; end; end agent; end mailbox;

With this generic package a task type is provided that has two entry calls, one for the message to be deposited and the other to allow the client task to collect the message when it is ready to do so. Use in a server package is illustrated below.

serverl ' call "~-Ic°ntr°ll

Iag ent ]

A server task will call the procedure transaction in order to pass data to control and receive the results. The transaction procedure, however, calls up a mailbox agent to handle the return data. The control task therefore receives the input data and an "address" (access variable) to where the reply should be sent. 114 A REVIEW OF ADA TASKING

package server is type input_data is new integer; type output_data is new integer; procedure transaction(I :input_data; 0 : out output_data); end server; with mailbox; package body server is package mbox is new mailbox(mess => output_data ; use mbox; task control is entry call(I : input_data; A : agt); end control; procedure transaction(I:input_data;0:out output_data) is A : agt := new agent; begin control.call(I,A); -- give input data to the -- control task together with -- a mailbox agent for the -- return data

A.coi!ect(O) ; -- wait for data to be -- ready in mailbox end transaction; task body control is temp_I : input_data; temp_0 : output_data; temp_A : agt; begin accept call(I : input_dana; A : agt) do temp_I := I; temp_A := A; end; -- produce temp_0 from temp_I temp_A.deposit(temp_0); -- when appropriate end control; end server; APPENDIX C

Implementation of a Reliable Transaction

This appendix contains a generic package that allows a reliable two-rendezvous transaction to be programmed in Ada. The reliability comes from two features: (a) The server task returns data to the client (during the second rendezvous) via an agent. The failure or abortion of the client does not therefore affect the server. (b) A pool of reusable agents is used to overcome the storage exhaustion problem (see section 4.1.2). The generic package has the specification shown below. The generic parameters provide a type for the re'turn data and a constant giving the size of the pool. For simplicity, this example uses a fixed size pool of agents. A dynamic pool is also possible, in which case the constant parameter would give the maximum size of the pool. 116 A REVIEW OF ADA TASKING

generic type mess is private; size_of_pool : integer := 16; package agent_pool is type agent is private; procedure deposit(agt : agent; m : mess); procedure collect(agt : agent; m : out mess); procedure allocate(agt : out agent); procedure free(agt : in out agent);

NO_AVAILABLE_AGENT : exception; -- raised by allocate private task type agent_t is entry deposit(m : mess); entry collect(m : out mess); end agent_t; type agent_p is access agent_t; type agent is record in_use : boolean :: FALSE; ptr : agent_p := new agent_t; end record; end agent_pool;

The generic package provides four procedures: two for obtaining and releasing an agent, and two for communication with the agent. An agent can therefore be used a number of times by a client before being returned to the pool. The agent itself has the form of an asynchronous receiver (see Appendix B). Also defined within the package is an exception that is raised if there is no free agent available. The body for the generic package is as follows. (Note that all agents and the agent manager terminate when required to do so.) APPENDIX C 117

package body agent_pool is

task manager is entry allocate(agt : out agent); e~ry free(agt: in out agent); end manager;

procedure deposit(agt : agent; m : mess) is begin agt.ptr.deposit(m); end deposit;

procedure collect(agt : agent; m : out mess) is begin agt.ptr.collect(m); end collect;

procedure allocate(agt : out agent) is begin manager.allocate(agt); end allocate;

procedure free(agt : in out agent) is begin manager.free(agt); end free;

task body agent_t is temp : mess; begin loop select accept deposit(m : mess) do temp := m; end; or terminate; end select;

accept collect(m : out mess) do m := temp; end; end loop; end agent_t; ]8 A REVIEW OF ADA TASK~G

task body manager is subtype pool_size is integer range i.. size_of_pool; agent_pool : array (pool_size) of agent; found : boolean begin loop loop -- first all outstanding calls -- to free are processed select accept free(agt : in out agent) do agt.in_use := FALSE; end free; else exit; end select; end loop; begin select accept alloeate(agt : out agent) do found := FALSE; for i in pool_size loop if not agent_pool(i).in_use then agent_pool(i).in_use :: TRUE; agt := agent_pool(i); found := TRUE; exit; end if; end loop; if not found then raise NO_AVAILABLE_AGENT; end if; end allocate; or accept free(agt : in out agent) do agt.in_use := FALSE; end free; or terminate; end select; exception when NO_AVAILABLE_AGENT => null; end; end loop; end manager; end agent_pool; APPENDIX C 119

To illustrate the use of this generic package the simple server task employed in Appendix B is implemented (reliably!):

package server is type input_data is new integer; type output_data is new integer; procedure transaction(I:input_data;0:out output_data); end server; with agent_pool; package body server is

package reliable_agents is new agent_pool(mess => output_data); task control is entry call(I:input_data;A:reliable_agents.agent); end control;

procedure transaction(I:input_data;0:out output_data) is A :reliable_agents.agent; begin reliable_agents.allocate(A); control.call(I,A); reliable_agents.collect(A,O); reliable_agents.free(A); end transaction;

task body control is temp_l : input_data; temp_0 : output_data; temp_A : reliable_agents.agent; begin accept call(I:input_data;A:re!iable_agents.agent) do temp_I := I; temp_A := A; end; reliable_agents.deposit(temp_A, temp_0);--when appropriate end control; end server; APPENDIX D

Using Families For Handling Priority Requests

In Section 4.2.6.3 a prioritised select was implemented to give preference to one entry over another in a two accept select statement. For a large number of priority levels a family of enties :must be used. Bums 47 gives a reliable solution to the problem of using families to this end. All calls to request must be preceded by a call to announce in which the priority of the calling task is "registered". This protocol can be enforced by hiding the required synchronisations in a package. The server task keeps a record of all outstanding calls and deals with them in priority order. To keep track of all calls the server task must make use of a tuple. A tuple is an ordered set with the possibility of multiple entries for any element (this will deal with more then one task calling with the same priority). Once a call to announce has been made the server notes which is the highest priority held in the bin and waits for either a call to request, with that family entry, or another call to announce. If a call to announce is accepted it is added to the bin and the new "highest" priority obtained; alternatively if a request entry is handled its priority is removed from the bin. The algorithm outlined below is reliable as an agent task is used. Even if the client task is aborted the agent would still be present to complete the interaction with the server. TO protect against memory exhaustion a pool of reusable agents should be employed (see Appendix C). I22 A REVIEW OF ADA TASK~G

generic type element is (<>); package tuple is function highest return element; procedure add(E : element); procedure remove(E : element); function not_empty return boolean; end tuple;

The package body is not important here.

with nuple; package resource is type some_priority is new integer range 0..999; procedure request(P : some_priority); end resource;

package body resource is task server is entry announce(P :some~mriority); entry require(some_priority); end server;

task type agent is entry call_in(P : some_priority); entry call_out; end agent;

type agt is access agent;

procedure request(P : some_priority) is A : agt := new agent; begin A~call_in(P); A.call_out; end request;

package Bin is new tuple(element => some_priority); APPENDIX D 123

task body server is Po : some_priority; begin loop select accept announce(P : some_priority) do Bin.add(P); end; or terminate; end select; while Bin.not_empty loop Po := Bin.highest; select accept announce(P : some_priority) do Bin.add(P); end; or when announce'count = 0 => accept require(Po); Bin.remove(Po); end select; end loop; end loop; end server;

task body agent is pri : some_priority; begin accept call_in(P : some_priority) do pri := P; end call_in; server .announce (pri) ; server, require (pri) ; select accept call_out; or terminate; end select; end agent;

end resource; REFERENCES

1. S. Abramsky and R. Bomat, "Pascal-m: A Language for Distributed Computing", in Distributed Computer Systems, ed. Y. Parker, Academic Press (1983). 2. M. Mac .an Airchinnigh, A. Bums, and C. Chedgey, "Reusable Units - Construction Methods and Measure", in Proceedings Ada-Europe Conference, Stockholm, Cambridge University Press (May 1987). 3. J.P. Andre and J.C. Petit, "Galaxie: a Reconfigurable Network of Processors with Distributed Control", 2nd International Conference on Distributed Computing Systems, Paris (April 1981). 4. G.R. Andrews, "Synchronising Resources", ACM Transactions on Programming Languages and Systems 3(4), pp. 405-431 (October 1981). 5. G.R. Andrews, "The Distributed Programming Language SR - Mechanisms, Design and Implementation", Software Practice and Experience 12(8), pp. 719- 754 (August 1982). 6. G.R. Andrews and F. Schneider, "Concepts and Notations for Concurrent Programmitng' ', ACM Computing Surveys 15(1), pp. 3-44 (March 1983). 7. K.R. Apt, N. Francez, and W. P. de Roever, "A Proof System for Communicating Sequential Processes", Transactions on Programming Languages and Systems 2(3), pp. 359-385, ACM (July 1980). 8. A. Ardo, "Considerations For Full Ada Implementation on an Experimental Multiprocessor Computer", DDt, Department of Computer Engineering, University of Lund (December 1983). 9. J.W. Armil~age and J.V. Chelini, "Ada Software for Distributed Targets: A Survey of Approaches", Ada Letters 4(4) (January 1985). 10. E. Astesiano, A. Giovini, F. Mazzanti, and G. Reggio, "Modelling Erroneous Executions and Incorrect Order Dependences", in The Trial Definition of Ada, Deliverable of the CEC MAP project: The Draft Formal Definition of ANSI/MIL- STD 1815A Ada (1985). 11. E. Astesiano and G. Reggio, "The SMoLCS Approach to the Specification of 126 A REVIEW OF ADA TASKING

Concurrent Systems 'm, pp. 237-254 in Cnet Distributed Systems on Local Networks, Progetto Finalizzato Informatica (1985). 12. E. Astesiano, N. C. Bendix, N. Botta, A. Fantechi, A. Giovini, P. Inverardi, E. Karlsen, F. Mazzanti, G. Reggio, and E. Zucca, The Trial Definition of Ada, Deliverable of the CEC MAP project: The Draft Formal Definition of ANSI/MIL- STD 1815A Ada, 1986. 13. E. Astesiano and G. Reggio, "The SMoLCS Methodology - An Introduction to the Methodology for the Dynamic Semantics", in The Trial Definition of Ada, Deliverable of the CEC MAP project: The Draft Formal Definition of ANSI/MtL- STD 1815A Ada (1986). 14. E. Astesiano, A. Giovini, F. Mazzanti, G. Reggio, and E. Zucca, "The Ada Challenge for New Formal Semantic Techniques", pp. 239-248 in Ada Managing the Transition, The Ada Companion Series, Cambridge University Press (1986). 15. C. Atkinson and S.J. Goldsack, "Ada for Distributed Systems - A Compiler Independent Approach", Proceedings of the 1FAC Workshop on Distributed Computer Control Systems (September 1986). t6. C. Atkinson and S.J. Goldsack, "Ada for Distributed Systems: A Library of Virtual Nodes", in Proceedings Ada-Europe Conference, Stockholm, Cambridge University Press (May 1987). 17. T.P. Baker and G.A. Riccardi, "Ada Tasking: From Semantics to Efficient Implementation", IEEE Software 2(2), pp. 34-46 (March 1985). 18. T.P. Baker and Gregory A. Riccardi, "Implementing Ada Exceptions", IEEE Software 3(5), pp. 43-51 (September 1986). 19. L G. P. Barnes, Programming in Ada (2nd Edition), Addison-Wesley (1984). 20. H. Barringer, "Formal Specification Techniques for Parallel and Distributed Systems: A Short Review", pp. 281-294 in Proceedings of the 3rd Joint Ada Europe/AdaTEC Conference, Ada Companion Series, Cambridge University Press (1984). 21. H. Barringer, "Specifying Ada Tasks", AdaUKNews 6(2), pp. 24-31 (April 1985). 22. H. Barringer, "A Survey of Verification Techniques for Parallel Programs", in Lecture Notes in Computer Science VoL 191, Springer-Verlag (1985). 23. H. Barringer, R. Kuiper, and A. Pnueli, "A Compositional Temporal Approach to a CSP-like Language", in Proceedings of the IFIP Conference on Formal Models in Programming, ed. E.J. Neuhold, North Holland (1985). 24. H. Barringer and I. Meatus, "A Proof System for Ada Tasks", BCS Computer Journal 29(5), pp. 404-415 (October 1986). REFERENCES 127

25. R. Bayan, C. Bonnet, A. Kung, W. Kirchgassner, R. Landwehr, and B. Schwarz, "Transition Towards Embedded Real-Time Applications in Ada", in Proceedings Ada-Europe Conference, Edinburgh, Cambridge University Press (6-8 May 1986). 26. R. Bayan, C. Bonnet, A. Kung, W. Kirchgassner, R. Landwehr, and B. Schwarz, "Requirements for a Real-time Ada Runtime Kernel and Proposed Kernel Interface", Arbeitspapiere der GMD 204, Gesellschaft Fur Mathematik Und Datenverarbeitung MBH (1986). 27. N.C. Bendix, N. Botta, A. Fantechi, and F. Mazzanti, "Modelling Implementation Aspects", in The Trial Definition of Ada, Deliverable of the CEC MAP project: The Draft Formal Definition of ANSI/MIL-STD 1815A Ada (1985). 28. A.D. Birrell and B. J. Nelson, "Implementing Remote Procedure Calls", ACM Transactions on Computer Systems 2(1), pp. 39-59 (1984). 29. J.M. Bishop, S.R. Adams, and D.J. Pritchard, A Practical Method for Distributing Concurrent Ada Programs, Department of Electronics and Computer Science, University of Southampton (October 1986). 30. D. Bjorner and O.N. Oest, Towards a Formal Description of Ada, Lecture Notes in Computer Science, Vol. 98, Springer-Verlag (1980). 31. T. Bloom, "Evaluating Synchronisation Mechanisms", Proceedings of the Seventh ACM Symposium on Operating System Principles, Pacific Grove, pp. 24-32 (December 1979). 32. P. de Bondeli, "Models for the Control of Concurrency in Ada based on Predicate Transition nets", presented at meeting of Ada-Europe working group on formal methods for specification and development, Brussels (1983). 33. G. Booch, Software Engineering with Ada (2nd Edition), The Benjamin/Cummings Publishing Company, Inc. (1986). 34. P. Brinch-Hansen, "The Nucleus of a Multiprogramming System", CACM 13(4), pp. 238-250 (April 1970). 35. P. Brinch-Hansen, Operating System Principles, Prentice-Hall, New Jersey (July 1973). 36. P. Brinch-Hansen, "The Programming Language Concurrent Pascal", IEEE Transactions on Software Engineering SE-I(2), pp. 199-206 (June 1975). 37. P. Brinch-Hansen, "Distributed Processes: A Concurrent Programming Concept", CACM 21(11), pp. 934-941 (November 1978). 38. G.N. Buckley and A. Silberschatz, "An Effective Implementation for the Generalized Input-Output Construct of CSP", Transactions on Programming Languages and Systems 5(2), pp. 223-235, ACM (April 1983). 128 A REV~W OF ADA TASKING

39. R.J.A. Buhr, System Design with Ada, Prentice-Hall International (1984). 40. T.M. Burger and.W. Nielsen, "An Assessment of the Overheads Associated with Tasking Facilities and Tasks Paradigms", Ada Letters 7(1), pp. 49-58 (January/February 1987). 41. Ao Bums, "Early Experiences in Providing Ada Training", Infomation Technology Training 2(I), pp. 29-31 (1984). 42. A. Bums, "Efficient Initialisation Routines for Multi-processor Systems programmed in Ada", Ada Letters 5(1), pp. 55-60 (July/August 1985). 43. A. Bums, Concurrent Programming in Ada, Ada Companion Series, Cambridge University Press (1985). 44. A. Bums and J. Robinson, "ADDS - A Dialogue Development System for the Ada Programming Language", International Journal of Man-Machine Studies 24, pp. 153-170 (1986). 45. A. Bums and J. A. Kirkham, "The Construction of Information System Prototypes in Ada", SOFTWARE - Practice and Experience 16(4), pp. 341-350 (April 1986). 46. A. Bums, A.M. Lister, and A.J. Wellings, "Ada Tasking Implementation Issues", Ada User 8(2) (1987). 47. A. Bums, "Using Large Families for Handling Priority Requests", Ada Letters 7(1), pp. 97-104 (January/February 1987). 48. A. Bums, Programming in occam, Addison Wesley (in press). 49. J.R. Cameron, "Mapping JSD Network Specifications into Ada", Proceedings of 6th Ada UK International Conference, Ada User 8 (Supplement), pp. 91-99 (1987). 50. R.H. Campbell and A.N. Habermann, "The Specification of Process Synchronisation by Path Expressions", Lecture Notes in Computer Science 16, pp. 89-102, Spinger-Verlag (1974). 51. D. Cheriton, M. A. Malcolm, L. S. Melen, and G. R. Sager, "Thoth, a Portable Real-time Operating System", CACM 22(2), pp. 105-115 (1979). 52. D. Cheriton and W. Zwaenepoel, "The Distributed V Kernel and its Performance for Diskless Workstations", Proceedings of the Ninth ACM Symposium on Operating System Principles, Bretton Wood, New Hampshire, pp. 128-139 (October 1983).- 53. D.R. Cheriton, "The V. Kernel: A Software Base for Distributed Systems", IEEE Software 1(2), pp. 19-43 (April 1984). 54. G.W. Cherry, Parallel Programming in ANSI Standard Ada, Reston (1984). 55. G.W. Cherry, Pamela Designers Handbook, Thought Tools Incorporated (1986). 56. Y. Chu and M. Abrams, "Columbia Ada: A Concurrent Ada Computer System REFERENCES 129

Organization", TR-1203, Department of Computer Science, University of Maryland (August 1982). 57. Y. Chu ~aad M. Abrams, "Instruction Set Processor of the Columbia-Ada Concurrent Architecture' ', TR-1253, Department of Computer Science, University of Maryland (March 1983). 58. R.M. Clapp, L. Duchesneau, R.A. Volz, T.N. Mudge, and T. Schultze, "Towards Real-Time Performance Benchmarks for Ada", in Communications of the ACM (August t986). 59. The Computer Science Committee, "Distributed Computing Systems A Framework for a Co-ordinated Programme of Research", P/BE/32 C4, Science Research Council, UK (August 1977). 60. R.P. Cook, "*MOD - A Language for Distributed Programming", Proceedings of the 1st International Conference on Distributed Computing Systems, Huntsville, Alabama, pp. 233-241 (October 1979). 61. D. Cornhill, "A Survivable Distributed Computing System for Embedded Application Programs Written in Ada", Ada Letters (November/December1983). 62. D. Cornhill, J. Beane, and J. Silverman, "Preliminary Reference Manual for the Ada Program Partitioning Language", Honeywell (January 1983). 63. D. Cornhill, "Four Approaches to Partitioning Ada Programs for Execution on Distributed Targets", IEEE Computer Society 1984 Conference on Ada Applications and Environments, pp. 153-164 (October 1984). 64. G.W. Cox, W.M. Corwin, K.K. Lai, and F. J. Pollack, "Interprocess Communication and Processor Dispatching on the Intel 432", Transactions on Computer Systems 1(1), pp. 45-66, ACM (February 1983). 65. C.R. Daw,,;on, "Ada in an Avionics Real-time Environment", Ada User 7(1), pp. 33-45 (1986). 66. U.S. Dep~ent of Defense, "Requirements for High Order Computer Programming Languages - STRAWMAN", (July 1975). 67. U.S. Department of Defense, "Requirements for High Order Computer Programming Languages - TINMAN", (June 1976). 68. U.S. Department of Defense, "Revised Ironman Requirement for High Order Computer Programming Languages", (July 1977). 69. U.S. Dep~wtment of Defense, "STEELMAN Requirements for High Order Computer Programming Languages", (June 1978). 70. U.S. Department of Defense, "Reference Manual for the Ada Programming Language", ANSI/MIL-STD 1815 A (January 1983). 130 A REVIEWOF ADA TASKING

71. H.M. Deitel, An Introduction to Operating Systems (Revised First Edition), Addison-Wesley (1984). 72. R Dewar, R.M. Froelich, G°A. Fisher, and P. Kruchten, "An Executable Semantic Model For Ada", Ada/Ed Interpreter Ada Project, Courant Institute, New York University (1983). 73. E.W. Dijkstra, "Cooperating Sequential Processes", in Programming Languages, ed. F. Genuys, Academic Press, London (1968). 74. E.W. Dijkstra, L. Lamport, A. J. Martin, C. S. Scholten, and E. M. F. Steffens, "On-the-Fly Garbage Collection: An Exercise in Cooperation", Communications of the ACM 21(11), pp. 966-? (November 1978). 75. V. A. Downes and S. J. Goldsack, "The use of the Ada Language for Programming a Distributed System", The Real Time Programming Workshop, Graz (April 1980). 76. G. Eisenhauer, R. Jha, and J.M. Kamrad II, "Distributed Ada: Methodology, Notation and Tools", Proceedings First International Conference on Ada .Programming Language Applications for the NASA Space Station, pp. B.3.2.1- B.3.2.8 (June 2-5, 1986). 77. T. Elliot, "Mascot 3 and Ada: An Approach to Real-time Systems based on Reusable Components", Proceedings of 6th Ada UK International Conference, Ada User 8(Supplement), pp. 41-46 (1987). 78. Ericsson, "SDS80/A Standardised Computing System for Ada", Document Number L/BD 5553 (January 1986). 79. K.P. Eswaran, J. N. Gray, R. A. Lowie, and I. L. Traiger, "The notions of consistency and predicate locks in a database system", Comm. ACM 19(11) (Nov 1976). 80. E. Falis, "Design and Implementation in Ada of a Runtime Task Supervisor", Proceedings of the AdaTEC Conference on Ada, Arlington, pp. 1-9 (October 1982). 8i. A. Fantechi, "Interfacing with Real Environments from Ada Programs", Ada Letters 4(2) (I984). 82. A. Fantechi, M. Farusi, P. Inverardi, and N. Lijtmaer, "Ada as the System Language: the Cnet Inter-node Communication Mechanism", pp. 29-50 in Cnet Distributed Systems on LocaI Networks, Progetto Finalizzato Informatica (1985). 83. A. Fantechi, P. Invarardi, and N. Lijtmaer, "Using High Level Languages for Local Computer Network Communication: A Case Study in Ada", Software Practice and Experience 16(8), pp. 701-718 (August 1986). 84. J.A. Feldman, "'High Level Programming for Distributed Computing", CACM REFERENCES 131

22(1), pp. 353-68 (June 1979). 85. D. Fisher, "WOODENMAN - Set of Criteria and Needed Characteristics for a Common DoD High Order Programming Language", Institute of Defense Analyses, 'Working Paper (August 1975). 86. D. Fisher, "DoD's Common Programming Language Effort", Computer, pp. 24- 33 (March 1978). 87. D.A. Fisher and R.M. Weatherly, "Issues in the Design of a Distributed Operating System for Ada", IEEE Computer 19(5), pp. 38-47 (May 1986). 88. R.W. Floyd, "Assigning Meaning to Programs", in Proceeding of the Symposium of Appl. Mathematics Vol 19 in Mathematical Aspects of Computer Science, ed. J.T. Schwartz, American Mathematical Society (1967). 89. C.H. Forsyth, "Support for Tasking in the Run-Time System", Aria Workbench Compiler Project 1981, Appendix G. YCS.48, University of York (1982). 90. N. Francez and M. Rodeh, "Achieving Distributed Terminaton without Freezing", IEEE Transactions on Software Engineering SE-8(3), pp. 287-292 (1982). 91. N. Francez and S. Yemini, "A Fully Abstract and Composable Inter-Task Communication Construct", Technical Reports #299, TECHNION - Israel Institute of Technology, Department of Computer Science, Haifa, Israel (November 1983). 92. N. Francez and A. Yemini, "Symmetric Intertask Communication", Transactions on Programming Languages and Systems 7(4), pp. 622-636, ACM (October 1985). 93. N.H. Gehani and T.A. Cargill, "Concurrent Programming in the Ada Language: The Polling Bias", Software-Practice and Experience 14(5), pp. 413-427 (May 1984). 94. N.H. Gehani, Ada Concurrent Programming, Prentice-Hall (1984). 95. H.J. Genrich and K. Lautenbach, "The Analysis of Distributed Systems by means of Predicate Transistion Nets", Lecture Notes in Computer Science 70, pp. 123- 146, Spinger-Verlag (1979). 96. H.J. Genrich and K. Lantenbach, "System Modelling with High Level Petri Nets", Theoretical Computer Science 13 (1981). 97. W.M. Gentleman, "Message Passing Between Sequential Processes: the Reply Primitive and the Administrator Concept", Software Practice and Experience 11(5), pp. 435-466 (May 1981). 98. R. Gerth, "A Sound and Complete Hoare Axiomatization of the Ada Rendezvous", pp. 252-264 in 9th International Colloquim on Automata, Languages and Programming, Lecture Notes in Computer Science, ed. M. Nielson 132 A REVIEWOF ADA TASKING

and E. M. Scbmidt, Springer-Veflag (July, 1982). 99. R. Gerth and W.P. de Roever, "A Proof System for Concurrent Ada Programs", in Technical Report RUU-CS-83-2, Utrecht University (1983). 100. R. Gerth and W. P. DeRoever, "A Proof System for Concurrent Ada Programs", pp. 159-204 in Science of Computer Programming (1984). 101o S.J. Goldsack and T. Moreton, "Ada Package Specifications: Path Expressions and Monitors", IEE Proceedings 129(2), pp. 49-54 (1982). 102. J.N. Gray, "Notes on Data Base Operating Systems", pp. 393-481 in Operating Systems An Advanced Course, Lecture Notes in Computer Science No. 60, Springer-Verlag (1978). !03. G.L. Greeley, "An Ada Implementation for Fault Detection, isolation and Reconfiguration Using a Fault-Tolerant Processor", Proceedings First International Conference on Ada Programming Language Applications for the NASA Space Station, pp. E.2.4.1-E.2.4.13 (June 2-5, 1986). 104. A.N. Habermarm and I. Nassi, "Efficient Implementation of Ada Tasks", CMU- CS-80-103, Department of Computer Science, Carnegie-Mellon University (January I980). i05. A.N. Habermann and D. E. Perry., Adafor Experienced Programmers, Addison- Wesley (1983). 106. B. Haddon, "Nested Monitor Calls", ACM Operating Systems Review 11(4), pp. 18-23 (October 1977). 107. B.T. Halpern and S.S. Owicki, "Modular Verification of Computer Communication Protocols", IEEE Transactions on Communication 1, pp. 49-68 (1983). 108. D. M. Harland, "Towards a Language for Concurrent Processes", SOFTWARE - Practice and Experience 15(9), pp. 839-888 (September 1985)o 1C9. Hartig, H., Pfitzmann, A., and Treff, L, "Task State Transitions in Ada", Ada Letters 1(t ), pp. 31-42 (July/August, 1981). !10. M. Herlihy and B. Liskov, "A Value Transmission Method for Abstract Data Types", ACM TOPLAS 4(4), pp. 527-551 (October 1982). 111. P. Hilfinger, "Implementation Strategies for Ada Tasking Idioms", Proceedings of the AdaTEC Conference on Ada, Arlington, pp. 26-30 (October 1982). !12. A.D. Hill, "ASPHODEL An Ada Compatible Specification and Design Language", Ada UKNews 5(4), pp. 42-48 (1984). 113. C.A.R. Hoare, "An Axiomatic Basis for Computer Programming", CACM 12(t0), pp. 576-580 (October 1969). REFERENCES 133

114. C.A.R. Hoare, "Proof of a Program: Find", CACM 14(1), pp. 39-45 (January 1971). 115. C.A.R. Hoare, "Monitors - An Operating System Structuring Concept", CACM 17(10), pp. 549-557 (October 1974). 116. C.A.R. Hoare, "Communicating Sequential Processes", CACM 21(8), pp. 666-677 (August 1978). 117. C.A.R. Home, "Subsetting of Ada", Draft Document (June 1979). 118. C.A.R. He,are, "A Calculus for Total Correctness for Communicating Sequential Processes", Science of Computer Programming 1, pp. 49-72 (1981). 119. E. Holler, "Multiple Copy Update", pp. 284-308 in Distributed Systems - Architecture and Implementation, ed. B.W. Lampson, Springer-Verlag (1981). 120. A.D. Hutcheon and A.J. Wellings, "Ada for Distributed Systems", Computer Standards and Interfaces (To appear). 121. L. Ibsen, "A Portable Virtual Machine for Ada", Software-Practice and Experience 14, pp. 17-29 (1984). 122. J.D. Ichbiah et al., "Reference Manual For The Green Programming Language",, Honeywell, Inc. and Cii Honeywell Bull (March 1979). 123. J. D. Ichbiah et al., "Rationale For The Design Of The Green Programming Language",, Honeywell, Inc. and Cii Honeywell Bull (March 1979). 124. INMOS_Limited, Occam Programming Manual, Prentice Hall, London (1984). 125. INRIA, "Formal Definition of the Ada Programming Language", Honeywell Inc, CII Honeywell Bull (1982). 126. P. Inverardi, F. Mazzanti, and C. Montangero, "The Use of Ada in the Design of Distributed Systems", pp. 85-96 in Ada in Use, The Ada Companion Series, ed. G.A. Fisher, Cambridge University Press (1985). 127. J. Jackson, "Distributed Ada Tasks", WESCON 86 (to appear). 128. K. Jackson, "Mascot 3 and Ada", Software Engineering Journal 1(3), pp. 121-135 (May 1986). 129. K. Jackson and T. Riddiough, "Rendezvous Avoidance - A Strategy for Faster Ada Execution", Ada User 7(4), pp. 53-58 (1986). 130. W. H. Jessop, "Ada and Distributed Systems", Technical Report #81-01-06, Department of Computer Science, University of Washington Seattle (January 1981). 131. W.H. Jessop, "Ada Packages and Distributed Systems", SIGPLANNotices 17(2), pp. 28-36 (February 1982). 132. C.B. Jones, "Specification and Design of (parallel) Programs", pp. 321-32 in 134 A REVIEWOF ADA TASKING

Information Processing 83, ed. R.E.A. Mason, Elsevier North-Holland (September 1983). 133. D. Keeffe, G.M. Tomlinson, I.C. Wand, and AJ. Wellings, "A Review of Ada Tasking", pp. 193-227 in PULSE: An Ada-based Distributed Operating System, APIC Studies in Data Processing Series, Academic Press (1985). 134. D. Keeffe, G. M. Tomlinson, I. C. Wand, and A. J. Wellings, PULSE: An Ada- based Distributed Operating System, APIC Studies in Data Processing Series, Academic Press (1985). 135. B. W Kernighan and D. M. Ritchie, The C Programming Language, Prentice-Hall Inc., New Jersey (1978). 136. J.C. Knight and J.I.A. Urquhart, "On the Implementation and Use of Ada on Fault-tolerant Distributed Systems", Ada Letters 4(3), pp. 53-64 (1984). 137. W. H. Kohler, "A Survey of Techniques for Synchronization and Recovery in Decentralized Computer Systems", ACM Computing Surveys 13(3), pp. 149-183 (June 1981). 138. J. Kranaer, J. Magee, M. S. Sloman, and A. M. Lister, "CONIC: an Integrated Approach to Distributed Computer Control Systems", lEE Proceedings (Part E) 180(1), pp. 1-10 (Jan 1983). 139. B. Krieg-Bruckher and D.C. Luckham, "Anna: Towards a Language for Annotating Ada Programs", SIGPLAN 15, pp. 128-138 (1980). 140. P. Lahtinen, "A Machine Architecture for Ada", Ada Letters 2(2), pp. 28-33 (September/October 1982). 141. L. Lamport, "Specifying Concurrent Program Modules", Transactions on Programming Languages and Systems 5(2), pp. 190-222, ACM (April 1983). 142. L. Lamport, "What it Means for a Concurrent Program to Satisfy a Specification: Why No One Has Specified Priority", SRI International, Menlo Park, California (1984). 143. B.W. Lampson and D. Redell, "Experience with Processes and Monitors in Mesa", CACM 23(2), pp. 105-117 (February 1980). 144. B.W. Lampson, "Remote Procedure Calls", pp. 365-370 in Lecture Notes in Computer Science, Vol. 105, Springer-Veflag (1981). 145. B.W. Lampson, "Atomic Transactions", pp. 246-264 in Distributed Systems - Architecture and Implementation, ed. B.W. Lampson, Springer-Verlag (1981). t46. D.S. Lane, G. Huling, and B.M. Bardin, "Implementation of a Real-Time Distributed Computer System in Aria", AIAA Computers in Aerospace IV Conference, Hartford, Connecticut, pp. 325-330 (October 1983). REFERENCES 135

147. J.F. Leattu'um, "Design of an Ada Run-Time System", IEEE Computer Society 1984 Conference on Ada Applications and Environments, pp. 4-13 (October 1984). 148. B. Liskov, "Primitives for Distributed Computing", Proceedings of the Seventh ACM Symposium on Operating System Principals, Pacific Grove, California, pp. 33-43 (December 1979). 149. B. Liskov and A. Snyder, "Exception Handling in CLU", IEEE Transaction on Software Engineering SE-5(6), pp. 546-558 (November 1979). 150. B. Liskov and R. Scheifler, "Guardians and Actions: Linguistic Support for Robust, Distributed Programs", ACM Transactions on Programming Languages and Systems 5(3), pp. 381-404'(July 1983). 151. B. Liskov, M. Herlihy, and L. Gilbert, "Limitations of Remote Procedure Call and Static Process Structure for Distributed Computing", Proceedings of Thirteenth Annual ACM Symposium on Principles of Programming Languages, St. Petersburg Beach, Florida, pp. 150-159 (January 1986). 152. A.M. Lister, "The Problem of Nested Monitor Calls", ACM, Operating Systems Review 11(3), pp. 5-7 (July 1977). 153. A. M. Lister, Fundamentals of Operating Systems (3rd Edition), Macmillan Computer Science Series (1984). 154. D.B. Lomet, "Process Structuring, Synchronisation and Recovery using Atomic Transactions", SIGPLAN 12(3), pp. 128-137 (1977). 155. A. Maccabe and R. LeBlanc, "The Design of a Programming Language Based on Communication Networks", 3rd International Conference on Distributed Computing, Miami Florida (October 1982). I56. A. B. Maccabe, "Language Features for Fully Distributed Processing Systems", GIT-ICS-82/12, Georgia Institute of Technology (August 1982). 157. Z. Manna and A. Pnueli, "How to Cook a Temporal Proof System for your Pet Language", Proceedings of the ACM Symposium on Principles of Programming 10, pp. 101-124 (1983). 158. R.A. Maule, "Run-Time Implementation Issues for Real-Time Embedded Ada", Proceedings First International Conference on Ada Programming Language Applications for the NASA Space Station, pp. E.3.4.1-E.3.4.11 (June 2-5, 1986). 159. A. McGettrick, "Program Verification and Ada", lEE Proceedings 129(2), pp. 55-62 (1982). 160. I. Mearns, "A Denotational Semantics for Concurrent Ada Programs", in PhD. thesis, University of Manchester, UK (1984). 161. R. Milner, "A Calculus of Communicating Systems", Lecture Notes in Computer !36 A REVIEW OF ADA TASKING

Science 92, Springer-Verlag (1980). 162. J.G. Mitchell, W. Maybury, and R. Sweet, '°Mesa Language Manuai Verson 5.0", CSL-79-3, Palo Alto Research Center, Xerox (April 1979). 163. T. Moreton, "Tools for the Building of Distributed Ada Programs", in Proceedings Ada-Europe Conference, Stockholm, Cambridge University Press (May 1987"). 164. D.A. Mundie and D.A. Fisher, "Parallel Processing in Ada", IEEE Computer t9(8), pp. 20-25 (August 1986)o 165. Jo Murdie, "Functional Specification of the York Ada Workbench Compiler, Release 1", YCS.62, Department of Computer Science, University of York (December 1983). 166. B. J. Nelson, "Remote Procedure Call", CMU-CS-81-119, Department of Computer Science, Carnegie-Mellon University (May 1981). 167. J. Nestor mid M. Van Deusen, "RED Language Reference Manual", IR-310-2, Intermetrics Inc. (March 1979)o 168. J. Nissen and P. Wallis, Portability and Style in Ada, Ada Companion Series, Cambridge University Press (1984). 169. J. Nissen et al., °'A Compiler-IndependentApproach to Distributing a Single Ada Program", First Report of DIADEM (MAP Project 770), Commission of European Comunities (1986). 170. M.C. Paulk, "Comparing Host and Target Environments for Distributed Ada Programs", Proceedings First International Conference on Ada Programming Language Applications for the NASA Space Station, pp. E.3.6.1-E.3.6.10 (June 2-5, 1986). 171. D.E. Perry, "High Level Language Features for Handling I/O Devices in Real- time Systems", D.Phil thesis, Faculty of the Stevens Institute of Technology, New Jersey (1978). 172. G. Persch, H.S. Johnson, R. Landwehr, J. Uhl, M. Dausmann, and W. Kirchgassner, "A Portable Ada Tasking System for Single Processors", in GC ACM Programming Environments and Compilers, Munich (April 1984). !73. J.L. Peterson and A. Silberschatz, Operating System Concepts (2nd Edition), Addison-Wesley (1985). 174. A. Pnueli and W. DeRoever, °'Rendezvous with Aria -A Proof Theoretical View", Proceedings of the AdaTEC Conference on Ada, Arlington, pp. 129-137 (October 1982). t75. G. Popek et aI, "LOCUS A Network Transparent, High Reliability Distributed REFERENCES 137

System", Proceedings of the Eighth ACM Symposium on Operating Systems Principles, Pacific Grove, California, pp. 169-177 (December 1981). 176. G.J. Popek and B.J. Walker, The LOCUS Distributed System Architecture, Computer Systems Series, The MIT Press (1985). 177. L. Pouzin, "Virtual Circuits vs Datagrams - Technical and Political Problems", Proceedings of the National Computer Conference, AFIPS, pp. 483-494 (June 1976). 178. I. C. Pyle, The Ada Programming Language (2nd Edition), Prentice Hall International (1985). 179. R. Racine, "Transparent Ada Rendezvous in a Fault Tolerant Distributed System", Proceedings First International Conference on Ada Programming Language Applications for the NASA Space Station, pp. E.2.1.1-E.2.1.7 (June 2-5, 1986). 180. B. Randell, P. A. Lee, and P. C. Treleaven, "Reliability Issues, in Computing System DesJLgn", ACM Computing Surveys 10(2), pp. 123-165 (June 1978). 181. R. F. Rashid and G. G. Robertson, "Accent: A Communication Oriented Network Operating System Kernel", Proceedings of the Eighth ACM Symposium on Operating Systems Principles, Pacific Grove, California, pp. 64-75 (December 1981). 182. K.A. Raymond, "Counting the Cost of Communication Primitives for Distributed Computing", 6th Australian Computer Science Conference, Sydney, pp. 214-224 (Feb 1983). 183. K. A. Raymond, "A Distributed Cookbook", TR-40, University of Queensland (Feb 1983). 184. D. Redell el: al., "Pilot: An Operating System for a Personal Computer", CACM 23(2), pp. 81-92 (February 1980). t85. D. Reed, "Implementing Atomic Actions on Decentralised Data", ACM Transactions on Computer Systems 1(1), pp. 3-23 (February 1983). 186. W. Reisig, in Petri Nets, Monograph on Theoretical Computer Science, Springer- Verlag (198:5). 187. P.F. Reynolds, J. Knight, and J. Urquhart, "The Implementation and Use of Ada on a Distributed System with High Reliability Requirements", Final Report on NASA Grant Number: NAG-I-260, Department of Applied Mathematics and Computer Science, University of Virginia (March 1983). 188. G.D. Rhodes, "Task Times", Ada User 7(3) (1986). 189. G.A. Riccardi and T.P. Baker, "A Runtime Supervisor to Support Ada Tasking: 138 A REVmW OF ADA TASKING

Rendezvous and Delays", pp. 329-342 in Ada in Use, The Ada Companion Series, ed. G.A. Fisher, Cambridge University Press (1985). 190. Ritchie, D. M. and Thompson, K., "The UNIX Time-sharing System", CACM t7(7), pp. 365-375 (July 1974). 191. P. Rogers and C.W. McKay, "Distributing Program Entities in Ada", Proceedings First International Conference on Ada Programming Language Applications for the NASA Space Station, pp. B.3.4.1-B.3.4.13 (June 2-5, 1986). !92. G. Rozenberg(ed.), in Advances in Petri Nets 1984, Lecture Notes in Computer Science, Spinger-Verlag (1985). !93. LH. Saltzer, D.P Reed, and D.D. Clark, "End-To-End Arguments in System Design", ACM Transactions on Computer Systems 2(4), pp. 277-288 (1984). 194. J. Schauer, "Vereinfachung von prozess - Systemen durch seqentialisievung", 30/82, Institut fur Informatik, Bericht (1982). !95. E. Schonberg and E. Schonberg, "Highly Parallel Ada Ada on an Ultracomputer", pp. 58-7t in Ada in Use, The Ada Companion Series, ed. G.A. Fisher, Cambridge University Press (I 985). I96. M.D. Schroeder, A. D. Bin'eI1, and R. M. Needham, "Experience with Grapevine: The Growth of a Distributed System", ACM Transactions on Computer Systems 2(t) (1984). 197. R.L. Schwartz, P.M. Melliar-Smith, F.H. Vogt, and D.A. Plaisted, "An Interval Logic for Higher-level Temporal Reasoning", NASA Contractor report 172262, SRI International, California (1983). !98. S. K. Shrivastava, "On the Treatment of Orphans in a Distributed System", Proceedings of the 3rd Symposium on Reliability in Distributed Software and Database Systems, Florida, pp. 155-162 (October 1983). 199. R.K. Shyamasundar, W.P. De Roever, R. Gerth, R. Koymans, and S. Arun-Kumar, "Compositional Semantics for Real-Time Distributed Computing", Technical Report RRU-CS-84-6, Utrecht University (1984). 200. A. Silberschatz, "On the Synchronisation Mechanism of the Ada Language", SIGPLANNotices 16(2), pp. 96-103 (February 1981). 201. A. Silberschatz, "On the Synchronizations Mechanism of the Ada language", Proceedings 7th Hawaff International Conference System Science (1984). 202. H.R. Simpson, "The Mascot Method", Software Engineering Journal 1(3), pp. 103-t20 (May 1986). 203. W. D. Sincoskie and D. J. Farber, "The Series/1 Distributed Operating System: Description and Comments' ', Proceedings of the COMPCON 80 Fall Distributed REFERENCES 139

Computing Conference, Washington DC, pp. 579-584 (September 1980). 204. M. Sloman, J. Magee, and J. Kramer, "Building Flexible Distributed Systems in Conic", pp. 86-105 in Distributed Computing Systems Programme, ed. D. A. Duce, Peter Peregrinus Ltd. (1984). 205. Softech, Reference Manual for the Blue Programming Language, 1978. 206. M.H. Solomon and R. A. Finkel, "The Roscoe Distributed Operating System", Proceedings of the Seventh ACM Symposium on Operating Systems Principles, pp. 108-114 (December 1979). 207. A. Z. Spector, J. Butcher, D. S. Daniels, D. J. Duchamp, J. L. Eppinger, C. E. Fineman, A. Heddaya, and P. M. Schwarz, "Support for Distributed Transactions in the TAB.S Prototype", CMU-CS-84-132, Department of Computer Science, Carnegie-Mellon University (Jul 1984). 208. SRI, Reference Manual for the Yellow Programming Language, 1978. 209. R. Stammers et al., "A Feasibility Study to Determine the Applicability of Ada and APSE', in a Multi-Microprocessor Distributed Environment", SPL International, Research Centre, The Charter, Abingdon, OX14 3LZ, UK (March 1983). 210. D.R. Stevenson, "Algorithms for Translating Ada Multi-tasking", SIGPLAN 15(11) (1980). ~ 21t. L. Svobodova, "Workshop Summary - Operating ~Systems in Computer Networks", ACM Operating System Review 19(2), pp. 6-39 (1985). 212. A. S. Tanenbaum, "Network Protocols", ACM Computing Surveys 13(4), pp. 453-489 (December 1981). 213. M. Tedd, S. Crespi-Reghizzi, and A. Natali, Adafor Multi-microprocessors, The Ada Companion Series, Cambridge University Press (1984). 214. G. M. Tomtinson, D. Keeffe, I. C. Wand, and A. J. Wellings, "The PULSE Distributed File System",, Software Practice and Experience (November 1985). 215. B. Tooby and K. Derrick, "Experience with Ada Targeted to INTEL 8086", Ada User 7(2), pp. 32-40 (t986). 216. M. Volz, T. Mudge, A.W. Naylor, and J.H. Mayer, "Some Problems in Distributing Real-Time Ada Programs Across Machines", pp. 72-84 in Ada in Use, The Ada Companion Series, ed. G.A. Fisher, Cambridge University Press (1985). 217. R.M. Weatherly, "A Message-Based Kernel to Support Ada Tasking", IEEE Computer Society 1984 Conference on Ada Applications and Environments, pp. 136-144 (October 1984). !40 A REVIEW OF ADA TASKING

218. P. Wegner and S. Smolka, "'Processes, Tasks, and Monitors: A Comparative Study of Concurrent Programming Primitives", IEEE Transaction on Software Engineering SE-9(4), pp. 446-462 (July 1983). 219. P.H. Welch, "A Structured Technique for Concurrent Systems design in Ada", in Proceedings Ada-Europe Conference, Edinburgh, Cambridge University Press (6- 8 May 1986). 220. P.H. Welch, "Parallel Processes as Reusable Components", in Proceedings Ada- Europe Conference, Stockholm, Cambridge University Press (May 1987). 221. A. J. Wellings, D. Keeffe, and G. M. Tomlinson, "A Problem with Ada and Resource AtIocation' ', Ada Letters 3(4) (January/February 1984). 222. A. J. Wellings, G. M. Tomhnson, D. Keeffe, and L C. Wand, "Communication Between Aria Programs", Proceedings of the IEEE Conference on Ada Applications and Environments, pp. 145-152 (October 1984). 223. A. J. Wellings, "Distributed Operating Systems and the Ada Programming Language", D. Phil. Thesis, Department of Computer Science, University of York, UK (April 1984). 224. A.J. Wellings, "The Use of Ada Tasking in the Implementation of a Distributed Operating System", Ada UKNews 6(3), pp. 53-60 (1985). 225. J. Welsh and D. Bustard, "Pascal-Plus - Another Language for Modular Mulfiprogramming", Software Practice and Experience 9(11), pp. 947-957 (November 1979). 226. J. Welsh and A. M. Lister, "A Comparative Study of Task Communication in Ada", Software Practice and Experience 11(3), pp. 257-290 (March 1981). 227. A.J. Williams, "Input and Output in High Level Programming Languages", M. Phil thesis, Department of Computer Science, University of York (1985). 228. N. Wirth, "Modula: a Language for Modular Multiprogramming", Software Practice and Experience 7(1), pp. 3-35 (January-February 1977). 229. N. Wirth, Programming in Modula-2, Second Edition, Springer-Verlag (1983). 230. W. Li, "An Operational Semantics of Multitasking and Exception Handling in Ada", Proceedings of the AdaTEC Conference on Ada, Arlington, pp. 138-15t (October 1982). 231. S. Yemini, "On the Suitability of Ada Multitasking for Expressing Parallel Algorithms", Proceedings of the AdaTEC Conference on Ada, Arlington, pp. 91- 97 (October 1982). 232. S. J. Young, Reai Time Languages: Design and Development, Ellis Horwood Publishers, Chichester (t 982). REFERENCES 141

233. S. Zeigler, "Ada for the Intel 432 Microcomputer", Computer 14(6), pp. 47-56 (June 1981). 234. W. Zwaenepoei and K. Lantz, "Perseus: Retrospective on a Portable Operating System", Software Practice and Experience 14(1), pp. 31-48 (January 1984).