Database Workload Replay with Redundant-Edge-Free Dependency Graphs
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing database replay systems face inefficiencies in generating dependency graphs due to redundant edges, which require significant time and computing resources, limiting concurrency and performance in database workload testing.
Innovation Solution
The proposed solution involves generating dependency graphs using a stateful single forward scan (SSFS) algorithm that removes redundant edges by analyzing state information during a single forward scan, and optionally a parallel version that hierarchically merges local graphs, reducing redundant edges and improving performance.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If a backward scan algorithm is used to generate dependency graphs, then output determinism is ensured, but significant time and computing resources are consumed
Solution Approach 1:
The patent inverts the traditional backward scan approach by using a forward scan algorithm that processes requests in chronological order. This forward scan method builds the dependency graph by examining future requests and determining dependencies as it progresses, eliminating the need for time-consuming backward scans while ensuring output determinism through proper dependency tracking.
Solution Approach 2:
The patent performs preliminary actions by pre-computing the set of all requests and organizing them in chronological order before generating the dependency graph. This preparation allows the forward scan algorithm to efficiently determine dependencies without needing to perform extensive backward scans, reducing overall computation time while maintaining determinism.
2Reliability
If redundant edges are not removed from dependency graphs, then all dependencies are captured, but computing resources and time are significantly increased
Solution Approach 1:
The patent extracts and removes redundant edges from the dependency graph by identifying edges that can be inferred through transitive relationships. The forward scan algorithm specifically targets and eliminates redundant edges while preserving essential dependencies, thereby reducing the graph size and computation requirements without compromising the completeness of captured dependencies.
Solution Approach 2:
The patent changes the parameter of edge redundancy by transforming the dependency graph from a dense representation with many redundant edges to a sparse representation with only essential edges. This parameter change is achieved through the forward scan algorithm that selectively includes only necessary edges, improving generation efficiency while maintaining dependency completeness.
3Reliability
If sequential replay of requests is used, then output determinism is maintained, but concurrency is severely limited
Solution Approach 1:
The patent introduces dynamics by enabling parallel replay of requests while maintaining output determinism. The optimized dependency graph with removed redundant edges allows multiple requests to be executed concurrently without violating dependencies, transforming the static sequential replay model into a dynamic parallel execution model that preserves determinism through careful dependency management.
Data Source
AI summary
Techniques and solutions are provided for providing improved replay of a database workload. In particular, the present disclosure provides techniques for generating dependency graphs that have a reduced number of redundant edges. In particular, the dependency graphs can be generated using a technique that removes subpaths of a larger path of requests for database operations that access a common database object. Another technique removes subpaths of a larger path the incudes additional requests in multiple sessions, even if some requests access different database objects. Particular implementations process a set of requests to generate state information, where the state information can be used in generating a dependency graph that excludes one more types of redundant edges. Additional efficiency is provided in that graphs can be generated using a single scan of a given request.