Worker Thread Decouples Backup History From Session Threads
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
The existing backup systems face performance bottlenecks due to the lockstep operation of backup threads waiting for client responses to acknowledge backup history, leading to idle time and delays, especially when multiple threads are operating in parallel, which affects the efficiency of backup operations.
Innovation Solution
A dedicated software thread, referred to as the worker thread, is introduced to handle the communication of backup history with clients, allowing session threads to continue backing up data without waiting for client responses, thereby improving efficiency and enabling multiple session threads to operate in parallel without requiring locks.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If backup threads operate in lockstep waiting for client responses, then data integrity is ensured, but backup speed and throughput deteriorate due to idle waiting time
Solution Approach 1:
The backup system segments the backup thread into two independent components: a session thread that performs data backup operations and a worker thread that handles backup history communication. This segmentation allows the session thread to continue backing up data without waiting for client responses, while the worker thread independently manages history transmission, thereby resolving the contradiction between data integrity and backup speed.
Solution Approach 2:
The worker thread acts as an intermediary between the session thread and the client. It receives backup history from the session thread and transmits it to the client, decoupling the data backup process from the history communication process. This intermediary mechanism ensures that the session thread is not blocked by client response delays, improving backup throughput while maintaining reliability through coordinated thread operation.
2Productivity
If multiple backup threads operate in parallel, then backup throughput is improved, but system complexity increases due to lock management requirements
Solution Approach 1:
By segmenting the backup thread into session threads and a dedicated worker thread, the system enables multiple session threads to operate in parallel without requiring complex lock management. Each session thread independently backs up data while the single worker thread handles all history communication, eliminating the need for locks between parallel backup operations and reducing system complexity.
3Reliability
If backup threads wait for client acknowledgments, then communication reliability is maintained, but time efficiency deteriorates due to waiting delays
Solution Approach 1:
The session thread performs the preliminary action of generating backup history and passing it to the worker thread before waiting for client acknowledgments. This preliminary action allows the data backup process to advance without delay, while the worker thread subsequently handles the time-consuming communication task of transmitting history to the client and receiving acknowledgments, thereby reducing overall waiting time while maintaining communication reliability.
Data Source
AI summary
A technique provides a dedicated software thread for communicating backup history to clients of a storage system during backup operations. Illustratively, an operating system of the storage system may execute one or more “session” (e.g., backup) threads and a “worker” (e.g., backup history) thread. In particular, the one or more session threads are each configured to backup stored data for a corresponding client to a backup storage device and to generate backup history of data backed up to the backup storage device. Also, the worker thread is configured to obtain the backup history from the one or more session threads, and transmit the backup history to the corresponding client of each of the one or more session threads. In this manner, the worker thread may wait for a response from the corresponding clients, while the one or more corresponding session threads continue to backup the stored data and generate backup history.