Intelligent Build Queue Merging for Source Control

Resolve Bottlenecks,
Find Innovative SolutionsGenerate Solutions

Solution Overview

Problem

In large projects, the build queue mechanism often leads to significant delays as multiple build requests wait for the completion of earlier requests, resulting in inefficient processing and potential errors due to the sequential nature of build processing.

Innovation Solution

The system intelligently and automatically merges build requests based on risk factors, creating request sets that are prioritized in the build queue, allowing for simultaneous processing of low-risk changes while ensuring that high-risk changes are processed individually or divided recursively to identify root causes of failures.

Engineering Contradictions & Design Principles

VSEngineering Contradiction Analysis

1Reliability

If multiple build requests are processed sequentially in the build queue, then each build request is verified individually ensuring build quality, but the processing time and queue delays increase significantly

Engineering Contradiction:

Improvebuild verification qualityVSAvoidbuild queue delay

Core Design Contradiction:

ReliabilityVSLoss of time

Solution Approach 1:

The patent merges multiple build requests into a single combined build request when they are determined to be compatible (non-conflicting changes). This allows multiple changes to be processed simultaneously in one build operation rather than sequentially, reducing queue delays while maintaining verification quality through the merging process that checks for conflicts between changes.

Inventive Principle:

Principle #5Merging (Combining)

2Productivity

If build requests are merged and processed together, then processing efficiency and throughput increase, but the complexity of detecting and measuring conflicts between changes increases

Engineering Contradiction:

Improvebuild processing throughputVSAvoidconflict detection complexity

Core Design Contradiction:

ProductivityVSDifficulty of detecting and measuring

Solution Approach 1:

The system implements feedback mechanisms where the results of build attempts are used to inform future merging decisions. When builds fail or conflicts are detected, this information feeds back into the merging logic to adjust which requests are combined, thereby managing conflict detection complexity while maintaining high processing throughput through learned optimization.

Inventive Principle:

Principle #23Feedback

Solution Approach 2:

The patent replaces manual or simple mechanical queue processing with an intelligent system that uses automated conflict detection algorithms and risk factor analysis. This substitution of mechanical FIFO processing with smart automated systems reduces the apparent complexity by handling conflict detection through programmed logic rather than manual intervention.

Inventive Principle:

Principle #28Mechanics substitution (Replace mechanical system)

3Reliability

If high-risk changes are processed individually while low-risk changes are merged, then build reliability is maintained, but the device complexity and automation requirements increase

Engineering Contradiction:

Improvebuild success rateVSAvoidqueue management system complexity

Core Design Contradiction:

ReliabilityVSDevice complexity

Solution Approach 1:

The system applies different processing qualities to different build requests based on their risk characteristics. Low-risk changes are merged and processed together with simplified verification, while high-risk changes are processed individually with more rigorous checking. This local differentiation of processing quality maintains overall reliability while managing system complexity through targeted rather than universal complexity.

Inventive Principle:

Principle #3Local quality

Data Source

PatentUS11500626B2Intelligent automatic merging of source control queue items

Publication Date: 2022.11.15 MICROSOFT TECHNOLOGY LICENSING LLC

AI summary

Methods for intelligent automatic merging of source control queue items are performed by systems and apparatuses. Project changes are submitted in build requests to a gated check-in build queue requiring successful builds to commit changes to a code repository according to source control. Multiple pending build requests in the build queue are intelligently and automatically merged into a single, pending merged request based on risk factor values associated with the build requests. For merged requests successfully built, files in the build requests are committed and the build requests are removed from the queue. Merged requests unsuccessfully built are divided into equal subsets based on updated risk factor values using information from the unsuccessful build. Successful builds of subsets allow for committing of files and removal from the build queue, while unsuccessful builds are further divided and processed until single build requests are processed to identify root cause errors.