Prediction of run-time resource consumption in multi-task component-based software systems

Embedded systems must be cost-effective. This imposesstrict requirements on the resource consumption of their applications. It is therefore desirable to be able to determine the resource consumption of applications as early as possible in its development. Only then, a designer is able to guarantee that an application will fit on a target device. In this paper we will present a method for predicting run-time resource resource consumption in multi-task component based systems based on a design of an application. In [5] we describe a scenario based resource prediction technique and show that it can be applied to non-pre-emptive non-processing resources, like memory. In this paper we extend this technique, which enables us to handle pre-emptive processing resources and their scheduling policies. Examples of these class of resources are CPU and network. For component based software engineering the challenge is to express resource consumption characteristics per component, and to combine them to do predictions over compositions of components. To this end, we propose a model and tools, for combining individual resource estimations of components. These composed resource estimations are then used in scenarios (which model run-time behavior) to predict resource consumption

C++11 Enhancements for Eclipse CDT

The aim of this project was to develop an Eclipse plug-in to help highlighting and fixing initialization issues in respect to the new C++11 brace-initializer syntax. The C++11 brace-initializer provides a uniform syntax for initialization, and is preferred in C++11 code over pre-C++11 initialization mechanisms such as copy-initialization or direct-initialization. The developed Eclipse plug-in detects initialization issues and provides an automated quickfix, to make it as easy as possible to fix initialization issues. Besides detecting issues, the plug-in also ensures that no semantic changes are introduced by a quickfix, so the resulting code is equivalent. The plug-in is written in Java, using Eclipse CDT’s Codan, which is a static code analysis framework for C++, providing an abstract syntax tree, that we traverse and modify to detect and fix the issues. To realize the Eclipse plug-in the existing quickfix-plug-in framework was used to ensure that the plug-in integrates well into eclipse and behaves as any other quickfix plug-in. To enable efficient fixing of larger code-bases to C++11-initializations, an additional massrefactoring has been implemented. This functionality can be triggered from the usual refactoring menus, to fix either complete source files or even full projects

A library of OCL specification patterns for behavioral specification of software components

A library of OCL specification patterns for behavioral specification of software components / J. Ackermann, K. Turowski. - In: Advanced information systems engineering / Eric Dubois ... (eds.). - Berlin [u.a.] : Springer, 2006. - S. S.255-269. – (Lecture notes in computer science ; 4001

Architectural reuse in software systems in-house integration and merge : experiences from industry

When organizations cooperate closely, for example after a company merger, there is typically a need to integrate their in-house developed software into one coherent system, preferably by reusing from all of the existing systems. The parts that can be reused may be arbitrarily small or large, ranging from code snippets to large self-containing components. Not only implementations can be reused however; sometimes it may be more appropriate to only reuse experiences in the form of architectural solutions and requirements. In order to investigate the circumstances under which different types of reuse are appropriate, we have performed a multiple case study, consisting of nine cases. Our conclusions are, summarized: reuse of components from one system requires reuse of architectural solutions from the same system; merge of architectural solutions cannot occur unless the solutions already are similar, or if some solutions from one are incorporated into the other. In addition, by hierarchically decomposing the systems we make the same observations. Finally, among the cases we find more architectural similarities than might had been expected, due to common domain standards and common solutions within a domain. Although these observations, when presented, should not be surprising, our experiences from the cases show that in practice organizations have failed to recognize when the necessary prerequisites for reuse have not been present