Students who can benefit from this course are programmers, developers, and software architects who will be involved in development of real-time systems using the Java programming language with the RTSJ extensions. Students should be fluent in the Java programming Language up to version 1.4 and should be have some familiarity with the nature of real-time programming, though extensive prior experience is not required.

• Design, write, and debug programs using Java 1.4
• Make use of inner classes, including anonymous inner classes
• Make use of the threading facilities of Java 1.4

• Control garbage collection induced jitter in thread release
• Create RealtimeThread objects, and use SchedulingParameters and PeriodicParameters to control thread behavior
• Control concurrent access to resources and describe priority inversion and the priority inheritance algorithm
• Understand the constraints that apply when using objects in non-heap memory, and issues that might arise when using library APIs in non-heap memory
• Use AsyncEvent, OneShotTimer, PeriodicTimer, and AsyncEventHandler objects to provide timed and asynchronous behavior
• Control the queueing of asynchronous events to limit the impact of out-of-spec events or handlers on other parts of a system
• Interrupt threads asynchronously and control their behavior under such conditions
• Use portals to access scoped memory
• Describe and use appropriately the scoped run loop, encapsulated method, handoff, timed algorithm, multi-scoped object, wedge thread pattern
• Use overrun handlers to limit the impact of out-of-spec threads on other parts of a system

Module 1 - Introduction to Real-Time Programming and the Sun Java Real-Time System

• Describe real-time programming, RTSJ and the Java Real-Time System
• Outline the relationships between Input/Output (I/O), resource contention, garbage collection, and real-time systems
• Outline memory types provided by RTSJ
• Describe fundamental real-time architectures
• Create a periodic real-time thread
• Measure the latency and jitter of a periodic real-time thread

Module 2 - Interacting With the Real World

• Design objects that give access to devices
• Design objects for use in a real-time system
• Describe actuators and sensors
• Describe ways of connecting hardware to computers
• Outline the use of raw or physical memory
• Select the appropriate techniques for handling external events

Module 3 - Creating the Timeline Executive

• Determine time constraints affecting tasks
• Determine a base frequency for a timeline
• Implement a timeline executive
• Determine and control frame costs
• Describe benefits and costs of the timeline architecture

Module 4 - Applying the Scoped Run Loop PatternModule

• Describe the impact of garbage collection on real-time response
• Describe how immortal and scoped memory spaces can avoid garbage collection effects and how objects in these spaces are recovered
• Describe scoped memory rules
• Recognize predictability issues with NHRT threads
• Configure and use initialization-time compilation
• Describe and implement the scoped run-loop pattern

Module 5 - Introduction to the Event-Driven ArchitectureModule

• Describe event-driven architecture
• List the advantages and disadvantages of event-driven architecture
• Describe how a single CPU is scheduled when multiple threads of differing priorities are runnable
• Describe real-time object design
• Design sound objects for a real-time system
• Schedule and dispatch in the RTSJ
• Write code for active components in RTSJ
• Add events to the simulation

Module 6 - Data Synchronization for Concurrent Tasks

• Design for data synchronization
• Implement data synchronization using the synchronized keyword
• Recognize critical sections and protect them with synchronized blocks
• Describe priority inversion and priority inversion avoidance techniques
• Describe the Java SE 5.0 concurrency utilities
• Describe the arbitration policies for multiple shared resources

Module 7 - Handling Asynchronous Events

• Describe asynchronous event handling
• Describe asynchronous event handlers and real-time threads
• Write code to handle a POSIX signal
• Create application-defined events
• Write code to issue an event under program control
• Describe aperiodic events and write code to control arrival time queue overflow behavior
• Describe sporadic events and write code to control arrival time queue overflow behavior

Module 8 - Scoped Memory Issues and Patterns

• Understand memory assignment rules
• Describe the single-parent rule and a threads active scope stack
• Describe memory areas and library APIs
• Describe and implement the encapsulated method pattern
• Describe the encapsulated method pattern

Module 9 - Component State Patterns

• Identify and differentiate component state and lifetimes
• Describe and implement the multi-scoped object pattern
• Describe and use the portal object of a ScopedMemory object
• Describe concurrency approaches suited to portals
• Describe and implement the wedge thread pattern
• Describe approaches for moving data between scopes
• Describe and implement the handoff pattern

Module 10 - Asynchronous Transfer of Control

• Describe the purpose of asynchronous transfer of control (ATC)
• Describe and use the ATC API
• Describe and implement the timed algorithm pattern
• Write interruptible code, and code that defers interrupts when necessary

Module 11 - Pipeline Architecture

• Describe the pipeline architecture
• Understand how synchronization between no-heap realtime threads and heap-aware threads can destroy realtime predictability
• Describe and use wait-free queues
• Understand key issues in the implementation of the pipeline architecture
• List benefits and costs of the pipeline architecture
• List benefits and costs of a distributed pipeline architecture