Logo des Repositoriums

Softwaretechnik-Trends 40(3) - 2020

https://dl.gi.de/handle/20.500.12116/39779
Auflistung nach:

Auflistung Softwaretechnik-Trends 40(3) - 2020 nach Erscheinungsdatum

Zu einem Punkt im Index springen:
1 - 10 von 22
  • Konferenzbeitrag
    Performance Modelling of Message-Oriented Middleware with Priority Queues
    (Softwaretechnik-Trends Band 40, Heft 3, 2020) Singh, Snigdha; Schmid, Larissa; Koziolek, Anne
    Message-Oriented Middleware (MOM) with priority queues reduces the latency of critical events. In general, MOM uses a FIFO queuing methodology. But, different application scenarios require certain critical events with higher priority to be served earlier over low-priority events, so that the subscriber of the event consumes the high-priority event with less delay. In the context of the Palladio Component Model (PCM), MOM-based systems have been modelled considering message queue length and latency as metrics for performance prediction and simulation. However, the approaches did not consider modelling MOM with priority queues and their impact on performance. We will first, discuss the existing approaches in PCM which support performance prediction for MOM-based systems and then propose how they can be extended to support performance predictions for MOM with priority queuing. We will then conclude which approach is best suited to extend by assessing their capabilities to predict performance metrics relevant for priority queuing, especially the delay of individual events at the subscriber end.
  • Konferenzbeitrag
    Toward Efficient Scalability Benchmarking of Event-Driven Microservice Architectures at Large Scale
    (Softwaretechnik-Trends Band 40, Heft 3, 2020) Henning, Sören; Hasselbring, Wilhelm
    Over the past years, an increase in software architectures containing microservices, which process data streams of a messaging system, can be observed. We present Theodolite, a method accompanied by an open source implementation for benchmarking the scalability of such microservices as well as their employed stream processing frameworks and deployment options. According to common scalability definitions, Theodolite provides detailed insights into how resource demands evolve with increasing load intensity. However, accurate and statistically rigorous insights come at the cost of long execution times, making it impracticable to execute benchmarks for large sets of systems under test. To overcome this limitation, we raise three research questions and propose a research agenda for executing scalability benchmarks more time-efficiently and, thus, for running scalability benchmarks at large scale.
  • Konferenzbeitrag
    Heap Evolution Analysis Using Tree Visualizations
    (Softwaretechnik-Trends Band 40, Heft 3, 2020) Weninger, Markus; Makor, Lukas; Mössenböck, Hanspeter
    Memory anomalies such as memory leaks can dramatically impact application performance and can even lead to crashes. Thus, supporting developers in understanding the heap memory behavior of their systems is essential. Unfortunately, most memory analysis tools lack advanced visualizations that could facilitate developers in analyzing suspicious memory behavior. To analyze heap memory, it is common to group the heap’s objects, for example, by their types or by their allocation sites. Using multiple grouping criteria thus results in a tree-shaped representation of the heap content. Such a heap tree is then typically presented textually in a tree table. In this paper, we present ongoing research on using well-known tree visualization techniques to visualize such heap trees as well as their evolution over time. Such visualizations may ease the detection of proliferating heap objects, facilitating memory leak analysis. To demonstrate the feasibility and applicability of the presented approach, we implemented a web-based visualization tool and integrated it into AntTracks, our trace-based memory monitoring tool.
  • Konferenzbeitrag
    A Dynamic Resource Demand Analysis Approach for Stream Processing Systems
    (Softwaretechnik-Trends Band 40, Heft 3, 2020) Rank, Johannes; Hein, Andreas; Krcmar, Helmut
    Systems that provide real-time business insights based on live data, so-called Stream Processing Systems (SPS), have received much attention in recent years. In many areas such as stock markets or surveillance, it is essential to process data immediately and react accordingly. As the processing of real-time data is at the heart of SPS, their performance in terms of latency, throughput, and resource utilization constitutes a crucial role. Traditional performance and benchmarking approaches for SPS usually focus on the throughput and latency, trying to answer the question of which engine processes the incoming events fastest. However, neglecting the corresponding resource utilization provides only a limited and sometimes even misleading view on their actual performance. Depending on the use-case, an engine that achieves faster processing results at the cost of higher memory utilization is not always best suited, which can be shown based on the example of IoT edge computing devices with limited resources. For this reason, we developed a dynamic performance approach to analyze the resource demands of an SPS. The approach yields fine-grained performance metrics based on the individual processing steps of the SPS and without requiring any knowledge of the actual source code. More-over it takes the whole system (engine and streaming application) into account. Since, we do not rely on code instrumentation or language-specific profiling techniques but instead, use the dynamic tracing capabilities of the Linux kernel, we can support a broad range of different SPSs. We evaluate our approach by inspecting the CPU performance of Apache Flink while performing the Yahoo streaming benchmark.
  • Konferenzbeitrag
    Heat-aware Load Balancing - Is it a Thing?
    (Softwaretechnik-Trends Band 40, Heft 3, 2020) Iffländer, Lukas; Schmitt, Norbert; Knapp, Andreas; Kounev, Samuel
    Dynamic frequency scaling, also known by the name of its most common implementation form Intel “Turbo Boost”, has been around for over ten years. While it provides a short time boost to a CPU’s clock rate, it has no permanent influence on it. Existing work either tried to characterize the boost’s behavior or explicitly disabled the boost not to influence their performance models. We present heat-aware load balancing. This approach allows migrating a service between servers in a matter that keeps the boosted state active as long as possible. We introduce a prototype implementation that shows the feasibility of our approach in a simulated environment.
  • Konferenzbeitrag
    Combating Run-time Performance Bugs with Performance Claim Annotations
    (Softwaretechnik-Trends Band 40, Heft 3, 2020) Casey, Zachery; Shah, Michael D.
    Bugs in software are classified by a failure to meet some aspect of a specification. A piece of code which does not match the performance given by a specification contains a performance bug. We believe there is a need for better in-source language support and tools to assist a developer in mitigating and documenting performance bugs during the software development life cycle. In this paper, we present our performance claim annotation framework for specifying and monitoring the performance of a program. A performance claim annotation (PCA) is written by a programmer to assert a section of code’s run-time execution coincides with a specific metric (e.g. time elapsed) and they want to perform some action, typically logging, if the code fails to match the metric during execution. Our implementation uses a combination of the DWARF debugging format and the Pin dynamic binary instrumentation tool to provide an interface for building, using, and checking performance claims in order to reduce performance bugs during the development life cycle.
  • Konferenzbeitrag
    Graph-Based Performance Analysis at System- and Application-Level
    (Softwaretechnik-Trends Band 40, Heft 3, 2020) Müller, Richard; Strempel, Tom
    The Kieker plugin for jQAssistant transforms monitored log data into graphs to support software engineers with performance analysis. In this paper, we describe how we have extended and improved this plugin to support performance analysis at system- and application-level and how we have evaluated its correctness and scalability using data from recent experiments. This is a first step to replicate complete experiments in the field of performance analysis using graphs.
  • Konferenzbeitrag
    Towards a Taxonomy for Applying Behavior-Driven Development (BDD)
    (Softwaretechnik-Trends Band 40, Heft 3, 2020) Faragó, David; Friske, Mario; Sokenou, Dehla
    Behavior-Driven Development (BDD) is a topic currently much talked about, especially in the agile community. Small scale examples of BDD suggest an intuitive and easy use, but experience shows that in practice, especially large projects, its application becomes elaborate and challenging. This paints an inconsistent picture about BDD. So, what are the requirements for a successful application of BDD? We have identi ed, discussed, and classi ed the core aspects of applying BDD. Depending on the application context, an aspect can speak for or against the use of BDD. These aspects and their pro and contra arguments are this article's main contribution. Everyone can use these aspects to decide whether and how to use BDD in their individual project context.
  • Konferenzbeitrag
    Test Architects at Siemens
    (Softwaretechnik-Trends Band 40, Heft 3, 2020) Zimmerer, Peter
    At Siemens we have invented and defined a new key role Test Architect to meet the diverse challenges of shorter time-to-market, increasing complexity and more agility while keeping quality and other key system properties high. In the real world our test systems increase in size, volume, flexibility, velocity, complexity and unpredictability: think about testing of autonomous systems or testing of AI systems (artificial intelligence). Additionally, digitalization (virtualization, cloud, mobile, big data, data analytics, internet of things, continuous delivery, DevOps) requires more than just a face lift in testing. This talk shares our motivations, decisions, achievements, and experiences on our journey since 2016 to establish this new key role Test Architect on eye level with the software architects within the company.
  • Konferenzbeitrag
    Vision of Continuously Assuring Performance
    (Softwaretechnik-Trends Band 40, Heft 3, 2020) Reichelt, David Georg; Kühne, Stefan; Hasselbring, Wilhelm
    When assuring performance, small performance differences at code level are difficult to measure at application level. Current approaches aimed at performance assurance are capable of identifying hotspots and major performance bugs. Apart from their inability to detect small regressions, they require manual effort for specification and execution. In this paper, we present the vision of continuously assuring performance by using functional unit tests. Utilizing small tests allows developers to detect small performance differences. Additionally, they do not have to define workloads manually if they use functional unit tests, since these are present in most projects. To achieve this, we propose integrating performance measurements in the continuous integration (CI) process, accelerating root cause analysis and creating parallel tests capable of identifying regressions that arise with parallel use.