Real-Time Java Platform Programming
Prentice Hall (Verlag)
978-0-13-028261-3 (ISBN)
- Titel ist leider vergriffen;
keine Neuauflage - Artikel merken
Real-time programming is critical to the development of a wide range of consumer, industrial, system, and military devices. Using the new Real-Time Specification for Java (RTSJ), developers can create, verify, analyze, execute and manage Java code that ensures the correctness, timeliness, and execution predictability that are essential to real-time programming. This book, written by one of RTSJ's creators, offers a practical introduction to real-time programming for every Java developer -- even those with no real-time experience at all. Replete with example code, this book gives any Java developer the skills and expertise to build powerful real-time applications. Peter Dibble begins with an overview of the key issues associated with Java real-time development. He covers garbage collection, priority scheduling and deadline scheduling in real-time environments; then introduces rate monotonic analysis, a powerful set of techniques for analyzing timing behavior to ensure that real-time systems will always meet their deadlines. The book covers every aspect of real-time Java development, including closures, the use of thread.interrupt, asynchronous events, timers, CT allocation, non-heap access, physical and "immortal" memory, structuring RT Java programming, supporting distributed real-time applications and interactions with non-RT threads, using RT Java exceptions, RT restrictions on the JVM, and much more.
PETER DIBBLE, a member of the team that created the Real-Time Specification for the Java platform, was also on the Microware Systems Corporation team that first ported the Sun Java platform to an embedded system and produced the first version of Personal Java technology for a commercial RTOS. He has over a decade's experience with real-time system software and is author of OS-9 Insights and The Complete Guide to OS-9.
Preface.
Introduction.
1. Landscape.
Java Technology and Real Time. Real-Time Programming Requirements. Java and Embedded Real Time. Definition of Real Time. Precision of Measurement. Consistency. Utility Function Curve. Java's Problem Domain. Real-Time Java's Problem Domain. Summary.
2. Architecture of the Java Virtual Machine.
Write Once, Run Anywhere: Maybe. JVM Components. Class Loading. Bytecode Interpreter. Security Manager. Garbage Collector. Thread Management. Input/Output. Graphics. Interpreter Implementation. Standard Interpreter. Optimized Interpreter. JIT. Snippets. Compilation to Independent Process. Native Methods. Compilation to a Native Method. Compilation to the JIT Interface.
3. Hardware Architecture.
Worst-Case Execution of One Instruction. Worst-Case Scenario. Practical Measures. Management of Troublesome Hardware. Managing Demand Paging. Managing DMA. Managing Cache. Managing Address Translation Cache. Managing Interrupts. Effects on the JVM.
4. Garbage Collection.
Reference Counting. Basic Garbage Collection. Mark and Sweep. Defragmentation. Copying Collectors. Incremental Collection. Incremental Garbage Collection in Practice. Generational Garbage Collection. Intergenerational References. Large Object Store. Real-Time Issues.
5. Priority Scheduling.
Scheduling Terms. Execution Sequences. Preemption. The Seductive Charm of Nonpreemptive Scheduling. Fixed versus Dynamic Priority. Priority Inversion. Why 32 Priorities? Problems with Priority Scheduling.
6. Scheduling with Deadlines.
Underlying Mechanism. Scope of the Scheduler. Some Systems. Earliest Deadline First (EDF). Least Laxity. Periodic Scheduling. Aperiodic Servers. Handling Overload. Timing Is Usually Probabilistic.
7. Rate Monotonic Analysis.
Theorems. Liu and Layland's Theorem. A Graphical Approach. Lehoczky, Sha, and Ding's Theorem. Restrictions. Independent Tasks. Deadlines Equal to Periods. Multiprocessor Systems.
8. Introduction to the Real-Time Java Platform.
A Brief History of Real-Time Java. Major Features of the Specification. Threads and Scheduling. Garbage Collection. Asynchronous Event Handlers. Asynchronous Transfer of Control. Memory Allocation. Memory Access. Implementation. RTSJ Hello World.
9. Closures.
The Language Construct. Java Closures. Closure Structure. Closures in the RTSJ. Limitations of Closures. Readability. Local Variables. Constructors. Nesting.
10. High-Resolution Time.
Resolution. The “clock”. HighResolutionTime Base Class. Absolute Time. Relative Time. Rational Time.
11. Async Events.
Binding a Happening to an Event. Basic Async Event Operation. Async Events without Happenings. Time Triggering. Fault Triggering. Software Event Triggering. Implementation Discussion.
12. Real-Time Threads.
Creation. Scheduling. Inversion Handling. Fixed Priority. Feasibility. Periodic Threads without Handlers. Feasibility Analysis. Periodic Threads with Handlers. Interactions with Normal Threads. Changing the Scheduler.
13. Non-Heap Memory.
The Advantage of Non-Heap Memory. The Allocation Regimes. Rules. Mechanisms for Allocating Immortal Memory. Mechanisms for Allocating from Scoped Memory. Allocation Time. Creating Scoped Memory. Allocation Mechanisms. Finalizers. Using Nested Scoped Memory. The Scope Stack (Tree). The DAG. Practical Use of Nested Scopes. Every Nested Scope Involves Two Memory Areas. Pitfalls. Using executeInArea. Using Standard Classes. Using Shared Scoped Memory. The Scope Stack Revisited. Scope Portals. Fine Print. Quick Examples.
14. Non-Heap Access.
Interaction with Scheduler. Rules. Samples. Final Remarks. Notes.
15. More Async Events.
Async Events and the Scheduler. The createReleaseParameters Method. Bound Async Event Handlers. Async Event Handlers and Non-Heap Memory. No-Heap Event Handlers vs. No-Heap Threads. Scheduling. Minimum Interarrival Time. Async Event Handlers and Threads. Special Async Events.
16. Reusing Immortal Memory.
Using Fixed-Object Allocators. Carrier Objects. Limitations. Recycling RT Threads. Recycling Async Event Handlers.
17. Asynchronous Transfer of Control.
Thread Interrupt in Context. Asynchronous Interrupt Firing. The Timed Class. The interrupt Method. The fire Method. In Summary. Replacement Rules. Rules for Async Exception Propagation. Oblivious catch. Nonmatching doInterruptible. Matching doInterruptible. Internals. Application Handling for Asynchronous Interrupts. Noninterruptible Code. Special Issues for Synchronized blocks. Legacy Code. Use of ATC for Thread Termination.
18. Physical Memory.
Physical and Virtual Memory. Physical Memory Manager. Memory Type. Removable Memory. Immortal Physical Memory. Scoped Physical Memory.
19. Raw Memory Access.
Security. Peek and Poke. Get/Set Methods. Mapping. The RawMemoryFloatAccess Class.
20. Synchronization without Locking.
Principles of Wait-Free Queues. Constructors. Common Methods. The Wait-Free Write Queue. Methods. Sharing the Wait-Free Queue. The Wait-Free Read Queue. The Extra Constructor. Methods. The Wait-Free Double-Ended Queue. Methods. No-Wait Queues and Memory. Implementation Notes.
21. Recommended Practice.
Powerful and Easy-to-Use Features of the RTSJ. Real-Time Threads. Periodic Threads. Asynchronous Event Handlers. High-Resolution Time. Happenings. Very Powerful and Dangerous Features of the RTSJ. Simple. Leaky. Viral. Very Powerful and Finicky Features of the RTSJ. Scoped Memory. No-Heap Asynchronous Event Handlers. No-Heap Real-Time Threads. Asynchronously Interrupted Exceptions. Selection of Priorities.
Index.
| Erscheint lt. Verlag | 20.3.2002 |
|---|---|
| Verlagsort | Upper Saddle River |
| Sprache | englisch |
| Gewicht | 664 g |
| Themenwelt | Informatik ► Programmiersprachen / -werkzeuge ► Java |
| Mathematik / Informatik ► Informatik ► Web / Internet | |
| ISBN-10 | 0-13-028261-8 / 0130282618 |
| ISBN-13 | 978-0-13-028261-3 / 9780130282613 |
| Zustand | Neuware |
| Haben Sie eine Frage zum Produkt? |
aus dem Bereich
