Resource control method, device and system

Abstract

The embodiment of the present application provides a resource control method, device and system, wherein the system includes multiple control nodes, multiple scheduling nodes connected to each control node, and a request node connected to each scheduling node; each machine node is connected to a control node; the request node receives pending jobs submitted by users and requests the first scheduling node to schedule the pending jobs; the first scheduling node creates a job manager for the pending jobs; determines the first machine node with available resources, and allocates the machine resources in the first machine node to the pending jobs; sends the resource allocation result of the first machine node to the corresponding first control node; receives the allocation success message fed back by the first control node, and sends the allocation success notification to the job manager. The technical solution provided by the embodiment of the present application ensures the normal processing of jobs and improves the utilization rate of cluster resources.

Description

Technical Field

[0001] The embodiments of the present application relate to the field of distributed processing technology, and in particular, to a resource control method, device and system. Background Art

[0002] Current job processing systems are usually implemented using a distributed architecture, where machine nodes are responsible for providing machine resources. Each machine resource can run a job node, and jobs submitted by users can be assigned to multiple job nodes for execution, thus achieving distributed processing.

[0003] In order to facilitate resource management, in the existing distributed job processing system, the resource manager performs resource scheduling and the job manager is responsible for the management and control of the job nodes. Specifically, the resource manager is responsible for receiving pending jobs submitted by users and creating a job manager in the machine node; the job manager applies for a certain number of machine resources from the resource manager based on the pending jobs; the resource manager allocates resources based on the available resources of different machine nodes, and feeds back the resource allocation results (how many machine resources are allocated to different machine nodes, etc.) to the job manager; the job manager creates a job node in the corresponding machine node based on the resource allocation result to execute the job.

[0004] From the above description, we can see that the resource manager is responsible for resource management and scheduling. In actual applications, there are often many jobs, but the performance of the resource manager is limited, which will affect job processing and reduce cluster resource utilization. Summary of the invention

[0005] Embodiments of the present application provide a resource control method, device, and system.

[0006] In a first aspect, an embodiment of the present application provides a resource control system, comprising a plurality of control nodes, a plurality of scheduling nodes connected to each control node, and a request node connected to each scheduling node; wherein each machine node is connected to a control node;

[0007] The requesting node is used to receive the pending job submitted by the user, and request the first scheduling node to schedule the pending job;

[0008] The first scheduling node is used to create a job manager for the job to be processed; determine a first machine node with available resources, and allocate machine resources in the first machine node to the job to be processed; send the resource allocation result of the first machine node to the corresponding first control node; receive an allocation success message fed back by the first control node, and send an allocation success notification to the job manager, so that the job manager can create a job node in the first machine node;

[0009] The first control node is used to receive the resource allocation result of the first machine node; determine whether the first machine node is allowed to allocate resources; if the resource allocation is allowed, feedback an allocation success message to the first scheduling node.

[0010] In a second aspect, an embodiment of the present application provides a resource control method, which is applied to a resource control system, wherein the resource control system includes a plurality of control nodes, a plurality of scheduling nodes connected to each control node, and a request node connected to each scheduling node; wherein each machine node is connected to a control node;

[0011] The method comprises:

[0012] Receive pending jobs submitted by users;

[0013] Determining a first scheduling node from a plurality of scheduling nodes;

[0014] Send a scheduling processing request to the first scheduling node so that the first scheduling node creates a job manager for the job to be processed, determines a first machine node with available resources, allocates machine resources in the first machine node to the job to be processed, and sends the resource allocation result of the first machine node to the corresponding first control node, receives an allocation success message fed back by the first control node, and sends an allocation success notification to the job manager so that the job manager can create a job node in the first machine node; wherein the first control node is used to determine whether the first machine node allows resource allocation, and if so, feeds back an allocation success message to the first scheduling node.

[0015] In a third aspect, an embodiment of the present application provides a resource control method, which is applied to a resource control system, wherein the resource control system includes a plurality of control nodes, a plurality of scheduling nodes connected to each control node, and a request node connected to each scheduling node; wherein each machine node is connected to a control node;

[0016] The method comprises:

[0017] Receiving a scheduling processing request sent by the requesting node; wherein the scheduling processing request is sent by the requesting node after receiving a pending job submitted by a user;

[0018] Creating a job manager for the job to be processed;

[0019] Determine a first machine node with available resources, and allocate machine resources in the first machine node to the job to be processed;

[0020] Sending the resource allocation result of the first machine node to the corresponding first control node;

[0021] Receive an allocation success message fed back by the first control node, and send an allocation success notification to the job manager so that the job manager can create a job node in the first machine node; wherein the first control node is used to determine whether the first machine node allows resource allocation, and if so, feed back an allocation success message.

[0022] In a fourth aspect, an embodiment of the present application provides a resource control method, which is applied to a resource control system, wherein the resource control system includes a plurality of control nodes, a plurality of scheduling nodes connected to each control node, and a request node connected to each scheduling node; wherein each machine node is connected to a control node;

[0023] The method comprises:

[0024] Receive a resource allocation result of a first machine node sent by a first scheduling node; wherein the resource allocation result is obtained by allocating machine resources in the first machine node to the job to be processed after the first scheduling node determines that the first machine node has available resources; the job to be processed is received by the requesting node and requests the first scheduling node to perform scheduling processing;

[0025] Determining whether the first machine node allows resource allocation;

[0026] If resource allocation is allowed, an allocation success message is fed back to the first scheduling node, so that the first scheduling node can send an allocation success notification to the job manager.

[0027] In a fifth aspect, an embodiment of the present application provides a resource control device, including:

[0028] A job receiving module is used to receive jobs to be processed submitted by users;

[0029] A node determination module, used to determine a first scheduling node from a plurality of scheduling nodes;

[0030] A request processing module, used to send a scheduling processing request to the first scheduling node, so that the first scheduling node creates a job manager for the job to be processed, determines a first machine node with available resources, allocates machine resources in the first machine node to the job to be processed, and sends the resource allocation result of the first machine node to the corresponding first control node, receives an allocation success message fed back by the first control node, and sends an allocation success notification to the job manager so that the job manager can create a job node in the first machine node; wherein the first control node is used to determine whether the first machine node allows resource allocation, and if so, feeds back an allocation success message to the first scheduling node.

[0031] In a sixth aspect, an embodiment of the present application provides a resource control device, including:

[0032] A request receiving module, used to receive a scheduling processing request sent by the requesting node; wherein the scheduling processing request is sent by the requesting node after receiving a pending job submitted by a user and determining a first scheduling node;

[0033] A creation module, used for creating a job manager for the job to be processed;

[0034] A resource allocation module, configured to determine a first machine node having available resources, and allocate machine resources in the first machine node to the job to be processed;

[0035] A result sending module, used for sending the resource allocation result of the first machine node to the corresponding first control node;

[0036] A notification module is used to receive an allocation success message fed back by the first control node, and send an allocation success notification to the job manager so that the job manager can create a job node in the first machine node; wherein the first control node is used to determine whether the first machine node allows resource allocation, and if so, feed back an allocation success message.

[0037] In a seventh aspect, an embodiment of the present application provides a resource control device, including:

[0038] A result receiving module is used to receive a resource allocation result of a first machine node sent by a first scheduling node; wherein the resource allocation result is obtained by allocating machine resources in the first machine node to the job to be processed after the first scheduling node determines that the first machine node has available resources; and the job to be processed is received by a requesting node and requests the first scheduling node to perform scheduling processing;

[0039] A resource determination module, used to determine whether the first machine node is allowed to allocate resources;

[0040] The result feedback module is used to feed back an allocation success message to the first scheduling node if resource allocation is allowed, so that the first scheduling node can send an allocation success notification to the job manager.

[0041] In an eighth aspect, an embodiment of the present application provides a computing device, including a processing component and a storage component;

[0042] The storage component stores one or more computer instructions; the one or more computer instructions are used to be called and executed by the processing component;

[0043] The processing component is used to:

[0044] Receive pending jobs submitted by users;

[0045] Determining a first scheduling node from a plurality of scheduling nodes;

[0046] Send a scheduling processing request to the first scheduling node so that the first scheduling node creates a job manager for the job to be processed, determines a first machine node with available resources, allocates machine resources in the first machine node to the job to be processed, and sends the resource allocation result of the first machine node to the corresponding first control node, receives an allocation success message fed back by the first control node, and sends an allocation success notification to the job manager so that the job manager can create a job node in the first machine node; wherein the first control node is used to determine whether the first machine node allows resource allocation, and if so, feeds back an allocation success message to the first scheduling node.

[0047] In a ninth aspect, an embodiment of the present application provides a computing device, including a processing component and a storage component;

[0048] The storage component stores one or more computer instructions; the one or more computer instructions are used to be called and executed by the processing component;

[0049] The processing component is used to:

[0050] Receiving a scheduling processing request sent by the requesting node; wherein the scheduling processing request is sent by the requesting node after receiving a pending job submitted by a user and determining a first scheduling node;

[0051] Creating a job manager for the job to be processed;

[0052] Determine a first machine node with available resources, and allocate machine resources in the first machine node to the job to be processed;

[0053] Sending the resource allocation result of the first machine node to the corresponding first control node;

[0054] Receive an allocation success message fed back by the first control node, and send an allocation success notification to the job manager so that the job manager can create a job node in the first machine node; wherein the first control node is used to determine whether the first machine node allows resource allocation, and if so, feed back an allocation success message.

[0055] In a tenth aspect, an embodiment of the present application provides a computing device, including a processing component and a storage component;

[0056] The storage component stores one or more computer instructions; the one or more computer instructions are used to be called and executed by the processing component;

[0057] The processing component is used to:

[0058] Receive a resource allocation result of a first machine node sent by a first scheduling node; wherein the resource allocation result is obtained by allocating machine resources in the first machine node to the job to be processed after the first scheduling node determines that the first machine node has available resources; the job to be processed is received by the requesting node and requests the first scheduling node to perform scheduling processing;

[0059] Determining whether the first machine node allows resource allocation;

[0060] If resource allocation is allowed, an allocation success message is fed back to the first scheduling node, so that the first scheduling node can send an allocation success notification to the job manager.

[0061] In an embodiment of the present application, a resource control system is provided, which is composed of multiple control nodes, multiple scheduling nodes connected to each control node, and a request node connected to each scheduling node; wherein each machine node is connected to a control node, and each control node is connected to at least one machine node; the control node is responsible for interactive control with the machine node, and the scheduling node is responsible for interactive control with the job manager, so as to avoid the problem of using a single resource manager for resource scheduling processing, resulting in insufficient performance and affecting job processing, so that cluster resources cannot be utilized. Therefore, the technical solution of the embodiment of the present application is adopted to ensure the normal processing of jobs and improve the utilization rate of cluster resources.

[0062] These and other aspects of the present application will become more clearly understood in the description of the following embodiments. BRIEF DESCRIPTION OF THE DRAWINGS

[0063] In order to more clearly illustrate the embodiments of the present application or the technical solutions in the prior art, a brief introduction will be given below to the drawings required for use in the embodiments or the description of the prior art. Obviously, the drawings described below are some embodiments of the present application. For ordinary technicians in this field, other drawings can be obtained based on these drawings without paying any creative work.

[0064] Figure 1 A schematic diagram of the structure of a job processing system in the prior art is shown;

[0065] Figure 2 A schematic diagram showing the structure of an embodiment of a resource control system provided by the present application is shown;

[0066] Figure 3A schematic diagram showing the structure of an embodiment of a job processing system provided by the present application is shown;

[0067] Figure 4 A flow chart of an embodiment of a resource control method provided by the present application is shown;

[0068] Figure 5 A flow chart showing another embodiment of a resource control method provided by the present application;

[0069] Figure 6 A flow chart showing another embodiment of a resource control method provided by the present application;

[0070] Figure 7 A schematic diagram showing the structure of an embodiment of a resource control device provided by the present application is shown;

[0071] Figure 8 A schematic diagram showing the structure of an embodiment of a computing device provided by the present application is shown;

[0072] Fig. 9 A schematic diagram showing the structure of an embodiment of a resource control device provided by the present application is shown;

[0073] Fig.10 A schematic diagram showing the structure of an embodiment of a computing device provided by the present application is shown;

[0074] Fig.11 A schematic diagram showing the structure of an embodiment of a resource control device provided by the present application is shown;

[0075] Fig.12 Shows a schematic diagram of the structure of an embodiment of a computing device provided by the present application. DETAILED DESCRIPTION

[0076] In order to enable those skilled in the art to better understand the solution of the present application, the technical solution in the embodiments of the present application will be clearly and completely described below in conjunction with the drawings in the embodiments of the present application.

[0077] In some of the processes described in the specification and claims of this application and the above-mentioned figures, multiple operations that appear in a specific order are included, but it should be clearly understood that these operations may not be executed in the order in which they appear in this article or executed in parallel. The serial numbers of the operations, such as 101, 102, etc., are only used to distinguish between different operations, and the serial numbers themselves do not represent any execution order. In addition, these processes may include more or fewer operations, and these operations may be executed in sequence or in parallel. It should be noted that the descriptions of "first", "second", etc. in this article are used to distinguish different messages, devices, modules, etc., do not represent the order of precedence, and do not limit the "first" and "second" to be different types.

[0078] The technical solution of the embodiment of the present application is mainly applied to a distributed job processing system to implement resource scheduling management in the job processing system.

[0079] Here, a job refers to a task submitted to a computer processing system to request the computer system to perform corresponding work. For example, in actual applications, a job may refer to a MySQL query task.

[0080] Figure 1 It is a schematic diagram of the structure of the job processing system in the prior art, combined with Figure 1 It can be seen that the job processing system may include a resource manager 101, a job manager 102, and a job node 103, etc., wherein the resource manager 101 is deployed in a physical machine for execution, and the job manager 102 and the job node 103 are both deployed in a machine node 104, and the machine node 104 is used to provide physical resources, such as CPU and memory, etc. The machine node 104 includes multiple machine nodes, and one or more job nodes can be deployed in one machine node 104. The resource manager 101, the job manager 102, and the job node 103 may specifically refer to processes running in a physical device.

[0081] The resource manager 101 receives the pending job submitted by the user, and can create a job manager 102 in a machine node 104 with available resources, and submit the pending job to the job manager 102 for processing. The job manager 102 can determine the number of job nodes that need to be executed based on the pending job, and can determine the required number of resource copies. Each resource can run a job node. A resource can include, for example, a 2-core CPU and 2GB of memory, etc. Therefore, the job manager 102 can apply for the required number of resources from the resource manager 101; the resource manager 101 allocates resources based on the available resources of different machine nodes, and feeds back the resource allocation results (how many machine resources are allocated in different machine nodes, etc.) to the job manager 102, and can determine the number of resource allocation copies in a machine node; the job manager 102 creates a job node 103 in the corresponding machine node based on the resource allocation result to execute the job.

[0082] Since there are often many jobs in actual applications, as the cluster size and the number of user requests grow, the processing performance of the resource manager is limited, which will affect job processing and make cluster resources not effectively utilized, resulting in a waste of cluster resources.

[0083] In order to ensure normal processing of jobs and improve cluster resource utilization, the inventor has proposed the technical solution of the present application after a series of studies. The embodiment of the present application provides a resource control system that uses a distributed method to perform resource scheduling to improve resource scheduling performance, ensure normal processing of jobs, and improve cluster resource utilization.

[0084] The following will be combined with the drawings in the embodiments of the present application to clearly and completely describe the technical solutions in the embodiments of the present application. Obviously, the described embodiments are only part of the embodiments of the present application, not all of the embodiments. Based on the embodiments in the present application, all other embodiments obtained by those skilled in the art without creative work are within the scope of protection of this application.

[0085] The present application embodiment provides a resource control system, such as Figure 2 As shown in , the resource control system may include multiple control nodes 201, multiple scheduling nodes 202 connected to each control node 201, and a request node 203 connected to each scheduling node 202; wherein each machine node is connected to a control node 203, and each control node 203 is connected to at least one machine node.

[0086] The request node 203 is used to receive the pending job submitted by the user, and request the first scheduling node 2021 to schedule the pending job;

[0087] The first scheduling node 2021 is used to create a job manager for the job to be processed; determine a first machine node with available resources, and allocate machine resources in the first machine node to the job to be processed; send the resource allocation result of the first machine node to the corresponding first control node 2011; receive an allocation success message fed back by the first control node 2011, and send an allocation success notification to the job manager, so that the job manager can create a job node in the first machine node;

[0088] The first control node 2011 is used to receive the resource allocation result of the first machine node; determine whether the first machine node is allowed to allocate resources; if the resource allocation is allowed, feedback an allocation success message to the first scheduling node 2021.

[0089] Among them, the first scheduling node can be a resource allocation application that receives the job manager; the resource allocation application can include the number of resource application copies and the number of resources contained in each resource copy; the first scheduling node can determine the number of resource allocation copies required in each machine node based on the number of resource application copies, and obtain the resource allocation result for each machine node.

[0090] Therefore, optionally, the first scheduling node allocating machine resources in the first machine node to the job to be processed may include:

[0091] Determine the number of resource allocation shares in the first machine node; and generate a resource allocation result for the first machine node based on the number of resource allocation shares.

[0092] The first machine node may be any machine node having available resources, and the resource allocation result may include the number of resource allocation shares.

[0093] In addition, after the first control node determines that resource allocation is allowed in the first machine node based on the resource allocation result, the resource allocation result can be passed to the first machine node so that the first machine node can prepare the number of resource allocation shares in the resource allocation result.

[0094] Among them, since each scheduling node knows the remaining resources of all machine nodes, it selects available resources from all machine nodes when allocating resources. Therefore, based on the jobs received by each scheduling node, multiple scheduling nodes may allocate resources to the same machine node. In order to ensure successful resource allocation, the resource allocation result of each scheduling node for each machine node needs to be submitted to the control node for arbitration. Therefore, the first control node receives the resource allocation result of the first machine node and determines whether the first machine node is allowed to allocate resources.

[0095] Optionally, the first control node determining whether the first machine node is allowed to allocate resources may include:

[0096] According to the resource allocation results of different jobs for the first machine node sent by different scheduling nodes, it is determined whether the submission time of the pending job is the earliest, and if so, it is determined to allow resource allocation. Otherwise, the machine resources of the first machine node are allocated to the job with the earliest submission time.

[0097] In this embodiment, the resource control system provided is responsible for performing resource scheduling in the job processing system, the control node is responsible for interactive control with the machine node, and the scheduling node is responsible for interactive control with the job manager, so as to avoid using a single resource manager for resource scheduling, resulting in insufficient performance and affecting job processing, so that cluster resources cannot be utilized. Therefore, the resource control system of this embodiment can ensure the normal processing of jobs and improve the utilization rate of cluster resources. Even if the cluster scale increases, only the corresponding scheduling nodes and control nodes need to be added, which is convenient for expansion.

[0098] The resource control system of the embodiment of the present application is applied to the job processing system and is responsible for resource scheduling. Therefore, the job processing system provided by the embodiment of the present application can be as follows: Figure 3 As shown in Figure 2 The resource control system shown is composed of a job manager 20 and a job node 30.

[0099] The resource control system is composed of multiple control nodes 101, multiple scheduling nodes 102 connected to each control node 101, and request nodes 103 connected to each scheduling node 102; wherein each machine node 10 is connected to a control node 103, and each control node 103 is connected to at least one machine node 10.

[0100] Combination Figure 2 As can be seen from the description, after the request node 20 receives the pending job submitted by the user, it requests the first scheduling node 2021 to schedule the pending job; the first scheduling node 2021 creates a job manager 20 for the pending job; determines that a first machine node 11 has available resources, and allocates machine resources in the first machine node 11 to the pending job.

[0101] After determining that the first machine node 11 is allowed to allocate resources, the job manager 20 may create a job node 30 in the first machine node 11 .

[0102] Of course, the job manager 20 may also create one or more job nodes in other machine nodes based on the resource allocation result of the first scheduling node to other machine nodes.

[0103] In certain embodiments, such as Figure 2 As well as Figure 3 As shown in , the resource control system may also include a coordination node 204;

[0104] The coordination node 204 is used to obtain the load status of each machine node reported by the multiple scheduling nodes 202; according to the load status of any machine node, notify the multiple scheduling nodes 202 whether to allow resource allocation to any machine node;

[0105] The first scheduling node 2021 determines that the first machine node has available resources, including determining that the first machine node has available resources and is in an allocation-allowed state.

[0106] That is, each control node can report the load status of each machine node connected to it to each scheduling node, and then each scheduling node synchronizes the load status of each machine node to the coordination node.

[0107] In some embodiments, the coordination node may also be used to determine at least one machine node according to the scheduling request of the first scheduling node, and notify other scheduling nodes excluding the first scheduling node to suspend resource allocation to the at least one machine node.

[0108] The scheduling request may include a machine identification of the at least one machine node, etc.

[0109] For example, when the job to be processed is more important, the first scheduling node needs to preferentially allocate machine resources on certain machine nodes, so the first scheduling node can initiate a scheduling request to the coordination node to request preferential allocation of machine resources on certain machine nodes.

[0110] Optionally, the coordination node may also be used to receive a user viewing request and output the load status of the machine node requested to be viewed.

[0111] In some embodiments, the requesting node requesting the first scheduling node to schedule the pending job includes:

[0112] According to the load conditions of different scheduling nodes, a first scheduling node whose load pressure meets the scheduling conditions is determined; and the first scheduling node is requested to schedule the pending job.

[0113] The dispatching condition may, for example, refer to a load pressure being less than a preset pressure value.

[0114] In some embodiments, the first scheduling node is further used to generate a resource recovery result according to the number of resource recovery copies for the job to be processed in the first machine node; and send the resource recovery result to the first control node;

[0115] The first control node is further configured to request the first machine node to release corresponding resources according to the resource recovery result, and to feed back a recovery success message to the first scheduling node;

[0116] The first scheduling node is further used to receive a recycling success message fed back by the first control node, and send a recycling success notification to the job manager so that the job manager ends the job task executed by the job node running in the recycling resource.

[0117] During the process of running a job node on a machine node, it may be necessary to recycle part or all of the machine resources due to machine failure or other reasons. At this time, a resource recovery result may be generated based on the number of resource recovery copies for the job to be processed in the first machine node; the resource recovery result may include the number of resource recovery copies.

[0118] After the job manager receives the notification of successful recycling, the job manager may re-initiate a resource allocation application based on the job tasks executed by the job node running the recycled resources.

[0119] In some embodiments, the first scheduling node is further configured to receive a resource return request sent by the job manager to the first machine node; generate a resource return result according to the number of resource return copies in the resource return request; and send the resource return result to the first control node;

[0120] The first control node is further configured to request the first machine node to release corresponding resources according to a resource return result of the first machine node, and to feed back a return success message to the first scheduling node.

[0121] The resource return request may be generated when the job manager detects that the execution of a job task in at least one job node ends.

[0122] Among them, when the first scheduling node allocates resources for the job to be processed, if the currently available machine resources are insufficient, only part of the machine resources can be allocated to run some job nodes to perform part of the job tasks, etc., and the machine resources of each machine node are detected. If there are machine nodes with available resources, resources will be allocated to run other job nodes that execute the job to be processed.

[0123] In the embodiment of the present application, the first scheduling node determines that the first machine node with available resources can be detected immediately after receiving the resource allocation application from the job manager, or detected during the execution of the job to be processed; or detected after receiving the resource allocation application re-initiated by the job manager, etc.

[0124] In combination with the above description, it can be known that the resource allocation result of the first machine node is sent to the first control node. The first control node may contain the resource allocation result of the first machine node that was previously allocated for the job to be processed and has not been processed. At this time, all resource allocation results for the first machine node can be accumulated and then processed comprehensively.

[0125] Therefore, in some embodiments, the first scheduling node sending the resource allocation result of the first machine node to the first control node includes: updating the resource allocation record corresponding to the to-be-processed job in the first machine node based on the resource allocation result of the first machine node; sending the resource allocation record to the first control node;

[0126] The first control node is specifically used to determine whether resource allocation is allowed according to the resource allocation record; if resource allocation is allowed, feeding back an allocation success message to the first scheduling node;

[0127] The first scheduling node receives the allocation success message of the first control node, and sends the allocation success notification to the job manager, including: receiving the allocation success message of the first control node, updating the allocated record of the pending job for the first machine node based on the number of successfully allocated resources, and clearing the number of successfully allocated resources in the resource allocation record; based on the allocated record, sending an allocation success notification to the job manager, and clearing the allocated record. The allocation success notification may include the number of allocated resources in the allocated record. The allocation success message may include the number of successfully allocated resources.

[0128] That is, the first scheduling node can record the resource scheduling status in different machine nodes for the pending job, including the resource allocation record, which can record the number of resource copies to be confirmed and allocated and to be sent to the first control node. If there is a resource allocation record corresponding to the pending job in the first machine node, the resource allocation record can be updated based on the resource allocation result of the first machine node. The resource allocation result includes the number of resource allocation copies. Assume that there is 1 machine resource, and the resource allocation record corresponding to the pending job in the first machine node records 1 machine resource. After the update, the resource allocation record will record 2 machine resources. Of course, if there is no resource allocation record corresponding to the pending job in the first machine node, the resource allocation record corresponding to the pending job in the first machine node can be generated based on the resource allocation result based on the first machine node.

[0129] The resource allocation record may be stored in a resource allocation field, and the resource allocation field will be represented by a string “toCommitAssign” in the following text.

[0130] The first control node sends the resource allocation record, so that the first control node determines whether to allow resource allocation based on the number of resource shares in the resource allocation record.

[0131] The first scheduling node receives the allocation success message from the first control node, and can determine that the resource allocation is successful. At this time, the number of successfully allocated resources in the resource allocation record can be cleared. For example, if 5 resources are recorded in the resource allocation record, if 4 are successfully allocated, the resource allocation record becomes 1 resource. That is, the number of successfully allocated resources in "toCommitAssign" is transferred to the allocated record.

[0132] The first scheduling node may receive multiple allocation success messages for the first machine node corresponding to the pending job, and some allocation success messages may not have been notified to the job manager. Therefore, the first scheduling node records the resource scheduling status in different machine nodes for the pending job, and may also include an allocated record, which records the number of allocated resources that the first control node has confirmed to allocate. Therefore, the first scheduling node may first update the allocated record after receiving the allocation success message. Of course, if there is no allocated record corresponding to the pending job in the first machine node, the allocated record corresponding to the pending job in the first machine node may be generated based on the resource allocation record of the first machine node.

[0133] The assigned records may be stored in the assigned field, and the string "toAssign" will be used to represent the assigned field in the following text.

[0134] The first scheduling node may send an allocation success notification to the job manager based on the allocated record, and after sending the allocation success notification, clear the allocated record, that is, clear "toAssign".

[0135] Furthermore, in some embodiments, the first scheduling node records resource scheduling conditions in different machine nodes for the job to be processed, and may also include resource recycling records.

[0136] The first scheduling node sending the resource recovery result of the first machine node to the first control node may include:

[0137] Based on the resource recovery result of the first machine node, updating the resource recovery record corresponding to the to-be-processed job in the first machine node; and sending the resource recovery record to the first control node;

[0138] The first control node is specifically used to request the first machine node to release corresponding resources according to the resource recovery record, and feedback a recovery success message to the first scheduling node;

[0139] The first scheduling node receives the recovery success message and sends a recovery success notification to the job manager, including: receiving the recovery success message from the first control node, updating the recovered record corresponding to the pending job in the first machine node based on the number of successfully recovered resources, and clearing the number of successfully recovered resources in the resource recovery record; based on the recovered record, sending a recovery success notification to the job manager, and clearing the recovered record. The allocation success notification may include the number of recovered resources in the recovered record. The recovery success message includes the number of successfully recovered resources.

[0140] Of course, if there is no resource recovery record corresponding to the pending job in the first machine node, a resource recovery record corresponding to the pending job in the first machine node may be generated based on the resource recovery result of the first machine node.

[0141] The resource recycling result includes the number of resource recycling copies, so the resource recycling record also records the number of resource copies to be sent to the first control node and to be confirmed for recycling.

[0142] Among them, the resource recovery record can be guaranteed to be in the resource recovery field, and the following part will use the string "toCommitRevoke" to represent the resource recovery field.

[0143] The first control node sends the resource recycling record, so that the first control node requests the first machine node to release the corresponding machine resources based on the number of resource shares in the resource recycling record.

[0144] When the first scheduling node receives the recovery success message from the first control node, it can be considered that the resource recovery is successful. At this time, the number of successfully recovered resources in the resource recovery record can be cleared, that is, the number of successfully recovered resources in the "toCommitRevoke" field can be transferred to the allocated record.

[0145] The first scheduling node may receive multiple recovery success messages for the first machine node corresponding to the pending job, and some recovery success messages may not have been notified to the job manager. Therefore, the first scheduling node records the resource scheduling status in different machine nodes for the pending job, and may also include a recovered record, which records the number of recovered resources that the first control node has confirmed to recover. Therefore, the first scheduling node may first update the recovered record after receiving the recovery success message. Of course, if there is no recovered record corresponding to the pending job in the first machine node, then the recovered record corresponding to the pending job in the first machine node may be generated based on the resource recovery record of the first machine node.

[0146] Among them, the recycled records can be saved in the allocated field, and the string "toRelease" will be used to represent the recycled field in the following part.

[0147] The first scheduling node may send a recycling success notification to the job manager based on the recycled record, and after sending the recycling success notification, clear the recycled record, that is, clear the "toRelease" field.

[0148] Furthermore, in some embodiments, the first scheduling node records resource scheduling status in different machine nodes for the job to be processed, and may also include resource return records.

[0149] The first scheduling node sending the resource return result to the first control node may include: updating the resource return record corresponding to the to-be-processed job in the first machine node based on the resource return result of the first machine node; sending the resource return record to the first control node;

[0150] The first control node is specifically used to request the first machine node to release corresponding resources according to the resource return record, and feed back a return success message to the first scheduling node;

[0151] The first scheduling node is further configured to receive the successful return message and clear the number of successfully returned resource shares in the resource return record. The successful return message may include the number of successfully returned resource shares.

[0152] The resource return record may record the number of resource copies to be sent to the first control node and to be confirmed to be returned. If there is a resource return record corresponding to the pending job in the first machine node, of course, if there is no resource return record corresponding to the pending job in the first machine node, then the resource return record corresponding to the pending job in the first machine node may be generated based on the resource return result of the first machine node.

[0153] The resource return record may be stored in a resource return field, and the resource return field will be represented by a string "toCommitReturn" in the following text.

[0154] Then, what the first control node sends is specifically the resource return record, so that the first control node requests the first machine node to release the corresponding resources based on the number of resource shares in the resource return record.

[0155] The first scheduling node receives the return success message from the first control node, and can determine that the number of resource copies recorded in the resource return record has been successfully returned. At this time, the number of successfully returned resource copies in the resource return record can be cleared. Since the machine resources requested to be returned by the job manager will definitely be returned successfully, there is no need to notify the job manager of the resource return status.

[0156] In addition, since resource allocation results, resource recovery results and resource return results may be generated in the first scheduling node, in some embodiments, the first scheduling node can also be used to update the resource scheduling record of the to-be-processed job for the first machine node based on the resource allocation results, the resource recovery results and the resource return results.

[0157] The resource scheduling record may record the total number of resource allocations of the to-be-processed job in the first machine node.

[0158] The resource allocation results will be accumulated in the resource scheduling record, and the resource recovery record and resource return results will be cleared from the resource scheduling record.

[0159] The resource scheduling record may be stored in a resource scheduling field, and the resource return field will be represented by a string "RunningQueue" in the following text.

[0160] Combined with the above description, it can be known that the first scheduling node can record the resource scheduling status of the job to be processed in the first machine node by the following fields:

[0161] Resource scheduling field: RunningQueue indicates that it is used to save resource scheduling records, that is, the total number of resource allocations of the job to be processed in the first machine node;

[0162] Resource allocation field: toCommitAssign indicates that it is used to save resource allocation records, that is, the number of resource shares to be confirmed and allocated and ready to be sent to the first control node;

[0163] Resource recovery field: toCommitRevoke indicates that it is used to save resource recovery records, that is, the number of resource copies to be confirmed for recovery and to be sent to the first control node;

[0164] Resource return field: toCommitReturn indicates that it is used to save resource return records, that is, the number of resource copies to be sent to the first control node for confirmation of return;

[0165] Allocated field: toAssign indicates that it is used to save the allocated record, that is, the number of allocated resource shares that the first control node has confirmed to allocate;

[0166] Recycled field: toRelease indicates that it is used to save recycled records, that is, the number of recycled resources that the first control node has confirmed to be recycled.

[0167] If the first scheduling node finds that toCommitAssign is not empty, it will send the resource allocation record in toCommitAssign to the first machine node; if it finds that toCommitRevoke is not empty, it will send the resource recovery record in toCommitRevoke to the first machine node; if it finds that toCommitReturn is not empty, it will send the resource return record in toCommitReturn to the first machine node.

[0168] If the first scheduling node receives an allocation success message, it transfers the number of resources successfully allocated in toCommitAssign to toAssign; if it receives a recovery success message, it transfers the number of resources successfully recovered in toCommitRevoke to toRelease;

[0169] If the first scheduling node finds that toAssign is not empty, it will send an assignment success notification to the job manager; if it finds toRelease, it will send a recycling success notification to the job manager.

[0170] From the interactive process described above when performing resource allocation, resource recovery and resource return, it can be known that resource allocation, resource recovery and resource return may occur simultaneously in the first machine node for the pending job, and resource allocation, resource recovery and resource return include operations such as sending records to the first control node, receiving arbitration messages from the first control node, and sending notifications to the job manager. Some operations may overlap and easily cause conflict events, which may increase the number of interactions and lead to resource waste. In order to reduce conflict events and avoid resource waste while ensuring accurate resource scheduling, several possible situations will be described below.

[0171] In one possible implementation:

[0172] The first scheduling node sending the resource allocation record to the first control node may include:

[0173] Determining whether there is a resource recovery record for the to-be-processed job for the first machine node;

[0174] If yes, if the resource recovery record is not sent to the first scheduling node and the number of resource recovery shares in the resource recovery record is greater than the number of resource allocation shares in the resource allocation record, clear the resource allocation record, and update the resource recovery record based on the resource allocation number; if the resource recovery record is not sent to the first scheduling node and the number of resource recovery shares in the resource recovery record is less than the number of resource allocation shares in the resource allocation record, clear the resource allocation record, and update the resource allocation record based on the resource recovery number, and send the updated resource allocation record to the first control node; if the resource recovery record is not sent to the first scheduling node and the number of resource recovery shares in the resource recovery record is equal to the number of resource allocation shares in the resource allocation record, clear the resource allocation record and the resource recovery record;

[0175] If not, sending the resource allocation record to the first control node.

[0176] That is, the first scheduling node obtains the resource allocation result, and can first update RunningQueue and toCommitAssign. When preparing to send the resource allocation record in toCommitAssign to the first control node, if it is found that toCommitRevoke is not empty and has not been sent to the first scheduling node, for the first scheduling node, if the number of resource recovery copies in toCommitRevoke is greater than the number of resource allocation copies in toCommitAssign, toCommitAssign can be cleared. Since toCommitAssign is empty, there is no need to send the resource allocation record to the first control node, that is, there is no need to allocate. And based on the number of resource allocation copies, toCommitRevoke is updated, that is, the original number of resource recovery copies in toCommitRevoke is subtracted from the number of resource allocation copies for updating.

[0177] If the number of resource recovery shares is less than the number of resource allocation shares, toCommitRevoke can be cleared. Since toCommitRevoke is empty, there is no need to send a resource recovery record to the first control node, that is, there is no need to perform recovery. Based on the number of resource recovery shares, toCommitAssign is updated, that is, the original resource allocation data in toCommitAssign is subtracted from the number of resource recovery shares for update.

[0178] If the number of resource recovery copies is equal to the number of resource allocation copies, toCommitAssign and toCommitRevoke can be cleared, and the recovery and allocation will offset each other. Since there is no record of resource allocation and resource recovery, there is no need to perform resource allocation and resource recovery. Resource allocation and resource recovery offset each other, and there is no need to send any notification to the job manager.

[0179] If there is no resource recovery record for the to-be-processed job for the first machine node, the resource allocation record may be directly sent to the first control node.

[0180] In another possible implementation:

[0181] The first scheduling node is further configured to send the resource allocation record to the first control node if the resource recovery record exists and the resource recovery record has been sent to the first control node.

[0182] That is, when the first scheduling node obtains the resource allocation result, it can first update RunningQueue and toCommitAssign. When it is ready to send the resource allocation record in toCommitAssign to the first control node, if it is found that toCommitRevoke is not empty and has been sent to the first scheduling node, the first scheduling node cannot determine whether the first control node has processed the resource recovery record. It can only be considered that the first control node has processed the resource recovery record, but has not yet received the recovery success message from the first control node. At this time, the resource allocation record in toCommitAssign needs to be sent to the first control node for allocation scheduling.

[0183] In yet another possible implementation:

[0184] The sending of an allocation success notification to the job manager based on the allocated record and clearing the allocated record may include:

[0185] Determining whether there is a recycled record of the to-be-processed job for the first machine node;

[0186] If yes, if the number of allocated resource shares in the allocated record is equal to the number of recycled resource shares in the recycled record, clear the allocated record and the recycled record; if the number of allocated resource shares in the allocated record is greater than the number of recycled resource shares in the recycled record, clear the recycled record, and update the allocated record based on the number of recycled resource shares, and based on the updated allocated record, send an allocation success notification to the job manager and clear the allocated record; if the number of allocated resource shares in the allocated record is less than the number of recycled resource shares in the recycled record, clear the allocated record, and update the recycled record based on the number of allocated resource shares;

[0187] If not, based on the allocated record, a successful allocation notification is sent to the job manager, and the allocated record is cleared. That is, when the first scheduling node obtains the resource allocation result, it can first update RunningQueue and toCommitAssign, and when preparing to send the resource allocation record in toCommitAssign to the first control node, if it is found that toRelease is not empty, it indicates that the first control node has processed the resource recovery record sent by the first scheduling node and the recovery is successful, but the first scheduling node has not yet sent a successful recovery notification to the job manager. At this time, the resource allocation record in toCommitAssign can be sent to the first control node. If the allocation success message from the first control node is received, toAssign is updated based on the resource allocation record.

[0188] At this time, if the number of allocated resource shares in toAssign is the same as the number of recovered resource shares in toRelease, toAssign and toRelease can offset each other, and there is no need to send any notification to the job manager; if the number of allocated resource shares is greater than the number of recovered resource shares, the recovered record is cleared, and the allocated record is updated based on the number of recovered resource shares, that is, the original number of allocated resource shares in the allocated record is subtracted from the number of recovered resource shares for update, and based on the updated allocated record, an allocation success notification is sent to the job manager; if the number of allocated resource shares is less than the number of recovered resource shares, the allocated record is cleared, and the recovered record is updated based on the allocated resource shares, that is, the original number of recovered resource shares in the recovered record is subtracted from the number of allocated resource shares for update.

[0189] If toRelease is empty, the resource allocation record may be directly sent to the first control node, and after obtaining the allocated record, based on the allocated record, an allocation success notification may be sent to the job manager, and the allocated record may be cleared.

[0190] In yet another possible implementation:

[0191] The first scheduling node sending the resource recovery record to the first control node may include:

[0192] Determining whether there is a resource allocation record for the job to be processed for the first machine node;

[0193] If yes, if the resource allocation record is not sent to the first control node and the number of resource allocation shares in the resource allocation record is greater than the number of resource recovery shares in the resource recovery record, clear the resource recovery record, and update the resource allocation record based on the number of resource recovery shares; if the resource allocation record is not sent to the first control node and the number of resource allocation shares in the resource allocation record is less than the number of resource recovery shares in the resource recovery record, clear the resource allocation record, and update the resource recovery record based on the number of resource recovery shares, and send the updated resource recovery record to the first control node; if the resource allocation record is not sent to the first control node and the number of resource allocation shares in the resource allocation record is equal to the number of resource recovery shares in the resource recovery record, clear the resource allocation record and the resource recovery record;

[0194] If not, the resource recovery record is sent to the first control node.

[0195] That is, the first scheduling node obtains the resource recovery result, and can first update RunningQueue and toCommitRevoke. When preparing to send the resource recovery record in toCommitRevoke to the first control node, if it is found that toCommitAssign is not empty and has not been sent to the first scheduling node, for the first scheduling node, if the number of resource recovery copies in toCommitRevoke is equal to the number of resource allocation copies in toCommitAssign, then toCommitAssign and toCommitRevoke can be cleared. The two things of recovery and allocation offset each other. Since there are no resource allocation records and resource recovery records, there is no need for resource allocation and resource recovery. Resource allocation and resource recovery offset each other, and there is no need to send any notification to the job manager.

[0196] If the number of resource recovery shares is greater than the number of resource allocation shares, toCommitAssign can be cleared. Since toCommitAssign is empty, there is no need to send the resource allocation record to the first control node, that is, no allocation is required. Based on the number of resource allocation shares, toCommitRevoke is updated, that is, the original number of resource recovery shares in toCommitRevoke is subtracted from the number of resource allocation shares for update, and the updated resource recovery record can be sent to the first control node;

[0197] If the number of resource recovery shares is less than the number of resource allocation shares, toCommitRevoke can be cleared. Since toCommitRevoke is empty, there is no need to send a resource recovery record to the first control node, that is, there is no need to perform recovery. Based on the number of resource recovery shares, toCommitAssign is updated, that is, the original number of resource allocation shares in toCommitAssign is subtracted from the number of resource recovery shares to perform the update.

[0198] If there is no resource allocation record for the to-be-processed job for the first machine node, the resource recovery record may be directly sent to the first control node.

[0199] In yet another possible implementation:

[0200] The first scheduling node may also be configured to send the resource recovery record to the first control node if there is a resource allocation record corresponding to the to-be-processed job on the first machine node and the resource allocation record has been sent to the first control node.

[0201] That is, if it is found that toCommitAssign is not empty and has been sent to the first scheduling node, the first scheduling node cannot determine whether the first control node has processed the resource allocation record. It can only be considered that the first control node has processed the resource allocation record, but has not yet received the allocation success message from the first control node. At this time, the resource recovery record in toCommitRevoke needs to be sent to the first control node for allocation scheduling.

[0202] In yet another possible implementation:

[0203] The first scheduling node sends a recycling success notification to the job manager based on the recycled record, and clears the recycled record, including:

[0204] Determine whether there is an allocated record of the to-be-processed job for the first machine node;

[0205] If yes, if the number of recycled resource shares in the recycled record is greater than the number of allocated resource shares in the allocated record, clear the allocated record and update the recycled record based on the number of allocated resource shares, and send a recycling success notification to the job manager based on the updated recycled record, and clear the recycled record; if the number of recycled resource shares in the recycled record is less than the number of allocated resource shares in the allocated record, clear the recycled record and update the allocated record based on the number of recycled resource shares; if the number of recycled resource shares in the recycled record is equal to the number of allocated resource shares in the allocated record, clear the recycled record and the allocated record;

[0206] If not, based on the recycled record, a recycling success notification is sent to the job manager, and the recycled record is cleared.

[0207] That is, the first scheduling node obtains the resource recovery result, and can first update RunningQueue and toCommitRevoke. When preparing to send the resource recovery record in toCommitRevoke to the first control node, if it is found that toAssign is not empty, it indicates that the first control node has processed the resource allocation record once and the first scheduling node has obtained the allocation success message, but the first scheduling node has not yet sent the allocation success notification to the job manager. At this time, the resource recovery record in toCommitRevoke can be sent to the first control node. If the recovery success message from the first control node is received, toRelease can be updated based on the resource recovery record.

[0208] At this time, if the number of allocated resource shares in toAssign is the same as the number of recovered resource shares in toRelease, toAssign and toRelease can offset each other, and there is no need to send any notification to the job manager; if the number of allocated resource shares is greater than the number of recovered resource shares, the recovered record is cleared, and the allocated record is updated based on the number of recovered resource shares, that is, the original number of allocated resource shares in the allocated record is subtracted from the number of recovered resource shares for update, and based on the updated allocated record, an allocation success notification can be sent to the job manager and the allocated record is cleared; if the number of allocated resource shares is less than the number of recovered resource shares, the allocated record is cleared, and the recovered record is updated based on the number of allocated resource shares, that is, the original number of recovered resource shares in the recovered record is subtracted from the number of allocated resource shares for update, and based on the updated recovered record, a recovery success notification is sent to the job manager and the recovered record is cleared;.

[0209] If toAssign is empty, the resource recovery record may be directly sent to the first control node, and after obtaining the recovered record, a recovery success notification may be sent to the job manager based on the recovered record, and the recovered record may be cleared.

[0210] In yet another possible implementation:

[0211] The first scheduling node sending the resource recovery record to the first control node may include:

[0212] Determining whether there is a resource return record for the to-be-processed job for the first machine node;

[0213] If yes, if the resource return record is not sent to the first control node and the number of resource return copies in the resource return record is greater than the number of resource recovery copies in the resource recovery record, clear the resource recovery record; if the resource return record is not sent to the first control node and the number of resource return copies in the resource return record is less than the number of resource recovery copies in the resource recovery record, clear the resource return record;

[0214] If not, the resource recovery record is sent to the first control node.

[0215] That is, when the first scheduling node obtains the resource recovery result, it can first update RunningQueue and toCommitRevoke. When it is ready to send the resource recovery record in toCommitRevoke to the first control node, if it is found that toCommitReturn is not empty and has not been sent to the first scheduling node, for the first scheduling node, if the number of resource return copies in toCommitReturn is greater than or equal to the number of resource recovery copies in toCommitRevoke, then toCommitRevoke can be cleared, and the returned resources offset the recovered resources. It is only necessary to return the resources, and there is no need to send the resource recovery record to the first control node.

[0216] If the number of resource returns is less than the number of resource recycling shares, the recycled resources offset the returned resources, and only the resource recycling record needs to be made. Therefore, toCommitReturn can be cleared without sending the resource recycling record to the first control node.

[0217] If the number of resource returns is equal to the number of resource recycles, toCommitReturn or toCommitRevoke can be cleared.

[0218] In yet another possible implementation:

[0219] The first scheduling node is also used to, if there is a resource return record for the first machine node for the pending job and the resource return record has been sent to the first control node, clear the resource recovery record if the number of resource return copies in the resource return record is greater than or equal to the number of resource recovery copies in the resource recovery record; if the number of resource return copies in the resource return record is less than the number of resource recovery copies in the resource recovery record, update the resource recovery record based on the number of resource return copies, and send the updated resource recovery record to the first control node.

[0220] That is, if it is found that toCommitReturn is not empty and has been sent to the first scheduling node, for the first scheduling node, if the number of resource return copies in toCommitReturn is greater than or equal to the number of resource recovery copies in toCommitRevoke, then toCommitRevoke can be cleared without sending the resource recovery record to the first control node. If the number of resource return copies is less than the number of resource recovery copies, it is necessary to update the resource recovery record based on the number of resource return copies, and also update the original number of resource recovery copies in the resource recovery record minus the number of resource return copies, and then send the updated resource recovery record to the first control node.

[0221] In yet another possible implementation:

[0222] The first scheduling node sending the resource return record to the first control node may include:

[0223] Determining whether there is a resource recovery record for the to-be-processed job for the first machine node;

[0224] If yes, if the resource recovery record has not been sent to the first control node and the number of resource recovery copies in the resource recovery record is greater than the number of resource return copies in the resource return record, clear the resource return record; if the resource return record has not been sent to the first control node and the number of resource return copies in the resource return record is greater than the number of resource recovery copies in the resource recovery record, clear the resource recovery record and send the resource return record to the first control node;

[0225] If not, the resource recovery record is sent to the first control node.

[0226] In yet another possible implementation:

[0227] The first scheduling node is also used to, if there is a resource recovery record for the first machine node for the pending job and the resource recovery record has been sent to the first control node, clear the resource return record if the number of resource recovery copies in the resource recovery record is greater than or equal to the number of resource return copies in the resource return record; if the number of resource recovery copies in the resource recovery record is less than the number of resource return copies in the resource return record, update the resource return record based on the number of resource recovery copies, and send the updated resource return record to the first control node.

[0228] As can be seen from the above description, in the job processing system of the embodiment of the present application, network communication will be performed between the request node and the scheduling node, between the scheduling node and the control node, and between the control node and the machine node, and multiple messages may be sent continuously. In order to improve the quality of network communication to further ensure the efficiency of job processing, the inventor has proposed after a series of studies that when the request node and the scheduling node, the scheduling node and the control node, and the control node and the machine node are respectively the sending end and the receiving end, network communication can be performed according to the following first predetermined communication mode;

[0229] The first predetermined communication method includes:

[0230] The sending end caches the sending message to be sent in the first sending queue corresponding to the receiving end;

[0231] The transmitting end detects whether the first sending queue is in a first state; wherein the initial state of the first sending queue is the first state;

[0232] If the first sending queue is in the first state, the sending end sends at least one sending message currently cached in the first sending queue to the receiving end, and switches the first sending queue to the second state; wherein the receiving end processes the at least one sending message in sequence according to the cache order of the at least one sending message;

[0233] The sending end receives a reply message from the receiving end to the at least one sent message, clears the at least one sent message in the first sending queue, and switches the first sending queue to the first state.

[0234] Optionally, if the sending end does not receive a reply message from the receiving end to at least one message currently cached in the first sending queue within a predetermined time after sending the at least one message currently cached in the first sending queue to the receiving end, the sending end may also forcibly send at least one message currently cached in the first sending queue to the receiving end.

[0235] Optionally, in the first predetermined communication mode, the sending end can also set a message sequence number for each sending message cached in the sending queue according to the cache order; wherein the receiving end processes the at least one sending message in sequence according to the cache order indicated by the message sequence number of the at least one sending message.

[0236] Optionally, the sending end may set a message sequence number for each send message cached in the sending queue according to the cache order, or may set a message sequence number for each send message cached in the first sending queue using consecutive numbers starting from 1 according to the cache order.

[0237] Optionally, the sending end may also set a first sending field for the first sending queue; wherein the first sending field is used to store the maximum message sequence number of the cached messages in the first sending queue;

[0238] The sending end receives a reply message from the receiving end to the at least one message, clears the at least one sent message in the sending queue, and switches the sending queue to the first state, which may include:

[0239] Receive at least one reply message and a second receiving field value sent by the receiving end; wherein the second receiving field is used to store the maximum message sequence number among the sending messages sent by the sending end that have been processed by the receiving end;

[0240] If the second receiving field value is the same as the first sending field value, switch the first sending queue to the first state, and clear the reply messages corresponding to the message sequence numbers less than or equal to the second receiving field value in the first sending queue.

[0241] Optionally, if the sending end determines that the second receiving field value is different from the first receiving field value, the sending message corresponding to each message sequence number less than or equal to the second receiving field value in the first sending queue may be cleared.

[0242] Optionally, the sending end may also set a first receiving field for the first sending queue; wherein the first receiving field is used to store the maximum message sequence number of the reply message sent by the receiving end and received by the sending end; the receiving end maintains a second sending queue for the sending end to cache the reply message to be sent to the sending end;

[0243] When sending at least one sending message currently cached in the first sending queue to the receiving end, the first receiving field value is sent to the receiving end so that the receiving end can clear the reply messages corresponding to each message sequence number less than or equal to the first receiving field in the second sending queue.

[0244] Optionally, the sending end may maintain corresponding sending queues for different receiving ends respectively.

[0245] For example, in actual applications, a control node may communicate with thousands of machine nodes, and a scheduling node may also communicate with multiple control nodes, which puts a lot of pressure on communication. However, the communication between a control node and different machine nodes is independent and does not interfere with each other. Therefore, in order to further improve communication performance, the sender can maintain corresponding sending queues for different receivers.

[0246] In addition, the sender may also send messages of different message types to the same receiver. For example, the scheduling node will send resource allocation results, resource recovery results, and resource return results to the control node. These are all messages of different message types. In addition, the scheduling node will send resource allocation results of different machine nodes to the control node. The resource allocation results of different machine nodes can also be considered as messages that do not belong to the same message type. Messages of different message types can also be independent of each other and do not interfere with each other.

[0247] Therefore, the sending end can maintain multiple first sending queues corresponding to different message types for the same receiving end;

[0248] The sending end may cache the to-be-sent message in the first sending queue corresponding to the receiving end:

[0249] Determining a message type of a send message to be sent;

[0250] Determining a first sending queue corresponding to the message type from a plurality of sending queues maintained for the receiving end;

[0251] The send message to be sent is cached in a first send queue corresponding to the message type.

[0252] Optionally, the receiving end processes at least one sending message sent by the sending end in sequence according to the cache order of the at least one sending message, and one or more reply messages may be obtained;

[0253] The receiving end may cache the one or more reply messages in a second sending queue;

[0254] Thus, the receiving end can send at least one reply message currently buffered in the second sending queue to the sending end.

[0255] Optionally, if the receiving end detects whether the second sending queue is in the first state; wherein, when receiving a sending message from the sending end, the second sending queue is switched to the first state;

[0256] If the second sending queue is in the first state, at least one reply message currently buffered in the second sending queue is sent to the sending end, and the first sending queue is switched to the second state.

[0257] Optionally, the receiving end may also set a message sequence number for each reply message cached in the second sending queue using consecutive numbers starting from 1 in the cache order.

[0258] Optionally, the receiving end may further set a second sending field for the second sending queue; wherein the second sending field is used to store the maximum message sequence number of the reply message currently cached in the second sending queue;

[0259] The receiving end receiving at least one sending message currently buffered in the first sending queue sent by the sending end may include:

[0260] Receive at least one send message currently cached in a first send queue sent by a sender and a first receive field value; wherein the first receive field value is used to store the maximum message sequence number in the reply message sent by the receiving end that has been received by the sender;

[0261] Clear the messages corresponding to the message sequence numbers that are less than or equal to the first receiving field value in the second sending queue.

[0262] In addition, the sender may send messages of different message types to the receiver. For example, the scheduling node will send resource allocation results, resource recovery results, and resource return results to the control node. These are all messages of different message types. In addition, the scheduling node will send resource allocation results of different machine nodes to the control node. The resource allocation results of different machine nodes can also be considered as messages that do not belong to the same message type. Messages of different message types can also be independent of each other and do not interfere with each other.

[0263] Therefore, in some embodiments, when the requesting node and the scheduling node, the scheduling node and the control node, and the control node and the machine node are respectively the sending end and the receiving end, network communication can be performed according to the following second predetermined communication mode:

[0264] The sender determines the message to be sent;

[0265] The transmitting end searches for a third transmitting queue in the first state from a plurality of transmitting queues; wherein the initial state of the third transmitting queue is the first state;

[0266] The sending end caches the sending message in the third sending queue;

[0267] The sending end sends at least one sending message currently cached in the third sending queue to the receiving end, and switches the third sending queue to the second state;

[0268] The sending end receives a reply message from the receiving end to the at least one sent message, clears the at least one sent message from the third sending queue, and switches the third sending queue to the first state.

[0269] Optionally, if the sending end does not receive a reply message from the receiving end within a predetermined time after sending the at least one sending message to the receiving end, the sending end forcibly sends at least one sending message currently cached in the third sending queue to the receiving end.

[0270] Optionally, if the sending end determines that the multiple sending queues are all in the second state, select any one sending queue; cache the sending message in any one of the sending queues; send at least one sending message currently cached in any one of the sending queues to the receiving end; receive a reply message to the at least one sending message, and switch any one of the sending queues to the first state.

[0271] Optionally, the sending end may set message sequence numbers for each send message cached in the target send queue using consecutive numbers starting from 1 in the cache order.

[0272] Optionally, the sending end may set a first sending field for the third sending queue; wherein the first sending field is used to store the maximum message sequence number of the cached messages in the third sending queue;

[0273] The sending end receives a reply message from the receiving end to the at least one sent message, clears the sent message from the third sending queue, and switches the third sending queue to the first state may include:

[0274] Receive at least one reply message and a second receiving field value sent by the receiving end; wherein the second receiving field is used to store the maximum message sequence number among the sending messages sent by the sending end that have been processed by the receiving end;

[0275] If the second receiving field value is the same as the first sending field value, switch the third sending queue to the first state, and clear the sending messages corresponding to each message sequence number less than or equal to the second receiving field value in the third sending queue.

[0276] Optionally, the sending end may also set a first receiving field for the third sending queue; wherein the first receiving field is used to store the maximum message sequence number of the reply message sent by the receiving end and received by the sending end; the receiving end maintains a fourth sending queue for the sending end to cache the reply message to be sent to the sending end;

[0277] While sending at least one sending message currently cached in the third sending queue to the receiving end, the first receiving field value is sent to the receiving end so that the receiving end can clear the reply messages corresponding to each message sequence number less than or equal to the first receiving field in the fourth sending queue.

[0278] Optionally, the sending end may also set an available resource list based on the queue identifiers of the multiple sending queues;

[0279] When the multiple sending queues are in an initial state, sequentially storing queue identifiers of the multiple sending queues in the available resource list;

[0280] After the sending end caches the sending message to the third sending queue and switches the third sending queue to the second state, the queue identifier of the third sending queue can also be deleted from the available resource list; after switching the third sending queue to the first state, the queue identifier of the third sending queue can also be stored in the available resource list.

[0281] The sending end searches for the third sending queue in the first state from the multiple sending queues by selecting any queue identifier from the available resource list; and determining the sending queue represented by any queue identifier as the third sending queue.

[0282] Optionally, the receiving end can obtain one or more reply messages by processing the at least one sent message in sequence according to the cache order of the at least one sent message; the one or more reply messages can be cached in a fourth sending queue; thereby, at least one reply message currently cached in the fourth sending queue can be sent to the sending end.

[0283] Corresponds to Figure 1 The resource control system shown, such as Figure 4 As shown in , a resource control method is also provided for the embodiment of the present application. Figure 4 The resource control method shown is executed by a requesting node, and the method may include the following steps:

[0284] 401: Receive pending jobs submitted by users.

[0285] 402: Determine a first scheduling node from multiple scheduling nodes.

[0286] Optionally, determining the first scheduling node from the multiple scheduling nodes may include:

[0287] According to the load conditions of different scheduling nodes, a first scheduling node whose load pressure meets the scheduling conditions is determined; and the first scheduling node is requested to schedule the pending job.

[0288] 403: Send a scheduling processing request to the first scheduling node so that the first scheduling node creates a job manager for the pending job, determines a first machine node with available resources, allocates machine resources in the first machine node to the pending job, and sends the resource allocation result of the first machine node to the corresponding first control node, receives an allocation success message fed back by the first control node, and sends an allocation success notification to the job manager so that the job manager creates a job node in the first machine node; wherein the first control node is used to determine whether the first machine node allows resource allocation, and if so, feeds back an allocation success message to the first scheduling node.

[0289] Corresponds to Figure 1 The resource control system shown, such as Figure 5 As shown in , a resource control method is also provided for the embodiment of the present application. Figure 5 The resource control method shown is executed by a scheduling node, and the method may include the following steps:

[0290] 501: Receive a scheduling processing request sent by the requesting node.

[0291] The scheduling processing request is sent by the requesting node after receiving the pending job submitted by the user and determining the first scheduling node.

[0292] 502: Create a job manager for the job to be processed.

[0293] 503: Determine a first machine node with available resources, and allocate machine resources in the first machine node to the job to be processed.

[0294] 504: Send the resource allocation result of the first machine node to the corresponding first control node.

[0295] 505: Receive an allocation success message fed back by the first control node, and send an allocation success notification to the job manager, so that the job manager can create a job node in the first machine node.

[0296] The first control node is used to determine whether the first machine node is allowed to allocate resources, and if so, feedback an allocation success message.

[0297] In some embodiments, allocating machine resources in the first machine node to the job to be processed includes: determining the number of resource allocation shares in the first machine node; and generating a resource allocation result for the first machine node based on the number of resource allocation shares.

[0298] In some embodiments, the method may further include:

[0299] Generate a resource recovery result according to the number of resource recovery copies for the pending job in the first machine node; send the resource recovery result to the first control node, so that the first control node can request the first machine node to release the corresponding resources according to the resource recovery result, and feed back a recovery success message to the first scheduling node;

[0300] Receive a recycling success message fed back by the first control node, and send a recycling success notification to the job manager, so that the job manager ends the job task executed by the job node running in the recycling resource.

[0301] In some embodiments, the method may further include:

[0302] The resource return result is generated based on the number of resource return copies in the resource return request; the resource return result is sent to the first control node, so that the first control node can request the first machine node to release the corresponding resources based on the resource return result of the first machine node, and feedback a return success message to the first scheduling node.

[0303] In some embodiments, sending the resource allocation result of the first machine node to the first control node includes:

[0304] Based on the resource allocation result of the first machine node, updating the resource allocation record corresponding to the to-be-processed job in the first machine node;

[0305] Sending the resource allocation record to the first control node, so that the first control node determines whether to allow resource allocation according to the resource allocation record; if the resource allocation is allowed, feeding back an allocation success message to the first scheduling node;

[0306] The receiving the allocation success message of the first control node and sending the allocation success notification to the job manager comprises:

[0307] Receiving an allocation success message from the first control node;

[0308] Based on the number of successfully allocated resource shares, updating the allocated record of the to-be-processed job for the first machine node, and clearing the number of successfully allocated resource shares in the resource allocation record;

[0309] Based on the allocated record, an allocation success notification is sent to the job manager, and the allocated record is cleared.

[0310] In some embodiments, sending the resource recovery result of the first machine node to the first control node includes:

[0311] Based on the resource recovery result of the first machine node, update the resource recovery record corresponding to the to-be-processed job in the first machine node; send the resource recovery record to the first control node, so that the first control node can request the first machine node to release the corresponding resources according to the resource recovery record, and feedback a recovery success message to the first scheduling node;

[0312] The receiving the recycling success message and sending a recycling success notification to the job manager comprises:

[0313] receiving a recycling success message from the first control node, updating a recycled record corresponding to the pending job in the first machine node based on the number of successfully recycled resources, and clearing the number of successfully recycled resources in the resource recycling record;

[0314] Based on the recycled record, a recycling success notification is sent to the job manager, and the recycled record is cleared.

[0315] In some embodiments, sending the resource allocation record to the first control node includes:

[0316] Determining whether there is a resource recovery record for the to-be-processed job for the first machine node;

[0317] If yes, if the resource recovery record is not sent to the first scheduling node and the number of resource recovery shares in the resource recovery record is greater than the number of resource allocation shares in the resource allocation record, clear the resource allocation record, and update the resource recovery record based on the resource allocation share; if the resource recovery record is not sent to the first scheduling node and the number of resource recovery shares in the resource recovery record is less than the number of resource allocation shares in the resource allocation record, clear the resource recovery record, and update the resource allocation record based on the resource recovery share, and send the updated resource allocation record to the first control node; if the resource recovery record is not sent to the first scheduling node and the number of resource recovery shares in the resource recovery record is equal to the number of resource allocation shares in the resource allocation record, clear the resource allocation record and the resource recovery record;

[0318] If not, sending the resource allocation record to the first control node.

[0319] In some embodiments, the method may further include:

[0320] If the resource recovery record exists and the resource recovery record has been sent to the first control node, the resource allocation record is sent to the first control node.

[0321] In some embodiments, based on the allocated record, sending an allocation success notification to the job manager and clearing the allocated record comprises:

[0322] Determining whether there is a recycled record of the to-be-processed job for the first machine node;

[0323] If yes, if the number of allocated resource shares in the allocated record is equal to the number of recycled resource shares in the recycled record, clear the allocated record and the recycled record; if the number of allocated resource shares in the allocated record is greater than the number of recycled resource shares in the recycled record, clear the recycled record, and update the allocated record based on the number of recycled resource shares, and based on the updated allocated record, send an allocation success notification to the job manager and clear the allocated record; if the number of allocated resource shares in the allocated record is less than the number of recycled resource shares in the recycled record, clear the allocated record, and update the recycled record based on the number of allocated resource shares;

[0324] If not, based on the allocated record, an allocation success notification is sent to the job manager, and the allocated record is cleared.

[0325] In some embodiments, sending the resource recovery record to the first control node includes:

[0326] Determining whether there is a resource allocation record for the job to be processed for the first machine node;

[0327] If yes, if the resource allocation record is not sent to the first control node and the number of resource allocation shares in the resource allocation record is greater than the number of resource recovery shares in the resource recovery record, clear the resource recovery record, and update the resource allocation record based on the number of resource recovery shares; if the resource allocation record is not sent to the first control node and the number of resource allocation shares in the resource allocation record is less than the number of resource recovery shares in the resource recovery record, clear the resource allocation record, and update the resource recovery record based on the number of resource recovery shares, and send the updated resource recovery record to the first control node; if the resource allocation record is not sent to the first control node and the number of resource allocation shares in the resource allocation record is equal to the number of resource recovery shares in the resource recovery record, clear the resource allocation record and the resource recovery record;

[0328] If not, the resource recovery record is sent to the first control node.

[0329] In some embodiments, the method may further include:

[0330] If there is a resource allocation record corresponding to the to-be-processed job on the first machine node and the resource allocation record has been sent to the first control node, the resource recovery record is sent to the first control node.

[0331] In some embodiments, based on the recycled record, sending a recycling success notification to the job manager and clearing the recycled record includes:

[0332] Determine whether there is an allocated record of the to-be-processed job for the first machine node;

[0333] If yes, if the number of recycled resource shares in the recycled record is greater than the number of allocated resource shares in the allocated record, clear the allocated record and update the recycled record based on the number of allocated resource shares, and send a recycling success notification to the job manager based on the updated recycled record, and clear the recycled record; if the number of recycled resource shares in the recycled record is less than the number of allocated resource shares in the allocated record, clear the recycled record and update the allocated record based on the number of recycled resource shares; if the number of recycled resource shares in the recycled record is equal to the number of allocated resource shares in the allocated record, clear the recycled record and the allocated record;

[0334] If not, based on the recycled record, a recycling success notification is sent to the job manager, and the recycled record is cleared.

[0335] In some embodiments, sending the resource recovery record to the first control node includes:

[0336] Determining whether there is a resource return record for the to-be-processed job for the first machine node;

[0337] If yes, if the resource return record has not been sent to the first control node and the number of resource return copies in the resource return record is greater than the number of resource recovery copies in the resource recovery record, clear the resource recovery record; if the resource return record has not been sent to the first control node and the number of resource return copies in the resource return record is less than the number of resource recovery copies in the resource recovery record, clear the resource return record and send the resource recovery record to the first control node;

[0338] If not, the resource recovery record is sent to the first control node.

[0339] In some embodiments, the method may further include:

[0340] If there is a resource return record for the to-be-processed job for the first machine node and the resource return record has been sent to the first control node, if the number of resource return copies in the resource return record is greater than or equal to the number of resource recovery copies in the resource recovery record, clear the resource recovery record;

[0341] If the number of resource returned copies in the resource return record is less than the number of resource recovered copies in the resource recovery record, the resource recovery record is updated based on the number of resource returned copies, and the updated resource recovery record is sent to the first control node.

[0342] In some embodiments, sending the resource return record to the first control node includes:

[0343] Determining whether there is a resource recovery record for the to-be-processed job for the first machine node;

[0344] If yes, if the resource recovery record has not been sent to the first control node and the number of resource recovery copies in the resource recovery record is greater than the number of resource return copies in the resource return record, clear the resource return record; if the resource return record has not been sent to the first control node and the number of resource return copies in the resource return record is greater than the number of resource recovery copies in the resource recovery record, clear the resource recovery record and send the resource return record to the first control node;

[0345] If not, the resource recovery record is sent to the first control node.

[0346] In some embodiments, the method may further include:

[0347] If there is a resource recovery record for the to-be-processed job for the first machine node and the resource recovery record has been sent to the first control node, if the number of resource recovery copies in the resource recovery record is greater than or equal to the number of resource return copies in the resource return record, clear the resource return record;

[0348] If the number of resource recovery shares in the resource recovery record is less than the number of resource return shares in the resource return record, the resource return record is updated based on the number of resource recovery shares, and the updated resource return record is sent to the first control node.

[0349] Corresponds to Figure 1 The resource control system shown, such as Figure 6As shown in , a resource control method is also provided for the embodiment of the present application. Figure 6 The resource control method shown is executed by a control node, and the method may include the following steps:

[0350] 601: Receive a resource allocation result of a first machine node sent by a first scheduling node.

[0351] The resource allocation result is that the first scheduling node determines that there is a first machine node with available resources, and allocates machine resources in the first machine node to the job to be processed; the job to be processed is received by the requesting node and requests the first scheduling node to perform scheduling processing.

[0352] 602: Determine whether the first machine node allows resource allocation; if so, execute step 603; otherwise, the process ends.

[0353] 603: Feedback an allocation success message to the first scheduling node, so that the first scheduling node sends an allocation success notification to the job manager.

[0354] Figures 4 to 6 The resource control method provided in the embodiment of the present application is described from the perspectives of different execution entities such as the request node, the scheduling node and the control node. The specific operations performed by the request node, the scheduling node and the control node have been described in detail in the above system embodiment. The implementation principles and technical effects can be found above and will not be elaborated here.

[0355] correspond Figure 4 The resource control method shown in the embodiment of the present application also provides a resource control device, such as Figure 7 As shown, the device may include:

[0356] The job receiving module 701 is used to receive the jobs to be processed submitted by the user;

[0357] A node determination module 702, configured to determine a first scheduling node from a plurality of scheduling nodes;

[0358] The request processing module 703 is used to send a scheduling processing request to the first scheduling node so that the first scheduling node can create a job manager for the job to be processed, determine a first machine node with available resources, allocate machine resources in the first machine node to the job to be processed, and send the resource allocation result of the first machine node to the corresponding first control node, receive an allocation success message fed back by the first control node, and send an allocation success notification to the job manager so that the job manager can create a job node in the first machine node; wherein the first control node is used to determine whether the first machine node allows resource allocation, and if so, feed back an allocation success message to the first scheduling node.

[0359] Figure 7 The resource control device can execute Figure 6 The implementation principle and technical effects of the resource control method described in the illustrated embodiment will not be elaborated on any more.

[0360] In one possible design, Figure 7 The resource control device of the embodiment shown can be implemented as a computing device, such as Figure 8 As shown, the computing device may include a storage component 801 and a processing component 802;

[0361] The storage component 801 stores one or more computer instructions, wherein the one or more computer instructions are called and executed by the processing component 802 .

[0362] The processing component 802 is used to:

[0363] Receive pending jobs submitted by users;

[0364] Determining a first scheduling node from a plurality of scheduling nodes;

[0365] Send a scheduling processing request to the first scheduling node so that the first scheduling node creates a job manager for the job to be processed, determines a first machine node with available resources, allocates machine resources in the first machine node to the job to be processed, and sends the resource allocation result of the first machine node to the corresponding first control node, receives an allocation success message fed back by the first control node, and sends an allocation success notification to the job manager so that the job manager can create a job node in the first machine node; wherein the first control node is used to determine whether the first machine node allows resource allocation, and if so, feeds back an allocation success message to the first scheduling node.

[0366] The processing component 802 may include one or more processors to execute computer instructions to complete all or part of the steps in the above method. Of course, the processing component may also be implemented by one or more application-specific integrated circuits (ASICs), digital signal processors (DSPs), digital signal processing devices (DSPDs), programmable logic devices (PLDs), field programmable gate arrays (FPGAs), controllers, microcontrollers, microprocessors or other electronic components to perform the above method.

[0367] The storage component 801 is configured to store various types of data to support operations in the computing device. The storage component can be implemented by any type of volatile or non-volatile storage device or a combination thereof, such as static random access memory (SRAM), electrically erasable programmable read-only memory (EEPROM), erasable programmable read-only memory (EPROM), programmable read-only memory (PROM), read-only memory (ROM), magnetic memory, flash memory, magnetic disk or optical disk.

[0368] Of course, a computing device may also include other components, such as input / output interfaces, communication components, etc.

[0369] The input / output interface provides an interface between the processing component and the peripheral interface module, which may be an output device, an input device, etc.

[0370] The communication component is configured to facilitate, among other things, wired or wireless communications between the computing device and other devices.

[0371] Among them, the computing device can be a physical device or an elastic computing host provided by a cloud computing platform, etc. In this case, the computing device can refer to a cloud server, and the above-mentioned processing components, storage components, etc. can be basic server resources rented or purchased from the cloud computing platform.

[0372] The present application also provides a computer-readable storage medium storing a computer program, wherein the computer program can achieve the above-mentioned Figure 3 The resource control method of the illustrated embodiment.

[0373] correspond Figure 5 The resource control method shown in the embodiment of the present application also provides a resource control device, such as Fig. 9 As shown, the device may include:

[0374] The request receiving module 901 is used to receive the scheduling processing request sent by the requesting node; wherein the scheduling processing request is sent by the requesting node after receiving the pending job submitted by the user and determining the first scheduling node;

[0375] A creation module 902, used to create a job manager for the job to be processed;

[0376] A resource allocation module 903, configured to determine a first machine node having available resources, and allocate machine resources in the first machine node to the job to be processed;

[0377] A result sending module 904, configured to send the resource allocation result of the first machine node to the corresponding first control node;

[0378] The notification module 905 is used to receive the allocation success message fed back by the first control node, and send an allocation success notification to the job manager so that the job manager can create a job node in the first machine node; wherein the first control node is used to determine whether the first machine node allows resource allocation, and if so, feed back an allocation success message.

[0379] Fig. 9 The resource control device can execute Figure 5 The implementation principle and technical effects of the resource control method described in the illustrated embodiment will not be elaborated on any more.

[0380] In one possible design, Fig. 9 The resource control device of the embodiment shown can be implemented as a computing device, such as Fig.10 As shown, the computing device may include a storage component 1001 and a processing component 1002;

[0381] The storage component 1001 stores one or more computer instructions, wherein the one or more computer instructions are called and executed by the processing component 1002 .

[0382] The processing component 1002 is used to:

[0383] Receiving a scheduling processing request sent by the requesting node; wherein the scheduling processing request is sent by the requesting node after receiving a pending job submitted by a user and determining a first scheduling node;

[0384] Creating a job manager for the job to be processed;

[0385] Determine a first machine node with available resources, and allocate machine resources in the first machine node to the job to be processed;

[0386] Sending the resource allocation result of the first machine node to the corresponding first control node;

[0387] Receive an allocation success message fed back by the first control node, and send an allocation success notification to the job manager so that the job manager can create a job node in the first machine node; wherein the first control node is used to determine whether the first machine node allows resource allocation, and if so, feed back an allocation success message.

[0388] The processing component 1002 may include one or more processors to execute computer instructions to complete all or part of the steps in the above method. Of course, the processing component may also be implemented by one or more application-specific integrated circuits (ASICs), digital signal processors (DSPs), digital signal processing devices (DSPDs), programmable logic devices (PLDs), field programmable gate arrays (FPGAs), controllers, microcontrollers, microprocessors or other electronic components to perform the above method.

[0389] The storage component 1001 is configured to store various types of data to support operations in the computing device. The storage component can be implemented by any type of volatile or non-volatile storage device or a combination thereof, such as static random access memory (SRAM), electrically erasable programmable read-only memory (EEPROM), erasable programmable read-only memory (EPROM), programmable read-only memory (PROM), read-only memory (ROM), magnetic memory, flash memory, magnetic disk or optical disk.

[0390] Of course, a computing device may also include other components, such as input / output interfaces, communication components, etc.

[0391] The input / output interface provides an interface between the processing component and the peripheral interface module, which may be an output device, an input device, etc.

[0392] The communication component is configured to facilitate, among other things, wired or wireless communications between the computing device and other devices.

[0393] Among them, the computing device can be a physical device or an elastic computing host provided by a cloud computing platform, etc. In this case, the computing device can refer to a cloud server, and the above-mentioned processing components, storage components, etc. can be basic server resources rented or purchased from the cloud computing platform.

[0394] The present application also provides a computer-readable storage medium storing a computer program, wherein the computer program can achieve the above-mentioned Figure 5 The resource control method of the illustrated embodiment.

[0395] correspond Figure 6 The resource control method shown in the embodiment of the present application also provides a resource control device, such as Fig.11 As shown, the device may include:

[0396] The result receiving module 1101 is used to receive the resource allocation result of the first machine node sent by the first scheduling node; wherein the resource allocation result is obtained by allocating the machine resources in the first machine node to the job to be processed after the first scheduling node determines that the first machine node has available resources; the job to be processed is received by the requesting node and requests the first scheduling node to perform scheduling processing;

[0397] The resource determination module 1102 is used to determine whether the first machine node allows resource allocation;

[0398] The result feedback module 1103 is used to feed back an allocation success message to the first scheduling node if resource allocation is allowed, so that the first scheduling node can send an allocation success notification to the job manager.

[0399] Fig.11 The resource control device can execute Figure 5 The implementation principle and technical effects of the resource control method described in the illustrated embodiment will not be elaborated on any more.

[0400] In one possible design, Fig.11 The resource control device of the embodiment shown can be implemented as a computing device, such as Fig.12 As shown, the computing device may include a storage component 1201 and a processing component 1202;

[0401] The storage component 1201 stores one or more computer instructions, wherein the one or more computer instructions are called and executed by the processing component 1202 .

[0402] The processing component 1202 is used to:

[0403] Receive a resource allocation result of a first machine node sent by a first scheduling node; wherein the resource allocation result is obtained by allocating machine resources in the first machine node to the job to be processed after the first scheduling node determines that the first machine node has available resources; the job to be processed is received by the requesting node and requests the first scheduling node to perform scheduling processing;

[0404] Determining whether the first machine node allows resource allocation;

[0405] If resource allocation is allowed, an allocation success message is fed back to the first scheduling node, so that the first scheduling node can send an allocation success notification to the job manager.

[0406] The processing component 1202 may include one or more processors to execute computer instructions to complete all or part of the steps in the above method. Of course, the processing component may also be implemented by one or more application-specific integrated circuits (ASICs), digital signal processors (DSPs), digital signal processing devices (DSPDs), programmable logic devices (PLDs), field programmable gate arrays (FPGAs), controllers, microcontrollers, microprocessors or other electronic components to perform the above method.

[0407] The storage component 1201 is configured to store various types of data to support operations in the computing device. The storage component can be implemented by any type of volatile or non-volatile storage device or a combination thereof, such as static random access memory (SRAM), electrically erasable programmable read-only memory (EEPROM), erasable programmable read-only memory (EPROM), programmable read-only memory (PROM), read-only memory (ROM), magnetic memory, flash memory, magnetic disk or optical disk.

[0408] Of course, a computing device may also include other components, such as input / output interfaces, communication components, etc.

[0409] The input / output interface provides an interface between the processing component and the peripheral interface module, which may be an output device, an input device, etc.

[0410] The communication component is configured to facilitate, among other things, wired or wireless communications between the computing device and other devices.

[0411] Among them, the computing device can be a physical device or an elastic computing host provided by a cloud computing platform, etc. In this case, the computing device can refer to a cloud server, and the above-mentioned processing components, storage components, etc. can be basic server resources rented or purchased from the cloud computing platform.

[0412] The present application also provides a computer-readable storage medium storing a computer program, wherein the computer program can achieve the above-mentioned Figure 5 The resource control method of the illustrated embodiment.

[0413] Those skilled in the art can clearly understand that, for the convenience and brevity of description, the specific working processes of the systems, devices and units described above can refer to the corresponding processes in the aforementioned method embodiments and will not be repeated here.

[0414] The device embodiments described above are merely illustrative, wherein the units described as separate components may or may not be physically separated, and the components displayed as units may or may not be physical units, that is, they may be located in one place, or they may be distributed on multiple network units. Some or all of the modules may be selected according to actual needs to achieve the purpose of the scheme of this embodiment. Ordinary technicians in this field can understand and implement it without paying creative labor.

[0415] Through the description of the above implementation methods, those skilled in the art can clearly understand that each implementation method can be implemented by means of software plus a necessary general hardware platform, and of course, it can also be implemented by hardware. Based on this understanding, the above technical solution is essentially or the part that contributes to the prior art can be embodied in the form of a software product, and the computer software product can be stored in a computer-readable storage medium, such as ROM / RAM, a disk, an optical disk, etc., including a number of instructions for a computer device (which can be a personal computer, a server, or a network device, etc.) to execute the methods described in each embodiment or some parts of the embodiments.

[0416] Finally, it should be noted that the above embodiments are only used to illustrate the technical solutions of the present application, rather than to limit it. Although the present application has been described in detail with reference to the aforementioned embodiments, those skilled in the art should understand that they can still modify the technical solutions described in the aforementioned embodiments, or make equivalent replacements for some of the technical features therein. However, these modifications or replacements do not deviate the essence of the corresponding technical solutions from the spirit and scope of the technical solutions of the embodiments of the present application.

Claims

1. A resource control system, characterized in that: It includes a plurality of control nodes, a plurality of scheduling nodes connected to each control node, and a request node connected to each scheduling node; wherein each machine node is connected to a control node; The requesting node is used to receive the pending job submitted by the user, and request the first scheduling node to schedule the pending job; The first scheduling node is used to create a job manager for the job to be processed; determine a first machine node with available resources, and allocate machine resources in the first machine node to the job to be processed; send the resource allocation result of the first machine node to the corresponding first control node; receive an allocation success message fed back by the first control node, and send an allocation success notification to the job manager, so that the job manager can create a job node in the first machine node; The first control node is used to receive the resource allocation result of the first machine node; determine whether the first machine node is allowed to allocate resources; if the resource allocation is allowed, feedback an allocation success message to the first scheduling node.

2. The system according to claim 1, characterized in that Also included are coordination nodes respectively connected to the plurality of scheduling nodes; The coordination node is used to obtain the load conditions of each machine node reported by the multiple scheduling nodes; according to the load condition in any machine node, notify the multiple scheduling nodes whether to allow resource allocation to any machine node; The first scheduling node determines that a first machine node has available resources, including: A first machine node is determined that has available resources and is in a state that allows allocation.

3. The system according to claim 2, characterized in that The coordination node is further configured to determine at least one machine node according to the scheduling request of the first scheduling node; and notify other scheduling nodes excluding the first scheduling node to suspend resource allocation to the at least one machine node.

4. The system according to claim 1, characterized in that The first scheduling node allocating machine resources in the first machine node for the job to be processed includes: Determine the number of resource allocation shares in the first machine node; and generate a resource allocation result for the first machine node based on the number of resource allocation shares.

5. The system according to claim 1, characterized in that The first control node determines whether to allow resource allocation including: According to the resource allocation results of different jobs for the first machine node sent by different scheduling nodes, it is determined whether the submission time of the to-be-processed job is the earliest, and if so, it is determined to allow resource allocation.

6. The system according to claim 1, characterized in that The requesting node requests the first scheduling node to schedule the pending job, including: According to the load conditions of different scheduling nodes, a first scheduling node whose load pressure meets the scheduling conditions is determined; and the first scheduling node is requested to schedule the pending job.

7. The system according to claim 1, characterized in that The first scheduling node is further configured to generate a resource recovery result according to the number of resource recovery copies for the job to be processed in the first machine node; and send the resource recovery result to the first control node; The first control node is further configured to request the first machine node to release corresponding resources according to the resource recovery result, and to feed back a recovery success message to the first scheduling node; The first scheduling node is further used to receive a recycling success message fed back by the first control node, and send a recycling success notification to the job manager so that the job manager ends the job task executed by the job node running in the recycling resource.

8. The system according to claim 7, characterized in that The first scheduling node is further configured to receive a resource return request sent by the job manager to the first machine node; and generate a resource return result according to the number of resource return copies in the resource return request; Sending the resource return result to the first control node; The first control node is further configured to request the first machine node to release corresponding resources according to a resource return result of the first machine node, and to feed back a return success message to the first scheduling node.

9. The system according to claim 7, characterized in that The first scheduling node sending the resource allocation result of the first machine node to the first control node includes: Based on the resource allocation result of the first machine node, updating the resource allocation record corresponding to the to-be-processed job in the first machine node; and sending the resource allocation record to the first control node; The first control node is specifically used to determine whether resource allocation is allowed according to the resource allocation record; if resource allocation is allowed, feeding back an allocation success message to the first scheduling node; The first scheduling node receives the allocation success message from the first control node, and sends the allocation success notification to the job manager, comprising: Receive an allocation success message from the first control node, update the allocated record of the to-be-processed job for the first machine node based on the number of successfully allocated resources, and clear the number of successfully allocated resources in the resource allocation record; based on the allocated record, send an allocation success notification to the job manager, and clear the allocated record.

10. The system according to claim 9, characterized in that The first scheduling node sending the resource recovery result of the first machine node to the first control node includes: Based on the resource recovery result of the first machine node, updating the resource recovery record corresponding to the to-be-processed job in the first machine node; and sending the resource recovery record to the first control node; The first control node is specifically used to request the first machine node to release corresponding resources according to the resource recovery record, and feedback a recovery success message to the first scheduling node; The first scheduling node receives the recycling success message, and sends a recycling success notification to the job manager, including: Receive a recycling success message from the first control node, update the recycled record corresponding to the to-be-processed job in the first machine node based on the number of successfully recycled resources, and clear the number of successfully recycled resources in the resource recycling record; based on the recycled record, send a recycling success notification to the job manager, and clear the recycled record.

11. The system according to claim 10, characterized in that The first scheduling node sending the resource allocation record to the first control node includes: Determining whether there is a resource recovery record for the to-be-processed job for the first machine node; If yes, if the resource recovery record has not been sent to the first scheduling node and the number of resource recovery shares in the resource recovery record is greater than the number of resource allocation shares in the resource allocation record, clear the resource allocation record, and update the resource recovery record based on the resource allocation share; if the number of resource recovery shares is less than the number of resource allocation shares, clear the resource recovery record, and update the resource allocation record based on the number of resource recovery shares, and send the updated resource allocation record to the first control node; if the number of resource recovery shares is equal to the number of resource allocation shares, clear the resource allocation record and the resource recovery record; If not, sending the resource allocation record to the first control node.

12. The system according to claim 11, characterized in that The first scheduling node is further configured to send the resource allocation record to the first control node if the resource recovery record exists and the resource recovery record has been sent to the first control node.

13. The system according to claim 11 or 12, characterized in that The first scheduling node sends an allocation success notification to the job manager based on the allocated record, and clears the allocated record, including: Determining whether there is a recycled record of the to-be-processed job for the first machine node; If yes, if the number of allocated resource shares in the allocated record is equal to the number of recycled resource shares in the recycled record, clear the allocated record and the recycled record; if the number of allocated resource shares is greater than the number of recycled resource shares, clear the recycled record, and update the allocated record based on the number of recycled resource shares, and based on the updated allocated record, send an allocation success notification to the job manager and clear the allocated record; if the number of allocated resource shares is less than the number of recycled resource shares, clear the allocated record, and update the recycled record based on the number of allocated resource shares; If not, based on the allocated record, an allocation success notification is sent to the job manager, and the allocated record is cleared.

14. The system according to claim 10, characterized in that The first scheduling node sending the resource recovery record to the first control node includes: Determining whether there is a resource allocation record for the job to be processed for the first machine node; If yes, if the resource allocation record has not been sent to the first control node and the number of resource allocation shares in the resource allocation record is greater than the number of resource recovery shares in the resource recovery record, clear the resource recovery record, and update the resource allocation record based on the resource recovery number; if the number of resource allocation shares is less than the number of resource recovery shares, clear the resource allocation record, and update the resource recovery record based on the number of resource recovery shares, and send the updated resource recovery record to the first control node; if the number of resource allocation shares is equal to the number of resource recovery shares, clear the resource allocation record and the resource recovery record; If not, the resource recovery record is sent to the first control node.

15. The system according to claim 14, characterized in that The first scheduling node is further configured to send the resource recovery record to the first control node if there is a resource allocation record corresponding to the to-be-processed job on the first machine node and the resource allocation record has been sent to the first control node.

16. The system according to claim 14, characterized in that The first scheduling node sends a recycling success notification to the job manager based on the recycled record, and clears the recycled record, including: Determine whether there is an allocated record of the to-be-processed job for the first machine node; If yes, if the number of recycled resource shares in the recycled record is greater than the number of allocated resource shares in the allocated record, clear the allocated record and update the recycled record based on the number of allocated resource shares, and send a recycling success notification to the job manager based on the updated recycled record, and clear the recycled record; if the number of recycled resource shares is less than the number of allocated resource shares, clear the recycled record and update the allocated record based on the number of recycled resource shares; if the number of recycled resource shares is equal to the number of allocated resource shares, clear the recycled record and the allocated record; If not, based on the recycled record, a recycling success notification is sent to the job manager, and the recycled record is cleared.

17. The system according to claim 8, characterized in that The first scheduling node sending the resource return result to the first control node includes: Based on the resource return result of the first machine node, updating the resource return record corresponding to the to-be-processed job in the first machine node; and sending the resource return record to the first control node; The first control node is specifically used to request the first machine node to release corresponding resources according to the resource return record, and feed back a return success message to the first scheduling node; The first scheduling node is further configured to, upon receiving the successful return message, clear the number of successfully returned resources in the resource return record.

18. The system according to claim 17, characterized in that The first scheduling node sending the resource recovery result of the first machine node to the first control node includes: Based on the resource recovery result of the first machine node, updating the resource recovery record of the to-be-processed job for the first machine node; and sending the resource recovery record to the first control node; The first control node is specifically used to request the first machine node to release corresponding resources according to the resource recovery record, and feedback a recovery success message to the first scheduling node; The first scheduling node is also used to receive a successful recycling message from the first control node, update the recycled record of the pending job for the first machine node based on the number of successfully recycled resources, and clear the number of successfully recycled resources in the resource recycling record; after sending a successful recycling notification to the job manager, clear the recycled record.

19. The system according to claim 18, characterized in that The first scheduling node sending the resource recovery record to the first control node includes: Determining whether there is a resource return record for the to-be-processed job for the first machine node; If yes, if the resource return record has not been sent to the first control node and the number of resource return copies in the resource return record is greater than the number of resource recovery copies in the resource recovery record, clear the resource recovery record; if the number of resource return copies is less than the number of resource recovery copies, clear the resource return record and send the resource recovery record to the first control node; If not, the resource recovery record is sent to the first control node.

20. The system according to claim 19, characterized in that The first scheduling node is also used to, if there is a resource return record for the first machine node for the pending job and the resource return record has been sent to the first control node, clear the resource recovery record if the number of resource return copies in the resource return record is greater than or equal to the number of resource recovery copies in the resource recovery record; if the number of resource return copies is less than the number of resource recovery copies, update the resource recovery record based on the number of resource return copies, and send the updated resource recovery record to the first control node.

21. The system according to claim 18, characterized in that The first scheduling node sending the resource return record to the first control node includes: Determining whether there is a resource recovery record for the to-be-processed job for the first machine node; If yes, if the resource recovery record has not been sent to the first control node and the number of resource recovery copies in the resource recovery record is greater than the number of resource return copies in the resource return record, clear the resource return record; if the number of resource return copies is greater than the number of resource recovery copies, clear the resource recovery record and send the resource return record to the first control node; If not, the resource recovery record is sent to the first control node.

22. The system according to claim 21, characterized in that The first scheduling node is further configured to, if there is a resource recovery record for the to-be-processed job for the first machine node and the resource recovery record has been sent to the first control node, clear the resource return record if the number of resource recovery copies in the resource recovery record is greater than or equal to the number of resource return copies in the resource return record; If the number of resource recovery shares is less than the number of resource return shares, the resource return record is updated based on the number of resource recovery shares, and the updated resource return record is sent to the first control node.

23. The system according to claim 8, characterized in that The first scheduling node is further configured to update the resource scheduling record of the to-be-processed job for the first machine node based on the resource allocation result, the resource recovery result, and the resource return result.

24. The system according to claim 1, characterized in that When the request node and the scheduling node, the scheduling node and the control node, and the control node and the machine node are respectively the sending end and the receiving end, network communication is performed according to the following first predetermined communication mode; The first predetermined communication method includes: The sending end caches the sending message to be sent in the first sending queue corresponding to the receiving end; The transmitting end detects whether the first sending queue is in a first state; wherein the initial state of the first sending queue is the first state; If the first sending queue is in the first state, the sending end sends at least one sending message currently cached in the first sending queue to the receiving end, and switches the first sending queue to the second state; wherein the receiving end processes the at least one sending message in sequence according to the cache order of the at least one sending message; The sending end receives a reply message from the receiving end to the at least one sent message, clears the at least one sent message in the first sending queue, and switches the first sending queue to the first state.

25. The system according to claim 24, characterized in that If the sending end does not receive a reply message from the receiving end to at least one sending message currently cached in the first sending queue within a predetermined time after sending the at least one sending message currently cached in the first sending queue to the receiving end, the sending end is forced to send at least one sending message currently cached in the first sending queue to the receiving end.

26. The system according to claim 1, characterized in that When the request node and the scheduling node, the scheduling node and the control node, and the control node and the machine node serve as a sending end and a receiving end respectively, network communication is performed according to the following second predetermined communication mode; The second predetermined communication method includes: The sender determines the message to be sent; The transmitting end searches for a third transmitting queue in the first state from a plurality of transmitting queues; wherein the initial state of the third transmitting queue is the first state; The sending end caches the sending message in the third sending queue; The sending end sends at least one sending message currently cached in the third sending queue to the receiving end, and switches the third sending queue to the second state; The sending end receives a reply message from the receiving end to the at least one sent message, clears the at least one sent message from the third sending queue, and switches the third sending queue to the first state.

27. The system according to claim 26, characterized in that If the sending end does not receive a reply message from the receiving end within a predetermined time after sending the at least one sending message to the receiving end, the sending end forcibly sends at least one sending message currently cached in the third sending queue to the receiving end.

28. A resource control method, characterized in that: A request node applied to a resource control system, wherein the resource control system comprises a plurality of control nodes, a plurality of scheduling nodes connected to each control node, and a request node connected to each scheduling node; wherein each machine node is connected to a control node; The method comprises: Receive pending jobs submitted by users; Determining a first scheduling node from a plurality of scheduling nodes; Send a scheduling processing request to the first scheduling node so that the first scheduling node creates a job manager for the job to be processed, determines a first machine node with available resources, allocates machine resources in the first machine node to the job to be processed, and sends the resource allocation result of the first machine node to the corresponding first control node, receives an allocation success message fed back by the first control node, and sends an allocation success notification to the job manager so that the job manager can create a job node in the first machine node; wherein the first control node is used to determine whether the first machine node allows resource allocation, and if so, feeds back an allocation success message to the first scheduling node.

29. A resource control method, characterized in that: A first scheduling node applied to a resource control system, wherein the resource control system includes a plurality of control nodes, a plurality of scheduling nodes connected to each control node, and a request node connected to each scheduling node; wherein each machine node is connected to a control node; The method comprises: Receiving a scheduling processing request sent by the requesting node; wherein the scheduling processing request is sent by the requesting node after receiving a pending job submitted by a user; Creating a job manager for the job to be processed; Determine a first machine node with available resources, and allocate machine resources in the first machine node to the job to be processed; Sending the resource allocation result of the first machine node to the corresponding first control node; Receive an allocation success message fed back by the first control node, and send an allocation success notification to the job manager so that the job manager can create a job node in the first machine node; wherein the first control node is used to determine whether the first machine node allows resource allocation, and if so, feed back an allocation success message.

30. A resource control method, characterized in that: A first control node applied to a resource control system, wherein the resource control system comprises a plurality of control nodes, a plurality of scheduling nodes connected to each control node, and a request node connected to each scheduling node; wherein each machine node is connected to a control node; The method comprises: receiving a resource allocation result of a first machine node sent by a first scheduling node; the first control node is connected to the first machine node; wherein the resource allocation result is obtained by allocating machine resources in the first machine node to the job to be processed after the first scheduling node determines that the first machine node has available resources; the job to be processed is received by the requesting node and requests the first scheduling node to perform scheduling processing; Determining whether the first machine node allows resource allocation; If resource allocation is allowed, an allocation success message is fed back to the first scheduling node, so that the first scheduling node can send an allocation success notification to the job manager.

31. A resource control device, characterized in that: A request node applied to a resource control system, the resource control system comprising a plurality of control nodes, a plurality of scheduling nodes connected to each control node, and a request node connected to each scheduling node; wherein each machine node is connected to a control node; comprising: A job receiving module is used to receive jobs to be processed submitted by users; A node determination module, used to determine a first scheduling node from a plurality of scheduling nodes; A request processing module, used to send a scheduling processing request to the first scheduling node, so that the first scheduling node creates a job manager for the job to be processed, determines a first machine node with available resources, allocates machine resources in the first machine node to the job to be processed, and sends the resource allocation result of the first machine node to the corresponding first control node, receives an allocation success message fed back by the first control node, and sends an allocation success notification to the job manager so that the job manager can create a job node in the first machine node; wherein the first control node is used to determine whether the first machine node allows resource allocation, and if so, feeds back an allocation success message to the first scheduling node.

32. A resource control device, characterized in that: A first scheduling node applied to a resource control system, the resource control system comprising a plurality of control nodes, a plurality of scheduling nodes connected to each control node, and a request node connected to each scheduling node; wherein each machine node is connected to a control node; comprising: A request receiving module, used to receive a scheduling processing request sent by the requesting node; wherein the scheduling processing request is sent by the requesting node after receiving a pending job submitted by a user and determining a first scheduling node; A creation module, used for creating a job manager for the job to be processed; A resource allocation module, configured to determine a first machine node having available resources, and allocate machine resources in the first machine node to the job to be processed; A result sending module, used for sending the resource allocation result of the first machine node to the corresponding first control node; A notification module is used to receive an allocation success message fed back by the first control node, and send an allocation success notification to the job manager so that the job manager can create a job node in the first machine node; wherein the first control node is used to determine whether the first machine node allows resource allocation, and if so, feed back an allocation success message.

33. A resource control device, characterized in that: A first control node applied to a resource control system, the resource control system comprising a plurality of control nodes, a plurality of scheduling nodes connected to each control node, and a request node connected to each scheduling node; wherein each machine node is connected to a control node; comprising: A result receiving module is used to receive a resource allocation result of a first machine node sent by a first scheduling node; the first control node is connected to the first machine node; wherein the resource allocation result is obtained by allocating machine resources in the first machine node to the job to be processed after the first scheduling node determines that the first machine node has available resources; the job to be processed is received by the requesting node and requests the first scheduling node to perform scheduling processing; A resource determination module, used to determine whether the first machine node is allowed to allocate resources; The result feedback module is used to feed back an allocation success message to the first scheduling node if resource allocation is allowed, so that the first scheduling node can send an allocation success notification to the job manager.

34. A computing device, characterized in that The device comprises a processing component and a storage component; the device is used to run a request node in a resource control system, the resource control system comprises a plurality of control nodes, a plurality of scheduling nodes connected to each control node, and a request node connected to each scheduling node; wherein each machine node is connected to a control node; The storage component stores one or more computer instructions; the one or more computer instructions are used to be called and executed by the processing component; The processing component is used to: Receive pending jobs submitted by users; Determining a first scheduling node from a plurality of scheduling nodes; Send a scheduling processing request to the first scheduling node so that the first scheduling node creates a job manager for the job to be processed, determines a first machine node with available resources, allocates machine resources in the first machine node to the job to be processed, and sends the resource allocation result of the first machine node to the corresponding first control node, receives an allocation success message fed back by the first control node, and sends an allocation success notification to the job manager so that the job manager can create a job node in the first machine node; wherein the first control node is used to determine whether the first machine node allows resource allocation, and if so, feeds back an allocation success message to the first scheduling node.

35. A computing device, characterized in that The device comprises a processing component and a storage component; the device is used to run a first scheduling node in a resource control system, the resource control system comprises a plurality of control nodes, a plurality of scheduling nodes connected to each control node, and a request node connected to each scheduling node; wherein each machine node is connected to a control node; The storage component stores one or more computer instructions; the one or more computer instructions are used to be called and executed by the processing component; The processing component is used to: Receiving a scheduling processing request sent by the requesting node; wherein the scheduling processing request is sent by the requesting node after receiving a pending job submitted by a user and determining a first scheduling node; Creating a job manager for the job to be processed; Determine a first machine node with available resources, and allocate machine resources in the first machine node to the job to be processed; Sending the resource allocation result of the first machine node to the corresponding first control node; Receive an allocation success message fed back by the first control node, and send an allocation success notification to the job manager so that the job manager can create a job node in the first machine node; wherein the first control node is used to determine whether the first machine node allows resource allocation, and if so, feed back an allocation success message.

36. A computing device, characterized in that The device comprises a processing component and a storage component; the device is used to operate a first control node in a resource control system, the resource control system comprises a plurality of control nodes, a plurality of scheduling nodes connected to each control node, and a request node connected to each scheduling node; wherein each machine node is connected to a control node; The storage component stores one or more computer instructions; the one or more computer instructions are used to be called and executed by the processing component; The processing component is used to: receiving a resource allocation result of a first machine node sent by a first scheduling node; the first control node is connected to the first machine node; wherein the resource allocation result is obtained by allocating machine resources in the first machine node to the job to be processed after the first scheduling node determines that the first machine node has available resources; the job to be processed is received by the requesting node and requests the first scheduling node to perform scheduling processing; Determining whether the first machine node allows resource allocation; If resource allocation is allowed, an allocation success message is fed back to the first scheduling node, so that the first scheduling node can send an allocation success notification to the job manager.

Images