Priority Inheritance Protocol Research Articles

Blocking analysis of suspension-based protocols for parallel real-time tasks under global fixed-priority scheduling

With the wide use of multiprocessor architecture, parallel tasks have been receiving growing attention in both industry and academia. In real-time systems, the scheduling and synchronization that ensure predictable task execution and resource access are of utmost importance. Although the scheduling of (independent) parallel tasks is widely studied in recent years, few works have been done for the synchronization with intra-task parallelism. In particular, the performance of the classical priority inheritance mechanism is still unfathomed for parallel tasks. In this paper, we extend the Priority Inheritance Protocol (PIP) and the Flexible Multiprocessor Locking Protocol (FMLP) for real-time parallel tasks (i.e., called P-PIP and P-FMLP respectively) under the global fixed-priority scheduling, and present the blocking analysis for both protocols with the state-of-the-art linear optimization technique. Empirical evaluations show that the P-PIP outperformed the P-FMLP with increasing shared resource contentions. • This paper first studies the synchronization of parallel tasks under global scheduling. • This paper proposes a unified analysis framework under the global scheduling. • A Mixed Integer Linear Programming technique is used to reduce analytical pessimism.

Precise Worst-Case Blocking Time of Tasks Under Priority Inheritance Protocol

The problem of precisely computing the worst-case blocking time that tasks may experience is one of the fundamental issues of schedulability analysis of real-time applications. While exact methods have been proposed for more sophisticated protocols, the problem is indeed complex in case of the Priority Inheritance Protocol, even restricting the attention to uniprocessor systems, non-nested resource accesses, and non-self-suspending tasks. Besides a very simple method leading in general to loose upper bounds, only one algorithm of exponential complexity has been so far reported in literature to tighten such bounds. In this article, we describe a novel approach which, leveraging an operational research technique for modeling the problem, computes the same tight bounds in polynomial time. We then discuss the scenarios in which, assuming no conditional statements in the tasks’ code, the computed bounds derive from an actually impossible blocking chain, and we refine the initial model to more precisely compute the worst-case blocking times for any task set in any possible operating condition.

Priority Inheritance Protocol Proved Correct

In real-time systems with threads, resource locking and priority scheduling, one faces the problem of Priority Inversion. This problem can make the behaviour of threads unpredictable and the resulting bugs can be hard to find. The Priority Inheritance Protocol is one solution implemented in many systems for solving this problem, but the correctness of this solution has never been formally verified in a theorem prover. As already pointed out in the literature, the original informal investigation of the Property Inheritance Protocol presents a correctness “proof” for an incorrect algorithm. In this paper we fix the problem of this proof by making all notions precise and implementing a variant of a solution proposed earlier. We also generalise the scheduling problem to the practically relevant case where critical sections can overlap. Our formalisation in Isabelle/HOL is based on Paulson’s inductive approach to protocol verification. The formalisation not only uncovers facts overlooked in the literature, but also helps with an efficient implementation of this protocol. Earlier implementations were criticised as too inefficient. Our implementation builds on top of the small PINTOS operating system used for teaching.

Integration of a preemptive priority based scheduler in the Palladio Workbench

This paper presents an extension to the Palladio Component Model (PCM), together with a new performance analysis infrastructure that supports the fixed-priority preemptive scheduling policy. The proposed solution allows modelling and analysing component-based embedded software applications that are defined using a specific pattern in which each component is executed by a task with a specific priority. The infrastructure is also capable of analysing the system performance when the tasks access shared resources, using either immediate priority ceiling, or priority inheritance protocols, in order to avoid the priority inversion problem. The paper shows the set of rules that enable the transformation between an application, compliant with the proposed design pattern, and its corresponding PCM. Finally, a use case example based on a real system, and a set of tests that validates the analysis infrastructure, are provided. This system is the on-board software of a satellite payload that is currently being developed by the Space Research Group of the University of Alcala. This software is in charge of managing the Instrument Control Unit of the Energetic Particle Detector, which will be launched as part of the Solar Orbiter mission of the European Space Agency and United States National Aeronautics and Space Administration (NASA).

Estimation of blocking factor for tasks in real-time systems with multi-core processors

An approach is described for estimate of task response time in real-time systems that are implemented by multi-core processors. The fact is shown, that in systems on multi-core processors the composite blocking of tasks is possible not only with use of priority inheritance protocols, but also with use other known protocols of mutual data access. A method is given for estimate of blocking factor for systems with composite blocking of tasks on multi-core processors.

Resolving priority inversions in composable conveyor systems

Abstract The well known problem of priority inversions that occurs in classical real-time systems also manifests in decentralized cyber-physical systems. Using a specific example of composable conveyor systems, we show how priority inversions hinder the transport of entities through the conveyor systems. We present a novel adaptation of the classical priority inheritance protocol for resolving these cyber-physical priority inversions. While the approach resolves cyber-physical priority inversions, the structure and constraints of the conveyor systems cause the jitter associated with the end-to-end latency of the highest priority parts to increase. Further, these constraints also limit the applicability of the classical priority ceiling protocol in this class of cyber-physical systems. Simulation results demonstrate the correctness and reasonable communication overhead of the approach.

Comparative analysis of real time resource access control protocols using UML 2.0

The behaviors of real time software systems do not depend only on the values of input and output signals, but also on the times of their occurrences. Real time systems (RTS) interact with their environments using time constrained input/output signals. The complexity of Real Time Systems is continually increasing which makes their design very challenging. In RTS, the scheduling of tasks with hard deadlines has been an important area of research. Unified Modeling Language (UML), the standard visual object-oriented modeling language, is suitable to deal with this complexity. The main objective of this paper is to compare two protocols using UML 2.0 models. The shortcomings of the existing Priority Inheritance protocol are represented using one UML model. Further, the Stack Based Priority Ceiling protocol is used to overcome this difficulty using an improved model.

Resource sharing among real-time components under multiprocessor clustered scheduling

In this paper we propose a general synchronization protocol for resource sharing among independently-developed real-time applications (components) on multi-core platforms. This protocol is a generalization of a previously proposed synchronization protocol (MSOS). In our proposed protocol, each component is statically allocated on a dedicated subset of processors (called cluster). A component has its own internal scheduler by which its tasks are scheduled. In this paper we focus on multiprocessor global fixed-priority preemptive scheduling algorithms to be used to schedule the tasks inside each component. Sharing the local resources is handled by the Priority Inheritance Protocol (PIP). For sharing the global resources (inter-component resource sharing) we have studied usage of FIFO and Round-Robin queues for access the resources across the components and usage of FIFO and prioritized queues inside the components. We have derived schedulability analysis for the different queue handling alternatives and compared their performance by using experimental evaluations. Finally, we have shown that the integration phase can be formulated in the form of a nonlinear integer programming problem where solution techniques in this domain can be used to minimize the total number of processors required to guarantee the schedulability of all components. As a proof of concept we have only provided the formulation for FIFO queues.

Priority inversion with fungible resources

Priority inversion occurs when the execution of a task is unnecessarily delayed by the dispatch of a lower priority task. This anomaly can result in failure if it causes the delay of hard real-time tasks. Priority inheritance protocols have been developed to limit priority inversions during competition over shared resources. Such methods are designed for individually identifiable resource units. Other approaches are indicated when shared resources contain interchangeable resource units. Current practices with resource deadlock, a scheduling anomaly that has many characteristics in common with priority inversion, provide insight into the control of priority inversion with these fungible resources.

Catching two rabbits: adaptive real‐time support for embedded Linux

AbstractThe trend of digital convergence makes multitasking common in many digital electronic products. Some applications in those systems have inherent real‐time properties, while many others have few or no timeliness requirements. Therefore the embedded Linux kernels, which are widely used in those devices, provide real‐time features in many forms. However, providing real‐time scheduling usually induces throughput degradation in heavy multitasking due to the increased context switches. Usually the throughput degradation becomes a critical problem, since the performance of the embedded processors is generally limited for cost, design and energy efficiency reasons. This paper proposes schemes to lessen the throughput degradation, which is from real‐time scheduling, by suppressing unnecessary context switches and applying real‐time scheduling mechanisms only when it is necessary. Also the suggested schemes enable the complete priority inheritance protocol to prevent the well‐known priority inversion problem. We evaluated the effectiveness of our approach with open‐source benchmarks. By using the suggested schemes, the throughput is improved while the scheduling latency is kept same or better in comparison with the existing approaches. Copyright © 2008 John Wiley & Sons, Ltd.

Kernel Thread Scheduling in Real-Time Linux for Wearable Computers

In Linux, real-time tasks are supported by separating real-time task priorities from non-real-time task priorities. However, this separation of priority ranges may not be effective when real-time tasks make the system calls that are taken care of by the kernel threads. Thus, Linux is considered a soft real-time system. Moreover, kernel threads are configured to have static priorities for throughputs. The static assignment of priorities to kernel threads causes trouble for real-time tasks when real-time tasks require kernel threads to be invoked to handle the system calls because kernel threads do not discriminate between real-time and non-real-time tasks. We present a dynamic kernel thread scheduling mechanism with weighted average priority inheritance protocol (PIP), a variation of the PIP. The scheduling algorithm assigns proper priorities to kernel threads at runtime by monitoring the activities of user-level real-time tasks. Experimental results show that the algorithms can greatly improve the unexpected execution latency of real-time tasks.

The implementation of the Priority Ceiling Protocol in Ada-2005

Ada 2005 is an even safer and more agile language than its predecessors, with all of the efficiency that is a hallmark of the Ada language design. It still has a strong focus on real-time response, multi-tasking, and sound engineering. It is the only international standard for object-oriented real-time distributed programming. High-integrity systems rarely make use of high-level language features such as Ada Protected Objects. Protected Types provide a passive mechanism for communication and synchronization between tasks. In this paper, we present some of these features, which are implemented using the Priority Ceiling Protocol (PCP). PCP is an extension of the Priority Inheritance Protocol (PIP), with the added features of preventing deadlocks and priority inversions. Priority inversion occurs when a high priority task is blocked for an unbounded time by lower priority tasks. Unfortunately though, PCP is not known to be supported by any operating systems. This article describes an implementation of PCP in Ada-2005. A detailed discussion of this protocol, and other related issues, are presented.

USING PRIORITY INHERITANCE TECHNIQUES TO OVERRIDE THE SIZE LIMIT OF CAN MESSAGES

The CAN bus, highly appreciated for its efficiency and low cost, is widely adopted in many fields, especially where real-time properties are required. However, it is particularly tailored for short data, supporting up to eight data bytes per frame. Larger data entities need to be fragmented so that they can be transferred over the network. Such fragmented messages may experience long delays caused by preemption by higher priority messages, even when these still exhibit slack. This problem has been found in lift control systems in which multi-frame CAN messages had to be sent regularly and were also subject to timing constraints. This paper shows how to use current analysis to deduce response times for multi-frame CAN messages and then it proposes using resource management policies in the CAN bus, namely the Priority Inheritance Protocol, to exploit the slack of higher priority messages and reduce those response times. The paper presents several results that show the efficiency of the proposed mechanisms and highlight their benefits and drawbacks.

실시간 운영체제의 우선순위 역전현상 해결을 위한 프로토콜 설계 및 구현

실시간 운영체제는 정해진 시간 내에 작업처리를 완료해야 하는 분야에 주로 사용되고 있으며, 최적의 실시간 운영체제를 설계하고 개발하기 위해서는 효과적인 스케줄링 정책, 인터럽트 지연 최소화, 우선순위 역전현상 해결 등의 조건을 만족시켜야한다. 이러한 조건들 중에서 우선순위 역전현상을 해결하기 위해 지금까지 basic priority inheritance 프로토콜, priority ceiling emulation 프로토콜 등이 제안되었으나, 하나의 프로세스가 동시에 다수의 자원을 소유하는 경우 또는 재귀적으로 자원을 소유하거나 요청하는 경우와 같이 대표적인 두 가지 복잡한 우선순위 역전현상에 대해서는 해결이 불가능하다. 이에 본 논문에서는 재귀적 자료구조를 기반으로 다양한 우선순위 역전현상을 효과적으로 해결할 수 있는 RPI(Recursive Priority Inheritance) 프로토콜을 설계하고, 이를 리눅스 커널에 구현하여 검증한 내용을 보인다. Real-time operating systems have been used in various computing environments, where a job must be completed in its deadline, with various conditions, such as effective scheduling policies, the minimum of an interrupt delay, and the solutions of priority inversion problems, that should be perfectly satisfied to design and develop optimal real-time operating systems. Up to now, in order to solve priority inversion problems among several those conditions. There have been two representative protocols: basic priority inheritance protocol and priority ceiling emulation protocol. However, these protocols cannot solve complicated priority inversion problems. In this paper, we design a protocol, called recursive priority inheritance (RPI), protocol that effectively solves the complicated priority inversion problems. Our proposed protocol is also implemented in the Linux kernel and is compared with other existing protocols in the aspect of qualitative analysis.

Priority Inheritance Revisited. Towards the conformance of real-time protocols

The priority inversion problem was discovered in the eighties. The decisive ideas to cope with this problem have been published in the nineties. In the meantime the suppliers of real-time operating systems and run-time systems have occupied this topic by providing certain protocols in order to give the application programmer comfortable system calls to avoid priority inversion. At a closer look there are considerable errors and defects in the protocol implementations but also in the approach to derive these protocols. So, on the one hand this article unfolds an undetected error of the priority inheritance protocol. On the other hand it shows by a sequence of test suites that certain operating systems and runtime systems have different kinds of defects in implementing the protocol.

Testing for the Conformance of Real-time Protocols Implemented by Operating Systems

The priority inversion problem arises when prioritized processes concurrently attempt to enter critical sections. This phenomenon results in extremely pessimistic estimations of worst case response times for real-time processes. Various protocols against priority inversion have been proposed in the literature and are available at system call level of operating systems and run-time executives. They belong to two major families of protocols: the priority inheritance protocols (PIP) and to the priority ceiling protocols (PCP). These protocols have in common that they allow to derive more optimistic worst case response times.In contrast to the importance of this predictability aspect in the context of time-critical applications a lot of PIP- and PCP-implementations are not correct and permit the violation of time bounds. This article presents an effective and flexible tool set applied here for the validation of the implementations of protocols of the PCP-family. Besides the manual setup and instrumentation major parts of the black-box validation process are executed automatically.

Task synchronization in reservation-based real-time systems

In this paper, we present the BandWidth Inheritance (BWI) protocol, a new strategy for scheduling real-time tasks in dynamic systems, which extends the resource reservation framework to systems where tasks can interact through shared resources. The proposed protocol provides temporal isolation between independent groups of tasks and enables a schedulability analysis for guaranteeing the performance of hard real-time tasks. We show that BWI is the natural extension of the well-known priority inheritance protocol to dynamic reservation systems. A formal analysis of the protocol is presented and a guarantee test for hard real-time tasks is proposed that takes into account the case in which hard real-time tasks interact with soft real-time tasks.

Mode Change Protocols for Real-Time Systems: A Survey and a New Proposal

This paper contains both a survey of mode change protocols for single-processor, fixed-priority, preemptively scheduled real-time systems, and a proposal of several new protocols along with their corresponding schedulability analysis and configuration methods. First, a classification of the protocols found in the literature is given and a set of requirements is proposed for their evaluation. Then, the new protocols are introduced and discussed in the light of the stated requirements. A number of mode change protocols are based on delaying the initiation of the new mode by applying an offset to the initial release of tasks in the destination mode. We tackle the problem of how to obtain these offsets for the proposed protocols. The issue of consistently sharing resources during the mode change by means of a priority inheritance protocol is also dealt with.

Perfecting preemption threshold scheduling for object-oriented real-time system design

In spite of the proliferation of object-oriented design methodologies in contemporary software development, their application to real-time embedded systems has been limited because of the practitioner's conservative attitude toward handling timing constraints. In fact, this conservative attitude is well-grounded because traditional priority-based scheduling techniques cannot be straightforwardly integrated into them. The automated implementation from the object-oriented real-time designs usually incurs a large number of tasks which, under traditional priority-based scheduling techniques, does not scale well due to excessive preemption overheads. Recently, preemption threshold scheduling was introduced to reduce run-time multi-tasking overhead while improving schedulability by exploiting non-preemptibility as much as possible. Unfortunately, the preemption threshold scheduling cannot be directly adopted into the object-oriented design methods due to the lack of real-time synchronization.In this paper, we present the essential basis of real-time synchronization for preemption threshold scheduling. Specifically, we integrate the priority inheritance protocol, the priority ceiling protocol, and the immediate inheritance protocol into preemption threshold scheduling. We also provide their schedulability analyses. Consequently, the integrated scheme, which minimizes worst-case context switches, is appropriate for the automated implementation of real-time object-oriented design models.

A Feasibility Decision Algorithm for Rate Monotonic andDeadline Monotonic Scheduling

Rate monotonic and deadline monotonic scheduling are commonly used for periodic real-time task systems. This paper discusses a feasibility decision for a given real-time task system when the system is scheduled by rate monotonic and deadline monotonic scheduling. The time complexity of existing feasibility decision algorithms depends on both the number of tasks and maximum periods or deadlines when the periods and deadlines are integers. This paper presents a new necessary and sufficient condition for a given task system to be feasible and proposes a new feasibility decision algorithm based on that condition. The time complexity of this algorithm depends solely on the number of tasks. This condition can also be applied as a sufficient condition for a task system using priority inheritance protocols to be feasible with rate monotonic and deadline monotonic scheduling.