Sharing Non-Processor Resources in Multiprocessor Real-Time Systems

Computing devices are increasingly being leveraged in cyber-physical systems, in which computing devices sense, control, and interact with the physical world. Associated with many such real-world interactions are strict timing constraints, which if unsatisfied, can lead to catastrophic consequences. Modern examples of such timing constraints are prevalent in automotive systems, such as airbag controllers, anti-lock brakes, and new autonomous features. In all of these examples, a failure to correctly respond to an event in a timely fashion could lead to a crash, damage, injury and even loss of life. Systems with imperative timing constraints are called real-time systems, and are broadly the subject of this dissertation. Much previous work on real-time systems and scheduling theory assumes that computing tasks are independent, i.e., the only resource they share is the platform upon which they are executed. In practice, however, tasks share many resources, ranging from more overt resources such as shared memory objects, to less overt ones, including data buses and other hardware and I/O devices. Accesses to some such resources must be synchronized to ensure safety, i.e., logical correctness, while other resources may exhibit better run-time performance if accesses are explicitly synchronized. The goal of this dissertation was to develop new synchronization algorithms and associated analysis techniques that can be used to synchronize access to many classes of resources, while improving the overall resource utilization, specifically as measured by real-time schedulability. Towards that goal, the Real-Time Nested Locking Protocol (RNLP), the first multiprocessor real-time locking protocol that supports lock nesting or fine-grained locking is proposed and analyzed. Furthermore, the RNLP is extended to support reader/writer locking, as well as k-exclusion locking. All presented RNLP variants are proven optimal. Furthermore, experimental results demonstrate the schedulability-related benefits of the RNLP. Additionally, three new synchronization algorithms are presented, which are specifically motivated by the need to manage shared hardware resources to improve real-time predictability. Furthermore, two new classes of shared resources are defined, and the first synchronization algorithms for them are proposed. To analyze these new algorithms, a novel analysis technique called idleness analysis is presented, which can be used to incorporate the effects of blocking into schedulability analysis.Doctor of Philosoph

Efficient Synchronization for Real-Time Systems with Nested Resource Access

Real-time systems are comprised of tasks, each of which must be guaranteed to meet its timing requirements. These tasks may request access to shared system components, called resources. Each such request may experience delays before being granted resource access. These delays can be separated into two categories: (i) those caused by the order in which tasks are granted resource access, and (ii) those caused by the time it takes to coordinate this ordering. If these delays are too large, a task may be unable to meet its timing requirements. Tasks can require access to multiple resources concurrently, acquiring these resources in a nested fashion. This nested resource access can cause significant delays to tasks; these delays can far exceed those when only a single resource is required at a time, as certain request orderings cause delays between tasks that do not share any resources. This dissertation presents locking protocols and a protocol-independent approach to mitigate resource access delays. Nested resource access can increase delays for all requests, including non-nested requests. The first protocol eliminates these additional delays by separating requests by type and creating a fast-path mechanism for non-nested requests. The next two protocols both reduce delays by reordering requests. One protocol reorders requests as they are issued, and the other uses an offline process to determine which requests may execute concurrently. These three protocols were compared to prior approaches in an evaluation across a range of task systems; all three protocols resulted in more task systems guaranteed to meet their timing requirements. Finally, a protocol-independent approach reduces delays by using a designated task to execute the locking protocol on behalf of other tasks. When applied to two protocol variants, this approach significantly reduced delays.Doctor of Philosoph

Blocking analysis of spin locks under partitioned fixed-priority scheduling

Partitioned fixed-priority scheduling is widely used in embedded multicore real-time systems. In multicore systems, spin locks are one well-known technique used to synchronize conflicting accesses from different processor cores to shared resources (e.g., data structures). The use of spin locks can cause blocking. Accounting for blocking is a crucial part of static analysis techniques to establish correct temporal behavior. In this thesis, we consider two aspects inherent to the partitioned fixed-priority scheduling of tasks sharing resources protected by spin locks: (1) the assignment of tasks to processor cores to ensure correct timing, and (2) the blocking analysis required to derive bounds on the blocking. Heuristics commonly used for task assignment fail to produce assignments that ensure correct timing when shared resources protected by spin locks are used. We present an optimal approach that is guaranteed to find such an assignment if it exists (under the original MSRP analysis). Further, we present a well-performing and inexpensive heuristic. For most spin lock types, no blocking analysis is available in prior work, which renders them unusable in real-time systems. We present a blocking analysis approach that supports eight different types and is less pessimistic than prior analyses, where available. Further, we show that allowing nested requests for FIFO- and priority-ordered locks renders the blocking analysis problem NP-hard.Partitioned Fixed-Priority Scheduling ist in eingebetteten Multicore-Echtzeitsystemen weit verbreitet. In Multicore-Systemen sind Spinlocks ein bekannter Mechanismus um konkurrierende Zugriffe von unterschiedlichen Prozessorkernen auf geteilte Resourcen (z.B. Datenstrukturen) zu koordinieren. Bei der Nutzung von Spinlocks können Blockierungen auftreten, die in statischen Analysetechniken zum Nachweis des korrekten zeitlichen Verhaltens eines Systems zu berücksichtigen sind. Wir betrachten zwei Aspekte von Partitioned Fixed-Priority Scheduling in Verbindung mit Spinlocks zum Schutz geteilter Resourcen: (1) die Zuweisung von Tasks zu Prozessorkernen unter Einhaltung zeitlicher Vorgaben und (2) die Analyse zur Entwicklung oberer Schranken für die Blockierungsdauer. Übliche Heuristiken finden bei der Nutzung von Spinlocks oft keine Taskzuweisung, bei der die Einhaltung zeitlicher Vorgaben garantiert ist. Wir stellen einen optimalen Ansatz vor, der dies (mit der ursprünglichen MSRP Analyse) garantiert, falls eine solche Zuweisung existiert. Zudem präsentieren wir eine leistungsfähige Heuristik. Die meisten Arten von Spinlocks können mangels Analyse der Blockierungsdauer nicht für Echtzeitsysteme verwendet werden. Wir stellen einen Analyseansatz vor, der acht Spinlockarten unterstützt und weniger pessimistische Schranken liefert als vorherige Analysen, soweit vorhanden. Weiterhin zeigen wir, dass die Analyse bei verschachtelten Zugriffen mit FIFO- und prioritäts-geordneten Locks ein NP-hartes Problem ist