Matthew M. Y. Kuo

Determining the worst-case reaction time of IEC 61499 function blocks

The IEC 61499 is an international standard for describing industrial process-control systems. Such systems typically consist of embedded computers that interact closely with physical processes within a feedback loop. In order to correctly control these physical processes, computations in response to inputs need to be done in a timely manner. A programs worst-case reaction time (WCRT) to inputs is usually used to ensure that timing constraints are met. Unfortunately, the standard has no provisions for specifying real-time constraints. Moreover, typical implementations of IEC 61499 are tightly coupled to their runtime environments—each with possibly different semantics and temporal properties—which makes it difficult to automate the estimation of their WCRTs. We propose to adopt a synchronous model for IEC 61499 programs. This allows the programs to be executed without the need of a run-time environment. Consequently, we are able to use a novel model-checking technique to estimate the WCRT of IEC 61499 programs. Experimental results on a suite of programs show that this approach provides conservative estimates that are, on average, less than 10 percent off from the actual WCRT.

Relaxing the synchronous approach for mixed-criticality systems

Synchronous languages are widely used to design safety-critical embedded systems. These languages are based on the synchrony hypothesis, asserting that all tasks must complete instantaneously at each logical time step. This assertion is, however, unsuitable for the design of mixed-criticality systems, where some tasks can tolerate missed deadlines. This paper proposes a novel extension to the synchronous approach for supporting three levels of task criticality: life, mission, and non-critical. We achieve this by relaxing the synchrony hypothesis to allow tasks that can tolerate bounded or unbounded deadline misses. We address the issue of task communication between multi-rate, mixed-criticality tasks, and propose a deterministic lossless communication model. To maximize system utilization, we present a hybrid static and dynamic scheduling approach that executes schedulable tasks during slack time. Extensive benchmarking shows that our approach can schedule up to 15% more task sets and achieve an average of 5.38% better system utilization than the Early-Release EDF (ER-EDF) approach. Tasks are scheduled fairer under our approach and achieve consistently higher execution frequencies, but require more preemptions.

Efficient WCRT analysis of synchronous programs using reachability

Static computation of the worst-case reaction time (WCRT) is required for the real-time execution of synchronous programs. Existing approaches use model checking or integer linear programming. we formulate this as an abstraction-based reachability analysis yielding a lower worst case complexity. Benchmarking shows a significant overall speed-up of 64-times over existing approaches.

Hierarchical and Concurrent ECCs for IEC 61499 Function Blocks

IEC 61499 enables component-oriented descriptions of complex industrial processes facilitating model-driven engineering. One aspect that is lacking, however, is the ability to directly express Statecharts-like hierarchy and concurrency within basic function blocks (BFBs). Such features can significantly enhance function blocks and help create more succinct and readable specifications. We propose a new syntactic extension to the standard called hierarchical and concurrent execution control chart (HCECC). A major roadblock for any suggested changes to the standard is the need for compliance. Our approach extends the synchronous execution semantics of IEC 61499, where HCECCs are purely syntactic sugar. Using a revised synchronous semantics, our compiler generates standard compliant C code from HCECCs. Benchmarking and usability studies reveal the relative superiority of the proposed approach over existing approaches.

Model-Driven Design Using IEC 61499

This book describes a novel approach for the design of embedded systems and industrial automation systems, using a unified model-driven approach that is applicable in both domains. The authors illustrate their methodology, using the IEC 61499 standard as the main vehicle for specification, verification, static timing analysis and automated code synthesis. The well-known synchronous approach is used as the main vehicle for defining an unambiguous semantics that ensures determinism and deadlock freedom. The proposed approach also ensures very efficient implementations either on small-scale embedded devices or on industry-scale programmable automation controllers (PACs). It can be used for both centralized and distributed implementations. Significantly, the proposed approach can be used without the need for any run-time support. This approach, for the first time, blurs the gap between embedded systems and automation systems and can be applied in wide-ranging applications in automotive, robotics, and industrial control systems. Several realistic examples are used to demonstrate for readers how the methodology can enable them to reduce the time-to-market, while improving the design quality and productivity.

Mixed-Criticality Systems as a Service for Non-critical Tasks

Mixed-Criticality Systems are capable of accommodating tasks of varying criticality. In this paper, these are [life, mission, and non-critical]. Tasks usually have an overestimated execution time to allow for the Worst Case Execution Time (WCET). When these tasks finish execution prior to their allotted execution time due to pessimistic assumptions present in the static analysis of the system. The surplus time is used to accommodate tasks with tolerance for deadline-misses. Non-critical tasks are often treated in a ”best-effort” capacity where no quality of service is considered. When processor utilisation is not overconstrained, all deadlines will be met. However, in cases where not enough processing resources exist to meet all deadlines for non-critical tasks, the allotted time for the non-critical tasks must be rationed between non-critical tasks. This paper proposes a novel method of prioritising non-critical tasks. By treating task execution as a service, non-critical tasks with unbounded deadline miss tolerance are given a Grade of Service for their met deadlines. This Grade of Service is used for the dynamic scheduling of non-critical tasks. Four different scheduling algorithms were tested with the proposed Highest Penalty First algorithm for distributing the effort of task execution amongst non-critical tasks in a proportionate manner and showing superior fairness of task execution compared to all other tested algorithms.

Precision Timed Embedded Systems Using TickPAD Memory

There has been a great deal of impetus for the design of predictable memory such as scratchpad memory. Moreover, static analysis of cache memory is an area of intense research activity. However, there has been minimal development of caches or scratchpads (SPMs) that can exploit the inherent concurrency in synchronous languages. In this paper, we have developed a new memory subsystem, called the TPM (TickPAD memory), for predictable and efficient execution of synchronous programs. TPMs are a hybrid between conventional caches and SPMs: they support dynamic loading of cache lines (like caches) and static allocation of program points (like SPMs). However, the dynamic loading is predictably managed through statically loaded TPM commands. Extensive benchmarking comparing TPMs to SPMs and direct mapped caches reveal that TPM achieves 8.5% WCRT reduction compared to locked SPMs, 12.3% WCRT reduction compared to thread multiplexed SPM and 13.4% WCRT reduction compared to direct mapped caches, while also keeping the analysis time comparatively small.

RunSync: A Predictable Runtime for Precision Timed Automation Systems

Many complex industrial control systems need to meet stringent timing requirements. Ensuring that implementations can meet these requirements can be a very difficult task. IEC 61499 is an emerging standard for modelling and implementing large distributed industrial control systems. However, there is currently no established approach for executing IEC 61499 code in a distributed time-predictable manner. In this paper, we present a novel time-predictable runtime called RunSync for executing IEC 61499 on the Precision Timed (PRET) architecture FlexPRET. PRET architectures are designed to guarantee timing repeatability while preserving performance. They are often designed as RISC architectures which utilize multiple hardware threads to remove pipeline hazards. Determining the allocation of tasks to the hardware threads is a key problem when utilizing such architectures. Hence, in this paper it is demonstrated that through RunSync it is possible to dynamically map IEC 61499 tasks to hardware threads during runtime, while preserving determinism and remaining amenable to timing analysis. Following that, quantitative results are presented, showing the minimal overheads of RunSync compared to implementations of the existing synchronous approach. RunSync is thus demonstrated to be more performant with large IEC 61499 networks, and when there are more hardware resources to be allocated.

Introduction to Synchronous Programming Using Esterel

This chapter describes the synchronous approach for designing embedded and automation systems. We present the core concepts of synchronous programming using a well-known synchronous language called Esterel. Esterel consists of a set of ”pure Esterel” statements for describing control flow. Data handling is performed using calls to C functions. We present the syntax and intuitive semantics of pure Esterel using a set of examples, such as a 4-bit counter and the user interface for a MP3 player. Subsequently, we present the Esterel to C interface using the pedagogic example of a lift-controller. This chapter introduces the key concepts necessary for the understanding of subsequent chapters.

IEC 61499 in a Nutshell

The IEC 61499 standard provides definition of various structures, such as systems, devices, resources, and various function block types, which allow for a component-oriented design of a program. This design approach resembles the famous object-oriented design paradigm, where the domain objects, e.g. sensors, actuators and devices, are modelled along with the automation logic. The execution of these structures depends on the adopted execution semantics, which determine the protocol of accepting inputs, processing signals, and generating outputs. In this chapter, we offer a brief introduction to some of the structures defined by the IEC 61499 standard and the various execution semantics that are commonly employed for their execution. The discussion on the advantages and disadvantages of each of the presented semantics motivates the adoption of the synchronous execution semantics proposed in this book, and described in detail in Chap. 4.