A Model-Driven Multicore Software Development Environment for Embedded System

We compare two parallel programming approaches for multi-core systems: the well-known OpenMP and the recently introduced Threading Building Blocks (TBB) library by Intel®. The comparison is made using the parallelization of a real-world numerical algorithm for medical imaging. We develop several parallel implementations, and compare them w.r.t. programming effort, programming style and abstraction, and runtime performance. We show that TBB requires a considerable program re-design, whereas with OpenMP simple compiler directives are sufficient. While TBB appears to be less appropriate for parallelizing existing implementations, it fosters a good programming style and higher abstraction level for newly developed parallel programs. Our experimental measurements on a dual quad-core system demonstrate that OpenMP slightly outperforms TBB in our implementation.

In this paper, we present the rapid development of efficient multi-core parallel code for the blocked Floyd-Warshall algorithm, using the C++ library gae.h [4], on top of the Intel C++ Threading Building Blocks (TBB) library. We demonstrate that developing parallel multi-core code using gae.h is easy and fast. The parallel code developed with gae.h is also efficient. The efficiency of the parallel code developed for the blocked Floyd-Warshall algorithm on an 80-core HP ProLiant DL980 G7 multi-core machine is above 70% if less than 70 cores are used and above 90% if less than 20 cores are used.

The most important element of industrial software development is the creation of a common vocabulary of terms for exchanging information between software and industrial engineers. Based on this cooperation, technical domain knowledge is converted into data structures, algorithms and rules. Currently, when people are used to receiving short and quick messages, the most efficient way of knowledge extraction is work on examples or mockups to facilitate better understanding of the problem. Shorter rounds in the presentation of mockups allows continuous work on live object models rather than specifications which make experts more open for sharing their knowledge and provides quicker and more reliable feedback on the data structure and the completeness of the model. Latest research and progress in the area of Model Driven Architecture (MDA) resulted in advanced tools for the creation of models, automatic source code generation as well as whole frameworks for creating application skeletons based on these models. In this paper a collaborative process which uses MDA approach (model, tools and frameworks) for extracting knowledge from domain experts is presented. During presented process, a cooperation of a software engineer and a domain expert via phone calls and one live workshop resulted in a complete model of machine and drive including specific machine features and diagnostic processes. Finally, a working diagnostics application was verified by the domain expert proving that MDA resulted in the expected results. The diagnostics application was verified on real data collected on the winding machine for more than one month, collected diagnostics data included more than 150 signals and 20Gb of raw analog data to dig into before getting condensed diagnostics results. Additionally to the process itself, the article presents identified risks, benefits from applying the MDA approach and lessons learned from applying this new innovative process. For further work, the possibilities of extending and dynamically extending existing models should be studied. In previous works we have focused on an ontology based approach, which does not meet all expectations when it comes to application in real world environment. As simpler and more mature technology, MDA was shown to be more productive and easier to adapt for building industrial applications.

The rise of the number and complexity of pervasive systems is a fact. Pervasive systems developers need advanced development methods in order to build better systems in an easy way. Software Factories and the Model Driven Architecture (MDA) are two important trends in the software engineering field. This paper applies the guidelines and strategies described by these proposals in order to build a methodological approach for pervasive systems development. Software Factories are based on the definition of software families supported by frameworks. Individual systems requirements are specified by means of domain specific languages. Following this strategy, our approach defines a framework and a domain specific language for pervasive systems. We use the MDA guidelines to support the development of our domain specific language and the automatic generation of the specific source code of a particular system. The approach presented in this paper raises the abstraction level in the development of pervasive systems and provides high reusable assets to reduce the effort in the development projects.KeywordsModel TransformationGraph TransformationSoftware Product LineGraph GrammarMeeting RoomThese 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.

Design of a quality software system is a complex and challenging task. This complexity arises due to negligence of non-functional requirements (NFRs) during development process. Model-Driven Development helps in reducing design complexity in the form of a continuous transformation of models of the desired system by providing abstraction at earlier phases of development and code generation. However, non-functional requirements which are important for building correctness in the design of the system are not adequately considered in current model driven development methods. This paper discusses the challenges in dealing non-functional requirements in model-driven development of systems and provides an approach based on architecture design decisions and technical decisions for the integration of nonfunctional properties in model-driven architecture.

This paper presents a System level Model Driven Architecture (MDA) approach for power estimation of real time operating system (RTOS) communication and synchronization services at early design phases.The approach integrates the Architecture Analysis and Design Language (AADL) in the design flow. We describe how to extend the language for modeling RTOS communication and synchronization services, and we explain how power consumption analysis can be performed on software components in the AADL platform independent model (PIM), once deployed into components in the AADL target hardware platform model. Operating system services are considered as components in the MDA approach in order to take them into account in the estimation methodology. This paper focuses on consumption analysis of RTOS communication and synchronization services.

Model-Driven Architecture (MDA) is a framework for software development focusing on models and model transformation. One of its models is the computation independent model, which describes the system environment and requirements. Representing this model and transforming it into a platform independent model typically involves Requirements Engineering approaches and diagrams. However, it is not clear how Requirements Engineering concepts are related to MDA models. To improve the understanding of MDA and to define which artifacts are expected from a Requirements Engineering perspective, this paper proposes mapping a requirements reference model, the WRSPM model, and Model-Driven Architecture models.

Ant colony optimization(ACO) provides an effective way to solve combinatorial optimization problem. However, with the complexity of the problem increasing, the ACO algorithm needs considerable computational time and resources to improve the good quality of solution, and this rarely satisfies the requirement of real-time computing in M&S (Modeling and Simulation) area. Parallel implementation of ACO can reduce the computational time obviously for the large scale combinatorial optimization problem, and much of the previous work in this field focuses on parallel implementation using MPI which is executed on clusters. Meanwhile, great emphasis is placed on multi-core computing technology with the development of multi-processor architecture and multi-core architecture. A new parallel ant colony optimization (PACO) algorithm is proposed, which applies two kinds of typical multi-core computing technologies, the well-known OpenMP and the recently introduced TBB (Threading Building Blocks) library by Intel Corporation, to solve target assignment problem(TAP). Effectiveness and efficiency of proposed algorithm is validated by studying the convergence speed, problem size scalability and thread size scalability of it.

Performing modeling and visualization of task-based parallel algorithms is challenging. Libraries such as Intel Threading Building Blocks (TBB) and Microsoft's Parallel Patterns Library provide high-level algorithms that are implemented using low-level tasks. Current tools present performance at this lower level. Developers like to tune and debug at the same level as the coding abstraction, so in this paper we propose tools and a two step methodology that target this level of abstraction. In the first step, the system level metrics of utilization and overhead are collected to determine if performance is acceptable. If a problem is suspected, the second step of our methodology projects these metrics on to the algorithms contained in the application. Using these projections many common performance issues can be quickly diagnosed. We demonstrate our methodology using a prototype implementation that is integrated with the Intel Threading Building Blocks library. We show the flexibility of the approach by analyzing three applications, including a client-server benchmark that uses a parallel_for nested within a parallel pipeline.

Almost a decade has passed since the OMG has issued the Model Driven Architecture (MDA) initiative. It soon became obvious that raising the level of abstraction in development and reasoning at the model level would help in asking the right questions at the right time. Based on a concrete problem, we discuss four alternative solutions to a multi-language system design problem. These solutions use a traditional approach, a technique based on modeling, a domain-specific approach, and a mix of modeling and domain-specific techniques, respectively. The solutions depend on the problem, but they are representative for the situations we encounter in practice, therefore giving us a good basis for a larger discussion on the appropriateness of using modeling techniques and on the place of MDA in current software engineering practice and design.

In Model Driven Architecture (MDA), business requirements for the information system are described in a Computation Independent Model (CIM), which additionally can describe knowledge of the business, and structure and behavior of both business and supporting information system. In object-oriented software development requirements are described by use cases. Use cases and identification of them are informal and application-oriented. Goal-based approaches provide a more systematic way for discovering use cases from informal knowledge about a system. The main and very important difference of the approach suggested in this chapter is that we ground our domain analysis on a mathematical engineering model, Topological Functioning Model. It is a formal holistic computation independent business model, whose characteristics help in avoiding challenges in functional requirements caused by non-systematic approaches and fragmental nature of use cases, namely, completeness, traceability and compliance with the problem domain.

Image segmentation is a computationally expensive and complex task that continuously focuses on performance challenges due to tremendous increase in the volume of high resolution images. Nowadays, shared memory multicore parallel programming architectures using OpenMP is emerging as an attractive computing platform for both general purpose and scientific computations due to their immense processing performance, less complexity and minimal cost. Faster execution of image segmentation process is emerging as an important criterion with the technical advancements in multicore architectures. This paper proposes an experimental method for parallelizing wavelet based image segmentation using OpenMP. Emphasis is also made on exploring the computational data and task parallelism in wavelet based image segmentation using OpenMP on shared memory architecture with promising processing speed and accurate segmentation result.

Network-based cloud computing is considered to be an emerging model of business computing, which maintains configurable resources such as processors, networks, storage, operating systems, database, and servers. One of the most successful paradigms that can be configured over the cloud is the Service oriented Architecture (SoA) environment, which provides a layered architecture for organising software resources as services, so that they can be deployed, discovered and combined to produce new services. The coordination of the interactions between such services is one of the key challenges of SoA, as any failings in these services could lead to lack of availability, which may violate Service Level Agreements. Therefore, this paper harnesses the capability of the Model Driven Architecture (MDA) in order to automate the creation and integration of a Protocol service, which is used to coordinate interactions between services. It is then linked with a real-time Business Activity Monitoring (BAM) dashboard, which is created automatically to monitor the performance of the Protocol service. The approach is implemented as a tool, it also configures the cloud interface to interact with these services.

The OMG's model-driven architecture is quickly attracting attention as a method of constructing systems that offers advantages over traditional approaches in terms of reliability, consistency, and maintainability. The key concepts in the MDA are models that are related by model transformations. However, for the MDA to provide an adequate alternative to existing approaches, it must offer comparable support for software engineering processes such as requirements analysis, design and testing. This paper attempts to explore the application of the last of these processes, testing, to the most novel part of the MDA, that of model transformation. We present a general view of the roles of testing in the different stages of model-driven development, and a more detailed exploration of approaches to testing model transformations. Based on this, we highlight the particular issues for the different testing tasks, including adequacy criteria, test oracles and automatic test data generation. We also propose possible approaches for the testing tasks, and show how existing functional and structural testing techniques can be adapted for use in this new development context.

Data Warehouses (DW) manage crucial enterprise information used for the decision making process which has to be protected from unauthorized accesses. However, security constraints are not properly integrated in the complete DWs' development process, being traditionally considered in the last stages. Furthermore, legacy systems need a reverse engineering process in order to accomplish re-documentation for detecting new security requirements as well as system's design recovery to enable migration and reuse. Thus, we have proposed a model driven architecture (MDA) for secure DWs which takes into account security issues from the early stages of development and provides automatic transformations between models. This paper fulfills this architecture providing an architecture-driven modernization (ADM) process focused on obtaining conceptual security models from legacy OLAP systems.