Raimundo S. Barreto

Analyzing software performance and energy consumption of embedded systems by probabilistic modeling: an approach based on coloured petri nets

This paper presents an approach for analyzing embedded systems’ software energy consumption and performance based on probabilistic modeling. Such an approach applies Coloured Petri Net modeling language (CPN) for supporting simulation and analysis. The proposed approach offers three basic contributions for embedded system analysis field:(i)code modeling, a probabilistic model for scenarios exploration being presented, (ii) formalism, a formal and widespread modeling language (CPN) being applied, with previously validated engines and algorithms for simulation;(iii) flexibility, the proposed approach enabling modeling of different micro-controllers at different abstraction levels.

A time Petri net approach for finding preruntime schedules in embedded hard real-time systems

There are two general approaches for scheduling tasks in real-time systems: runtime and preruntime scheduling. However, there are several situations where the runtime approach does not find a feasible schedule even when such a schedule exists. However, finding a feasible schedule is not trivial, because this problem is NP-hard in its general form. The proposed method finds a preruntime scheduling, when one exists, using state space exploration starting from a system formal model. Despite this technique being not new, at the best of our present knowledge, no one tried to use it for finding preruntime scheduling. The main problem with this approach is the space size, which can grow exponentially. This article shows how to minimize this problem. Additionally, the proposed algorithm is a depth-first search method on a labeled transition system derived from a time Petri net model. It is verified through real-world experimental results that the schedule is found examining a reduced number of states.

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

On the use of SCRUM for the management of practcal projects in graduate courses

The premises considered by this work are that projects development in graduate courses is important for knowledge consolidation. However, one of the problems is that, usually, students are not prepared to manage and to be managed. This situation causes higher effort waste and is time-consuming. Additionally, the quality is decreased due to poor self-management and inadequate division of activities. Such problems can be minimized if there is a management policy that provides a wider vision of the projects course, allowing the problems to be anticipated in such a way as to correct the flaws as soon as possible. This work proposes the adaptation of the SCRUM Agile Project Management Methodology in the context of the development of academic projects, both in undergraduate and graduate courses, where students are organized in small teams and execute the project in a systematic way. This method was applied during the practical part of the ¿real-time systems¿ course, whose project was the development of an automated industrial production line with robot arms, using the LEGO NXT robotic kit. Therefore, this paper will show implementation aspects of the proposed method, difficulties and solutions, which parts of Scrum were effectively adopted and, specially, the learnt lessons.

Towards a Software Power Cost Analysis Framework Using Colored Petri Net

This paper proposes a framework for software power cost estimation. This framework is conceived to be applied to embedded system design in which energy consumption is the main concern. The processor behavior is modeled in Colored Petri Net (CPN) so that to use CPN analyzing techniques for quantitative parameters. This approach allows to analyze consumption distribution along the program, using widespread CPN tool, as an open and retargetable evaluation environment. Such analysis helps designers to improve total consumption on either way: by software optimization and by software/hardware migration. A taxonomy is proposed in order to support that analysis. The main contribution includes the proposition of a method based on CPN for software power estimation that can be used as internal format for software power analysis tools.

A Platform-Based Software Design Methodology for Embedded Control Systems: An Agile Toolkit

A discrete control system, with stringent hardware constraints, is effectively an embedded real-time system and hence requires a rigorous methodology to develop the software involved. The development methodology proposed in this paper adapts agile principles and patterns to support the building of embedded control systems, focusing on the issues relating to a systems constraints and safety. Strong unit testing, to ensure correctness, including the satisfaction of timing constraints, is the foundation of the proposed methodology. A platform-based design approach is used to balance costs and time-to-market in relation to performance and functionality constraints. It is concluded that the proposed methodology significantly reduces design time and costs, as well as leading to better software modularity and reliability.

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.

Formal Verification of UML Sequence Diagrams in the Embedded Systems Context

This paper shows a method for translating UML sequence diagrams to Petri nets and verifying deadlockfreeness, reachability, safety and liveness properties by using a model checker. In this proposed method, the user has not to know about temporal logics to describe the property to be verified. Instead, the user may adopt a high-level properties specification interface, which is automatically translated to a suitable temporal logic. We show the application of the proposed method in an embedded control application that consists of a sensory device mounted on a motorized platform that must detect and track specific objects in the environment.

A retargetable environment for power-aware code evaluation: an approach based on coloured petri net

This paper presents an approach for power-aware code exploration, through an analysis mechanism based on Coloured Petri Net (CPN). Given a code under interest and a CPN description of architecture, a CPN model of application (processor + code) is generated. Coloured Petri Net models allow the application of widespread analysis approaches, for instance simulation and/or state-space exploration. Additionally, this work presents a framework where a widespread CPN tool is applied to processor architecture description, model validation and analysis by simulation. A Petri net integration environment was extended in order to support specific power-aware analysis. In the present approach, such framework is focused on the Embedded Systems context, covering pipeline-less and simplescalar architectures.