Collective operations can have a large impact on the performance of parallel applications. However, the ideal implementation of a particular collective communication often depends on both the application and the targeted machine structure. Our approach combines dynamic and static analysis techniques to identify common collective communication patterns expressed as point-to-point calls and transforms them into equivalent MPI collectives. We first detect potential collective communication patterns in runtime traces and associate them with the corresponding source code regions. If our static analysis verifies that the introduction of collectives is safe for any program flow, we then replace the original communication primitives with their collective counterpart. In this paper we introduce the necessary algorithms to determine the safety of these transformations and we demonstrate several use cases, including automatic use of new extensions to the MPI standard such as nonblocking collective operations. The use of dynamic analysis significantly reduces compile times, resulting in a speed-up of about 50 for source transformations of HPL due to more directed analysis capabilities and also dramatically decreases complexity of the underlying static analysis.

Large software projects contain significant code duplication, mainly due to copying and pasting code. Many techniques have been developed to identify duplicated code to enable applications such as refactoring, detecting bugs, and protecting intellectual property. Because source code is often unavailable, especially for third-party software, finding duplicated code in binaries becomes particularly important. However, existing techniques operate primarily on source code, and no effective tool exists for binaries.

Software is among the most complex human artifacts, and visualization is widely acknowledged as important to understanding software. In this paper, we consider the problem of understanding a software system's architecture through visualization. Whereas traditional visualizations use multiple stakeholder-specific views to present different kinds of task- specific information, we propose an additional visualization technique that unifies the presentation of various kinds of architecture-level information, thereby allowing a variety of stakeholders to quickly see and communicate current development, quality, and costs of a software system. For future empirical evaluation of multi-aspect, single-view architectural visualizations, we have implemented our idea in an existing visualization tool, Vizz3D. Our implementation includes techniques, such as the use of a city metaphor, that reduce visual complexity in order to support single-view visualizations of large-scale programs.

This paper describes an experiment of rapidly constructing reverse engineering tools from predefined components/tools. We perform two ways of construction. The first uses ad-hoc composition. The second exploits a framework design to support the customization of reverse engineering tools. We evaluate the quality of the assembled tools and their assembling time for each approach. For this, we describe in this paper briefly our framework, the metrics chosen for quality measurement based on the GQM approach, the experiment itself and our results. The paper gives empirical evidence that framework customization, here using the VizzAnalyzer framework, is superior to ad-hoc composition.

The VizzAnalyzer is a framework for analyses and visualizations of software. It has been developed over years, to a great deal by students and PhD students. In between it has been re-engineered to improve the software quality. In this paper, we publish the results of the software quality measurements over different versions of the VizzAnalyzer framework with well established quality metrics. Some metrics uncover qualities we were aiming at in our re-engineering, e.g. maintainability, some others uncover qualities we were deliberately ignoring or did not even think about, e.g. good "object-orientedness". Our measurements validate our expectation: the former metrics significantly improve over the versions whereas the latter contain positive as well as negative surprises

A software comprehension tool defines an abstract software model, views on this model, analyses creating the model, and a mapping between model and view. For creating new comprehension tools, we configure online analyses, models, views and their mappings instead of hand-coding them. In this paper, we introduce an architecture allowing such an online configuration and, as a proof of concept, a framework implementing this architecture. In several examples, we demonstrate the generality and flexibility of our approach.

Software development is difficult because software is complex, the software production process is complex and understanding of software systems is a challenge. We propose a 3D visual approach to depict software production cost related program information to support software maintenance. The information helps us to reduce software maintenance costs, to plan the use of personnel wisely, to appoint experts efficiently and to detect system problems early.