Challenges in Real-time Scheduling for Energy Harvesting Embedded Systems

Embedded processors have become increasingly complex, resulting in variable execution behavior and reduced timing predictability. On such processors, safe timing specifications expressed as bounds on the worst-case execution time (WCET) are generally too loose due to conservative assumptions about complex architectural features, timing anomalies and programmatic complexities. Hence, exploiting the latest architectures may not be an option for embedded systems with hard real-time constraints where deadline misses cannot be tolerated.This work addresses these shortcomings by contributing CheckerCore. CheckerCore is a mode-enhanced SPARC v8 soft core processor synthesized on an FPGA. During regular execution the core adheres to its original specifications. But when operating in a special time-checking configuration, CheckerCore executes programs irrespective of inputs and steers execution intentionally along selected control flow paths. Such execution allows systematic derivation of worst-case execution time (WCET) bounds. This paper presents the overall design and implementation of CheckerCore and also illustrates its use in deriving accurate WCET bounds for a set of embedded benchmarks. Overall, CheckerCore proposes a realistic processor core enhancement that encapsulate processor details without revealing them to users while supporting safe bounding of WCETs. To the best of our knowledge, this is the first contribution of a WCET-enhancing microarchitectural feature besides full processor encapsulations.

A real-time system is overloaded when all the tasks in a workload cannot meet their deadlines, and hence a robust algorithm is essential to maximize the number of tasks that meet their deadlines with the minimum number of miss rates and context switching. Although the Rate Monotonic (RM), Earliest Deadline First (EDF), and Least Laxity First (LLF) algorithms optimally perform and schedule tasks on a non-overloaded system, they have deficient performance when the system is overloaded. Therefore, we propose a new scheduling algorithm for uniprocessor and partitioned multiprocessor systems to address the overload situation. Since the proposed scheduling algorithm operates like EDF non-overloaded conditions, the proposed algorithm is optimal for non-overloaded systems. In addition, the proposed algorithm is robust against overloading situations as it executes the maximum possible tasks in the overload situation instead of missing deadlines of many tasks or burdening context switching to the system. The proposed algorithm allocates a processor to tasks based on the possibility of executing the task. The experimental results demonstrate that the proposed scheduling algorithm maximizes the number of tasks that meet their deadlines in overload conditions without a domino effect and context switching. In addition, the proposed algorithm achieves the lowest miss rate without context switching and the highest efficiency and processor utilization in the overloaded system compared with RM, EDF, and LLF.

A security-aware hardware scheduler for modern multi-core systems with hard real-time constraints

Since 1973, Earliest Deadline First (EDF) uniprocessor scheduling has been known to be superior to its Rate Monotonic (Fixed-Priority, FPS) counterpart. Such superiority manifested in optimality, the capacity of EDF to feasibly sustain full utilization, which FPS can only achieve in certain favorable circumstances. In 2005, further research results argued that EDF's superiority would also extend to finer-grained performance indicators, such as preemption count, release and response-time jitter, resilience to transient overload. Recent work allowed EDF uniprocessor scheduling to be used in place of default FPS in Ada Ravenscar systems with unchanged application code: this development provides an interesting and practical avenue for empirical EDF-to-RM performance comparisons in an especially lean and efficient embedded setting. We leveraged that opportunity to develop a toolbox that enables quantitative comparison of EDF-to-RM uniprocessor scheduling with lightweight run-time tracing and offline analytic. In this work we present that toolbox and illustrate results we obtained with it, which shed new light on the presumed superiority of EDF to RM.

Dynamic distribution of robot control components under hard realtime constraints – Modeling, experimental results and practical considerations

Scheduling tasks is an essential requirement in most real-time and embedded systems, but leads to unwanted central processing unit (CPU) overheads. The authors present a real-time schedulability algorithm for preemptable, asynchronous and periodic reconfigurable task systems with arbitrary relative deadlines, scheduled on a uniprocessor by an optimal scheduling algorithm based on the earliest deadline first (EDF) principles and on the dynamic reconfiguration. A reconfiguration scenario is assumed to be a dynamic automatic operation allowing addition, removal or update of operating system’s (OS) functional asynchronous tasks. When such a scenario is applied to save the system at the occurrence of hardware-software faults, or to improve its performance, some real-time properties can be violated. The authors propose an intelligent agent-based architecture where a software agent is used to satisfy the user requirements and to respect time constraints. The agent dynamically provides precious technical solutions for users when these constraints are not verified, by removing tasks according to predefined heuristic, or by modifying the worst case execution times (WCETs), periods, and deadlines of tasks in order to meet deadlines and to minimize their response time. They implement the agent to support these services which are applied to a Blackberry Bold 9700 and to a Volvo system and present and discuss the results of experiments.

In G. C. Buttazzo, Real-Time Syst., vol. 29, no. 1, pp. 5-26, 2005, the author empirically compared earliest deadline first (EDF) and rate monotonic (RM) scheduling algorithms and made a few EDF preemption behavior observations based on data obtained from the first 1000 time units of scheduling activities. However, based on test settings given in (G. C. Buttazzo, Real-Time Syst., vol. 29, no. 1, pp. 5-26, 2005), the first 1000 time units occupies only a small percentage of the entire task set's hyper-period. We extend EDF preemption behavior study by extending scheduling activities from the first small percentage of a hyper-period of a given task to the entire hyper-period. The extended experiments indicate that the number of preemptions occurred at the beginning of a task set's hyper-period does not necessarily represent the trend for the entire hyper-period. Hence, comparisons and conclusions made based on a small percentage of a scheduling interval over a task set's hyper-period may not be accurate. Second, the total number of preemptions within a task set's hyper-period does not decrease when the task set total utilization increases which is different from the observation obtained in (G. C. Buttazzo, Real-Time Syst., vol. 29, no. 1, pp. 5-26, 2005). We also investigate the impact of execution time differences among tasks on the preemption behavior.

Schedulability analysis of software-intensive systems requires solution techniques that go beyond worst-case assumptions, fostering a cross-fertilization between the areas of real-time systems and performance engineering. We address probabilistic schedulability analysis of tasks in single-processor non-preemptive real-time systems. To this end, we consider periodic tasks with offsets, scheduled by Fixed Priority (FP) or Earliest Deadline First (EDF), and managed by the discarding policy or the rejection policy to control deadline misses. Each task has a Worst Case Execution Time (WCET) which can be a deterministic value or a random variable, notably characterized by a non-Markovian distribution possibly with bounded support. A continuous-time stochastic model of task-set is specified through Stochastic Time Petri Nets (STPNs) and solved by regenerative transient analysis based on stochastic state classes. The evaluation of performance measures on resource allocation and missed deadlines enables the analysis of design choices and the estimation of over-provisioned resources that are likely to be unused at run-time. Feasibility and effectiveness of the approach are validated on randomly generated task-sets for different processor utilizations.

Our primary goal is to develop a compositional real-time scheduling framework where global (system-level) timing properties are established by composing together independently (specified and) analyzed local (component-level) timing properties. In this paper, we define two problems and one design issue in developing such a framework and present our approaches to the problems and the design issue. The two problems are (1) the scheduling interface derivation problem that is to (exactly) abstract the collective real-time requirements of a component as a single real-time requirement, or a scheduling interface and (2) the scheduling interface composition problem that is to (exactly) compose the scheduling interfaces of components into the system-level scheduling interface. The design issue is how to define a scheduling interface model. Our approach is to use the standard periodic model as the scheduling interface model and to address the two problems with the periodic model. We introduce exact conditions under which our proposed periodic scheduling interface model can abstract the collective real-time requirements that a set of periodic tasks demands under EDF (earliest deadline first) and RM (rate monotonic) scheduling. We present simulation results to evaluate the overheads that the periodic scheduling interfaces incur in terms of utilization increase.KeywordsSchedule AlgorithmSchedulability AnalysisSchedule FrameworkSchedule ComponentRate MonotonicThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

Multi-cores are the contemporary solution to satisfy high performance and low energy demands in general and embedded computing domains. However, currently available multi-cores are not feasible to be used in safety-critical environments with hard real-time constraints. Hard real-time tasks running on different cores must be executed in isolation or their interferences must be time-bounded. Thus, new requirements also arise for a real-time operating system (RTOS), in particular if the parallel execution of hard real-time applications should be supported. In this paper we focus on the MERASA system software as an RTOS developed on top of the MERASA multi-core processor. The MERASA system software fulfils the requirements for time-bounded execution of parallel hard real-time tasks. In particular we focus on thread control with synchronisation mechanisms, memory management and resource management requirements. Our evaluations show that all system software functions are time-bounded by a worst-case execution time (WCET) analysis.

On the computational complexity of periodic scheduling

Recently various real-time scheduling algorithms are being studied in order to maximize throughput per unit time in real-time disk scheduling. Particularly in many algorithms, SCAN technique is applied to EDF (earliest deadline first), which represents real-time disk scheduling algorithms. However, proposed algorithms have many restrictions because they have to consider I/O requests that continue to be made while SCAN groups are being created. In addition, the fixed service direction in the SCAN technique lowers the efficiency of the disk. In order to solve the problem, this paper proposed a new real-time disk scheduling algorithm based on the insertion technique and the two-way SCAN technique and proved the superiority of the proposed system in terms of throughput per unit time and serviceable I/O requests through an experiment.

One of the core functions of an operating system is scheduling applications such that overall system provides a satisfactory result. Real-time embedded systems have an additional requisite to provide correct output within deadline; failure could be catastrophic for safety critical systems. In this paper, the feasibility of Primary-Backup Fault Tolerant Scheduling (PB-FTS) to handle application level faults by means of switching between primary and secondary copy of task is examined. PB-FTS, which is the secondary scheduler, is evaluated over the different traditional scheduling algorithms such as Rate Monotonic (RM), Deadline Monotonic (DM) and Earliest Deadline First (EDF) under various fault scenarios. The fault handling capacity and performance of PB-FTS is measured by running MATLAB based simulations. Simulation results indicate a decreasing trend in fault handling capacity from 100% at 0.6 utilization factor for one fault to 53% at 1.0 utilization factor for three faults.

Cache partitioning is a technique to reduce interference among tasks running on the processors with shared caches. To make this technique effective, cache segments should be allocated to tasks that will benefit the most from having their data and instructions stored in the cache. The requests for cached data and instructions can be retrieved faster from the cache memory instead of fetching them from the main memory, thereby reducing overall execution time. The existing partitioning schemes for real-time systems divide the available cache among the tasks to guarantee their schedulability as the sole and primary optimization criterion. However, it is also preferable, particularly in systems with power constraints or mixed criticalities where low- and high-criticality workloads are executing alongside, to reduce the total cache usage for real-time tasks. Cache minimization as part of design space exploration can also help in achieving optimal system performance and resource utilization in embedded systems. In this paper, we develop optimization algorithms for cache partitioning that, besides ensuring schedulability, also minimize cache usage. We consider both preemptive and non-preemptive scheduling policies on single-processor systems with fixed- and dynamic-priority scheduling algorithms (Rate Monotonic (RM) and Earliest Deadline First (EDF), respectively). For preemptive scheduling, we formulate the problem as an integer quadratically constrained program and propose an efficient heuristic achieving near-optimal solutions. For non-preemptive scheduling, we combine linear and binary search techniques with different fixed-priority schedulability tests and Quick Processor-demand Analysis (QPA) for EDF. Our experiments based on synthetic task sets with parameters from real-world embedded applications show that the proposed heuristic: (i) achieves an average optimality gap of 0.79% within 0.1× run time of a mathematical programming solver and (ii) reduces average cache usage by 39.15% compared to existing cache partitioning approaches. Besides, we find that for large task sets with high utilization, non-preemptive scheduling can use less cache than preemptive to guarantee schedulability.

The ability of the system to complete the task within the stipulated deadline is an important parameter for real time systems. The relative deadlines for the processes may vary under different process load which is analysed in this paper using two widely used scheduling algorithms, Earliest Deadline First (EDF) and Rate Monotonic (RM). Also, different load conditions are considered which are classified as minimum, medium and maximum load in a system. The performance of the system under different load is graphically represented considering wide range of processes.