Roadmap

1
Roadmap

• Introduction
• Concurrent Programming
• Communication and Synchronization
• Completing the Java Model
• Overview of the RTSJ
• Memory Management
• Clocks and Time

• Scheduling and Schedulable Objects
• Asynchronous Events and Handlers
• Real-Time Threads
• Asynchronous Transfer of Control
• Resource Control
• Schedulability Analysis
• Conclusions

2
Conclusions

• Java has been generally immensely successful,
  however, it has yet to establish itself in the
  real-time and embedded markets
• The provision of real-time programming
  abstractions along with the promise of a
  predictable real-time Java Virtual Machine has
  the potential give Java a foothold
• However, there are still obstacles to be
  overcome the main challenges are
• Specification to produce a consistent and
  unambiguous Real-Time Specification for Java
  along with well-defined profiles for particular
  real-time application domains
• Implementation to generate efficient
  implementations of real-time virtual machines
  (both open source and propriety ones) for the
  full specification and the profiles
• Maintaining Momentum to stimulate evolution of
  the specification in a controlled and sustained
  manner to add new functionality and to address
  new architectures

3
Specification Challenges I

• Schedulable objects
• The RTSJ generalize real-time activities away
  from real-time threads towards the notion of
  schedulable objects ( real-time threads and
  asynchronous event handlers)
• Unfortunately, the operations that can be
  performed on a schedulable object are not
  consistently defined
• E.g. a schedulable object can create and enter
  into one or more scoped memory areas the methods
  for manipulating the resulting scoped memory
  stack can be found partly in RealtimeThread and
  partly in AsyncEventHandler
• Ideally, all operations associated with
  schedulable object should be defined either in
  the Schedulable interface or in the class
  defining the associated functionality (in this
  case the MemoryArea class)

4
Specification Challenges II

• Aperiodic and sporadic real-time threads
• AperiodicParameters and SporadicParameters can
  only successfully be used with asynchronous event
  handlers
• There is no notion of a release event for an
  aperiodic (or sporadic) thread and consequently
  it is difficult to see how an implementation can
  detect deadline miss or cost overrun
• The WaitForNextPeriod method
• Is only applicable to real-time threads with
  periodic release parameters
• Ideally, RealtimeThread should contain a
  waitForNextRelease method rather than a
  waitForNextPeriod method.
• A releaseRealtimeThread method would also be
  needed
• This approach would also solve the previous
  problem with aperiodic threads, and provide a
  level of consistency between asynchronous event
  handlers and real-time threads

5
Implementation Challenges

• Memory management
• The new memory management assignment rules must
  be checked by an implementation
• Whilst it is clear that static analysis of
  programs can eliminate many of the run-time
  checks, this requires special RTSJ-aware
  compilers or tools.
• The availability of these, along with efficient
  run-time implementations of the overall model,
  may well determine the eventual impact and take
  up of the RTSJ
• Asynchronous Transfer of Control
• It a major challenge to keep the ATC overheads in
  the JVM small and predictable, and to ensure that
  code not using this facility suffers minimal
  impact

6
Maintaining Momentum

• With any new technology, there is a tension
  between producing a stable standard base which
  users can depend on, and providing a dynamic
  product that continues to evolve and address new
  application needs
• Java has caught the imagination of the
  user-community, produced stable releases and
  maintained momentum for its evolution.
• If the RTSJ is to survive, it is important that
  it keeps pace with the more general Java
  development and also that it develops its own
  momentum.
• New standard schedulers
• Multiple schedulers
• Multiple criticalities
• Alternative interrupt handling models
• Real-time concurrency utilities
• Multiprocessor and distributed systems

7
Finally

• See http//www-course.cs.york.ac.uk/crt for
  course web page to help with exam preparation
• The exam will consist of three questions of which
  you have to answer two. You will be given
  summaries of all Java classes/interfaces used in
  the course
• One question will be on concurrent programming in
  Java, the other two will be on the RTSJ
• Typically a question has
• a general part asking you to explain some concept
  (bookwork)
• an unseen analysis or problem part, for example
• sketch some code to solve a particular problem or
  illustrate an algorithm
• analysis of a situation - e.g given some code
  with ATC components what happen when the ATC is
  fired
• illustrate the execution of some particular
  threads which use priority inheritance, or scoped
  memory