GPU Task Scheduling via Build Graph Segmentation
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
The increasing complexity of computer programs leads to inefficient resource utilization in software tests, particularly with workstation devices equipped with CPUs and GPUs, resulting in delays, inefficiencies, and complications due to inappropriate allocation of resources.
Innovation Solution
The techniques involve determining workstation devices and resource parameters for software tests by creating a build graph, scheduling tasks based on memory constraints, and utilizing scheduling queues to allocate tasks to appropriate GPUs, allowing for efficient compilation and testing of software code by matching tasks with the most suitable computing resources.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Power
If workstation devices with CPUs and GPUs are allocated for software tests, then computing power and processing capability are improved, but resource utilization efficiency deteriorates due to inappropriate allocation
Solution Approach 1:
The patent segments the computing resource pool into distinct CPU-based workstations and GPU-based workstations. The build graph is also segmented into CPU tasks and GPU tasks based on resource requirements. This segmentation enables precise matching of tasks to appropriate workstation types, preventing GPU workstations from being wasted on CPU-only tasks and vice versa, thereby improving overall resource utilization efficiency while maintaining high computing power.
2Ease of operation
If resources are allocated without considering task requirements, then allocation simplicity is improved, but test execution time increases due to delays and complications
Solution Approach 1:
The patent performs preliminary analysis of task resource requirements by creating a build graph that identifies whether each task requires CPU or GPU resources. This preliminary classification is done before task execution, allowing the system to pre-assign tasks to appropriate workstation queues. This advance preparation eliminates runtime allocation delays and complications, reducing test execution time while maintaining simple automated allocation processes.
3Power
If GPU resources are used for all tasks, then computing capability is improved, but energy consumption increases due to redundant compute cycles
Solution Approach 1:
The patent applies local quality by matching the computing resource type to the specific task requirements. CPU-bound tasks are executed on CPU workstations while GPU-bound tasks are executed on GPU workstations. This localized matching ensures that GPU resources are only consumed when actually needed for parallel computing tasks, eliminating redundant energy consumption from using GPUs for simple sequential tasks, while maintaining high computing capability where required.
4Adaptability or versatility
If inappropriate resources are allocated to tasks, then resource flexibility is improved, but task execution reliability deteriorates due to task corruption
Solution Approach 1:
The patent implements feedback by continuously monitoring task execution status and resource availability. The build graph analysis provides feedback on task requirements, and the scheduling system adjusts task assignments based on this feedback. This closed-loop control ensures tasks are consistently allocated to appropriate resource types, preventing task corruption from mismatched resources while maintaining flexible adaptation to changing workloads and resource availability.
Data Source
AI summary
Techniques for determining workstation devices and resource parameters for software tests are discussed herein. The workstation devices may include graphic processing units (GPUs) on which portions of the software tests are performed. The workstation devices and GPUs in the workstation devices may be allocated and designated for building and testing software programs. A task to be performed on a GPU cluster of a plurality of GPU clusters may be determined. The task may be added to a scheduling queue associated with the plurality of GPU clusters. The task may be assigned to an individual GPU, based at least in part on a memory constraint associated with the task. The task may be performed with the individual GPU of the GPU cluster to determine a result. The result may be returned to a computing device.