This study contributes to a deeper understanding of energy consumption in software applications, emphasizing the critical need for energy efficiency. We focus on integrating performance counter events and system call data to build energy predictive models using advanced machine learning techniques, including linear regression, multi-layer perceptrons, and random forests. These models are carefully calibrated against empirical energy measurements obtained through the Perf framework. Our study addresses variability in model outcomes that stem from differences in feature selection and the inherent discrepancies of operating systems. Through various experimentation, we demonstrate that our models robustly predict energy consumption across diverse scenarios, with particularly promising results in unseen datasets. However, challenges persist in cross-application efficacy. Event-based models particularly stand out, offering reliable energy estimations in novel applications. This research validates the effectiveness of our methodologies and also illuminates the complex landscape of precise energy consumption modeling in contemporary software 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.

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.