This document summarizes a research paper about Timeline, an operating system abstraction that allows time-aware applications to be aware of timing uncertainty in distributed systems. The abstraction introduces the concept of Quality-of-Time (QoT) to convey uncertainty. It presents a QoT architecture that uses timelines maintained as trees and bindings as linked lists to coordinate time synchronization across nodes based on application requirements. The implementation uses a data distribution service and synchronization services. Evaluation results show the approach enables choreographed scheduling while balancing performance and resource usage.

1. Timeline: An Operating System Abstraction for
Time-Aware Applications
Fatima M. Anwar, Sandeep D’souza, Andrew Symington, Adwait Dongare,
Ragunathan (Raj) Rajkumar, Anthony Rowe, Mani B. Srivastava
2016 IEEE Real-Time Systems Symposium
28/Mar/2019 – CSL704: AOS R2 Presentation
Anurag Banerjee (2018CSM1007)

2. Introduction
Background
Research Problem
Concepts Introduced
Architecture
Implementation Notes
Evaluation Results
Conclusion
2/17

3. Introduction
 Synchronization in distributed systems needed for ordered behavior
 Measuring and synchronizing time over distributed networks quite
accurate these days
 Existing methods are system centric, application requirements often
ignored
3/17

4. Background
 Leslie Lamport introduced Logical Clocks in 1978, won Turing award in
2013
 Many present versions – Vector Clocks, etc.
 The aim is to bring order unto chaos – global ordering of events
 Existing protocols filter out errors in synchronization – uncertainty
 From programming perspective
 Time triggered architecture: use global time base
 Event triggered model: use mapping between real and model time
 E.g. Google Spanner, NTP, etc.
4/17

5. Research Problem
 Applications not aware of uncertainty
 Applications have limited benefit because:
 Time management services
 Hardware-OS interface
 OS-Application interface
 Resource wastefulness – attempt at synchronizing all at once
5/17

6. Concepts Introduced
 Quality-of-Time:
 Based on timing uncertainty
 Uses platform independent OS abstraction: Timeline
 Tells how OS and Time-aware applications should exchange info
 Instead of Master-Slave clock sync idea of NTP/PTP (at fixed rate)
 Use factored coordination
 Only those nodes sync that need to
 Nodes bind to a timeline by providing (accuracy, resolution) need
 Timeline maintained as a Red-Black Tree
 Bindings maintained as linked lists
6/17

7. 7/17

8. QoT Architecture
 Consists of
 Clocks: Timekeeping Hardware
 Core Clocks: mandatory per node
 Network Interface Clocks
 System Services: user space processes for sync
 Data Distribution Service: collect timeline req. across all nodes and share
 Synchronous service: sync local with global
 System Uncertainty Estimation Service: update uncertainty stats for each time-stamp
 QoT Core: bridge between QoT architecture stack and OS
 Timeline Management: track timelines and their bindings
 Clock Management
 Event Scheduling: on global time notion
 QoT Propagation: expose uncertainty to app
8/17

9. 9/17

10. Implementation Notes
 OpenSlice used for DDS
 Node with highest
accuracy req. – ref. time for
timeline.
 Can become master
 Sync Service
 Use the tree :-
10/17

11. 11/17

12. Implementation - API
 API for programmers, functionalities include
 Timeline association – bind/unbind
 Time management – read timeline notion and uncertainty
 Event scheduling – use timeline based waits to schedule events
12/17

13. Evaluations Results13/17

14. Evaluation Results14/17

15. Evaluation Results15/17

16. Conclusion
 Ability to perform choreographed scheduling is a plus
 Introduced idea of QoT
 Applications now know about uncertainty and decide for themselves
 Multi-core environments not yet considered
 Accuracy attribute considered, resolution attribute for future
 Balance between performance and resource consumption
16/17

17. Thank You17/17