Thread Management Computing Device for Task Queue Assignment
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing thread management technologies lead to idle threads in one group while creating new threads in other groups to execute tasks, resulting in inefficient resource utilization due to unsupervised thread creation without visibility into available idle threads.
Innovation Solution
A method where a thread management computing device assigns tasks to a current task queue based on matching categories and determines availability of idle threads within thread groups using utilization parameters, creating new threads only when existing idle threads are unavailable, and reallocates threads between groups to optimize task execution.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Productivity
If new threads are created to execute tasks without supervision, then task execution capability is improved, but resource utilization deteriorates due to idle threads in other groups
Solution Approach 1:
The thread management computing device implements a feedback mechanism by continuously monitoring the availability of idle threads across all thread groups. When a new task arrives, the system checks for idle threads in the same or other thread groups before creating new threads, ensuring that thread creation decisions are based on real-time system state information.
Solution Approach 2:
The system enables self-service by allowing thread groups to autonomously manage their own thread pools based on their specific task requirements. Each thread group can request threads from the central pool or create threads independently when idle threads are unavailable, allowing decentralized decision-making while maintaining overall system efficiency.
2Speed
If idle threads are not reused across thread groups, then task execution speed is improved through immediate thread availability, but device complexity increases due to unsupervised thread creation
Solution Approach 1:
The patent implements universality by creating a shared pool of idle threads that can be allocated to any thread group that needs them. The thread management computing device maintains a global view of idle thread availability across all thread groups, allowing idle threads from one group to be reused by another group, making the thread pool universally applicable rather than group-specific.
Solution Approach 2:
The thread management computing device acts as an intermediary between thread groups and the central thread pool. It receives thread creation requests from thread groups, checks for available idle threads in the pool, and either allocates existing idle threads or creates new threads as needed. This intermediary role simplifies thread management by centralizing the decision-making process while maintaining fast execution through pre-existing idle threads.
3Ease of operation
If threads are allocated without visibility into idle threads, then ease of operation is improved for individual applications, but productivity deteriorates due to unnecessary thread creation
Solution Approach 1:
The system segments thread management into independent thread groups, each associated with specific task queues and maintaining its own thread pool. This segmentation allows individual applications or task types to operate independently with their own thread resources, while the thread management computing device provides coordinated oversight to prevent unnecessary thread creation by checking global idle thread availability.
Data Source
AI summary
This technology relates to assigning a task to a current task queue based on one or more matching category when the new task is received within an application for execution. Availability of one or more existing idle threads within one or more thread groups required for the execution of the received task determined based on one or more utilization parameters, where each of the thread groups is associated with one or more task queues and where the current task queue is one of the task queues. One or more new threads are created to allocate for execution of the task when the existing idle threads are determined to be unavailable in the thread groups within the application. Next, the created new threads are allocated to the task when the existing idle threads are determined to be unavailable. The task is executed using the allocated new threads.