1. Dynamic Mapping of Activation Trees Thesis Proposal January 29, 1998
Peter A. Dinda
Committee
David O’Hallaron (chair)
Thomas Gross
Peter Steenkiste
Jaspal Subhlok
David Bakken (BBN)

2. Outline Responsive interactive applications
Best effort real-time service
Dynamic mapping problem
History-based prediction approach
Other approaches and related work
Current results on simplified problem
Proposed thesis work
Responsive interactive applications
Best effort real-time service to bound execution time of activation trees
Local history-based prediction of application and environment to dynamically map nodes of activation trees to different hosts in order to achieve bounds
Compelling preliminary results on simplified problem
Extend approach to full problem

3. Interactive Application Model
Feedback
Message
Handler
Message
mouse_click()
Aperiodic
User Action
Activation tree dynamically unfolds - we don’t know its structure until we are finished executing the message handler
Feedback helps determine the user’s next action.
Make it clear that the tree is sequentially executed, and dynamically unfolds
Activation tree

4. Acoustic Room Modeling
impulse responses
Physical
Simulation
of Wave Eqn
Speakers
Modify model
Frequency
response plots
It’s a design application
keep listener position steady and manipulate room to equalize the frequency response
It’s a virtualized reality application
listener can wander around space listening
Split into two parts - freq response plots, and then the audio output
Make feedback loop point on freq resp.

5. Other Applications Image editing Computer aided design
The Adobe Photoshop universe
Computer aided design
Quake design optimization (Malcevic-97)
Computational steering
CUMULUS (Geist-96), CAVE (Disz-95), ...
Collaboration
Collaborative Planning (Zinky-DUTC-95), ...
Securities trading
(Wolfe-Lau-95)
Games
DIS (DIS-94)
I have spent some time thinking about image editing
vast images - should have slide to make this clear
Quake DO - can think of ARM as a model problem for it
Securities trading of basket of goods, or multiple exchange arbitrage
Games are relatively clear

6. Responsiveness Timely feedback to individual user actions
Bound: response time £ tmax
Jitter bound and resource usage hint
Bound: response time ³ tmin
Example: image editor drawing tool
Image editing drawing: needs to befast, non-jittery, but also doesn’t have to be faster than the user can perceive (or the monitor can repaint)
Image editing - free hand drawing is at perceptual limit, operation on large image is not, but still useful to bound it.
ARM - ideally want immediate audible response to movement/change. Realistically it will take longer. As compute rates increase the acceptable wait time may decline.
“No surprises”
tmin for resource conservation - system will probably provide itself some slack in meeting the tmax deadline, tmin gives it a hint as to how much slack it should
tmin is also a hint to the USER - you will wait at least this long, but no longer than this
As opposed to generalized utility functions (time constraint functions)

7. A Best Effort Real-time Service
MAP procedure() IN [tmin, tmax]
Execute the activation tree rooted at procedure() so that tmin£texec£tmax
No guarantees
Responsiveness spec: bounds [tmin,tmax]
Performance metric: fraction of trees that meet their bounds
Programmer responsibility is limited - no specification of tree under procedure(), or, etc, etc.
Bounds need only be known at the run-time call to MAP
Programmer can, of course, find out if bounds were met for a specific call, and can also interrogate the service about how it is doing
Have separate slide to show where this service would reside in a distributed object system
Soft rt - deterministic guarantees, statistical guarantees
BERT also could be called NON-DETERMINISTIC SOFT REAL-TIME
NOT A CONTRADICTION IN TERMS
BEST EFFORT IS NOT NO EFFORT
The service is aware of and attempts to meet your real-time requirements for task execution time, but can make no guarantees that they will be met.

8. Machine Model Hosts on a LAN Remote execution facility
No centralized or coordinated scheduling, or reservations
Other unrelated traffic exists
We are only a user
Remote execution facility
Can execute any procedure on any host
RPC, DSM, DCE, CORBA, DCOM, ...
Measurable - at least a good real-time clock exists (<1ms)
The point here is that we want to provide this service on a common sort of environment - the kind of environment most people have access too.
The point is the lack of assumptions.
We use the remote execution facility and the measurement capability to
Good real-time means better than typical Unix gettimeofday() - most res already haver 1ms or lower overheads and most unix gettimeofdays() only give ms accuracy - better ex is alpha or intel cycle counters
Should be clear that using the remote execution facility may mean the programmer has to rewrite. However, this is becoming more common with e.g., CORBA, DCOM, Java, so it’s not completely unreasonable to expect this. Probably not a huge deal
I like the idea of piggybacking on existing glue code, like rpc and do stubs

9. Execution Model
[tmin,tmax]
Dynamically map nodes of the unfolding activation tree to the hosts
At each procedure call, choose which host is best suited to execute the call in order to meet the bounds on the tree
Another way to look at this is that we allow the thread of execution to migrate at procedure call points

10. Dynamic Mapping Problem
How do we map the nodes of the trees to the hosts so that the fraction of trees that satisfy their bounds is maximized?
We are given a sequence of aperiodically arriving activation trees, where each tree has associated bounds [tmin,tmax] and its structure becomes known only as we sequentially execute it.
We can execute each node on any one of a group of uncoordinated but measurable hosts interconnected with a measurable network. The hosts and network can both carry unrelated computation and communication traffic.
How do we map the nodes of the trees to the hosts so that the fraction of trees that execute within their desired bounds is maximized?

11. Aspects of My Approach History-based prediction
Decomposition of bounds
Adaptation of mapping algorithms during tree traversal

12. History-based Prediction
foo()
[tmin,tmax]
time, duration, bounds
...
time, duration, bounds
[t’min,t’max]
time, duration, bounds H0
... H1
bar()
time, duration, bounds
time, duration, bounds
...
foo() is executing on H0
and calls bar(), which can be mapped to H0, H1, or H2
time, duration, bounds H2
H0 has a local history of execution times of bar() on each of the other hosts
For each host, H0 predicts whether it can meet the bounds, based on past local history and then chooses one where it is possible
Execution times include both communication for remote call and the actual computation
Cost model fits in here - how to choose “one where it it is possible” if possible on several hosts - “cheapest”

13. Decomposition of Bounds
foo()
[tmin,tmax]
partially executed, known
[t’min,t’max]?
bar()
unexecuted, known
unexecuted, unknown
unexecuted, unknown
Choice of [t’min,t’max] for bar() depends on unvisited portion of the tree
Collect history of what fraction of time spent in foo() subtree was spent in bar() subtree
Choose fraction of bounds to give to bar() based on that history and current time
Note that this is a ONE POSSIBLE SOLUTION.
THE POINT is that we want to divide the deadline on a subtree among its children according to the past history.

14. Adaptation of Mapping Algorithms During Tree Traversal
Tune strategy to how deep we are in the tree and how far along in the traversal
Explore more aggresively early in the traversal, when the effect of a bad decision is easiest to overcome
Find interesting new hosts
Spend less time making mapping decision deep in the tree
More likely to remain on single host

15. Thesis Statement
Dynamic mapping of activation trees using history-based prediction and traversal-based adaptation is an effective way to build a best effort real-time service for responsive interactive applications running in conventional environments.

16. Other Approaches Distributed soft real-time system
System modifications
Dynamic load balancing system
Different goals
Even distribution of load (OS-centric)
Minimization of exec times (app-centric)
Resource reservation system
Shared measurement system
Information level and dissemination
Distributed soft real-time
require system modifications - limits scope
mediation versus competition
system-centric vs application centric
Dynamic load balancing
Different goals as above
Resource reservations
system modifications
translation of app requirements to resources may be hard
Shared measurement
“load monitor”
delayed information, granularity, etc.
lower level information harder to use

17. Current Results Load trace collection and analysis
Algorithms and evaluation for simplified dynamic mapping problem

18. Algorithms and Evaluation for Simplified Problem
Map only leaf nodes
Ignore communication
for I=1 to N do MAP leaf_procedure() IN [tmin,tmax] end
Looked at cases where leaf_procedure always does some amount of work and cases where it varies according to different distributions.

19. RangeCounter(W): A Near Optimal Algorithm
Each host has a quality level Q and a window of the last W execution times (W is small)
Choose host with highest quality level, and age quality levels of all hosts: Q=Q-1
If bounds are met, increase host’s quality level by the inverse of our confidence in it:
If bounds are not met, reduce host’s quality level by half: Q=Q/2

20. Load Trace-based Simulation
Exec time computed from load trace using a simple, validated model
Mapping algorithms are given bounds, select a host, then are told exec time
Simulator computes performance of
Algorithm under test
Optimal (precognizant) algorithm
Random mapping
Individual host mappings

21. Scope of Evaluation 9 mapping algorithms 6 different groups of hosts
Chosen from 39 hosts
1 week, 1 Hz load trace from each host
648 different cases
Combinations of nominal time and bounds
100,000 calls for each case
I will show group of 8 PSC hosts, four mean load of ~1, four with mean load of ~0.2

22. upper bound set at tnominal - tightest bounds
Random - mapping decisions matter
Optimal is quite high
Choosing the best host and remaining there is suboptimal
Point out spread between random and optimal and best host and optimal

23. And here’s our near-optimal alg. Note it is dead-on-optimal up to 1s
Notice that we could possibly improve for tnominal>1s by making multiple decisions (migrate at calls, if available)
Reserve slide shows all algs

24. Effect of relaxing bound tmax for tnominal=100ms, very similar for other tnominals
Notice that best ind host would require 50% looser bound to catch up with optimal. Other algs similar.

25. And, again, rangecounter tracks optimal
Other algs take signicant extra slack to catch up with rc, behave eratically, or are very expensive
Reserve slide shows all algs

26. Proposed Work
Extend current results to the full dynamic mapping problem
Extend simulation environment to include communication and activation trees
Trace collection (Activation trees, network)
A trace for everything
Trace characterization
Simulator extension
Develop algorithm
Evaluate with benchmarks
Incorporate into real system
Should be clear that the first two are the core items. The idea is to built as realistic a simulation environment as possible so that as much work can be done in it as possible.

27. Activation Tree Traces
Collect activation trees where each node is annotated with compute time, and what data it references
Goal is to instrument off-the-shelf MS Windows programs
Other options exist
This approach would give access to a LARGE group of interactive applications with CLEAR credibility.
IMAGE EDITING - PHOTOSHOP
GAMES
COULD SAY IF THIS IS A USEFUL THJNG FOR EXISTING APPLICATIONS WITHOUT HAVING TO REWRITE THEM TO BE DISTRIBUTED
Note that building interactive apps for distributed systems is a relatively new idea, so there are few such programs that can be pulled easily off the shelf.
Further, many of the existing programs are really proprietary
Make it clear that there are fallback positions
Contributions: Instrumentation tools/methodology, Activation tree trace database

28. Network Traces Realistic communication times
Packet traces on Ethernet with tcpdump
Simple broadcast networks seem too limiting
Remos
Existing trace databases
Tension between getting lots of low level, interesting data on simple, less interesting networks or potentially less data on more interesting networks such as ATM or switched ethernet
Can’t easily just sniff something with a switch
Contributions: Methodology, Trace database

29. Trace Characterization
Classify traces into families, from which we can draw benchmarks for evaluation
Ideally, parameterized models to fit data
Characterizing activation tree traces most challenging
Contributions: Trace analysis, Models, Classification scheme, Benchmark suite

30. Simulator Extension
Extend my existing simulator to support arbitrary activation trees and realistic communication
Communication time model
Contributions: Simulator infrastructure for full dynamic mapping problem

31. Algorithm Development
Use approaches described earlier
Extend RangeCounter(W) with a separate algorithm to recursively divide bounds among subtrees
Iterative development using simulator and benchmarks
With the simulation infrastructure and benchmarks, it will be possible to iterate the algorithm quickly and thus (hopefully) converge on a reasonable solution quickly.
From past experience, analytical approaches to algorithm development don’t work well - the behavior of even load is quite complex. One has to find a solution and then attempt to understand it.
Contributions: Algorithm(s)

32. Evaluation Evaluate algorithm in simulation
Draw connections between benchmark characteristics and algorithm performance
Compare with other approaches
Load monitor with simple heuristic
Greater degrees of information sharing
Incorporate into distributed object system as proof of concept
Contributions: Evaluation, Working system

33. Thesis Timeline