Preemption-based avoidance of priority inversion for Java

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.

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.

The problem of priority inversion occurs when a high priority task is required to wait for completion of some other task with low priority as a result of conflict in accessing the shared system resource(s). This problem is discussed by many researchers covering a wide range of research areas. Some of the key research areas are real-time operating systems, real-time systems, real-time databases, and distributed real-time databases. Irrespective of the application area, however, the problem lies with the fact that priority inversion can only be controlled with no method available to eliminate it entirely. In this chapter, the priority inversion-related scheduling issues and research efforts in this direction are discussed. Different approaches and their effectiveness to resolve this problem are analytically compared. Finally, major research accomplishments to date have been summarized and several unanswered research questions have also been listed.

We come across several times the term “real time” tagged before any other noun or verb, like real-time data, real-time monitoring, real-time governance, and so on. Let us understand what real time signifies. After completing this chapter, one will be able to un-tag the term “real time” from many such usages. In this chapter, we will understand the characteristics of a system that qualifies it, to be called as real-time system. Then, we will classify the RT systems based on their traits. We will study the reference model by which we can analyze the system and focus on important aspects of them. We will study scheduling mechanisms through supporting algorithms to reach real-time constraints. Section 6.2 classifies real-time systems (RTS) to periodic, mostly periodic, aperiodic, and predictable and unpredictable (spurious) systems. Section 6.4 deals with models to execute such periodic tasks. Section 6.6 classifies scheduling algorithms. Section 6.7 deals with clock-driven scheduling. Section 6.8 deals with scheduling priority-driven periodic tasks. Section 6.9 deals with scheduling tasks with dynamic priority like Earliest Deadline First (EDF) and Least Slack Time First (LST). Section 6.10 deals with scheduling sporadic tasks. Section 6.11 deals with accessing resources by multiple tasks, handling the contention for resources and how to handle cases of priority inversion. To summarize, aperiodic jobs are soft and can be accommodated by stealing slack times and idle slots. Tasks can be prioritized based on their rate. RMA is a popular protocol. Priorities of jobs can be assigned using early deadlines and also the least slack time. EDF algorithms are most popular. Sporadic jobs are unpredictable with varied properties. Given a context, a sporadic job can be accepted if it is schedulable. Sporadic jobs have to be handled in a separate queue. The above algorithms assume no contention of resources. Resource contention modifies the execution times based on the availability of resources and the critical section of the resources in each job. The most serious problem is priority inversion, which has to be taken care with multiple algorithms like priority inheritance. This chapter becomes the input to the next chapter where we study the architecture of real-time executives, their standardization, and their features.

Uc/OS-II is an open-code real-time kernel based preemptive priority scheduling strategy. It assigns a unique priority for each task and does not support to schedule same priority tasks. In practical applications, assigning different priority for tasks which realizing the same function is not a very good logical design. Moreover it can only create a maximum of 64 tasks, which can not meet the needs of increasingly complex applications. Aiming at these problems, in the paper, the real time kernel uC/OS-II is modified. The new kernal creatively gives an approach of layered hybird scheduling for subsystem and jobs. The modified kernel divides a application system to some subsystems which is composed of several relevent jobs. There is a two layer hybird scheduling strategy which schedule subsystem based on priority and schedule jobs in the subsystem based on Hybrid scheduling method. Preemptive scheduling based on priority is adopted for jobs having different priority in the subsystem, while, round-robin scheduling is adopted for jobs having the same priority in the subsystem, which greatly augments application range of uC/OS-II. This paper also expounds the cause of priority inversion and the effect on system real-time performance, and two approaches named priority inheritance protocol and priority ceiling protocol are proposed to be used in uC/OS-II for restraining priority inversion phenomenon. Experiments testing show that the proposed subsystem hybrid scheduling algorithm and the method to realize restraining priority inversion protocols in uC/OS-II are feasible and effective.

To utilize the multi-core processors properly concurrent programming is needed. The main challenge is to design a correct and efficient concurrent program. Software Transactional Memory Systems (STMs) provide ease of multithreading to the programmer without worrying about concurrency issues as deadlock, livelock, priority inversion, etc. Most of the STMs work on read-write operations known as RWSTMs. Some STMs work at higher-level operations and ensure greater concurrency than RWSTMs. Such STMs are known as Single-Version Object-based STMs (SVOSTMs). The transactions of SVOSTMs can return commit or abort. Aborted SVOSTMs transactions retry. But in the current setting of SVOSTMs, transactions may starve. So, we propose a Starvation-Freedom in SVOSTM as SF-SVOSTM that satisfies the correctness criteria conflict-opacity.

The reality of multi-core hardware has made concurrent programs pervasive. Unfortunately, writing correct concurrent programs is difficult. Addressing this challenge requires advances in multiple directions, including concurrency bug detection, concurrent program testing, concurrent programming model design, etc. Designing effective techniques in all these directions will significantly benefit from a deep understanding of real world concurrency bug characteristics. This paper provides the first (to the best of our knowledge) comprehensive real world concurrency bug characteristic study. Specifically, we have carefully examined concurrency bug patterns, manifestation, and fix strategies of 105 randomly selected real world concurrency bugs from 4 representative server and client open-source applications (MySQL, Apache, Mozilla and OpenOffice). Our study reveals several interesting findings and provides useful guidance for concurrency bug detection, testing, and concurrent programming language design. Some of our findings are as follows: (1) Around one third of the examined non-deadlock concurrency bugs are caused by violation to programmers' order intentions, which may not be easily expressed via synchronization primitives like locks and transactional memories; (2) Around 34% of the examined non-deadlock concurrency bugs involve multiple variables, which are not well addressed by existing bug detection tools; (3) About 92% of the examined concurrency bugs canbe reliably triggered by enforcing certain orders among no more than 4 memory accesses. This indicates that testing concurrent programs can target at exploring possible orders among every small groups of memory accesses, instead of among all memory accesses; (4) About 73% of the examinednon-deadlock concurrency bugs were not fixed by simply adding or changing locks, and many of the fixes were not correct at the first try, indicating the difficulty of reasoning concurrent execution by programmers.

The 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.

The problem of pairwise CFL-reachability is to decide whether two given program locations in different threads are simultaneously reachable in the presence of recursion in threads and scheduling constraints imposed by synchronization primitives. Pairwise CFL-reachability is the core problem underlying concurrent program analysis especially dataflow analysis. Unfortunately, it is undecidable even for the most commonly used synchronization primitive, i.e., mutex locks. Lock usage in concurrent programs can be characterized in terms of lock chains, where a sequence of mutex locks is said to be chained if the scopes of adjacent (non-nested) mutexes overlap. Although pairwise reachability is known to decidable for threads interacting via nested locks, i.e., chains of length one, these techniques donpsilat extend to programs with non-nested locks used in crucial applications like databases and device drivers. In this paper, we exploit the fact that lock usage patterns in real life programs do not produce unbounded lock chains. For such programs, we show that pairwise CFL-reachability becomes decidable. Our new results narrow the decidability gap for pairwise CFL-reachability by providing a more refined characterization for it in terms of boundedness of lock chains rather than the current state-of-the-art, i.e., nestedness of locks (chains of length one).

GPUs are widely adopted in HPC and cloud computing platforms to accelerate general-purpose workloads. However, modern GPUs do not support flexible preemption, leading to performance and priority inversion problems in multi-tasking environments. In this paper, we propose and develop FLEP, the first software system that enables flexible kernel preemption and kernel scheduling on commodity GPUs. The FLEP compilation engine transforms the GPU program into preemptable forms, which can be interrupted during execution and yield all or part of the streaming multi-processors (SMs) in the GPU. The FLEP runtime engine intercepts all kernel invocations and determines which kernels and how those kernels should be preempted and scheduled. Experimental results on two-kernel co-runs demonstrate up to 24.2X speedup for high-priority kernels and up to 27X improvement on normalized average turnaround time for kernels with the same priority. FLEP reduces the preemption latency by up to 41% compared to yielding the whole GPU when the waiting kernels only need several SMs. With all the benefits, FLEP only introduces 2.5% runtime overhead, which is substantially lower than the kernel slicing approach.

The real-time performance of control network between process control system(PCS) in a nuclear power plant is an important factor to ensure safety and reliability of power plant. Ethernet network is widely adopted in modern PCS even though it does not guarantee hard real-time performance in the non-safety region of a nuclear power plant. To achieve better real-time performance and QoS(Quality of Service), PCS usually uses switched Ethernet with the priority feature, which is based on the IEEE 802.1Q/p protocol. However, the IEEE 802.1Q/p protocol also has a priority inversion problem when transmission of a higher-priority frame is requested during transmission of a lower-priority frame. To resolve this problem, this paper proposes Preemptive Switched Ethernet(PSE) that is based on the IEEE 802.1Q/p protocol with a preemption mechanism. This paper shows that PSE provides better real-time performance than the standard IEEE 802.1Q/p protocol especially when non-real-time and real-time traffics are mixed together. This paper also implements PSE controller using the FPGA (Virtex-4) and MicroBlaze processor. From the implementation results, PSE controller shows an improved latency and jitters of transmission period compare to the normal Ethernet controller. Experiment result shows that the jitter of real-time packet is 50% less than the standard 802.1Q/p protocol.

Few static analyses support concurrent higher-order programs. Tools for detecting concurrency bugs such as deadlocks and race conditions are nonetheless invaluable to developers. Concurrency can be implemented using a variety of models, each supported by different synchronization primitives. Using this poster, we present an approach for analyzing concurrent higher-order programs in a precise manner through abstract interpretation. We instantiate the approach for two static analyses that are capable of detecting deadlocks and race conditions in programs that rely either on compare-and-swap (cas), or on conventional locks for synchronization. We observe few false positives and false negatives on a corpus of small concurrent programs, with better results for the lock-based analyses. We also observe that these programs lead to a smaller state space to be explored by the analyses. Our results show that the choice of synchronization primitives supported by an abstract interpreter has an important impact on the complexity of the static analyses performed with this abstract interpreter.

Run-time errors in concurrent programs are generally due to the wrong usage of synchronization primitives such as monitors. Conventional validation techniques such as testing become ineffective for concurrent programs since the state space increases exponentially with the number of concurrent processes. In this paper, we propose an approach in which 1) the concurrency control component of a concurrent program is formally specified, 2) it is verified automatically using model checking, and 3) the code for concurrency control component is automatically generated. We use monitors as the synchronization primitive to control access to a shared resource by multipleconcurrent processes. Since our approach decouples the concurrency control component from the rest of the implementation it is scalable. We demonstrate the usefulness of our approach by applying it to a case study on Airport Ground Traffic Control.We use the Action Language to specify the concurrency control component of a system. Action Language is a specification language for reactive software systems. It is supported by an infinite-state model checker that can verify systems with boolean, enumerated and udbounded integer variables. Our code generation tool automatically translates the verified Action Language specification into a Java monitor. Our translation algorithm employs symbolic manipulation techniques and the specific notification pattern to generate an optimized monitor class by eliminating the context switch overhead introduced as a result of unnecessary thread notification. Using counting abstraction, we show that we can automatically verify the monitor specifications for arbitrary number of threads.

Designing irregular parallel algorithms with mutual exclusion and lock-free protocols

This paper focuses on resource sharing in hierarchical fixed priority pre-emptive systems where a number of separate applications, each with its own server, reside on a single processor. It defines the hierarchical stack resource policy, an appropriate global resource access policy that bounds priority inversion and also limits interference due to overruns during resource access. The paper provides detailed response time analysis enabling the schedulability of application servers and tasks to be determined for systems with local and global resource access. This analysis is applicable to real-world systems where server-based applications need mutually exclusive access to shared resources such as communications buffers, peripheral devices, operating system calls and data structures shared with interrupt handlers