Meuse N. Oliveira

Hard real-time tasks' scheduling considering voltage scaling, precedence and exclusion relations

Several scheduling approaches have been developed to address DVS in time-critical systems, however, overheads, precedence and exclusion relations have been neglected. This paper presents a pre-runtime scheduling method for hard real-time systems considering DVS, overheads as well as inter-task relations. The proposed method adopts a formal model based on time Petri nets in order to find a feasible schedule that satisfies timing and energy constraints.

Agile Development Methodology for Embedded Systems: A Platform-Based Design Approach

This paper describes an agile development methodology which combines agile principles with organizational patterns and adapts them to build embedded real-time systems focusing on the systems constraints. The hardware/software partitioning and platform-based design are used in the proposed methodology to support the embedded system designer meet the systems constraints in an iterative and incremental way and to reduce substantially the design time and cost of the product. To discuss the strengths and weakness of this methodology, a case study involving a pulse oximeter is also presented

A time Petri net-based method for embedded hard real-time software synthesis

Abstract Over the last few years, embedded software synthesis has drawn much attention. However, few works deal with software synthesis for hard real-time systems considering arbitrary inter-tasks precedence and exclusion relations. Code generation for meeting all timing and resource constraints is not a trivial task. Thus, this research area has several open issues, mainly related to generation of predictable-guaranteed scheduled code. The method proposed in this paper starts from a high-level specification, and automatically translates such specification into a time Petri net model; this model is adopted for finding a feasible static schedule meeting all constraints. If found, the approach generates a scheduled code, based on the found feasible schedule. Therefore, the user just enter the specification and receives, as result, the scheduled code. Thus, all intermediary phases are hidden from the users.

TXM: an agile HW/SW development methodology for building medical devices

Arterial oxygen saturation and heart rate measured by pulse oximetry is widely used to monitor critical care patients. This kind of system is classified as embedded hard real-time system and requires rigorous development methodologies to guarantee the correctness and timeliness of the application. Therefore, the proposed development methodology combines agile principles with organizational patterns and adapts them to build medical devices focusing on the issues related to the systems constraints and safety. Strong unit testing is the foundation of the proposed methodology for ensuring timeliness and correctness. Moreover, platform-based design approach is used to balance costs and time-to-market in view of performance and functionality constraints. We conclude that the proposed methodology reduces significantly the design time and cost as well as leads to better software modularity and safety.

Software synthesis for hard real-time embedded systems with multiple processors

Hard real-time embedded systems have stringent timing constraints that must be met in order to ensure the correct functioning of the system. In many cases, these systems are composed of several CPU-bound tasks, which may need to rely on multiple processors, since just a single processor may not allow meeting all timing constraints. In order to deal with stringent constraints, specialized operating system kernels are often adopted in real-time embedded systems. However, the operating system usage may introduce significant overheads in execution time as well as in memory requirement. Software synthesis is an alternative approach to operating systems usage, since it can generate tailored code that satisfy: (i) functional, performance, and resource constraints; and (ii) other features such as scheduling, resource management, communication and synchronization. In this paper, a software synthesis approach based on a formalism, namely, time Petri nets, is presented in order to generate predictable scheduled code for hard real-time embedded systems with multiple processors.

A time Petri net-based approach for software synthesis considering overheads

The context of this work is related to embedded hard real-time systems development, more specifically, in the software generation phase. Embedded software has become much harder to design caused by the diversity of requirements and high complexity. Correctness and timeliness verification is an issue to be concerned. Usually, complex embedded real-time systems rely on specialized operating system kernels. However, operating systems may introduce significant overheads in execution time as well as in memory requirement. Software synthesis might be an alternative approach to operating systems usage, since it can generate tailored code for satisfying functional, performance, and resource constraints, and automatically generate runtime support (scheduling, resource management, communication, etc.) customized for each particular specification. However, the dispatcher and timer interrupt handler overheads are often neglect in software synthesis research. This paper provides a formal approach for systems modeling, and such model is adopted for synthesizing a timely and predictable scheduled code taking into account dispatcher and interrupt handler overheads.

A methodology for software synthesis of embedded real-time systems based on TPN and LSC

This paper shows an approach for software synthesis in embedded hard real-time systems starting from Live Sequence Charts (LSC) scenarios as specification language. As the name suggests, LSCs specify liveness, that is, things that must happen. Therefore allowing the distinction between possible and necessary behavior as well as the specification of possible anti-scenarios. Embedded software has become much harder to design due to the diversity of requirements and high complexity. In such systems, correctness and timeliness verification is an issue to be concerned. The software synthesis method takes a specification (in this case composed by LSC scenarios) and automatically generates a program source code where: (i) functionalities and constraints are satisfied; and (ii) operational support for task’s execution is provided. This paper adopts a time Petri net (TPN) formalism for system modeling in order to find feasible pre-runtime schedules, and for synthesizing predictable and timely scheduled code. Embedded software synthesis has been receiving much attention. However, few works deal with software synthesis for hard real-time systems considering arbitrary precedence and exclusion relations.

A formal software synthesis approach for embedded hard real-time systems

Software synthesis is defined as the task of translating a specification into a software program, in a general purpose language, in such a way that this software can be compiled by conventional compilers. In general, complex real-time systems rely on specialized operating system kernels. However, the operating system usage may introduce significant overheads as in execution time as in memory requirement. In order to eliminate such overheads, automatic software synthesis methods should be implemented. Such methods comprise real-time operating system services (scheduling, resource management, communication, synchronization), and code generation. Formal methods are a very promising alternative to deal with the complexity of embedded systems, and for improving the degree of confidence in critical systems. We present a formal approach for automatic embedded hard real-time software synthesis based on time Petri nets. In order to illustrate the practical usability of the proposed method, it is shown how to synthesize a C code implementation using a heated-humidifier case study.

A time petri net-based approach for hard real-time systems scheduling considering dynamic voltage scaling, overheads, precedence and exclusion relations

Over the last years, DVS (Dynamic Voltage Scaling) hasbeen adopted as an effective technique for reducing energyconsumption in embedded systems. In the context of hard real-time embedded systems, several scheduling approaches have been developed to address voltage scaling together with stringent timing constraints. However, intertask relations as well as overheads, such as preemptions and frequency/voltage switchings, have been neglected, in such a way that those approaches may generate schedules that may not properly meet system constraints. This work presents a method for hard real-time systems scheduling considering dynamic voltage scaling, overheads, precedence and exclusion relations. The proposed work adopts a formal model based on time Petri nets in order to find a feasible schedule using apre-runtime approach that satisfies timing and energy constraints.

Pre-Runtime Scheduling Considering Timing and Energy Constraints in Embedded Systems with Multiple Processors

In this paper, a pre-runtime scheduling approach for hard real-time embedded systems with multiple processors is presented considering stringent timing and energy constraints. This paper adopts a formal approach, based on time Petri nets, for synthesizing feasible schedules.