Christian Wulf

Live trace visualization for comprehending large software landscapes: The ExplorViz approach

The increasing code complexity in modern enterprise software systems exceeds the capabilities of most software engineers to understand the systems behavior by just looking at its program code. Large software landscapes, e.g., applications in a cloud infrastructure, further increase this complexity. A solution to these problems is visualizing the applications of the software landscape to ease program comprehension and to understand the respective communication. An established visualization concept is the 3D city metaphor. It utilizes the familiarity with navigating a city to improve program comprehension. Dynamic analysis, e.g., monitoring, can provide the required program traces of the communication. In this paper, we present our live visualization approach of monitoring traces for large software landscapes. It combines a landscape and a system level perspective. The landscape level perspective provides an overview of the software landscape utilizing the viewers familiarity with UML. The system level perspective provides a visualization utilizing the city metaphor for each software system.

Synchrovis: 3D visualization of monitoring traces in the city metaphor for analyzing concurrency

The increasing code complexity in modern software systems exceeds the capabilities of most software engineers to understand the systems behavior by just looking at its program code. The addition of concurrency issues through the advent of multi-core processors in the consumer market further escalates this complexity. A solution to these problems is visualizing a model of the system to ease program comprehension. Especially for the comprehension of concurrency issues, static information is often not sufficient. For this purpose, profiling and monitoring can provide additional information on the actual behavior of a system. An established visualization approach is the 3D city metaphor. It utilizes the familiarity with navigating a city to improve program comprehension. In this paper, we present our trace-based SynchroVis 3D visualization approach for concurrency. It employs the city metaphor to visualize both static and dynamic properties of software systems with a focus on illustrating the concurrent behavior. To evaluate our approach, we provide an open source implementation of our concepts and present an exemplary dining philosophers scenario showing its feasibility.

Increasing the Throughput of Pipe-and-Filter Architectures by Integrating the Task Farm Parallelization Pattern

The Pipe-and-Filter style represents a well-known family of component-based architectures. By executing each filter on a dedicated processing unit, it is also possible to leverage contemporary distributed systems and multi-core systems for a high throughput. However, this simple parallelization approach is not very effective when (1) the workload is uneven distributed over all filters and when (2) the number of available processing units exceeds the number of filters. In the first case, parallelizing all filters can lead to a waste of resources since only the slowest filter is responsible for the overall throughput. In the second case, some processing units remain unused. In this paper, we present an automatic parallelization approach providing high throughput and utilizing the available processing units. Our main idea is to provide a composite filter that is wrapped around an existing filter to increase its throughput. We call this composite filter the Task Farm Filter since it implements the Task Farm parallelization pattern. It creates and executes multiple instances of the underlying filter in parallel. Moreover, we present a modular, self-adaptive mechanism that automatically adapts the number of instances at runtime to achieve the highest possible throughput. Finally, we present an extensive experimental evaluation of our self-adaptive task farm filter by employing a CPU-intensive, an I/O-intensive, and a hybrid scenario. The evaluation shows that our task farm automatically parallelize the underlying filter and thus increases the overall throughput. Furthermore, the evaluation shows that our task farm scales well with the workload of the executed Pipe-and-Filter architecture.

Parallel and Generic Pipe-and-Filter Architectures with TeeTime

Pipe-and-Filter (P&F) is a well-known and often used architectural style. However, to the best of our knowledge, there is no P&F framework which can model and execute generic P&F architectures. For example, the frameworks Fastflow, StreamIt, and Spark do not support multiple input and output streams per filter and thus cannot model branches. Other frameworks focus on very specific use cases and neglect type-safety when interconnecting filters. Furthermore, an efficient parallel execution of P&F architectures is still an open challenge. Although some available frameworks can execute filters in parallel, there is much potential for optimization. Unfortunately, most frameworks have a fixed execution strategy which cannot be altered without major changes. In this paper, we present our P&F framework TeeTime. It is able to model and to execute arbitrary P&F architectures. Simultaneously, it is open for modifications in order to experiment with the P&F style. Moreover, it allows to execute filters in parallel by utilizing the capabilities of contemporary multi-core processor systems. Besides a description of its major features, we also present an application example in Java.