Auflistung nach:
Auflistung Softwaretechnik-Trends 39(4) - 2019 nach Titel
1 - 10 von 17
Treffer pro Seite
Sortieroptionen
- Konferenzbeitrag10th Symposium on Software Performance (SSP) Würzburg, November 5-6, 2019: Preface(Softwaretechnik-Trends Band 39, Heft 4, 2019) Herbst, Nikolas; Reussner, RalfAround fifty participants from Karlsruhe, Würzburg, Stuttgart, München, Kiel, Nürnberg, Leipzig, Hannover, Ulm, Mannheim, Linz and Hildesheim attended the 10 year anniversary edition of the Symposium on Software Performance in Würzburg. Performance is one of the most relevant quality attributes of any IT system. While good performance leads to high user satisfaction, weak response times lead to loss of users, perceived unavailability of the system, or unnecessarily high costs of network or computing resources. Therefore, various techniques to evaluate, control, and improve the performance of IT systems have been developed, ranging from online monitoring and benchmarking to modeling and prediction. Experience shows, that for system design or later optimization, such techniques should be applied in smart combination. Therefore, the "Symposium on Software Performance" brings together researchers and practitioners interested in software performance, where performance is understood both in classical sense as the amount of useful work accomplished by a software system compared to the time and resources used", as well as in a broader sense as "the manner in which or the efficiency with which a software system reacts or fulfills its intended purpose". The scope of the symposium spans measurement, modeling, benchmark design, and run-time management. The focus is both on classical performance metrics such as response time, throughput and resource utilization, as well as on the relationship of such metrics to other software quality attributes including but not limited to scalability, elasticity, (energy) efficiency, dependability (in terms of availability and reliability), resilience, security and privacy.
- Konferenz-AbstractCall for Papers: 22. Workshop Software-Reengineering & -Evolution WSRE 2020 der GI-Fachgruppe Software-Reengineering (SRE)(Softwaretechnik-Trends Band 39, Heft 4, 2019) Knodel, Jens; Görg, Torsten; Gutheil, Matthias; Konersmann, Marco; Sauer, StefanUnser Ziel ist die Förderung der Zusammenarbeit und der fachliche Austausch zwischen Forschung und Praxis im deutschsprachigen Raum zu den Themen „Software-Reengineering“, „Software-Wartung“ und „Software-Evolution“. Darunter verstehen wir prinzipiell alle Aktivitäten, deren Ziel die Analyse, Visualisierung, Bewertung, Verbesserung, Migration und Weiterentwicklung von größeren und kleineren Software-Systemen ist. Wir laden Forscher und Praktiker herzlich ein, beim WSRE über Erfahrungen, Projekte, Forschungsergebnisse, Methoden, Werkzeuge, und „War-Stories“ in diesem Bereich zu berichten, ihre aktuellen Arbeiten vorzustellen und in einem offenen Umfeld konstruktiv zu diskutieren.
- KonferenzbeitragData Stream Operations as First-Class Entities in Palladio(Softwaretechnik-Trends Band 39, Heft 4, 2019) Werle, Dominik; Seifermann, Stephan; Koziolek, AnneThe Palladio Component Model (PCM) is an approach to simulate the performance of software systems using a component-based modeling language. When simulating PCM models, requests only influence each other if they compete for the same resources. However, for some applications, such as data stream processing, it is not realistic for requests to be this independent. For example, it is common to group requests in windows over time or to join data streams. Modeling the resulting behavior and resource demands in the system via stochastic approximations is possible but has drawbacks. It requires additional effort for determining the approximation and it may require spreading information across model elements that should be encapsulated in one place. In this paper, we propose a way of modeling interaction between requests that is similar to query languages for data streams. Thus, we introduce state into models without sacrificing the understandability and composability of the model.
- KonferenzbeitragGraph-Based Analysis and Visualization of Software Traces(Softwaretechnik-Trends Band 39, Heft 4, 2019) Müller, Richard; Fischer, MatteoGraphs are a suitable representation of software artifacts’ data created during development and maintenance activities. Software traces monitored with Kieker are one example of such data. We present a jQAssistant plugin that scans event-based Kieker traces and stores them in a Neo4j graph database. This opens up new possibilities for analyzing and visualizing these traces with respect to application performance monitoring and architecture discovery. We illustrate the feasibility and usefulness of the plugin with the Bookstore application example.
- KonferenzbeitragIdentifying Bottlenecks in a Visualization Platform for Tracing Adaptation Decisions(Softwaretechnik-Trends Band 39, Heft 4, 2019) Pfannemüller, Martin; Becker, ChristianMeasuring the performance of different operations as part of a software system can help to identify performance bottlenecks. This information can be used to improve the performance of the monitored system. In previous work, we proposed a visualization platform for observing and understanding adaptation decisions in self-adaptive systems. In this paper, we apply Kieker as a monitoring solution to measure the runtime of different operations based on the granularity of methods and tasks. As a result, we identified possibilities for improvements in our implementation.
- KonferenzbeitragImproving Batch Performance when Migrating to Microservices with Chunking and Coroutines(Softwaretechnik-Trends Band 39, Heft 4, 2019) Knoche, HolgerWhen migrating enterprise software towards microservices, batch jobs are particularly sensitive to communication overhead introduced by the distributed nature of microservices. As it is not uncommon for a single batch job to process millions of data items, even an additional millisecond of overhead per item may lead to a significant increase in runtime. A common strategy for reducing the average overhead per item is called chunking, which means that individual requests for different data items are grouped into larger requests. However, chunking is difficult to integrate into existing batch jobs, which are traditionally executed sequentially. In this paper, we present a chunking approach based on coroutines, and investigate whether it can be used to mitigate the potential penalty to batch performance during migrations to microservices.
- KonferenzbeitragMapping Data Flow Models to the Palladio Component Model(Softwaretechnik-Trends Band 39, Heft 4, 2019) Seifermann, Stephan; Werle, Dominik; Ebada, MazenPredicting quality properties such as privacy are reasonable use cases for Data Flow Models (DFMs). For other use cases such as performance prediction, component-based software architecture models focusing on control flows are more suitable. Designers can derive a Control Flow Model (CFM) from a DFM but they have to make numerous design decisions like defining operation signatures. Currently, this derivation is a creative process without a clear design space and without guidelines for navigating this space. In this paper, we present design alternatives for given data flow examples and derive mapping rules that allow to choose between reasonable alternatives. Our results are a first step towards a catalogue of rules for deriving CFMs from DFMs in a systematic way and providing semi-automated transformations.
- KonferenzbeitragMemory Leak Visualization using Evolving Software Cities(Softwaretechnik-Trends Band 39, Heft 4, 2019) Weninger, Markus; Makor, Lukas; Mössenböck, HanspeterMemory leaks occur when no longer needed objects are unnecessarily kept alive. They can have a significant performance impact, possibly leading to a crash of the application in the worst case. Most state-of-the-art memory monitoring tools lack visualizations of memory growth over time. However, domains such as software evolution and program comprehension have shown that graphically visualizing the growth and evolution of a system can help users in understanding and interpreting this growth. In this paper, we present ongoing research on how to visualize an application’s memory evolution over time using the software city metaphor. While software cities are typically used to visualize static artifacts of a software system such as classes, we use them to visualize the dynamic memory behavior of an application. In our approach, heap objects can be grouped by arbitrary properties such as their types or their allocating threads. These groups are visualized as buildings arranged in districts, where the size of a building corresponds to the number of objects it represents. Continuously updating the city over time creates the feeling of an evolving city. Users can then identify and inspect those buildings, i.e., object groups, that grow the most. We integrated our approach into AntTracks, a trace-based memory monitoring tool developed by us, to prove its feasibility.
- KonferenzbeitragModelling and Predicting Memory Behaviour in Parallel Systems with Network Links? Palladio-based Experiment Report(Softwaretechnik-Trends Band 39, Heft 4, 2019) Gruber, Philipp; Frank, MarkusThis work improves the capabilities of Palladio to predict the performance of parallel software in multicore environments. In previous work, we could show that the accuracy of the Palladio simulations is not sufficient for multicore systems. We assume that one reason for this is the memory bandwidth behaviour, which is not included in the Palladio Component Model and can become a bottleneck in parallel software. We present an approach to model the memory bandwidth behaviour by the means of an already existing network link concept. We can show that by using network link as a memory model we can improve our predictions up to 26% points using 16 cores on a machine and can receive an accuracy of 90% for our use case.
- KonferenzbeitragOn Learning Parametric Dependencies from Monitoring Data(Softwaretechnik-Trends Band 39, Heft 4, 2019) Grohmann, Johannes; Eismann, Simon; Kounev, SamuelA common approach to predict system performance are so-called architectural performance models. In these models, parametric dependencies describe the relation between the input parameters of a component and its performance properties and therefore significantly increase the model expressiveness. However, manually modeling parametric dependencies is often infeasible in practice. Existing automated extraction approaches require either application source code or dedicated performance tests, which are not always available. We therefore introduced one approach for identification and one for characterization of parametric dependencies, solely based on run-time monitoring data. In this paper, we propose our idea on combining both techniques in order to create a holistic approach for the identification and characterization of parametric dependencies. Furthermore, we discuss challenges we are currently facing and potential ideas on how to overcome them.