Redundancy Analysis and Elimination on Access Patterns of the Windows Applications Based on I/O Log Data

Jun-Ha Lee, Hyuk-Yoon KwonIEEE Access 2020 · DOI · OpenReview

Introduction

The Windows Registry serves as a critical central database for operating system and application configurations. However, modern Windows applications are often "chatty," performing excessive and redundant I/O operations against this database. This paper investigates these inefficiencies, proposing a two-level redundancy detection and elimination framework that leverages an event-driven cache to maintain data consistency while significantly boosting performance.

The Problem of Registry Redundancy

Registry access is a frequent source of system bottlenecks. Developers often implement code that retrieves the same registry key or value multiple times within a short window, leading to wasted CPU cycles and increased latency. While general file system I/O has been studied extensively, the specific nuances of registry access patterns—and how to safely optimize them without serving stale data—have remained largely unexplored.

Methodology

The researchers developed a systematic approach to prune the registry access tree through a two-level elimination process.

Redundancy Classification

Inefficiencies are categorized into two primary types:

  1. Internal Redundancy: Repeated read/write operations occurring within a single open-close handle session (e.g., calling RegQueryValue multiple times for the same key before closing it).
  2. Outer Redundancy: Repeatedly opening and closing the same registry key session to perform the same task.

Elimination and Consistency

The framework first simplifies access patterns by removing internal redundancies, which then facilitates the identification of outer redundancies. To ensure the optimized application behaves identically to the original, an event-driven consistency mechanism is used. By employing the RegNotifyChangeKeyValue API, the system only invalidates its local cache when an actual registry update occurs.

Figure 6: Comparison of original vs. optimized registry access patterns showing the reduction of redundant loops.

Data Collection and Analysis

To validate the framework, the authors analyzed a massive dataset of 15 million I/O events captured via Process Monitor across Windows 7, 8.1, and 10. The study focused on 10 common applications, including Chrome, Notepad, and Windows Explorer.

Figure 3: Process Monitor log illustrating the repetitive nature of registry operations like RegOpenKey and RegQueryValue.

The analysis revealed that registry operations account for a staggering 76.43% of all I/O occurrences. Crucially, approximately 59% of internal operations and 57% of outer operations were found to be redundant.

Key Results

The proposed elimination method yielded substantial performance improvements:

  • Pattern Speedup: Individual redundant access patterns saw performance gains of up to 90.25%.
  • System-Wide Impact: In concurrent workloads, overall system performance improved by 8.93% to 26.21%.
  • Low Overhead: The safety mechanism for data consistency added less than 2% overhead, even in environments with frequent registry updates.

Conclusion

This research demonstrates that significant performance gains can be achieved by optimizing how Windows applications interact with the registry. Future work will focus on automating the binary-to-binary optimization pipeline and exploring safe ways to handle redundant write operations.

Summary updated

Abstract

In this paper, we analyze I/O log data monitored in the Windows operating system for improving the system performance. Especially, we focus on the I/O operations to the Windows registry. As a result, we identify redundant access patterns of the Windows applications. To find all the possible redundant patterns from the large-scale log data, we propose the redundancy detection algorithm. Then, we propose the two-level redundancy elimination method to remove unnecessary redundant operations. We also present an event-driven method that guarantees that the result of redundancy elimination is equivalent to that of the original program. Through experiments, we show that the proposed redundancy elimination method improves the performance of the original program having redundant access patterns by up to 90.25% for individual access patterns; by 8.93% ~ 26.21% when the multiple programs having combined access patterns are running concurrently.
BibTeX
@article{lee2020redundancy,
  author = {Jun-Ha Lee and Hyuk-Yoon Kwon},
  title = {{Redundancy Analysis and Elimination on Access Patterns of the Windows Applications Based on I/O Log Data}},
  journal = {IEEE Access},
  year = {2020},
  doi = {10.1109/access.2020.2964260},
}
Figure