CN117992067A - Method and device for processing compiling task, electronic equipment and storage medium - Google Patents
Method and device for processing compiling task, electronic equipment and storage medium Download PDFInfo
- Publication number
- CN117992067A CN117992067A CN202410282682.3A CN202410282682A CN117992067A CN 117992067 A CN117992067 A CN 117992067A CN 202410282682 A CN202410282682 A CN 202410282682A CN 117992067 A CN117992067 A CN 117992067A
- Authority
- CN
- China
- Prior art keywords
- node
- compiling
- nodes
- processing
- command
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Pending
Links
- 238000012545 processing Methods 0.000 title claims abstract description 119
- 238000000034 method Methods 0.000 title claims abstract description 101
- 230000008569 process Effects 0.000 claims abstract description 55
- 230000007613 environmental effect Effects 0.000 claims abstract description 43
- 238000004806 packaging method and process Methods 0.000 claims description 12
- 238000012216 screening Methods 0.000 claims description 9
- 238000004590 computer program Methods 0.000 claims description 6
- 238000003672 processing method Methods 0.000 claims description 6
- 238000004891 communication Methods 0.000 description 12
- 238000010586 diagram Methods 0.000 description 8
- 230000006870 function Effects 0.000 description 8
- 230000004044 response Effects 0.000 description 8
- 230000002159 abnormal effect Effects 0.000 description 5
- 230000005856 abnormality Effects 0.000 description 3
- 238000004422 calculation algorithm Methods 0.000 description 3
- 230000008859 change Effects 0.000 description 2
- 230000000694 effects Effects 0.000 description 2
- 238000010801 machine learning Methods 0.000 description 2
- 230000003287 optical effect Effects 0.000 description 2
- 239000007787 solid Substances 0.000 description 2
- 238000003491 array Methods 0.000 description 1
- 230000009286 beneficial effect Effects 0.000 description 1
- 230000005540 biological transmission Effects 0.000 description 1
- 238000004364 calculation method Methods 0.000 description 1
- 239000000470 constituent Substances 0.000 description 1
- 238000013500 data storage Methods 0.000 description 1
- 238000013461 design Methods 0.000 description 1
- 238000011161 development Methods 0.000 description 1
- 239000000835 fiber Substances 0.000 description 1
- 230000010354 integration Effects 0.000 description 1
- 230000003993 interaction Effects 0.000 description 1
- 238000007726 management method Methods 0.000 description 1
- 238000012986 modification Methods 0.000 description 1
- 230000004048 modification Effects 0.000 description 1
- 238000012856 packing Methods 0.000 description 1
- 238000009877 rendering Methods 0.000 description 1
- 238000013468 resource allocation Methods 0.000 description 1
- 239000004065 semiconductor Substances 0.000 description 1
- 230000003068 static effect Effects 0.000 description 1
- 238000007619 statistical method Methods 0.000 description 1
Landscapes
- Stored Programmes (AREA)
Abstract
The embodiment of the specification discloses a method, a device, electronic equipment and a storage medium for processing a compiling task, wherein when the method processes the compiling task, environmental parameters corresponding to the compiling task can be acquired based on a first node, and at least one second node matched with the environmental parameters is determined; then, the environment database corresponding to the environment parameter can be deployed on the first node and all the second nodes respectively, and the first node and all the second nodes process the compiling task.
Description
Technical Field
The embodiment of the specification belongs to the technical field of software development, and particularly relates to a method and a device for processing compiling tasks, electronic equipment and a storage medium.
Background
In the software development process, data packaging is an important link, the packaging speed of the data packaging is easy to influence the whole software development efficiency to a certain extent, and a compiling task is used as an efficiency influence factor of data packaging, so that how to improve the processing speed of the compiling task becomes a problem to be solved.
The compiling task is a process of converting a source code file into an executable program or another code, and when the compiling task is processed in the prior art, the prior art often has higher compiling requirement, and the whole software development efficiency is easily affected, so that a compiling task processing scheme with higher efficiency needs to be provided.
Disclosure of Invention
The embodiment of the specification provides a method, a device, electronic equipment and a storage medium for processing compiling tasks, and the technical scheme is as follows:
In a first aspect, an embodiment of the present disclosure provides a method for processing a compiled task, including:
acquiring environmental parameters corresponding to the compiling task based on the first node, and determining at least one second node matched with the environmental parameters;
And respectively deploying the environment databases corresponding to the environment parameters on the first node and all the second nodes, and processing the compiling task by the first node and all the second nodes.
In a second aspect, an embodiment of the present disclosure provides a processing apparatus for compiling a task, including:
The first processing module is used for acquiring the environment parameters corresponding to the compiling task based on the first node and determining at least one second node matched with the environment parameters;
and the second processing module is used for respectively deploying the environment databases corresponding to the environment parameters on the first node and all the second nodes, and processing the compiling task by the first node and all the second nodes.
In a third aspect, embodiments of the present disclosure provide an electronic device, which may include: a processor and a memory; the memory stores a computer program adapted to be loaded by the processor and to perform the above-mentioned processing method steps of the compiling task.
In a fourth aspect, embodiments of the present disclosure provide a computer storage medium storing a plurality of instructions adapted to be loaded by a processor and to perform the above-described processing method steps of compiling tasks.
The technical scheme provided by some embodiments of the present specification has the following beneficial effects:
In one or more embodiments of the present disclosure, when a compiling task is processed, an environmental parameter corresponding to the compiling task may be obtained based on a first node, and at least one second node matching the environmental parameter may be determined; then, the environment database corresponding to the environment parameter can be deployed on the first node and all the second nodes respectively, and the first node and all the second nodes process the compiling task. Analyzing and processing the compiling task through the first node to obtain environmental parameters, and determining a plurality of corresponding second nodes capable of executing compiling and processing so as to effectively improve the overall compiling efficiency in a distributed compiling mode; and the compiling environment corresponding to the compiling task can be deployed on all the second nodes capable of executing the compiling process, so that the consistency of the compiling environment is ensured, the compiling problem caused by the compiling environment is avoided, and the overall compiling efficiency is further ensured.
Drawings
In order to more clearly illustrate the technical solutions in the embodiments of the present description, the drawings that are required in the embodiments will be briefly described below, and it is apparent that the drawings in the following description are only some embodiments of the present description, and other drawings may be obtained according to these drawings without inventive effort for a person skilled in the art.
Fig. 1 is a schematic system architecture diagram of a method for processing a compiling task according to an embodiment of the present disclosure;
FIG. 2 is a flowchart illustrating a method for processing a compiling task according to an embodiment of the present disclosure;
Fig. 3 is a schematic structural diagram of a node database according to an embodiment of the present disclosure;
FIG. 4 is a flowchart illustrating a method for processing a compiling task according to an embodiment of the present disclosure;
FIG. 5 is a processing effect diagram of distributed compiling according to an embodiment of the present disclosure;
FIG. 6 is a flowchart illustrating a method for processing a compiling task according to an embodiment of the present disclosure;
fig. 7 is a schematic structural diagram of a processing device for compiling tasks according to an embodiment of the present disclosure;
fig. 8 is a schematic structural diagram of an electronic device according to an embodiment of the present disclosure.
Detailed Description
The technical solutions in the embodiments of the present specification will be clearly and completely described below with reference to the drawings in the embodiments of the present specification.
The terms first, second, third and the like in the description and in the claims and in the above drawings are used for distinguishing between different objects and not necessarily for describing a particular sequential or chronological order. Furthermore, the terms "comprise" and "have," as well as any variations thereof, are intended to cover a non-exclusive inclusion. For example, a process, method, system, article, or apparatus that comprises a list of steps or elements is not limited to only those listed steps or elements but may include other steps or elements not listed or inherent to such process, method, article, or apparatus.
The following description provides examples and does not limit the scope, applicability, or examples set forth in the claims. Changes may be made in the function and arrangement of elements described without departing from the scope of the disclosure herein. Various examples may omit, replace, or add various procedures or components as appropriate. For example, the described methods may be performed in a different order than described, and various steps may be added, omitted, or combined. Furthermore, features described with respect to some examples may be combined into other examples.
In the software development process, a method for improving the processing efficiency of the compiling task is distributed compiling, that is, the compiling task is distributed to a plurality of compiling nodes for parallel processing. However, the conventional distributed compiling method needs to use an open source tool to greatly adjust the existing compiling environment, and the corresponding configuration file is not a well-known compiling language, so that many users need to expend energy to master the related compiling language, and the compiling problem is easily caused by the compiling environment, so that the overall compiling efficiency is affected. Secondly, the conventional distributed compiling method may not respond or make adjustments quickly when node faults occur, and the overall compiling efficiency and accuracy are also easily affected. Based on this, the present specification will describe in detail the processing of compilation tasks in connection with one or more embodiments.
Referring to fig. 1, fig. 1 is a schematic system architecture diagram of a method for processing a compiling task according to an embodiment of the present disclosure.
As shown in fig. 1, the system architecture of the method for processing a compiling task may at least include a server 101, a first node terminal 102, and a second node terminal 103, where the second node terminal 103 may include, but is not limited to, at least one or more node terminals capable of establishing a communication connection with the first node terminal 102. The first node terminal 102 may be understood as a node terminal for acquiring a compiling task or distributing a compiling task in a software development process, and the first node terminal 102 may process the acquired compiling task or the distributed compiling task, for example, may obtain a corresponding environmental parameter by analyzing and processing the compiling task, so as to compile the compiling task in combination with the environmental parameter, and further obtain a corresponding compiling result. Here, the environment parameters may include, but are not limited to, bundle information parameters corresponding to the compiling task (which may also be understood as bundle information for packing, organizing, and managing resources required for the project during development and deployment, such as but not limited to information including code files, dependency items, configuration files, and static files) and version parameters within the first node terminal 102 for processing the compiling task, which may be understood as, in particular, an operating system version, a tool chain version, and a version of an external dependency database of the first node terminal 102 to ensure a compiling environment for processing the compiling task through the environment parameters.
The server 101 may be configured to screen, according to the environmental parameter determined by the first node terminal 102, at least one second node terminal 103 that matches the environmental parameter, so that the at least one second node terminal 103 and the first node terminal 102 together implement processing of the compiling task. Here, in the process of screening out the second node terminals 103 that match the environmental parameters, the server 101 may, but is not limited to, determine all the second node terminals 103 that may establish a communication connection with the first node terminal 102, where all the second node terminals 103 may send an acquisition request of a compiling task to the first node terminal 102, and may receive the compiling task sent by the first node terminal 102 or a compiling command corresponding to the compiling task; then, the server 101 may further screen out a part of the second node terminals 103 consistent with the version parameter from all the second node terminals 103 according to the version parameter in the environment parameter, so as to ensure that the compiling environment of the part of the second node terminals 103 may be consistent with the compiling environment of the first node terminal 102, and determine the specific number of the second node terminals according to the binding information parameter in the environment parameter, so as to screen out the second node terminals 103 consistent with the number of the second node terminals from the part of the second node terminals 103.
It may be understood that the server 101 may also, but not limited to, download an environment database corresponding to the binding information parameter, and send the environment database to the first node terminal 102 and all the second node terminals 103, so that the first node terminal 102 and all the second node terminals 103 deploy a compiling environment for processing the compiling task. Here, the environment database may specifically include a compiled code database and an external dependency database, and the version of the external dependency database may also be determined according to, but not limited to, the above-mentioned version parameters.
In the embodiment of the present disclosure, when processing a compiling task, the environment parameters corresponding to the compiling task are obtained based on the first node terminal 102, and the server 101 determines at least one second node terminal 103 matching with the environment parameters; then, the server 101 may deploy the environmental databases corresponding to the environmental parameters on the first node terminal 102 and all the second node terminals 103, and the first node terminal 102 and all the second node terminals 103 process the compiling task. Analyzing and processing the compiling task through the first node terminal 102 to obtain environmental parameters, and determining a plurality of corresponding second node terminals 103 capable of executing compiling and processing so as to effectively improve the overall compiling efficiency in a distributed compiling mode; and, the compiling environments corresponding to the compiling tasks can be deployed on all the second node terminals 103 capable of executing the compiling process, so as to ensure consistency of the compiling environments, avoid compiling problems caused by the compiling environments, and further ensure the overall compiling efficiency.
Referring next to fig. 2, fig. 2 is a flowchart illustrating an overall method for processing a compiling task according to an embodiment of the present disclosure.
As shown in fig. 2, the processing method of the compiling task may at least include the following steps:
step 202, acquiring environmental parameters corresponding to the compiling task based on the first node, and determining at least one second node matched with the environmental parameters.
Specifically, when the compiling task is processed, the first node (i.e., the above-mentioned first node terminal, and all the nodes mentioned below may be understood as node terminals) may acquire the compiling task that needs to be processed, or the first node may issue the compiling task that needs to be processed according to the software development requirement, and analyze and process the compiling task and the system environment corresponding to the first node to obtain the environmental parameter corresponding to the compiling task. When the first node obtains the compiling task to be processed, the integrating server may automatically distribute the compiling task generated according to the software development requirement to the first node, and the number of the compiling tasks obtained by the first node is not limited to one or more.
It is understood that the environment parameters corresponding to the compiling task may include, but are not limited to, binding information parameters corresponding to the compiling task and version parameters corresponding to a system environment of the first node, where the version parameters may be specifically understood as an operating system version and a tool chain version set by the first node, and may further include an external dependency database version determined according to the binding information parameters.
Further, after the first node determines the environmental parameter corresponding to the compiling task, the server may, but is not limited to, screen at least one second node matched with the plurality of nodes corresponding to the first node according to the environmental parameter, where the plurality of nodes corresponding to the first node may respectively establish communication connection with the first node, so as to send an acquisition request of the compiling task to the first node, so that the processing efficiency of the compiling task is fast improved by matching with the first node. The method of screening out the matched at least one second node may, but not limited to, use all nodes consistent with or similar to version parameters in the environment parameters as at least one second node, or use all nodes consistent with version of the external dependency database corresponding to the environment parameters as at least one second node, so as to ensure that the screened out second node may be consistent with or similar to the compiling environment of the first node.
As an option of an embodiment of the present disclosure, determining at least one second node matching the environmental parameter includes:
screening out a first node set consistent with the version parameters from a node database corresponding to the first node;
And obtaining the number of nodes based on the historical compiling time lengths respectively corresponding to all the files in the binding information parameters, and taking all the nodes in the first node set, which are consistent with the number of the nodes, as at least one second node.
Specifically, when at least one second node matched with the environmental parameter is selected, but not limited to, a node database corresponding to the first node may be determined by the server, where the node database may include a plurality of first nodes and at least two nodes that are in communication connection with each first node in advance, and data interaction exists between the at least two nodes and the corresponding first nodes, that is, data transmission reliability between the at least two nodes and the corresponding first nodes is ensured, and each first node in the node database may acquire a compiling task that needs to be processed, or issue a compiling task that needs to be processed according to software development requirements.
Referring to fig. 3, as shown in fig. 3, the node database may include three first nodes, which may be respectively represented as a first node a, a first node B, and a first node C, where at least two nodes that have previously established communication connection with the first node a may be respectively represented as a node a1, a node a2, and a node a3, at least two nodes that have previously established communication connection with the first node B may be respectively represented as a node B1, a node B2, and a node B3, and at least two nodes that have previously established communication connection with the first node C may be respectively represented as a node C1, a node C2, and a node C3. It is understood that the at least one second node matched with the first node a may be, but is not limited to being, any of the node a1, the node a2, and the node a3, the at least one second node matched with the first node B may be, but is not limited to being, any of the node B1, the node B2, and the node B3, and the at least one second node matched with the first node C may be, but is not limited to being, any of the node C1, the node C2, and the node C3.
Then, after determining all the nodes corresponding to the first node in the node database, the server may, but is not limited to, send a version acquisition request to each node in the nodes to respectively receive the version parameters corresponding to each node, and screen out a node set (i.e., the first node set) consistent with the version parameters in the environment parameters. The version parameters corresponding to each node may specifically include an operating system version of the corresponding terminal, an external dependency database version required for executing the compiling task, a compiler version, and an SDK version, where each version may analyze and process the terminal through a corresponding preset query code or query instruction, so as to query specific version information from the corresponding storage path. For example, using a tool chain version as an example, the server may send a version command of the tool chain to the terminal corresponding to each node, so that the corresponding terminal may query and feed back the tool chain version. It should be understood that the version parameters in the environment parameters may specifically include the above-mentioned operating system version, the external dependency database version required for executing the compiling task, the compiler version, and the SDK version, and each version may be obtained through a corresponding preset query code or query instruction, which is not limited thereto.
When the node set consistent with the version parameter in the environment parameter is selected, the server may, but not limited to, use all nodes that are consistent with the operating system version, the external dependency database version required for executing the compiling task, the compiler version, and the SDK version in the environment parameter as the first node set, or use all nodes that are consistent with any at least two of the operating system version, the external dependency database version required for executing the compiling task, the compiler version, and the SDK version as the first node set.
Then, after determining the first node set, the server may query the historical compiling time length corresponding to each file in the historical compiling record library according to the file information corresponding to all files in the binding information parameter, where the file information may include, but is not limited to, a file name and a file size, and count the total historical compiling time length of all files. It can be understood that the binding information parameter corresponding to each compiling task includes a plurality of files, and each file can record the corresponding compiling time after being compiled and store the compiling time in the historical file compiling record library.
Then, after obtaining the historical compiling total duration of all the files, the server side can calculate the number of the second nodes according to the historical compiling total duration and the equipment core number corresponding to the first node set, and can randomly extract all the nodes consistent with the number from the first node set as at least one second node. The calculating method may, but is not limited to, calculating a ratio of the total historical compiling duration to the number of device cores corresponding to the first node set, that is, taking the result of the ratio as the number of the second nodes, and before calculating the ratio, converting the total historical compiling duration, for example, but not limited to, calculating a ratio of the total historical compiling duration to 180 (in seconds), but not limited to, the method is also described.
Here, the number of device cores corresponding to the first node set may be determined based on the number of CPU cores corresponding to the terminal of each node in the first node set, for example, but not limited to, a CPU core number average corresponding to the terminal of all nodes, and the CPU core number average may be guaranteed to be an integer as much as possible. As a preferred embodiment, the number of device cores corresponding to the first node set in the embodiment of the present disclosure may be the CPU core number with the largest number of corresponding nodes, and in this case, the above-mentioned first node set needs to be replaced by all the nodes corresponding to the CPU core number, that is, the number of device cores corresponding to the first node set is guaranteed to be consistent with the number of CPU cores corresponding to each node in the first node set.
It should be further understood that in the embodiment of the present disclosure, the second node number may be determined directly according to the number of all files in the binding information parameter, for example, a ratio between the number of all files and 100 may be used as the second node number, and when the ratio is not an integer, the ratio may be corrected according to a rounding rule. Of course, the manner of determining the number of the second nodes may also be combined with machine learning, for example, predicted by a trained machine learning model, and is not limited thereto.
As yet another alternative of the embodiment of the present disclosure, before taking all nodes, which are consistent with the number of nodes, in the first node set as at least one second node, the method further includes:
Acquiring the memory utilization rate corresponding to each node in the first node set;
obtaining a second node set based on all nodes with the memory utilization rate lower than a preset threshold value;
all nodes, the number of which is consistent with that of the nodes, in the first node set are taken as at least one second node, and the method comprises the following steps:
And taking all the nodes, the number of which is consistent with that of the nodes, in the second node set as at least one second node.
In order to effectively ensure the compiling processing efficiency of the second node, the method can also stand at the terminal processing performance angle corresponding to the node to carry out screening processing on the first node set so as to screen out the second node with higher compiling processing efficiency.
Specifically, before at least one second node is screened out, the server may also, but not limited to, obtain a memory utilization rate corresponding to each node in the first node set, that is, a current memory use condition, so as to filter out a portion of nodes with higher current memory utilization rate, to achieve an effect of optimizing resource allocation, and may use all nodes with a memory utilization rate lower than a preset threshold value as the second node set, where each node in the second node set has a lower memory utilization rate, and the above mentioned preset threshold value may be, but not limited to, 20%.
It can be understood that if the memory utilization rate corresponding to any node is detected to be higher than 80% in the first node set, which indicates that the node cannot be compiled temporarily, the node may be filtered, or other nodes that are screened out to be matched correspondingly by combining the above-mentioned environmental parameters may be updated to the first node set.
And 204, respectively deploying the environment databases corresponding to the environment parameters on the first node and all the second nodes, and processing the compiling task by the first node and all the second nodes.
Specifically, after screening out all the reasonable second nodes, the server may, but not limited to, perform query processing and download processing on the environmental database in a corresponding code repository according to the environmental database information corresponding to the binding information parameter in the environmental parameters, and may distribute the environmental database after the download processing to the first node and all the screened second nodes, so that the first node and all the second nodes deploy a consistent compiling environment. Here, the environment database may specifically include a compiled code library and external dependency data, and version information corresponding to the external dependency database may refer to the above embodiment, which is not limited thereto.
Further, after the first node and all the second nodes deploy the consistent compiling environments, the compiling tasks may be divided into a plurality of subtasks, so that the first node and all the second nodes compile all the subtasks, for example, but not limited to, the compiling tasks may be divided into subtasks with the same number as the total number of the nodes according to the total number of the nodes corresponding to the first node and all the second nodes, so that the first node and each second node can perform the compiling processing of the subtasks.
The foregoing describes specific embodiments of the present disclosure. Other embodiments are within the scope of the following claims. In some cases, the actions or steps recited in the claims can be performed in a different order than in the embodiments and still achieve desirable results. In addition, the processes depicted in the accompanying figures do not necessarily require the particular order shown, or sequential order, to achieve desirable results. In some embodiments, multitasking and parallel processing are also possible or may be advantageous.
Referring next to fig. 4, fig. 4 is a flowchart illustrating an overall method for processing a compiling task according to an embodiment of the present disclosure.
As shown in fig. 4, the processing method of the compiling task may at least include the following steps:
Step 402, acquiring environmental parameters corresponding to the compiling task based on the first node, and determining at least one second node matched with the environmental parameters.
Specifically, step 402 may refer to step 202, and will not be described in detail herein.
And step 404, respectively deploying the environment databases corresponding to the environment parameters on the first node and all the second nodes.
Specifically, step 404 may refer to step 204, and will not be described in detail herein.
Step 406, converting the configuration parameters corresponding to all the files in the binding information parameters to obtain corresponding compiling commands.
Specifically, after the first node and all the second nodes deploy the consistent compiling environments, as all the files in the binding information parameters respectively correspond to different compiling parameter settings, each compiling parameter change may possibly cause a compiling failure or a compiling result change, in order to improve the reading accuracy of the compiling parameters, the first node may write the configuration parameters (which may be understood as the compiling parameters) corresponding to each file into a preset configuration file, and analyze and convert the configuration file written with the configuration parameters to obtain a corresponding compiling command, so that the subsequent first node or any one of the second nodes may combine the compiling command and the corresponding file source code to perform the compiling process, and the accuracy of the compiling parameters may be effectively ensured.
It may be understood that after the first node generates the compiling command corresponding to each file in the binding information parameter, the compiling command may be stored in a preset storage path or stored with the corresponding file source code, so as to facilitate the distribution and compiling of each compiling command.
Step 408, arranging all the compiling commands according to a preset sequence to obtain a compiling queue, and obtaining a compiling request set corresponding to each compiling command in the compiling queue.
Specifically, after obtaining the compiling commands corresponding to each file in the binding information parameters, the first node may perform permutation processing on all the compiling commands according to the permutation sequence (i.e. the preset sequence) of each file, so that the permutation sequence of each compiling command is consistent with the corresponding file permutation sequence, and place all the compiling commands after permutation processing in a queue with safe threads, and receive the compiling request fed back by each second node by distributing compiling task instructions to each second node.
It may be appreciated that, when the compiling task instruction is distributed to each second node, the first node may sequentially distribute the compiling task instruction including each compiling command to each second node according to the compiling command arrangement order in the queue, so as to obtain a compiling request set corresponding to each compiling command. Here, the compiling request set may include a compiling request of at least one second node and a compiling request of a first node, where each compiling request set of the second node may be marked with a corresponding request response time, and the compiling request of the first node may be understood as an alternative compiling request, for example, but not limited to, when the request response time corresponding to all the second nodes in the compiling request set does not meet the compiling requirement, the compiling request set may default to include only the compiling request of the first node, that is, the first node performs the compiling process according to the compiling command corresponding to the compiling request set and the corresponding file source code.
Of course, the first node may, but not limited to, distribute the compiling task instruction to each second node, and further, may, but not limited to, distribute the compiling task instruction to itself, so as to receive the compiling request fed back by itself, and may mark a corresponding request response time, and determine the compiling object corresponding to each compiling command by determining the request response time.
Step 410, determining a corresponding compiling object based on the compiling request set corresponding to each compiling command, and processing the corresponding compiling command by each compiling object.
Specifically, after the compiling request set corresponding to each compiling command is obtained, the first node may determine the compiling object of the corresponding compiling command according to the request response time corresponding to each second node in each compiling request set, so as to send the file source code corresponding to the compiling command to the compiling object, that is, the compiling object performs compiling processing according to the compiling command and the corresponding file source code by calling a local tool chain and the like, so as to obtain a corresponding compiling result. Here, the compiling object may be any one of the second nodes or the first node, and when the request response time corresponding to all the second nodes in the compiling request set does not meet the compiling requirement, the first node may be used as the compiling object corresponding to the compiling request set.
It should be understood that any one of the second nodes or the first node may be a compiling object corresponding to at least one compiling command, that is, any one of the second nodes or the first node may perform a compiling process according to at least one compiling command and a corresponding file source code, and any one of the second nodes or the first node may perform a compiling process according to a next compiling command and a corresponding file source code after completing the compiling process according to one compiling command and a corresponding file source code.
It should be noted that, after determining the compiled object corresponding to each compiled command, in order to avoid the problem of repeated distribution of the compiled commands, the compiled commands of the compiled objects determined may be deleted in the compiling queue, that is, the compiled commands stored in the compiling queue are all compiled commands of the compiled objects that have not been allocated yet.
Referring to fig. 5, as shown in fig. 5, a compiling queue corresponding to a compiling task may include three compiling commands, which are respectively indicated as a compiling command a, a compiling command B, and a compiling command C, where a compiling object determined by the compiling command a may be a first node, and a corresponding compiling result a is obtained through a compiling process of the first node; the compiling object determined by the compiling command B can be a second node a, and a corresponding compiling result B is obtained through compiling processing of the second node a; the compiling object determined by the compiling command C may be the second node b, and the corresponding compiling result C is obtained through the compiling process of the second node b.
As yet another alternative of the embodiment of the present disclosure, the processing, by the first node and all the second nodes, of the compiling task further includes:
When any one of the second nodes does not receive the heartbeat signal sent by the first node within a preset time interval, the first node is replaced by any one of the second nodes, and the corresponding compiling command is processed by the processed first node.
In order to quickly judge whether the first node is abnormal in the whole compiling process, the processing state of the first node can be judged by detecting the heartbeat signal, so that the processing state can be adjusted in time when the abnormality is determined, and the stability and the reliability of the whole compiling process are further effectively ensured.
Specifically, when the first node and the second nodes process the compiling task, the first node may send a heartbeat signal to any one of the second nodes at preset time intervals, and the corresponding second node may send a response signal to the first node after receiving the heartbeat signal, so as to indicate that the corresponding second node is in a normal processing state. It can be understood that when the corresponding second node does not receive the heartbeat signal sent by the first node within the preset time interval, it indicates that the first node may have an abnormality, so that the normal operation of the whole compiling process cannot be guaranteed, and further, the server side may select one second node from all the second nodes and take the second node as the first node, so as to perform compiling processing according to the compiling command and the file source code corresponding to the abnormal first node, and the server side may also send the compiling command and the file source code corresponding to the abnormal first node to the second node, so as to effectively improve compiling efficiency.
It may be further understood that, when the first node does not receive the response signal fed back by the second node within the preset time interval, it indicates that the corresponding second node may be in an abnormal processing state, so that the first node may perform compiling processing according to the compiling command and the file source code corresponding to the second node, or the first node may send the compiling command and the file source code corresponding to the second node to other second nodes, so that other second nodes perform compiling processing according to the compiling command and the file source code corresponding to the second node.
In the embodiment of the present disclosure, the manner of selecting one second node from all the second nodes may be, but not limited to, determined according to the current memory utilization of all the second nodes, for example, the second node with the lowest current memory utilization may be used to perform the replacement processing on the first node, which is not limited thereto.
As yet another alternative of the embodiment of the present disclosure, the processing, by the first node and all the second nodes, of the compiling task further includes:
When the compiling command corresponding to any one of the second nodes is detected to have no compiling result, the first node processes the compiling command; or (b)
When detecting that any compiling command has error reporting information, the first node processes the compiling command and gathers the error reporting information.
In order to quickly judge whether the second node is abnormal in the whole compiling process, the processing state of the second node can be judged through the compiling result or the error reporting information, so that the second node can be timely adjusted when the abnormality is determined, and the stability and the reliability of the whole compiling process are further effectively ensured.
Specifically, after the compiling process is completed by the first node and the second nodes, the compiling process may be performed by the first node according to the compiling command and the file source code corresponding to the second node, so as to ensure the overall operation of the overall compiling process. It can be understood that when the compiling result of the compiling command corresponding to any one of the second nodes is detected, it indicates that all the second nodes are in a normal processing state, and further the first node can perform subsequent packaging operation according to all the compiling results.
Of course, after the first node and the second node complete the compiling process, the server side or the first node may receive the error reporting information fed back by any one of the second nodes, and when detecting that the error reporting information exists in the second node corresponding to any one of the compiling commands, it indicates that the second node may not normally perform the compiling process according to the corresponding compiling command and the file source code, and further the first node may perform the compiling process according to the compiling command corresponding to the second node and the file source code, so as to ensure the overall operation of the overall compiling process, and the first node may also perform the statistical analysis process on the error reporting information, so as to avoid the situation that the corresponding second node returns the error reporting information again. Here, the error reporting information may, but is not limited to, information generated by the second node according to the encountered problem when the second node performs the compiling process, for example, when the second node does not obtain the compiling result according to the file source code when the second node performs the compiling process, error reporting information indicating that the file source code is wrong may be generated.
Referring next to fig. 6, fig. 6 is a flowchart illustrating an overall method for processing a compiling task according to an embodiment of the present disclosure.
As shown in fig. 6, the processing method of the compiling task may at least include the following steps:
Step 602, acquiring environmental parameters corresponding to the compiling task based on the first node, and determining at least one second node matched with the environmental parameters.
Specifically, step 602 may refer to step 202, and will not be described in detail herein.
And step 604, respectively deploying the environment databases corresponding to the environment parameters on the first node and all the second nodes, and processing the compiling task by the first node and all the second nodes.
Specifically, step 604 may refer to step 204, which is not repeated here.
Step 606, the first node receives the compiling results of all the second nodes and the corresponding first hash values, and performs calculation processing on the compiling results of each second node to obtain the corresponding second hash values.
Specifically, after the compiling processing is completed by the first node and the second node, in order to effectively ensure the accuracy of the compiling result of the second node, the first node may, but is not limited to, receive the compiling result fed back by each second node and a corresponding first hash value, where the first hash value may be obtained by processing the corresponding compiling result by the second node according to a preset hash algorithm, and may be obtained by processing the compiling result corresponding to each second node by the first node according to the same preset hash algorithm, so as to obtain a corresponding second hash value, and quickly determine the accuracy of the corresponding compiling result by comparing the first hash value and the second hash value corresponding to each second node. Here, the preset hash algorithm may be a conventional technical means in the art, and will not be described in detail.
Step 608, when any one of the first hash values is detected to be inconsistent with the corresponding second hash value, eliminating the compiling result corresponding to the first hash value, and processing the compiling command corresponding to the first hash value by the first node.
Specifically, when the first node detects that the first hash value and the second hash value corresponding to any one of the second nodes are inconsistent, it indicates that the compiling result fed back by the second node may be wrong, and then the first node may reject the compiling result fed back by the second node, and compile according to the compiling command and the file source code corresponding to the second node, so as to generate a corresponding compiling result.
As yet another alternative of the embodiment of the present specification, after the compiling task is processed by the first node and all the second nodes, the method further includes:
and packaging the corresponding compiling result based on the file format in each compiling command.
In order to improve the subsequent packaging efficiency, after the first node and all the second nodes process the compiling tasks, the server side or the first node may perform packaging processing on the corresponding compiling result according to the file format in each compiling command, where the file format obtained by packaging is consistent with the file format in the corresponding compiling command, for example, but not limited to, when the file format in any at least one compiling command is frame work, all the corresponding compiling results may be packaged into frame work files; or when the file format in any at least one compiling command is so, all corresponding compiling results can be packaged into a so file; and when the file format in any at least one compiling command is dll, all corresponding compiling results can be packaged into dll files, and baseline processing can be carried out on all packaged files so as to ensure the management and use flow of all compiling results.
Referring to fig. 7, fig. 7 is a schematic structural diagram of a processing device for compiling tasks according to an embodiment of the present disclosure.
As shown in fig. 7, the processing apparatus for compiling tasks may include at least a first processing module 701 and a second processing module 702, where:
a first processing module 701, configured to obtain an environmental parameter corresponding to the compiling task based on the first node, and determine at least one second node that matches the environmental parameter;
The second processing module 702 is configured to deploy an environmental database corresponding to the environmental parameter on the first node and all the second nodes, and process the compiling task by the first node and all the second nodes.
In some possible embodiments, the environment parameters include version parameters and binding information parameters;
the first processing module 701 is specifically configured to:
screening out a first node set consistent with the version parameters from a node database corresponding to the first node;
And obtaining the number of nodes based on the historical compiling time lengths respectively corresponding to all the files in the binding information parameters, and taking all the nodes in the first node set, which are consistent with the number of the nodes, as at least one second node.
In some possible embodiments, the first processing module 701 is further configured to:
Before all nodes, the number of which is consistent with that of the nodes in the first node set, are used as at least one second node, the memory utilization rate corresponding to each node in the first node set is obtained;
obtaining a second node set based on all nodes with the memory utilization rate lower than a preset threshold value;
all nodes, the number of which is consistent with that of the nodes, in the first node set are taken as at least one second node, and the method comprises the following steps:
And taking all the nodes, the number of which is consistent with that of the nodes, in the second node set as at least one second node.
In some possible embodiments, the second processing module 702 is specifically configured to:
Converting configuration parameters corresponding to all files in the binding information parameters respectively to obtain corresponding compiling commands;
arranging all compiling commands according to a preset sequence to obtain a compiling queue, and acquiring a compiling request set corresponding to each compiling command in the compiling queue; the compiling request set comprises at least one compiling request corresponding to the second node and a compiling request corresponding to the first node;
Based on the compiling request set corresponding to each compiling command, determining a corresponding compiling object, and processing the corresponding compiling command by each compiling object; each compiling object is a first node or any one of second nodes, the first node corresponds to at least one compiling command, and each second node corresponds to at least one compiling command.
In some possible embodiments, the second processing module 702 is further configured to:
When any one of the second nodes does not receive the heartbeat signal sent by the first node within a preset time interval, the first node is replaced by any one of the second nodes, and the corresponding compiling command is processed by the processed first node.
In some possible embodiments, the second processing module 702 is further configured to:
When the compiling command corresponding to any one of the second nodes is detected to have no compiling result, the first node processes the compiling command; or (b)
When detecting that any compiling command has error reporting information, the first node processes the compiling command and gathers the error reporting information.
In some possible embodiments, the apparatus further comprises:
After the compiling tasks are processed by the first node and all the second nodes, the first node receives the compiling results of all the second nodes and corresponding first hash values, and calculates the compiling results of each second node to obtain corresponding second hash values;
When any one first hash value is detected to be inconsistent with the corresponding second hash value, eliminating the compiling result corresponding to the first hash value, and processing the compiling command corresponding to the first hash value by the first node.
In some possible embodiments, the apparatus further comprises:
After the compiling tasks are processed by the first node and all the second nodes, the corresponding compiling results are packaged based on the file format in each compiling command.
It will be apparent to those skilled in the art that the embodiments of the present disclosure may be implemented in software and/or hardware. "unit" and "module" in this specification refer to software and/or hardware capable of performing a particular function, either alone or in combination with other components, such as Field-Programmable gate arrays (Field-Programmable GATE ARRAY, FPGA), integrated circuits (INTEGRATED CIRCUIT, ICs), and the like.
Referring next to fig. 8, fig. 8 is a schematic structural diagram of an electronic device according to an embodiment of the present disclosure.
As shown in fig. 8, the electronic device 800 may include: at least one processor 801, at least one network interface 804, a user interface 803, memory 805, and at least one communication bus 802.
Wherein the communication bus 802 may be used to enable connectivity communication of the various components described above.
The user interface 803 may include keys, among other things, and the optional user interface may also include a standard wired interface, a wireless interface.
The network interface 804 may include, but is not limited to, a bluetooth module, an NFC module, a Wi-Fi module, and the like.
Wherein the processor 801 may include one or more processing cores. The processor 801 utilizes various interfaces and lines to connect various portions of the overall electronic device 800, perform various functions of routing the electronic device 800, and process data by executing or executing instructions, programs, code sets, or instruction sets stored in the memory 805, and invoking data stored in the memory 805. Alternatively, the processor 801 may be implemented in at least one form of hardware in DSP, FPGA, PLA. The processor 801 may integrate one or a combination of several of a CPU, GPU, modem, and the like. The CPU mainly processes an operating system, a user interface, an application program and the like; the GPU is used for rendering and drawing the content required to be displayed by the display screen; the modem is used to handle wireless communications. It will be appreciated that the modem may not be integrated into the processor 801 and may be implemented on a single chip.
The memory 805 may include RAM or ROM. Optionally, the memory 805 comprises a non-transitory computer readable medium. Memory 805 may be used to store instructions, programs, code, sets of codes, or instruction sets. The memory 805 may include a stored program area and a stored data area, wherein the stored program area may store instructions for implementing an operating system, instructions for at least one function (such as a touch function, a sound playing function, an image playing function, etc.), instructions for implementing the above-described respective method embodiments, etc.; the storage data area may store data or the like referred to in the above respective method embodiments. The memory 805 may also optionally be at least one storage device located remotely from the aforementioned processor 801. As shown in fig. 8, an operating system, a network communication module, a user interface module, and a processing application for compiling tasks may be included in the memory 805 as one type of computer storage medium.
In particular, the processor 801 may be used to invoke a processing application of a compiled task stored in the memory 805 and specifically perform the following operations:
acquiring environmental parameters corresponding to the compiling task based on the first node, and determining at least one second node matched with the environmental parameters;
And respectively deploying the environment databases corresponding to the environment parameters on the first node and all the second nodes, and processing the compiling task by the first node and all the second nodes.
In some possible embodiments, the environment parameters include version parameters and binding information parameters;
Determining at least one second node matching the environmental parameter, comprising:
screening out a first node set consistent with the version parameters from a node database corresponding to the first node;
And obtaining the number of nodes based on the historical compiling time lengths respectively corresponding to all the files in the binding information parameters, and taking all the nodes in the first node set, which are consistent with the number of the nodes, as at least one second node.
In some possible embodiments, before taking all nodes in the first node set, which are consistent with the number of nodes, as at least one second node, the method further includes:
Acquiring the memory utilization rate corresponding to each node in the first node set;
obtaining a second node set based on all nodes with the memory utilization rate lower than a preset threshold value;
all nodes, the number of which is consistent with that of the nodes, in the first node set are taken as at least one second node, and the method comprises the following steps:
And taking all the nodes, the number of which is consistent with that of the nodes, in the second node set as at least one second node.
In some possible embodiments, the processing of the compiling task by the first node and all the second nodes comprises:
Converting configuration parameters corresponding to all files in the binding information parameters respectively to obtain corresponding compiling commands;
arranging all compiling commands according to a preset sequence to obtain a compiling queue, and acquiring a compiling request set corresponding to each compiling command in the compiling queue; the compiling request set comprises at least one compiling request corresponding to the second node and a compiling request corresponding to the first node;
Based on the compiling request set corresponding to each compiling command, determining a corresponding compiling object, and processing the corresponding compiling command by each compiling object; each compiling object is a first node or any one of second nodes, the first node corresponds to at least one compiling command, and each second node corresponds to at least one compiling command.
In some possible embodiments, the processing of the compiling task by the first node and all the second nodes further comprises:
When any one of the second nodes does not receive the heartbeat signal sent by the first node within a preset time interval, the first node is replaced by any one of the second nodes, and the corresponding compiling command is processed by the processed first node.
In some possible embodiments, the first node and all the second nodes process the compiling task, further comprising:
When the compiling command corresponding to any one of the second nodes is detected to have no compiling result, the first node processes the compiling command; or (b)
When detecting that any compiling command has error reporting information, the first node processes the compiling command and gathers the error reporting information.
In some possible embodiments, after the compiling task is processed by the first node and all the second nodes, further comprising:
Receiving the compiling results of all the second nodes and the corresponding first hash values by the first node, and calculating the compiling results of each second node to obtain the corresponding second hash values;
When any one first hash value is detected to be inconsistent with the corresponding second hash value, eliminating the compiling result corresponding to the first hash value, and processing the compiling command corresponding to the first hash value by the first node.
In some possible embodiments, after the compiling task is processed by the first node and all the second nodes, further comprising:
and packaging the corresponding compiling result based on the file format in each compiling command.
Embodiments of the present disclosure also provide a computer-readable storage medium having instructions stored therein that, when executed on a computer or processor, cause the computer or processor to perform one or more of the steps of the embodiments shown in fig. 2 or 4 or 6 described above. The above-described constituent modules of the electronic apparatus may be stored in a computer-readable storage medium if implemented in the form of software functional units and sold or used as independent products.
In the above embodiments, it may be implemented in whole or in part by software, hardware, firmware, or any combination thereof. When implemented in software, may be implemented in whole or in part in the form of a computer program product. The computer program product includes one or more computer instructions. When the computer program instructions are loaded and executed on a computer, the processes or functions in accordance with embodiments of the present description are produced in whole or in part. The computer may be a general purpose computer, a special purpose computer, a computer network, or other programmable apparatus. The computer instructions may be stored in or transmitted across a computer-readable storage medium. The computer instructions may be transmitted from one website, computer, server, or data center to another website, computer, server, or data center by a wired (e.g., coaxial cable, fiber optic, digital subscriber line (Digital Subscriber Line, DSL)), or wireless (e.g., infrared, wireless, microwave, etc.). Computer readable storage media can be any available media that can be accessed by a computer or data storage devices, such as servers, data centers, etc., that contain an integration of one or more available media. The usable medium may be a magnetic medium (e.g., a floppy disk, a hard disk, a magnetic tape), an optical medium (e.g., a digital versatile disk (DIGITAL VERSATILE DISC, DVD)), or a semiconductor medium (e.g., a Solid state disk (Solid STATE DISK, SSD)), or the like.
Those skilled in the art will appreciate that implementing all or part of the above-described embodiment methods may be accomplished by way of a computer program, which may be stored in a computer-readable storage medium, instructing relevant hardware, and which, when executed, may comprise the embodiment methods as described above. And the aforementioned storage medium includes: various media capable of storing program code, such as ROM, RAM, magnetic or optical disks. The technical features in the present examples and embodiments may be arbitrarily combined without conflict.
The above embodiments are merely illustrative of the preferred embodiments of the present invention and are not intended to limit the scope of the present invention, and various modifications and improvements made by those skilled in the art to the technical solution of the present invention should fall within the protection scope defined by the claims of the present invention without departing from the design spirit of the present invention.
Claims (18)
1. The processing method of the compiling task comprises the following steps:
Acquiring environmental parameters corresponding to the compiling task based on the first node, and determining at least one second node matched with the environmental parameters;
And respectively deploying the environment databases corresponding to the environment parameters on the first node and all the second nodes, and processing the compiling task by the first node and all the second nodes.
2. The method of claim 1, the environment parameters comprising a version parameter and a binding information parameter;
the determining at least one second node matching the environmental parameter includes:
Screening out a first node set consistent with the version parameter from a node database corresponding to the first node;
And obtaining the number of nodes based on the historical compiling time lengths respectively corresponding to all the files in the binding information parameters, and taking all the nodes in the first node set, which are consistent with the number of the nodes, as at least one second node.
3. The method of claim 2, further comprising, prior to said regarding all nodes in said first set of nodes that are consistent with said number of nodes as at least one second node:
acquiring the memory utilization rate corresponding to each node in the first node set;
obtaining a second node set based on all nodes with the memory utilization rate lower than a preset threshold value;
The step of using all nodes, the number of which is consistent with that of the nodes, in the first node set as at least one second node comprises the following steps:
and taking all nodes, the number of which is consistent with that of the nodes, in the second node set as at least one second node.
4. The method of claim 2, the processing of the compilation task by the first node and all of the second nodes, comprising:
converting configuration parameters corresponding to all files in the binding information parameters respectively to obtain corresponding compiling commands;
Arranging all the compiling commands according to a preset sequence to obtain a compiling queue, and acquiring a compiling request set corresponding to each compiling command in the compiling queue; the compiling request set comprises at least one compiling request corresponding to the second node and a compiling request corresponding to the first node;
Determining corresponding compiling objects based on compiling request sets corresponding to the compiling commands, and processing the corresponding compiling commands by each compiling object; each compiling object is the first node or any one of the second nodes, the first node corresponds to at least one compiling command, and each second node corresponds to at least one compiling command.
5. The method of claim 4, the processing of the compilation task by the first node and all of the second nodes further comprising:
When any one of the second nodes does not receive the heartbeat signal sent by the first node within a preset time interval, the second node is subjected to replacement processing on the first node, and the processed first node is used for processing the corresponding compiling command.
6. The method of claim 4, the processing of the compilation task by the first node and all of the second nodes further comprising:
when detecting that the compiling command corresponding to any one of the second nodes does not have a compiling result, processing the compiling command by the first node; or (b)
When any compiling command is detected to have error reporting information, the first node processes the compiling command and gathers the error reporting information.
7. The method of claim 4, further comprising, after the processing of the compilation task by the first node and all of the second nodes:
receiving the compiling results of all the second nodes and corresponding first hash values by the first node, and calculating the compiling results of each second node to obtain corresponding second hash values;
When any one of the first hash values is detected to be inconsistent with the corresponding second hash value, eliminating the compiling result corresponding to the first hash value, and processing the compiling command corresponding to the first hash value by the first node.
8. The method of claim 4, further comprising, after the processing of the compilation task by the first node and all of the second nodes:
And packaging the corresponding compiling result based on the file format in each compiling command.
9. A processing apparatus for compiling a task, comprising:
The first processing module is used for acquiring environmental parameters corresponding to the compiling task based on the first node and determining at least one second node matched with the environmental parameters;
And the second processing module is used for respectively deploying the environment databases corresponding to the environment parameters on the first node and all the second nodes, and processing the compiling task by the first node and all the second nodes.
10. The apparatus of claim 9, the environment parameters comprising a version parameter and a binding information parameter;
the first processing module is specifically configured to:
Screening out a first node set consistent with the version parameter from a node database corresponding to the first node;
And obtaining the number of nodes based on the historical compiling time lengths respectively corresponding to all the files in the binding information parameters, and taking all the nodes in the first node set, which are consistent with the number of the nodes, as at least one second node.
11. The apparatus of claim 10, the first processing module further to:
Before all nodes, the number of which is consistent with that of the nodes in the first node set, are used as at least one second node, the memory utilization rate corresponding to each node in the first node set is obtained;
obtaining a second node set based on all nodes with the memory utilization rate lower than a preset threshold value;
The step of using all nodes, the number of which is consistent with that of the nodes, in the first node set as at least one second node comprises the following steps:
and taking all nodes, the number of which is consistent with that of the nodes, in the second node set as at least one second node.
12. The apparatus of claim 10, the second processing module being specifically configured to:
converting configuration parameters corresponding to all files in the binding information parameters respectively to obtain corresponding compiling commands;
Arranging all the compiling commands according to a preset sequence to obtain a compiling queue, and acquiring a compiling request set corresponding to each compiling command in the compiling queue; the compiling request set comprises at least one compiling request corresponding to the second node and a compiling request corresponding to the first node;
Determining corresponding compiling objects based on compiling request sets corresponding to the compiling commands, and processing the corresponding compiling commands by each compiling object; each compiling object is the first node or any one of the second nodes, the first node corresponds to at least one compiling command, and each second node corresponds to at least one compiling command.
13. The apparatus of claim 12, the second processing module further to:
When any one of the second nodes does not receive the heartbeat signal sent by the first node within a preset time interval, the second node is subjected to replacement processing on the first node, and the processed first node is used for processing the corresponding compiling command.
14. The apparatus of claim 12, the second processing module further to:
when detecting that the compiling command corresponding to any one of the second nodes does not have a compiling result, processing the compiling command by the first node; or (b)
When any compiling command is detected to have error reporting information, the first node processes the compiling command and gathers the error reporting information.
15. The apparatus of claim 12, the apparatus further comprising:
after the compiling tasks are processed by the first node and all the second nodes, the first node receives compiling results of all the second nodes and corresponding first hash values, and calculates and processes the compiling results of each second node to obtain corresponding second hash values;
When any one of the first hash values is detected to be inconsistent with the corresponding second hash value, eliminating the compiling result corresponding to the first hash value, and processing the compiling command corresponding to the first hash value by the first node.
16. The apparatus of claim 12, the apparatus further comprising:
and after the compiling tasks are processed by the first node and all the second nodes, packaging the corresponding compiling results based on the file format in each compiling command.
17. An electronic device includes a processor and a memory;
the processor is connected with the memory;
The memory is used for storing executable program codes;
The processor runs a program corresponding to executable program code stored in the memory by reading the executable program code for performing the method according to any one of claims 1-8.
18. A computer readable storage medium having stored thereon a computer program having instructions stored therein, which when run on a computer or processor, cause the computer or processor to perform the steps of the method according to any of claims 1-8.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202410282682.3A CN117992067A (en) | 2024-03-12 | 2024-03-12 | Method and device for processing compiling task, electronic equipment and storage medium |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202410282682.3A CN117992067A (en) | 2024-03-12 | 2024-03-12 | Method and device for processing compiling task, electronic equipment and storage medium |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| CN117992067A true CN117992067A (en) | 2024-05-07 |
Family
ID=90890605
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202410282682.3A Pending CN117992067A (en) | 2024-03-12 | 2024-03-12 | Method and device for processing compiling task, electronic equipment and storage medium |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN117992067A (en) |
-
2024
- 2024-03-12 CN CN202410282682.3A patent/CN117992067A/en active Pending
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN108628661B (en) | Automatic establishment method of cloud manufacturing service and cloud manufacturing system | |
| US20210365347A1 (en) | Load test framework | |
| EP3616066B1 (en) | Human-readable, language-independent stack trace summary generation | |
| US9858045B2 (en) | Designer tool for managing cloud computing services | |
| US8918760B2 (en) | Test script generation for application image validation | |
| CN110134400A (en) | Data capture method, device, electronic equipment and computer readable storage medium | |
| US20170123777A1 (en) | Deploying applications on application platforms | |
| WO2023061874A1 (en) | Checking source code validity at time of code update | |
| CN109189758B (en) | Operation and maintenance flow design method, device and equipment, operation method, device and host | |
| CN111258913A (en) | Automatic algorithm testing method and device, computer system and readable storage medium | |
| CN105868311A (en) | Data analyzing method and device | |
| CN112596876A (en) | Task scheduling method, device and related equipment | |
| CN115698941A (en) | Efficient packaging of components | |
| US20150006736A1 (en) | Method and System for Deploying and Modifying a Service-Oriented Architecture Deployment Environment | |
| CN112527459B (en) | Log analysis method and device based on Kubernetes cluster | |
| CN117370203A (en) | Automatic test method, system, electronic equipment and storage medium | |
| CN103176903B (en) | The test method and equipment of MapReduce distributed system program | |
| Boucher et al. | Transforming workflow models into automated end-to-end acceptance test cases | |
| CN117992067A (en) | Method and device for processing compiling task, electronic equipment and storage medium | |
| CN110362294A (en) | Development task executes method, apparatus, electronic equipment and storage medium | |
| US20200183737A1 (en) | Coordinating processes with interfering external actions | |
| CN115237441A (en) | Upgrade test method, device and medium based on cloud platform | |
| CN110727565A (en) | Network equipment platform information collection method and system | |
| CN112463596B (en) | Test case data processing method, device and equipment and processing equipment | |
| CN114356396A (en) | Service publishing method and device adaptive to multiple services |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination |