Least Laxity First Research Articles

Real-Time Scheduling on Hierarchical Heterogeneous Fog Networks

Cloud computing is widely used to support offloaded data processing for applications. However, latency constrained data processing has requirements that may not always be suitable for cloud-based processing. Fog computing brings processing closer to data generation sources, by reducing propagation and data transfer delays. It is a viable alternative for processing tasks with real-time requirements. We propose a scheduling algorithm RTH2S (Real Time Heterogeneous Hierarchical Scheduling) for a set of real-time tasks on a heterogeneous integrated fog-cloud architecture. We consider a hierarchical model for fog nodes, with nodes at higher tiers having greater computational capacity than nodes at lower tiers, though with greater latency from data generation sources. Tasks with various profiles have been considered. For regular profile jobs, we use least laxity first (LLF) to find the preferred fog node for scheduling. For tagged profiles, based on tag values, the jobs are split in order to finish execution before the deadline, or the LLF heuristic is used. Using HPC2N workload traces across 3.5 years of activity, the real-time performance of RTH2S versus comparable algorithms is demonstrated. Our proposed approach is validated using both simulation (to demonstrate scale up) as well as a lab-based testbed.

A Hybrid Traffic Scheduling Strategy for Time-Sensitive Networking

The traffic scheduling mechanism in Time-Sensitive Networking (TSN) is the key to guaranteeing the deterministic transmission of traffic. However, when time-sensitive traffic and non-time-sensitive traffic are transmitted together, traffic scheduling conflicts are easy to occur in TSN. As a result, the deterministic transmission of time-sensitive traffic will be disrupted, and non-time-sensitive traffic may be preempted for a long time. To optimize the performance of multi-type hybrid traffic scheduling in TSN, we firstly establish a collaborative scheduling framework that incorporates Time Aware Shaping (TAS) and Cyclic Queuing and Forwarding (CQF) mechanisms. We then design a traffic shaping method in this framework based on Least Laxity First (LLF), which considers traffic characteristics to dynamically arrange the time slot injection sequence for different types of traffic. Finally, the traffic schedulability is evaluated based on the scheduling constraints of different types of traffic. Compared with the existing scheduling strategies, the proposed hybrid traffic scheduling strategy can schedule more non-time-sensitive traffic and achieve better delay performance of rate-constrained traffic in different hybrid traffic scenarios. When the number of flows is 100, the time slot injection ratio is increased by 24.3% compared with the LLF_TAS method.

Strictly periodic first: An optimal variant of LLF for scheduling tasks in a time‐critical cyber‐physical system

SummaryCyber‐physical systems (CPSs) include time‐critical embedded systems where strict timing constraints are considered. These specific CPSs are dealing with close loop control functions, they are interfacing to sensors and actuators and have to fulfill safety critical real‐time constraints. To guarantee the timing correctness, a lot of work introduced the strict‐periodicity constraint. The latter is of great importance since it concerns sensors/actuators periodic tasks for which the relevancy of information they use is linked to the accuracy of their repetition. Applied to real‐time control systems, the strict‐periodicity constraint ensures much more stability and robustness. Therefore, the problem of scheduling real‐time strictly periodic tasks has been targeted by several works in the literature but all these works were interested in nonpreemptive systems. In this work, we consider as strictly periodic and nonpreemptive only the sensory subtask and the remaining portion of the task may be preempted. This way, input transaction of every task receives the highest priority when accessing processor resource which enhances system predictability. On the other hand, the preemption allows easing schedulability analysis and, most of the time, it leads to a better processor utilization. The article proposes an optimal such task scheduling algorithm, called SPF for Strictly Periodic First, based on the Least Laxity First (LLF) scheduler and an efficient schedulability analysis. Simulation experiments with randomly generated task sets allowed showing the effectiveness of the proposed approach.

Enhancing the Energy-Efficiency and Timeliness of IoT Communication in WiFi Networks

Increasing the number of Internet of Things (IoT) stations or regular stations escalates downlink channel access contention and queuing delay, which in turn result in higher energy consumption and longer communication delays with IoT stations. To remedy this problem, this paper presents WiFi IoT access point (Wiotap), an enhanced WiFi access point (AP) that implements a downlink packet scheduling mechanism. In addition to assigning higher priority to IoT traffic compared to regular traffic, the scheduling algorithm computes per-packet priorities to arbitrate the contention between the transmission of IoT packets. This algorithm employs a least-laxity first (LLF) scheme that assigns priorities based on the remaining wake-up time of the destination stations. We used simulation to show the scalability of the proposed system. Our results show that Wiotap achieves 37% improvement regarding the duty cycle of IoT stations compared to a regular AP. In addition, we developed a testbed to confirm the implementation correctness and the performance benefits of Wiotap in a network with four IoT stations and regular traffic. For the edge and cloud scenarios, our empirical evaluations show up to 44% and 38% improvement in energy and 52% and 41% improvement in delay, respectively.

Comparison of Scheduling Algorithms in The Design of Fault Tolerant Real Time Systems

Most of the real time systems have the timing constraints. The main important timing constraints of any real time systems are to meet the deadlines of its application tasks. Not only satisfying the timing constraints of any real-time system, but also the functional correctness of application needs to be guaranteed. Meeting the dead line of application is no use if it deviates from its precise output. Timing constraints of the system can be satisfied by choosing proper task scheduling algorithms and the reliability of the system can be reached by providing fault-tolerance. In this paper, various fault scheduling algorithms like fixed priority, EDF(Earliest dead line first), LLF (Least Laxity First),Rate monotonic etc have been studied and compare the parameters like Worst-case execution times, response time, task missed deadlines, Number of preemption, number of context switches, Deadlock and processor utilization factor.

Go-realtime

We present the design of Go-RealTime, a lightweight framework for real-time parallel programming based on Go language. Go-RealTime is implemented in user space with portability and efficiency as important design goals. It takes the advantage of Go language's ease of programming and natural model of concurrency. Goroutines are adapted to provide scheduling for real-time tasks, with resource reservation enabled by exposing Linux APIs to Go. We demonstrate nearly full utilization on 32 processors scheduling periodic heavy tasks using Least Laxity First (LLF) algorithm. With its abstraction and system support, Go-RealTime greatly simplifies the set up of sequential and parallel real-time programs on multiprocessor systems.

A Fuzzy Algorithm for Real-Time Scheduling of Soft Periodic Tasks

Many scheduling algorithms have been studied to guarantee the time constraints of real-time processes. Scheduling decision of these algorithms is usually based on parameters which are assumed to be crisp. However, in many circumstances the values of these parameters are vague. The vagueness of parameters suggests that we make use of fuzzy logic to decide in what order the requests should be executed to better utilize the system and as a result reduce the chance of a request being missed. We have proposed a new fuzzy algorithm called highest fuzzy priority first. The performance of this algorithm is compared with the well-known earliest deadline first (EDF) algorithm as well as least laxity first (LLF) algorithm through simulation. The simulations were divided into two parts. Firs, the tasks were considered to be preemptable, and second tasks were assumed to be non-preemptable. Simulation results show that this fuzzy approach outperforms the EDF and LLF. It is concluded that the proposed fuzzy approach is very promising and it has the potential to be considered for future research.

Real-Time Scheduling of Distributed Resources

We develop and analyze real-time scheduling algorithms for coordinated aggregation of deferrable loads and storage. These distributed resources offer flexibility that can enable the integration of renewable generation by reducing reserve costs. We present three scheduling policies: earliest deadline first (EDF), least laxity first (LLF), and receding horizon control (RHC). We offer a novel cost metric for RHC-based scheduling that explicitly accounts for reserve costs. We study the performance of these algorithms in the metrics of reserve energy and capacity through simulation studies. We conclude that the benefits of coordinated aggregation can be realized from modest levels of both deferrable load participation and flexibility.

Demand-based schedulability analysis for real-time multi-core scheduling

In real-time systems, schedulability analysis has been widely studied to provide offline guarantees on temporal correctness, producing many analysis methods. The demand-based schedulability analysis method has a great potential for high schedulability performance and broad applicability. However, such a potential is not yet fully realized for real-time multi-core scheduling mainly due to (i) the difficulty of calculating the resource demand under dynamic priority scheduling algorithms that are favorable to multi-cores, and (ii) the lack of understanding how to combine the analysis framework with deadline-miss conditions specialized for those scheduling algorithms. Addressing those two issues, to the best of our knowledge, this paper presents the first demand-based schedulability analysis for dynamic job-priority scheduling algorithms: EDZL (Earliest Deadline first until Zero-Laxity) and LLF (Least Laxity First), which are known to be effective for real-time multi-core scheduling. To this end, we first derive demand bound functions that compute the maximum possible amount of resource demand of jobs of each task while the priority of each job can change dynamically under EDZL and LLF. Then, we develop demand-based schedulability analyses for EDZL and LLF, by incorporating those new demand bound functions into the existing demand-based analysis framework. Finally, we combine the framework with additional deadline-miss conditions specialized for those two laxity-based dynamic job-priority scheduling algorithms, yielding tighter schedulability analyses. Via simulations, we demonstrate that the proposed schedulability analyses outperform the existing schedulability analyses for EDZL and LLF.

Laxity dynamics and LLF schedulability analysis on multiprocessor platforms

LLF (Least Laxity First) scheduling, which assigns a higher priority to a task with a smaller laxity, has been known as an optimal preemptive scheduling algorithm on a single processor platform. However, little work has been made to illuminate its characteristics upon multiprocessor platforms. In this paper, we identify the dynamics of laxity from the system's viewpoint and translate the dynamics into LLF multiprocessor schedulability analysis. More specifically, we first characterize laxity properties under LLF scheduling, focusing on laxity dynamics associated with a deadline miss. These laxity dynamics describe a lower bound, which leads to the deadline miss, on the number of tasks of certain laxity values at certain time instants. This lower bound is significant because it represents invariants for highly dynamic system parameters (laxity values). Since the laxity of a task is dependent of the amount of interference of higher-priority tasks, we can then derive a set of conditions to check whether a given task system can go into the laxity dynamics towards a deadline miss. This way, to the author's best knowledge, we propose the first LLF multiprocessor schedulability test based on its own laxity properties. We also develop an improved schedulability test that exploits slack values. We mathematically prove that the proposed LLF tests dominate the state-of-the-art EDZL tests. We also present simulation results to evaluate schedulability performance of both the original and improved LLF tests in a quantitative manner.

A Least-Laxity-First Scheduling Algorithm of Variable Time Slice for Periodic Tasks

The LLF (Least Laxity First) scheduling algorithm assigns a priority to a task according to its executing urgency. The smaller the laxity value of a task is, the sooner it needs to be executed. When two or more tasks have same or approximate laxity values, LLF scheduling algorithm leads to frequent switches among tasks, causes extra overhead in a system, and therefore, restricts its application. The least switch and laxity first scheduling algorithm is proposed in this paper by searching out an appropriate common divisor in order to improve the LLF algorithm for periodic tasks.

다중프로세서 시스템을 위한 여유시간 기반의 온라인 실시간 스케줄링 알고리즘

For multiprocessor systems, Earliest Deadline First (EDF) based on deadline and Least Laxity First (LLF) based on laxity are not suitable for practical environment since EDF has low schedulability and LLF has high context switching overhead. As a combining of EDF and LLF to improve the performance, Earliest Deadline Zero Laxity (EDZL) was proposed. EDZL is basically the same as EDF. But if the laxity of a task becomes zero, its priority is promoted to the highest level. In this paper, we propose Least Laxity Zero Laxity (LLZL) which is based on LLF. But context switching is allowed only if the laxity of a task on rady queue becomes zero. Simulation results show that LLZL has high schedulability approaching to LLF and low context switching overhead similar to EDF. In comparison with EDZL, LLZL has better performance in both of schedulability and context switching overhead.

Resource access control for dynamic priority distributed real-time systems

Many of today's complex computer applications are being modeled and constructed using the principles inherent to real-time distributed object systems. In response to this demand, the Object Management Group's (OMG) Real-Time Special Interest Group (RT SIG) has worked to extend the Common Object Request Broker Architecture (CORBA) standard to include real-time specifications. This group's most recent efforts focus on the requirements of dynamic distributed real-time systems. One open problem in this area is resource access synchronization for tasks employing dynamic priority scheduling. This paper presents two resource synchronization protocols that meet the requirements of dynamic distributed real-time systems as specified by Dynamic Scheduling Real-Time CORBA 2.0 (DSRT CORBA). The proposed protocols can be applied to both Earliest Deadline First (EDF) and Least Laxity First (LLF) dynamic scheduling algorithms, allow distributed nested critical sections, and avoid unnecessary runtime overhead. These protocols are based on (i) distributed resource preclaiming that allocates resources in the message-based distributed system for deadlock prevention, (ii) distributed priority inheritance that bounds local and remote priority inversion, and (iii) distributed preemption ceilings that delimit the priority inversion time further.

Simulation of resource synchronization in a dynamic real‐time distributed computing environment

AbstractToday, more and more distributed computer applications are being modeled and constructed using real‐time principles and concepts. In 1989, the Object Management Group (OMG) formed a Real‐Time Special Interest Group (RT SIG) with the goal of extending the Common Object Request Broker Architecture (CORBA) standard to include real‐time specifications. This group's most recent efforts have focused on the requirements of dynamic distributed real‐time systems.One open problem in this area is resource access synchronization for tasks employing dynamic priority scheduling. This paper presents two resource synchronization protocols that the authors have developed which meet the requirements of dynamic distributed real‐time systems as specified by Dynamic Scheduling Real‐Time CORBA (DSRT CORBA). The proposed protocols can be applied to both Earliest Deadline First (EDF) and Least Laxity First (LLF) dynamic scheduling algorithms, allow distributed nested critical sections, and avoid unnecessary runtime overhead. In order to evaluate the performance of the proposed protocols, we analyzed each protocol's schedulability. Since the schedulability of the system is affected by numerous system configuration parameters, we have designed simulation experiments to isolate and illustrate the impact of each individual system parameter. Simulation experiments show the proposed protocols have better performance than one would realize by applying a schema that utilizes dynamic priority ceiling update. Copyright © 2004 John Wiley & Sons, Ltd.

Real-time event-handling and scheduling on a multithreaded Java microcontroller

Our aim is to investigate the suitability of hardware multithreading for real-time event handling in combination with appropriate real-time scheduling techniques. We designed and evaluated a multithreaded microcontroller based on a Java processor core. Java threads are used as Interrupt Service Threads (ISTs) instead of the Interrupt Service Routines (ISRs) of conventional processors. Our proposed Komodo microcontroller supports multiple ISTs with zero-cycle context switching overhead. A so-called priority manager implements several real-time scheduling algorithms in hardware. We show the feasibility of a hardware real-time scheduler integrated deeply into the processor pipeline with a VHDL design and its synthesis. Evaluations with a software simulator and real-time applications as benchmarks show that hardware multithreading reaches a 1.2–1.4 performance increase for hard real-time applications (multithreading without latency utilization) and a 2.0–2.6 speedup by latency utilization for programs without hard real-time requirements. With respect to real-time scheduling on a multithreaded microcontroller, the Least Laxity First (LLF) scheme outperforms the Fixed Priority Preemptive (FPP), Earliest Deadline First (EDF), and Guaranteed Percentage (GP) schemes, but suffers from the highest implementation costs.

Errata: A New Algorithm for Scheduling Periodic, Real-Time Tasks

Two well known algorithms for real-time scheduling are the Least Laxity First (LLF) algorithm and the Earliest Deadline First (EDF) algorithm. The EDF algorithm always runs the jobs with earliest deadline. The LLF algorithm always runs the jobs with least laxity; the laxity of a job is its deadline minus the sum of its remaining processing time and the current time. In the paper [1], it was claimed that every instance schedulable by EDF on m processors is also schedulable by LLF on m processors. We show that this claim is, in fact, incorrect. We give an instance I DfJ1; J2; J3; J4; J5; J6g, such that EDF completes all jobs in I by their deadline on two processors, while LLF does not complete every job in I by its deadline on two processors. We use the notation JiD.ri; xi; di/ to denote that the arrival time of the job Ji is ri , the length of the job Ji is xi , and the deadline of the job Ji is di . The instance I is then

DYNAMIC SCHEDULING SOLUTIONS FOR REAL-TIME MULTIPROCESSOR SYSTEMS

This paper analyzes the behavior and performance of four dynamic algorithms for multiprocessor scheduling of hard real-time tasks. The well-known algorithms are the Earliest Deadline First (EDF) algorithm and the Least Laxity First (LLF) algorithm. An important feature of the original ones is that they are guarantee-oriented. The performance of these algorithms has been measured through simulations which analyze the behavior of the algorithms under two main load hypotheses: static loads and dynamic loads. The simulation results present practical bounds and a comparative study of the loads that they are able to guarantee, context switches and cpu utilization. Copyright © 1997 Elsevier Science Ltd

Dynamic Scheduling Solutions for Real-Time Multiprocessor Systems

This paper analyzes the behavior and performance of four dynamic algorithms for multiprocessor scheduling of hard real-time tasks. The well known algorithms are the Earliest Deadline First (EDF) algorithm and the Least Laxity First (LLF) algorithm. An important feature of the original ones is that they are guarantee-oriented.The performance of these algorithms has been measured through simulations which analyze the behavior of the algorithms under two main load hypothesis: static load and dynamic load. Simulation results present practical bounds and a comparative study on the loads that they are able to guarantee, context switches and cpu utilization.