1. Supporting Time-sensitive Application on a Commodity OS Ashvin Goel, Luca Abeni, Charles Krasic, Jim Snow, Jonathan Walpole Presented by Wen Sun Some Slides from “Shuping Tien” (spring 2006) & Madhura S Rama(winter 2006)

2. Overview Goal Approach Implement TSL  Firm timer  Fine-Grain Kernel Preemptibility  Improved CPU scheduling Evaluation Conclusion

3. Goal Satisfying time-sensitive application time constraint Attempt to integrate support for time-sensitive applications without sacrificing performance of traditional throughput-oriented applications Build Time-Sensitive Linux (TSL)  While support time-sensitive application, not degrade throughput-oriented application

4. Approach Time-sensitive applications require  Timely resources allocation  Low kernel latency : Timer latency + preemption latency + scheduling latency Time Wall-clock time event Timer Interrupt Scheduler Application Scheduled (Activation) Interrupt Handler Another app Scheduled Timer Latency Preemption Latency Scheduling Latency

5. Approach Improve the three keys causing latency  Accurate timing mechanism Firm timer  Responsive kernel Lock-breaking preemptible kernel  Effective CPU scheduling algorithm Proportion-period scheduler Priority-based scheduler

6. Timer Mechanism Periodic Timers  Periodic timer interrupts. Max timer latency equals to the period.  Reducing latency increases interrupt overhead One-Shot (Hard) Timers  Interrupts only when needed  Cost of timer reprogramming, fielding interrupts Soft Timers  Reduce cost of context switch caused by interrupts  Cost of polling, timer latency Firm Timers  Combines all the advantages of these timers above  Incurs very low overhead

7. Firm Timer design Providing accurate timing mechanism with low overhead Combining one-shot timers with soft timers by exposing a timer overshoot parameter bounding the latency. Programming one-shot timer to fire after an overshoot amount of time after the next timer expiry If a system call occurs after a timer has expired but before one-shot timer generate interrupt when soft timer is effective. Reprogramming one-shot timer for the next timer expiry – not incur overhead

8. Overshoot accuracy vs. overhead tradeoff Kernel Space Time System call Time-Sensitive Application require execution Reprogram timer Poll for timer expiry Overshoot Parameter Dispatching timer Timer Latency

9. Firm Timer Implementation Maintains a timer queue for each processor One-shot APIC timer is programmed to generate an interrupt at the next timer expiry event and global overshoot value (can be made dynamic) Soft timers enabled using non-zero timer overshoot value Periodic timer used when a timer needs longer timeout due to more efficient data structure TSL use the standard POSIX interface calls - modified the implementation to use firm timers

10. Fine-grained kernel preemptibility Problem:  Larger size of non-preemptible secion results in greater kernel latency Approaches:  Explicit insertion of preemption points  Allow preemption anytime the kernel is not accessing shared data structures  Robert Love’s lock-breaking preemptible kernel

11. CPU Scheduling Firm timer uses a combination of Proportion-Period CPU Scheduling Priority CPU Scheduling

12. Proportion-period CPU Scheduling Provides “temporal protection” by allocating each task a fixed proportion of the CPU at each task period Adjustable Q and T by using a feedback controller mechanism Improves accuracy of scheduling analysis 2/3 1/3 Proportion Q Time Period T

13. Priority-based CPU Scheduling Real-time priorities assigned based on application needs TSL schedules fixed priority tasks in the background  Exception: Shared server tasks -> Priority Inversion Use highest locking priority protocol (HLP) to cope with priority inversion Minimizes scheduling latency

14. Evaluation- Latency in Real Application Non-kernel CPU load Kernel CPU load File System Load

15. Non-kernel CPU load -10000-- 60000 0-40000 0--250

16. Kernel CPU load -10000-- 90000 0--400

17. File System Load -20000-- 120000 0--500

18. Evaluation- System Overhead Checking for preemption Three tests (memory access test, folk test, file- system access test) indicate that the overhead is very low Firm Timers Compare overhead of firm timers in TSL with Standard linux with 20 & 50 timer processes

19. Evaluation- System Overhead

20. Conclusion TSL can support applications requiring fine-grained resource allocation and low latency TSL provides effective supports to both time- sensitive and throughput-oriented applications as a general purpose operating system