Recovery Consumer Framework for Storage System Failure
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
In storage systems, the inefficiency in recovery processes due to unknown dependencies among storage containers leads to varying recovery times, causing some containers to be unavailable for data access requests for extended periods after a failure event.
Innovation Solution
A recovery consumer framework that allows concurrent execution of recovery actions by coordinating recovery consumers based on dependencies, using recovery logs and a tagging technique to serialize or parallelize recovery processes, ensuring that dependent actions are executed serially while independent actions can be performed in parallel.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If recovery actions are performed serially across all storage containers, then dependency issues are avoided, but recovery time is substantially increased
Solution Approach 1:
The patent segments the recovery process by dividing storage containers into groups based on their recovery dependencies. Containers with no dependencies can be recovered independently and in parallel, while containers with dependencies are grouped accordingly. This segmentation allows the system to avoid serial recovery of all containers while ensuring that dependency constraints are respected, thereby reducing overall recovery time without compromising recovery correctness.
Solution Approach 2:
The patent implements a dynamic recovery execution mechanism that adapts the recovery order based on dependency relationships. The system dynamically determines which containers can be recovered in parallel at each stage, rather than following a fixed serial order. This dynamic approach allows independent containers to be recovered simultaneously while maintaining proper sequencing for dependent containers, resolving the contradiction between speed and correctness.
2Loss of time
If recovery actions are performed in parallel across all storage containers, then recovery time is reduced, but dependency violations may occur
Solution Approach 1:
The patent segments storage containers into dependency-based groups, allowing parallel recovery within independent groups while maintaining serial execution for dependent groups. This segmentation enables the system to maximize parallelization opportunities without violating dependency constraints, thus reducing recovery time while ensuring correctness.
Solution Approach 2:
The system uses dependency information as feedback to dynamically control the parallelization of recovery actions. By analyzing dependency relationships, the system determines which containers can safely be recovered in parallel and which must be recovered sequentially. This feedback mechanism ensures that parallel execution does not lead to dependency violations while still achieving time reduction.
3Reliability
If recovery information is applied to all storage containers regardless of individual needs, then comprehensive recovery is ensured, but recovery efficiency is reduced
Solution Approach 1:
The patent applies local quality by tailoring the recovery process to the specific needs of each storage container based on its dependency relationships. Instead of applying the same recovery approach uniformly to all containers, the system adjusts the recovery strategy for each container according to its individual dependency profile. This allows independent containers to be recovered quickly in parallel while ensuring dependent containers receive appropriate sequential recovery treatment, thereby improving overall efficiency without compromising completeness.
Data Source
AI summary
A recovery consumer framework provides for execution of recovery actions by one or more recovery consumers to enable efficient recovery of information (e.g., data and metadata) in a storage system after a failure event (e.g., a power failure). The recovery consumer framework permits concurrent execution of recovery actions so as to reduce recovery time (i.e., duration) for the storage system. The recovery consumer framework may coordinate (e.g., notify) the recovery consumers to serialize execution of the recovery actions by those recovery consumers having a dependency while allowing concurrent execution between recovery consumers having no dependency relationship. Each recovery consumer may register with the framework to associate a dependency on one or more of the other recovery consumers. The dependency association may be represented as a directed graph where each vertex of the graph represents a recovery consumer and each directed edge of the graph represents a dependency. The framework may traverse (i.e., walk) the framework graph and for each vertex encountered, notify the associated recovery consumer to initiate its respective recovery actions.