Optimal deadline assignment for periodic real-time tasks in dynamic priority systems

Allocation problem has always been one of the fundamental issues of building the applications in real-time computing systems. For real-time applications, the allocation problem should directly address the issues of task and communication scheduling. In this context, the allocation of tasks has to fully utilize the available processors and the scheduling of tasks has to meet the specified timing constraints. Clearly, the execution of tasks under the allocation and schedule has to satisfy the precedence, resources, and other synchronization constraints among them. Recently, the timing requirements of the real-time systems emerge that the relative timing constraints are imposed on the consecutive executions of each task and the inter-task temporal relationships are specified across task periods. In this paper we consider the allocation and scheduling problem of the periodic tasks with such timing requirements. Given a set of periodic tasks, we consider the least common multiple (LCM) of the task periods. Each task is extended to several instances within the LCM. The scheduling window for each task instance is derived to satisfy the timing constraints. We develop a simulated annealing algorithm as the overall control algorithm. An example problem of the sanitized version of the Boeing 777 Aircraft Information Management System is solved by the algorithm. Experimental results show that the algorithm solves the problem in a reasonable time complexity.

In many real-time control applications, the task periods are typically fixed and worst-case execution times are used in schedulability analysis. With the advancement of robotics, flexible visual sensing using cameras has become a popular alternative to the use of embedded sensors. Unfortunately, the execution time of visual tracking varies greatly. In such environments, control tasks have a normally short computation time, but also an occasional long computation time; therefore, the use of worst-case execution time is inefficient for controlling performance optimization. Nevertheless, to maintain the control stability, we still need to guarantee the schedulability of the task set, even if the worst case arises. In this paper, we propose an integrated approach to control performance optimization and task scheduling for control applications where the execution time of each task can vary greatly. We present an innovative approach to overrun management that allows us to fully utilize the processor for optimizing the control performance and yet guaranteeing the schedulability of all tasks under worst-case conditions.

EPICS is used worldwide mostly for controlling accelerators and large experimental physics facilities. Although EPICS is well fit for the design and development of automation systems, which are typically VME or PLC-based systems, and for soft real-time systems, it may present several drawbacks when used to develop hard real-time systems/applications especially when general purpose operating systems as plain Linux are chosen. This is in particular true in fusion research devices typically employing several hard real-time systems, such as the magnetic control systems, that may require strict determinism, and high performance in terms of jitter and latency. Serious deterioration of important plasma parameters may happen otherwise, possibly leading to an abrupt termination of the plasma discharge. The MARTe framework has been recently developed to fulfill the demanding requirements for such real-time systems that are alike to run on general purpose operating systems, possibly integrated with the low-latency real-time preemption patches. MARTe has been adopted to develop a number of real-time systems in different Tokamaks. In this paper, we first summarize differences and similarities between EPICS IOC and MARTe. Then we report on a set of performance measurements executed on an x86 64 bit multicore machine running Linux with an IO control algorithm implemented in an EPICS IOC and in MARTe.

In hard real-time task systems where periodic and aperiodic tasks coexist, the object of task scheduling is to reduce the response time of the aperiodic tasks while meeting the deadline of periodic tasks. Total bandwidth server (TBS) and advanced TBS (ATBS) are used in dynamic priority systems. However, these methods are not optimal solutions because they use the worst-case execution time (WCET) or the estimation value of the actual execution time of the aperiodic tasks. This paper presents an online slack-stealing algorithm called SSML that can make significant response time reducing by modification of look-ahead earliest deadline first (laEDF) algorithm as the slack computation method. While the conventional slack-stealing method has a disadvantage that the slack amount of each frame must be calculated in advance, SSML calculates the slack when aperiodic tasks arrive. Our simulation results show that SSML outperforms the existing TBS based algorithms when the periodic task utilization is higher than 60%. Compared to ATBS with virtual release advancing (VRA), the proposed algorithm can reduce the response time up to about 75%. The performance advantage becomes much larger as the utilization increases. Moreover, it shows a small performance variation of response time for various task environments.

A real-time system is considered in which a set of periodic tasks are scheduled on an earliest-deadline-first basis and exclusively access critical sections through a dynamic priority ceiling protocol. An optimal online acceptance test is described for hard deadline aperiodic tasks. Aperiodic tasks are accepted only if all deadlines can be met. Here, optimality means that the algorithm is able to answer ‘yes’ to the question of the acceptance of a newly occurring task each time it is possible. The time complexity of the test is O(⌈R/p⌉.n+m) where n is the number of periodic tasks, R is the longest deadline, p is the shortest period and m is the number of aperiodic tasks that have previously been accepted but not completed.

Feasibility tests for hard real-time systems provide information about the schedulability of a set of tasks. However, this information is a yes or no answer whether the task set achieves the test or not. From the system design point of view, it would be useful to have more information, for example, how much can one vary some task parameters, such as computation time, without jeopardizing the system feasibility. The aim of the work is to provide a method to determine how much a task can increase its computation time, maintaining the system feasibility under a dynamic priority scheduling. This extra time can be determined not only in all the task activations, but in n of a window of m task invocations. This is what we call a window-constrained execution time system. In control applications, this information can be used to execute supervision activities, such as model updating which is not required to be executed in all the periods, or to determine new controller parameters for the current operating conditions. In fault tolerance, this information allows us to recover n faults in m activations.

This paper examines a class of real-time control systems in which each control task triggers its next release based on the value of the last sampled state. Prior work used simulations to demonstrate that self-triggered control systems can be remarkably robust to task delay. This paper derives bounds on a task's sampling period and deadline to quantify how robust the control system's performance will be to variations in these parameters. In particular we establish inequality constraints on a control task's period and deadline whose satisfaction ensures that the closed-loop system's induced L 2 gain lies below a specified performance threshold. The results apply to linear time-invariant systems driven by external disturbances whose magnitude is bounded by a linear function of the system state's norm. The plant is regulated by a full-information H infin controller. These results can serve as the basis for the design of soft real-time systems that guarantee closed-loop control system performance at levels traditionally seen in hard real-time systems.

Comparative analysis of algorithms and models for train running simulation

On the computational complexity of periodic scheduling

Parallel programming using GPUs is a modern solution to reduce computation time for large tasks. This is done by dividing algorithms in smaller parts which can be executed simultaneously. CUDA has many practical applications especially in video processing, medical imaging and machine learning. This paper presents how parallel implementations can speedup a ground truth data generation algorithm for eye location on infrared driver recordings which is executed on a database with more than 2 million frames. Computation time is much shorter compared to a sequential CPU implementation which makes it feasible to run it multiple times if updates are required and even use it in real time applications.

In a real-time system with both hard deadline periodic tasks and soft deadline aperiodic tasks, hard deadline tasks must be guaranteed to meet their deadlines and soft deadline tasks are serviced in a best-effort manner. To schedule soft deadline aperiodic tasks in dynamic priority systems, one can assign a virtual deadline like the TBS algorithm or use capacity servers like the DPE algorithm. Both approaches have their own advantages, and we cannot say which one is better in terms of response time. In some cases, TBS provides shorter response time than DPE server. In other cases, the reverse may happen. In this paper, we propose a combined approach to improve the response time of soft deadline aperiodic tasks. The proposed method combines the deadline assignment and the capacity server approach. When there is enough capacity available for aperiodic tasks, the aperiodic tasks are served by capacity servers. Otherwise, our method assigns a deadline and schedule aperiodic task together with periodic tasks by EDF algorithm. In the worst case, the proposed method provides response time no later than TBS. Experimental results show that the proposed approach improves the responsiveness of soft deadline aperiodic tasks.

Schedulability analysis models in embedded and real-time systems are experimentally validated using synthetic task sets, which are generated using random or pseudo-random selection algorithms. Validation of these schedulability models generally requires analyzing release of all jobs of tasks within a defined interval called the feasibility interval of the task set. The length of this interval is dependent on the hyper-period, which is the least common multiple of task periods. Hence, the time taken in experimental validations is directly proportional to the value of hyper-period, apart from the number and size of task sets. Currently, if tasks period values with low hyper-period are required, the only way to generate them is using manual or ad-hoc methods. In this paper, we present a structured method of selecting task period values from within a user-specified bounded range such that the hyper-period values of these task sets is minimized. Formula to compute maximum number of task sets of different sizes that can be generated is also derived. Finally, comparisons of hyper-period values generated from a bounded range using random selection and our method are presented.

This thesis presents techniques for modeling and control of X-ray image processing tasks, aiming at the fluent execution of a multitude of diagnostic and interventional X-ray imaging applications on a multi-core computing platform. A general trend in medical imaging systems is the execution of image processing on general-purpose programmable platforms, instead of specific dedicated hardware solutions. This even holds for the newest functionality such as image analysis, which performs computations in a more stochastic manner, rather than stream-based processing. The trend of more dynamic image processing and the new analysis functions in X-ray imaging, combined with the desire for more programmable and flexible future systems forms the starting point of our research. The first contribution of this thesis is the modeling and optimization of the processing performance of stream-based medical imaging tasks, in particular image quality enhancement for interventional X-ray. We have defined rules for specifying and dividing image processing tasks for parallel processing, to optimize the related memory communication. Similarly, for the computing architecture, we have specified the detailed timing requirements for data storage and communication, incorporating memory-access times. In the initial situation, the computing system was fully loaded, both in terms of memory and computation, and the latency was strongly time varying and could not be predicted. Our modeling has yielded a good understanding of the actual execution and its critical factors. The model has eventually lead to an approach for task splitting leading to a sharper system optimization with respect to essential parameters, such as latency. However, the method for building the model is time consuming. The same holds for the architecture. Nevertheless, the experiment has been highly valuable since the system optimization is associated with a considerable system cost and the resulting alternative execution architectures have provided ways for cost reduction or adding attractive functionality to the same system, which currently is executed on an additional separate platform. The second contribution of this thesis is the modeling and prediction of the computation time of feature-based medical imaging tasks, where the task complexity is non-deterministic and the resource demands fluctuate with the image content. We have focused in particular on applications for advanced diagnosis with image analysis and motion-compensated subtraction imaging. We demonstrated that the computation time for tasks with purely random resource usage can be successfully predicted with zero-order Markov chains. Furthermore, first-order Markov chains are used if temporal correlation between the computation time statistics exists for only short periods of time. For structural correlations between image frames, scenario-based methods have to be added to the obtained prediction model, extracted from the flow graph of tasks. Alternatively, when the computational complexity depends on external (spatial) factors, the prediction model is based on spatial (look-ahead) prediction. Experimental results have shown that it is possible to predict the computation time of feature-based medical image applications, even if the flow graph dynamically switches between groups of tasks. We have found an average accuracy for two different application scenarios between 95 – 97%, with sporadic excursions of the prediction error up to 20 – 30%. The third contribution of this thesis is the design of a control system for the fluent execution of a set of applications on a multi-core platform, where some of the applications have a fluctuating resource demand and others have strict low-latency requirements. As a possible solution, we have implemented options for scalability in applications for three application scenarios, using task scaling, task skipping and task delaying. A Quality-of-Service (QoS) control system then maintains constant throughput and latency by dynamically switching between application quality modes. A global resource manager maintains the overall resource usage of the system and local application controllers are responsible for resource estimation and quality control of each individual application. The global resource manager is based on a modified version of the Lagrangian relaxation algorithm that searches for suitable combinations of quality levels for a set of concurrent running applications. The research has been validated by executing three medical imaging applications in parallel, from which two are critical in latency. It is interesting to know that the above solution has a high industrial relevance because it can facilitate in reducing system costs for applications that are already released on the market. The work has resulted in a solution featuring a combination of both interventional and diagnostic signal processing, which are executed on a single computing device with nearly the same quality, as compared to two separated computers with those tasks in the original setting. Furthermore, the techniques can be employed for different classes of systems, with different cost-performance points.

This paper presents an improved CNN-based structure to recognize the traffic signs. In the conventional CNN structure, only features extracted by the last convolutional layer are fed into the first fully connected layer. A recently proposed method for using more features, the MS-CNN uses features extracted by all convolutional layers, but this method may ignore the differences among layers. In our improved structure, the previous convolutional feature maps are combined to the first fully connected layer by a dynamic priority algorithm, which is inspired by the dynamic priority scheduling in the operating system. Our improved structure assigns different priority weights for certain convolutional layers, and priority is dynamically changing. This structure emphases differences among various convolutional layers and trains the network from different scales of features with assigned priorities. The results on the GTSRB dataset show that our method achieves recognition accuracy up to 97.61%, which is a considerable improvement compared to the conventional CNN and the MS-CNN.

The most important goal in hard real-time systems is to guarantee that all timing constraints are satisfied. Even though object-based techniques (which contain reusable software components) are used to manage the complexity in the software development process of such systems, execution efficiency may have to be sacrificed, due to the large number of procedure calls and contention for accessing software components. These issues are addressed by the following parallelizing techniques: converting potentially inefficient procedure calls to a source of concurrency via asynchronous remote procedure calls (ARPC); and replicating (or cloning) software components to reduce the contention. The existing object-based scheduling algorithms construct an initial schedule and apply incremental parallelization techniques to modify the initial schedule until a feasible schedule is generated. These algorithms are applicable for scheduling only multiple independent tasks. This paper describes a pre-run-time scheduling algorithm for a set of periodic object-based tasks having precedence constraints among them. The algorithm employs parallelism exploitation techniques to guarantee timeliness in almost fully predictable environments such as factory automation, aerospace, and avionics. It allocates the components of object-based periodic tasks to the sites of a distributed system based on a clustering heuristic which takes into account the ARPC parallelism and load balancing, and schedules them on respective sites.