https://www.mdu.se/

This paper presents a protocol for resource sharing in a hierarchical real-time scheduling framework. Targeting real-time open systems, the protocol and the scheduling framework significantly reduce the efforts and errors associated with integrating multiple semi-independent subsystems on a single processor. Thus, our proposed techniques facilitate modern software development processes, where subsystems are developed by independent teams (or subcontractors) and at a later stage integrated into a single product. Using our solution, a subsystem need not know, and is not dependent on, the timing behaviour of other subsystems; even though they share mutually exclusive resources. In this paper we also prove the correctness of our approach and evaluate its efficiency.

The Hierarchical Scheduling Framework (HSF) has been introduced as a design-time framework toenable compositional schedulability analysis of embedded software systems with real-time properties. Inthis paper a software system consists of a number of semi-independent components called subsystems.Subsystems are developed independently and later integrated to form a system. To support this designprocess, in the paper, the proposed methods allow non-intrusive configuration and tuning of subsystemtiming-behaviour via subsystem interfaces for selecting scheduling parameters.This paper considers three methods to handle overruns due to resource sharing between subsystemsin the HSF. For each one of these three overrun methods corresponding scheduling algorithms and associatedschedulability analysis are presented together with analysis that shows under what circumstances one or the other is preferred. The analysis is generalized to allow for both Fixed Priority Scheduling (FPS)and Earliest Deadline First (EDF) scheduling. Also, a further contribution of the paper is the techniqueof calculating resource-holding times within the framework under different scheduling algorithms; theresource holding times being an important parameter in the global schedulability analysis.

This paper presents a new schedulability analysis for hierarchically scheduled real-time systems executing on a single processor using SIRAP; a synchronization protocol for inter subsystem task synchronization. We show that it is possible to bound the number of self-blocking occurrences that should be taken into consideration in the schedulability analysis of subsystems. Correspondingly, we present two novel schedulability analysis approaches with proof of correctness for SIRAP. An evaluation suggests that this new schedulability analysis can decrease the analytical subsystem utilization significantly

In this paper, we show that both global as well as local schedulability analysis of synchronization protocols based on the stack resource protocol (SRP) and overrun without payback for hierarchical scheduling frameworks based on fixed-priority pre-emptive scheduling (FPPS) are pessimistic.We present improved global and local schedulability analysis,illustrate the improvements by means of examples, and show that the improved global analysis is both uniform and sustainable.We evaluate the improved global and local schedulabilityanalysis based on an extensive simulation study and comparethe results with the existing analysis.

This paper presents algorithms that (1) facilitate system independent synthesis of timing-interfaces for subsystems and (2) system-level selection of interfaces to minimize CPU load. The results presented are developed for hierarchical fixed-priority scheduling of subsystems that may share logical recourses (i.e., semaphores). We show that the use of shared resources results in a tradeoff problem, where resource locking times can be traded for CPU allocation, complicating the problem of finding the optimal interface configuration subject to schedulability. This paper presents a methodology where such a tradeoff can be effectively explored. It first synthesizes a bounded set of interface-candidates for each subsystem, independently of the final system, such that the set contains the interface that minimizes system load for any given  system. Then, integrating subsystems into a system, it finds the optimal selection of interfaces. Our algorithms have linear complexity to the number of tasks involved. Thus, our approach is highly suitable for adaptable and reconfigurable systems.