Runtime Behavior Research Articles

Execution trace‐based model verification to analyze multicore and real‐time systems

AbstractAs a key part of model‐driven development, modeling allows users to represent the application workflow or to automatically generate source code. This is convenient for developers, particularly to create or improve real‐time applications embedded in complex systems. Multicore systems are difficult to debug because the concurrently running processes can interfere with each other. In real‐time systems, timing constraints add to the complexity, invalidating results when a deadline is missed. Tracing is usually the most accurate and reliable tool to study the runtime behaviour of those applications. However, the interpretation of voluminous detailed execution traces requires a deep understanding of the operating system and application behaviour, and time to dig through the millions of trace events.In this paper, we present the use of model‐based constraints on top of user‐space and kernel traces to provide weighted analysis results. Our algorithms have been applied to multiple traces showing common problems for multi‐core real‐time systems. The experimental results show that our algorithms can quickly identify many different types of problems with a low runtime, even for traces with millions of events, thus helping to save time when analyzing thousands of trace events for complex systems.

Evading behavioral classifiers: a comprehensive analysis on evading ransomware detection techniques

Recent progress in machine learning has led to promising results in behavioral malware detection. Behavioral modeling identifies malicious processes via features derived by their runtime behavior. Behavioral features hold great promise as they are intrinsically related to the functioning of each malware, and are therefore considered difficult to evade. Indeed, while a significant amount of results exists on evasion of static malware features, evasion of dynamic features has seen limited work. This paper examines the robustness of behavioral ransomware detectors to evasion and proposes multiple novel techniques to evade them. Ransomware behavior differs significantly from that of benign processes, making it an ideal best case for behavioral detectors, and a difficult candidate for evasion. We identify and propose a set of novel attacks that distribute the overall malware workload across a small set of independent, cooperating processes in order to avoid the generation of significant behavioral features. Our most effective attack decreases the accuracy of a state-of-the-art classifier from 98.6 to 0% using only 18 cooperating processes. Furthermore, we show our attacks to be effective against commercial ransomware detectors in a black-box setting. Finally, we evaluate a detector designed to identify our most effective attack, as well as discuss potential directions to mitigate our most advanced attack.

A novel deep framework for dynamic malware detection based on API sequence intrinsic features

Dynamic malware detection executes the software in a secured virtual environment and monitors its run-time behavior. This technique widely uses API sequence analysis to identify whether the running software is malicious or not. However, existing solutions typically only consider the API name or frequency of API usage, and the feature mining of API sequence is not sufficient, which leads some malware to escape from being detected. In this paper, we propose a novel malware detection framework using deep learning models to capture and combine more meaningful features which are called intrinsic features of the API sequence. Specifically, we first apply embedding and convolutional layers to conduct a joint representation of multiple APIs to represent the software behavior. Secondly, we use the category, action, and operation object of the API to represent the semantic information of each API call. Finally, we use the Bi-LSTM module to mine the relationship information between APIs. Our proposed model achieves an accuracy of 0.9731 and an F1-score of 0.9724 on a large real dataset, which outperforms baselines significantly. We also conduct ablation studies to prove the effectiveness of our intrinsic features.

Automated Piping in an Airbus A320 Landing Gear Bay Using Graph-Based Design Languages

System design in an aircraft is still a costly, manual and iterative approach. One major cost driver of changes in system installation are design efforts for creating new pipes in an earlier stage and the costs accumulated during the in service life. To reduce these costs and the time to market, an automation approach with an integrated design optimization encoded in graph-based design languages and executable in a design compiler is proposed. To generate the pipe work automatically, a set of input data (e.g., start- and end-points of a pipe with tangents and fixing positions) is given by the user. It also contains, among others, the weightings for the optimization criteria (e.g., length of the pipe resp. the weight vs. the number of bends) to influence the evaluation of the generated pipes and thereby the final solution. As an initial step in the automatic pipe generation process, a route through the installation space is searched. Subsequently, the installation space is simplified and a respective minimal distance to each obstacle which a pipe should satisfy is added. Then for each pipe an initial solution is estimated and each pipe is optimized by a simulated annealing algorithm. At last, all given requirements are automatically verified. A carried out investigation indicates a polynomial runtime behaviour of the algorithm. The capabilities of the newly developed automated piping are demonstrated on the pipe work in an Airbus A320 landing gear bay.

Antivirus applied to JAR malware detection based on runtime behaviors

Java vulnerabilities correspond to 91% of all exploits observed on the worldwide web. The present work aims to create antivirus software with machine learning and artificial intelligence and master in Java malware detection. Within the proposed methodology, the suspected JAR sample is executed to intentionally infect the Windows OS monitored in a controlled environment. In all, our antivirus monitors and considers, statistically, 6824 actions that the suspected JAR file can perform when executed. Our antivirus achieved an average performance of 91.58% in the distinction between benign and malware JAR files. Different initial conditions, learning functions and architectures of our antivirus are investigated. The limitations of commercial antiviruses can be supplied by intelligent antiviruses. Instead of blacklist-based models, our antivirus allows JAR malware detection preventively and not reactively as Oracle’s Java and traditional antivirus modus operandi.

Uncovering input-sensitive energy bottlenecks in oversubscribed GPU workloads

Graph algorithms are at the core of data-intensive applications in many computational domains. Although accelerator-based implementations have the potential for delivering improved energy efficiency on today’s large-scale graph analytics, there are many challenges to reaching the desired goals. This paper examines the issues of GPU oversubscription and input sensitivity in energy efficient graph processing. We introduce the notion of energy signatures, a collection of runtime events that can determine fluctuations in power consumption as a function of input graph characteristics. The study shows that variations in volume, density, diameter and dispersion in graphs can alter the runtime behavior of GPU applications and these changes in program behavior in turn impact the energy efficiency of the application. Based on the insight gained from our study, we develop three input-aware optimization techniques to mitigate energy bottlenecks. On experiments conducted on a Unified Memory supported GPU, the optimizations yield a 11.97% energy savings on average on Breadth-First Search and Single-Source Shortest Path algorithms.

Multicriteria Scalable Graph Drawing via Stochastic Gradient Descent, (SGD)2.

Readability criteria, such as distance or neighborhood preservation, are often used to optimize node-link representations of graphs to enable the comprehension of the underlying data. With few exceptions, graph drawing algorithms typically optimize one such criterion, usually at the expense of others. We propose a layout approach, Multicriteria Scalable Graph Drawing via Stochastic Gradient Descent, (SGD)2, that can handle multiple readability criteria. (SGD)2 can optimize any criterion that can be described by a differentiable function. Our approach is flexible and can be used to optimize several criteria that have already been considered earlier (e.g., obtaining ideal edge lengths, stress, neighborhood preservation) as well as other criteria which have not yet been explicitly optimized in such fashion (e.g., node resolution, angular resolution, aspect ratio). The approach is scalable and can handle large graphs. A variation of the underlying approach can also be used to optimize many desirable properties in planar graphs, while maintaining planarity. Finally, we provide quantitative and qualitative evidence of the effectiveness of (SGD)2: we analyze the interactions between criteria, measure the quality of layouts generated from (SGD)2 as well as the runtime behavior, and analyze the impact of sample sizes. The source code is available on github and we also provide an interactive demo for small graphs.

SimAnMo—A parallelized runtime model generator

In this article, we present the novel features of the recent version of SimAnMo, the Simulated Annealing Modeler. The tool creates models that correlate the size of one input parameter of an application to the corresponding runtime and thus SimAnMo allows predictions for larger input sizes. A focus lies on applications whose runtime grows exponentially in the input parameter size. Such programs are, for example, of high interest for cryptanalysis to analyze practical security of traditional and post-quantum secure schemes. However, SimAnMo also generates reliable models for the widespread case of polynomial runtime behavior and also for the important case of factorial runtime increase. SimAnMo's model generation is based on a parallelized simulated annealing procedure and heuristically minimizes the costs of a model. Those may rely on different quality metrics. Insights into SimAnMo's software design and its usage are provided. We demonstrate the quality of SimAnMo's models for different algorithms from various application fields. We show that our approach also works well on ARM architectures.

Timed protocol analysis of interconnected mobile IoT devices

With the emergence of the Internet of Things (IoT), application developers can rely on a variety of protocols and Application Programming Interfaces (APIs) to support data exchange between IoT devices. However, this may result in highly heterogeneous IoT interactions in terms of both functional and non-functional semantics. To map between heterogeneous functional semantics, middleware connectors can be utilized to interconnect IoT devices via bridging mechanisms. In this paper, we make use of the Data eXchange (DeX) connector model that enables interoperability among heterogeneous IoT devices. DeX interactions, including synchronous, asynchronous and streaming, rely on generic post and get primitives to represent IoT device behaviors with varying space/time coupling. Nevertheless, non-functional time semantics of IoT interactions such as data availability/validity, intermittent connectivity and application processing time, can severely affect response times and success rates of DeX interactions. We introduce timing parameters for time semantics to enhance the DeX API. The new DeX API enables the mapping of both functional and time semantics of DeX interactions. By precisely studying these timing parameters using timed automata models, we verify conditions for successful interactions with DeX connectors. Furthermore, we statistically analyze through simulations the effect of varying timing parameters to ensure higher probabilities of successful interactions. Simulation experiments are compared with experiments run on the DeX Mediators (DeXM) framework to evaluate the accuracy of the results. This work can provide application developers with precise design time information when setting these timing parameters in order to ensure accurate runtime behavior.

IoTranx: Transactions for Safer Smart Spaces

Smart spaces such as smart homes deliver digital services to optimize space use and enhance user experience. They are composed of an Internet of Things (IoT), people, and physical content. They differ from traditional computer systems in that their cyber-physical nature ties intimately with the users and the built environment. The impact of ill-programmed applications in such spaces goes beyond loss of data or a computer crash, risking potentially physical harm to the space and its users. Ensuring smart space safety is therefore critically important to successfully deliver intimate and convenient services surrounding our daily lives. By modeling smart space as a highly dynamic database, we present IoT Transactions, an analogy to database transactions, as an abstraction for programming and executing the services as the handling of the devices in smart space. Unlike traditional database management systems that take a “clear room approach,” smart spaces take a “dirty room approach” where imperfection and unattainability of full control and guarantees are the new normal. We identify Atomicity, Isolation, Integrity and Durability (AI 2 D) as the set of properties necessary to define the safe runtime behavior for IoT transactions for maintaining “permissible device settings” of execution and to avoid or detect and resolve “impermissible settings.” Furthermore, we introduce a lock protocol, utilizing variations of lock concepts, that enforces AI 2 D safety properties during transaction processing. We show a brief proof of the protocol correctness and a detailed analytical model to evaluate its performance.

A Crew Scheduling Model to Incrementally Optimize Workforce Assignments for Offshore Wind Farm Constructions

In the literature, different authors attribute between 15% to 30% of a wind farm’s costs to logistics during the installation, e.g., for vessels or personnel. Currently, there exist only a few approaches for crew scheduling in the offshore area. However, current approaches only satisfy subsets of the offshore construction area’s specific terms and conditions. This article first presents a literature review to identify different constraints imposed on crew scheduling for offshore installations. Afterward, it presents a new Mixed-Integer Linear Model that satisfies these crew scheduling constraints and couples it with a scheduling approach using a Model Predictive Control scheme to include weather dynamics. The evaluation of this model shows reliable scheduling of persons/teams given weather-dependent operations. Compared to a conventionally assumed full staffing of vessels and the port, the model decreases the required crews by approximately 50%. Moreover, the proposed model shows good runtime behavior, obtaining optimal solutions for realistic scenarios in under an hour.

Self-Tuning Lam Annealing: Learning Hyperparameters While Problem Solving

The runtime behavior of Simulated Annealing (SA), similar to other metaheuristics, is controlled by hyperparameters. For SA, hyperparameters affect how “temperature” varies over time, and “temperature” in turn affects SA’s decisions on whether or not to transition to neighboring states. It is typically necessary to tune the hyperparameters ahead of time. However, there are adaptive annealing schedules that use search feedback to evolve the “temperature” during the search. A classic and generally effective adaptive annealing schedule is the Modified Lam. Although effective, the Modified Lam can be sensitive to the scale of the cost function, and is sometimes slow to converge to its target behavior. In this paper, we present a novel variation of the Modified Lam that we call Self-Tuning Lam, which uses early search feedback to auto-adjust its self-adaptive behavior. Using a variety of discrete and continuous optimization problems, we demonstrate the ability of the Self-Tuning Lam to nearly instantaneously converge to its target behavior independent of the scale of the cost function, as well as its run length. Our implementation is integrated into Chips-n-Salsa, an open-source Java library for parallel and self-adaptive local search.

Static detection of silent misconfigurations with deep interaction analysis

The behavior of large systems is guided by their configurations: users set parameters in the configuration file to dictate which corresponding part of the system code is executed. However, it is often the case that, although some parameters are set in the configuration file, they do not influence the system runtime behavior, thus failing to meet the user’s intent. Moreover, such misconfigurations rarely lead to an error message or raising an exception. We introduce the notion of silent misconfigurations which are prohibitively hard to identify due to (1) lack of feedback and (2) complex interactions between configurations and code. This paper presents ConfigX, the first tool for the detection of silent misconfigurations. The main challenge is to understand the complex interactions between configurations and the code that they affected. Our goal is to derive a specification describing non-trivial interactions between the configuration parameters that lead to silent misconfigurations. To this end, ConfigX uses static analysis to determine which parts of the system code are associated with configuration parameters. ConfigX then infers the connections between configuration parameters by analyzing their associated code blocks. We design customized control- and data-flow analysis to derive a specification of configurations. Additionally, we conduct reachability analysis to eliminate spurious rules to reduce false positives. Upon evaluation on five real-world datasets across three widely-used systems, Apache, vsftpd, and PostgreSQL, ConfigX detected more than 2200 silent misconfigurations. We additionally conducted a user study where we ran ConfigX on misconfigurations reported on user forums by real-world users. ConfigX easily detected issues and suggested repairs for those misconfigurations. Our solutions were accepted and confirmed in the interaction with the users, who originally posted the problems.

An international survey on MPI users

The Message Passing Interface (MPI) plays a crucial part in the parallel computing ecosystem, a driving force behind many of the high-performance computing (HPC) successes. To maintain its relevance to the user community—and in particular to the growing HPC community at large—the MPI standard needs to identify and understand the MPI users’ concerns and expectations, and adapt accordingly to continue to efficiently bridge the gap between users and hardware. This questionnaire survey was conducted using two online questionnaire frameworks and has gathered more than 850 answers from 42 countries since February 2019. Some of preceding surveys of MPI uses are questionnaire surveys like ours, while others are conducted either by analyzing MPI programs to reveal static behavior or by using profiling tools to analyze the dynamic runtime behavior of MPI jobs. Our survey is different from other questionnaire surveys in terms of its larger number of participants and wide geographic spread. As a result, it is possible to illustrate the current status of MPI users more accurately and with a wider geographical distribution. In this report, we will show some interesting findings, compare the results with preceding studies when possible, and provide some recommendations for MPI Forum based on the findings.

Recommending Faulty Configurations for Interacting Systems Under Test Using Multi-objective Search

Modern systems, such as cyber-physical systems, often consist of multiple products within/across product lines communicating with each other through information networks. Consequently, their runtime behaviors are influenced by product configurations and networks. Such systems play a vital role in our daily life; thus, ensuring their correctness by thorough testing becomes essential. However, testing these systems is particularly challenging due to a large number of possible configurations and limited available resources. Therefore, it is important and practically useful to test these systems with specific configurations under which products will most likely fail to communicate with each other. Motivated by this, we present a search-based configuration recommendation ( SBCR ) approach to recommend faulty configurations for the system under test (SUT) based on cross-product line (CPL) rules. CPL rules are soft constraints, constraining product configurations while indicating the most probable system states with a certain degree of confidence. In SBCR , we defined four search objectives based on CPL rules and combined them with six commonly applied search algorithms. To evaluate SBCR (i.e., SBCR NSGA-II , SBCR IBEA , SBCR MoCell , SBCR SPEA2 , SBCR PAES , and SBCR SMPSO ), we performed two case studies (Cisco and Jitsi) and conducted difference analyses. Results show that for both of the case studies, SBCR significantly outperformed random search-based configuration recommendation ( RBCR ) for 86% of the total comparisons based on six quality indicators, and 100% of the total comparisons based on the percentage of faulty configurations (PFC). Among the six variants of SBCR, SBCR SPEA2 outperformed the others in 85% of the total comparisons based on six quality indicators and 100% of the total comparisons based on PFC.

Flexible Mixed-Criticality Scheduling with Dynamic Slack Management

Mixed-criticality (MC) system has attracted a lot of research attention in the past few years for its resource efficiency. Recent work attempted to provide a new MC model, the so-called Flexible Mixed-Criticality (FMC) task model, to relax the pessimistic assumptions in classic MC scheduling. However, in FMC, the behavior of MC tasks is still analyzed in offline stage. The run-time behavior such as dynamic slack has not yet been studied in FMC scheduling framework. In this paper, we present a utilization-based slack scheduling framework for FMC tasks. In particular, we monitor task execution on run time and collect dynamic slacks generated by task early completion. And these slacks can then be used either by high-criticality tasks to reduce mode-switches, or by low-criticality tasks so that less suspensions are triggered with more execution time, and thus quality of service is improved. We evaluate our approach with extensive simulations, and experiment results demonstrate the effectiveness of the proposed approaches.

Cloud Function Performance: a component modeling approach

Cloud Functions are a trend in cloud computing in which developers are allowed to install code in a Function-as-a-Service (FaaS) platform able to manage provisioning, execution, monitoring and automatic scaling. The underlying infrastructure in FaaS platforms is hidden from the developers and designers and, since the inuence of the infrastructure is unknown, this makes it di_cult to apply software performance engineering approaches on cloud functions, which could lead to wrong or inaccurate performance estimations. In this study, we explore the use of component-based modeling and simulation in order to generate performance estimations of an exemplar cloud function which was exercised using a variety of workloads. A cloud function was both implemented and instrumented to record performance datain a log _le, associated with its invocations; using the log _le as an input, we extracted a performance model in a Palladio Component Model format suitable for running simulations to validate whether the generated model could explain the runtime behavior of the function. Using this approach and further tunings in the model, we were able to validate that the simulations could explain more than 95% of the function's behavior and that component-based modeling and simulation can be considered a serious option when trying to explain the behavior of a cloud function.

Software engineering techniques for statically analyzing mobile apps: research trends, characteristics, and potential for industrial adoption

Mobile platforms are rapidly and continuously changing, with support for new sensors, APIs, and programming abstractions. Static analysis is gaining a growing interest, allowing developers to predict properties about the run-time behavior of mobile apps without executing them. Over the years, literally hundreds of static analysis techniques have been proposed, ranging from structural and control-flow analysis to state-based analysis.In this paper, we present a systematic mapping study aimed at identifying, evaluating and classifying characteristics, trends and potential for industrial adoption of existing research in static analysis of mobile apps. Starting from over 12,000 potentially relevant studies, we applied a rigorous selection procedure resulting in 261 primary studies along a time span of 9 years. We analyzed each primary study according to a rigorously-defined classification framework. The results of this study give a solid foundation for assessing existing and future approaches for static analysis of mobile apps, especially in terms of their industrial adoptability.Researchers and practitioners can use the results of this study to (i) identify existing research/technical gaps to target, (ii) understand how approaches developed in academia can be successfully transferred to industry, and (iii) better position their (past and future) approaches for static analysis of mobile apps.

Sparse harmonic transforms II: best s-term approximation guarantees for bounded orthonormal product bases in sublinear-time

In this paper we develop a sublinear-time compressive sensing algorithm for approximating functions of many variables which are compressible in a given Bounded Orthonormal Product Basis (BOPB). The resulting algorithm is shown to both have an associated best s-term recovery guarantee in the given BOPB, and also to work well numerically for solving sparse approximation problems involving functions contained in the span of fairly general sets of as many as \(\sim 10^{230}\) orthonormal basis functions. All code is made publicly available. As part of the proof of the main recovery guarantee new variants of the well known CoSaMP algorithm are proposed which can utilize any sufficiently accurate support identification procedure satisfying a Support Identification Property (SIP) in order to obtain strong sparse approximation guarantees. These new CoSaMP variants are then proven to have both runtime and recovery error behavior which are largely determined by the associated runtime and error behavior of the chosen support identification method. The main theoretical results of the paper are then shown by developing a sublinear-time support identification algorithm for general BOPB sets which is robust to arbitrary additive errors. Using this new support identification method to create a new CoSaMP variant then results in a new robust sublinear-time compressive sensing algorithm for BOPB-compressible functions of many variables.

Guided Exploration

Many monitoring tools that help developers in analyzing the run-time behavior of their applications share a common shortcoming: they require their users to have a fair amount of experience in monitoring applications to understand the used terminology and the available analysis features. Consequently, novice users who lack this knowledge often struggle to use these tools efficiently. In this paper, we introduce the guided exploration (GE) method that aims to make interactive monitoring tools easier to use and learn. In general, tools that implement GE should provide four support operations on each analysis step: they should automatically (1) detect and (2) highlight the most important information on the screen, (3) explain why it is important, and (4) suggest which next steps are appropriate. This way, tools guide users through their analysis processes, helping them to explore the root cause of a problem. At the same time, users learn the capabilities of the tool and how to use them efficiently. We show how GE can be implemented in new monitoring tools as well as how it can be integrated into existing ones. To demonstrate GE's feasibility and usefulness, we present how we extended the memory monitoring tool AntTracks to provided guided exploration support during memory leak analysis and memory churn analysis. We use these guidances in two user scenarios to inspect and improve the memory behavior of the monitored applications. We hope that our contribution will help usability researchers and developers in making monitoring tools more novice-friendly by improving their usability and learnability.