Log-based append-only storage

Abstract

The embodiment of the invention relates to log-based append-only storage. A method is directed to storing data in a non-volatile storage device. The method includes sequentially writing at least a major portion of the data record into one or more logical blocks of an additional only storage area of the non-volatile storage device until one or more first logical blocks are fully written. The method further includes generating a first log including a remainder of the first data record and a first log entry for the remainder. A storage device control system includes a non-volatile storage device and a controller for the non-volatile storage device.

Description

Technical Field

[0001] The present disclosure relates to a block-level storage device. More specifically, the present disclosure relates to a block storage device in a non-volatile storage device. Background Art

[0002] Block storage, or block-level storage, is a common form of storage for storing data in blocks, such as on a storage area network, in a cloud-based storage environment, etc. Each block can be stored as a separate block with a unique identifier. Cloud-based block storage or storage devices are common products provided by cloud service providers (cloud service provider, CSP). Block-level storage can be used to store data on storage devices (e.g., hard disk drives (HDD), solid-state drives (SSD), etc.). For example, conventional magnetic recording (CMR) is an example of a way to store data on a storage device (e.g., on a HDD) that is usually free of data overwrite constraints. Shingled magnetic recording (SMR) is another example of a way to store data on a storage device (e.g., on a HDD) in which data is stored on a region basis and each region is an append-only medium. Summary of the invention

[0003] In one embodiment, a method for storing data in a non-volatile storage device includes: sequentially writing at least a major portion of a first data record to one or more first logical blocks of a first append-only storage zone of the non-volatile storage device until the one or more first logical blocks are full; and generating a first log, the first log including a remaining portion of the first data record and a log entry for the remaining portion.

[0004] In one embodiment, a storage device control system includes a non-volatile storage device and a controller. The controller is configured to: sequentially write at least a major portion of a first data record into one or more sequential first logical blocks of a first append-only storage area of ​​the non-volatile storage device until the one or more sequential first logical blocks are full; and generate a first log, the first log including a remaining portion of the first data record and a log entry for the remaining portion.

[0005] In one embodiment, a non-transitory computer-readable medium having computer-executable instructions stored thereon, the computer-executable instructions, when executed, causing one or more processors to perform operations. The operations include: sequentially writing at least a major portion of a first data record to one or more first logical blocks of a first append-only storage area of ​​a non-volatile storage device until the one or more first logical blocks are full; and generating a first log, the first log including a remaining portion of the first data record and a log entry for the remaining portion. BRIEF DESCRIPTION OF THE DRAWINGS

[0006] The accompanying drawings illustrate various embodiments of systems, methods, and embodiments of various other aspects of the present disclosure. It will be appreciated by any person of ordinary skill in the art that the element boundaries (e.g., boxes, multiple groups of boxes, or other shapes) shown in the figures represent an example of boundaries. In some examples, an element may be designed as multiple elements, or multiple elements may be designed as one element. In some examples, an element shown as an internal component of an element may be implemented as an external component in another element, and vice versa. A non-restrictive, non-exhaustive description is described with reference to the following figures. The components in the figures are not necessarily drawn to scale, but emphasize the explanation principle. In the following specific embodiments, the embodiments are described only as explanations, because various changes and modifications may become apparent to those skilled in the art according to the following specific embodiments.

[0007] Figure 1 is a schematic diagram of an example cloud-based block storage system arranged in accordance with at least some embodiments described herein.

[0008] Figure 2 is a schematic diagram of an example block storage device control system arranged in accordance with at least some embodiments described herein.

[0009] Figure 3A is a schematic diagram of an embodiment of a storage area in a block-level storage space.

[0010] Figure 3B According to an embodiment Figure 3A Schematic diagram of a first storage area and a second storage area of ​​a block-level storage space in FIG.

[0011] Figure 3C According to one embodiment, after storing the first data record Figure 3B Schematic diagram of a first storage area and a second storage area in a block-level storage space.

[0012] Figure 3D According to one embodiment, after storing the second data record Figure 3B Schematic diagram of a first area and a second area in a block-level storage space.

[0013] Figure 3E According to one embodiment, after storing the third data record Figure 3B Schematic diagram of a first area and a second area in a block-level storage space.

[0014] Figure 4A is a schematic diagram of an embodiment of a first area and a second area in a block-level storage space after storing a first data record.

[0015] Figure 4B After storing the second data record Figure 4A Schematic diagram of a first area and a second area in a block-level storage space.

[0016] Figure 4C After the third data record is stored Figure 4A Schematic diagram of a first area and a second area in a block-level storage space.

[0017] Figure 5 is a flow chart showing an embodiment of a write process flow for aligned block storage writes using a log

[0018] Figure 6 Detailed description is a flowchart showing an embodiment of a write process flow for storing data in a nonvolatile memory.

[0019] Figure 7 is a schematic block diagram of an embodiment of a computer system suitable for implementing an electronic device.

[0020] Like numbers indicate similar features. DETAILED DESCRIPTION

[0021] In the following detailed description, specific embodiments of the present disclosure are described herein with reference to the accompanying drawings, which form a part of the description. In this specification and the accompanying drawings, similar reference numerals represent elements that can perform the same, similar or equivalent functions, unless the context otherwise dictates. In addition, unless otherwise specified, the description of each consecutive figure may refer to features from one or more previous figures to provide a clearer context and more substantial explanation of the current example embodiment. Nevertheless, the example embodiments described in the specific embodiments, the accompanying drawings, and the claims are not intended to be limiting. Other embodiments may be utilized, and other changes may be made, without departing from the spirit or scope of the subject matter presented herein. It will be readily understood that, as generally described herein and shown in the accompanying drawings, the various aspects of the present disclosure may be arranged, replaced, combined, separated, and designed in a variety of different configurations, all of which are explicitly contemplated herein.

[0022] It should be understood that the disclosed embodiments are merely examples of the present disclosure, which may be embodied in various forms. Well-known functions or structures are not described in detail to avoid unnecessary details that obscure the present disclosure. Therefore, the specific structural and functional details disclosed herein should not be interpreted as limiting, but merely as a basis for the claims, and as a representative basis for teaching those skilled in the art to variously adopt the present disclosure with almost any appropriate detailed structure.

[0023] In addition, the present disclosure may be described herein in terms of functional block components and various processing steps. It should be understood that these functional blocks may be implemented by any number of hardware components and / or software components configured to perform the specified functions.

[0024] The scope of the present disclosure should be determined by the appended claims and their legal equivalents, rather than by the examples given herein. For example, the steps recited in any method claim may be performed in any order and are not limited to the order presented in the claim. In addition, no element is essential to the practice of the present disclosure unless specifically described as "critical" or "essential" herein.

[0025] As referred to herein, a "block" or "logical block" in a data storage device may refer to a fixed-size amount of storage within a storage medium that can store a piece of data. It should be understood that data may be stored in blocks, and each block may be assigned a unique address or identifier. In an example embodiment, the size of each block may be 4KB.

[0026] As referred to herein, "padding" in a data storage device may refer to additional non-information bits added to data (eg, to the end of the data) to cause the data to be of the expected size. "Padding" is provided to allow data to be written aligned with the logical block size.

[0027] As mentioned herein, "aligned write" and "logical block alignment" in a data storage device refers to writing data that just fills one or more logical blocks into the one or more logical blocks. For example, for a logical block size of 4KB, logical blocks are written in increments of 4KB (e.g., 4KB, 8KB, 12KB, etc.) so that all blocks being written are filled.

[0028] As referred to herein, “append only” in a data storage device may refer to a storage area in which written data cannot be overwritten unless the entire storage area is reset.

[0029] As referred to herein, "metadata" may refer to data that provides information about other data, but not the content of the data. It should be understood that metadata may be referred to as "data about data" (i.e., data that provides information about one or more aspects of other data). In some example embodiments, metadata may include the time and date of creation, the size of the data, the source of the data, the purpose of the data, links between two pieces of data, etc.

[0030] As referred to herein, "remainder" or "remainder" refers to a portion of a data record that is not written to a data storage area, and may be the entirety of an entire data record. For example, the remainder of a data record may be less than the entirety of the data record or the entire data record, depending on the size of the data record and the logical block size.

[0031] Figure 1 is a schematic diagram of an example cloud-based block storage system 100 arranged in accordance with at least some embodiments described herein.

[0032] System 100 may include terminal devices 110, 120, 130, and 140, a network 160, a host controller 170 (eg, a host device), and one or more servers 150A-150N. It should be understood that Figure 1 Only exemplary numbers of terminal devices, networks, host controllers, and servers are shown. The embodiments described herein are not limited to the number of terminal devices, networks, host devices, and / or servers described. That is, the number of terminal devices, networks, and / or servers described herein is provided for illustrative purposes only and is not intended to be limiting.

[0033] According to at least some example embodiments, terminal devices 110, 120, 130, and 140 may be various electronic devices. Various electronic devices may include, but are not limited to, mobile devices such as smart phones, tablet computers, e-book readers, laptop computers, desktop computers, and / or any other suitable electronic devices.

[0034] According to at least some example embodiments, the network 160 may be a medium for (e.g., designed, programmed, or otherwise programmed to) provide a communication link between the terminal devices 110, 120, 130, 140 and the server 150. The network 160 may be the Internet, a local area network (LAN), a wide area network (WAN), a local interconnect network (LIN), a cloud network, etc. The network 160 may be implemented by various types of connections such as a wired communication link, a wireless communication link, an optical fiber cable, etc.

[0035] According to at least some example embodiments described and documented herein, the host controller 170 is designed, programmed, or otherwise configured to link servers 150A-150N together (e.g., in a data center), or to link other host controllers together (e.g., in other data centers). In addition, the host controller 170 is designed, programmed, or otherwise configured to send and / or receive applications, services, data, etc. to one or more of the connected terminal devices 110, 120, 130, 140.

[0036] According to at least some example embodiments, one or more servers 150A-150N are designed, programmed, or otherwise configured to provide various services, such as cloud storage services and / or computing services, to end users using one or more of terminal devices 110, 120, 130, 140. Servers 150A-150N may be implemented as a data center including a distributed server cluster, which includes one or more of servers 150A-150N. In some embodiments, one or more data centers may communicate with each other via a network 160. One or more of servers 150A-150N may also include a controller to control hardware and / or store software and firmware, and provide the functionality of one or more of servers 150A-150N. Hereinafter, unless the context requires otherwise, reference will be made to "server 150" that conveys the implementation of one or more of servers 150A-150N.

[0037] In some embodiments, the server 150 may physically or communicatively correspond to one or more such storage devices, such as non-volatile hard disk drives (HDDs) (e.g., magnetic disk drives), non-volatile memory (NVM) solid-state drives (SSDs) (e.g., flash memory) using various communication interfaces that allow for robust data storage and / or retrieval on one or more storage devices. In some embodiments, the server 150 may physically or communicatively communicate with one or more HDDs using a communication protocol that allows for robust data storage and / or retrieval on its non-volatile magnetic disk drives.

[0038] The end user may use one or more of the terminal devices 110, 120, 130, and 140 to interact with the server 150 via the network 160. Various applications, such as social media applications, may be installed on the terminal devices 110, 120, 130, and 140. In some embodiments, the end user may request big data analysis or data mining of data on a storage device connected to the server 150 for supporting a learning model, etc. In some embodiments, the end user may transmit data to be stored on the storage device(s) connected to the server 150.

[0039] It should be understood that the software application or service according to the embodiments described herein and / or according to the services provided by the cloud service provider may be executed by the server 150 and / or the terminal devices 110, 120, 130, and 140 (which may be referred to as user devices in this article). Accordingly, the apparatus for the software application and / or service may be arranged in the server 150 and / or in the terminal devices 110, 120, 130, and 140.

[0040] It should also be understood that, in the case where the service is not performed remotely, the system 100 may not include the network 160, but only include the terminal devices 110, 120, 130 and 140 and / or the server 150. In addition, according to some example embodiments described herein, when the service is not performed remotely, the system 100 may not include the network 160, but include the terminal devices 110, 120, 130 and 140, the host controller 170 and / or the server 150.

[0041] It should also be understood that the terminal devices 110, 120, 130 and 140 and / or the server 150 may each include one or more processors, memories and storage devices storing one or more programs. The terminal devices 110, 120, 130 and 140 and / or the server 150 may also each include an Ethernet connector, a wireless fidelity receiver, etc. One or more programs, when executed by one or more processors, may cause one or more processors to perform the (multiple) methods described in any embodiment described herein. In addition, it should be understood that according to the embodiments described herein, a computer-readable non-volatile medium may be provided. The computer-readable medium stores a computer program. The computer program is used to perform the (multiple) methods described in any embodiment described herein when executed by a processor.

[0042] Figure 2 is a schematic diagram of an example block storage device control system 200 arranged in accordance with at least some embodiments described herein.

[0043] The system 200 can be arranged according to at least some embodiments described herein. Although shown as discrete components, various components can be divided into additional components, combined into fewer components, or eliminated altogether while being contemplated within the scope of the disclosed subject matter. Each function and / or operation of a component can be implemented individually and / or collectively by a wide variety of hardware, software, firmware, or any combination thereof.

[0044] System 200 includes a host 210, a block storage write module 220, and one or more storage devices 230A-230N. One or more of storage devices 230A-230N may be block storage devices. Host 210 may direct data to be stored on storage devices 230A-230N. Host 210 may access and / or retrieve data on storage devices 230A-230N.

[0045] According to the example embodiments described and documented herein, the host device 210 may be implemented as Figure 1 A controller, processor (e.g., CPU (central processing unit)) or software on a server 150 in the block storage device control system 200 or on a central node in the block storage device control system 200; and can be communicatively connected to one or more of the server 150 and / or the block storage write module 220. In some example embodiments, the host 210 may physically or communicatively correspond to Figure 1 In one example embodiment, the host 210 may correspond physically or communicatively to the server 150. Figure 1 The host 210 may correspond to the server 150, and the block storage write module 220 may correspond to the server 150. In another example embodiment, the host 210 may correspond to the server 150, and the block storage write module 220 may physically or communicatively correspond to the controller of the associated (multiple) storage devices (e.g., the controller of the storage devices 230A-230N), Figure 1 The software and / or controller of the host 170 in the embodiment of the present invention and / or the firmware of the storage device associated with the server 150. For example, Figure 2 The storage write module 220 shown may be incorporated into the host 210 (eg, as software in the host 210), or may be incorporated into the storage devices 230A-230N (eg, as a controller in the storage devices 230A-230N, as firmware of the storage devices 230A-230N).

[0046] In some embodiments, host device 210 may include processor 212 and one or more software applications 214 to operate, manipulate, read, write, delete, store, or otherwise access data on one or more of storage devices 230A-230N via storage write module 220. When host device 170 is configured to write directly to storage devices 230A-230N, host device 170 may be incorporated into host device 170 as software 214 implemented by software 212.

[0047] The storage write module 220 is designed, programmed, or otherwise configured to store (e.g., write) data in the storage devices 230A-230N. The storage write module 220 may include and / or be implemented as software, firmware, an application specific integrated circuit (ASIC) and / or a field programmable gate array (FPGA). In some embodiments, the storage write module 220 may also be designed, programmed, or otherwise configured to write, delete, store, or otherwise access data stored on one or more of the storage devices 230A-230N.

[0048] According to some example embodiments described herein, one or more of the host 210, the block storage write module 220, and / or the storage devices 230A-230N may include a memory 216, 222, 232A-232N. For example, the memory 216, 222, 232A-232N may include a random access memory (RAM), such as a dynamic random access memory (DRAM), a static random access memory (SRAM), etc. The memory / RAM may be configured to be used as one or more logs (e.g., Figure 3C-Figure 3D Logs 310, 320, 330, Figure 4A-4C 310, 330 in the memory cache, as described below), as described below.

[0049] In one embodiment, the memory 216, 222, 232A-232N may include a non-volatile memory, such as a hard disk drive HDD, an SSD, etc. In one example embodiment, the non-volatile memory in the memory 216, 222, 232A-232N may be used to store logs generated for the remainder that occurs when storing data on the storage devices 230A-230N (e.g., Figure 3C-Figure 3D Logs 310, 320, 330 in Figure 4A-4C For example, the logs generated for the remainder of storing data on the storage devices 230A-230N may be stored (e.g., written) in non-volatile memory and / or memory cache in the memory 216, 222, 232A-232N of the host 210, the block storage write module 220, and / or one or more of the storage devices 230A-230N.

[0050] According to some example embodiments described herein, the host device 210 is designed, programmed, or otherwise configured to support a big data analysis system, and / or is combined with a business intelligence solution (e.g., data mining, predictive analysis, real-time analysis, etc.) that collects, processes, cleans, and analyzes big data. Therefore, the host device 210 may include one or more software applications 214 to support the big data analysis system, and may include one or more of an application programming interface (API), a software development kit (SDK), one or more device drivers, one or more runtime libraries, one or more software plug-ins, management tools, etc.

[0051] In an example embodiment, the operation of the block device write module 220 may be transparent to the host 210. That is, the host 210 operates, manipulates, reads, writes, stores, or otherwise accesses data on the storage devices 230A-230N via the block device write module 220. For example, when the host 210 writes data to the storage devices 230A-230N, the host 210 may send the data to the block storage write module 220. For example, the host 210 may access and / or retrieve data stored on the storage devices 230A-230N via the block storage write module 220. The block storage write module 220 may control the storage / writing of data on the storage devices 230A-230N.

[0052] In an example embodiment, the interface between the host 210 and the block storage write module 220 and / or the interface between the storage devices 230A-230N and the block storage write module 220 may be, for example, an interface that implements a non-volatile memory express (NVMe) storage access and transfer protocol. It should be understood that the features of the embodiments disclosed herein may be implemented in the block storage write module 220. In an example embodiment, the block storage write module 220 may include one or more components of the computer system 2000 (e.g., Figure 7 In one example embodiment, the block storage write module 220 may include storage devices 230A-230N. In one example embodiment, the block storage write module 220 may be in the form of a computer card or the like.

[0053] Figure 3A-3B 300 are schematic diagrams of example storage spaces 300 arranged according to at least some embodiments described herein. Storage space 300 is a storage space in a non-volatile memory. For example, storage space 300 in one embodiment may be Figure 2 The storage space 300 is a storage space of a non-volatile memory of one or more storage devices 230A-230N in the block-level storage device. The storage space 300 is a block-level storage space in a block-level storage device (for example, one or more storage devices 230A-230N are block-level storage devices). Figure 3C-Figure 3D is a schematic diagram showing an example of storing (eg, writing) data records into the block-level storage space 300 .

[0054] In a block-level storage device, the block-level storage space is divided into multiple storage areas with set sizes. Each storage area contains multiple logical blocks with a set size (i.e., a set logical block size). The block-level storage space is divided into multiple storage areas, each of which contains multiple logical blocks (logic blocks, LB). In a non-limiting example, the area size may be 256MB, and the logical block size may be 4KB (for example, the size of each storage area is 256MB, and the size of each logical block is 4KB). It should be understood that there are no particular limitations on the area size and the logical block size, and in other embodiments may be sizes different from 256MB and 4KB. For example, in other embodiments, the area size may be, but is not limited to, 1024MB, 512MB, 128MB, 64MB, etc. For example, the logical block size in other embodiments may be, but is not limited to, 4KB, 8KB, 16KB, 32KB, etc. In Figure 3A-3E In the embodiment shown, the region size is 256MB.

[0055] Figure 3Ais a storage area Z in an example storage space 300 according to one embodiment. D1 -Z JM The storage space 300 includes a storage area Z D1 -Z JM .For example, Figure 3A Storage area Z in D1 -Z JM A group of storage areas that are physically adjacent to each other in the storage space 300. Storage area Z D1 -Z JM Including data storage area Z D1 -Z DN (e.g., N data storage areas) and log storage area Z J1 -Z JM (For example, M log storage areas).

[0056] In an exemplary embodiment, the storage space 300 is a storage space in a hard disk drive (HDD). In an HDD, storage areas are arranged on parallel tracks. The storage space 300 may be divided into data storage areas (e.g., data storage area Z D1 -Z DN ) and log storage area (log storage area Z J1 -Z JM ). Figure 3A A set of storage areas Z in D1 -Z JM Corresponding to physically adjacent storage areas located in adjacent tracks. Storage areas are utilized so that at least one log storage area is allocated to each data storage area. For example, the ratio of data storage areas to log storage areas (N:M) can be adjusted to optimize data lookups or log lookups. For example, in an example embodiment, when they have the same number of open areas, the inner tracks in the HDD (e.g., closer to the center of the disk) have a smaller ratio of data storage areas to log storage areas than the tracks further outward. Although log storage areas have been described herein as corresponding to storage areas, such disclosure is not intended to be limiting. More specifically, log storage areas can be used to support one or more storage areas, e.g., one or more open areas, etc.

[0057] In the embodiment shown, the storage area Z D1 -Z JMEach is an append-only storage area. In an append-only storage area, overwriting is not allowed within the area. For example, data is written sequentially to logical blocks of the append-only storage area so that writes in the area are continuous and data in the area cannot be overwritten. For example, sequential writes in an append-only storage area begin with the first logical block in the sequence in the storage area, occur continuously within the storage area, and end with the last logical block in the sequence in the storage area. When data is no longer required to be retained in the append-only storage area, the append-only storage area can be reset (e.g., by Figure 2 The storage write module 220 in is indicated as empty), which may allow new data to be written sequentially to the append-only storage area.

[0058] In an example embodiment, each region in the storage space can be in a free region state, an open region state, or a full region state. A region in a free state contains unwritten logical blocks (e.g., the region does not contain data) and does not allow writing. A region in an open state can be written in an append-only manner. For example, the controller managing the storage space (e.g., Figure 2 A controller of a block level storage device 230A-230N in Figure 2 The associated storage writing module 220, the associated host 270, Figure 1 The controller of the server 150A-150N in Figure 1 The free state area can be opened (i.e., converted to an open state area) to ensure that each open data storage area is provided with a corresponding open log storage area. An area in a full state is completely written and cannot be written again. The log storage area can be reset and reopened as an open data storage area. For example, once the log storage area reaches a full state, resetting the log storage area can be considered. In an example embodiment, the controller of the storage space can be configured to reset the log storage area after all remaining parts contained in the log storage area have been written to the data storage area. For example, this allows all areas in the storage space to eventually become full areas.

[0059] Figure 3B is a schematic diagram of a first storage area Z1 and a second storage area Z2 in a block-level storage space 300 according to at least some embodiments described herein. Figure 3B The first storage area Z1 in corresponds to Figure 3A The first data area Z in D1 ,and Figure 3B The second storage area Z2 in corresponds to Figure 3A The first log data area D in J1 .

[0060] like Figure 3B As shown, the first storage area Z1 includes a plurality of logic blocks LB A1 -LB AN , and the second storage area Z2 includes a plurality of logic blocks LB A2 . Logical Block LB A1 -LB AN , LB B1 -LB BN With the logical block size set as described above. For example, the first storage area Z1 may be a data storage area, and the second storage area may be a log storage area for storing logs generated when writing to the first storage area Z1.

[0061] It should be understood that the numerical terms (e.g., "first," "second," "third," etc.) used herein regarding regions, logic blocks, writes, and data records should not be interpreted as limitations on specific locations or times, unless otherwise specified. For example, the numerical terms regarding regions and logic blocks should not be interpreted as limited to specific locations of regions in the storage space, or to the locations of logic blocks within regions. For example, the "first region" may not be the initial region in the storage space (e.g., it may be a region in the middle portion of the storage space). For example, multiple "first logic blocks" (or one "first logic block") in a certain region may not be multiple initial logic blocks (or one initial logic block) in the region (e.g., it may be a logic block set in the middle portion of the region). For example, the "first write" may not be the earliest write / initial write in the storage region. For example, the "first data record" may not be the earliest data record / initial data record stored in the storage region. According to some embodiments, the "first write" may occur earlier than the "second write" (before the "second write"); and the "second write" may occur earlier than the "third write" (before the "third write").

[0062] Figure 3C-Figure 3E An example embodiment for storing three data records in storage space 300 is shown. Figure 3C-Figure 3E In the example shown, the logical block size is set to 4K (for example, the logical block LB A1 -LB AN , LB B1 -LB BN Each of them has a size of 4K). In the illustrated embodiment, the first storage area Z1 is a data storage area in which data records are to be stored, and the second storage area Z2 is a log storage area for storing logs, as described below. For example, the log storage area is configured as an intermediate storage device for data as described below.

[0063] Figure 3CAn example of a storage space 300 after a (first) writing of a first data record is shown. Figure 3D An example of a storage space after performing a (second) write of a second data record (eg, after performing write of a first data record and a second data record) is shown. Figure 3E FIG. 4 shows an example of a storage space after performing a third write of a third data record (eg, after performing writes of a first data record, a second data record, and a third data record). Figure 3C-Figure 3E Different shading patterns are used in the representation. For example, a first type of shading pattern indicates data of a first data record stored, a second type of shading indicates data of a second data record stored, and so on.

[0064] exist Figure 3C-Figure 3E In the exemplary embodiment of FIG. 3 , the size of the first data record is 9K, the size of the second data record is 9K, and the size of the third data record is 9K. The size of the data record refers to the size of the data record stored in the storage space 300 .

[0065] In one embodiment, in a controller (e.g., Figure 2 A controller of a block level storage device 230A-230N in Figure 2 The associated storage write module 220, the controller of the associated host 270, Figure 1 The controller of the server 150A-150N in Figure 1 The first data record, the second data record, and the third data record may correspond to separate data write requests. In one example, the first data record corresponds to a first record IO received by the controller of the storage space 300, the second data record corresponds to a second record IO received by the controller of the storage space, and the third data record corresponds to a third record IO received by the controller of the storage space.

[0066] When writing in an append-only data storage area (e.g., data storage area Z1), data is written sequentially to fill one or more logical blocks. This results in (multiple) logical blocks being full (i.e., full of data without padding), which is referred to as aligned writing or logical block alignment. In the example shown, the size of the first data record (9KB) is larger than the logical block size (4K). The data of the first data record is written sequentially to completely fill sequential logical blocks (e.g., multiple logical blocks for aligned writing), i.e., two logical blocks LB. A1 , LB A2 In the embodiment shown, the logical blocks are two sequential logical blocks LB in the data storage area Z1. A1 , LBA2 In some embodiments, the data written to the logical block may include metadata. In one embodiment, the metadata may include an identifier corresponding to the original data record (e.g., each logical block LB A1 , LB A2 An identifier that identifies the data in the same data record as part of the same data record and / or as belonging together).

[0067] The data record may include a main portion and a remainder. The data / portion of the data record that is initially written to the data storage area may be referred to as the main portion, and the remainder is the portion of the data record that has not yet been written (e.g., data / portion that is not included in the main portion). In other examples, storage of the entire data record may result in a full logical block; such that the data record has no remainder. In other examples, storage of the data record may not result in a full block; such that the entire data record is the remainder.

[0068] For example, the first data record is written into the logical block LB A1 , LB A2 The data / portion of the first data record is the main portion 302A of the first data record, and the other data / portion of the first data record that is not written to the data storage area Z1 is the remaining portion of the first data record (e.g., the remaining portion 302B described below). In the example shown, the main portion 302A is 8KB (i.e., 2×4KB logical blocks), and the remaining portion 302B is 1KB (i.e., 9KB of the first data record-8KB of the main portion 302A). The logical block LB filled with the main portion 302A of the first record A1 , LB A2 It may also be referred to as a first logical block. The remainder 302B of the first data record may also be referred to as a remainder (eg, a remainder of the first data record), a first remainder, or a first remainder.

[0069] It should be understood that the term "main portion" as used herein refers to the portion of the data record that is stored first in the data storage area, rather than the size, importance, etc. of the portion. For example, the main portion 302A is stored in the data storage area Z1 before the remaining portion 302A. In some examples, the size of the main portion of the data record can be smaller than the remaining portion.

[0070] A log is generated for each data record remainder that occurs (e.g., when a portion of data is not written into (multiple) logical blocks to prevent misalignment, when a portion of data is not written into the first data area Z1 to prevent having an underfilled logical block, when a remainder 310B occurs). The log may include the remainder of the data record and the log entry. In the example shown, a first log 310 is generated for the first data record, and the first log 310 includes the remainder 302B of the first data record and the first log entry 312. In some embodiments, the components of the log may be written to the same logical block (e.g., the remainder 302B, the first log entry 312, and the fill 314 are written to the logical block LB). B1 to generate logs.

[0071] The remaining portion that has not yet been written to the data storage area (eg, written to the log storage area but not yet copied / written to the data storage area) may be referred to as an outstanding remainder. Figure 3C , the first remaining part 302B is an unfinished remaining part because the data of the first remaining part 302B has not yet been written into the data storage area Z1.

[0072] The log entry in the log may identify the remainder. For example, the log entry may be or include metadata of the remainder. In some embodiments, the log entry may identify the location of the corresponding main part, the corresponding data record, the logical block following its corresponding main part (or the logical block into which the remainder is to be written), a cyclic redundancy code (CRC), etc. For example, the first log entry 312 may include the location of the main part 302A (e.g., the location of the first logical block 302A in the storage space 300), an identifier of the first data record, and the logical block LB that is the last logical block to be filled. A2 Identifiers, etc.

[0073] like Figure 3C As shown, the first log 310 is stored in the log storage area Z2 of the storage space 300. In particular, the first log is written into the logical block LB in the log storage area Z2. B1 The first log 310 may include padding 314 such that the first log 310 is logical block aligned (e.g., padding 314 is added such that the size of the first log 310 is the same as the logical block size). In some examples, the log may not include padding when the log is already at the logical block size (e.g., the combined size of the remainder 302B and the log entry 312 is equal to the logical block size).

[0074] When preparing to store another data record in the storage area, the log storage area is scanned / checked to determine whether there is an uncompleted remainder. For example, when preparing to store the second data record in the storage area 300, the first log 310 in the log storage area Z2 can be read to determine that the remainder 302B is an uncompleted remainder. In some embodiments, the log entry 312 of the log 310 is used to determine that the first remainder 302B corresponds to the data in the last full logical block in the data storage area Z1 (for example, the log entry 312 indicates that the remainder 302B and the last full logical block LB A2 Corresponding to the same data record, log entry 312 sets the logical block LB A3 Indicates the target logical block to act on for the remainder of the storage, etc.).

[0075] The data of the unfinished remainder (e.g., remainder 302B) and the second data record are sequentially written to the data storage space to completely fill sequential logical blocks (e.g., multiple logical blocks for aligned writing). In an example embodiment, the data of the unfinished (first) remainder 302B and the second data record may be aggregated, and the aggregated data may be written to the data storage space.

[0076] Figure 3D An example of the storage space 300 is shown after the second data record has been written into the storage space 300. In the example shown, the unfinished remainder 302B and the second data record fill two logical blocks LB in the data storage area Z1. A3 , LB A4 In the embodiment shown, the filled logical blocks are two sequential logical blocks LB in the data storage area Z1. A3 , LB A4 . Two logical blocks LB A3 , LB A4 is the first / previously written logical block LB in the data storage area Z1 A1 , LB A2 (eg, the logical block containing the main portion 302A of the first data record). Figure 3D The "302" in the table indicates the first data record stored in the data storage area Z1. For example, the remaining part 302B and the main part 302A of the first data record are written / stored in the sequential logical blocks LB. A1 , LB A2 , LB A3 The first data record 302 may be stored continuously in sequential logical blocks LB. A1 , LB A2 , LB A3 middle.

[0077] The main part 304A is the second data record stored / written to the logical block LB A3 , LB A4 The remainder 304B of the second data record is the other data / portion of the second data record that is not written to the data storage area Z1. In the example shown, the main portion 304A of the second data record is 7KB (i.e., 2×4KB logical blocks - 1KB of the remainder 302B of the first data record 302), and the remainder 304B of the second data record is 2KB (i.e., 9KB of the second data record - 7KB of the main portion 304A). The logical block LB filled with the main portion 304A of the second record A3 , LB A4 It may be referred to as a second logical block. The remainder 304B of the second data record may also be referred to as a remainder (eg, a remainder of the second data record), a second remainder, or a second remainder.

[0078] A log is generated for the remaining portion of the second data record. In the example shown, a second log 320 is generated for the second remaining portion 304B. The second log 320 includes the remaining portion 304B of the second data record and a (second) log entry 322. For example, in Figure 3D In , the second remaining part 304B is an unfinished remaining part because the data of the second remaining part 304B has not yet been written into the data storage area Z1. Figure 3D , the first remaining part 302B is no longer an unfinished remaining part because the data of the first remaining part 302B is stored / written in the data storage area Z1.

[0079] The second log entry may identify the second remainder. In an example embodiment, the second log entry 322 may include the location of the main portion 304A of the second data record (eg, the second logical block LB A3 , LB A4 (a plurality of) locations in the storage space 300), an identifier of a second data record, a logical block LB which is the last logical block to be filled A2 One or more of the identifiers, etc.

[0080] like Figure 3D As shown, the second log 320 is stored in the log storage area Z2 of the storage space 300. In particular, the second log is written into the logical block LB in the log storage area Z2. B2The second log 320 may include padding 324 such that the second log 320 is logical block aligned (eg, the padding 324 is added such that the size of the second log 320 matches the logical block size), as similarly discussed above with respect to the first log 310 .

[0081] When preparing to store the third data record in the storage space 300, the log storage area Z2 may be scanned / checked to determine whether there is an uncompleted remainder. For example, the second log 320 in the log storage area Z2 may be read to determine that the second remainder 304B is an uncompleted remainder. In some embodiments, the log entry 322 may be used to determine that the remainder 304B corresponds to data in the last full logical block in the data storage area Z1 (e.g., the log entry 322 indicates that the second remainder 304B and the last full logical block LB A4 Corresponding to the same data record, log entry 322 sets the logical block LB A5 indicated as a target logical block for storing the second remainder 304B, and so on).

[0082] The data of the unfinished remainder (e.g., the second remainder 304B) and the third data record are sequentially written to the data storage space to completely fill sequential logical blocks (e.g., multiple logical blocks for aligned writing). In an example embodiment, the data of the unfinished (second) remainder 304B and the third data record may be aggregated, and the aggregated data may be written to the data storage space.

[0083] Figure 3E An example of the storage space 300 is shown after the third data record has been written into the storage space 300. In the example shown, the unfinished (second) remainder 304B and the third data record fill two logical blocks LB in the data storage area Z1. A5 , LB A6 In the embodiment shown, the filled logical blocks are two sequential logical blocks LB in the data storage area Z1. A5 , LB A6 . Two logical blocks LB A5 , LB A6 is the second / previously written logical block LB in the data storage area Z1 A3 , LB A4 (eg, a logical block containing the main portion 304A of the second data record). Figure 3E The "304" in the figure indicates the second data record stored in the data storage area Z1. For example, the remaining part 304B and the main part 304A of the second data record are written / stored in the sequential logical blocks LB. A3 , LB A4 , LBA5 The second data record 304 may be stored consecutively in sequential logical blocks LB. A3 , LB A4 , LB A5 middle.

[0084] The main part 306A is the third data record stored / written to the logical block LB A5 , LB A6 (e.g., it has a portion of the (second) remainder 304B of the second record). The (third) remainder 304B of the second data record is the other data / portion of the third data record that is not written to the data storage area Z1. In the example shown, the main portion 306A of the third data record is 6KB (i.e., 2×4KB logical blocks - 2KB of the second remainder 306B), and the remainder 306B of the third data record is 2KB (i.e., 9KB of the third data record - 6KB of the main portion 306A). The logical block LB filled with the main portion 306A of the third data record A5 , LB A6 It may also be referred to as a third logical block. The remainder 306B of the third data record may also be referred to as a remainder (eg, a remainder of the third data record), a third remainder, or a third remainder.

[0085] A log is generated for the remaining portion of the third data record. In the example shown, a (third) log 330 is generated for the third remaining portion 306B. The third log 330 includes the third remaining portion 306B and a (third) log entry 332. For example, in Figure 3E In , the third remaining part 306B is an unfinished remaining part because the data of the third remaining part 306B has not yet been written into the data storage area Z1. Figure 3E , the first remaining part 302B and the second remaining part 304B are no longer unfinished remaining parts because the data of the first remaining part 302B and the second remaining part 304B are stored / written in the data storage area Z1.

[0086] The third log entry may identify the third remainder. In an example embodiment, the third log entry 332 may include the location of the main portion 306A of the third data record (eg, the third logical block LB A5 , LB A6 (a plurality of) locations in the storage space 300), an identifier of a third data record, a logical block LB which is the last logical block to be filled A6 One or more of the identifiers, etc.

[0087] like Figure 3EAs shown, the third log 330 is stored in the log storage area Z2 of the storage space 300. In particular, the third log is written into the logical block LB in the log storage area Z2. B3 The third log 330 may include padding 334 such that the third log 330 is logical block aligned (eg, padding 334 is added such that the size of the third log 330 matches the logical block size), as similarly discussed above with respect to the first log 310 .

[0088] In some example embodiments, the logs for the remaining portions may be additionally or alternatively stored in a memory cache. For example, the log(s) may be stored in a memory cache of a block storage device (e.g., Figure 2 The most recent log in the memory cache can be used to reduce the read of the storage space, which can reduce the read / write time of the storage space. The logs stored in the storage space can be used for fault recovery. For example, the log entries in the log storage area can be used to patch the corresponding data storage area. When a crash occurs, the log entries stored in the log storage area can be used to patch the corresponding data storage area (for example, the log entry 312 in the log storage area Z2 is used to patch the data storage area Z1). In one embodiment, the log entries stored in the data storage area may include sequential numbers to prevent confusion when the log area contains logs used in different versions of data stored in the data storage area (for example, logs for a data storage area that has been reset and written again).

[0089] Figure 4A-4C Another example embodiment of storing three data records in the storage space 300' is shown. The storage space 300' may have the same Figure 3A-3E For example, the storage space 300' includes a first storage area Z1' and a second storage area Z2', the first storage area Z1' is a data storage area, and the second storage area Z2' is a log storage area, which is similar to the storage area 300 discussed in the embodiment of the present invention. Figure 3A-3E The storage space 300 in FIG. 3 is similar to that discussed above. Different types of data are stored in Figure 4A-4C Different shading patterns are used to indicate Figure 3C-Figure 3E .

[0090] Figure 4A An example of a storage space 300 ′ is shown after a (first) writing of a first data record has been performed. Figure 4BAn example of a storage space 300 ′ is shown after a (second) writing of a second data record has been performed (eg after the writing of a first data record and a second data record). Figure 4C An example of a storage space 300' is shown after performing a (third) writing of a third data record (eg, after writing of the first data record, the second data record, and the third data record). Figure 4A-4C In the exemplary embodiment of , the size of the first data record is 3KB, the size of the second data record is 5KB, and the size of the third data record is 14KB. The size of the logical block in the storage space 300 ′ is 4KB, similar to the storage space 300 .

[0091] When preparing to store the first data record in the storage space 300', the log storage area Z2' may be scanned / checked to determine whether there is an unfinished remainder. In this example, before writing of the first data record, there is no unfinished remainder in the data storage area Z1'.

[0092] Data is written sequentially into the data storage space 300' to completely fill sequential logical blocks (e.g., multiple logical blocks for aligned writes). In this example, the size of the first data record is 3K, which is not enough to fill a single logical block (4KB); and the entire first data record is the (first) remainder 302B'. The first write in this embodiment is not written in the data storage area. The remainder 302B' of the first data record may also be referred to as the remainder (e.g., the remainder of the first data record), the first remainder, or the first remainder.

[0093] A log is generated for the remaining portion of the first data record. In the example shown, a first log 310' is generated for the remaining portion 302B' (ie, the entire first data record). The (first) log 310' includes the first remaining portion 302B' and the (first) log entry 312'. For example, in Figure 4A , the first remaining part 302B′ is an unfinished remaining part because the data of the first remaining part 302B′ has not yet been written into the data storage area Z1′.

[0094] The log entry 312' may identify the first remaining portion 302B'. In an example embodiment, the log entry 312' may include an identifier of the first data record, a LB' that is a target storage logical block for the remaining portion 302B', and a A1 Identifiers, etc.

[0095] like Figure 4A As shown, the log 310' is stored in the log storage area Z2' of the storage space 300. In particular, the second log is stored / written to the logical block LB of the log storage area Z2'. B2The first log 310' may include padding 314' such that the first log 310' is logical block aligned (eg, the padding 314' is added such that the size of the first log 310' matches the logical block size).

[0096] When preparing to store the second data record in the storage area 300', the log storage area 300' can be scanned / checked to determine whether there is an unfinished remainder. For example, when preparing to store the second data record in the storage area 300', the first log 310' in the log storage area Z2' can be read to determine that the first remainder 302B' is an unfinished remainder. In some embodiments, the log entry 312' of the log 310' is used to determine that the first remainder 302B' does not correspond to data in the last full logical block in the data storage area Z1' (for example, the log entry 312' indicates that the remainder 302B' and the last full logical block (not shown) correspond to different data records, the log entry 312' indicates that the remainder 302B' is the entire data record, etc.).

[0097] The data of the unfinished remainder (e.g., the first remainder 302B') and the second data record are sequentially written to the data storage space to completely fill sequential logical blocks (e.g., multiple logical blocks for aligned writing). In an example embodiment, the data of the unfinished (first) remainder 302B' and the second data record may be aggregated, and the aggregated data may be written to the data storage space.

[0098] Figure 4B An example of the storage space 300' is shown after the second data record has been written into the storage space 300'. In the example shown, the unfinished (first) remainder 302B' and the second data record fill two logical blocks LB' in the data storage area Z1'. A1 LB' A2 In the embodiment shown, the filled logical blocks are two sequential logical blocks LB′ in the data storage area Z1′. A1 LB' A2 .

[0099] The main part of the second data record is stored / written to the logical block LB' A1 LB' A2 (e.g., the remaining portion 302B' of the first record). The storage of the entire first data record and the entire second data record results in two full logical blocks (i.e., 2 x 4KB logical blocks = 3KB of the first data record + 5KB of the second data record). In this example, the entire second data record is stored in the filled logical block LB' A1 LB' A2, so that there is no remaining part of the second data record; and the main part of the (second) data record in this example is the entire second data record. Figure 4B and Figure 4C "302"' in FIG. 1 indicates a first data record stored in the data storage area Z1'. Figure 4B and Figure 4C The "304" in the table indicates a second data record stored in the data storage area Z1'. For example, the first data record 302' is written / stored in a single logical block LB' A1 For example, the second data record is written to / stored in the sequential logical block LB' A2 LB' A2 The second data record 304' may be stored consecutively in sequential logical blocks LB' A1 LB' A2 middle.

[0100] In this example, the second data record has no remainder. Because there is no remainder, no log is generated for the second data record. Figure 4B , the first remaining part 302B′ is no longer an unfinished remaining part because the data of the first remaining part 302B′ is stored / written in the data storage area Z1.

[0101] When preparing to store the third data record in the storage space 300', the log storage area Z2' can be scanned / checked to determine whether there is an unfinished remainder. For example, the first log 310 in the log storage area Z2' can be read to determine that there is no unfinished remainder. In some embodiments, the log entry 312' of the first log 310' can be used to determine that the last remainder 304B' does not correspond to the latest data record (e.g., the second data record) stored in the last full logical block of the data storage area Z1'.

[0102] Since there is no unfinished remainder, only the third data record is sequentially written to the data storage space 300 ′ to completely fill sequential logical blocks (eg, multiple logical blocks for aligned writing).

[0103] Figure 4C An example of the storage space 300' is shown after the third data record has been written into the storage space 300'. In the example shown, the third data record fills three logical blocks LB' in the data storage area Z1'. A3 LB' A4 LB' A5 In the embodiment shown, the filled logical blocks are three sequential logical blocks LB' in the data storage area Z1'. A3 LB'A4 LB' A5 . Three logical blocks LB' A3 LB' A4 LB' A5 is the second / previously written logical block LB' in the data storage area Z1' A1 LB' A2 (eg, a logical block containing the main portion 304A of the second data record).

[0104] The main part 306A' is the third data record stored / written to the logical block LB' A3 LB' A4 LB' A5 The remainder 306B' of the third data record is other data / portion of the third data record that is not written to the data storage area Z1'. In the example shown, the main portion 306A' of the third data record is 12KB (i.e., 3×4KB logical blocks), and the remainder 306B' of the third data record is 2KB (i.e., 14KB of the third data record - 12KB of the main portion 306A'). The logical block LB' filled with the main portion 306A of the third data record A3 LB' A4 LB' A5 It may also be referred to as a third logical block. The remainder 306B' of the third data record may also be referred to as a remainder (eg, remainder of the third data record), a second remainder (eg, second because there is no remainder of the second data record), or a second remainder.

[0105] A log is generated for the remaining portion of the third data record. In the example shown, a (third) log 330' is generated for the third remaining portion 306B'. The third log 330' includes the third remaining portion 306B' and a (third) log entry 332'. For example, in Figure 4C In , the second remaining part 306B' is an unfinished remaining part because the data of the third remaining part 306B' has not yet been written into the data storage area Z1'. Figure 4C , the first remaining part 302B′ is no longer an unfinished remaining part because the data of the first remaining part 302B′ is stored / written in the data storage area Z1′.

[0106] The third log entry may identify the third remainder. In an example embodiment, the third log entry 332′ may include the location of the main portion 306A′ of the third data record (eg, the third logical block LB′). A3 LB' A4 LB' A5location in the storage space 300'), an identifier of the third data record, a logical block LB' which is the last logical block to be filled A5 One or more of the identifiers, etc.

[0107] like Figure 4C As shown, the third log 330' is stored in the log storage area Z2' of the storage space 300'. In particular, the third log 330' is written into the logical block LB' in the log storage area Z2'. B3 The third log 330' may include padding 334' such that the third log 330' is logical block aligned, similar to that discussed above with respect to the first log 310'.

[0108] Figure 5 is a flow diagram illustrating an example write processing flow 1000 for aligned block storage writes using logging, in accordance with at least some embodiments described herein.

[0109] It should be understood that the process flow 1000 disclosed herein may be executed by one or more processors (e.g., Figure 1 a processor of one or more of the terminal devices 110, 120, 130 and 140, Figure 1 The server has 150 processors, Figure 7 CPU unit 2005, Figure 2 The block device write module 220 processor, and / or any other suitable processor) is used to execute unless otherwise stated.

[0110] It should also be understood that the processing flow 1000 may include one or more operations, actions, or functions as shown in one or more of blocks 1010, 1020, 1030, 1040, 1050, 1060, 1070, and 1080. These various operations, functions, or actions may correspond, for example, to software, program code, or program instructions that can be executed by a processor that causes the functions to be performed. Although shown as separate blocks, obvious modifications may be made, for example, two or more blocks may be reordered; more blocks may be added; and various blocks may be divided into additional blocks, combined into fewer blocks, or eliminated, depending on the desired implementation. It should be understood that prior to the processing flow 1000, operations including initialization and the like may be performed. For example, system parameters and / or application parameters may be initialized, one or more storage areas may be reset, storage areas may be opened, open storage areas may be designated as open data storage areas or open log storage areas, and so on. The processing flow 1000 may begin at block 1010. It should also be understood that the processing flow 1000 may be initiated from a host (e.g., Figure 1 The terminal devices 110, 120, 130 and 140, Figure 1 Server 150, Figure 2The processing flow 1000 may be transparent to the host and / or the application running on the host (the application requesting the write process).

[0111] At block 1010 (Receive Data Record Write Request), the processor may receive a data write request. For example, the processor receives a request to store data in one or more storage devices (e.g., Figure 1 In one example, the data write request may be an internal request of the host (e.g., a request of an application of the host). In another example, the data write request may be an external request (e.g., a request from one of the terminal devices 110, 120, 130, and 140, Figure 1 150 in the host, a request from a different server, etc.) to store the data in one or more storage devices associated with the host (e.g., Figure 2 The data write request may include the data to be stored.

[0112] At block 1020 (Detect Incomplete Remaining Portions), the processor may detect incomplete remaining portions. The incomplete remaining portions are remaining portions of the data storage area that have not yet been stored / written to the storage device(s) (e.g., Figure 3C The remaining part 302B, Figure 3D The remaining part 304B, Figure 3E The remaining part 306B, Figure 4A The remaining part 302A', Figure 4C For example, a log entry (e.g., Figure 4A-4C Log entries 312, 322, 332 in Figure 4A-4C The log entries 312', 332' in the can be used (e.g., scanned, read, etc.) to determine whether there is a remaining portion of the storage that is unfinished. When no unfinished remaining portion is detected, the process flow 1000 can proceed to 1040. When an unfinished remaining portion is detected, the process flow 1000 can proceed to block 1030.

[0113] At block 1030 (Aggregate Data Records with Incomplete Remaining Portions), the processor may aggregate the data records and the incomplete remaining portions. This aggregation may be referred to as "aggregating the data records." For example, aggregating the data records with the incomplete remaining portions may include determining the combined size of the data records and the incomplete remaining portions when stored in a storage area (e.g., in the format of a data storage device, in a compressed state stored in a data storage device, etc.). In some embodiments, the aggregation of data records with incomplete remaining portions may include, for example, but not limited to, storing the data records and the incomplete remaining portions in the same memory cache, combining data of the data records with data of the incomplete remaining portions, and the like. Process 1000 may then proceed to block 1040.

[0114] At block 1040 (Determine Data Record Alignment), the processor may determine whether the aggregated data record is logical block aligned as stored in the data storage device. As described above, the block storage device may have a set logical block size. When the stored data will fill an exact number of logical blocks (e.g., the size of the storage is a multiple of the logical block size), the data is aligned in the block storage device. For example, when the aggregated data record will fill all of the one or more logical blocks with padding in the one or more logical blocks or will produce a remainder (e.g., the size of the aggregated record is not a multiple of the logical block size), the aggregated data record is not aligned. When the aggregated data record is logical block aligned, the processing flow 1000 may proceed to 1070. When the aggregated data record is not logical block aligned, the processing flow 1000 may proceed to block 1050.

[0115] At 1050 (UPDATE DATA AREA REMAINDER CONTEXT), the processor may update the context of the remainder of the aggregate data record. Updating the context of the remainder may include determining data of the aggregate data record to be stored in the data storage area (e.g., determining a major portion of the aggregate data record, Figure 3C The main part 302A, Figure 3D The main part of 304A, Figure 3E 306A or Figure 4C The main part 306A).

[0116] At block 1060 (Generate Log), the process may generate logs for the remaining portions (e.g., Figure 3C-Figure 3E Log 310, Figure 4A-4C310', 330' in the log. The log may include a log entry and a remainder. In some embodiments, the remainder may include, but is not limited to, the size of the remainder, the location in the data storage area where the remainder will be stored, the location in the data storage area where the non-remaining portion (e.g., the main portion) of the aggregate data record will be stored, the context / information of the previous remainder (e.g., the cyclic redundancy check (CNC) of the previous remainder, the location of the previous remainder, etc.), etc. In an example embodiment, the generation of the log may include storing the log in (e.g., writing to) a non-volatile memory associated with a storage device. In some embodiments, the log may be stored in a log storage area in the same non-volatile memory as the aggregate data record (e.g., Figure 3B-Figure 3E Log storage area Z2' in Figure 4A-4C For example, the logs may be stored in a non-volatile memory different from the aggregate data records, such as a host associated with a storage device (e.g., Figure 1 Host 170, Figure 2 210 in the host), an associated storage write module (eg, Figure 2 222 in the storage device), a different non-volatile memory of the storage device, etc. In some embodiments, the log may be additionally or alternatively stored in a memory cache associated with the storage device (e.g., a memory cache of the memory 232A-232N of the storage device 230A-232N, a memory cache of the memory 222 of the storage write module 220, a memory cache 210 of the associated host 210, etc.). Process flow 1000 may proceed to block 1070.

[0117] At 1070 (Write Aligned Data Records to Data Area), the processor may write the aligned data records of the aggregated data record to a data storage area (e.g., Figure 3B-Figure 3E The data storage area Z1 in Figure 4A-4C For example, the aligned portion of the aggregated data record may include a portion of the data record and an unfinished remaining portion (e.g., Figure 3D The main part 304A and the remaining part 304B, Figure 3E The main part 306A and the remaining part 304B, Figure 4B The main part 304A' and the remaining part 302B', Figure 4CThe data in the aligned portion is logically block aligned (e.g., its size when written to the data storage area is equal to a multiple of the logical block size, and its size does not result in a non-full block without fill). Process flow 1000 can proceed to block 1080.

[0118] At block 1080 (Confirm Write Complete), the process may provide confirmation of completion of the data write request. The confirmation may be a completion response to the data write request received at block 1080. In one example, the data write request may be an internal request of the host (e.g., a confirmation to an application of the host that sent the request). In another example, the data write request may be an external confirmation (e.g., a confirmation to an application of the host that sent the request). Figure 1 The confirmation of one of the terminal devices 110, 120, 130 and 140 in Figure 1 , a request from a different server, etc.) to store the data in one or more storage devices associated with the host (e.g., Figure 2 In the storage devices 230A-230N).

[0119] Figure 6 1 is a flow chart illustrating another example write process flow 1200 for storing data in a non-volatile memory according to at least some embodiments described herein. When employed, the process flow 1100 can reduce or eliminate the use of padding when storing data in (multiple) non-append data storage areas of the non-volatile memory. In one example, the process flow 1200 can be used in shingled magnetic recording (SMR) to write / store data on an SMR storage device (e.g., HDD) with reduced / removed padding, so that data storage efficiency on the HDD is improved relative to traditional SMR recording.

[0120] It should be understood that the process flow 1200 disclosed herein may be executed by one or more processors (e.g., Figure 1 a processor of one or more of the terminal devices 110, 120, 130 and 140, Figure 1 The server has 150 processors, Figure 2 The processor 212 of the host 201, Figure 7 CPU unit 2005 processor, Figure 2 The block device write module 220 processor, and / or any other suitable processor) is used to execute unless otherwise stated.

[0121] It should be understood that process flow 1200 may be performed to store one or more data records in a non-volatile memory. In one embodiment, the non-volatile memory may be Figure 2In one embodiment, the non-volatile memory may be one or more storage devices 230A-230N. Figure 1 The non-volatile memory of one or more servers 150A-150N or one of the terminal devices.

[0122] It should also be understood that the processing flow 1200 may include one or more operations, actions, or functions as shown in one or more of blocks 1210, 1220, 1230, 1240, 1250, and 1260. These various operations, functions, or actions may correspond, for example, to software, program code, or program instructions that can be executed by a processor that causes the functions to be performed. Although shown as separate blocks, obvious modifications may be made, for example, two or more blocks may be reordered; more blocks may be added; and various blocks may be divided into additional blocks, combined into fewer blocks, or eliminated, depending on the desired implementation. It should be understood that prior to the processing flow 1200, operations including initialization may be performed, similar to those for Figure 5 The process flow 1200 may begin at block 1210. It should also be understood that the process flow 1200 may begin at block 1210. Figure 1 The terminal devices 110, 120, 130 and 140, Figure 1 Server 150, Figure 2 The processing flow 400 may be transparent to the host and / or an application running on the host (the application requesting the write process).

[0123] At block 1210 (Store Main Portion of First Data Record), the processor may store the main portion of the first data record in one or more first logical blocks. For example, storing the main portion of the first data record may include sequentially writing at least the main portion to an append-only storage area (e.g., Figure 3B In the storage area Z1 in Figure 3A Data storage area Z in D1 -Z DN The main portion of the first data record may be written sequentially to one or more first logical blocks of the append-only storage area. In some embodiments, there may be an unfinished remainder (e.g., in a corresponding log for the storage area). In such an embodiment, both the main portion and the unfinished remainder of the first data record may be written sequentially to the storage area. One or more first logical blocks are filled. For example, the main portion (or the main portion and the unfinished remainder, if any) are logically block aligned so that the write fills one or more first logical blocks. In one example, the main portion may be at least twice the logical block size of the storage area, and the main portion is written to multiple first logical blocks (e.g., Figure 4C The main part 306' is stored in the logical block Z A3 , Z A3 , Z A4 Process 1200 may proceed to block 1220.

[0124] At block 1220 (Generate First Log), the processor may generate a (first) log including the remainder of the first data record and a log entry. The log entry corresponds to the remainder of the first data record. For example, the log entry may include information about the remainder, as discussed herein. In one example, the log entry may include a storage location of the corresponding main portion in a data storage area (e.g., an identifier of (multiple) first logical blocks in the storage area), an identifier of the first data record, and the like. In an example embodiment, the generation of the log entry may include writing a log in a log storage area.

[0125] In some embodiments, writing of the entire first data record may result in (multiple) full logical blocks (eg, the entire first data record is written into the logical block and logical block aligned). When this occurs, there is no remainder and block 1220 may be omitted.

[0126] In one example, the log is written to a second append-only storage area of ​​the non-volatile storage device and / or a memory cache associated with the block level storage device. For example, the log may be written to a second append-only storage area of ​​the non-volatile storage device and a memory cache. The log stored in the second append-only storage area may be used in response to a failure / crash of the memory cache, while the log stored in the memory cache may be relied upon to allow the remainder to be written to the log without reading from the non-volatile memory (e.g., allowing reduced reading when the non-volatile memory is an HDD). Process flow 1200 may then proceed to block 1230.

[0127] At block 1230 (Storing Remaining Portion of First Data Record and Main Portion of Second Data Record), the processor may store the remaining portion of the first data record and the main portion of the second record in one or more first logical blocks. For example, storing the main portion of the first data record and the remaining portion of the first data record may include sequentially writing the main portion and the remaining portion to one or more logical blocks of the append-only storage area (e.g., to one or more second logical blocks). The one or more second logical blocks are filled. For example, the combination of the main portion and the remaining portion is logical block aligned such that the write fills the second logical block(s). Flow 1200 may proceed to block 1240.

[0128] In one embodiment, after the remainder is stored in the first storage area, the second storage area can be reset. For example, in such an embodiment, the reset can occur in response to the second storage area being full or nearly full. Once the second storage area is opened, this can allow the second storage area to be reused (e.g., written to). Process 1200 can proceed to block 1240.

[0129] At block 1240 (generate second log), the processor may generate a (second) log including the remainder of the second data record and a log entry. The log entry corresponds to the remainder of the second data record. For example, the log entry may include information about the remainder, as discussed herein. In one example, the log entry may include a storage location of the corresponding main portion in the data storage area (e.g., an identifier of (multiple) second logical blocks in the storage area), an identifier of the second data record, and the like. In an example embodiment, the generation of the log entry may include writing a log in the log storage area.

[0130] In some embodiments, the writing of the entire second data record (by itself or in combination with the remainder of the first record (when present)) may result in (multiple) full logical blocks (e.g., the entire second data record is written into (multiple) second logical blocks and is logically block aligned, or the entire second data record and the remainder of the first data record are written into the second logical block and is logically block aligned). When this occurs, there is no remainder, and block 1240 may be omitted.

[0131] In one example, the (second) log may be written to a second append-only storage area of ​​the non-volatile storage device and / or a memory cache associated with a block-level storage device, similar to that discussed above with respect to the first log. In some exemplary embodiments described herein, the first log may be written to a first logical block, and the second log may be written to a second logical block of the same storage area (e.g., both logs are stored in a second append-only storage area of ​​the non-volatile storage device, both logs are stored in the same append-only log storage area). Process flow 1200 may then proceed to block 1250.

[0132] At block 1250 (Store Remaining Portion of Second Data Record and Main Portion of Third Data Record), the processor may store the remaining portion of the second data record and the main portion of the third record in one or more first logical blocks. For example, storing the main portion of the third data record and the remaining portion of the second data record may include sequentially writing the main portion and the remaining portion to one or more logical blocks of the append-only storage area (e.g., to one or more third logical blocks). The one or more third logical blocks are filled. For example, the combined main portion and the remaining portion are logically block aligned so that the write fills the third logical block(s). Flow 1200 may proceed to block 1260.

[0133] At block 1260 (Generate Third Log), the processor may generate a (third) log including the remainder of the third data record and a log entry. The log entry corresponds to the remainder of the third data record. For example, the log entry may include information about the remainder, as discussed herein. In one example, the log entry may include a storage location of the corresponding main portion in the data storage area (e.g., an identifier of (multiple) third logical blocks in the storage area), an identifier of the second data record, and the like. In an example embodiment, the generation of the log entry may include writing a log in the log storage area.

[0134] In some embodiments, the writing of the entire third data record (by itself or in combination with the remainder of the second record (when present)) may result in (multiple) full logical blocks (e.g., the entire third data record is written into (multiple) third logical blocks and is logically block aligned, or the entire third data record and the remainder of the second data record are written into (multiple) second logical blocks and is logically block aligned). When this occurs, there is no remainder, and block 1260 may be omitted.

[0135] In one example, the (second) log may be written to a second append-only storage area of ​​the non-volatile storage device and / or a memory cache associated with a block-level storage device, similar to that discussed above with respect to the first log. In some exemplary embodiments described herein, the first log may be written to a first logical block, the second log may be written to a second logical block, and the third log may be written to a third logical block of the same storage area (e.g., both logs are stored in a second append-only storage area of ​​the non-volatile storage device, and both logs are stored in the same append-only log storage area). For example, the first logical block, the second logical block, and the third logical block may be contiguous logical blocks in the same storage area.

[0136] It should be understood that Figure 6The process 1200 in the embodiment of the present invention can be modified to utilize the features discussed herein. For example, the process 1200 can be modified to include Figure 3A-Figure 4C For example, process 1200 may be modified to include the following: Figure 5 Features described in process 1000.

[0137] Figure 7 is an electronic device (e.g., Figure 1 150A-150N or one of the terminal devices 110, 120, 130, 140). It should be understood that Figure 7 The computer system shown is for illustration only and is not intended to limit the functionality and applicability of the embodiments described herein.

[0138] As shown, the computer system 2000 may include a central processing unit (CPU) 2005. The CPU 2005 may perform various operations and processes based on a program stored in a read-only memory (ROM) 2010 or a program loaded from a storage device 2040 to a random access memory (RAM) 2015. The RAM 2015 may also store various data and programs required for the operation of the system 2000. The CPU 2005, the ROM 2010, and the RAM 2015 may be connected to each other via a bus 2220. An input / output (I / O) interface 2025 may also be connected to the bus 2220.

[0139] like Figure 7As shown, the components connected to the I / O interface 2025 may also include an input device 2030, an output device 2035, an output device 2035, a storage device 2040 and / or a communication device 2045. The input device 2030 may include a keyboard, a mouse, a digital pen, a drawing board, etc. The output device 2035 may include a display (e.g., a liquid crystal display (LCD), a light-emitting diode (LED) display, an organic LED display, etc.), a speaker, etc. The storage device 2040 may include a hard disk (e.g., HDD, SSD, etc.), etc. In one embodiment, a drive 2050 may also be connected to the I / O interface 2025. The communication device 2045 may include a network interface card (e.g., a LAN card), a modem, etc. The communication device 2045 may perform communication processing via a network such as the Internet, a WAN, a LAN, a LIN, a cloud, etc. A removable medium 2055 (eg, a magnetic disk, an optical disk, a magneto-optical disk, a semiconductor memory, etc.) may be mounted on the drive 2050 as needed, so that a computer program read from the removable medium 2055 may be installed in the storage device 2040 .

[0140] It should be understood that reference Figure 3C-Figure 3E Storage of data in the storage space in Figure 5 and Figure 6 The processes described in the flowcharts and other figures may be implemented as computer software programs or in hardware. A computer program product may include a computer program stored in a computer-readable non-volatile medium. The computer program includes program code for executing the methods shown in the flowcharts and / or GUIs. In this embodiment, the computer program may be downloaded and installed from a network via a communication device 2045, and / or may be installed from a removable medium 2055. The computer program, when executed by a central processing unit (CPU) 2005, may implement the above-mentioned functions specified in the methods in the embodiments disclosed herein.

[0141] It should be understood that the disclosed and other solutions, examples, embodiments, modules and functional operations described in this document can be implemented in digital electronic circuits, or in computer software, firmware or hardware (including the structures disclosed in this document and their structural equivalents), or in a combination of one or more of them. The disclosed and other embodiments can be implemented as one or more computer program products, that is, one or more modules of computer program instructions encoded on a computer-readable medium, for execution by a data processing device or controlling the operation of the data processing device. The computer-readable medium can be a machine-readable storage device, a machine-readable storage substrate, a memory device, a material combination that implements a machine-readable propagation signal, or a combination of one or more of them. The term "data processing device" covers all devices, equipment and machines for processing data, including, for example, a programmable processor, a computer or multiple processors or computers. In addition to hardware, the device may also include code that creates an execution environment for the computer program in question, for example, code that constitutes processor firmware, a protocol stack, a database management system, an operating system, or a combination of one or more of them.

[0142] A computer program (also referred to as a program, software, software application, script, or code) may be written in any form of programming language, including compiled or interpreted languages, and it may be deployed in any form, including as a stand-alone program, or as a module, component, subroutine, or other unit suitable for a computing environment. A computer program does not necessarily correspond to a file in a file system. A program may be stored as part of a file that holds other programs or data (e.g., one or more scripts stored in a markup language document), in a single file dedicated to the program in question, or in multiple coordinated files (e.g., files that store one or more modules, subroutines, or code portions). A computer program may be deployed to execute on one computer, or on multiple computers located at one location or distributed at multiple locations and interconnected by a communications network.

[0143] The processes and logic flows described in this document may be performed by one or more programmable processors executing one or more computer programs to perform functions by operating on input data and generating output. The processes and logic flows may also be performed by special purpose logic circuits, and the apparatus may also be implemented as special purpose logic circuits, such as field programmable gate arrays, application specific integrated circuits, etc.

[0144] For example, processors suitable for executing computer programs include general-purpose microprocessors and special-purpose microprocessors, and any one or more processors of any kind of digital computer. Typically, the processor will receive instructions and data from a read-only memory or a random access memory or both. The basic elements of a computer are a processor for executing instructions and one or more memory devices for storing instructions and data. Typically, the computer will also include or be operatively coupled to one or more large-capacity storage devices (e.g., magnetic disks, magneto-optical disks, or optical disks) for storing data to receive data from it, or to transfer data to it, or both. However, the computer is not required to have such a device. Computer-readable media suitable for storing computer program instructions and data include all forms of non-volatile memory, media, and memory devices, including, for example: semiconductor memory devices, such as erasable programmable read-only memory, electrically erasable programmable read-only memory, and flash memory devices; magnetic disks, such as internal hard disks or removable disks; magneto-optical disks; and compact disk read-only memory and digital video disk read-only memory disks. The processor and memory may be supplemented or incorporated by dedicated logic circuits.

[0145] It should be understood that various details have been used to illustrate and describe different features, variations, and multiple different embodiments. In this application, the content sometimes described according to specific embodiments is only for illustrative purposes, rather than for limiting or suggesting that the content envisioned is only a specific embodiment or multiple specific embodiments. It should be understood that the present disclosure is not limited to any single specific embodiment or the variants listed. Many modifications, variations, and other embodiments will occur to those skilled in the art, and these modifications, variations, and other embodiments are intended to represent the present disclosure and are actually covered by the present disclosure. In fact, the scope of the present disclosure should be determined by the appropriate legal interpretation and understanding (including equivalents) of the present disclosure, as understood by those skilled in the art by the complete disclosure presented at the time of submission.

[0146] aspect:

[0147] Any of aspects 1-12 may be combined with any of aspects 13-20, and any of aspects 14-19 may be combined with aspect 2.

[0148] Aspect 1: A method for storing data in a non-volatile storage device, comprising: sequentially writing at least a major portion of a first data record into one or more first logical blocks of a first append-only storage area of ​​the non-volatile storage device until the one or more first logical blocks are full; and generating a first log, the first log comprising a remaining portion of the first data record and a log entry for the remaining portion.

[0149] Aspect 2: The method according to aspect 1, wherein the log entry includes a location of the one or more first logical blocks in the non-volatile storage device.

[0150] Aspect 3: The method according to any one of aspects 1-2, wherein the first log is generated by writing the remaining portion of the first data record and the log entry to a logical block of a second append-only storage area of ​​the non-volatile storage device.

[0151] Aspect 4: A method according to Aspect 3, wherein the non-volatile storage device includes multiple adjacent append-only storage areas, the multiple adjacent append-only storage areas include a group of sequential append-only data storage areas and a group of sequential append-only log storage areas, the group of sequential append-only data storage areas includes a first append-only storage area, and the group of sequential append-only log storage areas includes a second append-only storage area.

[0152] Aspect 5: The method according to any one of aspects 1-4, wherein the first log is stored in a memory cache.

[0153] Aspect 6: The method according to any one of aspects 1-5, wherein the size of the first data record is larger than a logical block size of the non-volatile storage device, and the one or more first logical blocks are a plurality of sequential first logical blocks.

[0154] Aspect 7: The method according to any one of Aspects 1-6 further includes: sequentially writing the remaining portion of the first data record and the main portion of the second data record into one or more second logical blocks in the first append-only storage area until the one or more second logical blocks are full; and generating a second log, the second log including the remaining portion of the second data record and log entries for the remaining portion of the second data record.

[0155] Aspect 8: The method according to Aspect 7 further includes: writing the first log into a first logical block of a second append-only storage area of ​​the nonvolatile storage device; and writing the second log into a second logical block of a second append-only storage area of ​​the nonvolatile storage device.

[0156] Aspect 9: The method according to aspect 8, further comprising: resetting the second append-only storage area after the remaining portion of the first data record has been written to the first append-only storage area.

[0157] Aspect 10: The method according to aspect 9, further comprising: after resetting the second append-only storage area, opening the second append-only storage area, wherein the second append-only storage area is opened as a data storage area in the nonvolatile storage device.

[0158] Aspect 11: The method according to any one of Aspects 7-10 also includes: sequentially writing the remaining portion of the second data record and the main portion of the third data record into one or more third logical blocks in the first append-only storage area until the one or more third logical blocks are full; and generating a third log, the third log including the remaining portion of the third data record and log entries for the remaining portion of the second data record.

[0159] Aspect 12: The method according to Aspect 11 also includes: writing the first log to a first logical block of a second append-only storage area of ​​a non-volatile storage device; writing the second log to a second logical block of a second append-only storage area of ​​the non-volatile storage device; and writing the third log to a third logical block of the second append-only storage area of ​​the non-volatile storage device, wherein the log entries of the first log, the log entries of the second log, and the log entries of the third log include sequential numbers.

[0160] Aspect 13: A storage device control system comprising: a non-volatile storage device; and a controller configured to: sequentially write at least a major portion of a first data record into one or more sequential first logical blocks of a first append-only storage area of ​​the non-volatile storage device until the one or more sequential first logical blocks are full; and generate a first log, the first log comprising a remaining portion of the first data record and a log entry for the remaining portion.

[0161] Aspect 14: The storage device control system according to Aspect 13, wherein the non-volatile storage device is configured as a shingled magnetic recording block storage device.

[0162] Aspect 15: The storage device control system according to Aspect 14, wherein the controller is configured to: store the first log in a memory cache of the controller.

[0163] Aspect 16: The storage device control system according to any one of aspects 13 to 15, wherein the controller is configured to: store the first log in a second append-only storage area of ​​the non-volatile storage device.

[0164] Aspect 17: A storage device control system according to any one of Aspects 13-16, wherein the controller is configured to: sequentially write the remaining portion of the first data record and the main portion of the second data record into one or more second logical blocks in the first append-only storage area until the one or more second logical blocks are full; and generate a second log, the second log including the remaining portion of the second data record and log entries for the remaining portion of the second data record.

[0165] Aspect 18: A storage device control system according to Aspect 17, wherein the controller is configured to: write a first log to a first logical block of a second append-only storage area of ​​a non-volatile storage device; and write a second log to a second logical block of a second append-only storage area of ​​the non-volatile storage device, wherein the log entries of the first log and the log entries of the second log include sequential numbers.

[0166] Aspect 19: The storage device control system according to any one of aspects 17 and 18, wherein the first data record corresponds to a first record IO received by the controller, and the second data record corresponds to a second record IO received by the controller after the first record IO.

[0167] Aspect 20: A non-transitory computer-readable medium having computer-executable instructions stored thereon, which when executed cause one or more processors to perform operations, the operations comprising: sequentially writing at least a major portion of a first data record into one or more first logical blocks of a first append-only storage area of ​​a non-volatile storage device until the one or more first logical blocks are full; and generating a first log, the first log comprising a remaining portion of the first data record and a log entry for the remaining portion.

[0168] The terms used herein are intended to describe specific embodiments and are not intended to be limiting. The terms "a", "an" and "the" also include plural forms unless otherwise expressly indicated. When used in this specification, the terms "include" and / or "comprise" specify the presence of the features, wholes, steps, operations, elements and / or components, but do not exclude the presence or addition of one or more other features, wholes, steps, operations, elements and / or components.

[0169] With respect to the foregoing description, it should be understood that changes may be made in detail, especially in the construction materials adopted and the shapes, sizes and arrangements of the parts, without departing from the scope of the present disclosure. This specification and the described embodiments are exemplary only, with the true scope and spirit of the present disclosure being indicated by the appended claims.

Claims

1. A method for storing data in a non-volatile storage device, comprising: sequentially writing at least a major portion of a first data record into one or more first logical blocks of a first append-only storage area of ​​the non-volatile storage device until the one or more first logical blocks are full; as well as A first log is generated, the first log comprising a remaining portion of the first data record and a log entry for the remaining portion. 2 . The method of claim 1 , wherein the log entry comprises a location of the one or more first logical blocks in the non-volatile storage device.

3. The method according to claim 1, wherein The first log is generated by writing both the remaining portion of the first data record and the log entry into a logical block of a second append-only storage area of ​​the nonvolatile storage device.

4. The method of claim 3, wherein the non-volatile storage device comprises a plurality of adjacent append-only storage areas, the plurality of adjacent append-only storage areas comprising a set of sequential append-only data storage areas and a set of sequential append-only log storage areas, the set of sequential append-only data storage areas comprising the first append-only storage area, and the set of sequential append-only log storage areas comprising the second append-only storage area. The method of claim 1 , wherein the first log is stored in a memory cache. 6 . The method of claim 1 , wherein a size of the first data record is larger than a logical block size of the non-volatile storage device, and the one or more first logical blocks are a plurality of sequential first logical blocks.

7. The method according to claim 1, further comprising: sequentially writing a remaining portion of the first data record and a main portion of the second data record into one or more second logical blocks in the first append-only storage area until the one or more second logical blocks are full; as well as A second log is generated, the second log including the remaining portion of the second data record and a log entry for the remaining portion of the second data record.

8. The method according to claim 7, further comprising: writing the first log into a first logical block of a second append-only storage area of ​​the non-volatile storage device; as well as The second log is written into a second logical block of the second append-only storage area of ​​the nonvolatile storage device.

9. The method according to claim 8, further comprising: After the remainder of the first data record has been written to the first append-only storage area, the second append-only storage area is reset.

10. The method according to claim 9, further comprising: After the resetting of the second additional-only storage area, the second additional-only storage area is opened, wherein the second additional-only storage area is opened as a data storage area in the nonvolatile storage device.

11. The method according to claim 7, further comprising: sequentially writing the remaining portion of the second data record and the main portion of the third data record into one or more third logical blocks in the first append-only storage area until the one or more third logical blocks are full; as well as A third log is generated, the third log including the remainder of the third data record and log entries for the remainder of the second data record.

12. The method according to claim 11, further comprising: writing the first log into a first logical block of a second append-only storage area of ​​the non-volatile storage device; writing the second log into a second logical block of the second append-only storage area of ​​the non-volatile storage device; as well as writing the third log into a third logical block of the second append-only storage area of ​​the nonvolatile storage device, The log entries of the first log, the log entries of the second log, and the log entries of the third log include sequential numbers.

13. A storage device control system, comprising: Non-volatile storage device; as well as The controller is configured as: sequentially writing at least a major portion of a first data record into one or more sequential first logical blocks of a first append-only storage area of ​​the non-volatile storage device until the one or more sequential first logical blocks are full, and A first log is generated, the first log comprising a remaining portion of the first data record and a log entry for the remaining portion.

14. A non-transitory computer-readable medium having stored thereon computer-executable instructions, the computer-executable instructions, when executed, causing one or more processors to perform operations comprising: sequentially writing at least a major portion of a first data record into one or more first logical blocks of a first append-only storage area of ​​a non-volatile storage device until the one or more first logical blocks are full; as well as A first log is generated, the first log comprising a remaining portion of the first data record and a log entry for the remaining portion.

Images