A preemptive task scheduling method and apparatus for log structure merging trees

Abstract

This invention discloses a preemptive task scheduling method and apparatus for log structure merging trees, belonging to the field of data merging. The method includes: responding in real-time to workload by generating corresponding tasks in a scheduler; wherein the task types include transaction query, file propagation, and file merging; each task is configured with priority, work granularity, and completion status; for each idle background thread, the following steps are performed: assigning a task to the current thread based on the priority of each task in the scheduler; after the current thread advances the iterator by a fixed step size based on the work granularity of the task, pausing the task and releasing the thread; if the task is completed, it is deleted from the scheduler; if the task is not completed, its priority is increased based on the number of times it has been executed, so that it can wait for reassignment. This solution can improve the rationality of computational resource allocation and processing efficiency in adaptive response to time-varying read / write hot requests.

Description

Technical Field

[0001] This invention relates to the field of data merging technology, and in particular to a preemptive task scheduling method and apparatus for log structure merging trees. Background Technology

[0002] Log Structure Merge Tree (LSM-Tree) is widely used as the underlying storage engine in many database systems, including RocksDB, LevelDB, Cassandra, and HBase, serving various real-world HTAP (Hybrid Transactional / Analytical Processing) applications such as IoT and 5G, real-time fraud detection, and instant decision-making. This is due to its adherence to a non-in-place data ingestion paradigm. It facilitates concurrent read / write processing by buffering data modifications in a sequential, memory-resident structure, deferring file changes and physical garbage collection to background merge operations during data propagation to deeper levels on disk.

[0003] However, modern HTAP workloads often exhibit time-varying skew in key access patterns. In practical applications, read / write hotspots can shift significantly over time. Furthermore, bursts of dense requests within hotspots can easily lead to high concurrency levels, exceeding system resource capacity. This extreme time-varying nature presents a significant challenge to LSM-Tree systems, which are typically constrained by pre-defined rigid configurations, including pre-defined thread resource allocation and existing background file merging strategies. Thread allocation between foreground queries and background merging is usually pre-defined (e.g., even distribution) and remains static at runtime. This means that existing thread pool partitioning mechanisms cannot proactively pause and switch tasks during execution, resulting in coarse-grained scheduling of similar tasks and a lack of fairness control. Therefore, bursts of requests from hotspots can overwhelm background threads, causing task blocking.

[0004] Existing background file merging strategies include two types: leveling and tiering. In practice, these two merging strategies are typically used independently at the LSM-Tree level, meaning that the selected merging strategy is uniformly applied to the entire key range within a single level. This configuration becomes inefficient when read / write hotspots in an HTAP workload occur simultaneously in different key regions. If a read-friendly leveling strategy is used upfront to facilitate lookup operations, write stalls and latency spikes are more likely to occur due to the accumulation of files to be merged in write hotspots and the exclusive use of resources by long-term merging processes. Conversely, a write-friendly tiering strategy will significantly degrade lookup performance due to more severe read amplification.

[0005] Therefore, there is an urgent need for a preemptive task scheduling method and apparatus for log structure merging trees that can improve the adaptability to time-varying tilt key access patterns, reduce latency peaks and write stalls, thereby improving the overall response efficiency and processing capacity of the system. Summary of the Invention

[0006] This invention provides a preemptive task scheduling method and apparatus for log structure merging trees, which can solve the problems of low response efficiency and slow processing capacity in existing LSM-Tree systems when facing time-varying read / write hot requests, due to traditional background file merging strategies and thread allocation granularity. The technical solution is as follows: On the one hand, a preemptive task scheduling method for log structure merging trees is provided, the method comprising: The scheduler generates corresponding tasks in real time to respond to the workload. The task types include transaction query, file propagation, and file merging. Each task is configured with priority, work granularity, and completion level. The work granularity of the file propagation task is smaller than that of the transaction query and file merging tasks. The work granularity of the transaction query task must cover the work granularity required to complete the transaction query task, and the work granularity of the file merging task is smaller than that required to complete the file merging task. For each idle background thread, the following steps are performed: Assign a task to the current thread based on the priority of each task in the scheduler; After the current thread advances the iterator by a fixed step size based on the work granularity of the task, the task is paused and the thread is released. If the task is completed, then delete the task from the scheduler; If the task is not completed, its priority is increased based on the number of times it has been executed, so that it can be reassigned for execution.

[0007] On the other hand, a preemptive task scheduling device for log structure merging trees is provided, the device comprising: The generation unit is used to respond to the workload in real time and generate corresponding tasks in the scheduler. The task types include transaction query, file propagation, and file merging. Each task is set with priority, work granularity, and completion degree. The work granularity of the file propagation task is smaller than that of the transaction query and file merging tasks. The work granularity of the transaction query task is required to cover the work granularity required to complete the transaction query task, and the work granularity of the file merging task is smaller than that required to complete the file merging task. The allocation unit is used to perform the following for each idle background thread: allocate a task to the current thread based on the priority of each task in the scheduler; The calling unit is used to call the current thread to advance the task by a fixed step size based on the work granularity driven iterator of the task, then pause the task and release the thread; The deletion unit is used to delete the task from the scheduler if the task is completed. The priority unit is used to increase the priority of a task based on the number of times it has been executed if the task has not been completed, so that it can be reassigned for execution.

[0008] On the other hand, a computer device is provided, the computer device including a memory and a processor, the memory for storing a computer program, and the processor for executing the computer program stored in the memory to implement the steps of the method described above.

[0009] On the other hand, a computer-readable storage medium is provided, wherein a computer program is stored therein, and when the computer program is executed by a processor, it implements the steps of the method described above.

[0010] On the other hand, a computer program product is provided, including a computer program that, when executed by a processor, implements the steps of the method described above.

[0011] The technical solution provided by this invention can bring at least the following beneficial effects: By refining the task granularity of write load, a fine-grained elastic merging strategy is designed to achieve flexible task-based switching and scheduling between tiering and leveling merging strategies. Furthermore, by further subdividing the file merging task granularity, a single merging task can be executed by calling multiple threads, enabling task pauses and switching. This alleviates the amplification bottleneck of HTAP workloads with skew-key access patterns. A scheduler is introduced in conjunction with a task priority mechanism to dynamically manage task execution, breaking the opacity of resource allocation between front-end query processing and back-end merging in LSM-Tree. This improves the rationality and processing efficiency of adaptive response to time-varying skewed read / write hot requests. Attached Figure Description

[0012] To more clearly illustrate the technical solutions in the embodiments of the present invention or the prior art, the drawings used in the description of the embodiments or the prior art will be briefly introduced below. Obviously, the drawings described below are some embodiments of the present invention. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0013] Figure 1 This is a flowchart of a preemptive task scheduling method for a log structure merging tree provided in an embodiment of the present invention; Figure 2This is a structural diagram of a preemptive task scheduling device for a log structure merging tree provided in an embodiment of the present invention; Figure 3 This is a hardware architecture diagram of a computer device provided in an embodiment of the present invention. Detailed Implementation

[0014] To make the objectives, technical solutions, and advantages of the embodiments of the present invention clearer, the technical solutions of the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are some embodiments of the present invention, but not all embodiments. All other embodiments obtained by those skilled in the art based on the embodiments of the present invention without creative effort are within the scope of protection of the present invention.

[0015] The specific implementation of the above concept is described below.

[0016] Please refer to Figure 1 This invention provides a preemptive task scheduling method for log structure merging trees, the method comprising: Step 100: Respond to the workload in real time and generate corresponding tasks in the scheduler; among them, the task types include transaction query, file propagation and file merging; each task is set with priority, work granularity and completion degree; the work granularity of the file propagation task is smaller than that of the transaction query and file merging tasks; the work granularity of the transaction query task is required to cover the work granularity required to complete the transaction query task, and the work granularity of the file merging task is smaller than that required to complete the file merging task. Step 102: For each idle background thread, perform the following: Assign tasks to the current thread based on the priority of each task in the scheduler; Step 104: After the current thread advances the iterator by a fixed step size based on the task's work granularity, the task is paused and the thread is released. Step 106: If the task is completed, delete the task from the scheduler. Step 108: If the task is not completed, increase the priority of the task based on the number of times it has been executed, so that it can be reassigned for execution.

[0017] In this embodiment of the invention, by refining the task granularity of the write load, a fine-grained elastic merging strategy is designed to achieve flexible task-based switching and scheduling between tiering and leveling merging strategies. Furthermore, by subdividing the file merging task granularity, a single merging task can be executed by calling threads multiple times, enabling task pauses and switching. This can alleviate the amplification bottleneck of HTAP workloads with tilt-key access patterns. A scheduler is introduced in conjunction with a task priority mechanism to dynamically manage task execution, breaking the opacity of resource allocation between front-end query processing and back-end merging in the LSM-Tree. This improves the rationality of computational resource allocation and processing efficiency in adaptive response to time-varying tilt-key read / write hotspot requests.

[0018] The following description Figure 1 The execution method for each step is shown.

[0019] For step 100: In this embodiment, the file propagation task is as follows: When a workload triggers the merging of files to be merged into files at the next level of the tree structure, the files to be merged are propagated to the buffer segment at the next level; wherein the files to be merged and the original files at that level share an overlap key range.

[0020] The triggering condition for the file merging task is: When the size of files in a buffer segment at any level exceeds the configured capacity, a task is triggered to merge the files in that buffer segment with the original files at that level.

[0021] As mentioned earlier, the traditional leveling merging method integrates and merges files from the previous level with those from the next level, as long as the previous level's files meet the requirements of the lower-level merging mechanism. This results in files with non-overlapping key ranges. Because of the non-overlapping key ranges, this method is easy to locate when searching for a specific key value, making it read-friendly. However, due to the accumulation of files to be merged in write hotspots and the resource monopolization during long-term merging processes, write stalls and latency spikes are likely to occur, making it write-unfriendly. In contrast, the tiering merging method allows overlapping key ranges at each level, making it write-friendly but read-unfriendly because searching for a specific key value range will result in finding multiple files. Furthermore, the two traditional merging methods are typically used independently at the level granularity, meaning only one merging method can be set per level.

[0022] Therefore, in this embodiment, by setting a buffer segment at each level, when the workload triggers the merging of files to be merged into files at the next level of the tree structure, the files to be merged are only propagated to the buffer segment at the next level and are not merged with the files at the next level temporarily. This is a file propagation task. Because the required time is particularly short, the granularity of the file propagation task is the smallest, and the highest priority can be set.

[0023] When the size of files in a buffer segment at each level exceeds the configured capacity, the files in that buffer segment are merged with the original files at that level; this is the file merging task. It can be seen that the merging strategy in this embodiment refines the flat merging strategy into multiple tasks and incorporates a stacked shared overlap key range. Therefore, this embodiment proposes a novel fine-grained merging strategy to address the inherent amplification bottleneck of tiered key access patterns in LSM-Tree processing of HTAP workloads. In this strategy, the files to be merged in each merge are first propagated to the next level in a hierarchical manner, forming buffer segments with files sharing the same overlap key range. When the size of a buffer segment exceeds its configured limit, a leveling-like merging task is triggered to sort and merge the entries within it. In this way, the flexible switching scheduling between tiering and leveling merges can be further delegated at the task granularity to the global scheduler for thread allocation based on priority.

[0024] It's important to note that the granularity of each task is set to the step size required to advance the iterator with each thread call. Since the file propagation task requires the least time, its granularity is smaller than that of the transaction query and file merge tasks. Furthermore, the transaction query task is more urgent, as the client is waiting; therefore, its granularity must cover the necessary work to complete the transaction query task—one thread call, one execution, is sufficient to complete the query, without multiple executions. The file merge task, however, runs in the background and takes the longest. To prevent sudden request spikes from occupying threads for extended periods and blocking other tasks, its granularity is smaller than the necessary work to complete the file merge task—one thread call, one execution, only completes a portion of the file merge task, resulting in multiple executions. Therefore, the granularity setting mechanism for the file merge task allows threads to proactively pause and switch tasks, refining the scheduling granularity and improving control fairness.

[0025] In some implementations, priority is set in the following manner: The priority scores for file propagation tasks and transaction query tasks are set to the first and third preset values, respectively. When the buffer segment in a file merging task is located at level L0, the priority score of the file merging task is set to a second set value; wherein, the first set value is greater than the second set value, and the second set value is greater than the third set value; The priority scores of file merging tasks located in the buffer segment from the L1 level to the LN level of the structure tree are distributed evenly in descending order to a third set value between 0 and 0.

[0026] For example, the priority scores for file propagation tasks and transaction query tasks are set to a first setting of 100 and a third setting of 80, respectively; when the buffer segment in a file merge task is located at level L0, the priority score for that file merge task is set to a second setting of 90. The first setting is greater than the second setting, and the second setting is greater than the third setting. Since blocking a merge at level L0 will affect the execution of all tasks, the priority of a file merge task at level L0 should be higher than the priority of a transaction query task.

[0027] The priority score for file merging tasks located in the L1 level of the buffer segment should be calculated using the following formula: In the formula, This represents the priority score for file merging tasks located in the Ld layer of the buffer segment. This is the third set value. The total number of levels in the tree structure. To indicate which layer the buffer segment is located in, d is not equal to 0. This is the third set value.

[0028] Assuming the tree structure has three levels, L0, L1, and L2, and the buffer segment is located in the remaining levels excluding L0, then... The priority score for the file merging task located in the L1 level of the buffer segment is 40. The priority score for file merging tasks located in the L2 layer of the buffer segment is 0.

[0029] Regarding step 102: In some implementations, background threads include elastic threads and merge threads; Elastic threads are used to execute three types of tasks: transaction query, file propagation, and file merging, and are allocated based on the priority of each task. The merge thread is used to perform file merge tasks based on priority.

[0030] Traditional background threads do not differentiate between them. In this embodiment, to ensure that all three types of tasks can proceed smoothly, an elastic thread and a merging thread are set up. The elastic thread is used to execute the three types of tasks: transaction query, file propagation, and file merging. The merging thread is used to execute the file merging task, which can further avoid blocking of a certain type of task.

[0031] In some implementations, idle threads are assigned tasks in the following manner: Determine whether both elastic threads and merged threads exist simultaneously in the current background idle threads; If so, tasks are assigned to each merging thread based on the priority of each file merging task, and then tasks are assigned to each elastic thread based on the priority of the remaining tasks. If not, task allocation will be based on the type of currently idle thread and the priority of the corresponding task.

[0032] In this embodiment, although the file propagation task has the highest priority, this is mainly because the thread time it occupies is very short. However, the file merging task at layer L0 is the most urgent. If there are both elastic threads and merging threads in the background idle threads, the task will be assigned to the merging thread first to ensure that the file merging task at layer L0 is given priority. At the same time, the existence of elastic threads and the setting of the priority of the file propagation task to the highest can also ensure the execution speed of the file propagation task.

[0033] This invention proposes a step-size-based scheduling strategy to ensure deterministic resource allocation while enabling dynamic priority adjustment between tasks. Transaction query tasks and L0 layer critical merges are given elevated priorities to ensure timely preemptive execution, effectively mitigating severe latency spikes caused by rigid resource constraints during HTAP.

[0034] Regarding steps 104 and 106: In this embodiment, a unified iterator-based work granularity is introduced, decomposing all tasks into comparable, bounded work units. Each unit corresponds to a fixed step size (i.e., work granularity) in the multi-level structure within the LSM-Tree, which advances the iterator forward. Furthermore, the work granularity of the file merging task in this embodiment is set to be very short, which can ensure flexibility and achieve a balance between system responsiveness and scheduling overhead.

[0035] Regarding step 108: In some implementations, task priority is increased in the following ways: In the formula, To improve the score of the later priority, The initial priority score set for this task. This represents the current number of times the task has been executed. For the final priority score, This is the third set value.

[0036] In this embodiment, to avoid excessive delays caused by multiple executions of file merging tasks in layers other than L0, a method of prioritizing tasks based on the number of executions is set up so that when multiple file merging tasks of the same level occur, those with more executions and higher completion rates are given priority.

[0037] Compared to existing technologies, this invention abandons the rigid configuration pre-defined in traditional LSM-Trees. Through elastic resource allocation based on task scheduling and fine-grained merging strategies, it achieves efficient resource management and merging optimization in HTAP workload scenarios. The proposed solution significantly improves the execution efficiency of LSM-Tree systems, greatly reducing latency spikes and write stalls while optimizing the utilization efficiency of computing resources. This effectively reduces response latency and computing resource consumption when handling HTAP workloads, exhibiting excellent performance, especially in large-scale time-varying skew-key access scenarios. Verification using the PULSE prototype system built on RocksDB demonstrates that this solution effectively mitigates latency spikes and achieves superior performance in intensive HTAP workloads.

[0038] Please refer to Figure 2 This invention provides a preemptive task scheduling device for a log structure merging tree, the device comprising: The generation unit 201 is used to respond to the workload in real time and generate corresponding tasks in the scheduler. The task types include transaction query, file propagation and file merging. Each task is set with priority, work granularity and completion degree. The work granularity of the file propagation task is smaller than that of the transaction query and file merging tasks. The work granularity of the transaction query task is required to cover the work granularity required to complete the transaction query task, and the work granularity of the file merging task is smaller than that required to complete the file merging task. Allocation unit 202 is used to perform the following for each idle background thread: allocate a task to the current thread based on the priority of each task in the scheduler; Calling unit 203 is used to call the current thread to advance the iterator based on the work granularity of the task by a fixed step size, then pause the task and release the thread. The deletion unit 204 is used to delete the task in the scheduler if the task is completed. The escalation unit 205 is used to increase the priority of the task based on the number of times the task has been executed if the task has not been completed, so as to wait for the task to be reassigned for execution.

[0039] It should be noted that the preemptive task scheduling device for log structure merging trees provided in the above embodiments is only an example of the division of the above functional modules. In practical applications, the above functions can be assigned to different functional modules as needed, that is, the internal structure of the device can be divided into different functional modules to complete all or part of the functions described above. In addition, the above device embodiments and method embodiments belong to the same concept, and the specific implementation process can be found in the method embodiments, which will not be repeated here.

[0040] Embodiments of this application also provide a computer device, please refer to... Figure 3 The computer device includes a processor and a memory, the memory storing at least one instruction, at least one program, code set, or instruction set, wherein at least one instruction, at least one program, code set, or instruction set is loaded and executed by the processor to implement the preemptive task scheduling method for log structure merging tree provided in the above method embodiments.

[0041] Embodiments of this application also provide a computer-readable storage medium storing at least one instruction, at least one program, code set, or instruction set, wherein the at least one instruction, at least one program, code set, or instruction set is loaded and executed by a processor to implement the preemptive task scheduling method for log structure merging tree provided in the above-described method embodiments.

[0042] Embodiments of this application also provide a computer program product, which includes a computer program. A processor of a computer device reads the computer program from a computer-readable storage medium and executes the computer program, causing the computer device to perform any of the preemptive task scheduling methods for log structure merging trees described in the above embodiments.

[0043] For ease of description, the above systems or devices are described separately as various modules or units based on their functions. Of course, in implementing this application, the functions of each unit can be implemented in one or more software and / or hardware components.

[0044] As can be seen from the above description of the embodiments, those skilled in the art can clearly understand that this application can be implemented by means of software plus necessary general-purpose hardware platforms. Based on this understanding, the technical solution of this application, in essence, or the part that contributes to the prior art, can be embodied in the form of a software product. This computer software product can be stored in a storage medium, such as ROM / RAM, magnetic disk, optical disk, etc., and includes several instructions to cause a computer device (which may be a personal computer, server, or network device, etc.) to execute the methods described in various embodiments or some parts of the embodiments of this application.

[0045] Finally, it should be noted that in this document, relational terms such as first, second, third, and fourth are used only to distinguish one entity or operation from another, and do not necessarily require or imply any such actual relationship or order between these entities or operations. Furthermore, the terms "comprising," "including," or any other variations thereof are intended to cover non-exclusive inclusion, such that a process, method, article, or apparatus that comprises a list of elements includes not only those elements but also other elements not expressly listed, or elements inherent to such a process, method, article, or apparatus. Without further limitations, an element defined by the phrase "comprising one..." does not exclude the presence of other identical elements in the process, method, article, or apparatus that includes said element.

[0046] The above description is only a preferred embodiment of this application. It should be noted that for those skilled in the art, several improvements and modifications can be made without departing from the principle of this application, and these improvements and modifications should also be considered within the scope of protection of this application.

Claims

1. A preemptive task scheduling method for log structure merging trees, characterized in that, include: The scheduler generates corresponding tasks in real time to respond to the workload. The task types include transaction query, file propagation, and file merging. Each task is configured with priority, work granularity, and completion level. The work granularity of the file propagation task is smaller than that of the transaction query and file merging tasks. The work granularity of the transaction query task must cover the work granularity required to complete the transaction query task, and the work granularity of the file merging task is smaller than that required to complete the file merging task. For each idle background thread, the following steps are performed: Assign a task to the current thread based on the priority of each task in the scheduler; After the current thread advances the iterator by a fixed step size based on the work granularity of the task, the task is paused and the thread is released. If the task is completed, then delete the task from the scheduler; If the task is not completed, its priority is increased based on the number of times it has been executed, so that it can be reassigned for execution.

2. The method as described in claim 1, characterized in that, The task of file distribution is as follows: When the workload triggers the merging of files to be merged into files at the next level of the tree structure, the files to be merged are propagated to the buffer segment at the next level; wherein the files to be merged and the original files at that level share an overlap key range. The triggering conditions for a file merging task are: When the size of files in a buffer segment at any level exceeds the configured capacity, a task is triggered to merge the files in that buffer segment with the original files at that level.

3. The method as described in claim 1, characterized in that, Background threads include elastic threads and merge threads; The elastic thread is used to execute three types of tasks: transaction query, file propagation, and file merging, and is allocated based on the priority of each task. The merge thread is used to perform file merge tasks based on priority.

4. The method as described in claim 3, characterized in that, Idle threads allocate tasks in the following way: Determine whether both elastic threads and merged threads exist simultaneously in the current background idle threads; If so, tasks are assigned to each merging thread based on the priority of each file merging task, and then tasks are assigned to each elastic thread based on the priority of the remaining tasks. If not, task allocation will be based on the type of currently idle thread and the priority of the corresponding task.

5. The method according to any one of claims 2-4, characterized in that, Priority is set as follows: The priority scores for file propagation tasks and transaction query tasks are set to the first and third preset values, respectively. When the buffer segment in a file merging task is located at level L0, the priority score of the file merging task is set to a second set value; wherein, the first set value is greater than the second set value, and the second set value is greater than the third set value; The priority scores of file merging tasks located in the buffer segment from the L1 level to the LN level of the structure tree are distributed evenly in descending order to the range of the third set value to 0.

6. The method as described in claim 5, characterized in that, Task priority is increased in the following ways: In the formula, To improve the score of the later priority, The initial priority score set for this task. This represents the current number of times the task has been executed. For the final priority score, This is the third set value.

7. A preemptive task scheduling device for a log structure merging tree, used to implement the method described in any one of claims 1-6, characterized in that, The device includes: The generation unit is used to respond to the workload in real time and generate corresponding tasks in the scheduler. The task types include transaction query, file propagation, and file merging. Each task is set with priority, work granularity, and completion degree. The work granularity of the file propagation task is smaller than that of the transaction query and file merging tasks. The work granularity of the transaction query task is required to cover the work granularity required to complete the transaction query task, and the work granularity of the file merging task is smaller than that required to complete the file merging task. The allocation unit is used to perform the following for each idle background thread: allocate a task to the current thread based on the priority of each task in the scheduler; The calling unit is used to call the current thread to advance the task by a fixed step size based on the work granularity driven iterator of the task, then pause the task and release the thread; The deletion unit is used to delete the task from the scheduler if the task is completed. The priority unit is used to increase the priority of a task based on the number of times it has been executed if the task has not been completed, so that it can be reassigned for execution.

8. A computer device, characterized in that, The computer device includes a memory and a processor. The memory is used to store computer programs, and the processor is used to execute the computer programs stored in the memory to implement the steps of the method according to any one of claims 1-6.

9. A computer-readable storage medium, characterized in that, The storage medium stores a computer program, which, when executed by a processor, implements the steps of the method described in any one of claims 1-6.

10. A computer program product, characterized in that, Includes a computer program, which, when executed by a processor, implements the steps of the method according to any one of claims 1-6.

Images