Muutke küpsiste eelistusi

Concurrent and Real-Time Programming in Ada [Kõva köide]

3.83/5 (11 hinnangut Goodreads-ist)
(University of York), (University of York)
  • Formaat: Hardback, 476 pages, kõrgus x laius x paksus: 244x170x27 mm, kaal: 950 g, 17 Tables, unspecified; 29 Line drawings, unspecified
  • Ilmumisaeg: 05-Jul-2007
  • Kirjastus: Cambridge University Press
  • ISBN-10: 0521866979
  • ISBN-13: 9780521866972
Teised raamatud teemal:
Concurrent and Real-Time Programming in AdaSuurem pilt
  • Formaat: Hardback, 476 pages, kõrgus x laius x paksus: 244x170x27 mm, kaal: 950 g, 17 Tables, unspecified; 29 Line drawings, unspecified
  • Ilmumisaeg: 05-Jul-2007
  • Kirjastus: Cambridge University Press
  • ISBN-10: 0521866979
  • ISBN-13: 9780521866972
Teised raamatud teemal:
Püsilink: https://www.kriso.ee/db/9780521866972.html
Märksõnad:
Burns and Wellings (U. of York, England) discuss the Ada tasking model in computer programming applications, and how it is the only ISO standard real-time programming language that is concurrent and object-oriented. Designed as an update to the duo's 2005 book, Concurrency in Ada, this volume takes a look at the new developments in programming techniques and changes in the Ada language. This is intended as both a tutorial for professional software engineers and advanced computer science students. Annotation ©2008 Book News, Inc., Portland, OR (booknews.com)

Ada is the only ISO-standard, object-oriented, concurrent, real-time programming language. It is intended for use in large, long-lived applications where reliability and efficiency are essential, particularly real-time and embedded systems. In this book, Alan Burns and Andy Wellings give a thorough, self-contained account of how the Ada tasking model can be used to construct a wide range of concurrent and real-time systems. This is the only book that focuses on an in-depth discussion of the Ada tasking model. Following on from the authors' earlier title Concurrency in Ada, this book brings the discussion up to date to include the new Ada 2005 language and the recent advances in real-time programming techniques. It will be of value to software professionals and advanced students of programming alike: indeed every Ada programmer will find it essential reading and a primary reference work that will sit alongside the language reference manual.

Only book that explains Ada tasking model; covers latest version of Ada and its use in real-time and concurrent systems.

Arvustused

' thorough, self-contained ' Zentralblatt MATH

Muu info

The only book that explains Ada tasking model, covering the latest version of Ada and its use in real-time and concurrent systems.
Preface xi
Introduction
1(14)
Concurrency
2(1)
Real-time systems
3(3)
Ada's time and clock facilities
6(7)
Summary
13(1)
Further reading
13(2)
The nature and uses of concurrent programming
15(16)
Uses of concurrent programming
17(1)
Program entities
18(2)
Process representation
20(1)
A simple embedded system
21(9)
Summary
30(1)
Further reading
30(1)
Inter-process communication
31(24)
Data communication
32(1)
Synchronisation
33(1)
Deadlocks and indefinite postponements
34(2)
System performance, correctness and reliability
36(2)
Dining philosophers problem
38(1)
Shared variables and protected variables
39(2)
Semaphores
41(3)
Monitors
44(4)
Message-based communication
48(5)
Summary
53(1)
Further reading
54(1)
Task types and objects
55(24)
Task creation
57(8)
Task activation, execution, finalisation and termination
65(5)
Task hierarchies
70(5)
Task identification
75(2)
Task creation, communication and synchronisation within task finalisation
77(1)
Summary
77(2)
The rendezvous
79(18)
The basic model
79(2)
The entry statement
81(2)
The accept statement
83(5)
The Count attribute
88(1)
Entry families
88(2)
Three-way synchronisation
90(2)
Private entries
92(1)
Exceptions and the rendezvous
93(1)
Task states
94(1)
Summary
94(3)
The select statement and the rendezvous
97(32)
Selective accept
97(4)
Guarded alternatives
101(2)
Delay alternative
103(4)
The else part
107(2)
The correct use of guards
109(2)
The terminate alternative
111(5)
The exception Program_Error
116(2)
Summary of the selective accept statement
118(1)
Conditional and timed entry calls
118(3)
Mutual exclusion and deadlocks
121(3)
The dining philosophers
124(3)
Task states
127(1)
Summary
127(2)
Protected objects and data-oriented communication
129(34)
Protected objects
129(2)
Mutual exclusion
131(2)
Condition synchronisation
133(2)
Entry calls and barriers
135(4)
Private entries and entry families
139(3)
Restrictions on protected objects
142(2)
Access variables and protected types
144(2)
Elaboration, finalisation and exceptions
146(1)
Shared data
147(1)
The readers and writers problem
148(3)
The specification of synchronisation agents
151(1)
Shared variables
152(4)
Volatile and atomic data
156(4)
Task states
160(1)
Summary
161(2)
Avoidance synchronisation and the requeue facility
163(32)
The need for requeue
163(12)
Semantics of requeue
175(4)
Requeuing to other entities
179(4)
Real-time solutions to the resource control problem
183(3)
Entry families and server tasks
186(4)
Extended example
190(3)
Task states
193(1)
Summary
194(1)
Exceptions, abort and asynchronous transfer of control
195(28)
Exceptions
195(3)
The abort statement
198(2)
Asynchronous transfer of control
200(12)
Understanding the asynchronous select statement
212(5)
A robust readers and writers algorithm
217(4)
Task states
221(1)
Summary
221(2)
Object-oriented programming and tasking
223(24)
The Ada 2005 OOP model
224(7)
Tasks and interfaces
231(8)
Protected types and interfaces
239(5)
Synchronized interfaces
244(2)
Summary
246(1)
Further reading
246(1)
Concurrency utilities
247(46)
Communication and synchronisation abstractions
248(1)
Semaphores
248(9)
Locks
257(6)
Signals
263(1)
Event variables
264(2)
Buffers
266(2)
Blackboards
268(1)
Broadcasts
269(7)
Barriers
276(1)
Concurrent execution abstractions
277(1)
Callables and futures
278(2)
Executors
280(4)
Completion services
284(4)
Image processing example revisited
288(3)
Summary
291(2)
Tasking and systems programming
293(24)
Device driving and interrupt handling
296(4)
Model of interrupts
300(11)
Task identifiers
311(2)
Task attributes
313(3)
Summary
316(1)
Further reading
316(1)
Scheduling real-time systems - fixed priority dispatching
317(14)
Scheduling
317(2)
Fixed priority dispatching
319(3)
Priority ceiling locking
322(5)
Entry queue policies
327(1)
Active priorities and dispatching policies
327(2)
Summary
329(1)
Further reading
329(2)
Scheduling real-time systems - other dispatching facilities
331(30)
Non-preemptive dispatching
331(1)
Round-robin dispatching
332(3)
Earliest deadline first dispatching
335(12)
Mixed scheduling
347(1)
Dynamic priorities
348(6)
Synchronous and asynchronous task control
354(5)
Summary
359(1)
Further reading
359(2)
Timing events and execution-time control
361(30)
Events and event handling
361(1)
Timing events
362(4)
Dual priority scheduling
366(3)
Execution-time clocks
369(2)
Execution-time timers
371(3)
Group budgets
374(13)
Task termination events
387(2)
Summary
389(1)
Further reading
389(2)
Real-time utilities
391(42)
Real-time task state
393(2)
Real-time task release mechanisms
395(2)
Periodic release mechanisms
397(8)
Sporadic release mechanisms
405(2)
Aperiodic release mechanisms and execution-time servers
407(8)
Real-time tasks
415(4)
The cruise control system example
419(13)
Summary
432(1)
Restrictions, metrics and the Ravenscar profile
433(18)
Restricted tasking and other language features
433(3)
The Ravenscar profile
436(3)
Partition elaboration control
439(1)
Examples of the use of the Ravenscar profile
440(8)
Metrics and optimisations
448(1)
Summary
449(1)
Further reading
450(1)
Conclusion
451(4)
Support for concurrency
452(1)
Support for real-time
452(1)
New to Ada 2005
453(1)
Outstanding issues and the future
453(2)
References 455(2)
Index 457


Alan Burns is a Professor in Computer Science and the Head of the Computer Science Department at the University of York. His research activities have covered a number of aspects of real-time and safety critical systems including the assessment of languages for use in the real-time safety critical domain, distributed operating systems, the formal specification of scheduling algorithms and implementation strategies, and the design of dependable user interfaces to safety critical applications. His teaching activities include courses in Operating Systems, Scheduling and Real-time Systems. He has authored over 350 papers and reports and 8 books, including Real-time Systems and Programming Languages, 3rd edition and Concurrency in Ada, 2nd edition. Andy Wellings is a Professor of Real-Time Systems in the Computer Science Department at University of York. He is interested in most aspects of the design and implementation of real-time dependable computer systems and, in particular, real-time programming languages and operating systems. He is European Editor-in-Chief for the Computer Science journal Software-Practice and Experience and a member of the International Expert Groups currently developing extensions to the Java platform for real-time, safety critical and distributed programming. He has authored over 200 papers and several books, including Real-time Systems and Programming Languages, 3rd edition and Concurrency in Ada, 2nd edition.