Task scheduling method and related device

Abstract

The present application discloses a task scheduling method, comprising: receiving a task, and scheduling the task or a task shard of the task to a first execution node in a distributed cluster; during execution of the task or the task shard by the first execution node, receiving a shard adjustment request sent by the first execution node on the basis of a load of the task or the task shard on the first execution node; and on the basis of the shard adjustment request, increasing a task shard of a task in a second execution node in the distributed cluster, or reducing the task shard of the task in the first execution node. The method can implement adaptive adjustment of a task or task shard in a running state, and the resource use is adjusted by dynamically adjusting the task shard of the task, so that the overall cluster resource reaches a load balance, preventing the risk of a task failure or node downtime due to the fact that execution nodes are completely occupied by a single task or task shard.

Description

A task scheduling method and related equipment

[0001] This application claims priority to the Chinese patent application filed with the State Intellectual Property Office on December 5, 2023, with application number 202311677310.2, and with the invention name “A task scheduling method and related equipment”, as well as the Chinese patent application filed with the State Intellectual Property Office on March 12, 2024, with application number 202410284789.1, and with the invention name “A task scheduling method and related equipment”, the entire contents of which are incorporated by reference into this application. Technical Field

[0002] The present application relates to the field of computer technology, and in particular to a task scheduling method, a task scheduling system, a computing device cluster, a computer-readable storage medium, and a computer program product. Background Art

[0003] With the continuous advancement of computer technology, applications that provide services to large-scale users are constantly emerging. Internet applications and enterprise-level applications, for example, often require large batch processing tasks. As the architecture of these applications evolves from monolithic architectures to microservices, distributed task scheduling strategies can be used to schedule tasks in microservices-based applications.

[0004] Distributed task scheduling is a type of task scheduling that runs in a distributed cluster environment. A scheduling node dispatches tasks to execution nodes within the distributed cluster for processing. With the increasing diversity of tasks, the requirements for task scheduling strategies are becoming increasingly stringent. Further exploration is needed to more accurately schedule tasks, achieve load balancing across cluster resources, and improve computing resource utilization.

[0005] However, many tasks cannot determine the amount of cluster resources required to execute the task. The scheduling node schedules the task to the execution node, which may lead to insufficient node resources after the task starts running, resulting in the failure of running the task on the node or the risk of the entire node crashing.

[0006] Summary of the Invention

[0007] This application provides a task scheduling method that adaptively adjusts the number of task slices based on the load of the running task or task slice, and can further dynamically adjust the resource usage of the task to achieve load balancing of the overall cluster resources, avoiding the risk of execution nodes being fully occupied by a single task or task slice, resulting in task failure or node downtime, and improving reliability and availability. This application also provides a scheduling system, computing device cluster, computer-readable storage medium, and computer program product corresponding to the above method.

[0008] In a first aspect, the present application provides a task scheduling method. The method can be executed by a scheduling system. The scheduling system can be a distributed task scheduling system, which is used to schedule tasks to a distributed cluster for processing by the distributed cluster. The scheduling system can be a software system, and the software system can be an independent software system, such as an independent scheduling engine, or integrated into other software, such as integrated into other software in the form of plug-ins, applets, etc. Among them, the software system can be provided to users in the form of a code package and deployed by the user themselves, or provided to users in the form of a cloud service. The software system can be deployed in a computing device cluster, and the computing device cluster executes the program code of the software system, thereby executing the task scheduling method of the present application. In some examples, the task scheduling system can also be a hardware system, such as a computing device cluster with scheduling capabilities. When the hardware system is running, the task scheduling method of the present application is executed.

[0009] Specifically, the scheduling system receives a task and schedules the task or the task slice of the task to the first execution node in the distributed cluster, where the first execution node is at least one execution node in the distributed cluster. During the process of the first execution node executing the task or the task slice, the scheduling system receives a slice adjustment request sent by the first execution node. The slice adjustment request is used to request to increase the task slice of the task or reduce the task slice of the task, and the slice adjustment request is generated by the first execution node based on the load of the task or the task slice on the first execution node. The scheduling system adjusts the task slice of the task in the distributed cluster based on the slice adjustment request. Adjusting the task slice of the task includes: increasing the task slice of the task at the second execution node, or reducing the task slice of the task in the first execution node.

[0010] This method can adaptively adjust the number of task shards according to the load of the running tasks or task shards, and then dynamically adjust the resource usage of the tasks to achieve load balancing of the overall cluster resources, avoiding the risk of task failure or node downtime caused by the execution node being occupied by a single task or task shard, thereby improving reliability and availability.

[0011] In some possible implementations, when the load of the task or task slice on the first execution node is greater than a first threshold, the slice adjustment request is used to request to increase the task slice of the task; or, when the load of the target task slice of the task on the first execution node is less than a second threshold, the slice adjustment request is used to reduce the target task slice of the task.

[0012] This allows the number of task slices to be adaptively adjusted based on the load size of the task or task slice, and then dynamically adjusts the resource usage of the task to achieve load balancing of the cluster resources.

[0013] In some possible implementations, the scheduling system includes a scheduling node and a data module. When the data module detects that a task slice of a task has been adjusted, it re-slices the processing data of the task to obtain at least one data slice, and the at least one data slice corresponds one-to-one with the adjusted task slice.

[0014] This method re-slices the task processing data when it detects that the task slice has been adjusted, for example, it re-load balances the processing data, thereby reducing the resource load occupied by tasks or task slices with heavier loads, and achieving the goal of relatively balanced overall resources.

[0015] In some possible implementations, the data module can reshard the task's processed data to obtain at least one data shard based on the adjusted number of task shards through load balancing. The data module reshards the processed data through load balancing to ensure a relatively balanced amount of data pulled by each task shard, thereby achieving relatively balanced overall resources.

[0016] In some possible implementations, the data module can also record the progress of pulling the task's processed data. Accordingly, the data module can determine the remaining data based on the task's progress and then reshard the remaining data to obtain at least one data shard. This ensures that even when the task shard changes, the processed data can be fully pulled, ensuring data uniqueness and integrity.

[0017] In some possible implementations, the data module can also send heartbeat messages to the task shards to monitor their activity. The data module then adjusts the data shards based on the activity of the task shards. This allows for dynamic monitoring of the status of the task shards, enabling coordinated adjustments between data and task shards to ensure overall resource balance.

[0018] In some possible implementations, tasks or task slices are assembled into a data body. This data body records the load of the running task or task slice, as well as the task or task slice's identity. By maintaining a data body of task information, such as a cube, and recording the load occupancy of running tasks, this method can quickly determine the resource load occupied by each running task, providing a reference for whether to reduce the number of tasks.

[0019] In some possible implementations, the task includes a log processing task.

[0020] In a second aspect, the present application provides a scheduling system. The scheduling system includes:

[0021] A scheduling node, configured to receive a scheduling task, and schedule the task or a task slice of the task to a first execution node in a distributed cluster, wherein the first execution node is at least one execution node in the distributed cluster, and receive a slice adjustment request sent by the first execution node during the process of the first execution node executing the task or the task slice, wherein the slice adjustment request is used to request to increase the task slice of the task or reduce the task slice of the task, and the slice adjustment request is generated by the first execution node according to the load of the task or the task slice of the task on the first execution node;

[0022] The scheduling node is further configured to adjust the task sharding of the task in the distributed cluster according to the sharding adjustment request;

[0023] The adjusting of the task slices of the task includes: increasing the task slices of the task in the second execution node, or reducing the task slices of the task in the first execution node.

[0024] In some possible implementations, when the load of the task or the task slice of the task on the first execution node is greater than a first threshold, the slice adjustment request is used to request to increase the task slice of the task; or, when the load of the target task slice of the task on the first execution node is less than a second threshold, the slice adjustment request is used to reduce the target task slice of the task.

[0025] In some possible implementations, the scheduling system includes the scheduling node and a data module, where the data module is specifically configured to:

[0026] When it is detected that the task slice of the task is adjusted, the processed data of the task is re-sliced ​​to obtain at least one data slice, and the at least one data slice has a one-to-one correspondence with the adjusted task slice.

[0027] In some possible implementations, the data module is specifically configured to:

[0028] According to the adjusted number of task shards, the processing data of the task is re-sharded to obtain at least one data shard through load balancing.

[0029] In some possible implementations, the data module is further configured to:

[0030] Record the progress of pulling the processing data of the task;

[0031] The data module is specifically used for:

[0032] Determining remaining data based on the progress of pulling the processing data of the task;

[0033] The remaining data is re-sharded to obtain at least one data shard.

[0034] In some possible implementations, the data module is further configured to:

[0035] Sending a heartbeat message to the task slice, wherein the heartbeat message is used to detect the activity of the task slice;

[0036] The data shards are adjusted according to the activity of the task shards.

[0037] In some possible implementations, the task or the task slice is assembled in a data body, and the data body records the load of the running task or the task slice and the identification of the task or the task slice.

[0038] In some possible implementations, the task includes a log processing task. This task can read raw logs from a corresponding log source based on the user's task configuration information, process them according to the user's desired rules, and then write the results to the intended destination. It should be noted that the task can also be other tasks with uncertain resource requirements or tasks where the resource usage of running tasks varies significantly.

[0039] This method can be applied to task scheduling scenarios of different tasks and has high availability.

[0040] In a third aspect, the present application provides a computing device cluster. The computing device cluster includes at least one computing device, wherein the at least one computing device includes at least one processor and at least one memory. The at least one processor and the at least one memory communicate with each other. The at least one processor is configured to execute instructions stored in the at least one memory, so that the computing device or computing device cluster performs the task scheduling method described in the first aspect or any implementation of the first aspect.

[0041] In a fourth aspect, the present application provides a computer-readable storage medium storing instructions, wherein the instructions instruct a computing device or a computing device cluster to execute the task scheduling method described in the first aspect or any implementation of the first aspect.

[0042] In a fifth aspect, the present application provides a computer program product comprising instructions, which, when executed on a computing device or a computing device cluster, enables the computing device or computing device cluster to execute the task scheduling method described in the first aspect or any one of the implementations of the first aspect.

[0043] Based on the implementation methods provided in the above aspects, this application can also be further combined to provide more implementation methods. BRIEF DESCRIPTION OF THE DRAWINGS

[0044] In order to more clearly illustrate the technical methods of the embodiments of the present application, the following briefly introduces the drawings required for use in the embodiments.

[0045] FIG1 is a schematic diagram of a task scheduling process provided by this application;

[0046] FIG2 is a schematic diagram of the structure of a scheduling system provided by this application;

[0047] FIG3 is a flowchart of a task scheduling method provided by the present application;

[0048] FIG4 is a schematic diagram of a task slicing adaptive adjustment provided by the present application;

[0049] FIG5 is a schematic diagram of adaptive adjustment of data sharding with task sharding provided by the present application;

[0050] FIG6 is a schematic diagram of a process for adaptive adjustment of task slicing provided by the present application;

[0051] FIG7 is a schematic diagram of a task scheduling method provided by the present application applied to a log processing scenario;

[0052] FIG8 is a schematic diagram of the structure of a scheduling node provided by the present application;

[0053] FIG9 is a schematic diagram of the structure of a computing device provided by the present application;

[0054] FIG10 is a schematic diagram of the structure of a computing device cluster provided by this application;

[0055] FIG11 is a schematic diagram of the structure of another computing device cluster provided by the present application;

[0056] FIG12 is a schematic diagram of the structure of another computing device cluster provided in this application. DETAILED DESCRIPTION

[0057] The terms "first" and "second" in the embodiments of this application are used for descriptive purposes only and should not be understood to indicate or imply relative importance or implicitly specify the number of technical features indicated. Therefore, features specified as "first" or "second" may explicitly or implicitly include one or more of the features.

[0058] First, some technical terms involved in the embodiments of this application are introduced.

[0059] Distributed task scheduling is a type of task scheduling that runs in a distributed cluster environment. Distributed refers to the deployment of different businesses split according to the microservice architecture style, and cluster refers to the deployment of the same business split according to the microservice architecture style on different nodes. Based on this, a distributed cluster refers to the cluster setting of each node in a distributed system, for example, cluster deployment of different split businesses. In specific implementation, the scheduling node can schedule tasks to the execution node in the distributed cluster for execution and processing. The scheduling node can also be called the master node, which is responsible for task scheduling, specifically scheduling tasks to reasonable execution nodes according to reasonable scheduling strategies. The execution node can also be called the worker node, which is the node that actually runs the task and completes task processing according to the task logic written by the user.

[0060] Many tasks cannot determine the amount of cluster resources required to execute the task. The scheduling node schedules the task to the execution node. After the task starts running, it may lead to insufficient node resources, which in turn leads to the failure of running the task on the node or the risk of the entire node crashing. The industry has proposed a task scheduling method based on MapReduce.

[0061] As shown in Figure 1, the task center includes Task 1 and Task 2. The scheduling center includes multiple master nodes, such as Master 1 and Master 2. The scheduling center dispatches tasks to task executors for execution. Task executors include multiple worker nodes, such as Worker 1 through Worker 3. The master node in the scheduling center monitors the load status of the cluster (the cluster formed by the worker nodes) and dynamically monitors information during the execution of each worker node. When Task 1 and Task 2 arrive at the scheduling center, the master node decides whether to split the tasks based on the current cluster load. In this example, the master node decides to split the tasks and send them to different worker nodes for processing. For example, Task 1 can be split into Task 1 Map, Task 1 Reduce-1, and Task 1 Reduce 2, and dispatched to Worker 1 through Worker 3, respectively. A MapReduce job typically divides the input dataset into several independent data blocks, which are processed by map tasks in a fully parallel manner. The output of the map tasks can serve as the input to the reduce tasks.

[0062] MapReduce-based task scheduling can achieve dynamic sharding, which can better utilize cluster resources. However, in extreme scenarios, reduce tasks can still saturate worker resources, leading to task failure or node downtime. These distributed scheduling methods assign tasks to specific executors only at the time they are issued, without considering the subsequent workload of each executor. Even with user-defined sharding policy interfaces, the entire logic is still determined at task issuance and cannot be dynamically adapted. If a high-energy-consuming task is subsequently scheduled, the scheduling engine will continue to allocate it to each executor using static sharding or MapReduce dynamic sharding, without being able to identify the subsequent resource usage of the task. This risks completely consuming the resources of the entire executor, causing other tasks to fail or the entire node to crash.

[0063] In view of this, the present application provides a task scheduling method. The method can be performed by a scheduling system. The scheduling system can be a distributed task scheduling system. The task scheduling system is suitable for scheduling scenarios where the required resource size and the number of shards are uncertain at the start of scheduling, there are a large number of batch tasks, or the required resource size in the running state changes over time, and there are long-term stable task scenarios where a single task will fully utilize the resources of the execution node. The scheduling system can be a software system. The software system can be an independent software system, such as an independent scheduling engine, or integrated into other software, such as in the form of a plug-in, mini-program, etc. The software system can be provided to users in the form of a code package and deployed by the user, or provided to users in the form of a cloud service. The software system can be deployed in a computing device cluster, which executes the program code of the software system, thereby performing the task scheduling method of the present application. In some examples, the task scheduling system can also be a hardware system, such as a computing device cluster with scheduling capabilities. When the hardware system is running, it executes the task scheduling method of the present application.

[0064] Specifically, the scheduling system can receive a task and schedule the task or the task slice of the task to the first execution node in the distributed cluster. The first execution node is at least one execution node in the distributed cluster. Then, during the process of executing the task or the task slice on the first execution node, the scheduling system receives a slice adjustment request sent by the first execution node. The slice adjustment request is used to request to increase the task slice of the task or reduce the task slice of the task. The slice adjustment request is generated by the first execution node based on the load of the task or the task slice of the task on the first execution node. The scheduling system adjusts the task slice of the task in the distributed cluster according to the slice adjustment request. Adjusting the task slice of the task includes increasing the task slice of the task on the second execution node or reducing the task slice of the task in the first execution node.

[0065] This method can adaptively adjust the number of task shards according to the load of the running tasks or task shards, and then dynamically adjust the resource usage of the tasks to achieve load balancing of the overall cluster resources, avoiding the risk of task failure or node downtime caused by the execution node being occupied by a single task or task shard, thereby improving reliability and availability.

[0066] In order to make the technical solution of the present application clearer and easier to understand, the system architecture of the present application is introduced below with reference to the accompanying drawings.

[0067] Referring to the architectural diagram of a scheduling system shown in FIG2 , the scheduling system 10 includes a scheduling node 100. Considering reliability or load balancing, the scheduling system 10 may include multiple scheduling nodes 100, and the scheduling node 100 may be a master. Among them, the scheduling nodes may form a scheduling center. The scheduling system 10 is connected to the task center 20 and the task executor 30 respectively. The task executor 30 may include a distributed cluster formed by multiple execution nodes. The scheduling system 10 is used to schedule the tasks of the task center 20 to the execution nodes in the task executor 30 for execution. Among them, the execution nodes may be working nodes. Furthermore, the scheduling system 10 may also include a data module 200.

[0068] Specifically, the scheduling node 100 is used to receive a task and schedule the task or a task slice of the task to a first execution node in a distributed cluster. The first execution node is at least one execution node in the distributed cluster. During the process of the first execution node executing the task or task slice, the scheduling node receives a slice adjustment request sent by the first execution node. The slice adjustment request is used to request to increase or reduce the task slice of the task. The slice adjustment request is generated by the first execution node based on the load of the task or the task slice of the task on the first execution node. In some examples, the slice adjustment request may include an adjustment type and an identifier of the adjustment object. The adjustment type may be to increase or reduce the task slice. The identifier of the adjustment object may include at least one of the task identifier or the task slice identifier. In other examples, the slice adjustment request may include the load of the task or task slice. The scheduling node is further used to adjust the task slice of the task in the distributed cluster based on the slice adjustment request. Adjusting the task slice of the task includes adding the task slice of the task on the second execution node or reducing the task slice of the task on the first execution node.

[0069] Data module 200 stores the data required to execute tasks, also known as task processing data. Using Figure 2 as an example, data module 200 can store data 1 (e.g., data 1) required to execute task 1 and data 2 (e.g., data 2) required to execute task 2. Tasks or task slices running on execution nodes can pull task processing data from data module 200 to execute the tasks.

[0070] The first execution node is used to sense the load of the task or task slice, decide whether to adjust the number of task slices based on the load, and then generate a slice adjustment request based on the decision result. In some possible implementations, the scheduling system can set a threshold value for deciding whether to adjust the number of task slices, such as a first threshold value or a second threshold value. When the load of the task or the task slice of the task on the first execution node is greater than the first threshold value, the slice adjustment request is used to request to increase the task slice of the task. Alternatively, when the load of the target task slice of the task on the first execution node is less than the second threshold value, the slice adjustment request is used to reduce the target task slice of the task. Among them, the first threshold value or the second threshold value can be set according to experience, and the first threshold value can be equal to the second threshold value or not equal to the second threshold value. This embodiment does not impose any restrictions on this.

[0071] Still using the example of Figure 2, task 1 is scheduled to the first execution node (such as working node 1, denoted as worker1) by the scheduling node 100 (such as master1) when scheduling begins. When worker1 senses that the load of task 1 is greater than the first threshold, it can send a shard adjustment request to the scheduling node 100. The shard adjustment request is used to request to add a task shard of task 1 to the second execution node. Among them, the second execution node can be an execution node other than the first execution node in the distributed cluster, such as worker3. Based on this, task 1 can be divided into the following task shards: task 1-1 (task1-1), task 1-2 (task1-2). Among them, task1-2 can be a newly added task shard, and task1-1 is a task shard formed after the original task 1 shares part of the load to task1-2.

[0072] When data module 200 detects an adjustment to the task slicing of a task, it reslices the task's processed data to obtain at least one data slicing. The at least one data slicing corresponds one-to-one with the adjusted task slicing. Still using the example of FIG2 , if task 1 is divided into two task slicings, data 1 can be resliced ​​into two data slicings. For example, data blocks numbered 0 through 3 in data 1 are divided into one data slicing, and data blocks numbered 4 through 7 are divided into another data slicing.

[0073] The task slices can pull data from the corresponding data slices and then process the task according to the data slices. The results of the execution nodes executing the tasks or task slices can be reported to the scheduling node 100.

[0074] Based on the aforementioned scheduling system 10, the present application further provides a task scheduling method, which is described in detail below in conjunction with embodiments.

[0075] Referring to the flowchart of a task scheduling method shown in FIG3 , the method may be executed by a scheduling system 10 . The scheduling system 10 includes a scheduling node 100 . Furthermore, the scheduling system 10 may also include a data module 200 . The method specifically includes the following steps:

[0076] S301: The scheduling node 100 receives a task.

[0077] A task refers to a task that needs to be dispatched by the scheduling node 100 to the execution node for execution. The task is a task or a batch processing task with an uncertain required resource size, an uncertain number of shards, and a resource size that changes over time in the running state. In some examples, the task may be a log processing task. The log processing task may read the original log from the corresponding log source based on the user's task configuration information, process it according to the rules expected by the user, and then write the result to the expected target. In other examples, the task may also be other tasks with uncertain required resource size or tasks with large fluctuations in the resources occupied by running tasks.

[0078] S302 : The scheduling node 100 schedules the task or the task slice of the task to the first execution node in the distributed cluster.

[0079] The first execution node is at least one execution node in the distributed cluster. The scheduling node 100 may determine the first execution node from the distributed cluster based on the load of the execution nodes in the distributed cluster. For example, the scheduling node 100 may determine the node with the smallest load or a load less than a set value as the first execution node. The scheduling node 100 may then schedule the task to the first execution node.

[0080] In some possible implementations, the scheduling node 100 may further slice the task to obtain multiple task slices. The scheduling node 100 may schedule the multiple task slices to different first execution nodes. For example, upon receiving task1, the scheduling node 100 may divide task1 into multiple task slices, specifically task1-1 and task1-2, based on the initial task requirements, and schedule task1-1 and task1-2 to different first execution nodes, wherein task1-1 is scheduled to worker1 and task1-2 is scheduled to worker2.

[0081] S304 . The scheduling node 100 receives a slicing adjustment request sent by the first execution node during the process of the first execution node executing the task or task slicing.

[0082] The slicing adjustment request is used to request to increase the task slice of a task or reduce the task slice of a task. The slicing adjustment request is generated by the first execution node based on the load of the task or task slice of the task on the first execution node. The task or task slice scheduled to the first execution node can pull the processing data corresponding to the task or task slice to execute the task or task slice. During the process of the first execution node executing the task or task slice, the first execution node can monitor the load of the task or task slice, wherein the load of the task or task slice refers to the resource load of the task or task slice. Taking computing resources as an example, the resource load of the task or task slice can be the sum of the number of processes being processed and waiting to be processed by the processor within a period of time. The first execution node can generate a slicing adjustment request based on the load of the task or task slice and send the slicing adjustment request to the scheduling node 100. Accordingly, the scheduling node 100 receives the slicing adjustment request sent by the first execution node during the execution of the task or task slice and can perform subsequent slicing adjustment operations.

[0083] The following describes in detail the process of generating a shard adjustment request.

[0084] The first execution node compares the load (e.g., resource load) of the task or the task slice of the task with a set threshold. Specifically, when the load of the task or the task slice is greater than the first threshold, the first execution node may generate a slice adjustment request for requesting to increase the task slice. When the load of the task slice is less than the second threshold, the first execution node may generate a slice adjustment request for requesting to reduce the task slice.

[0085] As illustrated in Figure 4, for task 1 (such as task1), the scheduling center schedules task1 to working node 1 (such as worker1). Worker1 detects that the load of task1 is greater than the first threshold and sends a shard adjustment request to the scheduling center. The shard adjustment request is used to request an increase in task shards of task1, for example, to add a task shard of task1 to working node 3 (such as worker3), such as task 1-2 (task1-2). Accordingly, task1 running on worker1 can become a task shard of task1, such as task 1-1 (such as task1-1). For task 2 (such as task2), the scheduling center divides task2 into three task shards, such as task 2-1 (such as task2-1), task 2-2 (such as task2-2), and task 2-3 (such as task2-3), which are respectively scheduled to worker1, working node 2 (such as worker2), and worker3. When worker2 detects that the load of task slice task2-2 executing task2 is less than the second threshold, it may send a shard adjustment request to the scheduling center, where the shard adjustment request is used to request scaling down task slice task2-2 of task2.

[0086] In some possible implementations, a task or task slice can be assembled in a data body. The data body can be a cube that carries the running task or task slice. Among them, the data body can also record the load of the running task or task slice and the identifier of the task or task slice. The task slice is a subtask of the task. Based on this, the data body can record the load of the task or subtask and the identifier of the task or subtask. The first execution node can encapsulate the task or task slice and the identifier of the task, the identifier of the task slice, and the resource load in a cube for each task or task slice scheduled to the execution node. For ease of understanding, Figure 4 is used as an example. In this example, worker1 can assemble task1 in a cube and record the identifier of the task (denoted as taskId), the identifier of the task slice (denoted as SubTaskId) and the load of the task or task slice (denoted as ResourceLoad) in the cube. Similarly, worker2 can assemble task2-2 in a cube and record the identifier of task2, the identifier of task2-2, and the load of task2-2 in the cube.

[0087] The scheduling node 100 may receive a slicing adjustment request generated by the first execution node based on the load of the task or task slice. In some examples, the slicing adjustment request may include an adjustment type and an identifier of an adjustment target. The adjustment type may be to increase or decrease a task slice, and the identifier of the adjustment target may include at least one of a task identifier or a task slice identifier. In other examples, the slicing adjustment request may include the load of the task or task slice.

[0088] S306 : The scheduling node 100 adjusts the task shards of the task in the distributed cluster according to the shard adjustment request.

[0089] Adjusting the task slices of the task includes increasing the task slices of the task in the second execution node, or reducing the task slices of the task in the first execution node. The second execution node may be an execution node other than the first execution node in the distributed cluster.

[0090] The shard adjustment request indicates an adjustment type or an adjustment object. When the adjustment type is to add task shards, the scheduling node can add task shards of the task in the second execution node according to the identifier of the task in the shard adjustment request. Among them, the scheduling node can determine the second execution node in a similar manner to determining the first execution node. The scheduling node can obtain the load of each execution node in the distributed cluster and determine the second execution node based on the load of the execution node. The second execution node can be the execution node with the smallest load among the other execution nodes in the distributed cluster except the first execution node, or the execution node with a load less than a set value. When the adjustment type is to reduce task shards, the scheduling node can reduce the target task shard in the first execution node according to the identifier of the target task shard, for example, the identifier of the target task shard in the shard adjustment request.

[0091] S308 : When the data module 200 detects that the task slice of the task is adjusted, it re-slices the processing data of the task to obtain at least one data slice.

[0092] The data module 200 stores the processing data of the task. The data module 200 can slice the processing data of the task according to the number of slices of the task to obtain at least one data slice. The newly added task slice can be automatically registered with the data module 200. In this way, the data module 200 can detect that the task slice of the task has been adjusted, and the data module 200 can re-slice the processing data of the task to obtain at least one data slice. Taking Figure 5 as an example, task1 includes the following task slices task1-1 and task1-2. When the scheduling node 100 adds a task slice task1-3, the task slice can be automatically registered with the data module 200. The data module 200 detects the increase in task slices and can re-slice the processing data of the task from 2 data slices to 3 data slices. For example, the data block numbered 3 in data slice 1 and the data blocks numbered 4 and 5 in data slice 2 can be stripped from the original data slice and merged into a new data slice.

[0093] Taking shards as an example, task processing data, such as log data, can be stored in individual shards. Shards support operations such as indexing and data querying. When the data module 200 detects a new task shard, it performs a rebalance operation, resharding the shard to ensure a relatively balanced amount of data pulled from each task shard.

[0094] In some possible implementations, the data module 200 may also record the progress of pulling the task's processed data, such as the progress of pulling the data shards. Accordingly, when resharding the task's processed data, the data module 200 may determine the remaining data based on the progress of pulling the task's processed data, and then reshard the remaining data to obtain at least one data shard. By recording the pulling progress of each data shard (e.g., shard), this method can ensure that data pulling is non-duplicated.

[0095] In some possible implementations, the data module 200 can also send a heartbeat message to the task slice, and the heartbeat message is used to detect the activity of the task slice. Among them, the activity of the task slice is used to characterize the current state of the task slice, such as whether it is a normal operating state or an inactivated state. Accordingly, the data module 200 can also adjust the data slice according to the activity of the task slice. For example, if the data module 200 detects that the task slice is inactivated, it can readjust the data slice and reduce the number of data slices. In this method, a heartbeat is maintained between the data module 200 and the task slice, and the shard assigned to the task slice is guaranteed to be updated in real time through monitoring, thereby ensuring the integrity of data pulling.

[0096] It should be noted that the above S308 is an optional step of the embodiment of the present application. The task scheduling method of the embodiment of the present application may not execute the above step.

[0097] Based on the above description, the present application provides a task scheduling method. The method receives a task and schedules the task or the task slice of the task to the first execution node in the distributed cluster. During the process of the first execution node executing the task or the task slice, the method receives a slice adjustment request generated and sent by the first execution node according to the load of the task or the task slice on the node, and adjusts the task slice of the task in the distributed cluster according to the slice adjustment request, thereby monitoring the load of the running task or the task slice, adaptively adjusting the number of tasks or task slices according to the load of the task or task slice, and then dynamically adjusting the resource usage of the task, so that the overall cluster resources are load balanced, avoiding the execution node being occupied by a single task, causing the risk of task failure or node downtime, and improving reliability and availability.

[0098] The following is an illustration of the process of adaptive adjustment of task slicing. As shown in Figure 6, the adaptive adjustment of task slicing can be divided into multiple stages: task scheduling, operation monitoring, and dynamic adjustment.

[0099] During the task scheduling phase, the scheduling node 100 receives new tasks, such as task1 and task2, and can schedule the new tasks to execution nodes with relatively abundant resources based on the scheduling policy. In the example of Figure 6, the scheduling node 100 can schedule task1 to worker1 and task2 to worker2.

[0100] During the runtime phase, each time a task pulls a batch of processing data, the worker can determine the resource load of the task. It should be noted that when a task is divided into task slices and dispatched to different workers, the worker can determine the resource load of the task slice.

[0101] During the dynamic adjustment phase, the worker can send a shard adjustment request to the scheduling node 100 to request an increase in task shards based on the monitored task load when the task load exceeds a set threshold, for example, when it exceeds a first threshold. The newly added task shards can trigger the data module 200 to rebalance. The newly added task shards can pull data from the rebalanced data shards to share the resource load of the existing tasks, thereby reducing the resource usage of the worker where the existing tasks are located. When the task load is lower than the set threshold, for example, lower than the second threshold, the worker can send a shard adjustment request to the master to request the reduction of the task shards. When the task shards of the task are not unique in the distributed cluster, the scheduling node 100 can reduce the task shards, and the remaining task shards share the data shards corresponding to the task shards.

[0102] In order to make the technical solution of this application clearer and easier to understand, this application also provides application scenarios for example illustration.

[0103] Referring to FIG7 , a schematic diagram of a task scheduling method applied to a log processing scenario is shown. In this scenario, the task can be a log processing task. The user can create a log processing task. The scheduling node 100 can divide task 1 into two task shards, specifically task 1-1 and task 1-2, based on the initial task requirements, and schedule the two task shards, assigning them to worker 1 and worker 2, respectively. The two task shards each pull data corresponding to log 1 (such as the log1 log stream) in the log pulling module. Task 1-1 pulls log data from shards 0-2, and task 1-2 pulls log data from shards 3-5. The log data is input into the function module for processing according to user-defined rules, and the processed log is output. The user-defined rules can be rules based on a domain-specific language (DSL). A domain-specific language is a language used in a specific context within a specific domain. It is usually optimized for a specific type of problem and includes a higher-level abstract programming language. A DSL can use concepts and rules from a professional or domain to process log data and output a processed log.

[0104] During the operation of the log processing task, when it is monitored that the load (or occupied resources) of the task shard task1-1 exceeds the set threshold (for example, the first threshold), the scheduling node 100 is automatically requested to add the shard of task 1 (task1). The scheduling node 100 schedules the task shard task1-3 to worker3. The log pulling module monitors the task shard corresponding to the newly added log1 and rebalances it, allocating 0-1 shard to task1-1, 2-3 shard to task1-2, and 4-5 shard to task1-3, thereby reducing the resource load occupied by task1-1 and achieving relatively balanced overall resources.

[0105] Based on the aforementioned task scheduling method, the present application also provides a scheduling system. As shown in FIG2 , the scheduling system 10 includes:

[0106] The scheduling node 100 is configured to receive a scheduling task and schedule the task or a task slice of the task to a first execution node in a distributed cluster. The first execution node is at least one execution node in the distributed cluster. During execution of the task or the task slice by the first execution node, the scheduling node 100 receives a slice adjustment request sent by the first execution node. The slice adjustment request is used to request to increase the task slice of the task or reduce the task slice of the task. The slice adjustment request is generated by the first execution node based on the load of the task or the task slice of the task on the first execution node.

[0107] The scheduling node 100 is further configured to adjust the task slices of the task in the distributed cluster according to the slice adjustment request, wherein adjusting the task slices of the task includes: increasing the task slices of the task in the second execution node, or reducing the task slices of the task in the first execution node.

[0108] The scheduling node 100 can be implemented in software or hardware. When implemented in hardware, the scheduling node 100 can include at least one computing device, such as a server. When implemented in software, the scheduling node 100 can be an application running on the computing device, such as a virtualized application.

[0109] Furthermore, referring to FIG8 , the scheduling node 100 may include the following functional modules:

[0110] Interaction module 102, used for receiving scheduling tasks;

[0111] A scheduling module 104 is configured to schedule a task or a task slice to a first execution node in the distributed cluster, where the first execution node is at least one execution node in the distributed cluster;

[0112] The interaction module 102 is further configured to receive a shard adjustment request sent by the first execution node during the process of the first execution node executing the task or the task shard, wherein the shard adjustment request is used to request to increase the task shard of the task or to reduce the task shard of the task, and the shard adjustment request is generated by the first execution node based on the load of the task or the task shard of the task on the first execution node;

[0113] The adjustment module 106 is configured to adjust the task shards of the task in the distributed cluster according to the shard adjustment request.

[0114] The interaction module 102 , the scheduling module 104 or the adjustment module 106 may be implemented by software or hardware.

[0115] When implemented via software, the interaction module 102, scheduling module 104, or adjustment module 106 can be an application running on a computing device, such as a computing engine. This application can be provided to users via virtualization services. Virtualization services can include virtual machine (VM) services, bare metal server (BMS) services, and container services. VM services can use virtualization technology to create a virtual machine (VM) resource pool on multiple physical hosts, providing users with VMs on demand. BMS services use virtualized BMS resource pools on multiple physical hosts, providing users with BMSs on demand. Container services use virtualized container resource pools on multiple physical hosts, providing users with containers on demand. A VM is a simulated virtual computer, or logically a single computer. BMS is a scalable, high-performance computing service with computing performance comparable to traditional physical machines and secure physical isolation. Containers are a kernel virtualization technology that provides lightweight virtualization to isolate user space, processes, and resources. It should be understood that the VM service, BMS service and container service in the above-mentioned virtualization services are only specific examples. In actual applications, virtualization services can also be other lightweight or heavyweight virtualization services, which are not specifically limited here.

[0116] When implemented through hardware, the interaction module 102, the scheduling module 104, or the adjustment module 106 may include at least one computing device, such as a server. Alternatively, the interaction module 102, the scheduling module 104, or the adjustment module 106 may be implemented using an application-specific integrated circuit (ASIC) or a programmable logic device (PLD). The PLD may be a complex programmable logical device (CPLD), a field-programmable gate array (FPGA), a generic array logic (GAL), or any combination thereof.

[0117] In some possible implementations, when the load of the task or the task slice of the task on the first execution node is greater than a first threshold, the shard adjustment request is used to request to increase the task slice of the task; or, when the load of the target task slice of the task on the first execution node is less than a second threshold, the shard adjustment request is used to reduce the target task slice of the task.

[0118] In some possible implementations, the scheduling system 10 includes a scheduling node 100 and a data module 200. The data module 200 is specifically configured to:

[0119] When it is detected that the task slice of the task is adjusted, the processing data of the task is re-sliced ​​to obtain at least one data slice, and the at least one data slice corresponds to the adjusted task slice one-to-one.

[0120] Similar to the interaction module 102 , the scheduling module 104 or the adjustment module 106 , the data module 200 may be implemented by software or hardware.

[0121] When implemented via software, data module 200 can be an application running on a computing device, such as a computing engine. This application can be provided to users via virtualization services such as VM services, BMS services, or container services. When implemented via hardware, data module 200 can include at least one computing device, such as a server. Alternatively, data module 200 can be implemented using an ASIC or PLD.

[0122] In some possible implementations, the data module 200 is specifically configured to:

[0123] According to the adjusted number of task shards, the task processing data is re-sharded to obtain at least one data shard through load balancing.

[0124] In some possible implementations, the data module 200 is further configured to:

[0125] Record the progress of pulling task processing data;

[0126] The data module 200 is specifically used for:

[0127] Determine the remaining data based on the progress of pulling the task's processing data;

[0128] The remaining data is resharded to obtain at least one data shard.

[0129] In some possible implementations, the data module 200 is further configured to:

[0130] Send heartbeat messages to task shards. Heartbeat messages are used to detect the activity of task shards.

[0131] Adjust data sharding based on the activity of task sharding.

[0132] In some possible implementations, tasks or task slices are assembled in a data body, which records the load of the running tasks or task slices and the identification of the tasks or task slices.

[0133] In some possible implementations, the task includes a log processing task.

[0134] This application also provides a computing device 900. As shown in Figure 9, computing device 900 includes a bus 902, a processor 904, a memory 906, and a communication interface 908. Processor 904, memory 906, and communication interface 908 communicate with each other via bus 902. Computing device 900 can be a server or a terminal device. It should be understood that this application does not limit the number of processors and memories in computing device 900.

[0135] Bus 902 may be a Peripheral Component Interconnect (PCI) bus or an Extended Industry Standard Architecture (EISA) bus, among others. Buses may be classified as address buses, data buses, control buses, and the like. For ease of illustration, FIG9 illustrates a single bus line, but this does not imply a single bus or type of bus. Bus 902 may include a path for transmitting information between various components of computing device 900 (e.g., memory 906, processor 904, and communication interface 908).

[0136] The processor 904 may include any one or more processors such as a central processing unit (CPU), a graphics processing unit (GPU), a microprocessor (MP), or a digital signal processor (DSP).

[0137] The memory 906 may include a volatile memory, such as a random access memory (RAM). The memory 906 may also include a non-volatile memory, such as a read-only memory (ROM), a flash memory, a hard disk drive (HDD) or a solid state drive (SSD). The memory 906 stores an executable program code, and the processor 904 executes the executable program code to implement the aforementioned task scheduling method. Specifically, the memory 906 stores instructions for the scheduling system 10 to execute the task scheduling method. For example, the memory 906 may store instructions for the interaction module 102, the scheduling module 104, and the adjustment module 106 in the scheduling node 100. Furthermore, the memory 906 may also store instructions for the data module 200.

[0138] The communication interface 908 uses a transceiver module such as, but not limited to, a network interface card or a transceiver to implement communication between the computing device 900 and other devices or a communication network.

[0139] Embodiments of the present application also provide a computing device cluster. The computing device cluster includes at least one computing device. The computing device can be a server, such as a central server, an edge server, or a local server in a local data center. In some embodiments, the computing device can also be a terminal device such as a desktop computer, a laptop computer, or a smartphone.

[0140] As shown in Figure 10, the computing device cluster includes at least one computing device 900. The memory 906 of one or more computing devices 900 in the computing device cluster may store the same instructions of the scheduling system 10 for executing the task scheduling method.

[0141] In some possible implementations, one or more computing devices 900 in the computing device cluster may also be used to execute some of the instructions of the scheduling system 10 for executing the task scheduling method. In other words, a combination of one or more computing devices 900 may jointly execute the instructions of the scheduling system 10 for executing the task scheduling method.

[0142] It should be noted that the memories 906 in different computing devices 900 in the computing device cluster may store different instructions for executing partial functions of the scheduling system 10 .

[0143] Figure 11 illustrates a possible implementation. As shown in Figure 11, two computing devices 900A and 900B are connected via a communication interface 908. The memory in computing device 900A stores instructions for executing the functions of scheduling node 100, such as instructions for executing the functions of interaction module 102, scheduling module 104, and adjustment module 106. Furthermore, the memory in computing device 900B stores instructions for executing the functions of data module 200. In other words, the memories 906 of computing devices 900A and 900B jointly store instructions for the scheduling system 10 to execute the task scheduling method.

[0144] The connection mode between the computing device clusters shown in Figure 11 may be considered to be based on the fact that the task scheduling method provided by this application requires more resources to detect whether the task slices are adjusted. Therefore, it is considered to hand over the functions implemented by the data module 200 to the computing device 900B.

[0145] It should be understood that the functionality of the computing device 900A shown in FIG11 may also be implemented by multiple computing devices 900. Similarly, the functionality of the computing device 900B may also be implemented by multiple computing devices 900.

[0146] In some possible implementations, one or more computing devices in a computing device cluster may be connected via a network. The network may be a wide area network or a local area network, etc. FIG12 shows a possible implementation. As shown in FIG12 , two computing devices 900C and 900D are connected via a network. Specifically, the network is connected via a communication interface in each computing device. In this type of possible implementation, the memory 906 in the computing device 900C stores instructions for executing the functions of the scheduling node 100, such as instructions for executing the functions of the interaction module 102, the scheduling module 104, and the adjustment module 106. At the same time, the memory 906 in the computing device 900D stores instructions for executing the functions of the data module 200.

[0147] The connection method between the computing device clusters shown in Figure 12 can be considered to be that the task scheduling method provided in this application requires more resources to perform task slicing detection, so it is considered to hand over the functions implemented by the data module 200 to the computing device 900D for execution.

[0148] It should be understood that the functionality of the computing device 900C shown in FIG12 may also be accomplished by multiple computing devices 900. Similarly, the functionality of the computing device 900D may also be accomplished by multiple computing devices 900.

[0149] The embodiment of the present application also provides a computer-readable storage medium. The computer-readable storage medium can be any available medium that can be stored by a computing device or a data storage device such as a data center that contains one or more available media. The available medium can be a magnetic medium (e.g., a floppy disk, a hard disk, a tape), an optical medium (e.g., a DVD), or a semiconductor medium (e.g., a solid-state drive). The computer-readable storage medium includes instructions that instruct the computing device to execute the task scheduling method applied to the scheduling system 10.

[0150] The present application also provides a computer program product including instructions. The computer program product may be software or a program product including instructions that can be run on a computing device or stored in any available medium. When the computer program product is run on at least one computing device, the at least one computing device executes the task scheduling method described above.

[0151] Finally, it should be noted that the above embodiments are only used to illustrate the technical solutions of the present invention, rather than to limit it. Although the present invention 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 protection scope of the technical solutions of the various embodiments of the present invention.

Claims

1. A task scheduling method, characterized in that: The method comprises: The scheduling system receives the task; The scheduling system schedules the task or the task slice of the task to a first execution node in the distributed cluster, where the first execution node is at least one execution node in the distributed cluster; During the process of the first execution node executing the task or the task slice, the scheduling system receives a slice adjustment request sent by the first execution node, the slice adjustment request is used to request to increase the task slice of the task or reduce the task slice of the task, and the slice adjustment request is generated by the first execution node according to the load of the task or the task slice on the first execution node; The scheduling system adjusts the task slice of the task in the distributed cluster according to the slice adjustment request; The adjusting of the task slices of the task includes: increasing the task slices of the task in the second execution node, or reducing the task slices of the task in the first execution node.

2. The method according to claim 1, characterized in that When the load of the task or the task slice on the first execution node is greater than a first threshold, the slice adjustment request is used to request to increase the task slice of the task; or, when the load of the target task slice of the task on the first execution node is less than a second threshold, the slice adjustment request is used to reduce the target task slice of the task.

3. The method according to claim 1 or 2, characterized in that: The scheduling system includes a scheduling node and a data module, and the method further includes: When the data module detects that the task slice of the task is adjusted, the processing data of the task is re-sliced ​​to obtain at least one data slice, and the at least one data slice corresponds to the adjusted task slice one by one.

4. The method according to claim 3, characterized in that The data module re-shards the processed data of the task to obtain at least one data shard, including: The data module re-slices the processing data of the task to obtain at least one data slice through load balancing according to the adjusted number of task slices.

5. The method according to claim 3, characterized in that: The method further comprises: The data module records the progress of pulling the processing data of the task; The data module re-shards the processed data of the task to obtain at least one data shard, including: The data module determines the remaining data according to the pulling progress of the processing data of the task; The data module re-shards the remaining data to obtain at least one data shard.

6. The method according to any one of claims 3 to 5, characterized in that: Said also includes: The data module sends a heartbeat message to the task slice, and the heartbeat message is used to detect the activity of the task slice; The data module adjusts the data slice according to the activity of the task slice.

7. The method according to any one of claims 1 to 6, characterized in that: The task or the task slice is assembled in a data body, and the data body records the load of the running task or the task slice and the identification of the task or the task slice.

8. The method according to any one of claims 1 to 7, characterized in that: The tasks include log processing tasks.

9. A scheduling system, characterized in that: The dispatching system comprises: A scheduling node, used for receiving a scheduling task, scheduling the task or the task slice of the task to a first execution node in a distributed cluster, the first execution node being at least one execution node in the distributed cluster, and receiving a slice adjustment request sent by the first execution node during the process of the first execution node executing the task or the task slice, the slice adjustment request being used to request to increase the task slice of the task or reduce the task slice of the task, the slice adjustment request being generated by the first execution node according to the load of the task or the task slice of the task on the first execution node; The scheduling node is further used to adjust the task slice of the task in the distributed cluster according to the slice adjustment request; The adjusting of the task slices of the task includes: increasing the task slices of the task in the second execution node, or reducing the task slices of the task in the first execution node.

10. The system according to claim 9, characterized in that When the load of the task or the task slice of the task on the first execution node is greater than a first threshold, the slice adjustment request is used to request to increase the task slice of the task; or, when the load of the target task slice of the task on the first execution node is less than a second threshold, the slice adjustment request is used to reduce the target task slice of the task.

11. The system according to claim 9 or 10, characterized in that: The scheduling system includes the scheduling node and a data module, and the data module is specifically used for: When it is detected that the task slice of the task is adjusted, the processed data of the task is re-sliced ​​to obtain at least one data slice, and the at least one data slice corresponds to the adjusted task slice one by one.

12. The system according to claim 11, characterized in that The data module is specifically used for: According to the adjusted number of task slices, the processing data of the task is re-sliced ​​to obtain at least one data slice through load balancing.

13. The system according to claim 11, characterized in that The data module is also used for: Record the progress of pulling the processing data of the task; The data module is specifically used for: Determining remaining data according to the pulling progress of the processing data of the task; The remaining data is re-sharded to obtain at least one data shard.

14. The system according to any one of claims 9 to 13, characterized in that: The data module is also used for: Sending a heartbeat message to the task slice, wherein the heartbeat message is used to detect the activity of the task slice; The data shards are adjusted according to the activity of the task shards.

15. The system according to any one of claims 9 to 14, characterized in that The task or the task slice is assembled in a data body, and the data body records the load of the running task or the task slice and the identification of the task or the task slice.

16. The system according to any one of claims 9 to 15, characterized in that The tasks include log processing tasks.

17. A computing device cluster, characterized in that: The computing device cluster includes at least one computing device, and the at least one computing device includes at least one processor and at least one memory, wherein the at least one memory stores computer-readable instructions; the at least one processor executes the computer-readable instructions so that the computing device cluster performs the task scheduling method as described in any one of claims 1 to 8.

18. A computer-readable storage medium, characterized in that: Comprising computer-readable instructions; the computer-readable instructions are used to implement the task scheduling method described in any one of claims 1 to 8.

19. A computer program product, characterized in that Comprising computer-readable instructions; the computer-readable instructions are used to implement the task scheduling method described in any one of claims 1 to 8.

Images