Parallel Software Build Orchestration for Multi-Target Compilation

Resolve Bottlenecks,
Find Innovative Solutions
Generate Solutions

Solution Overview

Problem

The inefficiency of software building processes due to long build times for large software projects, which can take several hours or days, significantly impacting development efficiency.

Innovation Solution

A software building method that utilizes a resource pool of instances to execute multiple building tasks in parallel, including obtaining code and dependency files, generating tasks based on compilation control files, and distributing these tasks across instances for concurrent execution, thereby improving efficiency.

Engineering Contradictions & Design Principles

VSEngineering Contradiction Analysis

1Productivity

If software building is performed on a single node sequentially, then the building process is simple to manage, but the build time becomes excessively long

Engineering Contradiction:
Improvesoftware building efficiencyVSAvoidbuild time
Core Design Contradiction:
ProductivityVSLoss of time

Solution Approach 1:

The patent divides the software building process into multiple independent building tasks, each targeting a specific module or component. These tasks can be executed in parallel across multiple nodes, transforming a sequential single-node process into a parallel multi-node workflow, thereby significantly reducing overall build time

Inventive Principle:
Principle #1Segmentation

Solution Approach 2:

The patent transitions from a single-dimensional sequential execution model to a multi-dimensional parallel execution model by introducing multiple processing nodes and task distribution mechanisms. This dimensional expansion allows simultaneous execution of multiple building tasks across different nodes

Inventive Principle:
Principle #17Another dimension (Dimensionality change)

2Productivity

If multiple building tasks are executed in parallel across multiple instances, then building efficiency is improved, but system complexity increases

Engineering Contradiction:
Improvebuilding efficiencyVSAvoidsystem complexity
Core Design Contradiction:
ProductivityVSDevice complexity

Solution Approach 1:

The patent introduces a task distribution mechanism that acts as an intermediary between the building system and multiple instances. This mediator manages task allocation, coordination, and result aggregation, simplifying the complexity of parallel execution by providing a centralized control layer

Inventive Principle:
Principle #24Intermediary (Mediator)

Solution Approach 2:

The patent creates a universal task execution framework that can handle multiple types of building tasks across different instances with a unified approach. This multi-functional system manages diverse building operations through standardized interfaces and protocols

Inventive Principle:
Principle #6Universality (Multi-functionality)

Data Source

PatentUS20250362904A1Software building method and apparatus, and related device
Publication Date: 2025.11.27 HUAWEI CLOUD COMPUTING TECHNOLOGIES CO LTD
  • US20250362904A1 patent drawing
  • US20250362904A1 patent drawing
  • US20250362904A1 patent drawing

AI summary

A first instance obtains a code file of to-be-built software from a code repository, and obtains, from a dependency library, a dependency file needed for building the software. The first instance generates a plurality of building tasks based on a plurality of targets in the code file, where different building tasks include different targets, and indicates a plurality of instances in a resource pool to execute the plurality of building tasks in parallel by using the dependency file, to obtain execution results respectively corresponding to the plurality of building tasks, so that the first instance obtains the software through building based on the plurality of execution results. In this way, in a software building process, the first instance executes building processes in parallel for the plurality of building tasks including different targets. Compared with a manner of building targets one by one on a single node.