Hardware Dirty Cache Line Tracking via Interconnect Detection
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Current methods for tracking modified application data lack sufficient granularity, often overestimating the amount of dirty data and incurring high logging costs, while existing virtual memory-based approaches like Page Modification Logging (PML) are inefficient and performance-intensive.
Innovation Solution
A method that involves sending a command to a hardware unit to register physical addresses for tracking, requesting and receiving a list of dirty cache lines, and adding them to a buffer, allowing for precise tracking of changes at cache line granularity without altering the application's code or significantly impacting performance.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Measurement precision
If virtual memory-based approaches like Page Modification Logging (PML) are used to track dirty data, then tracking capability is provided, but granularity is insufficient and performance is significantly impacted
Solution Approach 1:
The patent segments the memory tracking granularity from page level to cache line level. By tracking dirty data at the cache line granularity (64 bytes) instead of page granularity (4KB), the system achieves finer measurement precision while reducing the overhead burden, thus improving both tracking accuracy and performance.
Solution Approach 2:
The patent introduces a hardware unit as an intermediary between the application and the operating system to track dirty cache lines. This hardware unit interceptors memory access requests and maintains a dirty cache line list, enabling precise tracking without requiring application code modification and minimizing performance impact through hardware-level optimization.
2Loss of information
If logging of all modified data is performed, then complete tracking information is obtained, but logging costs increase significantly
Solution Approach 1:
The patent extracts only the dirty cache lines from the entire memory space for logging. By identifying and isolating only the modified cache lines (rather than logging all modified data within a page), the system achieves complete tracking information for modified data while significantly reducing logging volume and associated costs.
Solution Approach 2:
The patent changes the tracking parameter from page-level granularity to cache line-level granularity. This parameter change enables the system to identify and log only the specific cache lines that have been modified, rather than logging entire pages, thus maintaining tracking accuracy while reducing logging overhead.
3Measurement precision
If application code is modified to enable precise tracking, then tracking accuracy improves, but code integrity is altered
Solution Approach 1:
The patent introduces a hardware unit as an intermediary that automatically tracks dirty cache lines without requiring any modification to the application code. The hardware unit intercepts memory access requests and maintains the dirty cache line list in the background, enabling precise tracking while preserving complete code integrity.
Solution Approach 2:
The hardware unit performs self-service by automatically tracking and maintaining the dirty cache line list without requiring application code modification or manual intervention. The system tracks dirty data through hardware-level mechanisms that operate independently of the application, ensuring both precision and code integrity.
Data Source
AI summary
Described herein is a method for tracking changes to memory locations made by an application. In one embodiment, the application decides to start tracking and sends a list of virtual memory pages to be tracked to an operating system via an interface. The operating system converts the list of virtual memory pages to a list of physical addresses and sends the list of physical addresses to a hardware unit which performs the tracking by detecting write backs on a coherence interconnect coupled to the hardware unit. After the application ends tracking, the application requests a list of dirty cache lines. In response to the request, the operating system obtains the list of dirty cache lines from the hardware unit and adds the list to a buffer that the application can read. In other embodiments, the operating system can perform the tracking without the application making the request.