Method for performing data write using autonomous yielding mechanism in multi-cpu architecture

Abstract

The application discloses a method for executing data writing by using an autonomous yielding mechanism in a multi-CPU architecture, which is suitable for a solid state disk storage device. The method divides a main buffer area into multiple sub-buffer areas, each of which corresponds to at least one CPU, independently processes data writing and maintains a writing state; a global data consistency mark table and a local mark table are established to track the writing progress of each sub-buffer area, forming a double-layer consistency management. Each CPU sequentially writes data according to the corresponding sub-buffer area, and autonomously judges whether to interrupt, shorten or abandon the current writing section based on local observation information, temporarily yields the writing permission to other CPUs, temporarily retains and tracks the written data, continues writing when the subsequent CPU is completed or the system allows, and synchronously updates the mark table after any writing or yielding is completed, so as to maintain data consistency and overall efficiency.

Description

Technical Field

[0001] This invention relates to solid-state drive storage systems and multiprocessor data management technology, and in particular to a method for performing data writing in a multi-CPU architecture using an autonomous yielding mechanism to improve parallel writing efficiency and data consistency. Background Technology

[0002] Existing multi-CPU architecture solid-state drives (SSDs) or storage devices largely rely on central scheduling or global locking mechanisms for data write management to ensure data consistency and write order across different CPUs. However, these methods have multiple limitations and bottlenecks, making it difficult to fully utilize the performance of multi-CPU systems. On the one hand, central scheduling or global locking can easily cause some CPUs to wait for write permissions for extended periods, resulting in idle main or sub-buffer resources, reducing overall buffer utilization and failing to effectively support high-throughput data write demands. On the other hand, current technologies lack the ability to dynamically adjust for performance differences or write latency between CPUs. When a CPU is operating at low efficiency or encounters data transfer bottlenecks, overall write efficiency is dragged down, causing a decline in system performance.

[0003] Furthermore, existing technologies typically employ fixed scheduling or static allocation of sub-buffers for writing, lacking mechanisms for alternating writes or dynamically adjusting segments based on real-time CPU status. This results in poor parallel write efficiency and makes it difficult to balance data consistency and performance requirements. Traditional methods also lack safe interruption or temporary storage mechanisms for data that has not yet been committed. When rescheduling or resource allocation is required, it may lead to data rewriting, wasted computing resources, and even affect data consistency, increasing management burden. Simultaneously, in existing systems, individual CPUs often cannot autonomously determine their write load, performance, or buffer usage status, and cannot proactively decide to pause, shorten, or abandon the current write segment. Therefore, they cannot effectively distribute write pressure or improve the efficiency of collaboration between CPUs. In high-load or multi-CPU expansion scenarios, the synchronization latency and management complexity of central scheduling and global locking methods increase exponentially with the number of CPUs, further limiting the overall system performance and expansion potential. Moreover, existing technologies lack flexibility and autonomy in cache management, data consistency marking, sub-buffer allocation, and alternating write collaboration, making it impossible to automatically adjust write strategies to improve overall efficiency even when some CPUs are idle or resources are not fully utilized.

[0004] Due to the aforementioned limitations, existing multi-CPU solid-state drive storage systems struggle to simultaneously achieve high performance, data consistency, resource utilization, and elastic scalability. In particular, their performance improvement potential is limited in high-load, large-data-volume, or multi-CPU parallel environments. Therefore, a new data write management method is urgently needed, which enables each CPU to dynamically alternate writing through autonomous judgment and yielding mechanisms while maintaining data consistency, thereby improving overall storage efficiency and multi-CPU system performance. Summary of the Invention

[0005] One objective of this invention is to provide a method for performing data writing in a multi-CPU architecture using a self-giving mechanism, which improves the write efficiency and multi-CPU parallel performance of solid-state drive (SSD) storage devices while maintaining data consistency. This method divides the main buffer into multiple independently operable sub-buffers and establishes corresponding local and global consistency management for each CPU. This allows each CPU to autonomously assess write load, performance, and security interruption conditions, and to interrupt, shorten, or relinquish its current write segment as needed, temporarily granting write access to other CPUs while retaining written data and tracking progress. This enables alternating writing and dynamic adjustment of sub-buffers. In this way, the invention effectively reduces the problem of a single CPU occupying resources for extended periods, improves overall buffer utilization efficiency, enhances inter-CPU write cooperation, and avoids performance losses caused by data inconsistency or rewriting.

[0006] To achieve the above objectives, the present invention provides a method for performing data writing using an autonomous yielding mechanism in a multi-CPU architecture, applied to a solid-state drive (SSD) storage device, comprising: (A) a sub-buffer configuration step: dividing a main buffer of the storage device into multiple independently operable sub-buffers, each sub-buffer corresponding to at least one CPU to handle data writing tasks; wherein each sub-buffer can independently accept write requests and maintain its write state; (B) a consistency management establishment step: establishing a global data consistency tag table to record the overall write state of the multiple sub-buffers, and establishing a corresponding local tag table for each CPU to record the real-time write state of the multiple sub-buffers belonging to the multiple CPUs, thereby forming a two-layer consistency management, enabling each CPU to perform partially independent write behavior under consistency constraints; (C) a write execution step: each CPU executes data writing according to the write order of its multiple sub-buffers, and during the alternating write process, each CPU further decides, according to a yielding strategy, whether to interrupt, shorten, or abandon the execution of its current write segment, so as to temporarily... The write permission is granted to other CPUs. The pass-through strategy refers to the decision made by multiple CPUs during data write execution based on their locally observable write status information, whether to relinquish the current write segment, so that the write permission can be transferred to other CPUs without the need for central scheduling, global locking, or forced arbitration. During the pass-through period, the data already written by the original CPU is retained in the original sub-buffer and the progress is tracked by the local tag table. When other CPUs complete their segment write or the system schedule allows it, the original CPU can resume writing from the pause point to perform alternating writes or write segment adjustments for the multiple sub-buffers. (D) Status synchronization update step: After any write, alternation, or pass-through behavior is completed, the status information of the multiple sub-buffers in the global data consistency tag table and the corresponding local tag table is updated synchronously to maintain data consistency and overall write efficiency when multiple CPUs write in parallel.

[0007] Preferably, the yielding strategy is that when each CPU determines that the amount of data, the writing time, or the corresponding writing load of its current writing segment exceeds a preset threshold during the execution of the writing segment, it actively abandons the continuous execution of the writing segment in order to release the write permission of the corresponding sub-buffer.

[0008] Preferably, the yielding strategy is that when each CPU determines, based on its locally observable write performance status information, that the latency, cache hit rate, or data filling efficiency of its current write operation is lower than a performance threshold, it actively interrupts or shortens the execution of its write segment to temporarily relinquish the write permission of the sub-buffer.

[0009] Preferably, the multiple CPUs execute the yielding policy only when their current write segment is in a safe interruptible state; wherein the safe interruptible state means that the data in the write segment has not yet been marked as committed, and its write content can be temporarily stored, reclaimed, or reallocated without affecting data consistency.

[0010] In summary, the core of this invention lies in the autonomous yielding mechanism under a multi-CPU architecture, providing a flexible, efficient, and reliable data writing method. Through this mechanism, each CPU can autonomously determine whether to interrupt, shorten, or abandon the current write segment based on its locally observable write status information, temporarily yielding write access to other CPUs without relying on central scheduling, global locking, or mandatory arbitration procedures. This autonomous decision-making effectively avoids a single CPU occupying sub-buffer resources for extended periods, promoting balance and cooperation among multiple CPUs, making parallel write operations smoother and significantly improving overall efficiency. Furthermore, during the yielding period, the data already written by the original CPU remains in the corresponding sub-buffer, and progress is tracked by a local tag table, ensuring data integrity, rewritability, and reclaimability, preventing data loss, duplicate writes, or consistency errors. Through this mechanism, this invention can dynamically adjust resource allocation among multiple CPUs, achieving real-time balance between write load and performance differences, optimizing the throughput and response speed of the storage device, while reducing system bottlenecks and resource contention risks, significantly improving the overall performance and stability of solid-state drives under high-load, multi-CPU parallel environments. This autonomous yielding strategy simplifies the write scheduling process, provides an innovative and practical multi-CPU data write control scheme, fully utilizes the potential of storage system resources, and achieves efficient and secure data processing. Attached Figure Description

[0011] Figure 1 This is a flowchart of a preferred embodiment of the present invention.

[0012] Explanation of reference numerals in the attached figures: (A)~(D) - steps. Detailed Implementation

[0013] To enable those skilled in the art to clearly understand the technical content of this invention, the following embodiments are described in conjunction with the accompanying drawings to further illustrate the operation of this invention. Please refer to... Figure 1 This is a flowchart of a preferred embodiment of the present invention, wherein each step will be described sequentially in the following embodiments to illustrate the technical features and operation flow of the present invention.

[0014] This invention provides a method for performing data writing in a multi-CPU architecture using a self-giving mechanism, applicable to solid-state drive (SSD) storage devices. First, the (A) sub-buffer configuration step is performed: In the storage device, its main buffer is divided into multiple independently operable sub-buffers, each corresponding to at least one CPU to handle data writing tasks. "Independently operable" means that each sub-buffer can accept write requests independently without waiting for other sub-buffers to complete their operations; simultaneously, each sub-buffer maintains its write status information, such as the amount of data currently filled, write progress, or whether it is idle, for the CPU to refer to in subsequent operations. For example, if the storage device contains four CPUs, the main buffer can be divided into four sub-buffers, each corresponding to a CPU. When CPU1 needs to write data, it only operates on its corresponding sub-buffer without affecting the operations of other CPUs; this method can improve the efficiency of parallel writing by multiple CPUs and avoid resource blocking.

[0015] Next, execute step (B) of the consistency management establishment process: Establish a global data consistency flag table to record the overall status of each sub-buffer during the write process. This global data consistency flag table provides information on the occupancy and availability of each sub-buffer, without involving scheduling, arbitration, or control decisions for write operations. Simultaneously, establish a corresponding local flag table for each CPU to record the real-time write status information of the sub-buffer belonging to that CPU, including the amount of data written, the current write segment position, or the segment's progress status, for the CPU to use for local judgment and control during the write process. Each CPU autonomously executes write operations or subsequent operations based solely on the observable write status information provided by its local flag table. The global data consistency flag table serves only for status synchronization and result provision, ensuring data consistency is maintained even when multiple CPUs write in parallel, without constituting a central scheduling or centralized control mechanism.

[0016] Next, the (C) write execution step is performed: After obtaining write permission for its corresponding sub-buffer, each CPU executes data writing according to the write order of its sub-buffer. During the write execution, it continuously evaluates the execution status of its current write segment based on the real-time write status information provided by its local tag table. During the write process, each CPU further determines whether to interrupt, shorten, or abandon the execution of its current write segment based on a yielding strategy. This yielding strategy is made by the CPU itself during the data write execution based on its locally observable write progress, segment status, or resource usage, rather than based on status notifications from other CPUs, central scheduling instructions, or global arbitration results. In short, each CPU continuously monitors its local tag table during the write process, and autonomously decides whether to interrupt, shorten, or abandon the current segment based on its own observable data volume, write load, or performance indicators. It immediately retains the yielding behavior execution result in its local tag table and synchronously updates the global tag table, without central intervention.

[0017] For example, in one implementation, each CPU, while executing its assigned write segment, can continuously assess the cumulative data volume, actual write time, or corresponding write load of that write segment based on its locally observable write status information. When a CPU determines that the data volume of its current write segment is too large, the continuous write time is too long, or the write load has exceeded a preset threshold, the CPU can proactively relinquish the continuous execution of that write segment to release the write permission of the corresponding sub-buffer. In this way, write permission can be autonomously relinquished by the CPU based on its own write status without central scheduling or global arbitration, allowing other CPUs to utilize the sub-buffer for subsequent write operations, thereby preventing a single CPU from occupying write resources for an extended period. The preset threshold can be one or more reference conditions used to determine whether a write segment is suitable for continuous execution. For example, the threshold may include the maximum data volume limit of a single write segment, the longest allowed continuous write time, or the relative write load proportion undertaken by the CPU during the write period. In one implementation, these thresholds can be set according to the hardware characteristics of the storage device, the size of the sub-buffer, or the processing power of the CPU, and can be selected or adjusted by each CPU before or during the execution of a write task, rather than being determined uniformly by a central scheduling unit.

[0018] Alternatively, in another implementation, each CPU can autonomously determine the execution quality of the current write operation based on its locally observable write performance status information. This write performance status information may include metrics such as write latency variations, cache hit rate, or data filling efficiency. When a CPU determines that the performance of its current write operation is below a performance threshold, the CPU can proactively interrupt or shorten the execution of its write segment to temporarily relinquish write access to the corresponding sub-buffer. In this way, write resources can avoid being continuously allocated to poorly performing write operations, instead allowing other CPUs to perform data writing under better conditions, thereby improving the overall multi-CPU write efficiency. The performance threshold is used as a criterion for evaluating whether the current write operation still possesses execution efficiency. For example, it may include a write latency exceeding an allowable time range, a write-related cache hit rate below a reference ratio, or the effective data filling amount per unit time failing to reach a minimum efficiency standard. In one implementation, the performance threshold is determined by comparing the performance status information available locally to each CPU, and these thresholds can be dynamically adjusted according to different write scenarios or workloads, without relying on global performance evaluation or central control unit for judgment.

[0019] On the other hand, in some implementations, to maintain data stability, the aforementioned yielding strategy can be limited to not being executed at any arbitrary point in time. Instead, it requires that each CPU's current write segment be in a safe-to-interrupt state before it can perform the autonomous yielding behavior. The so-called safe-to-interrupt state means that the data in the write segment has not yet been marked as committed, and its written content can be temporarily stored, reclaimed, or reallocated without affecting data consistency or system correctness. By confirming this safe-to-interrupt state before yielding, even if the CPU actively interrupts or abandons the current write segment, it can ensure that the written data will not cause data loss or consistency errors, thereby achieving autonomous yielding while maintaining data reliability.

[0020] Furthermore, when a CPU decides to yield based on its own judgment, it temporarily releases the write permission of its corresponding sub-buffer, allowing other CPUs to acquire the sub-buffer and execute their data write tasks. During the yielding period, the data that the CPU had already written remains in the sub-buffer, and its write progress and segment position are recorded by the CPU's local flag table, without being considered as a completed commit. When the CPU subsequently regains write permission, it can resume data writing from the originally interrupted write segment according to the pause point recorded in its local flag table. This allows each sub-buffer to form an alternating, interruptible, and resumable write process under multi-CPU parallel operation, without the need for a central scheduling or global locking mechanism.

[0021] Finally, the (D) state synchronization update step is executed: After any CPU completes a write operation or performs a yielding action, it must synchronously update the state information of its sub-buffer in the global data consistency flag table and the corresponding local flag table. This synchronization mechanism ensures data consistency and overall efficiency during parallel writes by multiple CPUs, avoiding resource conflicts or duplicate operations due to outdated state. For example, after CPU1 completes the write to a sub-buffer segment, it updates the global data consistency flag table to "this segment has been written," allowing other CPUs to refer to this information in real time for subsequent operations. This step enables the entire system to maintain high efficiency and stability during parallel writes by multiple CPUs.

[0022] In summary, the core of this invention lies in the autonomous yielding mechanism under a multi-CPU architecture, providing a flexible, efficient, and reliable data writing method. Through this mechanism, each CPU can autonomously determine whether to interrupt, shorten, or abandon the current write segment based on its locally observable write status information, temporarily yielding write access to other CPUs without relying on central scheduling, global locking, or mandatory arbitration procedures. This autonomous decision-making effectively avoids a single CPU occupying sub-buffer resources for extended periods, promoting balance and cooperation among multiple CPUs, making parallel write operations smoother and significantly improving overall efficiency. Furthermore, during the yielding period, the data already written by the original CPU remains in the corresponding sub-buffer, and progress is tracked by a local tag table, ensuring data integrity, rewritability, and reclaimability, preventing data loss, duplicate writes, or consistency errors. Through this mechanism, this invention can dynamically adjust resource allocation among multiple CPUs, achieving real-time balance between write load and performance differences, optimizing the throughput and response speed of the storage device, while reducing system bottlenecks and resource contention risks, significantly improving the overall performance and stability of solid-state drives under high-load, multi-CPU parallel environments. This autonomous yielding strategy simplifies the write scheduling process, provides an innovative and practical multi-CPU data write control scheme, fully utilizes the potential of storage system resources, and achieves efficient and secure data processing.

[0023] The above description is merely a preferred embodiment of the present invention and is not intended to limit the scope of the present invention. Therefore, all equivalent changes and modifications made without departing from the scope of the present invention should be covered within the protection scope of the present invention.

Claims

1. A method for performing data writing using a self-giving mechanism in a multi-CPU architecture, applied to a solid-state drive (SSD) storage device, characterized in that, Include: (A) Sub-buffer configuration steps: Divide a main buffer of the storage device into multiple sub-buffers that can operate independently, each of the multiple sub-buffers corresponding to at least one of the CPUs to process data write tasks; wherein each sub-buffer can independently accept write requests and maintain its write state. (B) Consistency Management Establishment Steps: Establish a global data consistency tag table to record the overall write status of the multiple sub-buffers, and establish a corresponding local tag table for each CPU to record the real-time write status of the multiple sub-buffers belonging to the CPU, thereby forming a two-layer consistency management, so that each CPU can perform partially independent write behavior under consistency constraints. (C) Write Execution Steps: Each CPU executes data writing according to the write order of its multiple sub-buffers. During the alternating write process, each CPU also actively decides whether to interrupt, shorten, or abandon the execution of its current write segment based on a yielding strategy, so as to temporarily yield the write permission to other CPUs. This yielding strategy refers to the multiple CPUs autonomously making a decision on whether to abandon the current write segment based on the write status information they can observe locally during the data write execution, so that the write permission can be transferred to other CPUs without the need for central scheduling, global locking, or forced arbitration procedures. During the yielding period, the data already written by the original CPU is retained in the original sub-buffer, and the progress is tracked by the local tag table. When other CPUs complete their segment writing or the system schedule allows, the original CPU resumes writing from the pause point to perform alternating writing or write segment adjustment of the multiple sub-buffers; and (D) State synchronization update step: After any write, alternation or yielding action is completed, the state information of the multiple sub-buffers in the global data consistency mark table and the corresponding local mark table is updated synchronously to maintain data consistency and overall write efficiency when multiple CPUs write in parallel.

2. The method as described in claim 1, characterized in that, The yielding strategy is that when each CPU determines that the amount of data, the writing time, or the corresponding writing load of its current writing segment exceeds a preset threshold during the execution of a writing segment, it will actively give up the continuous execution of the writing segment in order to release the write permission of the corresponding sub-buffer.

3. The method as described in claim 1, characterized in that, The yielding strategy is that when each CPU determines, based on the write performance status information it can observe locally, that the latency, cache hit rate, or data filling efficiency of its current write operation is lower than a performance threshold, it actively interrupts or shortens the execution of its write segment to temporarily relinquish the write permission of the sub-buffer.

4. The method as described in claim 2 or 3, characterized in that, Multiple CPUs will only execute the yielding policy when their current write segment is in an interruptible state; wherein, the interruptible state means that the data in the write segment has not yet been marked as committed and its write content can be temporarily stored, reclaimed or reallocated without affecting data consistency.

Images