Parallel Filesystem Traversal Using LIFO Job Queue
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Mirroring operations across networks are slow due to idle time while waiting for command results during filesystem traversal, as commands need to be packed, transmitted, and processed, leading to inefficiencies in file system copying processes.
Innovation Solution
Implementing a system with a pool of job executors (threads) and a job queue that uses Last In First Out (LIFO) ordering for parallel file system traversal, allowing multiple job executors to process filesystem nodes simultaneously, with a trigger tracker to manage child nodes and optional barriers for controlled processing.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Speed
If a single job executor is used for filesystem traversal, then the system complexity is low, but the processing speed is slow due to idle time waiting for network command results
Solution Approach 1:
The patent divides the filesystem traversal task into multiple independent sub-tasks that can be executed in parallel. Each job executor handles a portion of the filesystem nodes, allowing simultaneous processing of different directory trees or file sets. This segmentation enables the system to overcome network latency by keeping multiple executors busy with different tasks rather than having a single executor idle waiting for responses.
Solution Approach 2:
The patent transitions from sequential single-threaded traversal to parallel multi-threaded traversal by adding the dimension of concurrency. Multiple job executors operate simultaneously on different portions of the filesystem, effectively utilizing multiple CPU cores and network connections. This dimensional change from 1D sequential processing to 2D parallel processing dramatically increases throughput while the job queue manages the complexity.
2Productivity
If multiple job executors are used for parallel processing, then the processing speed increases, but the system complexity increases due to job queue management and synchronization
Solution Approach 1:
The job queue serves multiple functions: it acts as a task distributor, a synchronization barrier, and a buffer between producers and consumers. This universal component manages the complexity of coordinating multiple job executors while enabling them to work independently. The same job queue structure handles task assignment, progress tracking, and completion signaling, reducing the need for separate management mechanisms.
Solution Approach 2:
Each job executor is self-sufficient, independently pulling tasks from the job queue, executing them, and reporting completion without requiring direct coordination with other executors. This self-service approach minimizes inter-executor communication and synchronization overhead. The executors autonomously manage their own task queues and processing states, reducing the overall system complexity while maintaining high productivity.
3Speed
If parallel processing is implemented without barriers, then the processing speed is fast, but the control over processing order and debugging capability is reduced
Solution Approach 1:
The job queue acts as an intermediary that mediates between the need for parallel execution and the need for controlled processing. Barriers implemented as special job queue entries allow the system to insert synchronization points without disrupting the overall parallel flow. These intermediary barrier objects enable debugging and controlled processing by pausing parallel execution at specific points while maintaining the speed benefits of parallelism elsewhere in the system.
Data Source
AI summary
A system and method for parallel file system traversal using multiple job executors is disclosed. The system includes a pool of job executors, a job queue, and a trigger tracker. An object, representative of a node in the filesystem, is added (i.e., pushed) to the job queue for processing by an job executor. The job queue assigns (i.e., pops) objects to job executors in accordance to a LIFO (Last In First Out) ordering. Then the job executor performs an action such as copy. In one embodiment, the trigger tracker follows the processing of a child nodes to a particular child node. Thus, the filesystem is being traversed by several job executors at the same time.


