Task repair method and task repair device

Abstract

The application discloses a task repair method and a task repair device, and relates to the technical field of data storage. The method comprises the following steps: in response to monitoring a task rollback request for a plurality of executed tasks included in a disk array; determining whether the position corresponding to a to-be-repaired task after rollback falls into an executed task area based on a preconfigured mapping table; if it is determined that the position corresponding to the to-be-repaired task after rollback falls into the executed task area, skipping the executed task area and executing a target task area after the executed task area to repair the target task area, wherein the target task area comprises at least one uncompleted task. The method solves the problem of frequent progress rollback in the related art by skipping the executed task area in the redo task after the rollback task, and reduces the execution efficiency of the task.

Description

Technical Field

[0001] This application relates to the field of data storage technology, and in particular to a task repair method and a task repair device. Background Technology

[0002] With the continuous development of storage systems, centralized multi-controller storage systems are increasingly being used in various scenarios. For multi-controller storage systems, storage management software is designed to enable multiple controllers to control and manage the storage disk array in parallel, as well as provide fault tolerance and repair. In other words, it manages the disk array through a Redundant Array of Independent Disks (RAID) and uses an XOR algorithm to generate checksums to achieve redundancy.

[0003] When disk failures or business expansion occur, RAID needs to execute background tasks to restore data consistency. In multi-controller systems, nodes need to coordinate task processing, or in scenarios where the home region may dynamically change due to load balancing or failover, frequent rollbacks can cause progress stalls, prolonged task stagnation, reduced task execution efficiency, and wasted resources. Summary of the Invention

[0004] This application provides a task repair method and a task repair device to at least solve the technical problem in the related art that frequent progress rollbacks reduce the execution efficiency of tasks.

[0005] Firstly, this application provides a task repair method, including:

[0006] In response to the detection of task rollback requests for multiple executed tasks included in the disk array;

[0007] Based on the pre-configured mapping table, determine whether the position corresponding to the task to be repaired falls into the area of ​​completed tasks. The area of ​​completed tasks is the merged continuous task area, and the task status of any task included in the continuous task area is the completed status.

[0008] If it is determined that the position corresponding to the task to be repaired falls into the area of ​​completed tasks, then the area of ​​completed tasks is skipped, and the target task area after the area of ​​completed tasks is executed to repair the target task area, which includes at least one unfinished task.

[0009] Secondly, this application provides a task repair device, including: a memory and a processor;

[0010] The memory stores instructions that the computer executes;

[0011] The processor executes computer execution instructions stored in memory, causing the processor to perform the steps of the task repair method as described in any of the first aspects.

[0012] This application provides a task repair method and device. The method accelerates task rotation within completed task areas by mapping and reducing task regions and merging already executed task regions. This avoids repeated scanning and execution of partially completed task regions, speeding up the overall task execution progress in scenarios with frequent rollbacks due to various factors, and preventing prolonged task stagnation and waiting due to rollbacks. It reduces resource waste caused by repeated executions, avoids wear and tear from frequent execution in fixed areas, shortens the time span for business recovery, and eliminates the data risk of repair tasks not being completed in a timely manner. Attached Figure Description

[0013] To more clearly illustrate the embodiments of this application, the accompanying drawings used in the embodiments will be briefly introduced below. Obviously, the drawings described below are only some embodiments of this application. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0014] Figure 1 This is a schematic diagram of a sliding task area provided in an embodiment of this application;

[0015] Figure 2 This is a schematic diagram of progress rollback under the cursor management method provided in an embodiment of this application;

[0016] Figure 3 This is a schematic diagram illustrating an application scenario of a task repair method provided in an embodiment of this application;

[0017] Figure 4 A flowchart illustrating a task repair method provided in an embodiment of this application;

[0018] Figure 5 This is a schematic diagram illustrating the skipping of completed task areas in a task repair method provided in an embodiment of this application;

[0019] Figure 6 A schematic diagram of the setting mapping table process for a task repair method provided in an embodiment of this application;

[0020] Figure 7 This is a schematic diagram of the structure of a task repair device provided in one embodiment of this application;

[0021] Figure 8 This is a schematic diagram of the structure of a task repair device provided in an embodiment of this application. Detailed Implementation

[0022] The technical solutions of the embodiments of this application will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of this application, and not all embodiments. Based on the embodiments of this application, all other embodiments obtained by those of ordinary skill in the art without creative effort are within the protection scope of this application.

[0023] To enable those skilled in the art to better understand the present application, the present application will be further described in detail below with reference to the accompanying drawings and specific embodiments.

[0024] RAID is used to divide the storage space on the disk. After dividing the disk space according to the basic strip, they are arranged in a fixed combination to produce the smallest storage data recovery unit, the stripe. The stripe is the basic unit we use for fault tolerance recovery and read / write operations.

[0025] Among them, the Redundant Array of Independent Disks (RAID) is the smallest unit of data recovery after the storage area on the disk array is uniformly divided; internally, it is further divided into several strips.

[0026] For multi-controller systems, in order to achieve mutual exclusion of writes to the disk array by multiple controllers, while avoiding the huge overhead of input / output (IO) caused by inter-controller locks, the storage space of the disk array is divided into ownership regions. IO is performed according to the fixed ownership region of the current node to avoid read / write conflicts. Therefore, for any ownership changes that may occur, the upper layer will issue a change task to notify RAID to update the metadata bitmap recording the ownership information, so as to ensure that the ownership information of the upper and lower layers is consistent and that the background tasks of RAID used for fault tolerance and recovery (formatting, disk failure reconstruction) and the execution region of host IO are consistent.

[0027] The metadata consists of a data bitmap that records the execution status of each stripe during the background task execution. Each bit in the bitmap uniquely corresponds to one stripe, with 1 representing not executed and 0 representing executed. This is used to accurately record the execution status of each stripe when the node ownership information of the stripe unit changes in a multi-controller system that manages the same RAID array.

[0028] In a multi-controller system that manages the same RAID array, the attribution information records that each stripe has a designated attribution information record that the IO execution processing of the current stripe area is performed by a certain node, in order to avoid mutual interference between multiple controllers. This attribution information is generally default, or may be changed in real time later due to business scenarios such as load balancing.

[0029] Among them, background tasks refer to the formatting tasks of the entire array during the RAID array management process, the reconstruction tasks for fault-tolerant recovery of faulty areas due to disk failures, and the copy-back tasks triggered to restore the empty state of the backup disk after disk replacement.

[0030] Therefore, to adapt to the ownership allocation mechanism of the four controllers and the need for ownership changes between controllers, the following management and execution mechanisms apply to tasks within a window:

[0031] Optionally, the required task strips can be traversed from beginning to end using a cursor and a fixed-length record. The cursor controls the execution progress of the current task, and the fixed-length record indicates the strips that need to be executed.

[0032] Optionally, after the strips in the record have been executed, control the cursor to scroll down to push the task forward;

[0033] Optionally, each controller only executes tasks for the stripe currently belonging to its region, and each controller has a task execution progress. The total progress is the average of the progress of each controller.

[0034] Optionally, after a strip ownership change occurs, the division of ownership areas is triggered to increase or decrease between controllers. To avoid omissions in the execution of tasks within the window, the cursors of each controller revert to the state with the lowest progress among the controllers.

[0035] At the level of the thin storage pool, the space provided by the lower layer is divided into basic units of blocks. During the IO process, the pool-level address—called the physical address—is obtained through a mapping relationship based on the volume identity identifier and the IO processing address (Logical address) when the volume issues IO, and then passed to the lower layer for IO processing.

[0036] Furthermore, for RAID, after a window-like background task starts, it manages a window-like metadata structure to record two main pieces of information: one as a cursor indicating the current window position, and the other as an array or table structure to record the stripes that are being filled or executed after the current position. When these stripes are randomly retrieved and executed by threads, their completion order within the array is not in the ordered sequence, but rather a random value. Therefore, Figure 1 A sliding window diagram illustrating a task repair method provided in an embodiment of this application, as shown below. Figure 1 As shown, the parameter x (as shown) is used as the cursor. Figure 1 The conditions for adding a vertex (x) are generally as follows:

[0037] Optionally, when within the window (e.g. Figure 1 After all the stripes dispatched in the middle (x~x+15) are completed, the window moves down to the right edge. In this case, there is scheduling wait due to the different completion times of each thread, so it is not suitable for tasks that require efficient and fast execution.

[0038] Optionally, the window is set with a uint16 integer parameter y of the length of the window, and each bit in it represents the completion status of the stripe execution within the window, with 1 indicating incomplete and 0 indicating complete. When the stripe to the right of cursor x+1 is completed, the window is triggered to move, and the moving length is the distance recorded in y from the position of x to the first non-1 position.

[0039] Furthermore, RAID primarily manages array fault tolerance through parity generation and storage. This involves using space divided into fixed-size strip blocks as basic units, logically arranging them into a fixed-distribution array combination. Under this combination, the XOR calculation result of row and diagonal data is calculated according to a certain rule to generate parity data, which is then combined with the data blocks as a special block and mapped to the corresponding space on the disk. When there is an I / O operation, the corresponding data block is indexed, and a new parity block is generated and written to disk simultaneously.

[0040] Therefore, when data / verification information is corrupted, RAID initiates a repair task. This task recalculates the data block information using XOR verification, based on the verification information and other combinations. Corrupted verification data is then recalculated using the same XOR logic. Thus, the repair task is reworkable; recalculating the repair for previously repaired or correct areas yields the same result without affecting data accuracy. For reworkable repair tasks, metadata management via window-based methods typically uses progress rollback to ensure that in a multi-controller system, after a node failure, no newly acquired areas earlier than the current controller's progress are missed during periods of mutual takeover or change in the ownership of different nodes. Therefore, the progress of each node needs to be rolled back to the minimum of all node progress. Due to varying execution rates among controllers and differences in the size of the acquired areas (resulting in uneven ownership distribution under business requirements), significant progress differences may exist between nodes.

[0041] Figure 2 This is a schematic diagram of progress rollback under a cursor management method provided in an embodiment of this application, as shown below. Figure 2 As shown, task management and rollback follow the process below:

[0042] Optionally, the execution of window metadata starts from 0 and moves backward until it equals a four-controller system (such as...). Figure 2 The total number of stripeable arrays jointly managed by Node0, Node1, Node2, and Node3 in the array, and the current controller's progress percentage is the current cursor (e.g., ...). Figure 2 The index values ​​of index0, index1, index2, and index3 in the above band are compared with the total number of the previous band.

[0043] Optionally, each controller may execute only the portion of the total stripe range from 0 to MAX_NUM during task execution, as shown in the example. Figure 1 The regions to which each controller belongs may be continuous or discrete.

[0044] Optionally, when a change of ownership region occurs between controllers (due to business needs or controller failure), the minimum progress value of each controller is obtained, and the system is rolled back to the minimum value to continue execution, in order to avoid missing the repair of the changed region.

[0045] Optional, such as Figure 2As shown, the change from Node0 to Node1 was not executed. However, since the progress of Node1 has exceeded the range of the changed region, it needs to be rolled back. The change from Node2 to Node3 is the same as the change from Node0 to Node1. In order to avoid the change from the minimum progress value to the maximum progress value in the four-controller system, it is necessary to obtain the minimum progress value among Node0, Node1, Node2 and Node3, and roll back to the minimum value to continue execution.

[0046] Optionally, the total task progress is the average of the progress of each controller. The task ends when the progress of the task on each controller reaches 100%.

[0047] In scenarios where business needs frequently change the ownership region (with ownership volumes frequently expanding under high IO pressure) or where there are multiple controller failures, the repair task may experience frequent rollbacks, leading to progress stalls, prolonged task stagnation, and repeated redoing.

[0048] Therefore, the technical problems of the related technologies are as follows:

[0049] Optionally, in business scenarios that require frequent changes in the assigned region, the repair task may experience frequent rollbacks, and the progress may stagnate for a long time when the number of executions is lower than the number of rollbacks, affecting business recovery.

[0050] Optionally, repeated rollbacks of tasks and repeated redoing of stripes in the same area increase the wear and tear on disk space in the fixed area, increase the frequency of metadata operations in the fixed area and affect the release interval of the exclusive lock of the metadata area stripe. In scenarios where read and write I / O are processed simultaneously in the same area, it affects the execution latency and efficiency of business I / O.

[0051] Optionally, continuously repairing already repaired stripes reduces task execution efficiency and wastes resources.

[0052] Optionally, the repair task may be difficult to complete within the expected time; RAID loss during the repair of tasks with existing faults can restore data redundancy, so data loss may occur under the superposition of other faults. Failure to complete the repair within the fixed period increases the risk of data being affected during the period when fault tolerance is not repaired in time.

[0053] Therefore, when facing the technical problems mentioned above, to address the issue of frequent rollbacks that reduce task execution efficiency, we map and shrink task regions, and merge completed task regions to accelerate task movement within these regions. This avoids repeated scanning and execution of partially completed task regions, speeding up the overall task execution progress in scenarios with frequent rollbacks due to various factors, and preventing prolonged task stagnation and waiting caused by rollbacks. This reduces resource waste caused by repeated executions, avoids wear and tear from frequent execution in fixed regions, shortens the time required for business recovery, and eliminates the data risk of repair tasks not being completed in a timely manner.

[0054] Optional, Figure 3 This is a schematic diagram illustrating an application scenario of a task repair method provided in an embodiment of this application. The task repair system is a computer device. Figure 3 In the above architecture, at least one of data acquisition device 301, processing device 302 and display device 303 is included.

[0055] It is understood that the structures illustrated in the embodiments of this application do not constitute a specific limitation on the architecture of the application data processing system. In other feasible embodiments of this application, the above architecture may include more or fewer components than illustrated, or combine some components, or split some components, or arrange different components, which can be determined according to the actual application scenario and is not limited here. Figure 3 The components shown can be implemented in hardware, software, or a combination of both.

[0056] In the specific implementation process, the data acquisition device 301 may include an input / output interface or a communication interface, and the data acquisition device 301 can be connected to the processing device through the input / output interface or the communication interface.

[0057] The processing device 302 can accelerate the scrolling of tasks in completed task areas by mapping and shrinking task areas and merging completed task areas, thereby avoiding repeated scanning and execution of some completed task areas, accelerating the overall execution progress of tasks in scenarios where various factors cause frequent rollbacks, and avoiding long-term stagnation and waiting of tasks due to rollbacks.

[0058] Display device 303 can also be a touch screen or the screen of a terminal device, used to receive user commands while displaying the above-mentioned content, so as to realize interaction with the user.

[0059] It should be understood that the aforementioned processing device can be implemented by a processor reading instructions from memory and executing those instructions, or it can be implemented by a chip circuit.

[0060] Optionally, such as Figure 3 As shown, the data acquisition device 301, the processing device 302, and the display device 303 can be connected via a wired network or a wireless network.

[0061] Furthermore, the network architecture and business scenarios described in the embodiments of this application are for the purpose of more clearly illustrating the technical solutions of the embodiments of this application, and do not constitute a limitation on the technical solutions provided in the embodiments of this application. As those skilled in the art will know, with the evolution of network architecture and the emergence of new business scenarios, the technical solutions provided in the embodiments of this application are also applicable to similar technical problems.

[0062] The technical solution of this application and how the technical solution of this application solves the above-mentioned technical problems are described in detail below with specific embodiments. These specific embodiments can be combined with each other, and the same or similar concepts or processes may not be described again in some embodiments. The embodiments of this application will be described below with reference to the accompanying drawings.

[0063] In the several embodiments provided in this application, it should be understood that the disclosed devices and methods can be implemented in other ways. For example, the device embodiments described above are merely illustrative; for instance, the division of modules is only a logical functional division, and in actual implementation, there may be other division methods. For example, multiple modules may be combined or integrated into another system, or some features may be ignored or not executed. Furthermore, the coupling or direct coupling or communication connection shown or discussed may be indirect coupling or communication connection through some interfaces, devices, or modules, and may be electrical, mechanical, or other forms.

[0064] Figure 4 This is a flowchart illustrating a task repair method provided in one embodiment of this application, as shown below. Figure 4 As shown, the task repair method includes the following steps:

[0065] S401, In response to detecting a task rollback request for multiple executed tasks included in the disk array.

[0066] S402. Based on the pre-configured mapping table, determine whether the position corresponding to the task to be repaired falls into the area of ​​completed tasks. The area of ​​completed tasks is the merged continuous task area, and the task status of any task included in the continuous task area is the completed status.

[0067] Each rollback request corresponds to a rollback region, and the number of completed task regions in the rollback region is variable.

[0068] S403. If it is determined that the position corresponding to the task to be repaired falls into the area of ​​completed tasks, then skip the area of ​​completed tasks and execute the target task area after the area of ​​completed tasks to repair the target task area. The target task area includes at least one unfinished task.

[0069] Figure 5 This is a schematic diagram illustrating the skipping of completed task areas in a task repair method provided in an embodiment of this application, as shown below. Figure 5 As shown:

[0070] First, determine whether there are areas within the rollback area where tasks have already been completed.

[0071] Optionally, if a region containing completed tasks exists within the rollback region, then the region containing completed tasks is located using the MAP (Mapping Table). Figure 5 (The completed interval in the middle) skips the completed task area and executes the target task area after the completed task area to repair the target task area.

[0072] Optionally, if there is no completed task area within the rollback area, then the entire rollback area is executed.

[0073] The task repair method provided in this application accelerates task scrolling within completed task areas by mapping and reducing task areas and merging completed task areas. This avoids repeated scanning and execution of partially completed task areas, speeding up the overall task execution progress in scenarios where frequent rollbacks occur due to various factors, and preventing prolonged task stagnation and waiting due to rollbacks. It reduces resource waste caused by repeated executions, avoids wear and tear from frequent executions in fixed areas, shortens the time span for business recovery, and eliminates the data risk of repair tasks not being completed in a timely manner.

[0074] As an optional implementation, based on any of the above embodiments, the disk array includes multiple task areas, and each task area includes multiple tasks; before determining whether the position corresponding to the task to be repaired falls within the area of ​​a completed task based on a pre-configured mapping table, the method further includes:

[0075] Execute tasks within any task area of ​​the disk array.

[0076] Determine the merge-related information for any completed task area.

[0077] Based on the relevant information about merging, determine the task regions to be merged, and merge the task regions to obtain the regions of tasks that have been executed and completed.

[0078] In this process, a mapping table is used to establish the association between tasks, merged related information, and task regions.

[0079] Specifically, before responding to the detection of a task rollback request for multiple executed tasks included in the disk array, the method further includes: dividing the disk array into multiple task regions according to a first preset number; dividing each task region into multiple sub-task regions according to a second preset number; configuring an array of corresponding length for each task region, and associating each task region with the corresponding array to obtain a first association relationship; wherein the number of elements in the array is the same as the number of sub-task regions of the corresponding task region, and the array is used to store merging-related information; associating each sub-task region with the corresponding array element in the array to obtain a second association relationship; and constructing a mapping table based on the first and second association relationships, the mapping table being used to locate the corresponding array element according to the cursor index value.

[0080] For example, the first preset quantity is N, the second preset quantity is M, the array space length MAX_NUM of the entire execution disk array is divided into N equal parts, and for each interval range i (i is 0~N-1), another array of length LEN (subscript j, j is 0~M-1) is set.

[0081] Specifically, the task in any task area of ​​the disk array is executed, including: addressing and locating the corresponding array element according to the cursor index value and mapping table of the task; when a preset number of consecutive tasks are detected to be in the completed state, generating the merge information corresponding to the completed task area; and writing the merge information into the array element.

[0082] Specifically, the maximum preset number can be 16. When the cursor value index / (MAX_NUM / N)=i, the pointer at the specified position (i=k) is indexed in the MAP table, and the corresponding array LENk is obtained.

[0083] The current position of the task cursor starts from index 0. When the cursor moves to the position of index+16, and the task status of all 16 tasks is completed, index-16 is used as the initial position and count=1 is used as the counter value to record in the mapping table at the offset position corresponding to the current cursor position in the entire storage space.

[0084] Specifically, determining the merge-related information corresponding to any completed task area means that in the corresponding LEN, the offset j in the LEN table can be obtained by calculating (index-i*MAX_NUM / N) / (MAX_NUM / N / M) based on the cursor index value, and then indexing the corresponding merge-related information.

[0085] Specifically, by mapping and skipping the incremental rolling sequence of tasks, the incremental sequence of already executed regions is broken and remapped. This allows for a single multiplication and division calculation mapping with a complexity similar to the original incremental progress, thus enabling the skipping of already executed regions in the rollback region during task execution. This reduces the number of task executions, improves task execution efficiency, and optimizes the total execution time of the task.

[0086] The task repair method provided in this application divides the disk array into multiple task regions in a fixed number of equal parts, establishes a first association relationship between the task region and the array, and a second association relationship between the subtask and the subarray. Combined with the equal division of the original mapping table, a multi-level mapping table is formed, which realizes accurate association and efficient indexing of relevant information for merging task regions. When the cursor moves, the merging information is quickly obtained by calculating the index to the corresponding array position, which improves the coherence of merging task regions, storage space management efficiency and merging operation accuracy.

[0087] As an optional implementation, based on any of the above embodiments, determining the previous task status corresponding to the previous task area for any completed task area further includes:

[0088] Determine the value of the second parameter representing the state of the previous task in the previous task region.

[0089] If the value of the second parameter is the first preset value, then the previous task status is determined to be incomplete.

[0090] If the value of the second parameter is the second preset value, then the previous task status is determined to be completed.

[0091] The second parameter value, which uses the total identifier old_set, represents the state of the previous task.

[0092] Specifically, after all tasks in the previous task area are completed and written to the mapping table, the cursor continues to move and old_set is set to 1.

[0093] Furthermore, after any completed task region has finished executing, if old_set is 1, then the corresponding count value in the mapping table is updated by 1 according to the initial position of the previous task region, thus realizing the aggregation of continuous regions.

[0094] Furthermore, if old_set is not 1, the initial position of the previous task area is not indexed, and the current position of the cursor is set as the new initial position in the mapping table.

[0095] The task repair method provided in this application determines the incomplete / complete status by determining the second parameter value old_set of the previous task area and judging it based on its value (first / second preset value). Combined with the mechanism of dynamically updating the mapping table count value (incrementing by 1 or setting a new initial position) according to the old_set value after the task is completed, it realizes accurate aggregation and status tracking of continuous completed task areas, and improves the continuity and efficiency of task management.

[0096] As an optional implementation, based on any of the above embodiments, before determining whether the position corresponding to the task to be repaired falls within the area of ​​already completed tasks, based on a pre-configured mapping table, the method further includes:

[0097] Determine the first parameter value representing the current task status in any task region.

[0098] If the value of the first parameter is the first preset value, then the current task status is determined to be completed.

[0099] If the value of the first parameter is not the first preset value, then the current task status is determined to be incomplete.

[0100] The first parameter value, represented by the integer parameter bitmap, indicates the current task status and marks the completion status of 16 tasks starting from the current position (which is the maximum number of concurrent tasks scheduled by the system).

[0101] For example, the cursor of the repair task starts from index 0. Each time it is detected that a task has been actually completed, rather than skipping the execution of stripes that do not belong, the bit value of the offset position of the current task strip number stride-index is marked as 0 in the bitmap parameter used for identification.

[0102] Specifically, when the cursor moves to the position of index+16, it checks whether the first parameter value of uint16, bitmap, is 0. If it is 0, it means that the past 16 tasks have been executed. At this time, index-16 is used as the initial position, and count=1 is used as the counter value to record in the mapping table at the offset position corresponding to the current cursor position in the entire storage space.

[0103] Specifically, check if the first parameter value of uint16, bitmap, is 0. If it is not 0, it means that a stripe has been skipped. In this case, discard this completed record and do not record it in the table. The cursor will continue to scroll as usual.

[0104] The task repair method provided in this application uses a first parameter value bitmap to mark the completion status of the current and the next 16 tasks, and combines the cursor position to dynamically detect the bitmap value (whether it is 0), thereby achieving accurate identification and aggregation of continuously completed tasks. When it is detected that all 16 past tasks have been completed, the starting position and count value are written into the mapping table; if there are incomplete tasks, invalid records are automatically skipped, ultimately improving the accuracy of task status tracking and the consistency of storage space management.

[0105] As an optional implementation, based on any of the above embodiments, the merging-related information corresponding to any completed task area includes: the target starting position and target quantity of any completed task area, where the target starting position is the starting position corresponding to the area to be merged, and the target quantity is the number of task areas to be merged up to the task area.

[0106] In the first completed task region following an incomplete task region, the cursor's initial position after completing that completed task region becomes the initial position of the region to be merged. This completed task region, along with its subsequent consecutive completed task regions, forms the region to be merged.

[0107] In the array table of the mapping table, the initial position of each completed task area in the region to be merged is the initial position of the first completed task area after the uncompleted task area.

[0108] The target number is the number of regions in the region to be merged that have completed their tasks.

[0109] The task repair method provided in this application embodiment unifies the starting position of the region to be merged as the initial position of the first completed task region after the incomplete task region, and dynamically counts the number of consecutive completed task regions as the target number. Combined with the mapping table association mechanism, it realizes the accurate positioning of the boundary of the merged region and the centralized management of the merge information. This ensures the uniqueness of the starting position of the region to be merged and dynamically tracks the merge range through the target number, ultimately improving the continuity of task region merging, the efficiency of storage space management, and the accuracy of the merge operation.

[0110] As an optional implementation, based on any of the above embodiments, determining the merging-related information corresponding to any completed task area includes:

[0111] Determine the status of the previous task corresponding to the previous task area for any completed task area.

[0112] Determine the target location and quantity for any completed task area based on the previous task status.

[0113] Among them, any completed task area determines whether it is the first completed task area in a region to be merged by checking the previous task status corresponding to the previous task area.

[0114] If the previous task status corresponding to the previous task area is incomplete, then the completed task area is the first completed task area in a region to be merged.

[0115] If the previous task status corresponding to the previous task area is completed, then the completed task area is not the first completed task area in a region to be merged.

[0116] The task repair method provided in this application determines whether the currently completed task area is the first completed area in the areas to be merged by judging the task status (incomplete / complete) of the previous task area. This allows for the accurate determination of the target location and target quantity, enabling dynamic tracking and efficient association of merging-related information. This avoids invalid merging operations for areas that are not the first completed area and ensures that the merging process is based on continuous completion status, ultimately improving the accuracy, consistency, and granularity of task area merging and storage space management.

[0117] As an optional implementation, based on any of the above embodiments, determining the target location and target quantity corresponding to any completed task area according to the previous task status includes:

[0118] If the previous task status is "completed", then the target location is determined to be the target location corresponding to the previous task area, and the target quantity is determined to be the sum of the target quantity corresponding to the previous task area and the second preset value.

[0119] If the previous task status is incomplete, the target position is determined to be the difference between the end position of the completed task area and the length of the completed task area, and the target quantity is determined to be the second preset value.

[0120] Specifically, if the previous task status of any completed task area is completed, then the completed task area is not the first completed task area in a region to be merged. The initial position of the completed task area follows the initial position of the previous task area, and the target quantity of the completed task area is the target quantity of the previous task area plus one.

[0121] Specifically, if the preceding task of any completed task area is in an incomplete state, then that completed task area becomes the first completed task area in a region to be merged. The difference between the end position and the length of the completed task area is the target position, and the target number of the completed task areas is one. If there are consecutive task areas following the completed task area, then the initial position of the entire region to be merged is the target position.

[0122] The task repair method provided in this application dynamically adjusts the target position (using the previous position or calculating the difference between the end position and the length) and the target quantity (accumulating or resetting to 1) according to the previous task status, thereby achieving accurate identification of the first completed region and precise inheritance of merging information. This ensures the uniqueness of the starting position of the region to be merged and accurately tracks the merging range through quantity accumulation, ultimately improving the continuity of task region merging, the efficiency of merging operations, and the level of fine-grained storage space management.

[0123] As an optional implementation, based on any of the above embodiments, the task regions to be merged are determined according to merging-related information, including:

[0124] Multiple completed task regions with the same starting position are identified as task regions to be merged, and the number of task regions to be merged is the same as the number of targets in the last completed task region among the task regions to be merged.

[0125] Specifically, the target number of each completed task region in the task region to be merged is the number of completed task regions preceding that completed task region plus one.

[0126] The task repair method provided in this application uses the consistency of the target starting position as the merging basis and dynamically determines the range to be merged by associating the target quantity of the last completed task area. This achieves precise alignment of the merged area boundary and accurate quantification of the merged range. It avoids invalid merging of non-contiguous areas and ensures the continuity of the merged range by binding the target quantity with the last task area. Ultimately, it improves the accuracy of task area merging, the efficiency of storage space management, and the reliability of merging operations.

[0127] This application also provides a possible embodiment. Figure 6 This is a schematic diagram of the setting mapping table process for a task repair method provided in an embodiment of this application. Figure 5 Based on the illustrated embodiments, as Figure 6As shown, the initial bit value of the bitmap is 1, and a completion array of length x is set for the current repair task to record the completion status of the repair task within a certain period of time before the current index. When the bitmap detects that all consecutive indices are completed, it records start=index and count=1 in the MAP table; where Ptr0 (i=0) and Ptr1 (i=1) in the MAP table are the corresponding storage controller nodes.

[0128] When the cursor value index / (MAX_NUM / N)=i, the pointer is indexed to the specified position (i=k) in the MAP table to obtain the array LENk corresponding to each storage controller node; where all_total is the number of global repair tasks, total is the number of repair tasks in the corresponding storage controller node, and z, x and y are variables.

[0129] Furthermore, in the corresponding LEN, the offset j in the LEN table can be obtained by calculating (index-i*MAX_NUM / N) / (MAX_NUM / N / M) based on the cursor index value, thereby indexing the corresponding merge-related information (start, count).

[0130] Where start is the initial position and count is the target quantity.

[0131] Furthermore, when a predetermined number of tasks are detected to be in a completed state, merge-related information corresponding to the completed task area is generated, including: obtaining the second parameter value of the task; if the second parameter value is the first value, the historical target quantity is incrementally updated to generate the target quantity of merge-related information.

[0132] For example, if the task area is set at this time and old_set=1 indicates that it is a continuous setting, the count of the corresponding offset parameter is incremented by 1 in the LENj indexed this time.

[0133] If the second parameter is a second value, then determine whether the number of historical targets is less than the number of current targets.

[0134] For example, if old_set is 0, it means it is a new setting. In this indexing, the corresponding position parameter is retrieved in LENj to determine whether it has already been set.

[0135] If it is less than the target number, then the current target number will be used as the target number for merging the relevant information.

[0136] For example, if the offset parameter of the indexed LEN has already been set, then compare whether the count at the original position is greater than the count set this time. If it is less, then the previous record will be overwritten.

[0137] If it is greater than the target number, continue executing the task and continuously accumulate the current target number (e.g.) Figure 5 The counts (count1 and count2) accumulate until the number of historical targets is less than the number of current targets, or until the value of the first parameter is detected to be different from the first preset value.

[0138] If the number of historical targets is less than the number of current targets, then the number of current targets will be used as the target number for merging relevant information.

[0139] For example, if the value is greater than the original value, the start and count records for this query will not be set for the time being, and the task will continue to accumulate until it is greater than the original record in the next query, at which point it will be overwritten.

[0140] If the value of the first parameter is not the first preset value, then the currently generated merge-related information is cleared.

[0141] For example, if the bitmap is no longer a series of consecutive 1s, the process is interrupted and cleaned up before proceeding to the next round of judgment and execution.

[0142] Furthermore, if the corresponding offset parameter of the LEN indexed in the middle is not set, then it is set directly.

[0143] By dynamically distinguishing between continuous and new setting scenarios, and combining the merge information comparison and overwrite mechanism (overwrite when the original count is less than the current count, and temporarily store and accumulate when it is greater than the current count) and the logic of directly writing when no setting is made, the system achieves accurate accumulation, efficient updating and effective maintenance of merge information. This ensures the accuracy of dynamic tracking of the number of merged items and avoids the accumulation of invalid information through interruption cleanup optimization, ultimately improving the efficiency of storage space management, the continuity of merge operations and the reliability of system operation.

[0144] The task repair method provided in this application embodiment achieves accurate positioning of merged information through a multi-level indexing mechanism (locating LENk in the mapping table array and calculating LEN offset j). Combined with dynamic merged information processing logic (count accumulation when setting continuously, overwrite condition judgment when setting a new one, and direct writing when not set) and interruption cleanup optimization, it realizes unique control over the boundary of the task area merge range, dynamic tracking of the number of merges, and automatic cleanup of invalid information. This ensures the continuity and accuracy of the merge operation, while also improving the efficiency of storage space management and the overall reliability of the system.

[0145] As an optional implementation, based on any of the above embodiments, determining whether the position corresponding to the task to be repaired, based on a pre-configured mapping table, falls within the area of ​​tasks that have been completed includes:

[0146] Obtain the value of the third parameter that represents the location of the task to be repaired;

[0147] Based on the third parameter value and the mapping table, determine the location area corresponding to the area where the completed task has been executed.

[0148] Determine whether the value of the third parameter is within the location area corresponding to the area where the task has been completed.

[0149] If so, then the position corresponding to the task to be repaired is determined to fall into the area of ​​tasks that have been completed.

[0150] If not, then it is determined that the position corresponding to the task to be repaired during the rollback did not fall into the area of ​​tasks that have already been completed.

[0151] The third parameter is the current position (index) of the cursor.

[0152] In one possible embodiment, determining the location region corresponding to the region where the task has been completed, based on the third parameter value and the mapping table, includes: obtaining the index subscript based on the mapping table; calculating the offset based on the third parameter value and the index subscript; addressing and locating the corresponding array element based on the offset to read the corresponding merging-related information; and obtaining the location region corresponding to the region where the task has been completed based on the merging-related information.

[0153] For example, if the first preset quantity is N, the second preset quantity is M, and the index is i, when index / (MAX_NUM / N)=i, the pointer at the specified position (i=k) in the MAP table is indexed to obtain the corresponding array LENk.

[0154] Furthermore, in the corresponding LEN, the offset j in the LEN table can be obtained by calculating (index-i*MAX_NUM / N) / (MAX_NUM / N / M) based on the cursor index value, thereby indexing the corresponding merge-related information (start, count).

[0155] Where start is the initial position and count is the target quantity.

[0156] For example, if a repair task triggers a progress rollback, when the task is restarted, the mapping table is used to index the interval (start, count) corresponding to the current index. Only completed task areas are recorded in the mapping table.

[0157] Specifically, at this time the task operation is a query operation. In the corresponding array table, the offset j in the array table can be obtained by calculating (index-i*MAX_NUM / N) / (MAX_NUM / N / M) based on the cursor index value. The corresponding record value is then indexed to obtain the position area (start, count) corresponding to the completed task area in this interval.

[0158] Furthermore, the total count is used to determine whether the mapping table is empty. If it is not empty, the index of the current cursor is compared to see if it falls within the interval (start, count). If it is within the interval, the process skips directly to the end of start + count and proceeds with the execution.

[0159] Furthermore, if the mapping table is empty, the corresponding array table of the mapping is empty, or the cursor index is not within the range, then continue to execute downwards, and check in a loop after the next round of movement.

[0160] The task repair device provided in this application embodiment records the interval (start, count) of the completed task area through a mapping table and dynamically judges the cursor position, thereby achieving accurate positioning and execution jump of the rollback task position. This avoids repeated operations in the already executed area and ensures the continuity of task execution through the automatic skipping mechanism for empty tables / outside intervals, ultimately improving task repair efficiency, storage space utilization and system operation reliability.

[0161] Figure 7 This is a schematic diagram of the structure of a task repair device provided in an embodiment of this application, as shown below. Figure 7 As shown, embodiments of this application also provide a task repair device, including: a response module 71, a determination module 72, and a processing module 73.

[0162] The response module 71 is used to respond to the detection of a task rollback request for multiple executed tasks included in the disk array.

[0163] The determination module 72 is used to determine, based on a pre-configured mapping table, whether the position corresponding to the task to be repaired falls into the area of ​​completed tasks. The area of ​​completed tasks is the merged continuous task area, and the task status of any task included in the continuous task area is the completed status.

[0164] The processing module 73 is used to skip the completed task area and execute the target task area after the completed task area if it is determined that the position corresponding to the task to be repaired falls into the completed task area. The target task area includes at least one unfinished task.

[0165] In one possible design, the disk array comprises multiple task areas, and any one task area contains multiple tasks.

[0166] Before determining whether the position corresponding to the task to be repaired falls into the area of ​​completed tasks based on the pre-configured mapping table, the determination module 72 is specifically used to: execute the tasks included in any task area in the disk array; determine the merge-related information corresponding to any completed task area; determine the task area to be merged based on the merge-related information, and merge the task areas to be merged to obtain the area of ​​completed tasks.

[0167] In one possible design, the merge-related information for any completed task area includes: the target starting position and target quantity of any completed task area, where the target starting position is the starting position of the area to be merged, and the target quantity is the number of task areas to be merged up to the task area.

[0168] In one possible design, the determining module 72 is further used to: determine the previous task state corresponding to the previous task area of ​​any completed task area; and determine the target location and target quantity corresponding to any completed task area based on the previous task state.

[0169] In one possible design, the determining module 72 is further used to: determine a second parameter value representing the state of the previous task in the previous task area; if the value of the second parameter is a first preset value, then determine that the state of the previous task is incomplete; if the value of the second parameter is a second preset value, then determine that the state of the previous task is completed.

[0170] In one possible design, based on a pre-configured mapping table, before determining whether the position corresponding to the task to be repaired falls into the area of ​​completed tasks, the determination module 72 is specifically used to: determine the first parameter value representing the current task status in any task area; if the first parameter value is a first preset value, then determine the current task status as completed; if the first parameter value is not a first preset value, then determine the current task status as incomplete.

[0171] In one possible design, the determining module 72 is further configured to: if the previous task status is completed, determine the target position as the target position corresponding to the previous task area, and determine the target quantity as the sum of the target quantity corresponding to the previous task area and a second preset value; if the previous task status is incomplete, determine the target position as the difference between the end position of the completed task area and the length of the completed task area, and determine the target quantity as the second preset value.

[0172] In one possible design, the determining module 72 is further used to: determine multiple completed task regions with the same target starting position as task regions to be merged, and the number of task regions to be merged is the same as the target number of the last completed task region in the task regions to be merged.

[0173] In one possible design, the determining module 72 is further configured to: obtain a third parameter value representing the location corresponding to the task to be repaired; determine the location region corresponding to the region of the completed task based on the third parameter value and the mapping table; determine whether the third parameter value is within the location region corresponding to the region of the completed task; if so, determine that the location corresponding to the task to be repaired that has been rolled back to falls into the region of the completed task; if not, determine that the location corresponding to the task to be repaired that has been rolled back to does not fall into the region of the completed task.

[0174] In one possible design, before detecting a task rollback request for multiple executed tasks included in the disk array, the processing module 73 is further configured to: divide the disk array equally according to a first preset number to obtain multiple task regions; divide each task region equally according to a second preset number to obtain multiple sub-task regions corresponding to the task region; configure an array of corresponding length for each task region, and perform association processing between each task region and the corresponding array to obtain a first association relationship; wherein the number of elements in the array is the same as the number of sub-task regions of the corresponding task region, and the array is used to store merging related information; associate each sub-task region with the corresponding array element in the array to obtain a second association relationship; and construct a mapping table according to the first association relationship and the second association relationship, the mapping table being used to address and locate the corresponding array element according to the cursor index value of the task.

[0175] In one possible design, the processing module 73 is further configured to: locate the corresponding array element based on the cursor index value of the task and the mapping table; when a preset number of consecutive tasks are detected to be in a completed state, generate the merging information corresponding to the completed task area; and write the merging information into the array element.

[0176] In one possible design, the processing module 73 is further configured to: obtain the second parameter value of the task; if the second parameter value is the first value, then incrementally update the historical target quantity to generate the target quantity for merging related information; if the second parameter value is the second value, then determine whether the historical target quantity is less than the current target quantity; if it is less, then use the current target quantity as the target quantity for merging related information.

[0177] In one possible design, after determining whether the number of historical targets is less than the current target number, the processing module 73 is further configured to: if it is greater, continue to execute the task and continuously accumulate the current target number until the number of historical targets is less than the current target number, or detect that the value of the first parameter is not the first preset value; if the number of historical targets is less than the current target number, use the current target number as the target number for merging related information; if detect that the value of the first parameter is not the first preset value, clear the currently generated merge-related information.

[0178] In one possible design, the processing module 73 is further configured to: obtain the index subscript according to the mapping table; calculate the offset according to the third parameter value and the index subscript; locate the corresponding array element according to the offset to read the corresponding merging-related information; and obtain the location region corresponding to the region where the completed task has been executed according to the merging-related information.

[0179] For a description of the features in the embodiment corresponding to the task repair device, please refer to the relevant description in the embodiment corresponding to the task repair method, which will not be repeated here.

[0180] Figure 8 This is a schematic diagram of the structure of a task repair device provided in one embodiment of this application, as shown below. Figure 8 As shown, the task repair device 80 provided in the embodiments of this application includes a processor 81 and a memory 82. The task repair device 80 also includes a communication component 83. The processor 81, memory 82, and communication component 83 are connected via a bus 84 and communicate with each other.

[0181] In the specific implementation process, the processor 81 executes the computer execution instructions stored in the memory 82, causing the processor 81 to perform the above-described method.

[0182] The specific implementation process of processor 81 can be found in the above method embodiments, and its implementation principle and technical effect are similar. It will not be repeated here.

[0183] In the above embodiments, it should be understood that the processor 81 can be a Central Processing Unit (CPU), or other general-purpose processors, digital signal processors (DSPs), application-specific integrated circuits (ASICs), etc. The general-purpose processor can be a microprocessor or any conventional processor. The steps of the method disclosed in this invention can be directly implemented by a hardware processor, or implemented by a combination of hardware and software modules within the processor.

[0184] The memory 82 may include random access memory (RAM) and may also include non-volatile memory (NVM), such as at least one disk storage device.

[0185] The bus can be an Industry Standard Architecture (ISA) bus, a Peripheral Component Interconnect (PCI) bus, or an Extended Industry Standard Architecture (EISA) bus, etc. Buses can be categorized as address buses, data buses, control buses, etc. For ease of illustration, the buses shown in the accompanying drawings are not limited to a single bus or a single type of bus.

[0186] Embodiments of this application also provide a computer-readable storage medium storing a computer program, wherein the computer program is configured to execute the steps in any of the above-described task repair method embodiments when it is run.

[0187] In one exemplary embodiment, the aforementioned computer-readable storage medium may include, but is not limited to, various media capable of storing computer programs, such as a USB flash drive, read-only memory (ROM), random access memory (RAM), portable hard disk, magnetic disk, or optical disk.

[0188] Embodiments of this application also provide a computer program product, which includes a computer program that, when executed by a processor, implements the steps in any of the above-described task repair method embodiments.

[0189] Embodiments of this application also provide another computer program product, including a non-volatile computer-readable storage medium storing a computer program, which, when executed by a processor, implements the steps in any of the above-described task repair method embodiments.

[0190] Those skilled in the art will further recognize that the units and algorithm steps of the various examples described in conjunction with the embodiments disclosed herein can be implemented in electronic hardware, computer software, or a combination of both. To clearly illustrate the interchangeability of hardware and software, the components and steps of the various examples have been generally described in terms of functionality in the foregoing description. Whether these functions are implemented in hardware or software depends on the specific application and design constraints of the technical solution. Those skilled in the art can use different methods to implement the described functions for each specific application, but such implementation should not be considered beyond the scope of this application.

[0191] The above provides a detailed description of a task repair method and a task repair device provided in this application. Specific examples have been used to illustrate the principles and implementation methods of this application. The descriptions of the embodiments above are merely for the purpose of helping to understand the method and its core ideas. It should be noted that those skilled in the art can make various improvements and modifications to this application without departing from its principles, and these improvements and modifications also fall within the protection scope of this application.

Claims

1. A task repair method, characterized in that, include: In response to the detection of task rollback requests for multiple executed tasks included in the disk array; Based on a pre-configured mapping table, it is determined whether the position corresponding to the task to be repaired falls into the area of ​​completed tasks. The area of ​​completed tasks is a merged continuous task area, and the task status of any task included in the continuous task area is a completed state. If it is determined that the position corresponding to the task to be repaired falls into the area of ​​completed tasks, then the area of ​​completed tasks is skipped, and the target task area after the area of ​​completed tasks is executed to repair the target task area, which includes at least one unfinished task.

2. The method according to claim 1, characterized in that, The disk array includes multiple task areas, and any one task area includes multiple tasks. Before determining whether the position corresponding to the task to be repaired falls within the area of ​​already completed tasks, based on the pre-configured mapping table, the process also includes: Execute the tasks contained in any task area of ​​the disk array; Determine the merge-related information for any completed task area; Based on the merge-related information, the task regions to be merged are determined, and the task regions to be merged are merged to obtain the task regions that have been executed and completed.

3. The method according to claim 2, characterized in that, The merge-related information corresponding to any completed task area includes: the target starting position and target quantity of any completed task area, wherein the target starting position is the starting position corresponding to the area to be merged, and the target quantity is the number of task areas to be merged up to the task area.

4. The method according to claim 3, characterized in that, The determination of the merging-related information corresponding to any completed task area includes: Determine the status of the previous task corresponding to the previous task area of ​​any completed task area. Based on the previous task status, determine the target location and target quantity corresponding to any completed task area.

5. The method according to claim 4, characterized in that, The step of determining the previous task status corresponding to the previous task area for any completed task area further includes: Determine the value of the second parameter representing the state of the previous task in the previous task area; If the value of the second parameter is the first preset value, then the previous task status is determined to be incomplete. If the value of the second parameter is a second preset value, then the previous task status is determined to be a completed status.

6. The method according to claim 5, characterized in that, Before determining whether the position corresponding to the task to be repaired falls within the area of ​​already completed tasks, based on the pre-configured mapping table, the process also includes: Determine the first parameter value representing the current task state in any of the task regions; If the value of the first parameter is a first preset value, then the current task status is determined to be a completed state. If the value of the first parameter is not the first preset value, then the current task status is determined to be incomplete.

7. The method according to claim 4, characterized in that, The step of determining the target location and target quantity corresponding to any completed task area based on the previous task status includes: If the previous task status is completed, the target location is determined to be the target location corresponding to the previous task area, and the target quantity is determined to be the sum of the target quantity corresponding to the previous task area and the second preset value. If the previous task status is incomplete, the target position is determined to be the difference between the end position of the completed task area and the length of the completed task area, and the target quantity is determined to be a second preset value.

8. The method according to claim 2, characterized in that, The step of determining the task region to be merged based on the merge-related information includes: Multiple completed task regions with the same starting position are identified as task regions to be merged, and the number of task regions to be merged is the same as the number of targets in the last completed task region among the task regions to be merged.

9. The method according to claim 1, characterized in that, The determination of whether the position corresponding to the task to be repaired, based on the pre-configured mapping table, falls within the area of ​​tasks that have already been completed includes: Obtain the value of the third parameter that represents the location of the task to be repaired; Based on the third parameter value and the mapping table, determine the location area corresponding to the area where the task has been completed; Determine whether the value of the third parameter is within the location area corresponding to the area where the task has been completed; If so, then the position corresponding to the task to be repaired is determined to fall into the area of ​​the completed task; If not, then it is determined that the position corresponding to the task to be repaired during the rollback did not fall into the area of ​​tasks that have already been completed.

10. The method according to claim 6, characterized in that, Prior to detecting a task rollback request for multiple executed tasks included in the disk array, the method further includes: The disk array is divided into multiple task areas according to a first preset number. According to the second preset number, each task area is divided equally to obtain multiple sub-task areas corresponding to the task area. Each task region is configured with an array of corresponding length, and each task region is associated with the corresponding array to obtain a first association relationship; wherein, the number of elements in the array is the same as the number of sub-task regions of the corresponding task region, and the array is used to store the merging-related information; Each subtask region is associated with the corresponding array element in the array to obtain a second association relationship; Based on the first association relationship and the second association relationship, the mapping table is constructed. The mapping table is used to locate the corresponding array element according to the cursor index value of the task.

11. The method according to claim 10, characterized in that, The task to be executed in any task area of ​​the disk array includes: Based on the cursor index value of the task and the mapping table, locate the corresponding array element; When a preset number of tasks are detected to be in a completed state, merge-related information corresponding to the completed task area is generated. Write the merge-related information into the array element.

12. The method according to claim 11, characterized in that, When a predetermined number of consecutive tasks are detected to be in a completed state, merge-related information corresponding to the completed task area is generated, including: Obtain the second parameter value of the task; If the second parameter value is the first value, then the historical target quantity is incrementally updated to generate the target quantity of the merged related information; If the second parameter value is the second value, then determine whether the number of historical targets is less than the current number of targets; If it is less than the target number, then the current target number will be used as the target number for merging the relevant information.

13. The method according to claim 12, characterized in that, After determining whether the number of historical targets is less than the current target number, the method further includes: If it is greater than the target number, the task continues to be executed and the current target number is continuously accumulated until the historical target number is less than the current target number, or the value of the first parameter is detected to be different from the first preset value. If the historical target number is less than the current target number, then the current target number will be used as the target number for merging the relevant information; If the value of the first parameter is not the first preset value, then the currently generated merge-related information is cleared.

14. The method according to claim 9, characterized in that, The step of determining the location region corresponding to the region where the task has been completed, based on the third parameter value and the mapping table, includes: According to the mapping table, obtain the index subscript; The offset is calculated based on the third parameter value and the index subscript; Based on the offset, the corresponding array element is located to read the corresponding merge-related information; Based on the merge-related information, obtain the location region corresponding to the region where the completed task has been executed.

15. A task repair device, characterized in that, include: Memory, processor; The memory stores computer-executed instructions; The processor executes computer execution instructions stored in the memory, causing the processor to perform the task repair method as described in any one of claims 1-14.

Images