Thread Pool Allocation via Queue Depth Monitoring

Resolve Bottlenecks,
Find Innovative SolutionsGenerate Solutions

Solution Overview

Problem

Computing devices face inefficiencies in processing requests due to limited resources, leading to delays when resources are not allocated efficiently, especially during increased demand.

Innovation Solution

Modular event-driven processing divides computational functionality into thread boundaries, allowing dynamic allocation of resources based on queue depth, with a resource allocation module monitoring and adjusting resource distribution to optimize performance.

Engineering Contradictions & Design Principles

VSEngineering Contradiction Analysis

1Productivity

If resources are statically allocated to requests, then resource management is simple, but system performance degrades under increased demand

Engineering Contradiction:

Improverequest processing efficiencyVSAvoidresource allocation complexity

Core Design Contradiction:

ProductivityVSDevice complexity

Solution Approach 1:

The system implements dynamic resource allocation where the resource allocation module continuously monitors queue depths and adjusts thread assignments in real-time based on current load conditions, transforming static resource allocation into a dynamic adaptive system that responds to changing demand

Inventive Principle:

Principle #15Dynamics

Solution Approach 2:

The resource allocation module uses feedback from queue depth monitoring to make informed decisions about thread allocation, creating a closed-loop control system that continuously optimizes resource distribution based on system state

Inventive Principle:

Principle #23Feedback

2Productivity

If more resources are allocated to handle increased requests, then processing capacity increases, but resource waste occurs during low demand

Engineering Contradiction:

Improverequest processing capacityVSAvoidresource utilization efficiency

Core Design Contradiction:

ProductivityVSLoss of energy

Solution Approach 1:

Thread pool size and allocation are dynamically adjusted based on real-time queue depth monitoring, allowing the system to scale resource usage up during high demand and down during low demand, optimizing the balance between capacity and efficiency

Inventive Principle:

Principle #15Dynamics

Solution Approach 2:

The system changes operational parameters (thread allocation counts, pool sizes) based on queue depth thresholds, transitioning between different resource allocation states to match demand levels

Inventive Principle:

Principle #35Parameter changes

3Loss of time

If resources are not efficiently allocated, then system simplicity is maintained, but request processing delays increase

Engineering Contradiction:

Improverequest processing delayVSAvoidresource management complexity

Core Design Contradiction:

Loss of timeVSDevice complexity

Solution Approach 1:

The system segments resource management into distinct functional modules (resource allocation module, queue monitoring, thread pool management) that can operate independently but coordinate together, reducing overall system complexity while enabling efficient resource allocation

Inventive Principle:

Principle #1Segmentation

Solution Approach 2:

The resource allocation module acts as an intermediary between the thread pool and request queues, managing resource distribution and preventing direct coupling between components, which simplifies resource management while reducing processing delays

Inventive Principle:

Principle #24Intermediary (Mediator)

Data Source

PatentUS8397237B2Dynamically allocating threads from a thread pool to thread boundaries configured to perform a service for an event

Publication Date: 2013.03.12 INTELLECTUAL VENTURES I LLC

AI summary

Each of a plurality of thread boundaries comprises functionality to be performed for a given event by a single thread. A plurality of queues through which events may be routed may be coupled to the thread boundaries. A plurality of tasks may be configured in a defined relationship, each task being associated with a thread boundary and comprising a unit of code for performing a specific function. Resources may be allocated to thread boundaries based on queue depth.