International audience

The efficient management of software logs is crucial in software performance evaluation, enabling detailed examination of runtime information for postmortem analysis. Recognizing the importance of logs and the challenges developers face in making informed log-placement decisions, there is a clear need for a robust log-placement framework that supports developers. Existing frameworks, however, are limited by their inability to adapt to customized logging objectives, a concern highlighted by our industrial partner, Ciena, who required a system for their specific logging goals in resource-limited environments like routers. Moreover, these frameworks often show poor cross-project consistency. This study introduces a novel performance logging objective designed to uncover potential performance-bugs, categorized into three classes-Loops, Synchronization, and API Misuses-and defines 12 source code features for their detection. We present an Adaptive Logging System (ALS), based on reinforcement learning, which adjusts to specified logging objectives, particularly for identifying performance-bugs. This framework, not restricted to specific projects, demonstrates stable cross-project performance. We trained and evaluated ALS on Python source code from 17 diverse open-source projects within the Apache and Django ecosystems. Our findings suggest that ALS has the potential to significantly enhance current logging practices by providing a more targeted, efficient, and context-aware logging approach, particularly beneficial for our industry partner who requires a flexible system that adapts to varied performance objectives and logging needs in their unique operational environments.

Resource-constrained devices face significant performance challenges when encountering memory pressure situations due to limited hardware resources. Existing approaches mainly focus on reactive and instantaneous approaches, but they often fail to accurately identify the root cause of memory pressure, resulting in delayed and ineffective response strategies. In this paper, we address this limitation by proposing an alternative data-driven approach to proactively detect memory pressure and identify the responsible process in resource-limited devices. Our method enables the activation and deactivation of extended process-level profiling based on the predicted memory pressure, facilitating the identification of the root cause process. Through evaluation, we achieved an 85% accuracy in forecasting memory pressure situations and correctly identified the responsible process in 83% of use-cases. These results demonstrate the effectiveness of our strategy to stream large amount of trace data in mitigating memory pressure issues in resource-constrained systems. This approach has the potential to enhance system performance and improve overall system architecture in such devices.

The dynamic nature of applications in Virtual Machines (VMs) and the increasing demand for virtualized systems make the analysis of dynamic environments critical to achieve efficient operation of such complex distributed systems. In this article, we propose a precise host-based tracing and analysis method to retrieve execution flows, and dependency flows from virtualized environments, regardless of the level of nested virtualization. Given a host operating system level trace, the Any-Level vCPU Detection (ASD) algorithm and Guest Thread-state Analysis (GTA) algorithm detect the different states of vCPUs and threads for arbitrary nesting depths. Then, the Execution-graph Construction (HEC) algorithm extracts the waiting / wake-up dependencies chains out of the running processes across VMs, for any level of virtualization in a transparent manner. The process dependency graph, vCPU state, and VM process state are displayed in an interactive trace viewer, Trace Compass, for further inspection. Our proposed VM trace analysis algorithms have been open-sourced for further enhancements and collaborative research and development. Our new techniques were evaluated with workloads generated using several well-known server applications (e.g., Hadoop, Apache, MySQL, Linux apt-get, and IMS network). The proposed approaches are based on host hypervisor tracing, which brings a lower tracing overhead (around 1 percent), is easier to deploy, and presents fewer security issues as compared to other approaches.

Memory leaks are of serious concern in software programs written in languages that do not have a dedicated garbage collector. Memory leaks are the result of prolonged unnecessary usage of the system memory resources. This increases the workload, paging, and lowers the response rate leading to performance degradation of the system or software. Such leaks are difficult to detect due to a software’s development testing span and different working environments.This research paper proposes an algorithm to detect memory leaks based on the growth analysis of the memory blocks. The proposed method captures the allocation made in memory blocks via malloc, calloc, and realloc and stores the captured results onto the files. The files are then analyzed using the leak threshold determined by the developer or tester. Unlike other approaches such as ASAN/LSAN which require multiple snapshots to analyze the leaks, the proposed method works without a snapshot for the summary analysis algorithm and only requires one snapshot, collected at the end of the execution. This approach does not need to be integrated within the application to analyze the software and detect memory leaks. Our method provides more accurate results by visualizing the captured and analyzed data for the developers, making it more convenient to detect the root cause of the leakage.

Kernel traces are sequences of low-level events comprising a name and multiple arguments, including a timestamp, a process id, and a return value, depending on the event. Their analysis helps uncover intrusions, identify bugs, and find latency causes. However, their effectiveness is hindered by omitting the event arguments. To remedy this limitation, we introduce a general approach to learning a representation of the event names along with their arguments using both embedding and encoding. The proposed method is readily applicable to most neural networks and is task-agnostic. The benefit is quantified by conducting an ablation study on three groups of arguments: call-related, process-related, and time-related. Experiments were conducted on a novel web request dataset and validated on a second dataset collected on pre-production servers by Ciena, our partnering company. By leveraging additional information, we were able to increase the performance of two widely-used neural networks, an LSTM and a Transformer, by up to 11.3% on two unsupervised language modelling tasks. Such tasks may be used to detect anomalies, pre-train neural networks to improve their performance, and extract a contextual representation of the events.