Chaitanya Belwal

Determining actual response time in P-FRP

A purely functional model of computation, called Priority-based Functional Reactive Programming (P-FRP), has been introduced as a new paradigm for building real-time software. Unlike the classical preemptive model of real-time systems, preempted events in P-FRP are aborted and have to restart when higher priority events have completed, making the response time of events dependent on the execution pattern of higher priority events. Though methods to determine approximate values for the response time of P-FRP events have been presented, no convenient method has yet been established to determine actual response time. A common method for computing actual response time in the preemptive model does not give guaranteed results in P-FRP. A simulation based approach is computationally expensive and not feasible in most practical situations. We show that an exhaustive enumeration technique for idle periods is a more efficient technique, and can be easily adopted to determine actual response time in P-FRP.

Lazy Versus Eager Conflict Detection in Software Transactional Memory: A Real-Time Schedulability Perspective

Transactional memory is a mechanism of controlling access to shared resources in concurrent programs. Though originally implemented in hardware, software implementations of transactional memory are now available as library extensions in all major programming language. Lately, variants of software transactional memory (STM) with real-time support have been presented. The conflict detection policy used in STM, which can be of lazy or eager type, determines the point at which transactions are aborted. The conflict detection policy can have a significant effect on the schedulability of tasks sharing common resources. Using an abstract model, we present a real-time scheduling perspective analysis of lazy and eager conflict detection policies used in STM.

Determining Actual Response Time in P-FRP Using Idle-Period Game Board

A new, purely functional model of computation, called Priority-based Functional Reactive Programming (P-FRP), has been introduced as a new paradigm for building real-time software. P-FRP allows assignment of static priorities to tasks and guarantees that, when a higher priority task is released, the system will immediately preempt any lower-priority tasks that may be executing at the time. This execution model is different from the classical preemptive model of real-time systems due to the abort nature of preempted tasks. Methods developed for determining actual response time in the preemptive model are not guaranteed to work in P-FRP. In previous work, the gap-enumeration technique has been presented as a viable alternative to simulations for computing actual response time in P-FRP. Unfortunately, this method is difficult to implement due to its use of a Red-Black tree which is not available as a native function in programming languages. Also this method requires a complex logic loop for finding idle periods. In this paper, we present another technique using game-board which is simple to implement and uses native data structures. However, this simplicity comes at a performance cost which has also been analyzed in this paper.

Feasibility interval for the transactional event handlers of P-FRP

declarative approach for modeling and building safety-critical embedded systems. Recently, Priority-based FRP (P-FRP) was introduced as a formalism that guarantees real-time response. Due to the state-less nature of execution of functional programs, P-FRP implements a transactional nature of execution where preempted lower priority tasks are aborted. This makes the response time of a lower priority task completely dependent on the execution pattern of higher priority tasks. The feasibility interval in the classical preemptive model† of real-time systems is known and is dependent on the least common multiple (LCM) of task periods. However, since the abort nature of preemption can induce side-effects on the execution of lower priority tasks, it has been unknown to date if the feasibility in P-FRP is also dependent on the LCM. In this paper, we rigorously prove that these side-effects of preemption are bounded within the LCM and formally derive a value of the feasibility interval in P-FRP. This value of feasibility interval is vital for more robust schedulability analysis of the P-FRP execution model.

Schedulability Analysis of Transactions in Software Transactional Memory Using Timed Automata

Software Transactional Memory (STM) is a mechanism for controlling access to shared resources in memory using an abort-restart preemption model for tasks which share data objects. This execution model of STM is different from the classical preemptive or non-preemptive models and currently the only method to determine schedulability is through an exhaustive search through the state space of all release scenarios of higher priority tasks. The existing method is costly and scales exponentially with the number of tasks making its use limited in practical situations. Timed Automata has been proven as an expressive formalism for time based systems. This paper presents a methodology for developing Timed Automata encodings for the schedulability analysis of STM systems. We validate our models using the model checker UPPAAL, and show that Timed Automata offers an efficient alternative for schedulability analysis in real-time STM.

Scheduling Conditions for Real-Time Software Transactional Memory

Software transactional memory (STM) is a transactional mechanism of controlling access to shared resources in memory. Recently, variants of STM with real-time support have been presented. Due to its abort-restart nature, the execution semantics of STM are different from the classical preemptive or nonpreemptive model. In this letter, we formally derive utilization based necessary and sufficient scheduling condition for a STM system using lazy conflict detection.

A Utilization Based Sufficient Condition for P-FRP

Priority-based1Functional Reactive Programming (P-FRP) is a new functional programming formalism for developing safety-critical embedded systems. P-FRP allows static priority assignment and guarantees real-time response by preempting lower priority tasks. Due to the state-less nature of functional programs, preempted tasks in P-FRP are aborted and have to restart after the higher priority tasks have completed execution. Since the execution semantics of P-FRP are different from the classical preemptive model of execution, existing utilization based sufficient conditions cannot be applied. In this paper, we derive a new utilization based sufficient schedulability condition for P-FRP, and validate it using experimental task sets.

Worst case response time for real-time software transactional memory

Software transactional memory (STM) is used to control access to shared resources. The worst case response time (WCRT) estimation is different from the classical preemptive or nonpreemptive model due to its abort-restart nature. In this paper, we derive a WCRT for a STM system using lazy conflict detection. A WCRT example is also given.

Time petri nets for schedulability analysis of the transactional event handlers of P-FRP

Priority-based FRP (P-FRP) is a functional programming formalism for reactive systems that guarantees real-time response. Preempted tasks in P-FRP are aborted and have to restart when no higher priority tasks are present in the execution queue. The abort and eventual restart makes the response time of a lower priority task completely dependent on the execution pattern of higher priority tasks. Exact schedulability analysis methods of P-FRP that have been presented so far require the evaluation of all release scenarios of higher priority tasks. Unfortunately, the number of such scenarios scales exponentially with the size of the task set, making exact schedulability analysis of this execution model a computationally expensive proposition. The formal method of Time Petri Net (TPN) has previously been used for schedulability analysis of preemptive and non-preemptive models. TPNs for P-FRP or other transaction like execution models have not been developed yet. In this paper, we develop TPN models for the transactional execution model of P-FRP and show that TPNs offer an efficient alternative for schedulability analysis of this model. We have implemented our TPNs in the model checker ROMEO and have validated the correctness of our models through experimental task sets.

A Sufficient Schedulability Test for Real-Time Software Transactional Memory

Transactional Memory (TM) is a mechanism to control access to shared resources in memory. Though originally implemented in hardware, software implementations of TM are now available as library extensions in major programming language. Lately, variants of software transactional memory (STM) with real-time support have been presented. As real-time STM begins to be increasingly used in commercial embedded systems, a good understanding of their temporal properties for ascertaining real-time guarantees is required. Unlike the classical models of preemptive or non-preemptive execution, in STM higher priority tasks can induce an abort cost in addition to the interference cost on preempted lower priority tasks. Due to the abort cost, several existing approaches developed for the classical model cannot be used to ascertain real-time guarantees in STM. In this paper, we convert the abort costs induced by higher priority tasks into new phantom tasks and transform the transactional execution model of STM into a pessimistic preemptive model. An existing iterative method to compute response time is then applied to determine schedulability. This approach is utilized to derive a polynomial time sufficient schedulability test for both the lazy and eager conflict detection polices of STM. Experiment results to validate the sufficient test and analyze its coverage are presented.