stars and metropolis: static and dynamic rtos modeling
DESCRIPTION
STARS and Metropolis: static and dynamic RTOS modeling. Felice Balarin Cadence Berkeley Labs. RTOS modeling. Any OS has two basic function: To create abstraction of computational tasks running concurrently while sharing HW resources like CPU - PowerPoint PPT PresentationTRANSCRIPT
STARS and Metropolis: static and dynamic RTOS modeling
Felice BalarinCadence Berkeley Labs
RTOS modeling
Any OS has two basic function:
• To create abstraction of computational tasks running concurrently while sharing HW resources like CPU
• To offer communication services between tasks and the rest of the world, and between tasks themselves
In addition, Real-time OS (RTOS) needs to ensure that computation and communication done by tasks occurs in a predictable time-frame
• dynamic or static performance analysis
• Metropolis and STARS
RTOS: a Metropolis architectural componentAn RTOS is modeled by
• what it can do • how much it costs
: interfaces: time, energy, resource utilization
medium RTOS implements RTOSservices …{ port MemService Mem; …void compute(int time) { [[Sheduler.request(B(thisAction),thisProcess); TimeMgr.request(E(thisAction), TimeMgr.A(B(thisAction))+time); Sheduler.request(E(thisAction), rtosProcess); ]] ;} …
interface RTOSservices extends Port { void send(message m, mailbox b); message receive(mailbox b); … void compute(int time);}
Scheduler
RTOSTimeMgr
Metropolis: architecture netlist
BusArbiterBus
Mem
RTOS Sched
MyArchNetlist
…
…
…
Master
CPU + OS
SlaveMem
Arbiter
Architecture netlist specifies configurations of architecture components.
Each constructor
- instantiates arch. components,
- connects them,
Meta-model: mapping netlist
BusArbiterBus
Mem
RTOS OsSched
MyArchNetlist
mP1 mP2mP1 mP2
MyFncNetlist
MP1 P2
Env1 Env2
B(P1, M.write) <=> B(mP1, mP1.send); E(P1, M.write) <=> E(mP1, mP1.send);B(P1, P1.f) <=> B(mP1, mP1.compute); E(P1, P1.f) <=> E(mP1, mP1.compute);B(P2, M.read) <=> B(P2, mP2.receive); E(P2, M.read) <=> E(mP2, mP2.receive);B(P2, P2.f) <=> B(mP2, mP2.compute); E(P2, P2.f) <=> E(mP2, mP2.compute);
MyMapNetlist
Outline
• Background
– VCC
– STARS
• VCC-STARS integration– extend any VCC simulation model with abstractions required by
STARS • Automatic abstraction generation
– for a class of VCC models
VCC Behavior
• network of behavioral blocks
• many ways to specify a block (BlackBox C++, WhiteBox C, ...)
• simulation used to verify functionality
VCC Architecture
• network of architectural blocks
• needed to determine performance of behavioral blocks
VCC Mapping
• performance of each behavioral block is modeled
• simulation is used to verify performance
BlackBox C++ behavioral blocks
class fifo: public FxCPPBlackBoxModel { InputPort<int> Request, Input; OutputPort<int> Output; ...};
void fifo::Run() { if(Request.Enabled()&& !empty) Output.Post(FIFOPop()); if (Input.Enabled()) FIFOPush(Input.Value()); ...}
Input Output
Request
fifo
•the only kind understood by VCC simulation core
WhiteBox C behavioral blocks
void point_entry_run() { if(Request_Enabled()&& !empty) Output_Post(FIFOPop()); if (Input_Enabled()) FIFOPush(Input_Value()); ...}
void fifo::Run() { _delayCycles(60); if(Request.Enabled()&& !empty){ Output.Post(FIFOPop()); _delayCycles(80); } _delayCycles(75); if (Input.Enabled()) { _delayCycles(100); FIFOPush(Input.Value()); } ...}
Input Output
Request
fifo
estimation
CPU model
Outline
• Background
– VCC
– STARS
• VCC-STARS integration– extend any VCC simulation model with abstractions required by
STARS • Automatic abstraction generation
– for a class of VCC models
STatic Analysis of Reactive Systems
For all inputs:
• Can I process all workload between two ticks?
• How much bus traffic will I generate?
• How much energy will I use?
play
message control buffernetwork
ticksamplerequest
frame
Outline
• STARS– overview– representing signals– representing system components– finding worst-case behaviors – representing timing information
STARS overview
• STARS finds worst-case signature of any execution window of a given length
• STARS finds the worst-case CPU busy period
play
message control buffernetwork
ticksamplerequest
frame
pl
ms
tksmrq
fr
SIGNATURE
Fcntr Fbfr
Fenv
SIGNATURE ABSTRACTION
tick
play
frame
pl = 1fr = 2tk = 3
Signatures
• in practice, counting “events”
– state transitions may be considered events
– combinations of events may have separate counters
– may need linear constraints over counters
• less events is “better than” () more events
t t+T
s,T
t t+Tq
Signature Abstractions
Estimate output signature based on input signature and length• must be conservative
F( s, T)F
system
Signature Abstractions: Environment
• at least 625s between messages
– Fms (s, T) = T/625 + 1
• tick has 125s period
– Ftk (s, T) = T/125 + 1
• at most 1 play a second
– Fpl (s, T) = T/1,000,000 + 1
play
message control buffernetwork
ticksamplerequest
frame
Signature Abstraction: Buffer
BUFFER:if ( present ( frame ) {
samples = frame; last = 50; }if ( present ( tick ) && last > 0) {
emit sample ( samples[ last -- ] );if ( last == 20 ) emit request(); }
play
message control buffernetwork
ticksamplerequest
frame
Frq (s, T) = min( fr, tk/30)
Fsm (s, T) = min( tk, 50*fr )
s
t t+T
Fix-point Theorem
If:
• s = F(s, T),
• s is worse than signature of initial state,
then s is worse than signature of any execution segment of length T
Workload Function
Estimates required processor time from signatures
• must be conservative
s
Task 2Task 1
Idle
W(s)
Workload Function: VM pager
BUFFER:if ( present ( frame ) {
samples = frame; last = 50; }
if ( present ( tick ) && last > 0) {emit sample ( samples[ last -- ] );if ( last == 20 ) emit request(); }
play
message control buffernetwork
ticksamplerequest
frame
W (s) = 20*fr + 20*sm + ...
1 line = 10 time units
STARS
1Pick a signature
2Chose a signature abstraction F and workload function W and verify they and conservative
3Solve
s = F(s,T)
T = W(s)
4T is a bound on response time
the processor cannot be continuously busy for more than T time units
Outline
• Background
– VCC
– STARS
• VCC-STARS integration– why, what and how
• Automatic abstraction generation– for a class of VCC models
Why VCC-STARS?
• cannot relate components to their abstractions
play
message control buffernetwork
ticksamplerequest
frame
pl
ms
tksmrq
frFcntr Fbfr
Fenv
VCC
STARS
??? ??? ???
VCC-STARS: What?
• abstract models used by STARS can be validated by VCC simulation
play
message control buffernetwork
ticksamplerequest
frame
pl
ms
tksmrq
frFcntr Fbfr
Fenv
monitor
VCC-STARS: How?
BlackBox C++ extensions to represent signatures
• vectors of counter values
• each behavioral block has:
– one counter for each input port
– one counter for each output port
– a counter measuring CPU time usage
– optional user-defined counters
Signature: example
class fifo: public FxCPPBlackBoxModel { InputPort<int> Request, Input; OutputPort<int> Output; starsCounter numExecutions; ... };
counters:
•Output.count•Input.count•Request.count •numExecutions• the one pointed to by processorTimeCounter()
VCC-STARS: How?BlackBox C++ extensions to represent signature abstractions
• each block has member function: void starsAbstraction()
• sets bounds of output-port, CPU-usage, and user-defined counters, based on input-port counters and length of time
• must be conservative:
t t+T
sign.
t t+Tsign.
est. sign.starsAbstraction()
Run()
Signature abstraction example
class fifo: public FxCPPBlackBoxModel { InputPort<int> Request, Input; OutputPort<int> Output; starsCounter numExecutions; ... };
void fifo::Run() { numExecutions++; if(Request.Enabled()&& !empty) Output.Post(FIFOPop()); if (Input.Enabled()) FIFOPush(Input.Value()); ... }
void fifo::starsAbstraction() { Output.count.setBound( min( Input.count, Request.count)); numExecutions.setBound( Input.count + Request.count); ... }
Signature abstraction example (cont’d)
delay_model(){input(Input);input(Request);run();delay('0.000001');output(Output);
}
void fifo::starsAbstraction() { Output.count.setBound(min(Input.count, Request.count)); numExecutions.setBound(Input.count + Request.count); starsCounter * p = processorTimeCounter(); if(p) p->setBound(1000*numExecutions); }
Signature abstractions
• may depend on time:void env::starsAbstraction() {
Burst.count.setBound(mgr()->timeWindow()/625000+1);
}
•mgr() is a manager containing STARS info
• timeWindow() depends on context
– in simulation, it’s the time since monitor creation
– in STARS, it can be a constant
– in STARS, it can be current estimate of the busy-period
starsAbstraction()
• is verified to be conservative by simulation monitors that perform the following check every time an output counter is changed
– evaluate starsAbstraction() using current values of input counters
– compare output counters with bounds computed by starsAbstraction()
– if bounds are violated, warn that starsAbstraction() is not conservative
• is used by STARS to compute to compute worst-case bounds of all the counters in the network
Voice Mail Pager
• 16 modules
• ~ 4000 lines of C++ code annotated with timing estimates
• build signature abstractions manually
– 150 lines of C code
VMP First experiment
• model environment so that a single message is received and then played
– same as VCC test-bench
• max busy period:
– VCC: 82 s (simulating 8s took ~ 30 s)
– STARS: 83 s (took 16 ms to compute)
VMP second experiment
• same as first except:
– don’t limit the environment to a single message
• max busy period:
– STARS 148 s (more than 125 s between two ticks)
– VCC: can find input that has 146 s
1 2 3 29 30 31 49 50
50x125
125
message, play
66s wide window in a 6250 s period
Outline
• Background
– VCC
– STARS
– other related work
• VCC-STARS– BlackBox C++ extensions
• Automatic abstraction generation– for WhiteBox C blocks
What?
• abstract models can be automatically generated for WhiteBox C blocks
play
message control buffernetwork
ticksamplerequest
frame
pl
ms
tksmrq
fr
Fenv
Fcntr Fbfr
VC
C-S
TA
RS
VC
C-S
TA
RS
Automatic abstraction: How?
• WhiteBox C flow in VCC
WhiteBox C
estimation
CPU model
annotatedBlackBox C++
signatureabstraction
Hints
estimation
-STARS
Automatic abstraction algorithm
starting from:
– input counters
– user hints,
propagate bounds to
– statements
– output counters
for each output counter with a bound
set its bound to the minimum of all
if each basic block of code has a bound
use VCC delay estimates to bound CPU time
boundpropagation
codegeneration
Example
void point_entry_run() { starsIncrement(numExecutions); if (Request_Enabled() && !empty ) Output_Post(FIFOPop()); if (Input_Enabled()) FIFOPush(Input_Value());}
Request.count
void fifo::starsAbstraction() { Output.count.setBound( Request.count ); }
Hints
void point_entry_run() { starsIncrement(numExecutions); if (Request_Enabled() && !empty ) Output_Post(FIFOPop()); if (Input_Enabled()) FIFOPush(Input_Value());}
Request.count
void fifo::starsAbstraction() { numExecutions.setBound( 10 ); int b = min( numExecutions, Request.count); Output.count.setBound( b ); starsCounter * p = processorTimeCounter(); if(p) p->setBound(numExecutions*(D1+D3+D4) + b*D2);}
void starsSetBounds() { numExecutions_SetBound(10); }
numExecutionsD1
D2D3D4
RESULTS ON AUTOMATIC ABSTRACTION
IMMEDIATE
• generating signature abstractions automatically is undecidable for arbitrary code
DATE 2000
• if transition relation of a memory-less component is a Boolean function represented with a BDD then its ideal signature abstraction can be generated automatically
SASIMI 2001
• generating signature abstraction automatically is possible for finite-state machines
Related Work
• YAPI-STARS, presented at CODES 2000
– systems in YAPI are networks of concurrent processes, similar to Khan’s process networks
– YAPI-STARS is good for bounding communication requirements
– no performance analysis
• Program path analysis (Cinderella), Li and Malik 1999
– intended for timing analysis of embedded software
– useful for automatically generating abstractions used by STARS
Conclusions
• STARS adds worst-case analysis to simulation
– can prove that performance requirements are met
– helps find hard performance bugs
• requires additional designer effort to specify abstractions
– typically |STARS abstractions| < 10% * |simulation models|
– even smaller for estimated WhiteBox C
• abstractions can be verified by VCC simulations
• could be applied to any simulation environment where meaningful counters can be defined
Thank you
Outline
• Background
– VCC
– STARS
– other related work
• VCC-STARS intergration– BlackBox C++ extensions
• Automatic abstraction generation– for WhiteBox C blocks
t t+T
sign.
t t+Tsign.
Signature Abstractions
Estimate signature of output counters based on the signature of input counters – must be conservative
boundstarsAbstraction()
Run()
Proposal
VCC + STARS = VCC-STARS
• Black Box C++ extensions:
– providing signatures of events on ports
– enabling the user to associate a signature abstraction for
each BlackBox C++ block