Symbolic execution is an effective method to analyse an application's properties thoroughly, based on the idea of analysing every control flow path an application can take. Although symbolic execution has many different use cases, it suffers from two main challenges: the state space explosion problem and the computationally expensive solving of constraints collected along the paths. The primary goal of this thesis is to tackle both issues and improve the applicability of symbolic execution, i.e., allowing larger and more complex applications to be analysed by symbolic execution. This work will focus on C and C++ as languages for systems programming. Moreover, this work heavily builds on KLEE --- a symbolic execution engine based on the LLVM framework. We took on the challenge of managing the memory used by symbolic execution more efficiently. If an application is tested, symbolic execution tracks its memory. Due to the state space explosion problem, dynamic symbolic execution must handle many states simultaneously. Choosing the right granularity of tracked memory changes will positively impact symbolic execution's performance and memory utilisation. While constraint solving is one computationally expensive part of symbolic execution, incremental solving is an effective method for SMT and SAT solving to reuse existing solutions and speed up the solving process. Unfortunately, utilising this approach is less straightforward in symbolic execution as it hinders different optimisations and caching strategies used by symbolic execution. We introduce a technique that nevertheless helps to combine these methods efficiently. Furthermore, we researched how a multi-threaded symbolic execution engine can efficiently utilise process-local resources, avoiding inter-process communication. We mainly focus on the shared use of solver queries across threads by separating shared and common query constraints and re-using the latter results more efficiently across multiple queries. Besides the general challenges of symbolic execution, we found it difficult to evaluate the improvement we made along with this work. While partially caused by our learning process, we found that symbolic execution and its state-space explosion problem make it hard to compare contributions in this field and assess their impact. Therefore, we came up with Deterministic State-Space Exploration that improves this process.

Assessing Anonymized System Logs Usefulness for Behavioral Analysis in RNN Models Tom Richard Vargis1,∗, Siavash Ghiasvand1,2 1Technische Universität Dresden, Germany 2Center for Scalable Data Analytics and Artificial Intelligence (ScaDS.AI) Dresden/Leipzig, Germany Abstract System logs are a common source of monitoring data for analyzing computing systems behavior. Due to the complexity of modern computing systems and the large size of collected monitoring data, automated analysis mechanisms are required. Numerous machine learning and deep learning methods are proposed to address this challenge. However, due to the existence of sensitive data in system logs their analysis and storage raise serious privacy concerns. Anonymization methods could be used to cleanse the monitoring data before analysis. However, anonymized system logs in general do not provide an adequate usefulness for majority of behavioral analysis. Content-aware anonymization mechanisms such as 𝑃𝛼𝑅𝑆 preserve the correlation of system logs even after anonymization. This work evaluates the usefulness of anonymized system logs of Taurus HPC cluster anonymized using 𝑃𝛼𝑅𝑆, for behavioural analysis via recurrent neural network models. To facilitate the reproducibility and further development of this work, the implemented prototype and monitoring data are publicly available [12].

The community project OpenStreetMap (OSM), which is well-known for its open geographic data, still lacks a commonly accepted mapping scheme for indoor data. Most of the previous approaches show inconveniences in their mapping workflow and affect the mapper's motivation. In our paper, an easy to use data scheme for OSM indoor mapping is presented. Finally, by means of several rendering examples from our Android application, we show that the new data scheme is capable for real world scenarios.

Der Einsatz von Multicore-Prozessoren in der industriellen Steuerungstechnik birgt sowohl Chancen als auch Risiken. Die vorliegende Dissertation entwickelt und bewertet aus diesem Grund generische Strategien zur Nutzung dieser Prozessorarchitektur unter Berücksichtigung der spezifischen Rahmenbedingungen und Anforderungen dieser Domäne. Multicore-Prozessoren bieten die Chance zur Konsolidierung derzeit auf dedizierter Hardware ausgeführter heterogener Steuerungssubsysteme unter einer bisher nicht erreichbaren temporalen Isolation. In diesem Kontext definiert die vorliegende Dissertation die spezifischen Anforderungen, die eine integrierte Ausführung in der Domäne der industriellen Automatisierung erfüllen muss. Eine Vorbedingung für ein derartiges Szenario stellt allerdings der Einsatz einer geeigneten Konsolidierungslösung dar. Mit einem virtualisierten und einem hybriden Konsolidierungsansatz werden deshalb zwei repräsentative Lösungen für die Domäne eingebetteter Systeme vorgestellt, die schließlich hinsichtlich der zuvor definierten Kriterien evaluiert werden. Da die Taktraten von Prozessoren physikalische Grenzen erreicht haben, werden sich in der Steuerungstechnik signifikante Performanzsteigerungen zukünftig nur durch den Einsatz von Multicore-Prozessoren erzielen lassen. Dies hat zur Vorbedingung, dass die Firmware die Parallelität dieser Prozessorarchitektur in geeigneter Weise zu nutzen vermag. Leider entstehen bei der Parallelisierung eines komplexen Systems wie einer Automatisierungs-Firmware im Allgemeinen signifikante Aufwände. Infolgedessen sollten diesbezügliche Entscheidungen nur auf Basis einer objektiven Abwägung potentieller Alternativen getroffen werden. Allerdings macht die Systemkomplexität eine Abschätzung der durch eine spezifische parallele Firmware-Architektur zu erwartenden Performanz zu einer anspruchsvollen Aufgabe. Dies gilt vor allem, da eine Parallelisierung gefordert wird, die für eine Vielzahl von Lastszenarien in Form gesteuerter Maschinen geeignet ist. Aus diesem Grund spezifiziert die vorliegende Dissertation eine anwendungsorientierte Methode zur Unterstützung von Entwurfsentscheidungen, die bei der Migration einer bestehenden Singlecore-Firmware auf eine homogene Multicore-Architektur zu treffen sind. Dies wird erreicht, indem in automatisierter Weise geeignete Firmware-Modelle auf Basis von dynamischem Profiling der Firmware unter mehreren repräsentativen Lastszenarien erstellt werden. Im Anschluss daran werden diese Modelle um das Expertenwissen von Firmware-Entwicklern erweitert, bevor mittels multikriterieller genetischer Algorithmen der Entwurfsraum der Parallelisierungsalternativen exploriert wird. Schließlich kann eine spezifische Lösung der auf diese Weise hergeleiteten Pareto-Front auf Basis ihrer Bewertungsmetriken zur Implementierung durch einen Entwickler ausgewählt werden. Die vorliegende Arbeit schließt mit einer Fallstudie, welche die zuvor beschriebene Methode auf eine numerische Steuerungs-Firmware anwendet und dabei deren Potential für eine umfassende Unterstützung einer Firmware-Parallelisierung aufzeigt. / The application of multi-core CPUs in industrial control technology holds chances as well as risks. Consequently, this thesis develops and evaluates generic strategies for using this processor architecture in due consideration of the specific framework conditions and demands of this domain. Multi-core CPUs offer the chance of consolidating heterogeneous control subsystems currently running on dedicated hardware devices while maintaining a degree of temporal isolation in between them that has been unattainable so far. In this context, this thesis defines the specific demands an integrated execution has to meet in the domain of industrial automation. However, one precondition to this scenario is the use of an appropriate consolidation solution. Thus, two representative solutions for the domain of embedded systems are presented in terms of a virtualized and a hybrid consolidation approach, before being finally evaluated with regard to the previously defined criteria. As CPU clock rates have reached physical boundaries, significant future performance gains in the domain of control technology will only be achieved by the application of multi-core CPUs. As a precondition, the firmware has to exploit the parallelism of this processor architecture in an appropriate manner. Unfortunately, for a sophisticated system like an automation firmware, a parallelization commonly induces significant efforts. Thus, decisions in this regard should only be made on the basis of an objective consideration of potential alternatives. However, an estimation of a specific parallel firmware design's prospective performance is challenging due to the system's complexity. This is particularly true, as a parallelization is required that fits a variety of load scenarios in terms of the machines being controlled. Thus, this thesis specifies an application-oriented method that supports the design decisions to be taken when migrating an existing single-core firmware to a homogeneous multi-core architecture. This is achieved by automatically building adequate firmware models based on dynamic firmware profiling under multiple representative load scenarios. These models are then enhanced by the firmware developers' expert knowledge before multi-objective genetic algorithms are applied for exploring the design space of parallelization alternatives. Finally, a specific solution from the retrieved Pareto front can be selected on basis of its evaluation metrics for an implementation by a developer. This thesis concludes with a case study that applies the aforementioned method to a numerical control firmware and thereby reveals its potential of supporting a firmware parallelization in a comprehensive way.

Process patterns allow the modular modelling and adaptable application of business processes. Present descriptions of process patterns show defects like non-uniform and unequivocal description forms and missing relationship definitions. These defects disadvantageously affect the effective usage of process patterns. In this work we introduce the language PROPEL (Process Pattern Description Language), which provides concepts for the semiformal description of process patterns and relationships between process patterns. With the help of PROPEL single process patterns can be modelled and, by definition of relationships, be composed to more complicated processes. With the representation of different views of a process pattern catalog the process patterns and their relationships can be shown clearly. An example illustrates how a process pattern catalog and the contained process patterns are modelled. It is shown that in applying PROPEL the complexity of a process model can be reduced and inconsistencies of processes be eliminated.

In this paper we improve the rate-distortion performance of a previously proposed video coder based on frame replenishment and adaptive mean-removed vector quantization. This is realized by determining for each block of a given frame the optimal encoding mode in the rate-distortion sense. The algorithm is a new contribution to very low bit rate video coding with adaptive vector quantization suitable for videophone applications. Experimental results comparing the two coders for several test sequences at different bit rates are provided.

We study algorithms for efficient compression and decompression of a sequence of integers on modern hardware. Our focus is on universal codes in which the codeword length is a monotonically non-decreasing function of the uncompressed integer value; such codes are widely used for compressing 'small integers'. In contrast to traditional integer compression, our algorithms make use of the SIMD capabilities of modern processors by encoding multiple integer values at once. More specifically, we provide SIMD versions of both null suppression and Elias gamma encoding. Our experiments show that these versions provide a speedup from 1.5x up to 6.7x for decompression, while maintaining a similar compression performance.

Background: Software is an integral part of today's world with an outlook of ever-increasing importance. Maintaining all of these software artifacts is a major challenge for software engineering. A future with robust software primarily relies on programmers' ability to understand existing source code, because they spend most of their time on it. Program comprehension is the cognitive process of understanding source code. Since program comprehension is an internal cognitive process, it is inherently difficult to observe and measure reliably. Decades of research have developed fundamental models of program comprehension, but there still are substantial knowledge gaps in our understanding of program comprehension. Novel psycho-physiological and neuroimaging measures provide an additional perspective on program comprehension which promise new insights to program comprehension. Recently, these measures have been permeating software engineering research. The measures include eye tracking and physiological sensors, but also neuroimaging measures, such as functional magnetic resonance imaging (fMRI), which allow researchers to more objectively observe cognitive processes. Aims: This dissertation aims to advance software engineering by better understanding program comprehension. We apply and refine the use of psycho-physiological and neuroimaging measures. The goals are twofold: First, we develop a framework for studying program comprehension with neuroimaging, psycho-physiological, eye tracking, and behavioral methods. For neuroimaging, we focus on functional magnetic resonance imaging (fMRI), as it allows researchers to unravel cognitive processes in high detail. Our framework offers a detailed, multi-modal view on program comprehension that allows us to examine even small effects. Second, we shed light on the underlying cognitive process of program comprehension by applying our experiment framework. One major focus is to understand experienced programmers' efficient top-down comprehension. We also link programmers' cognition to common code complexity metrics. Method and Results: To fulfill our goals, we conduct a series of empirical studies on program comprehension. In these studies, we use and combine fMRI, psycho-physiological, and eye-tracking measures. Throughout the experiments, we develop and refine a multi-modal experiment framework to shed light onto program comprehension with a neuro-cognitive perspective. We demonstrate that the framework provides a reliable approach to quantify and to investigate programmers' cognitive processes. We explore the neuro-cognitive perspective of program comprehension to validate and extend established program-comprehension models. We show that programmers using top-down comprehension require less cognitive effort, but use the same network of brain areas. We also demonstrate how our developed experiment framework and fMRI as a measure can be used in software engineering to provide objective data in long-standing debates. For example, we show that commonly used, but criticized code complexity metrics indeed only have a limited predictive power on the required cognitive effort to understand source code. Conclusion: In our interdisciplinary research, we show how neuroimaging methods, such as fMRI, in combination with psycho-physiological, eye tracking and behavioral measures, is beneficial to software-engineering research. This dissertation provides a foundation to further investigate the neuro-cognitive perspective to programmers' brains, which is a critical contribution to the future of software engineering. / Hintergrund: Software ist ein fester Bestandteil der heutigen Welt mit einer immer wichtiger werdenden Bedeutung. Das moderne Leben ist infolgedessen zunehmend von funktionierender und möglichst fehlerfreier Software abhängig. Deshalb ist die Pflege aller Software-Artefakte eine wichtige und große Herausforderung für das Software-Engineering. Eine Zukunft mit robuster Software hängt in erster Linie von der Fähigkeit ab, den vorhandenen Quellcode zu verstehen, da damit die meiste Zeit verbracht wird. Programmverständnis ist der kognitive Prozess des Verstehens von Quellcode. Da dieser kognitive Prozess intern abläuft, ist ein zuverlässiges Beobachten und ein genaues Messen mit erheblichen Schwierigkeiten verbunden. Jahrzehntelange Forschung hat zwar grundlegende Modelle des Programmverständnisses entwickelt, aber das Bild von Programmverständnis weist noch immer erhebliche Wissenslücken auf. Neuartige psychophysiologische und nicht-invasive human-bildgebende Verfahren bieten zusätzliche Perspektiven auf das Programmverständnis, die neue Erkenntnisse versprechen. In den letzten Jahren haben diese Erfassungsmöglichkeiten die Software-Engineering-Forschung durchdrungen. Zu den Messverfahren gehören Eyetracking und physiologische Sensoren, aber auch nicht-invasive Human-Bildgebung, wie die funktionelle Magnetresonanztomographie (fMRT). Diese innovativen Messverfahren ermöglichen es Forschenden, kognitive Prozesse objektiver und genauer zu verfolgen und auszuwerten. Ziele: Diese Dissertation zielt darauf ab, Software-Engineering durch ein besseres Erfassen des Programmverständnisses voranzubringen. Dafür werden psychophysiologische und nicht-invasive human-bildgebende Verfahren angewendet und verfeinert. Es werden zwei Ziele verfolgt: Zum einen wird ein Framework für Experimente zum Programmverständnis, die mit Human-Bildgebung, Psychophysiologie, Eyetracking und Verhaltensmethoden durchgeführt werden, entwickelt. Bei der Human-Bildgebung erfolgt die Konzentration auf die funktionelle Magnetresonanztomographie (fMRT), da sie kognitive Prozesse mit hoher Detailschärfe entschlüsseln kann. Das entwickelte Framework bietet eine detaillierte, multimodale Sicht auf das Programmverständnis, die es ermöglicht, auch kleine Effekte zu untersuchen. Zum anderen wird der zugrunde liegende kognitive Prozess des Programmverständnisses durch den Einsatz des aufgestellten Frameworks analysiert. Ein Hauptaugenmerk liegt dabei auf dem Erfassen des effizienten Top-Down-Verstehens von Quellcode. Zusätzlich wird die Kognition beim Programmieren mit gängigen Komplexitätsmetriken von Quellcode verknüpft und im Zusammenhang ausgewertet. Methodik und Ergebnisse: Um die Ziele zu erreichen, werden eine Reihe empirischer Studien zum Programmverständnis durchgeführt. In diesen Studien werden fMRT, Psychophysiologie sowie Eyetracking verwendet und miteinander kombiniert. Während der Experimente erfolgt eine Entwicklung und Verfeinerung eines multimodalen Experimentframework, um das Programmverständnis mit einer neurokognitiven Perspektive zu beleuchten. Es wird dokumentiert, dass das entwickelte Framework einen zuverlässigen Ansatz bietet, um kognitive Prozesse beim Programmieren zu quantifizieren und zu untersuchen. Weiterhin wird die neurokognitive Perspektive des Programmverständnisses erforscht, um etablierte Programmverständnismodelle zu validieren und zu erweitern. Im Kontext dessen wird belegt, dass das Top-Down-Verständnis das gleiche Netzwerk von Gehirnbereichen aktiviert, aber zu geringerer kognitiver Last führt. Es wird demonstriert, wie das entwickelte Experimentframework und fMRT als Messverfahren im Software-Engineering verwendet werden können, um in langjährigen Debatten objektive Daten zu bieten. Dabei wird insbesondere gezeigt, weshalb gängige, aber in Frage gestellte Komplexitätsmetriken von Quellcode tatsächlich nur eine begrenzte Vorhersagekraft auf die erforderliche kognitive Last beim Verstehen von Quellcode haben. Schlussfolgerung: In interdisziplinärer Forschung wird nachgewiesen, dass nicht-invasive human-bildgebende Verfahren wie die fMRT, kombiniert mit Psychophysiologie, Eyetracking sowie Verhaltensmethoden für die Software-Engineering-Forschung von erheblichem Vorteil sind. Diese Dissertation bietet eine belastbare Grundlage für die weitere Untersuchung der neurokognitiven Perspektive auf das Gehirn von Programmierern. Damit wird ein entscheidender Beitrag für ein erfolgreiches Software-Engineering geleistet.

New application versions may contain source code changes that decrease the application’s performance. To ensure sufficient performance, it is necessary to identify these code changes. Peass is a performance analysis tool using performance measurements of unit tests to achieve that goal for Java applications. However, it can only be utilized for Java applications that are built using the tools Apache Maven or Gradle. This thesis provides a plugin for Peass that enables it to analyze applications built with Apache Ant. Peass utilizes the frameworks Kieker and KoPeMe to record the execution traces and measure the response times of unit tests. This results in the following tasks for the Peass-Ant plugin: (1) Add Kieker and KoPeMe as dependencies and (2) Execute transformed unit tests. For the first task, our plugin programmatically resolves the transitive dependencies of Kieker and KoPeMe and modifies the XML buildfiles of the application under test. For the second task, the plugin orchestrates the process that surrounds test execution—implementing performance optimizations for the analysis of applications with large codebases—and executes specific Ant commands that prepare and start test execution. To make our plugin work, we additionally improved Peass and Kieker. Therefore, we implemented three enhancements and identified twelve bugs. We evaluated the Peass-Ant plugin by conducting a case study on 200 commits of the open-source project Apache Tomcat. We detected 14 commits with 57 unit tests that contain performance changes. Our subsequent root cause analysis identified nine source code changes that we assigned to three clusters of source code changes known to cause performance changes.:1. Introduction 1.1. Motivation 1.2. Objectives 1.3. Organization 2. Foundations 2.1. Performance Measurement in Java 2.2. Peass 2.3. Apache Ant 2.4. Apache Tomcat 3. Architecture of the Plugin 3.1. Requirements 3.2. Component Structure 3.3. Integrated Class Structure of Peass and the Plugin 3.4. Build Modification Tasks for Tomcat 4. Implementation 4.1. Changes in Peass 4.2. Changes in Kieker and Kieker-Source-Instrumentation 4.3. Buildfile Modification of the Plugin 4.4. Test Execution of the Plugin 5. Evaluative Case Study 5.1. Setup of the Case Study 5.2. Results of the Case Study 5.3. Performance Optimizations for Ant Applications 6. Related Work 6.1. Performance Analysis Tools 6.2. Test Selection and Test Prioritization Tools 6.3. Empirical Studies on Performance Bugs and Regressions 7. Conclusion and Future Work 7.1. Conclusion 7.2. Future Work / Neue Versionen einer Applikation können Quelltextänderungen enthalten, die die Performance der Applikation verschlechtern. Um eine ausreichende Performance sicherzustellen, ist es notwendig, diese Quelltextänderungen zu identifizieren. Peass ist ein Performance-Analyse-Tool, das die Performance von Unit-Tests misst, um dieses Ziel für Java-Applikationen zu erreichen. Allerdings kann es nur für Java-Applikationen verwendet werden, die eines der Build-Tools Apache Maven oder Gradle nutzen. In dieser Arbeit wird ein Plugin für Peass entwickelt, das es ermöglicht, mit Peass Applikationen zu analysieren, die das Build-Tool Apache Ant nutzen. Peass verwendet die Frameworks Kieker und KoPeMe, um Ausführungs-Traces von Unit-Tests aufzuzeichnen und Antwortzeiten von Unit-Tests zu messen. Daraus resultieren folgende Aufgaben für das Peass-Ant-Plugin: (1) Kieker und KoPeMe als Abhängigkeiten hinzufügen und (2) Transformierte Unit-Tests ausführen. Für die erste Aufgabe löst das Plugin programmbasiert die transitiven Abhängigkeiten von Kieker und KoPeMe auf und modifiziert die XML-Build-Dateien der zu testenden Applikation. Für die zweite Aufgabe steuert das Plugin den Prozess, der die Testausführung umgibt, und führt spezielle Ant-Kommandos aus, die die Testausführung vorbereiten und starten. Dabei implementiert es Performanceoptimierungen, um auch Applikationen mit einer großen Codebasis analysieren zu können. Um die Lauffähigkeit des Plugins sicherzustellen, wurden zusätzlich Verbesserungen an Peass und Kieker vorgenommen. Dabei wurden drei Erweiterungen implementiert und zwölf Bugs identifiziert. Um das Peass-Ant-Plugin zu bewerten, wurde eine Fallstudie mit 200 Commits des Open-Source-Projekts Apache Tomcat durchgeführt. Dabei wurden 14 Commits mit 57 Unit-Tests erkannt, die Performanceänderungen enthalten. Unsere anschließende Ursachenanalyse identifizierte neun verursachende Quelltextänderungen. Diese wurden drei Clustern von Quelltextänderungen zugeordnet, von denen bekannt ist, dass sie eine Veränderung der Performance verursachen.:1. Introduction 1.1. Motivation 1.2. Objectives 1.3. Organization 2. Foundations 2.1. Performance Measurement in Java 2.2. Peass 2.3. Apache Ant 2.4. Apache Tomcat 3. Architecture of the Plugin 3.1. Requirements 3.2. Component Structure 3.3. Integrated Class Structure of Peass and the Plugin 3.4. Build Modification Tasks for Tomcat 4. Implementation 4.1. Changes in Peass 4.2. Changes in Kieker and Kieker-Source-Instrumentation 4.3. Buildfile Modification of the Plugin 4.4. Test Execution of the Plugin 5. Evaluative Case Study 5.1. Setup of the Case Study 5.2. Results of the Case Study 5.3. Performance Optimizations for Ant Applications 6. Related Work 6.1. Performance Analysis Tools 6.2. Test Selection and Test Prioritization Tools 6.3. Empirical Studies on Performance Bugs and Regressions 7. Conclusion and Future Work 7.1. Conclusion 7.2. Future Work

The key objective of database systems is to reliably manage data, whereby high query throughput and low query latency are core requirements. To satisfy these requirements, database systems constantly adapt to novel hardware features. Although it has been intensively studied and commonly accepted that hardware error rates in terms of bit flips increase dramatically with the decrease of the underlying chip structures, most database system research activities neglected this fact, leaving error (bit flip) detection as well as correction to the underlying hardware. Especially for main memory, silent data corruption (SDC) as a result of transient bit flips leading to faulty data is mainly detected and corrected at the DRAM and memory-controller layer. However, since future hardware becomes less reliable and error detection as well as correction by hardware becomes more expensive, this free ride will come to an end in the near future. To further provide a reliable data management, an emerging research direction is employing specific and tailored protection techniques at the database system level. Following that, we are currently developing and implementing an adopted system design for state-of-the-art in-memory column stores. In our lightning talk, we will summarize our current state and outline future work.