Browsing by Author "Becker, Steffen (Prof. Dr.-Ing.)"

Now showing 1 - 4 of 4

Open Access
A dedicated architectural view for simulation-based design of elasticity policies
(2024) Klinaku, Floriment; Becker, Steffen (Prof. Dr.-Ing.)
The cloud computing model enables the provisioning of computing resources based on demand. It lowers the burden of manual management by operators, improves efficiency, and improves the environmental impact. Software architects shift to a strategic role in the process, where they have to design, configure, and deploy appropriate policies for automated management of computing resources—elasticity policies. Designing appropriate elasticity policies to achieve certain performance or cost objectives is a complex problem. Several approaches in the literature of different flavors tackle the problem. Most of them require deep mathematical and formal modeling skills, for example, Queueing Theory, to model and predict the consequences of a particular policy design. Approaches closer to architectural modeling in the software engineering domain, such as Palladio or CloudSim, do not offer specific means for representing elasticity. They either require workarounds or rely on generic means of modeling, hampering productivity and predictive power. This thesis proposes the Slingshot approach: a dedicated architectural view for modeling elasticity policies, associated analysis based on discrete event simulations, development process, and tool support. We materialize the view through a domain-specific language for elasticity called the Scaling Policy Definition (SPD) modeling language. We integrate the proposal into the Palladio software architecture simulator. The contribution aims to improve productivity and increase predictive power, i.e., to enable researchers and practitioners to evaluate elasticity policies effectively with low effort and sufficient accuracy. To validate the impact of our proposal in terms of its predictive power, we perform two single-case mechanism experiments with applications that are representative of real-world complexity. In the first single-case mechanism experiment, we find that the style and configuration of an elasticity policy significantly impact performance and lead to trade-offs in decision-making. The simulation results reliably predict the average response times of various elasticity policy designs with a mean absolute prediction error between 23% and 46% . For the performance indicators, average response time and throughput, there is a strong positive correlation between predictions and ground-truth measurements. For the tail latencies captured through the 95th percentile for response times there is a moderate positive correlation. The second single-case mechanism experiment shows that the approach is feasible for larger applications with the drawback of increased simulation times. In addition, we perform a user study with a representative sample of novice software architects to validate the proposal’s impact on productivity by collecting 12 data points in which participants model and refine SPD models. The user study results provide evidence that the contribution is easily adoptable by novice software architects. Participants solved 90% of the tasks, rated the usability high with a value of 71%, and achieved an average total score of 76% in nearly half of the allocated time. Compared to existing architectural modeling views for modeling the control flow, the resource environment, and the usage profile, the collected empirical evidence suggests that participants require more time to produce models of similar size in the proposed architectural view for elasticity.
Open Access
Model-based performance prediction for concurrent software on multicore architectures - a simulation-based approach
(2021) Frank, Markus; Becker, Steffen (Prof. Dr.-Ing.)
Model-based performance prediction is a well-known concept to ensure the quality of software. Thereby, software architects create abstract architectural models and specify software behaviour, hardware characteristics, and the user's interaction. They enrich the models with performance-relevant characteristics and use performance models to solve the models or simulate the software behaviour. Doing so, software architects can predict quality attributes such as the system's response time. Thus, they can detect violations of service-level objectives already early during design time, and alter the software design until it meets the requirements. Current state-of-the-art tools like Palladio have proven useful for over a decade now, and provide accurate performance prediction not only for sophisticated, but also for distributed cloud systems. They are built upon the assumption of single-core CPU architectures, and consider only the clock rate as a single metric for CPU performance. However, current processor architectures have multiple cores and a more complex design. Therefore, the use of a single-metric model leads to inaccurate performance predictions for parallel applications in multicore systems. In the course of this thesis, we face the challenges for model-based performance predictions which arise from multicore processors, and present multiple strategies to extend performance prediction models. In detail, we (1) discuss the use of multicore CPU simulators used by CPU vendors; (2) conduct an extensive experiment to understand the effect of performance-influencing factors on the performance of parallel software; (3) research multi-metric models to reflect the characteristics of multicore CPUs better, and finally, (4) investigate the capabilities of software modelling languages to express massively parallel behaviour. As a contribution of this work, we show that (1) multicore CPU simulators simulate the behaviour of CPUs in detail and accurately. However, when using architectural models as input, the simulation results are very inaccurate. (2) Due to extensive experiments, we present a set of performance curves that reflect the behaviour of characteristic demand types. We included the performance curves into Palladio and have increased the performance predictions significantly. (3) We present an enhanced multi-metric hardware model, which reflects the memory architecture of modern multicore CPUs. (4) We provide a parallel architectural pattern catalogue, which includes four of the most common parallelisation patterns (i.e., parallel loops, pipes and filter, fork/join, master worker). Through this catalogue, we enable the software architect to model the parallel behaviour of software faster and with fewer errors.
Open Access
Semi-automated architecture-based cross-component issue dependency and propagation analysis and management
(2025) Speth, Sandro; Becker, Steffen (Prof. Dr.-Ing.)
Component-based and (micro-)service-oriented systems are increasingly popular due to their modularity and scalability. While components are independently developable, integrating them into larger systems introduces architectural dependencies. Consequently, issues arising in one component can propagate throughout the system, affecting other components and causing additional issues or even leading to cascading failures. Each component typically uses its own issue management system (IMS) project, often delivered by different providers such as GitHub or Jira. These IMS projects, especially those across providers, are rarely integrated, making the identification and management of cross-component issues and their propagations time-consuming and error-prone. Unfortunately, no scientific solution has been found to address this challenge so far. Industrial approaches often rely on IMS-specific plugins that offer only partial issue synchronization and limited applicability. To address this gap, we propose the Gropius method, which combines a structured issue management process with a language for cross-component issue management that integrates architectural knowledge and issues in a unified model and is integrated into our Gropius tool. Synchronizing issues between Gropius and each component's IMS project enables architecture-wide availability of issues and semantic linking of issues across the boundaries of a single component. An architecture-based issue propagation analysis enables semi-automated prediction of issue propagation graphs, proactively identifying whether a component is transitively affected by a root-causing issue. Furthermore, we employ multiclass classification on issue pairs to predict issue relations such as "depends on", possibly across different components. We evaluated the Gropius method through its application in an open-source software project over an 11-month period, supplemented by a survey and semi-structured interviews with the development team. Results indicate that incorporating architectural knowledge into issue management, as done in our Gropius method, improves the effectiveness and efficiency of cross-component issue handling. Additionally, we evaluated the issue propagation analysis using precision, recall, and F1 score in two case studies. The propagation analysis accurately predicts issue dependencies, though it requires considerable modeling effort. We also assessed our relation prediction by computing precision, recall, and F1 score.The classification results are promising and confirm the technical feasibility of relation prediction in domains with ambiguous textual descriptions, though the accuracy still requires improvement for production-level applicability. Overall, the Gropius method supports software architects, product owners, and DevOps engineers in managing cross-component issues effectively and efficiently by combining architectural knowledge with issue tracking in a unified model and enabling automated analysis.
Open Access
Understanding behavior of third-party components through explanation and configurable mapping models
(2024) Hakamian, Alireza; Becker, Steffen (Prof. Dr.-Ing.)
Most of the code executed in modern software systems is developed and maintained outside the organization. Understanding whether or not third-party components behave as intended requires expertise, which is rare and costly. Behavioral conformance checking (BCC) aims to identify deviations and conformances between system design and implementation by establishing relations between elements of design and implementation models. This dissertation aims to assist application designers in (1) simplifying BCC for different third-party components and (2) understanding the behavior of third-party components. Our method aligns more with design science methodology that aims to address research questions by developing and evaluating IT artifacts.