Real-Time%20Java*%20Programming - PowerPoint PPT Presentation

About This Presentation
Title:

Real-Time%20Java*%20Programming

Description:

http://www.cs.wustl.edu/~cdgill/RTSJ/COOTS01_M4.ppt. COOTS 2001 Tutorial M4 ... Provide an overview of real-time programming issues ... – PowerPoint PPT presentation

Number of Views:97
Avg rating:3.0/5.0
Slides: 68
Provided by: chris161
Category:

less

Transcript and Presenter's Notes

Title: Real-Time%20Java*%20Programming


1
Real-Time Java Programming
  • Christopher D. Gill
  • cdgill_at_cs.wustl.edu
  • Center for Distributed Object Computing
  • Department of Computer Science
  • Washington University, St. Louis
  • http//www.cs.wustl.edu/cdgill/RTSJ/COOTS01_M4.pp
    t
  • COOTS 2001 Tutorial M4
  • Monday, January 29, 2001

JavaTM is a registered trademark of Sun
Microsystems
2
Tutorial Objectives
Real-Time Java Programming
  • Provide an overview of real-time programming
    issues
  • Describe a motivating real-time programming
    example
  • An on-line stock market analysis tool
  • Exhibits canonical requirements and issues common
    to other classes of real-time systems
  • Show through incremental evolution of the example
  • How real-time programming issues can arise in a
    JavaTM (Java) programming environment
  • How features of the Real-Time Specification for
    JavaTM (RTSJ) can be applied to resolve these
    issues

3
Example Stock Market Analysis Tool
Real-Time Java Programming
  • Performs automated decision aiding for stock
    trading
  • Inputs arrive from real-time data streams
  • May run queries against on-line databases
  • Sends alerts to human operator and/or other
    automated systems with specific recommendations
    (e.g., sell, buy, limit order, short, call, put)
  • Timeliness of outputs is crucial
  • A functionally correct output sent too late can
    be worse than no output at all
  • Several application layers compete in real-time
    for system resources (i.e., CPU, memory)

4
Example Stock Market Analysis Tool
Real-Time Java Programming
  • Inputs arrive in real-time from data streams
  • Real-time (seconds) arrival of data events
  • One feed per market
  • May run queries on-line tables and databases
    differences in latency and latency jitter
  • Analyst reports
  • Market histories
  • Sector P/E tables

DataFeed
NYSEFeed
NasdaqFeed
DataStore
NasdaqStore
NYSEStore
ResearchStore
5
Example Stock Market Analysis Tool
Real-Time Java Programming
  • Sends recommendations as alerts to
  • Human operators
  • Automated systems
  • Documented quality of information is key
  • Decision path, triggers
  • Additional info, links
  • Timeliness constraints must also be met
  • Incremental addition, refinement is useful


Annotation
Alert
MarketOrder
Option
Call
Put
Buy
Sell
6
Example Stock Market Analysis Tool
Real-Time Java Programming
1
AnalysisPipeline
AnalysisFilter
1
SectorPE
PortfolioBalance
Composite
  • Input events pass through an analysis pipeline
  • Each analysis filter handles the data and news
    events in which it is interested, may search
    databases
  • May attach additional information to event and
    pass it on or consume it, and/or produce alerts
  • Composites combine other analysis filters

7
Example Roadmap
Real-Time Java Programming
AnalysisTool
AnalysisPipeline
AnalysisFilter
AlertList
SectorPEFilter
PortfolioBalanceFilter
CompositeFilter
Portfolio
Annotation
AnnotationList
DataFeedEvent
Alert
DataFeed
NasdaqDataFeed
MarketOrderAlert
OptionAlert
ResearchAnnotation
DataStore
NasdaqAnnotation
CallAlert
PutAlert
NasdaqStore
ResearchStore
BuyAlert
SellAlert
8
Example Stock Market Analysis Tool
Real-Time Java Programming
  • // Input Event Streams Code
  • public class DataFeedEvent
  • private float bid
  • private float ask
  • private float change
  • private long volume
  • // ...
  • public DataFeedEvent
  • (float b, float a,
  • float c, long v)
  • bid b ask a
  • change c volume v
  • public float getBid () return bid
  • public float getAsk () return ask
  • public float getChange () return change
  • public long getVolume () return volume
  • // ...

market order
90 seconds
data event
Market
data feed
9
Example Stock Market Analysis Tool
Real-Time Java Programming
  • // Input Event Streams Code, Continued
  • public abstract class DataFeed
  • public abstract DataFeedEvent
  • pullDataFeedEvent ()
  • public class NasdaqDataFeed extends DataFeed
  • // low-ish latency
  • public DataFeedEvent pullDataFeedEvent ()
  • return pullNasdaqDataFeedEvent ()
  • protected DataFeedEvent pullNasdaqDataFeedEvent
    ()
  • float bid 0.0F float ask 0.0F
  • float chg 0.0F long vol 0
  • // read data from socket, etc...
  • return new DataFeedEvent (bid, ask, chg,
    vol)
  • / ... Other DataFeed Classes ... /
  • Separate data feed for each market
  • Low latency to pull an event from a market data
    feed

10
Example Roadmap
Real-Time Java Programming
AnalysisTool
AnalysisPipeline
AnalysisFilter
AlertList
SectorPEFilter
PortfolioBalanceFilter
CompositeFilter
Portfolio
Annotation
AnnotationList
Alert
DataFeedEvent
DataFeed
NasdaqDataFeed
MarketOrderAlert
OptionAlert
ResearchAnnotation
DataStore
NasdaqAnnotation
CallAlert
PutAlert
NasdaqStore
ResearchStore
BuyAlert
SellAlert
11
Example Stock Market Analysis Tool
Real-Time Java Programming
  • // Alerts Code
  • public abstract class Annotation / ... /
  • public class AnnotationList
  • private java.util.Vector alist // list of
    annotations
  • public void addSorted (Annotation a) / ...
    /
  • public abstract class Alert
  • private AnnotationList anotes
  • private DataFeedEvent trigger
  • Alert (DataFeedEvent dfe)
  • anotes new AnnotationList ()
  • trigger dfe
  • public DataFeedEvent getTrigger ()
  • return trigger
  • public void addAnnotation (Annotation a)
  • anotes.addSorted (a)
  • public Annotation nextAnnotation (boolean
    restart)
  • / move to next annotation in list, return
    it ... /

Alert
trigger
annotations
12
Example Stock Market Analysis Tool
Real-Time Java Programming
  • // Alerts Code, Continued
  • public abstract class MarketOrderAlert extends
    Alert
  • private float orderPrice private String
    symbol
  • public MarketOrderAlert (DataFeedEvent dfe,
  • float op, String s)
  • super (dfe) orderPrice op symbol s
  • protected String getSymbol () return symbol
  • protected float getOrderPrice () return
    orderPrice
  • / ... Similarly, for OptionAlert and its
    derived classes ... /
  • public class BuyAlert extends MarketOrderAlert
  • public BuyAlert (DataFeedEvent dfe, float op,
  • String s) super (dfe, op,
    s)
  • float getBuyPrice () return
    super.getOrderPrice ()
  • / ... Similarly for SellAlert, Other Alert
    Classes ... /

13
Example Stock Market Analysis Tool
Real-Time Java Programming
  • // Data Store Query Code
  • public class NasdaqAnnotation extends Annotation
  • private float sectorAvgEarnings
  • private float sectorPERatio
  • public NasdaqAnnotation (float e, float r)
  • sectorAvgEarnings e sectorPERatio r
  • public float getSectorAvgEarnings ()
  • return sectorAvgEarnings
  • public float getSectorPERatio ()
  • return sectorPERatio
  • / ... Other Annotation Classes /
  • public class ResearchAnnotation
  • extends Annotation
  • // URLs for research reports
  • private java.util.Vector research_reports
  • public void addReport (java.net.URL u)
    reports.add (u)
  • public java.net.URL nextReport (boolean restart)
    / ... /
  • / ... Other Annotation Classes /

annotations
P/E
URL
sector analysis table
research reports
14
Example Roadmap
Real-Time Java Programming
AnalysisTool
AnalysisPipeline
AnalysisFilter
AlertList
SectorPEFilter
PortfolioBalanceFilter
CompositeFilter
Portfolio
Annotation
AnnotationList
Alert
DataFeedEvent
DataFeed
NasdaqDataFeed
MarketOrderAlert
OptionAlert
ResearchAnnotation
DataStore
NasdaqAnnotation
CallAlert
PutAlert
NasdaqStore
ResearchStore
BuyAlert
SellAlert
15
Example Stock Market Analysis Tool
Real-Time Java Programming
  • // Data Store Query Code, Continued
  • public abstract class DataStore
  • public abstract void
  • annotateAlert (Alert a)
  • public class NasdaqStore
  • extends DataStore
  • public float getPE
  • (String symbol, boolean sector)
  • / medium duration /
  • public float getEarnings
  • (String symbol) /.../
  • public void annotateAlert (Alert a)
  • addNasdaqAnnotation (a) / ... /
  • protected void addNasdaqAnnotation (Alert a)
  • float e 0.0F float r 0.0F
  • // compute PE and Earnings averages for the
    sector
  • a.addAnnotation (new NasdaqAnnotation (e,
    r))

annotations
P/E
sector analysis table
analysis query
Nasdaq market history database
16
Example Stock Market Analysis Tool
Real-Time Java Programming
  • // Data Store Query Code, Continued
  • public class ResearchStore extends DataStore
  • public void annotateAlert (Alert a)
  • addResearchAnnotation (a)
  • protected void
  • addResearchAnnotation (Alert a)
  • // long duration guided
  • // search for research
  • // reports, adding URLS
  • // for relevant analyst
  • // research reports to
  • // the annotation
  • // (ordered by relevance
  • // confidence factors)
  • // add annotation to alert
  • a.addAnnotation
  • (new ResearchAnnotation ())

annotations
URL
report index
search agent
hyper-linked research reports
17
Example Roadmap
Real-Time Java Programming
AnalysisTool
AnalysisPipeline
AnalysisFilter
AlertList
SectorPEFilter
PortfolioBalanceFilter
CompositeFilter
Portfolio
Annotation
AnnotationList
Alert
DataFeedEvent
DataFeed
NasdaqDataFeed
MarketOrderAlert
OptionAlert
ResearchAnnotation
DataStore
NasdaqAnnotation
CallAlert
PutAlert
NasdaqStore
ResearchStore
BuyAlert
SellAlert
18
Example Stock Market Analysis Tool
Real-Time Java Programming
// Analysis Filter Code public class
AlertList // Alerts raised so far private
java.util.Vector alerts public void addAlert
(Alert a) alerts.add (a) public Alert
nextReport (boolean restart) / ... /
public void reset () alerts.clear
() public abstract class AnalysisFilter
public abstract boolean handleDataEvent
(DataFeedEvent d, AlertList a) // ...
alert list
Analysis filter
data event
data feed
19
Example Stock Market Analysis Tool
Real-Time Java Programming
// Analysis Filter Code, Continued public class
CompositeFilter extends AnalysisFilter //
the composed filters private java.util.Vector
filters public void addFilter (AnalysisFilter
af) filters.add (af) public boolean
handleDataEvent (DataFeedEvent dfe, AlertList
al) boolean consumed false for (int i
0 !consumed i lt filters.size ()
i) consumed ((AnalysisFilter)
filters.get(i)).handleDataEvent (dfe, al)
return consumed
data event
Composite Filter
20
Example Stock Market Analysis Tool
Real-Time Java Programming
// Analysis Filter Code, Continued public class
SectorPEFilter extends AnalysisFilter private
NasdaqStore nh private ResearchStore rr
public boolean handleDataEvent (DataFeedEvent
dfe, AlertList al) boolean consumed false
// See if event is of interest, // compare
its PE to the avg for // its sector, look at
existing // alerts, possibly generate //
new ones annotated with // relevant research
reports rr.annotateAlert (alert) return
consumed
data event
Sector P/E Filter
sector analysis table
research reports
21
Example Stock Market Analysis Tool
Real-Time Java Programming
// Analysis Filter Code, Continued public class
Portfolio public float projectRiskDelta
(DataFeedEvent d) /.../ public float
projectGainDelta (DataFeedEvent d)
/.../ public class PortfolioBalanceFilter
extends AnalysisFilter protected Portfolio p
public boolean handleDataEvent
(DataFeedEvent dfe, AlertList al)
boolean consumed false // issue/remove
alerts based on // data feed event and
projected // risk/gain to portfolio goals
return consumed
alert list
data event
Portfolio Balance Filter
risk profile
goals
22
Example Stock Market Analysis Tool
Real-Time Java Programming
// Analysis Pipeline Code public class
AnalysisPipeline private CompositeFilter cf
private DataFeed df private AlertList
al public void addFilter (AnalysisFilter
af) cf.addFilter (af) public void
sendAlerts () / Send all alerts,
reset list / public void run () for ()
DataFeedEvent dfe df.pullDataFeedEvent
() cf.handleDataEvent (dfe, al) //
possibly long latency sendAlerts () /
latency depends on alert count /
alert list
send alerts
data event
Operator
Filter Pipeline
23
Example Stock Market Analysis Tool
Real-Time Java Programming
  • // Analysis Tool Code
  • public class AnalysisTool
  • public static void main
  • (String args)
  • AnalysisPipeline ap
  • new AnalysisPipeline ()
  • ap.addFilter
  • (new PortfolioBalanceFilter ())
  • ap.addFilter
  • (new SectorPEFilter ())
  • ap.run () // run the pipeline

alert list
send alerts
market order
data event
data feed
Market
24
Review Roadmap
Real-Time Java Programming
AnalysisTool
AnalysisPipeline
AnalysisFilter
AlertList
SectorPEFilter
PortfolioBalanceFilter
CompositeFilter
Portfolio
Annotation
DataFeedEvent
AnnotationList
DataFeed
Alert
NasdaqDataFeed
MarketOrderAlert
OptionAlert
ResearchAnnotation
DataStore
NasdaqAnnotation
CallAlert
PutAlert
NasdaqStore
ResearchStore
BuyAlert
SellAlert
25
Example Time Scales
Real-Time Java Programming
AnalysisTool
AnalysisPipeline
AnalysisFilter
AlertList
SectorPEFilter
PortfolioBalanceFilter
CompositeFilter
Portfolio
DataFeedEvent
AnnotationList
Annotation
Alert
DataFeed
NasdaqDataFeed
MarketOrderAlert
OptionAlert
ResearchAnnotation
DataStore
NasdaqAnnotation
CallAlert
PutAlert
ResearchStore
NasdaqStore
BuyAlert
SellAlert
26
Java Real-Time Issues
Real-Time Java Programming
  • Existing JavaTM facilities take us several
    important steps in the direction of real-time
    application behavior
  • Threads
  • Liveness (what and how much happens)
  • Threads are used to decouple activity time scales
  • Synchronization
  • Safety (nothing unsafe happens)
  • Careful application of monitors can preserve
    liveness
  • Well start in a bottom-up liveness-first design
    mode, using thread adapters (Lea, Concurrent
    Programming in JavaTM)

27
Java Threading Issues
Real-Time Java Programming
  • Separate threads of execution are useful to
    improve liveness by doing the following
    concurrently
  • Getting and handling market data events
  • Medium latency
  • Searching stores to add annotations
  • High latency
  • Issuing alerts
  • Low latency

// Analysis Tool Code, Revisited // Separate
high latency activity public class
StoreThreadAdapter implements Runnable private
DataStore store private Alert alert public
StoreThreadAdapter (DataStore ds, Alert a)
store ds alert a public void run ()
store.annotateAlert (alert)
28
Java Threading Issues
Real-Time Java Programming
// Analysis Filter Code, Revisited public class
SectorPEFilter extends AnalysisFilter private
NasdaqStore nh private ResearchStore rr
public boolean handleDataEvent (DataFeedEvent
dfe, AlertList
al) boolean consumed false // possibly
generate new alerts ... // ... annotated with
relevant research reports... Thread
annotationThread new Thread (new
StoreThreadAdapter (rr, alert))
annotationThread.setPriority (Thread.MIN_PRIORITY)
annotationThread.start () return
consumed
29
Java Threading Issues
Real-Time Java Programming
  • // Analysis Tool Code, Revisited
  • // Separate low latency activity
  • public class AlertThreadAdapter implements
    Runnable
  • private AnalysisPipeline pipeline
  • private long timeout
  • public AlertThreadAdapter (AnalysisPipeline ap,
    long t)
  • pipeline ap timeout t
  • public void run ()
  • for () // in reality, could use more
    sophisticated
  • // loop control e.g., wait,
    notifyAll, etc.
  • try Thread.sleep (timeout)
    pipeline.sendAlerts ()
  • catch (java.lang.InterruptedException e)
    / ... /

30
Java Threading Issues
Real-Time Java Programming
// Analysis Pipeline Code, Revisited // Separate
medium latency activity public class
AnalysisPipeline private CompositeFilter cf //
filters in the pipeline private DataFeed df
// paced data event feed private AlertList
al // list of alerts public void
addFilter (AnalysisFilter af) cf.addFilter
(af) public void sendAlerts () / Send
all alerts in the list, reset alert list /
public void run () for ()
DataFeedEvent dfe df.pullDataFeedEvent ()
cf.handleDataEvent (dfe, al) // possibly long
latency
31
Java Threading Issues
Real-Time Java Programming
  • // Analysis Tool Code, Revisited
  • public class AnalysisTool
  • public static void main (String args)
  • AnalysisPipeline ap new AnalysisPipeline
    ()
  • ap.addFilter (new PortfolioBalanceFilter ())
  • ap.addFilter (new SectorPEFilter ())
  • Thread alertThread
  • new Thread (new AlertThreadAdapter (ap,
    1000))
  • alertThread.setPriority (Thread.MAX_PRIORITY)
  • alertThread.start ()
  • ap.run () // run pipeline in the current
    thread

32
Java Synchronization Issues
Real-Time Java Programming
  • But, before we go further addressing liveness
    issues, need to address concurrency safety
  • Shift to top-down safety-first design mode, using
    fine-grain synchronization (Lea, Concurrent
    Programming in JavaTM)
  • Well combine two styles block and method
    synchronization

// Concurrency safety additions // using method
synchronization public abstract class Alert
/ ... / public synchronized void
addAnnotation (Annotation a) / .../
public synchronized Annotation
nextAnnotation (boolean restart)
/.../
33
Java Synchronization Issues
Real-Time Java Programming
  • // Concurrency safety additions using block
    synchronization
  • public class AnalysisPipeline
  • / ... /
  • protected void sendAlerts ()
  • synchronized (al)
  • / Send all the alerts in the list, reset
    alert list /
  • public void run ()
  • for ()
  • DataFeedEvent dfe df.pullDataFeedEvent
    ()
  • // spawns separate threads for long latency
    activities
  • cf.handleDataEvent (dfe, al)

34
Java Synchronization Issues
Real-Time Java Programming
  • // Concurrency safety additions using block
    synchronization
  • public class PortfolioBalanceFilter extends
    AnalysisFilter
  • protected Portfolio p
  • public boolean handleDataEvent (DataFeedEvent
    dfe,
  • AlertList al)
  • boolean consumed false
  • synchronized (al)
  • / add alerts based on data feed event
    and the
  • projected risk and gain changes to
    portfolio /
  • return consumed

35
Java Synchronization Issues
Real-Time Java Programming
  • // Concurrency safety additions using block
    synchronization
  • public class SectorPEFilter extends
    AnalysisFilter
  • private NasdaqStore nh
  • private ResearchStore rr
  • public boolean handleDataEvent (DataFeedEvent
    dfe,
  • AlertList al)
  • boolean consumed false
  • / compare PE to the average for its sector
    /
  • synchronized (al) / look at existing
    alerts/
  • / possibly generate new ones, annotated in a
    separate
  • thread with relevant research reports...
    /
  • synchronized (al) / add any new alerts to
    the list /
  • return consumed

36
Threads and Synch Points
Real-Time Java Programming
AnalysisTool
AnalysisPipeline
AnalysisFilter
AlertList
SectorPEFilter
PortfolioBalanceFilter
CompositeFilter
Portfolio
Annotation
DataFeedEvent
AnnotationList
DataFeed
Alert
NasdaqDataFeed
MarketOrderAlert
OptionAlert
ResearchAnnotation
DataStore
NasdaqAnnotation
CallAlert
PutAlert
NasdaqStore
ResearchStore
BuyAlert
SellAlert
37
The RTSJ and Real-Time Issues
Real-Time Java Programming
  • Threads (revisited)
  • Release characteristics failures
  • Scheduling
  • Synchronization (revisited)
  • Time and timers
  • Asynchronous event handling
  • Memory management
  • Asynchronous transfer of control
  • Exceptions
  • System-level options

38
RT Issues Threads
Real-Time Java Programming
  • Multi-threading is useful to decouple different
    activities
  • Active objects, request queues, synch/asynch
  • However, work in different threads competes for
    CPU time and memory resources
  • Must ensure resource usage by non-critical
    activities does not interfere with needs of
    critical activities

39
RTSJ Threading Issues
Real-Time Java Programming
  • Threads compete for time on the CPU
  • Some activities are higher priority than others
  • Java thread priorities take us a step in the
    right direction, but
  • garbage collector thread priority and preemption
    issues
  • Non-RT priority uniqueness is not ensured

// Solution real-time threads AlertThreadAdapter
alertAdapter new AlertThreadAdapter (ap,
1000) javax.realtime.RealtimeThread
alertThread new javax.realtime.RealtimeThread
(alertAdapter) javax.realtime.RealtimeThread
pipelineThread new javax.realtime.Realtime
Thread (ap) alertThread.start
() pipelineThread.start ()
40
RTSJ Threading Issues
Real-Time Java Programming
  • // To run the pipeline in a Realtime thread, it
    could just implement Runnable for
    AnalysisPipeline this is not very invasive so
    well skip writing a separate adapter
  • public class AnalysisPipeline
  • / ... /
  • protected void sendAlerts ()
  • synchronized (al)
  • / Send all the alerts in the list, reset
    alert list /
  • public void run ()
  • for ()
  • DataFeedEvent dfe df.pullDataFeedEvent
    ()
  • // spawns separate threads for long latency
    activities
  • cf.handleDataEvent (dfe, al)

implements Runnable
41
RT Issues Release Characteristics
Real-Time Java Programming
  • To know whether threads will interfere, need to
    characterize their temporal behavior
  • Need descriptors with key temporal attributes
  • E.g., execution cost, deadline
  • Can abstract out separate descriptors for
    canonical behavioral classes
  • I.e., periodic, aperiodic, sporadic

Time
42
RTSJ Release Characteristics Issues
Real-Time Java Programming
  • While threading allows priority partitioning,
    specific information and/or constraints on
    threads are needed
  • Must ensure sufficient resources are available
    and correctly managed for desired behavior


javax.realtime.RelativeTime cost new
javax.realtime.RelativeTime (100,
0) javax.realtime.RelativeTime period new
javax.realtime.RelativeTime (1000,
0) javax.realtime.PeriodicParameters pp
new javax.realtime.PeriodicParameters ( null,
// start immediately,
period, cost, null, //
deadline period end
null, null)
alertThread.setReleaseParameters
(pp) alertThread.start ()
43
RTSJ Release Characteristics Issues
Real-Time Java Programming
  • // Analysis Tool Code, Revisited
  • public class AlertThreadAdapter implements
    javax.realtime.Schedulable
  • / we can should get/set release parameters,
    scheduling
  • parameters, memory parameters, ... /
  • public void run ()
  • addToFeasibility ()
  • javax.realtime.RealtimeThread t
  • (javax.realtime.RealtimeThread)
    Thread.currentThread ()
  • for ()
  • t.waitForNextPeriod () // respect
    advertised cost, period times
  • pipeline.sendAlerts ()

44
RT Issues Release Failures
Real-Time Java Programming
  • Release characteristics advertise how threads are
    projected to behave
  • However, differences between projected and actual
    behavior can lead to unexpected failures
  • Need to be able to detect (and if possible
    handle) release failures
  • Cost overruns
  • Deadline misses

Time
45
RTSJ Release Failure Issues
Real-Time Java Programming
public class CostOverrunEventHandler extends
javax.realtime.AsyncEventHandler public void
handleAsyncEvent() / ... / public class
DeadlineMissEventHandler extends
javax.realtime.AsyncEventHandler public void
handleAsyncEvent() / ... / javax.realtime.Pe
riodicParameters pp new javax.realtime.Periodic
Parameters (null, // start immediately,
period,
cost, null, // deadline period end
new
CostOverrunEventHandler (), new
DeadlineMissEventHandler ()) alertThread.setRele
aseParameters (pp) alertAdapter.setReleaseParamet
ers (pp) alertThread.start ()
  • Differences between projected and expected
    behavior result in release failures
  • Execution overruns
  • Deadline misses
  • Can install a handler for each release
    characteristics instance to at least record, and
    possibly correct, failures

46
RT Issues Scheduling
Real-Time Java Programming
  • Priorities
  • Need sufficient unique priority levels
  • Preemptive scheduling
  • Need well defined and appropriate semantics
  • Fairness among threads is not usually a Real-Time
    concern (FIFO vs. RR)
  • But may be useful
  • Feasibility
  • Admission control, certification/testing

runnable
scheduler
blocked
47
RTSJ Scheduling Issues
Real-Time Java Programming
// Analysis Tool Code, Revisited javax.realtime.Pr
iorityScheduler psched (javax.realtime.Priori
tyScheduler) javax.realtime.Scheduler.getDefault
Scheduler () javax.realtime.PriorityParameters
high new javax.realtime.PriorityParameters
(psched.getMaxPriority ()) javax.realtime.Priorit
yParameters med new javax.realtime.PriorityPa
rameters (psched.getNormPriority ()) try
alertThread.setSchedulingParameters (high)
pipelineThread. setSchedulingParameters (med)
catch (java.lang.IllegalArgumentException e) /
... / alertThread.start () pipelineThread.start
()
  • Release characteristics give control over threads
  • Scheduling addresses how to manage those threads
  • Priority, preemption
  • Feasibility

48
RTSJ Scheduling Issues
Real-Time Java Programming
// Analysis Tool Code, Revisited public class
StoreThreadAdapter implements javax.realtime.Sched
ulable / ... / public void run ()
javax.realtime.PriorityScheduler psched
(javax.realtime.PriorityScheduler)
javax.realtime.Scheduler.getDefaultScheduler ()
try javax.realtime.PriorityParameters pp
new javax.realtime.PriorityParameters
(psched.getMinPriority ())
setSchedulingParameters (pp)
javax.realtime.RealtimeThread t
(javax.realtime.RealtimeThread)
Thread.currentThread ()
t.setSchedulingParameters (pp) catch
(java.lang.IllegalArgumentException e) / ...
/ store.annotateAlert (alert)
49
RT Issues Synchronization
Real-Time Java Programming
  • Risk of unbounded priority inversions
  • Canonical high, low, middle scenario
  • Priorities can uncover or exacerbate bad
    executions of existing race conditions
  • Horstmann Cornell, Core Java 2
  • Need well defined thread and locking semantics

waiting (blocked) on a condition variable
synchronized block
high
low
middle
priority key
50
RTSJ Synchronization Issues
Real-Time Java Programming
  • Real-time threads at different priorities share
    resources
  • However, this presents new real-time issues
  • Priority inversions
  • Need additional mechanisms to ensure
    priority-safe sharing
  • Monitor Control
  • Methods wait and notifyAll still work (avoid
    notify unless absolutely sure OK)
  • But, add overhead
  • Non-blocking R/W queues thread glue

// Solution Monitor Control javax.realtime.Monito
rControl.setMonitorControl (new
javax.realtime.PriorityInheritance ()) //
Solution wait-free queues public class
StoreThreadAdapter implements
javax.realtime.Schedulable / ... / private
javax.realtime.WaitFreeDequeue dequeue / ...
/
51
RT Issues Time and Timers
Real-Time Java Programming
  • Time resolution needed
  • Hours down to nsec
  • Relative Time
  • Since start of thread
  • Since last period
  • Absolute time
  • Common temporal reference, e.g., UTC
  • Occurrences over time
  • Absolute clock
  • Timer mechanisms
  • One-shot, periodic

52
RTSJ Time and Timer Issues
Real-Time Java Programming
// A needed solution watchdog timer public class
StoreTimeoutHandler extends javax.realtime.Async
EventHandler public void handleAsyncEvent() /
... / public class StoreThreadAdapter
implements javax.realtime.Schedulable public
void run () // ... set up thread priorities
... long m 60000 // one minute new
javax.realtime.OneShotTimer (new
javax.realtime.RelativeTime (m,0), new
StoreTimeoutHandler ()) store.annotateAlert
(alert) // ...
  • Threads offer a clean programming model
  • However, many real-time systems benefit from
    asynchronous behavior
  • Also, pacing is an effective/alternative way to
    reduce resource contention and improve resource
    utilization

53
RT Issues Asynch Event Handling
Real-Time Java Programming
  • Threads allow synchronous programming styles
  • Sometimes, asynchronous styles are more
    appropriate
  • Real-world timing issues
  • Decoupling processing

handler method
handler
  • Events-and-handlers model provides mechanisms
    for
  • Synchronous gt threads
  • Asynchronous gt timers
  • Mixed gt half-synch / half-asynch pattern

54
RTSJ Asynch Event Handling Issues
Real-Time Java Programming
  • We saw an earlier example of a one-shot timer
    used to determine when a long-running thread had
    been gone too long
  • Could also use a periodic timer to re-implement
    the high priority alert transmission code

// Another way to implement periodicity public
class TransmitTimeoutHandler extends
javax.realtime.AsyncEventHandler public void
handleAsyncEvent () /.../ new
javax.realtime.PeriodicTimer (null,
new javax.realtime.RelativeTime
(1000, 0), new TransmitTimeoutHandler ())
55
RT Issues Memory Management
Real-Time Java Programming
  • Bounded allocation times
  • Managed vs. raw access
  • Trade-off in control vs. responsibility
  • Memory lifetimes
  • Program, local scope
  • Resource use descriptors
  • Application/manager interactions
  • Priority inversions
  • Memory contention
  • Safety and liveness

memory manager
56
RTSJ Memory Management Issues
Real-Time Java Programming
  • Realtime threads get higher priority than the
    garbage collector
  • However, there is still a possibility of priority
    inversion
  • If GC is collecting the heap, it must reach a
    safe state before RT threads can use the heap
  • NoHeapRealtime threads avoid this

// Solution separate memory areas and // no-heap
real-time threads javax.realtime.MemoryArea ma
new javax.realtime.LTMemory (initSize,
maxSize) javax.realtime.NoHeap
RealtimeThread alertThread new
javax.realtime.NoHeapRealtimeThread (sp, //
sched params rp, // release params mp, //
memory params ma, // memory area pg, //
processing group alertAdapter)
57
RTSJ Memory Management Issues
Real-Time Java Programming
  • Scoped memory is key for no-heap real-time
    threads
  • Other kinds of MemoryArea
  • Immortal Memory can improve GC performance
  • Physical Memory
  • Immortal, scoped, raw
  • Factory

// Immortal Memory is a Singleton javax.realtime.
MemoryArea im javax.realtime.ImmortalMemory.in
stance () im.enter (this) // this must be
Runnable // allocates memory
on // the ImmortalMemory area
// until another memory
// area is entered, or
// the Runnable run () // call
exits and enter () // returns
58
RT Issues Asynch Transfer of Control
Real-Time Java Programming
  • Want to provide real-time behavior for
    long-running synchronous activities (e.g.,
    searches)
  • For fault-tolerance, some activities may need to
    be halted immediately
  • However, standard threading and interrupt
    semantics can produce undefined/deadlock behavior
    in many common use-cases
  • ATC refines semantics

Publisher
Shipper
Exhaustive Lookup
searching
59
RTSJ ATC Issues
Real-Time Java Programming
  • Even with the one-shot timer, the long
    running-thread must be reigned in somehow
  • Deprecated Thread stop, suspend calls are unsafe
  • ATC defers exception as pending in synchronized
    methods avoids problem w/deprecated Thread stop
    method

// Data Store Query Code, Revisited public
abstract class DataStore / ... / public
abstract void annotateAlert (Alert a) throws
javax.realtime.AsynchronouslyInterruptedException
// In timer handling for //
StoreThreadAdapter run () t.interrupt ()
60
RT Issues Exceptions
Real-Time Java Programming
  • Additional special-purpose exceptions w/ standard
    semantics for
  • Memory management
  • Synchronization
  • System resource management
  • Special semantics for ATC
  • When to throw (or not)
  • Deferred propagation semantics (exception
    tunneling) - safety
  • Nesting/replacement

61
RTSJ Exceptions Issues
Real-Time Java Programming
  • Semantics for AIE are different than others
  • deferred in pending state until inside a safe
    scope, where it will be thrown
  • Other new exceptions deal primarily with
    incompatibilities of memory areas
  • Trying to assign a reference to scoped memory to
    a variable in immortal or heap memory
  • Setting up a WaitFreeQueue, exception
    propagation, etc. in an incompatible memory area
  • Raw memory allocation errors (offset, size)
  • Raw memory access errors

62
RT Issues System-level Options
Real-Time Java Programming
  • Although strict layering is often desirable,
    platform-specific issues tend to peek through
  • E.g., signals, schedulers
  • Collecting the system-wide constants, methods,
    etc. under one or more classes reduces pollution
    and improves the programming model
  • May add points of configurability (I.e., various
    system-wide managers)

SIGKILL
SIGINT
SIGABRT
getManager
security manager
setManager
63
RTSJ System-level Options Issues
Real-Time Java Programming
  • javax.realtime.RealtimeSystem is analogous to
    java.lang.System
  • Gives access to real-time system properties
  • E.g., concurrent locks, endian properties
  • Allows a RealtimeSecurity manager to be set as
    the system security manager
  • Gives access to the current garbage collector
  • PosixSignalHandler
  • Required on platforms that provide POSIX signals
  • Thus, can only be used portably among those
    implementations

64
Review Time Scales
Real-Time Java Programming
AnalysisTool
AnalysisPipeline
AnalysisFilter
AlertList
SectorPEFilter
PortfolioBalanceFilter
CompositeFilter
Portfolio
DataFeedEvent
AnnotationList
Annotation
Alert
DataFeed
NasdaqDataFeed
MarketOrderAlert
OptionAlert
ResearchAnnotation
DataStore
NasdaqAnnotation
CallAlert
PutAlert
ResearchStore
NasdaqStore
BuyAlert
SellAlert
65
Review Java, RTSJ, Real-Time Issues
Real-Time Java Programming
  • Threads (Java, revisited in RTSJ)
  • Release characteristics failures
  • Scheduling
  • Synchronization (Java, revisited in RTSJ)
  • Time and timers
  • Asynchronous event handling
  • Memory management
  • Asynchronous transfer of control
  • Exceptions
  • System-level options

66
Review Java and RTSJ
Real-Time Java Programming
AnalysisTool
duration timer
AnalysisPipeline
AnalysisFilter
over-run handler
feasibile
AlertList
high priority
real-time
SectorPEFilter
PortfolioBalanceFilter
CompositeFilter
Portfolio
periodic
no heap
scoped memory
Annotation
DataFeedEvent
AnnotationList
DataFeed
Alert
priority inheritance
NasdaqDataFeed
MarketOrderAlert
OptionAlert
ResearchAnnotation
DataStore
NasdaqAnnotation
aynch transfer of control
CallAlert
PutAlert
NasdaqStore
ResearchStore
BuyAlert
SellAlert
67
Concluding Remarks
Real-Time Java Programming
  • The RTSJ extends and/or refines existing Java
    semantics to address issues of real-time concern
  • Priority control, memory management, release
    parameters, feasibility,
  • However, the RTSJ largely stays within the
    existing programming model
  • Some new idioms to master, but much is preserved
  • ATC in particular illustrates the trade-offs
  • Stay tuned, more evolution is on the horizon
  • Reference implementations and benchmarking
  • New specification efforts, e.g., the DRTSJ (JSR
    50)
Write a Comment
User Comments (0)
About PowerShow.com