Autonomous Server Task Allocation via Shared Pool
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Current computer network systems face inefficiencies in task allocation, particularly with indeterminate computing tasks and heterogeneous resources, leading to potential bottlenecks and poor load balancing, as they require central monitoring and communication overhead, which can result in idle or overwhelmed servers and reduced overall efficiency.
Innovation Solution
A system where server computers request processing tasks from processor computers with an associated expiration time, allowing for dynamic task allocation and reallocation based on priority and availability, ensuring that tasks are completed within the given time frame and optimizing resource utilization by leveraging idle processors in image-storage computers for image-processing tasks.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Productivity
If a central task allocator is used to distribute computing tasks among servers, then task allocation can be monitored and dispatched to keep workers busy, but the system requires central monitoring and communication overhead that can create bottlenecks and reduce overall efficiency
Solution Approach 1:
Each server computer autonomously selects and executes computing tasks from the task pool without requiring central allocation or monitoring. Servers independently evaluate their own workload and capability, then self-assign tasks from the shared pool, eliminating the need for centralized task management infrastructure and reducing communication overhead.
Solution Approach 2:
The patent extracts the central task allocator component from the system architecture entirely. Instead of having a dedicated central monitoring system, the task pool is made directly accessible to all servers, which independently interact with it. This removal of the intermediary allocator eliminates the communication bottlenecks and complexity associated with centralized control.
2Productivity
If tasks are allocated to servers with the smallest current load, then load balancing can be achieved, but this approach does not account for indeterminate task durations and unpredictable resource requirements
Solution Approach 1:
The patent changes the selection parameters from static load metrics to dynamic capability-based evaluation. Servers are evaluated based on their specific computing capabilities, available resources, and task-type expertise rather than simple current load counts. This allows the system to account for indeterminate task requirements by matching tasks to servers based on capability fit rather than instantaneous load state.
Solution Approach 2:
The task pool and server capabilities are dynamically evaluated at the time of task selection rather than using static pre-allocation. Servers continuously update their available capacity and capability profiles, and the task pool reflects real-time task requirements. This dynamic approach allows the system to adapt to unpredictable task durations and resource needs by making allocation decisions based on current system state.
3Productivity
If servers maintain a queue of tasks to keep busy, then worker utilization can be improved, but idle time occurs when workers complete tasks and await further work
Solution Approach 1:
The shared task pool ensures continuous availability of new tasks for servers. As servers complete tasks, new tasks are immediately available in the pool for selection, eliminating idle waiting time. The system maintains continuous useful action by ensuring the task pool is continuously replenished and accessible, allowing servers to transition smoothly from one task to the next without interruption or idle time.
Data Source
AI summary
Server computers send requests over a network for an allocation of server tasks and processing tasks, the processing task requests having an associated expiration time. The plurality of server computers process received server tasks provided to the server computers in response to the requests, and process processing tasks within the expiration time in response to the requests for processing tasks. The server computers perform the allocated processing tasks only if there are no pending server tasks.