Use computing functions to exchange data between the host and storage devices

Abstract

The present disclosure generally relates to exchanging data between a host and a storage device using a computing function. Various embodiments described herein relate to systems and methods for a storage device (e.g., a solid-state drive (SSD)) to perform a computing function (CF), comprising: receiving a command from a host, the command identifying the CF; and in response to receiving the command, executing the CF on at least one of internal data stored in the storage device or external data transmitted from the host to determine a computation result of the CF.

Description

Technical Field

[0001] The present disclosure generally relates to systems, methods, and non-transitory processor-readable media for data replication in data storage devices. Background Art

[0002] Since the invention of storage devices, their primary purpose has been to store and retrieve data by writing data to and reading data from the storage devices. To communicate with storage devices, interfaces have been defined. Interfaces typically include a set of commands (e.g., write data commands, read data commands, etc.) supported by both the host and the storage device. A write data command (also called a "write command") is used to transfer data from the host's buffer memory to the storage device's buffer memory across the interface. The data is then written by the storage device to its storage medium. A read data command (also called a "write command") is used to read data from the storage device's storage medium into the storage device's buffer memory and to transfer data from the buffer memory to the host's buffer memory across the interface. Summary of the Invention

[0003] In some arrangements, the present disclosure relates to systems, methods, and non-transitory computer-readable media for copying data in a data storage device, comprising: receiving a command from a host, wherein the command identifies a compute function (CF); and in response to receiving the command, executing the CF on at least one of internal data stored in the storage device or external data transmitted from the host to determine a computation result. BRIEF DESCRIPTION OF THE DRAWINGS

[0004] Figure 1 A block diagram is shown of an example system including a storage device and a host according to some implementations.

[0005] Figure 2 A schematic diagram showing compute functions (CFs) involving data having the same number of logic blocks, according to some implementations.

[0006] Figure 3 Schematic diagrams showing CFs involving data with different numbers of logical blocks, according to some implementations.

[0007] Figure 4A 、 5A , 6A, 7A, 8A, 9A, 10A, 11A, 12A, 13A, 14A, 15A, 16A, and 17A are block diagrams illustrating example methods for performing CF in a write operation according to some implementations.

[0008] Figure 4B 、 5B, 6B, 7B, 8B, 9B, 10B, 11B, 12B, 13B, 14B, 15B, 16B, and 17B are flowcharts illustrating example methods for performing CF in a write operation according to some implementations.

[0009] Figure 18A 、 19A , 20A, 21A, 22A, 23A, 24A, and 25A are block diagrams illustrating example methods for performing CF in a read operation according to some implementations.

[0010] Figure 18B 、 19B , 20B, 21B, 22B, 23B, 24B, and 25B are flowcharts illustrating example methods for performing CF in a read operation according to some implementations.

[0011] Figure 26 is a flowchart illustrating an example method for performing CF according to some embodiments. DETAILED DESCRIPTION

[0012] The present disclosure relates to systems, methods, and non-transitory computer-readable media for efficiently exchanging data between a host and at least one storage device (e.g., a solid-state drive (SSD)) using a CF (e.g., annotated CF) during read / write data transfers across a storage interface between the host and at least one storage device. As used herein, a computation transfer (or "XFER") method (or annotation method) refers to a method by which data transfers are annotated to call out computations performed on data by the storage device before, after, or in parallel with reading data from or writing data to the storage device. Computation transfers can be used with respect to data written to (in a write operation) a non-volatile memory or volatile memory of a storage device and read from (in a read operation) a non-volatile memory or volatile memory of the storage device. Annotations are used to improve the utilization of the central processing unit (CPU) and memory resources of modern storage devices to increase the efficiency of input / output (I / O) communications between the host and the storage device. Specifically, the number of data transfers between the host and the storage device can be reduced, which in turn improves the performance, reliability, and availability of the storage device while reducing the cost, power consumption, and network utilization of the storage device.

[0013] In some arrangements, the computation transfer method enables the storage device to utilize its internal resources, such as, but not limited to, available processing bandwidth, memory capacity, and hardware automation, to perform the CFs described by the annotations. Examples of CFs include, but are not limited to: arithmetic operations, such as addition, subtraction, multiplication, division, Galois Field (GF) math operations; logical operations, such as AND, OR, NAND, XOR, NOR, NOT (invert), XOR; Boolean (true / false result) operations, such as AND, OR, XOR; bitwise operations, such as logical shift, arithmetic shift, rotation; comparison operations, such as greater than, less than, not equal to; string operations, such as copy, lookup, compare; database query language functions, such as AVG(), FIRST(), LAST(), MAX(), MIN(), SUM(); which can be used in sequence or in combination to perform more complex computations, such as data compression, Reed-Solomon or erasure coding, search, replace (if different), data encryption, database table manipulation, etc.

[0014] The CF described by the annotation is executed in conjunction with or in response to a compute transfer command that provides a framework for unidirectional and bidirectional transfers to and from the host. In other words, in response to receiving a compute transfer command containing the annotation and data, the storage device executes the CF and the data referenced by the annotation. As described in more detail herein, various types of compute transfer methods can be used to meet the different needs of storage systems and applications running on the storage systems.

[0015] To assist in explaining the embodiments of the present invention, Figure 1 A block diagram of a system including storage devices 100a, 100b, ..., 100n (collectively referred to as storage devices 100) coupled to a host 101, according to some examples, is shown. Host 101 may be a user device operated by a user of the storage device or an autonomous central controller, where host 101 and storage devices 100 correspond to a storage subsystem or storage device. Host 101 may be connected to a communication network (via a network interface card (NIC) 108) so that other host computers (not shown) can access the storage subsystem or storage device via the communication network. Examples of such a storage subsystem or device include an all-flash array (AFA) or a network-attached storage (NAS) device. As shown, host 101 includes memory 102, a processor 104, a bus 105, a graphics processing unit (GPU) 106, a NIC 108, and the like. Processor 104, memory 102, GPU 106, and NIC 108 may be operably coupled to each other via bus 105. Processor 104 is sometimes referred to as the central processing unit (CPU) of host 101 and is configured to execute processes for host 101 .

[0016] Memory 102 is local memory of host 101. In some examples, memory 102 is or includes one or more buffers (e.g., buffer 103). In some examples, memory 102 is a volatile memory device. In other examples, memory 102 is a non-volatile persistent storage device. Examples of memory 102 include, but are not limited to, random access memory (RAM), dynamic random access memory (DRAM), static RAM (SRAM), magnetic RAM (MRAM), phase change memory (PCM), etc.

[0017] The bus 105 includes one or more of software, firmware, and hardware that provides an interface through which components of the host 101 can communicate. Examples of components include, but are not limited to, the processor 104, the NIC 108, internal storage devices, the memory 102, the GPU 106, and the like. Additionally, the host 101 (e.g., the processor 104) can communicate with the storage device 100 using the bus 105. In some examples, the storage device 100 is directly attached or communicatively coupled to the bus 105 via a suitable interface 140. The bus 105 is one or more of a serial bus, a PCIe bus or network, a PCIe root complex, an internal PCIe switch, and the like.

[0018] The processor 104 may execute an operating system (OS), which provides a file system and applications that use the file system. The processor 104 may communicate with the storage devices 100 (e.g., the controller 110 of each of the storage devices 100) via a communication link or network. In this regard, the processor 104 may use an interface 140 to the communication link or network to send data to and receive data from one or more of the storage devices 100. The interface 140 allows software running on the processor 104 (e.g., a file system) to communicate with the storage devices 100 (e.g., their controllers 110) via the bus 105. The storage devices 100 (e.g., their controllers 110) are operatively coupled to the bus 105 directly via the interface 140. Although the interface 140 is conceptually shown as a dashed line between the host 101 and the storage devices 100, the interface 140 may include one or more controllers, one or more physical connectors, one or more data transfer protocols (including namespaces), ports, transport mechanisms, and connectivity thereof. Although the connection between host 101 and storage device 100 is shown as a direct link, in some implementations, the link may include a network fabric, which may include networking components such as bridges and switches.

[0019] To send and receive data, processor 104 (software or a file system running thereon) communicates with storage device 100 using a storage data transfer protocol running on interface 140. Examples of protocols include, but are not limited to, Serial Attached SCSI (SAS), Serial ATA (SATA), and Non-Volatile Memory Express (NVMe) protocols. In some examples, interface 140 includes hardware (e.g., a controller) implemented on or operably coupled to bus 105, storage device 100 (e.g., controller 110), or another device operably coupled to bus 105 and / or storage device 100 via one or more suitable networks. Interface 140 and the storage protocol running thereon also include software and / or firmware executed on such software. In some embodiments, storage device 100 may be an SSD using non-volatile memory and may operate using a storage data transfer protocol running on interface 140. Examples of storage data transfer protocols include PCIe (PCI Express) memory read / write, CXL.mem, CXL.cache, and CXL.io protocols.

[0020] In some examples, processor 104 can communicate with a communications network via bus 105 and NIC 108. Other host systems (not shown) attached or communicatively coupled to the communications network can communicate with host 101 using a suitable network storage protocol, examples of which include, but are not limited to, NVMe over Fabrics (NVMeoF), iSCSI, Fibre Channel (FC), Network File System (NFS), Server Message Box (SMB), and the like. NIC 108 allows software running on processor 104 (e.g., a storage protocol or file system) to communicate with external hosts attached to the communications network via bus 105. In this manner, network storage commands can be issued by an external host and processed by processor 104, which can then issue storage commands to storage device 100 as needed. Thus, data can be exchanged between the external host and storage device 100 via the communications network. In this example, any data exchanged is buffered in memory 102 of host 101.

[0021] GPU 106 includes buffer 107. For example, buffer 107 may be volatile or non-volatile memory located on the same hardware (e.g., the same chip) as other components (e.g., a processor) of GPU 106. In other examples, buffer 107 may be any suitable memory that buffers data for GPU 106.

[0022] NIC 108 includes a buffer 109. For example, buffer 109 may be volatile or non-volatile memory located on the same hardware (e.g., the same chip) as other components (e.g., a processor) of NIC 108. In other examples, buffer 109 may be any suitable memory that buffers data for NIC 108.

[0023] In some examples, buffers 103, 107, and 109 are referred to as buffers or host buffers of components of host 101. Each of buffers 103, 107, and 109 may include one or more buffers connected to bus 105, each of the one or more buffers having a corresponding address (e.g., a PCIe address) on bus 105. Although buffers 103, 107, and 109 are shown as example buffers of host 101, other buffers of host 101 may also benefit from the disclosed arrangement.

[0024] In some examples, storage device 100 is located in a data center (not shown for simplicity). The data center may include one or more platforms or rack units, each of which supports one or more storage devices (such as (but not limited to) storage device 100). In some embodiments, host 101 and storage device 100 together form a storage node, with host 101 acting as a node controller. An example of a storage node is a Kioxia Kumoscale storage node. One or more storage nodes within a platform are connected to a top-of-rack (TOR) switch, each connected to the TOR via one or more network connections (such as Ethernet, Fibre Channel, or InfiniBand), and can communicate with each other via the TOR switch or another suitable intra-platform communication mechanism. In some embodiments, storage device 100 may be a network-attached storage device (such as an Ethernet SSD) connected to the TOR switch, where host 101 is also connected to the TOR switch and can communicate with storage device 100 via the TOR switch. In some embodiments, at least one router may facilitate communication between storage devices 100 in storage nodes in different platforms, racks, or cabinets via a suitable networking fabric. Examples of storage device 100 include non-volatile devices such as, but not limited to, solid-state drives (SSDs), Ethernet-attached SSDs, non-volatile dual in-line memory modules (NVDIMMs), universal flash storage (UFS), secure digital (SD) devices, and the like.

[0025] Each of the storage devices 100 includes at least a controller 110 and a memory array 120. Memory array 120 includes nonvolatile memory devices that retain data written to them after power to the device is removed. For simplicity, other components of the storage device 100 are not shown. Memory array 120 includes NAND flash memory devices 130a through 130n. Each of the NAND flash memory devices 130a through 130n includes one or more individual NAND flash dies, which are NVMs capable of retaining data without power. Therefore, NAND flash memory devices 130a through 130n refer to multiple NAND flash memory devices or dies within the storage device 100. Each of the NAND flash memory devices 130a through 130n includes one or more dies, each of which has one or more planes. Each plane has multiple blocks, and each block has multiple pages.

[0026] Although NAND flash memory devices 130a-130n are shown as examples of memory array 120, other examples of nonvolatile memory technology for implementing memory array 120 include, but are not limited to, nonvolatile (battery backup) DRAM, magnetic random access memory (MRAM), phase change memory (PCM), ferroelectric RAM (FeRAM), etc. The arrangements described herein may likewise be implemented on a memory system using such memory technologies and other suitable memory technologies.

[0027] Examples of the controller 110 include, but are not limited to, an SSD controller (eg, a client SSD controller, a data center SSD controller, an enterprise SSD controller, etc.), a UFS controller, or an SD controller, etc.

[0028] The controller 110 can combine raw data storage in multiple NAND flash memory devices 130a-130n so that the NAND flash memory devices 130a-130n logically function as a single storage unit. The controller 110 can include a processor, a microcontroller, buffers (e.g., buffers 112, 114, 116), an error correction system, a data encryption system, a flash translation layer (FTL), and a flash interface module. Such functions can be implemented in hardware, software, and firmware, or any combination thereof. In some arrangements, the software / firmware of the controller 110 can be stored in the memory array 120 or any other suitable computer-readable storage medium.

[0029] The controller 110 includes suitable processing and memory capabilities for performing the functions described herein and other functions. As described, the controller 110 manages various features of the NAND flash memory devices 130a-130n, including (but not limited to) I / O handling, reading, writing / programming, erasing, monitoring, logging, error handling, garbage collection, wear leveling, logical-to-physical address mapping, data protection (encryption / decryption, cyclic redundancy check (CRC)), error correction coding (ECC), data scrambling, and the like. Thus, the controller 110 provides access to the NAND flash memory devices 130a-130n to perform data reading and writing.

[0030] Buffer memory 111 is a memory device that is locally operably coupled to controller 110. For example, buffer memory 111 may be on-chip SRAM memory located on the chip of controller 110. In some embodiments, buffer memory 111 may be implemented using a memory device of storage device 100 that is external to controller 110. For example, buffer memory 111 may be DRAM located on a chip other than the chip of controller 110. In some embodiments, buffer memory 111 may be implemented using memory devices both internal to controller 110 and external to controller 110 (e.g., both on-chip and off-chip). For example, buffer memory 111 may be implemented using both internal SRAM and external DRAM, both of which are transparent / exposed to other devices and accessible to other devices, such as host 101 and other storage devices 100, via interface 140. In this example, controller 110 includes an internal processor that uses memory addresses within a single address space, and a memory controller that controls both the internal SRAM and the external DRAM, selecting whether to place data on the internal SRAM or the external DRAM based on efficiency. In other words, the internal SRAM and external DRAM are addressed as a single memory. As shown, buffer memory 111 includes buffer 112, write buffer 114, and read buffer 116. In other words, buffer 112, write buffer 114, and read buffer 116 can be implemented using buffer memory 111. In some embodiments, buffer memory 111 can be implemented in whole or in part using fast-access non-volatile memory such as MRAM or PCM. In such embodiments, data temporarily stored in buffer memory that needs to survive power cycles can be stored in non-volatile memory within buffer memory 111, thereby avoiding the need to persist this data by copying it to memory array 120 upon power loss.

[0031] Controller 110 includes a buffer 112, sometimes referred to as a drive buffer or controller memory buffer (CMB). In addition to being accessible by controller 110, buffer 112 can be accessed by other devices, such as host 101 and others in storage device 100, via interface 140. In this manner, buffer 112 (e.g., addresses of memory locations within buffer 112) is exposed across bus 105, and devices on bus 105 can issue read and write commands using addresses corresponding to physical memory locations within buffer 112 or logical addresses (e.g., logical block addresses (LBAs)) to read and write data within the buffer. In some examples, buffer 112 is a volatile memory device. In some examples, buffer 112 is a non-volatile persistent memory device. Examples of buffer 112 include, but are not limited to, RAM, DRAM, SRAM, MRAM, PCM, etc. Buffer 112 may refer to a plurality of buffers, each configured to store different types of data, as described herein.

[0032] In some embodiments, as Figure 1 , buffer 112 is shown as local memory of controller 110. For example, buffer 112 may be on-chip SRAM memory located on the chip of controller 110. In some implementations, buffer 112 may be implemented using a memory device of storage device 100 that is external to controller 110. For example, buffer 112 may be DRAM located on a chip other than the chip of controller 110. In some implementations, buffer 112 may be implemented using memory devices both internal to controller 110 and external to controller 110 (e.g., both on-chip and off-chip). For example, buffer 112 may be implemented using both internal SRAM and external DRAM, both of which are transparent / exposed to other devices and accessible to other devices, such as host 101 and other storage devices 100, via interface 140. In this example, controller 110 includes an internal processor that uses memory addresses within a single address space, and a memory controller that controls both the internal SRAM and the external DRAM, selecting whether to place data there based on efficiency. In other words, the internal SRAM and external DRAM are addressed as a single memory.

[0033] In one example regarding a write operation (without CF), in response to receiving data from the host 101 (via the host interface 140), the controller 110 acknowledges the write command to the host 101 after writing the data to the write buffer 114. In some implementations, the write buffer 114 may be implemented in a separate memory distinct from the buffer 112, or the write buffer 114 may be a defined area or portion of the memory that includes the buffer 112, where only the CMB portion of the memory is accessible to other devices other than the write buffer 114. The controller 110 may write the data stored in the write buffer 114 to the memory array 120 (e.g., NAND flash memory devices 130a to 130n). Once the data is written to the physical address of the memory array 120, the FTL updates the mapping between the logical address (e.g., LBA) associated with the data by the host 101 and the physical address used by the controller 110 to identify the physical location of the data.

[0034] In another example regarding read operations, controller 110 includes another buffer 116 (e.g., a read buffer) distinct from buffer 112 and buffer 114 to store data read from memory array 120. In some implementations, read buffer 116 may be implemented in a separate memory distinct from buffer 112, or read buffer 116 may be a defined area or portion of the memory that includes buffer 112, where only the CMB portion of the memory is accessible by other devices, not read buffer 116.

[0035] Although non-volatile memory devices, such as NAND flash memory devices 130a-130n, are presented herein as examples, the disclosed scheme may be implemented on any storage system or device connected to the host 101 via an interface, where such a system temporarily or permanently stores data for later retrieval by the host 101.

[0036] Although storage devices 100 are shown and described as single physical devices, the arrangements disclosed herein are equally applicable to virtualized storage devices 100. For example, the controller 110 and memory array 120 of each of the storage devices 100 may be virtualized from hardware components such as a processor and memory.

[0037] In some arrangements, the host 101 may send a read command or a write command to one of the storage devices 100 (e.g., storage device 100a) across the interface 140, wherein the read command or write command specifies or otherwise identifies the CF to be executed by the storage device 100a. In one example, the read command or write command may be an NVMe read command or write command that has been appropriately modified to specify or otherwise identify the CF to be executed. In one example, the modified NVMe read command or write command may use defined input / output parameters based on a 128-bit data pointer register (DPTR) and a 64-bit starting LBA (SLBA) to refer to the memory operands of the CF operation. The DPTR is a pointer to a memory buffer of the host 101 or to a scatter list (SGL) of the host 101's memory descriptors.

[0038] The example expression of CF operation can be expressed as:

[0039] StatusResult=CF(Operand1,Operand2,OpNLB1,opNLB2,OTYPE,ComFun) (1),

[0040] Where StatusResult is the status of the completion result (e.g., success / failure) of the CF operation, which is different from the calculation result described in this article. Operand1 and Operand2 are used as input parameters of the calculation, and the calculation result of the calculation is written to Operand1 or Operand2 depending on the type of CF. Therefore, for a CF with a 'write' type, the calculation result is written to Operand2, so that Operand2 is used as both input and output parameters (i.e., input / output parameters or I / O parameters). For a CF with a 'read' type, the calculation result is returned or written to Operand1, so that Operand1 is used as both input and output parameters (i.e., input / output parameters or I / O parameters). In some instances (e.g. Figure 4A ), the flag in OTYPE may indicate that Operand2 may not be considered as an input parameter, so that CF only operates on Operand1. Figure 18A), the flag in OTYPE may indicate that Operand1 may not be considered as an input parameter, so that CF only operates on Operand2. Operand1 can be two types of addresses, which refer to: (1) one or more physical memory buffer address locations of a device connected to the storage device 100a via the interface 140 and / or the bus 105; or (2) a logical address of a location in the non-volatile memory (such as the memory array 120) of the storage device 100a, etc. The address type of Operand1 depends on the value of OTYPE. OTYPE is a parameter with one or more flags, which have values ​​indicating the type of address of Operand1 (whether a physical memory buffer address, a logical address, etc.). In some examples, OTYPE may also indicate that the output parameter is a temporary buffer. The type of address of Operand1 includes (but is not limited to) a logical address of a location in the non-volatile memory of the storage device 100, an address of a buffer of a device connected to the storage device 100a via the interface 140 and / or the bus 105, etc. Examples of buffers of a device connected to storage device 100a via interface 140 and / or bus 105 include, but are not limited to, buffer locations in host 101, buffer locations in storage devices 100b through 100n, and the like. Examples of buffer locations in host 101 include, but are not limited to, locations in buffer 103 of memory 102, locations in buffer 107 of GPU 106, locations in buffer 109 of NIC 108, and the like. Examples of buffer locations in storage devices 100b through 100n include, but are not limited to, locations in buffer 112 of storage devices 100b through 100n. The addresses of the buffers of a device connected to storage device 100a via interface 140 and / or bus 105 may be addresses on bus 105 (e.g., PCIe addresses), as described.

[0041] OpNLB1 defines the number of logical blocks from the location indicated by Operand1 related to the CF. Operand2 is the logical address of the first logical block of a region of memory in the nonvolatile memory of storage device 100a (e.g., memory array 120). In some cases, Operand1 and Operand2 may refer to different logical block addresses within the nonvolatile memory of storage device 100a (e.g., memory array 120), and when both Operand1 and Operand2 are input parameters, one of Operand1 or Operand2 may be both an input and output parameter, or an I / O parameter. This enables calculations to be performed on two data operands located in memory array 120, with the result of the calculation being stored back in memory array 120 and overwriting one of the input operands. In this way, computations can be performed on data in memory array 120 and the results stored in memory array 120 without requiring any data to be transferred from host 101 to storage device 100 or back from storage device 100 to host 101, thereby saving time and bandwidth utilization on bus 105. OpNLB2 defines the number of logical blocks from the logical blocks indicated by Operand2 for the CF involved. ComFun is a parameter that defines the compute function to be used for the CF operation. For example, it can be a unique identifier associated with a specific compute function. The association can be predefined by a published standard specification, allowing both host 101 and storage device 100a to have a common understanding of which compute function is associated with a particular identifier. In some embodiments, storage device 100a can define its own proprietary association, and the host can discover what compute functions the device supports by issuing a query command to controller 110, which responds with a list of supported compute functions. An example of a query command is the Identify Controller command in the NVMe protocol.

[0042] In other words, in the CF operation shown in Table (1), in some cases, Operand1 and OpNLB1 are used to define data located in a physical memory buffer addressable on bus 105. In other cases, Operand1 and OpNLB1 can also be used to define the logical address of data located in the non-volatile memory (e.g., memory array 120) of memory device 100a. In the CF operation shown in Table (1), Operand2 and OpNLB2 are used to define data located in the non-volatile memory (e.g., memory array 120) of memory device 100a. In some embodiments, the roles of Operand1, OpNLB1 and Operand2, OpNLB1 can be reversed, such that Operand2 and OpNLB2 are used to define data located in a physical memory buffer addressable on bus 105 and Operand1 and OpNLB1 are used to define data located in the non-volatile memory (e.g., memory array 120) of memory device 100a.

[0043] In some examples, a write with CF includes writing the result of the calculation of CF to the logical address of storage device 100a identified by Operand2, similar to executing a write command in which data is written to a location defined by an SLBA parameter. This enables the result of the calculation to be stored in memory array 120 and the data currently stored in that location to be used as an input operand for the calculation, because Operand2 is used as an I / O parameter in the write with CF. Therefore, Operand1 can appear as a combined I / O parameter for the write operation.

[0044] In some instances where OTYPE specifies that Operand1 is the address of a buffer of a device connected to storage device 100a via interface 140 and / or bus 105, a read with CF includes returning the result of the computation of CF to the buffer of the device connected to storage device 100a via interface 140 and / or bus 105. In these instances, a read with CF includes writing the result of the computation of CF to the logical address indicated by Operand1. As described, the location corresponding to Operand1 can be a location in buffers 103, 107, and 109 of host 101 or buffer 112 of storage devices 100a through 100n. Thus, in a read with CF, the result of the computation can be written to a buffer in host 101 or to a controller buffer memory of the same storage device that performed the CF operation, for example, to enable the latter to be used to temporarily store the result of the computation to be subsequently used in another computation, thereby saving time and bus bandwidth utilization when transferring the temporary computation result data back to host 101. In other examples, in a read with CF, the calculated result of the computation can be transferred and written to a controller buffer memory of a memory device 100a-100n different from the memory device performing the CF operation, for example, to enable the calculation result to be transferred directly to another memory device on the same bus 105 without having to be transferred through the host 101 and back again, thereby saving time and bus bandwidth utilization when transferring temporary calculation result data to a different memory device and back again through the host 101. In other examples where OTYPE specifies that Operand1 is a logical address, a read with CF includes writing the calculation result of the CF to a logical address on the memory array 120 of the memory device 100a. Therefore, Operand1 can appear as a combined I / O parameter for a read operation.

[0045] In some examples, a single CF operation can perform the functionality of a 'read with CF' operation or a 'write with CF' operation by including a flag in the OTYPE that specifies whether the result of the calculation of the CF is to be written to the address specified by Operand1 or Operand2. Thus, a single CF operation can perform the equivalent of a 'read with CF' operation by specifying a flag indicating that Operand1 is an output parameter. Similarly, a single CF operation can perform the equivalent of a 'write with CF' operation by specifying a flag indicating that Operand2 is an output parameter. In some examples, in a read or write command specifying that a CF is to be executed by the memory device 100a, two parameters (e.g., OpNLB1 and OpNLB2) can be used to define the number of logical blocks, as shown in Table (1). In some arrangements, OpNLB1 and OpNLB2 can be the same for certain CFs that involve the same number of logical blocks referenced in Operand1 and Operand2.

[0046] in this regard, Figure 2 A schematic diagram showing CF 230 involving data 201 and 211 having the same number of logical blocks according to some implementations is shown. Figure 1 and 2 The type of CF 230 executed by the storage device 100a (e.g., XOR, ADD, etc.), Operand1, Operand2, OpNLB1, and OpNLB2 are specified in a read command or a write command received by the storage device 100a from the host 101. As shown, Operand1 specifies one or more memory buffer locations of the first data 201, while OpNLB1 defines the number of logical blocks (e.g., n) of the first data 201. In other words, the first data 201 includes n logical blocks 202a, 202b, 202c, ..., 202n-1. Operand2 specifies the logical address of the first logical block of a region of memory in the non-volatile memory of the storage device 100a (e.g., the memory array 120) for the second data 211, while OpNLB2 defines the number of logical blocks (e.g., n) of the second data 211. In other words, the second data 211 includes n logical blocks 212a, 212b, 212c, ..., 212n-1.

[0047] The storage device 100 a (eg, the controller 110 thereof) may perform a CF 230 on the first data 201 and the second data 211 to determine a calculation result 221 . As shown, the first logic block 202a of the first data 201 and the corresponding first logic block 212a of the second data 211 are input into the CF 230 to determine the first logic block 222a of the calculation result 221, the second logic block 202b of the first data 201 and the corresponding second logic block 212b of the second data 211 are input into the CF 230 to determine the second logic block 222b of the calculation result 221, the third logic block 202c of the first data 201 and the corresponding third logic block 212c of the second data 211 are input into the CF 230 to determine the third logic block 222c of the calculation result 221,…, and the last logic block 202n-1 of the first data 201 and the corresponding last logic block 212n-1 of the second data 211 are input into the CF 230 to determine the last logic block 222n-1 of the calculation result 221. Examples of the CF 230 include, but are not limited to, XOR, ADD, etc., where each logical block of the first data 201 is added or XORed with a corresponding logical block of the second data 211 .

[0048] therefore, Figure 2The logic block identified by Operand1 and the corresponding logic block identified by Operand2 are shown to be added or XORed together by storage device 100a, and the calculation result 221 is stored in the buffer identified by Operand1 or Operand2. In this case, OpNLB1 and OpNLB2 are the same. In other examples, instead of using two parameters, OpNLB1 and OpNLB2, only one parameter needs to be specified in the read or write command. In some examples, a flag in OTYPE can indicate whether the numbers OpNLB1 and OpNLB2 are the same.

[0049] In some arrangements, a second number of logical blocks (e.g., OpNLB2) may be used for certain CFs that relate to the difference between the number of logical blocks referenced in Operand1 and the number of logical blocks referenced in Operand2. Figure 3 A schematic diagram showing a CF 330 involving data 301 and 311 having different numbers of logical blocks according to some implementations. Figure 1 and 3 The type of CF 330 executed by the storage device 100a (e.g., search, XOR, etc.), Operand1, Operand2, OpNLB1, and OpNLB2 are specified in a read command or a write command received by the storage device 100a from the host 101. As shown, Operand1 specifies one or more memory buffer locations of the first data 301, while OpNLB1 defines the number of logical blocks (e.g., 2) of the first data 301. In other words, the first data 301 includes two logical blocks 302a and 302b. Operand2 specifies the logical address of the first logical block of a memory region in the non-volatile memory of the storage device 100a (e.g., the memory array 120) for the second data 311, while OpNLB2 defines the number of logical blocks (e.g., n) of the second data 311. In other words, the second data 311 includes n logical blocks 312a, 312b, 312c, ..., 312n-1.

[0050] Storage device 100a (e.g., its controller 110) may perform a CF 330 on first data 301 and second data 311 to determine a StatusResult 322. In one example, CF 330 is a search or find operation that attempts to identify a logical block in second data 311 that matches first data 301. Specifically, logical blocks 302a and 302b are compared to each two consecutive logical blocks in logical blocks 312a through 312n-1 to determine a match. StatusResult 322 may indicate the result of CF 330 (e.g., found or not found) and, if a match is found, include the logical addresses of two consecutive logical blocks 312a through 312n-1 that match logical blocks 302a and 302b. For the search or find operation, no data is written to Calculation Result 324, and the contents of both Operand1 and Operand2 remain unchanged. In some examples, Operand may be used to indicate some or all of StatusResult 322. For example, Operand 1 contains the text string to be searched, and Operand 2 contains the data to be searched. The location of the string in Operand 1 found in Operand 2 can be written to Operand 1 in a 'Read (Search) with CF' operation. In other examples, this information can be written to Operand 1 when a match is found. In this example, the calculation result 324 including logic blocks 324 a through 324 n-1 may not be written, so that the original data in Operand 2 312 a through 312 n-1 is not changed by the search operation.

[0051] In another example, CF 330 is an XOR operation in which logic blocks 302a and 302b are each XORed with each group of two consecutive logic blocks 312a through 312n-1. StatusResult 322 indicates the success / failure of the operation, with calculation result 324 including n logic blocks 324a through 324n-1, each of which is the result of an XOR operation of a corresponding logic block 312a through 312n-1 with one of logic blocks 302a and 302b.

[0052] Depending on whether a 'write with CF' or 'read with CF' operation is being performed and the type of CF operation (e.g., search or XOR) of CF 330, calculation results 324a to 324n-1 are stored in the buffer identified by Operand1 or Operand2. In this case, OpNLB1(2) and OpNLB2(n) are different. For some CF operations, such as 'search', no calculation results may be written to Operand1 or Operand2, but StatusResult 322 may indicate found / not found in addition to success / failure, where success / failure may indicate success / failure in reading the data in Operand2 to perform the search operation, and StatusResult 322 may indicate success (Operand2 data was successfully read) and not found, indicating that although no error was encountered when reading the operand, the searched data (in Operand1) was not found in Operand2.

[0053] As described herein, the memory device 100a may execute a CF indicated by a read command (eg, a comment read command) or a write command (eg, a comment read command). Figures 4A to 25B Describes the instance methods used to execute CF.

[0054] Figure 4A is a block diagram illustrating an example method 400a for performing CF in a write operation according to some embodiments. Figure 1 and 4A Method 400a can be performed by host 101 and storage device 100a. One of buffers 103, 107, or 109 includes host buffer (new data) 401. NVM (result) 404 refers to a memory location in memory array 120 of storage device 100a. Each of drive buffer (new data) 402 and drive buffer (result) 403 can be write buffer 114 or buffer 112. In some examples, drive buffer (new data) 402 and drive buffer (result) 403 are the same buffer (e.g., the same write buffer 114 or the same buffer 112) to conserve buffer resources. In method 400a, controller 110 of storage device 100a performs CF 410 on data received from host 101 and then writes the calculation result of CF 410 to NVM (result) 404.

[0055] In method 400a, host 101 submits a comment write command to controller 110 of storage device 100a over bus 105 and via interface 140. The comment write command includes a comment or indication identifying the type of CF 410 to be performed on new data stored in host buffer (new data) 401.

[0056] The host 101 presents the host buffer (new data) 401 to the controller 110 for writing. In response, at 411, the controller 110 performs a data transfer to obtain the new data from the host buffer (new data) 401 across the interface 140 through the bus 105 and stores the new data in the drive buffer (new data) 402.

[0057] The controller 110 of the storage device 100a executes CF 410 on the new data in the drive buffer (new data) 402. The input of CF 410 is the new data in the drive buffer (new data) 402, and the output of CF 410 is the calculation result of CF 410. At 412, the controller 110 of the storage device 100a stores the calculation result of CF 410 in the drive buffer (result) 403. At 413, the controller 110 of the storage device 100a writes the calculation result from the drive buffer (result) 403 to the NVM (result) 404. In some examples, instead of writing the calculation result from the drive buffer (result) 403 to the NVM (result) 404, the controller 110 of the storage device 100a may write the calculation result from the drive buffer (result) 403 to the buffer 112 of the storage device 100a. According to the sample representation of CF discussed previously, method 400a corresponds to a write with CF, where Operand1 is the location of host buffer 401, Operand2 is the logical address of NVM (result) 404, and OTYPE indicates that Operand2 can be treated as an input parameter and can only be used as an output parameter. In other words, the calculation function CF 410 only operates on the new data located at Operand1 and writes the calculation result to Operand2.

[0058] Figure 4B is a flow chart illustrating an example method 400b for performing CF in a write operation according to some embodiments. Figure 1 、 4A 4B, the method 400b corresponds to the method 400a. The method 400b may be executed by the controller 110 of the storage device 100a.

[0059] At 421, controller 110 receives a comment write command from host 101 operatively coupled to storage device 100a. The comment write command identifies a CF 410 to be executed. At 422, in response to receiving the comment write command, controller 110 transfers new data from host 101 (e.g., from host buffer (new data) 401) across bus 105 and via interface 140 to a drive buffer (e.g., drive buffer (new data) 402) of storage device 100a. At 423, controller 110 executes CF 410 on the new data to determine a calculation result. The transfer of new data from host 101 at 422 can be performed incrementally based on a transfer unit size. Thus, CF 410 can be incrementally executed for some of the new data already received in drive buffer (new data) 402 while the remainder of the new data is still being transferred to drive buffer (new data) 402. Thus, CF 410 can be executed concurrently and in real time as new data is received and as calculation results are stored in drive buffer (result) 403. At 424 , the controller 110 of the memory device 100 a stores the calculation result of the CF 410 in a result drive buffer (eg, the drive buffer (result) 403 ). At 425 , the controller 110 of the memory device 100 a writes the calculation result to the NVM (result) 404 .

[0060] Figure 5A is a block diagram illustrating an example method 500a for performing CF in a write operation according to some embodiments. Figure 1 and 5AMethod 500a can be performed by host 101 and storage device 100a. One of buffers 103, 107, or 109 includes host buffer (new data) 501. NVM (new data) 504 refers to a memory location in memory array 120 of storage device 100a. Each of drive buffer (new data) 502 and drive buffer (result) 503 can be write buffer 114 or buffer 112. In some examples, drive buffer (new data) 502 and drive buffer (result) 503 are the same buffer (e.g., the same write buffer 114 or the same buffer 112) to save buffer resources. In method 500a, controller 110 of storage device 100a writes data from host 101 to NVM (new data) 504 before performing CF 510 on the new data. In other examples, the controller 110 writes data from the host 101 to the NVM (new data) 504 while (in parallel or simultaneously) executing the CF 510 on the new data, or after. Based on the sample representation of the CF discussed previously, method 500a corresponds to a write with CF, where Operand1 is the location of the host buffer 501, Operand2 is the logical address of the NVM (new data) 504, and OTYPE indicates that Operand2 may not be considered an input parameter and is only used as an output parameter. In other words, the calculation function CF 510 only operates on the new data located at Operand1 and writes the calculation result to Operand2.

[0061] In method 500a, host 101 submits a comment write command to controller 110 of storage device 100a over bus 105 and via interface 140. The comment write command includes a comment or indication identifying the type of CF 510 to be performed on new data stored in host buffer (new data) 501.

[0062] The host 101 presents the host buffer (new data) 501 to the controller 110 for writing. In response, at 511, the controller 110 performs a data transfer to obtain the new data from the host buffer (new data) 501 across the interface 140 via the bus 105 and stores the new data in the drive buffer (new data) 502. At 513, the controller 110 of the storage device 100a writes the new data from the drive buffer (new data) 502 to the NVM (new data) 504.

[0063] The controller 110 of the storage device 100a executes CF 510 on the new data in the drive buffer (new data) 502. The input of CF 510 is the new data in the drive buffer (new data) 502, and the output of CF 510 is the calculation result of CF 510. In some examples, 513 is executed before CF 510 is executed (e.g., started or completed). In other examples, 513 is executed while (in parallel or simultaneously) or after CF 510 is executed. At 512, the controller 110 of the storage device 100a stores the calculation result of CF 510 in the drive buffer (result) 503.

[0064] Figure 5B is a flow chart illustrating an example method 500b for performing CF in a write operation according to some embodiments. Figure 1 、 5A 5B, method 500b corresponds to method 500a. Method 500b may be executed by controller 110 of storage device 100a.

[0065] At 521, the controller 110 receives a comment write command from the host 101 operatively coupled to the storage device 100a. The comment write command identifies the CF 510 to be executed. At 522, in response to receiving the comment write command, the controller 110 transfers new data from the host 101 (e.g., from host buffer (new data) 501) across the bus 105 and via the interface 140 to the drive buffer of the storage device 100a (e.g., drive buffer (new data) 502). At 523, the controller 110 of the storage device 100a writes the new data from the drive buffer to the NVM (result) 504. At 524, the controller 110 executes the CF 510 on the new data to determine a calculation result. At 525, the controller 110 of the storage device 100a stores the calculation result of the CF 510 in a result drive buffer (e.g., drive buffer (result) 503).

[0066] Figure 6A is a block diagram illustrating an example method 600a for performing CF in a write operation according to some embodiments. Figure 1 and 6AMethod 600a can be performed by host 101 and storage device 100a. One of buffers 103, 107, or 109 includes host buffer (new data) 601. NVM (result) 604 refers to a first memory location in memory array 120 of storage device 100a. NVM (old data) 605 refers to a second memory location in memory array 120 of storage device 100a. Each of drive buffer (new data) 602 and drive buffer (result) 603 can be write buffer 114 or buffer 112. In some examples, drive buffer (new data) 602 and drive buffer (result) 603 are the same buffer (e.g., the same write buffer 114 or the same buffer 112) to conserve buffer resources. In method 600a, controller 110 of storage device 100a performs CF 610 on new data received from host 101 and old data stored in NVM (old data) 605. The new data and the old data have the same logical address. Next, the calculation result is written to NVM (result) 604 to replace the old data. Therefore, the memory location (e.g., physical location) of NVM (old data) 605 and the memory location (e.g., physical location) of NVM (result) 604 correspond to the same address, so that the old data at the logical address of NVM (old data) 605 is replaced by the calculation result at the same logical address. According to the sample form of CF discussed previously, method 600a corresponds to a write with CF, where Operand1 is the location of host buffer 601, Operand2 is the logical address of NVM (old data) 605 (which is the same address as NVM (result) 604), and OTYPE indicates that the logical address in Operand2 is used as both an input parameter and an output parameter, and Operand1 is used as an input parameter. In other words, the calculation function CF 610 operates on both the new data located at Operand1 and the old data at Operand2 and writes the calculation result to Operand2.

[0067] In method 600a, host 101 submits a comment write command to controller 110 of storage device 100a via bus 105 and interface 140. The comment write command includes a comment or indication identifying the type of CF 610 to be performed on new data stored in host buffer (new data) 401 and old data stored in NVM (old data) 605. The comment write command uses Operand1 (the address on bus 105 corresponding to host buffer (new data) 601) and OpNLB1 to identify the new data and uses Operand2 and OpNLB2 to identify the logical address of the old data. The comment write command may further include a flag specifying that the result of the CF 610 calculation is to be written to the logical address corresponding to Operand2.

[0068] The host 101 presents the host buffer (new data) 601 to the controller 110 for writing. In response, at 611, the controller 110 performs a data transfer to obtain the new data from the host buffer (new data) 601 across the interface 140 via the bus 105 and stores the new data in the drive buffer (new data) 602. At 612, the controller 110 of the storage device 100a performs a NAND read on the NVM (old data) 605. In other words, the controller 110 reads the old data and the existing data corresponding to the logical address (Operand2) in the annotated write command from the memory array 120.

[0069] The controller 110 of the storage device 100a executes a CF 610 on the new data in the drive buffer (new data) 602 and the old data read from the NVM (old data) 605. The inputs to the CF 610 are the new data in the drive buffer (new data) 602 and the old data read from the NVM (old data) 605. The output of the CF 610 is the calculation result of the CF 610. At 613, the controller 110 of the storage device 100a stores the calculation result of the CF 610 in the drive buffer (result) 603. At 614, the controller 110 of the storage device 100a writes the calculation result from the drive buffer (result) 603 to the NVM (result) 604. In other words, at 614, the controller 110 then updates the old data with the calculation result by writing the calculation result from the drive buffer (result) 603 to the NVM (result) 604. The controller 110 (eg, FTL) updates the address mapping table to correspond the physical address of the NVM (result) 604 to the logical address (Operand2). The controller 110 marks the physical address of the NVM (old data) 605 for obsolete item collection.

[0070] Figure 6B is a flow chart illustrating an example method 600b for performing CF in a write operation according to some embodiments. Figure 1 、 6A 6B, method 600b corresponds to method 600a. Method 600b may be executed by the controller 110 of the storage device 100a.

[0071] At 621, the controller 110 receives a comment write command from the host 101 operatively coupled to the storage device 100a. The comment write command identifies the CF 610 to be executed. At 622, in response to receiving the comment write command, the controller 110 transfers new data from the host 101 (e.g., from host buffer (new data) 601) to the drive buffer (e.g., drive buffer (new data) 602) of the storage device 100a across the bus 105 and via the interface 140. At 623, the controller 110 reads old data from the NVM (old data) 605. At 624, the controller 110 executes the CF 610 on the new data and the old data to determine a calculation result. The transfer of new data from the host 101 and the reading of old data at 622 can be performed in steps based on one or more transfer unit sizes. Thus, CF 610 can be executed incrementally for some of the new data already received in drive buffer (new data) 602 and some of the corresponding old data already read from NVM (old data) 605, while the remaining portion of the new data is still being transferred to drive buffer (new data) 602 and the remaining portion of the old data is still being read. Thus, CF 610 can be executed concurrently and in real time as new data is received, as old data is read, and as calculation results are stored in drive buffer (result) 603. At 625, controller 110 of storage device 100a stores the calculation results of CF 610 in a result drive buffer (e.g., drive buffer (result) 603). At 626, controller 110 of storage device 100a writes the calculation results to NVM (result) 604.

[0072] Figure 7A is a block diagram illustrating an example method 700a for performing CF in a write operation according to some embodiments. Figure 1 and 7AMethod 700a can be performed by host 101 and storage device 100a. One of buffers 103, 107, or 109 includes host buffer (new data) 701. NVM (new data) 704 refers to a first memory location in memory array 120 of storage device 100a. NVM (old data) 705 refers to a second memory location in memory array 120 of storage device 100a. Each of drive buffer (new data) 702 and drive buffer (result) 703 can be write buffer 114 or buffer 112. In some examples, drive buffer (new data) 702 and drive buffer (result) 703 are the same buffer (e.g., the same write buffer 114 or the same buffer 112) to conserve buffer resources. In method 700a, controller 110 of storage device 100a performs CF 710 on the new data received from host 101 and the old data stored in NVM (old data) 705. Before CF 710 is executed, new data is written to NVM (new data) 704 to replace the old data. In other examples, controller 110 writes data from host 101 to NVM (new data) 704 while (in parallel or simultaneously) or after CF 710 is executed on the new data. Therefore, the memory location (e.g., physical location) of NVM (old data) 705 and the memory location (e.g., physical location) of NVM (new data) 704 may be different, but correspond to the same logical address. According to the sample form of CF discussed previously, method 700a corresponds to a write with CF, where Operand1 is the location of host buffer 701, Operand2 is the logical address of NVM (old data) 705 (which is the same address as NVM (new data) 704), and OTYPE indicates that the logical address in Operand2 is used as both an input parameter and an output parameter, and Operand1 is used as an input parameter. In other words, compute function CF 710 operates on both the new data at Operand 1 and the old data at Operand 2, then writes drive buffer 702 to the logical address in Operand 2 and writes the computed result to temporary buffer 703, which may be identified by one or more flags in OTYPE.

[0073] In method 700a, host 101 submits a comment write command to controller 110 of storage device 100a over bus 105 and via interface 140. The comment write command includes a comment or indication identifying the type of CF 710 to be performed on new data stored in host buffer (new data) 701 and old data stored in NVM (old data) 705. The comment write command further includes a logical address.

[0074] The host 101 presents the host buffer (new data) 701 to the controller 110 for writing. In response, at 711, the controller 110 performs a data transfer to obtain the new data from the host buffer (new data) 701 across the interface 140 via the bus 105 and stores the new data in the drive buffer (new data) 702. At 712, the controller 110 of the storage device 100a performs a NAND read on the NVM (old data) 705. In other words, the controller 110 reads the old data and the existing data corresponding to the logical address in the annotate write command from the memory array 120.

[0075] At 713, the controller 110 of the storage device 100a writes the new data from the drive buffer (new data) 702 to the NVM (new data) 704. In other words, at 713, the controller 110 then updates the old data with the new data by writing the new data from the drive buffer (new data) 702 to the NVM (new data) 704. The controller 110 (e.g., the FTL) updates the addressing mapping table so that the physical address of the NVM (new data) 704 corresponds to the logical address. The controller 110 marks the physical address of the NVM (old data) 705 for obsolete item collection.

[0076] After 712, the controller 110 of the storage device 100a performs CF 710 on the new data in the drive buffer (new data) 702 and the old data read from the NVM (old data) 705. The input of CF 710 is the new data in the drive buffer (new data) 702 and the old data read from the NVM (old data) 705. The output of CF 710 is the calculation result of CF 710. At 714, the controller 110 of the storage device 100a stores the calculation result of CF 710 in the drive buffer (result) 703. In the example where the drive buffer (result) 703 is the buffer 112, the host 101 or the other of the storage devices 100 can retrieve the calculation result from the drive buffer (result) 703.

[0077] Figure 7B is a flow chart illustrating an example method 700b for performing CF in a write operation according to some embodiments. Figure 1 、 7A 7B, method 700b corresponds to method 700a. Method 700b may be executed by the controller 110 of the storage device 100a.

[0078] At 721, the controller 110 receives a write-annotation command from the host 101 operatively coupled to the storage device 100a. The write-annotation command identifies the CF 710 to be executed. At 722, in response to receiving the write-annotation command, the controller 110 transfers new data from the host 101 (e.g., from the host buffer (new data) 701) to the drive buffer (e.g., drive buffer (new data) 702) of the storage device 100a across the bus 105 and via the interface 140. At 723, the controller 110 reads the old data from the NVM (old data) 705. At 724, the controller 110 of the storage device 100a writes the new data to the NVM (new data) 704. According to the sample representation of CF discussed previously, method 700a corresponds to a write with CF, where Operand1 is the location of host buffer 701, Operand2 is the logical address of NVM (old data) 705 (which is the same address as NVM (new data) 704), and OTYPE indicates that the logical address in Operand2 is used as both an input parameter and an output parameter, and Operand1 is used as an input parameter. In other words, calculation function CF 710 operates on both the new data located at Operand1 and the old data at Operand2, then writes drive buffer 702 to the logical address in Operand2 and writes the calculation result to temporary buffer 703, which can be identified by one or more flags in OTYPE.

[0079] At 725, controller 110 executes CF 710 on the new data and the old data to determine a calculation result. The transfer of new data from host 101 at 722 and the reading of old data at 723 can be performed incrementally based on one or more transfer unit sizes. Thus, CF 710 can be performed incrementally for some of the new data already received in drive buffer (new data) 702 and some of the corresponding old data already read from NVM (old data) 705, while the remaining portion of the new data is still being transferred to drive buffer (new data) 702 and the remaining portion of the old data is still being read. Thus, CF 710 can be executed concurrently and in real time as new data is received, as old data is read, and as calculation results are stored in drive buffer (result) 703. At 726, controller 110 of storage device 100a stores the calculation result of CF 710 in a result drive buffer (e.g., drive buffer (result) 703).

[0080] like Figure 6A and 7A In both cases, the calculation results are stored in a buffer such as the driver buffer (result) 603 or 704. Figure 7AIn FIG6A , CF 710 may be executed after the NVM write at 713, while in 6A , CF 610 may be executed before the result can be written to NVM result 604 at 614. In both cases, controller 110 assigns addresses to at least two buffers selected by controller 110 rather than specified by host 101. The first buffer (e.g., 602 or 702) is used to receive new data, and the second buffer (e.g., 603 or 703) is used to hold the calculation results. In addition, although not shown, old data read from NMV (old data) 605 or 705 is also temporarily stored in a buffer before executing the CF. This buffer may be a third buffer in storage device 100a or the same as the second buffer, where the blocks of new data in the second buffer are replaced by the resulting data bytes as they are calculated. Thus, in one example, while the CF is in progress, data of mixed data types is located in the second buffer. When the CF is complete, the second buffer stores only the result data.

[0081] Controller 110 may assign buffers 603 and 703 a buffer memory size of OpNLB1 or OpNLB2, or if the CF is a search, another size within the searched LBA (e.g., a position value, 8 bits, 16 bits, 32 bits, etc.). In some examples, buffer 603 or 703 may be referenced in subsequent CFs. In other examples, a bit in the flags of OTYPE may correspond to the buffer number of buffer 603 or 703, indicating that buffer 603 or 703 has the size indicated by OpNLB1 or OpNLB2.

[0082] In some arrangements, OTYPE can be used to identify a buffer for controller 110. In some arrangements, controller 110 can select a buffer implied by the CF itself. In one example, three explicit commands include 1) "Start calculation, store temporary result size OpNLB2 in bufferID1" CF, followed by 2) "Continue calculation, retrieve Operand1 using bufferID1 and store temporary result", ... <repeat>, and 3) "End calculation, retrieve Operand1 using bufferID1 and store final result in Operand2". The three commands on CF can be used explicitly to perform chained calculations and use an internal buffer, the location of which can be selected by controller 110. The internal buffer can involve BufferID=x and the size of OpNLB1 or OpNLB2 (e.g., in the OTYPE flag).

[0083] Figure 8A is a block diagram illustrating an example method 800a for performing CF in a write operation according to some embodiments. Figure 1 and 8AMethod 800a can be performed by host 101 and storage device 100a. One of buffers 103, 107, or 109 includes host buffer (new data) 801. NVM (old data) 805 refers to a memory location in memory array 120 of storage device 100a. Each of drive buffer (new data) 802 and drive buffer (result) 803 can be write buffer 114 or buffer 112. In some examples, drive buffer (new data) 802 and drive buffer (result) 803 are the same buffer (e.g., the same write buffer 114 or the same buffer 112) to conserve buffer resources. In method 800a, controller 110 of storage device 100a performs CF 810 on new data received from host 101 and old data stored in NVM (old data) 805. The logical address corresponding to the new data is the same as the logical address corresponding to the old data. Neither the new data nor the calculation result of CF 810 is stored in the NVM (e.g., memory array 120) of storage device 100a. Based on the sample representation of CF discussed previously, method 800a corresponds to a write with CF, where Operand1 is a location in host buffer 801, Operand2 is a logical address in NVM (old data) 805, and OTYPE indicates that the logical address in Operand2 is used as an input parameter and Operand1 is used as an input parameter. In other words, calculation function CF 810 operates on both the new data located at Operand1 and the old data at Operand2, and then writes the calculation result to temporary buffer 803, which can be identified by one or more flags in OTYPE.

[0084] In method 800a, host 101 submits a comment write command to controller 110 of storage device 100a over bus 105 and via interface 140. The comment write command includes a comment or indication identifying the type of CF 810 to be performed on new data stored in host buffer (new data) 801 and old data stored in NVM (old data) 805. The comment write command further includes a logical address.

[0085] The host 101 presents the host buffer (new data) 801 to the controller 110 for writing. In response, at 811, the controller 110 performs a data transfer to obtain the new data from the host buffer (new data) 801 across the interface 140 via the bus 105 and stores the new data in the drive buffer (new data) 802. At 812, the controller 110 of the storage device 100a performs a NAND read on the NVM (old data) 805. In other words, the controller 110 reads the old data and the existing data corresponding to the logical address in the annotated write command from the memory array 120.

[0086] The controller 110 of the storage device 100a executes CF 810 on the new data in the drive buffer (new data) 802 and the old data read from the NVM (old data) 805. The input of CF 810 is the new data in the drive buffer (new data) 802 and the old data read from the NVM (old data) 805. The output of CF 810 is the calculation result of CF 810. At 813, the controller 110 of the storage device 100a stores the calculation result of CF 810 in the drive buffer (result) 803. In the example where the drive buffer (result) 803 is the buffer 112, the host 101 or the other of the storage devices 100 can retrieve the calculation result from the drive buffer (result) 803. According to the sample representation of CF discussed previously, method 800a corresponds to a write with CF, where Operand1 is the location of host buffer 801, Operand2 is the logical address of NVM (old data) 805, and OTYPE indicates that the logical address in Operand2 is used as an input parameter and Operand1 is used as an input parameter. In other words, the calculation function CF 810 operates on both the new data at Operand1 and the old data at Operand2, and then writes the calculation result to the temporary buffer 803, which can be identified by one or more flags in OTYPE.

[0087] Figure 8B is a flow chart illustrating an example method 800b for performing CF in a write operation according to some embodiments. Figure 1 、 8A 8B, method 800b corresponds to method 800a. Method 800b may be executed by the controller 110 of the storage device 100a.

[0088] At 821, the controller 110 receives a comment write command from the host 101 operatively coupled to the storage device 100a. The comment write command identifies the CF 810 to be executed. At 822, in response to receiving the comment write command, the controller 110 transfers new data from the host 101 (e.g., from the host buffer (new data) 801) to the drive buffer (e.g., drive buffer (new data) 802) of the storage device 100a across the bus 105 and via the interface 140. At 823, the controller 110 reads the old data from the NVM (old data) 805.

[0089] At 824, controller 110 executes CF 810 on the new data and the old data to determine a calculation result. The transfer of new data from host 101 at 822 and the reading of old data at 823 can be performed incrementally based on one or more transfer unit sizes. Thus, CF 810 can be executed incrementally for some of the new data already received in drive buffer (new data) 802 and some of the corresponding old data already read from NVM (old data) 805, while the remaining portion of the new data is still being transferred to drive buffer (new data) 802 and the remaining portion of the old data is still being read. Thus, CF 810 can be executed concurrently and in real time as new data is received, as old data is read, and as calculation results are stored in drive buffer (result) 803. At 825, controller 110 of storage device 100a stores the calculation result of CF 810 in a result drive buffer (e.g., drive buffer (result) 803).

[0090] Figure 9A is a block diagram illustrating an example method 900a for performing CF in a write operation according to some embodiments. Figure 1 and 9A Method 900a can be performed by host 101 and storage device 100a. One of buffers 103, 107, or 109 includes host buffer (new data) 901. NVM (stored data) 905 refers to a memory location in memory array 120 of storage device 100a. Each of drive buffer (new data) 902 and drive buffer (result) 903 can be write buffer 114 or buffer 112. In some examples, drive buffer (new data) 902 and drive buffer (result) 903 are the same buffer (e.g., the same write buffer 114 or the same buffer 112) to conserve buffer resources. In method 900a, controller 110 of storage device 100a performs CF 910 on new data received from host 101 and stored data stored in NVM (stored data) 905. The logical address corresponding to the new data is different from the logical address corresponding to the stored data. Neither the new data nor the calculation result of CF 910 is stored in the NVM (e.g., memory array 120) of storage device 100a. According to the sample representation of CF discussed previously, method 900a corresponds to a write with CF, where Operand1 is the location of host buffer 901, Operand2 is the logical address of NVM (stored data) 905, and OTYPE indicates that the logical address in Operand2 is used as an input parameter and Operand1 is used as an input parameter. In other words, calculation function CF 910 operates on both the new data located at Operand1 and the old data at Operand2, and then writes the calculation result to temporary buffer 903, which can be identified by one or more flags in OTYPE.

[0091] In method 900a, host 101 submits a comment write command to controller 110 of storage device 100a over bus 105 and via interface 140. The comment write command includes a comment or indication identifying the type of CF 910 performed on new data stored in host buffer (new data) 901 and stored data stored in NVM (stored data) 905. The comment write command further includes a logical address of the stored data, which is different from the logical address of the new data in host buffer (new data) 901.

[0092] The host 101 presents the host buffer (new data) 901 to the controller 110 for writing. In response, at 911, the controller 110 performs a data transfer to obtain the new data from the host buffer (new data) 901 across the interface 140 via the bus 105 and stores the new data in the drive buffer (new data) 902. At 912, the controller 110 of the storage device 100a performs a NAND read on the NVM (stored data) 905. In other words, the controller 110 reads the stored data corresponding to the logical address in the annotated write command from the memory array 120.

[0093] The controller 110 of the storage device 100a executes CF 910 on the new data in the drive buffer (new data) 902 and the stored data read from the NVM (stored data) 905. The input of CF 910 is the new data in the drive buffer (new data) 902 and the stored data read from the NVM (stored data) 905. The output of CF 910 is the calculation result of CF 910. At 913, the controller 110 of the storage device 100a stores the calculation result of CF 910 in the drive buffer (result) 903. In the example where the drive buffer (result) 903 is the buffer 112, the host 101 or the other of the storage devices 100 can retrieve the calculation result from the drive buffer (result) 903.

[0094] Figure 9B is a flow chart illustrating an example method 900b for performing CF in a write operation according to some embodiments. Figure 1 、 9A 9B, the method 900b corresponds to the method 900a. The method 900b may be executed by the controller 110 of the storage device 100a.

[0095] At 921, the controller 110 receives a comment write command from the host 101 operatively coupled to the storage device 100a. The comment write command identifies the CF 910 to be executed and the logical address of the stored data. At 922, in response to receiving the comment write command, the controller 110 transfers the new data from the host 101 (e.g., from the host buffer (new data) 901) to the drive buffer (e.g., drive buffer (new data) 902) of the storage device 100a across the bus 105 and via the interface 140. At 923, the controller 110 reads the stored data from the NVM (stored data) 905. As described, the stored data and the new data have different logical addresses.

[0096] At 924, controller 110 executes CF 910 on the new data and the stored data to determine the calculation results. The transfer of new data from host 101 at 922 and the reading of stored data at 923 can be performed incrementally based on one or more transfer unit sizes. Thus, CF 910 can be performed incrementally for some of the new data already received in drive buffer (new data) 902 and some of the corresponding stored data already read from NVM (stored data) 905, while the remainder of the new data is still being transferred to drive buffer (new data) 902 and the remainder of the stored data is still being read. Thus, CF 910 can be executed concurrently and in real time as new data is received, stored data is read, and calculation results are stored in drive buffer (result) 903. At 925, controller 110 of storage device 100a stores the calculation results of CF 910 in a result drive buffer (e.g., drive buffer (result) 903).

[0097] Figure 10A is a block diagram illustrating an example method 1000a for performing CF in a write operation according to some embodiments. Figure 1 and 10AMethod 1000a can be performed by host 101 and storage device 100a. One of buffers 103, 107, or 109 includes host buffer (new data) 1001. NVM (stored data) 1005 refers to a memory location in memory array 120 of storage device 100a. NVM (result) 1004 refers to another memory location in memory array 120 of storage device 100a. Each of drive buffer (new data) 1002 and drive buffer (result) 1003 can be write buffer 114 or buffer 112. In some examples, drive buffer (new data) 1002 and drive buffer (result) 1003 are the same buffer (e.g., the same write buffer 114 or the same buffer 112) to conserve buffer resources. In method 1000a, controller 110 of storage device 100a performs CF 1010 on new data received from host 101 and stored data stored in NVM (stored data) 1005. The logical address corresponding to the new data is different from the logical address corresponding to the stored data. The calculation result of the CF 1010 is saved in the NVM (eg, memory array 120) of the storage device 100a at the address specified by the comment write command.

[0098] In method 1000a, host 101 submits a comment write command to controller 110 of storage device 100a over bus 105 and interface 140. The comment write command includes a comment or indication identifying the type of CF 1010 to be performed on new data stored in host buffer (new data) 1001 and stored data stored in NVM (stored data) 1005. The comment write command uses Operand1 (the address on bus 105 corresponding to host buffer (new data) 1001) and OpNLB1 to identify the new data and uses Operand2 and OpNLB2 to identify the logical address of the stored data. The comment write command may further include a flag specifying that the result of the calculation of CF 1010 is to be written to the logical address corresponding to Operand1, the logical address corresponding to Operand2, or another logical address specified by the comment write command.

[0099] Host 101 presents host buffer (new data) 1001 to controller 110 for writing. In response, at 1011, controller 110 performs a data transfer to obtain the new data from host buffer (new data) 1001 across interface 140 via bus 105 and stores the new data in drive buffer (new data) 1002. At 1012, controller 110 of storage device 100a performs a NAND read with respect to NVM (stored data) 1005. In other words, controller 110 reads the stored data corresponding to the specified logical addresses (Operand2 and OpNLB2) in the annotated write command from memory array 120.

[0100] The controller 110 of the memory device 100a executes a CF 1010 on the new data in the drive buffer (new data) 1002 and the stored data read from the NVM (stored data) 1005. The input of the CF 1010 is the new data in the drive buffer (new data) 1002 and the stored data read from the NVM (stored data) 1005. The output of the CF 1010 is the calculation result of the CF 1010. At 1013, the controller 110 of the memory device 100a stores the calculation result of the CF 1010 in the drive buffer (result) 1003.

[0101] At 1014, the controller 110 of the storage device 100a writes the calculation result from the drive buffer (result) 1003 to the NVM (result) 1004. In the example where the comment write command specifies that the calculation result is to be written to the logical address of the new data, at 1014, the controller 110 (e.g., FTL) updates the addressing mapping table so that the physical address of the NVM (result) 1004 corresponds to the logical address (Operand1) of the new data. In the example where the comment write command specifies that the calculation result is to be written to the logical address of the stored data, at 1014, the controller 110 (e.g., FTL) updates the addressing mapping table so that the physical address of the NVM (result) 1004 corresponds to the logical address (Operand2) of the stored data. In the example where the comment write command specifies that the calculation result is to be written to another logical address, at 1014, the controller 110 (e.g., FTL) updates the addressing mapping table so that the physical address of the NVM (result) 1004 corresponds to the logical address. The controller 110 marks any expired physical addresses for garbage collection.

[0102] Figure 10B is a flow chart illustrating an example method 1000b for performing CF in a write operation according to some embodiments. Figure 1 、 10A 10B, the method 1000b corresponds to the method 1000a. The method 1000b may be executed by the controller 110 of the storage device 100a.

[0103] At 1021, controller 110 receives a comment write command from host 101 operatively coupled to storage device 100a. The comment write command identifies the CF 1010 to be executed, the logical address of the stored data, and the logical address where the calculation result of CF 1010 will be stored. At 1022, in response to receiving the comment write command, controller 110 transfers the new data from host 101 (e.g., from host buffer (new data) 1001) across bus 105 and via interface 140 to the drive buffer of storage device 100a (e.g., drive buffer (new data) 1002). At 1023, controller 110 reads the stored data from NVM (stored data) 1005. As described, the stored data and the new data have different logical addresses.

[0104] At 1024, controller 110 executes CF 1010 on the new data and the stored data to determine the calculation results. The transfer of new data from host 101 at 1022 and the reading of stored data at 1023 can be performed incrementally based on one or more transfer unit sizes. Thus, CF 1010 can be executed incrementally for some of the new data already received in drive buffer (new data) 1002 and some of the corresponding stored data already read from NVM (stored data) 1005, while the remainder of the new data is still being transferred to drive buffer (new data) 1002 and the remainder of the stored data is still being read. Thus, CF 1010 can be executed concurrently and in real time as new data is received, stored data is read, and calculation results are stored in drive buffer (result) 1003. At 1025, controller 110 of storage device 100a stores the results of CF 1010 in a result drive buffer (e.g., drive buffer (result) 1003). At 1026 , the controller 110 of the storage device 100 a writes the calculation result from the result drive buffer to the NVM (result) 1004 .

[0105] Figure 11A is a block diagram illustrating an example method 1100a for performing CF in a write operation according to some embodiments. Figure 1 and 11AMethod 1100a can be performed by host 101 and storage device 100a. One of buffers 103, 107, or 109 includes host buffer (new data) 1101. NVM (stored data) 1105 refers to a memory location in memory array 120 of storage device 100a. Each of drive buffer (new data) 1102 and drive buffer (result) 1103 can be write buffer 114 or buffer 112. In some examples, drive buffer (new data) 1102 and drive buffer (result) 1103 are the same buffer (e.g., the same write buffer 114 or the same buffer 112) to conserve buffer resources. In method 1100a, controller 110 of storage device 100a performs CF 1110 on new data received from host 101 and stored data stored in NVM (stored data) 1105. The logical address corresponding to the new data is different from the logical address corresponding to the stored data. New data is written to NVM (eg, memory array 120) of storage device 100a before execution of CF 1110. In other examples, data is written to NVM (new data) 1104 while (in parallel or simultaneously) or after execution of CF 1110 on the new data.

[0106] In method 1100a, host 101 submits a comment write command to controller 110 of storage device 100a over bus 105 and via interface 140. The comment write command includes a comment or indication identifying the type of CF 1110 to be performed on new data stored in host buffer (new data) 1101 and stored data stored in NVM (stored data) 1105. The comment write command uses Operand1 (the address on bus 105 corresponding to host buffer (new data) 1001) and OpNLB1 to identify the new data and uses Operand2 and OpNLB2 to identify the logical address of the stored data. The comment write command may further specify that the new data is to be written to the logical address corresponding to Operand1.

[0107] Host 101 presents host buffer (new data) 1001 to controller 110 for writing. In response, at 1111, controller 110 performs a data transfer to obtain the new data from host buffer (new data) 1101 across interface 140 via bus 105 and stores the new data in drive buffer (new data) 1102. At 1112, controller 110 of storage device 100a performs a NAND read with respect to NVM (stored data) 1105. In other words, controller 110 reads the stored data corresponding to the specified logical addresses (Operand2 and OpNLB2) in the annotated write command from memory array 120.

[0108] At 1113, the controller 110 of the storage device 100a writes the new data from the drive buffer (new data) 1102 to the NVM (new data) 1104. In the example where the annotated write command specifies that the calculation result is to be written to the logical address of the new data, at 1014, the controller 110 (e.g., FTL) updates the addressing mapping table so that the physical address of the NVM (result) 1104 corresponds to the logical address of the new data (Operand1). The controller 110 marks any expired physical addresses for obsolete item collection.

[0109] After 1113, the controller 110 of the storage device 100a executes CF 1110 on the new data in the drive buffer (new data) 1102 and the stored data read from the NVM (stored data) 1105. The input of CF 1110 is the new data in the drive buffer (new data) 1102 and the stored data read from the NVM (stored data) 1105. The output of CF 1110 is the calculation result of CF 1110. At 1114, the controller 110 of the storage device 100a stores the calculation result of CF 1110 in the drive buffer (result) 1103 for later retrieval.

[0110] Figure 11B is a flow chart illustrating an example method 1100b for performing CF in a write operation according to some embodiments. Figure 1 、 11A 11B, method 1100b corresponds to method 1100a. Method 1100b may be executed by controller 110 of storage device 100a.

[0111] At 1121, controller 110 receives a write-annotation command from host 101 operatively coupled to storage device 100a. The write-annotation command identifies the CF 1110 to be executed, the logical address of the stored data, and the logical address of the new data. At 1122, in response to receiving the write-annotation command, controller 110 transfers the new data from host 101 (e.g., from host buffer (new data) 1101) across bus 105 and via interface 140 to a drive buffer (e.g., drive buffer (new data) 1102) of storage device 100a. At 1123, controller 110 reads the stored data from NVM (stored data) 1105. As described, the stored data and the new data have different logical addresses. At 1124, controller 110 of storage device 100a writes the new data from the new data buffer to NVM (new data) 1104.

[0112] At 1125, controller 110 executes CF 1110 on the new data and the stored data to determine the calculation results. The transfer of new data from host 101 at 1122 and the reading of stored data at 1123 can be performed incrementally based on one or more transfer unit sizes. Thus, CF 1110 can be executed incrementally for some of the new data already received in drive buffer (new data) 1102 and some of the corresponding stored data already read from NVM (stored data) 1105, while the remaining portion of the new data is still being transferred to drive buffer (new data) 1102 and the remaining portion of the stored data is still being read. Thus, CF 1110 can be executed concurrently and in real time as new data is received, stored data is read, and calculation results are stored in drive buffer (result) 1103. At 1126, controller 110 of storage device 100a stores the calculation results of CF 1110 in a result drive buffer (e.g., drive buffer (result) 1103).

[0113] Figure 12A is a block diagram illustrating an example method 1200a for performing CF in a write operation according to some embodiments. Figure 1 and 12A Method 1200a can be performed by host 101 and storage device 100a. One of buffers 103, 107, or 109 includes host buffer (new data) 1201. Coefficient table 1205 refers to a memory location in memory array 120 of storage device 100a or another suitable memory unit of storage device 100a. Each of drive buffer (new data) 1202 and drive buffer (result) 1203 can be write buffer 114 or buffer 112. In some examples, drive buffer (new data) 1202 and drive buffer (result) 1203 are the same buffer (e.g., the same write buffer 114 or the same buffer 112) to conserve buffer resources. In method 1200a, controller 110 of storage device 100a performs CF 1210 on new data received from host 101 and data stored in coefficient table 1205 (e.g., a set of coefficients). The calculation result of CF 1210 is saved in the NVM of storage device 100a (e.g., memory array 120) at the address specified by the comment write command. In some examples, the logical address where the calculation result is to be saved is the same as the logical address of the new data received from host 101.

[0114] In method 1200a, host 101 submits a comment write command to controller 110 of storage device 100a via bus 105 and interface 140. The comment write command includes a comment or indication identifying the type of CF 1210 to be performed on new data stored in host buffer (new data) 1201 and data stored in coefficient table 1205. The comment write command uses Operand1 (the address on bus 105 corresponding to host buffer (new data) 1201) and OpNLB1 to identify the new data and uses Operand2 and OpNLB2 to identify the address (e.g., logical address) of coefficient table 1205. The comment write command may further specify that the result of the calculation of CF 1210 is to be written to the logical address corresponding to Operand1.

[0115] The host 101 presents the host buffer (new data) 1201 to the controller 110 for writing. In response, at 1211, the controller 110 performs a data transfer to obtain the new data from the host buffer (new data) 1201 across the interface 140 via the bus 105 and stores the new data in the drive buffer (new data) 1202. At 1212, the controller 110 of the storage device 100a performs a table fetch to retrieve a set of coefficients from the coefficient table 1205. In other words, the controller 110 reads the coefficient data corresponding to the specified logical addresses (Operand2 and OpNLB2) in the annotated write command from the memory array 120.

[0116] The controller 110 of the storage device 100a performs CF 1210 on the new data in the drive buffer (new data) 1202 and a set of stored coefficients from the coefficient table 1205. The input of CF 1210 is the new data in the drive buffer (new data) 1202 and a set of stored coefficients from the coefficient table 1205. The output of CF 1210 is the calculation result of CF 1210. At 1213, the controller 110 of the storage device 100a stores the calculation result of CF 1210 in the drive buffer (result) 1203.

[0117] At 1214, the controller 110 of the storage device 100a writes the calculation result from the drive buffer (result) 1203 to the NVM (result) 1204. In the example where the annotation write command specifies that the calculation result is to be written to the logical address of the new data, at 1214, the controller 110 (e.g., FTL) updates the addressing mapping table so that the physical address of the NVM (result) 1204 corresponds to the logical address of the new data (Operand1). The controller 110 marks any expired physical addresses for obsolete item collection.

[0118] Figure 12Bis a flow chart illustrating an example method 1200b for performing CF in a write operation according to some embodiments. Figure 1 、 12A 12B, the method 1200b corresponds to the method 1200a. The method 1200b may be executed by the controller 110 of the storage device 100a.

[0119] At 1221, the controller 110 receives a comment write command from the host 101 operatively coupled to the storage device 100a. The comment write command identifies the CF 1210 to be executed, the logical address of the stored coefficients, and the logical address where the calculation results of the CF 1210 are to be stored. At 1222, in response to receiving the comment write command, the controller 110 transfers new data from the host 101 (e.g., from host buffer (new data) 1201) across the bus 105 and via the interface 140 to the drive buffer of the storage device 100a (e.g., drive buffer (new data) 1202). At 1223, the controller 110 reads the stored coefficient data from the coefficient table 1205. As described, the stored coefficient data and the new data have different logical addresses.

[0120] At 1224, controller 110 executes CF 1210 on the new data and the stored coefficient data to determine the calculation results. The transfer of new data from host 101 at 1222 and the reading of stored data at 1223 can be performed incrementally based on one or more transfer unit sizes. Thus, CF 1210 can be performed incrementally for some of the new data already received in drive buffer (new data) 1202 and some of the corresponding coefficient data already read from coefficient table 1205, while the remainder of the new data is still being transferred to drive buffer (new data) 1202 and the remainder of the coefficient data is still being read. Thus, CF 1210 can be executed concurrently and in real time as new data is received, stored data is read, and calculation results are stored in drive buffer (result) 1203. At 1225, controller 110 of storage device 100a stores the calculation results of CF 1210 in a result drive buffer (e.g., drive buffer (result) 1203). At 1226 , the controller 110 of the storage device 100 a writes the calculation result from the result-driven buffer to the NVM (result) 1204 .

[0121] Figure 13A is a block diagram illustrating an example method 1300a for performing CF in a write operation according to some embodiments. Figure 1 and 13AMethod 1300a can be performed by host 101 and storage device 100a. One of buffers 103, 107, or 109 includes host buffer (new data) 1301. Coefficient table 1305 refers to a memory location in memory array 120 of storage device 100a or another suitable memory unit of storage device 100a. Each of drive buffer (new data) 1302 and drive buffer (result) 1303 can be write buffer 114 or buffer 112. In some examples, drive buffer (new data) 1302 and drive buffer (result) 1303 are the same buffer (e.g., the same write buffer 114 or the same buffer 112) to conserve buffer resources. In method 1300a, controller 110 of storage device 100a performs CF 1310 on new data received from host 101 and data stored in coefficient table 1205 (e.g., a set of coefficients). Before execution of CF 1310, the new data is stored in the NVM (e.g., memory array 120) of storage device 100a at the address specified by the comment write command. In other examples, the data is written to NVM (new data) 1304 while (in parallel or simultaneously) or after execution of CF 1310 on the new data from host 101. In some examples, the logical address where the new data is to be stored is different from the logical address of the coefficient data.

[0122] In method 1300a, host 101 submits a comment write command to controller 110 of storage device 100a over bus 105 and via interface 140. The comment write command includes a comment or indication identifying the type of CF 1310 to be performed on new data stored in host buffer (new data) 1301 and coefficient data stored in coefficient table 1305. The comment write command uses Operand1 (the address on bus 105 corresponding to host buffer (new data) 1301) and OpNLB1 to identify the new data and uses Operand2 and OpNLB2 to identify the address (e.g., logical address) of coefficient table 1305. The comment write command may further specify that the new data is to be written to the logical address corresponding to Operand1.

[0123] The host 101 presents the host buffer (new data) 1301 to the controller 110 for writing. In response, at 1311, the controller 110 performs a data transfer to obtain the new data from the host buffer (new data) 1301 across the interface 140 via the bus 105 and stores the new data in the drive buffer (new data) 1302. At 1312, the controller 110 of the storage device 100a performs a table fetch to retrieve a set of coefficients from the coefficient table 1305. In other words, the controller 110 reads the coefficient data corresponding to the specified logical addresses (Operand2 and OpNLB2) in the annotated write command from the memory array 120.

[0124] At 1313, the controller 110 of the storage device 100a writes the new data from the drive buffer (new data) 1302 to the NVM (new data) 1304. The controller 110 (e.g., FTL) updates the address mapping table so that the physical address of the NVM (new data) 1304 corresponds to the logical address (Operand1) of the new data. The controller 110 marks any expired physical addresses for obsolete collection.

[0125] After 1313, the controller 110 of the storage device 100a performs CF 1310 on the new data in the drive buffer (new data) 1302 and the set of stored coefficients from the coefficient table 1305. The input of CF 1310 is the new data in the drive buffer (new data) 1302 and the set of stored coefficients from the coefficient table 1305. The output of CF 1310 is the calculation result of CF 1310. At 1314, the controller 110 of the storage device 100a stores the calculation result of CF 1310 in the drive buffer (result) 1303.

[0126] Figure 13B is a flow chart illustrating an example method 1300b for performing CF in a write operation according to some embodiments. Figure 1 、 13A 13B, the method 1300b corresponds to the method 1300a. The method 1300b may be executed by the controller 110 of the storage device 100a.

[0127] At 1321, controller 110 receives a write-annotation command from host 101 operatively coupled to storage device 100a. The write-annotation command identifies the CF 1310 to be executed, the logical address of the stored coefficients, and the logical address where the new data is to be stored. At 1322, in response to receiving the write-annotation command, controller 110 transfers the new data from host 101 (e.g., from host buffer (new data) 1301) across bus 105 and via interface 140 to a drive buffer (e.g., drive buffer (new data) 1302) of storage device 100a. At 1323, controller 110 reads the stored coefficient data from coefficient table 1305. As described, the stored coefficient data and the new data have different logical addresses. At 1324, controller 110 of storage device 100a writes the new data from drive buffer (new data) 1302 to NVM (new data) 1304.

[0128] At 1325, controller 110 executes CF 1310 on the new data and the stored coefficient data to determine the calculation results. The transfer of new data from host 101 at 1322 and the reading of stored data at 1323 can be performed incrementally based on one or more transfer unit sizes. Thus, CF 1310 can be performed incrementally for some of the new data already received in drive buffer (new data) 1302 and some of the corresponding coefficient data already read from coefficient table 1305, while the remainder of the new data is still being transferred to drive buffer (new data) 1302 and the remainder of the coefficient data is still being read. Thus, CF 1310 can be executed concurrently and in real time as new data is received, stored data is read, and calculation results are stored in drive buffer (result) 1303. At 1326, controller 110 of storage device 100a stores the calculation results of CF 1310 in a result drive buffer (e.g., drive buffer (result) 1303).

[0129] Figure 14A is a block diagram illustrating an example method 1400a for performing CF in a write operation according to some embodiments. Figure 1 and 14A Method 1400a can be performed by host 101 and storage device 100a. One of buffers 103, 107, or 109 includes host buffer (new data) 1401. NVM (result) 1404 refers to a memory location in memory array 120 of storage device 100a. Each of drive buffer (new data) 1402 and drive buffer (result) 1403 can be write buffer 114 or buffer 112. In some examples, drive buffer (new data) 1402 and drive buffer (result) 1403 are the same buffer (e.g., the same write buffer 114 or the same buffer 112) to save buffer resources. In some examples, drive buffer (stored data) 1405 can be buffer 112, write buffer 114, or read buffer 116 of storage device 100a. In method 1400a, controller 110 of storage device 100a performs a CF 1410 on new data received from host 101 and stored data stored in drive buffer (stored data) 1405. The logical address corresponding to the new data is different from the logical address corresponding to the stored data. The result of the CF 1410 calculation is saved in the NVM (e.g., memory array 120) of storage device 100a at the address specified by the comment write command.

[0130] In method 1400a, host 101 submits a comment write command to controller 110 of storage device 100a via bus 105 and interface 140. The comment write command includes a comment or indication identifying the type of CF 1410 to be performed on new data stored in host buffer (new data) 1401 and stored data stored in drive buffer (stored data) 1405. The comment write command identifies the new data using an address on bus 105 corresponding to host buffer (new data) 1401. The comment write command may also identify the logical address or buffer address of the stored data (of drive buffer (stored data) 1405). The comment write command may further specify that the result of the calculation of CF 1410 corresponds to the logical address of the new data.

[0131] The host 101 presents the host buffer (new data) 1401 to the controller 110 for writing. In response, at 1411, the controller 110 performs a data transfer to obtain the new data from the host buffer (new data) 1401 across the interface 140 via the bus 105 and stores the new data in the drive buffer (new data) 1402. At 1412, the controller 110 of the storage device 100a performs a buffer fetch to fetch the stored data from the drive buffer (stored data) 1405.

[0132] The controller 110 of the storage device 100a executes a CF 1410 on the new data in the drive buffer (new data) 1402 and the stored data extracted from the drive buffer (stored data) 1405. The input of the CF 1410 is the new data in the drive buffer (new data) 1402 and the stored data extracted from the drive buffer (stored data) 1405. The output of the CF 1410 is the calculation result of the CF 1410. At 1413, the controller 110 of the storage device 100a stores the calculation result of the CF 1410 in the drive buffer (result) 1403.

[0133] At 1414, the controller 110 of the storage device 100a writes the calculation result from the drive buffer (result) 1403 to the NVM (result) 1404. In the example where the annotation write command specifies that the calculation result is to be written to the logical address of the new data, the controller 110 (e.g., FTL) updates the addressing mapping table so that the physical address of the NVM (result) 1404 corresponds to the logical address of the new data at 1414. The controller 110 marks any expired physical addresses for obsolete item collection.

[0134] Figure 14B is a flow chart illustrating an example method 1400b for performing CF in a write operation according to some embodiments. Figure 1 、 14A14B, method 1400b corresponds to method 1400a. Method 1400b may be executed by controller 110 of storage device 100a.

[0135] At 1421, the controller 110 receives a comment write command from the host 101 operatively coupled to the storage device 100a. The comment write command identifies the CF 1410 to be executed, the address of the stored data, and the logical address where the calculation result of the CF 1410 will be stored. At 1422, in response to receiving the comment write command, the controller 110 transfers the new data from the host 101 (e.g., from the host buffer (new data) 1401) to the drive buffer (e.g., drive buffer (new data) 1402) of the storage device 100a across the bus 105 and via the interface 140. At 1423, the controller 110 extracts the stored data from the drive buffer (stored data) 1405.

[0136] At 1424, controller 110 executes CF 1410 on the new data and the stored data to determine the calculation results. The transfer of new data from host 101 at 1422 and the retrieval of stored data at 1423 can be performed incrementally based on one or more transfer unit sizes. Thus, CF 1410 can be executed incrementally for some of the new data already received in drive buffer (new data) 1402 and some of the corresponding stored data already retrieved from drive buffer (stored data) 1405, while the remaining portion of the new data is still being transferred to drive buffer (new data) 1402 and the remaining portion of the stored data is still being retrieved. Thus, CF 1410 can be executed concurrently and in real time as new data is received, as stored data is retrieved, and as the calculation results are stored in drive buffer (result) 1403. At 1425, controller 110 of storage device 100a stores the calculation results of CF 1410 in a result drive buffer (e.g., drive buffer (result) 1403). At 1426 , the controller 110 of the storage device 100 a writes the calculation result from the result-driven buffer to the NVM (result) 1404 .

[0137] Figure 15A is a block diagram illustrating an example method 1500a for performing CF in a write operation according to some embodiments. Figure 1 and 15AMethod 1500a can be performed by host 101 and storage device 100a. One of buffers 103, 107, or 109 includes host buffer (new data) 1501. NVM (result) 1504 refers to a memory location in memory array 120 of storage device 100a. Each of drive buffer (new data) 1502 and drive buffer (result) 1503 can be write buffer 114 or buffer 112. In some examples, drive buffer (new data) 1502 and drive buffer (result) 1503 are the same buffer (e.g., the same write buffer 114 or the same buffer 112) to save buffer resources. In some examples, drive buffer (stored data) 1505 can be buffer 112, write buffer 114, or read buffer 116 of storage device 100a. In method 1500a, controller 110 of storage device 100a executes a CF 1510 on new data received from host 101 and stored data stored in drive buffer (stored data) 1505. The logical address corresponding to the new data is different from the logical address corresponding to the stored data. Before executing CF 1510, the new data is stored in NVM (e.g., memory array 120) of storage device 100a. In other examples, the data is written to NVM (new data) 1504 while (in parallel or simultaneously) or after executing CF 1510 on the new data from host 101.

[0138] In method 1500a, host 101 submits a comment write command to controller 110 of storage device 100a over bus 105 and via interface 150. The comment write command includes a comment or indication identifying the type of CF 1510 to be performed on new data stored in host buffer (new data) 1501 and stored data stored in drive buffer (stored data) 1505. The comment write command identifies the new data using an address on bus 105 corresponding to host buffer (new data) 1501. The comment write command may also identify the logical address or buffer address of the stored data (of drive buffer (stored data) 1505). The comment write command may further specify that the result of the calculation of CF 1510 is to be written to the logical address corresponding to the new data.

[0139] The host 101 presents the host buffer (new data) 1501 to the controller 110 for writing. In response, at 1511, the controller 110 performs a data transfer to obtain the new data from the host buffer (new data) 1501 across the interface 140 through the bus 105 and stores the new data in the drive buffer (new data) 1502. At 1512, the controller 110 of the storage device 100a performs a buffer fetch to fetch the stored data from the drive buffer (stored data) 1505.

[0140] At 1513, the controller 110 of the storage device 100a writes the new data from the drive buffer (new data) 1503 to the NVM (new data) 1504. The controller 110 (e.g., FTL) updates the address mapping table so that the physical address of the NVM (new data) 1504 corresponds to the logical address of the new data. The controller 110 marks any expired physical addresses for obsolete item collection.

[0141] After 1513, the controller 110 of the storage device 100a executes CF 1510 on the new data in the drive buffer (new data) 1502 and the stored data extracted from the drive buffer (stored data) 1505. The input of CF 1510 is the new data in the drive buffer (new data) 1502 and the stored data extracted from the drive buffer (stored data) 1505. The output of CF 1510 is the calculation result of CF 1510. At 1513, the controller 110 of the storage device 100a stores the calculation result of CF 1510 in the drive buffer (result) 1503.

[0142] Figure 15B is a flow chart illustrating an example method 1500b for performing CF in a write operation according to some embodiments. Figure 1 、 15A 15B, method 1500b corresponds to method 1500a. Method 1500b may be executed by the controller 110 of the storage device 100a.

[0143] At 1521, controller 110 receives a comment write command from host 101 operatively coupled to storage device 100a. The comment write command identifies the CF 1510 to be executed, the address of the stored data, and the logical address where the calculation result of CF 1510 will be stored. At 1522, in response to receiving the comment write command, controller 110 transfers new data from host 101 (e.g., from host buffer (new data) 1501) across bus 105 and via interface 140 to a drive buffer (e.g., drive buffer (new data) 1502) of storage device 100a. At 1523, controller 110 extracts the stored data from drive buffer (stored data) 1505. At 1524, controller 110 of storage device 100a writes the new data from the result drive buffer to NVM (new data) 1504.

[0144] At 1525, controller 110 executes CF 1510 on the new data and the stored data to determine the calculation results. The transfer of new data from host 101 at 1522 and the retrieval of stored data at 1523 can be performed incrementally based on one or more transfer unit sizes. Thus, CF 1510 can be executed incrementally for some of the new data already received in drive buffer (new data) 1502 and some of the corresponding stored data already retrieved from drive buffer (stored data) 1505, while the remaining portion of the new data is still being transferred to drive buffer (new data) 1502 and the remaining portion of the stored data is still being retrieved. Thus, CF 1510 can be executed concurrently and in real time as new data is received, as stored data is retrieved, and as the calculation results are stored in drive buffer (result) 1503. At 1525, controller 110 of storage device 100a stores the calculation results of CF 1510 in a result drive buffer (e.g., drive buffer (result) 1503).

[0145] Figure 16A is a block diagram illustrating an example method 1600a for performing CF in a write operation according to some embodiments. Figure 1 and 16A Method 1600a can be performed by host 101 and storage device 100a. One of buffers 103, 107, or 109 includes host buffer (new data) 1601. Coefficient table 1605 refers to a memory location in memory array 120 of storage device 100a or another suitable memory unit of storage device 100a. Each of drive buffer (new data) 1602 and drive buffer (result) 1603 can be write buffer 114 or buffer 112. In some examples, drive buffer (new data) 1602 and drive buffer (result) 1603 are the same buffer (e.g., the same write buffer 114 or the same buffer 112) to conserve buffer resources. In method 1600a, controller 110 of storage device 100a performs CF 1610 on the new data received from host 101 and the data stored in coefficient table 1605 (e.g., a set of coefficients). Both the new data and the calculation result of CF 1610 are stored in the NVM (eg, memory array 120 ) of storage device 100 a .

[0146] In method 1600a, host 101 submits a comment write command to controller 110 of storage device 100a over bus 105 and via interface 140. The comment write command includes a comment or indication identifying the type of CF 1610 performed on new data stored in host buffer (new data) 1601 and data stored in coefficient table 1605. The comment write command further includes an address of coefficient table 1605 (e.g., a logical address or another suitable address).

[0147] The host 101 presents the host buffer (new data) 1601 to the controller 110 for writing. In response, at 1611, the controller 110 performs a data transfer to obtain the new data from the host buffer (new data) 1601 across the interface 140 via the bus 105 and stores the new data in the drive buffer (new data) 1602. At 1612, the controller 110 of the storage device 100a performs a table fetch to retrieve a set of coefficients from the coefficient table 1605. In other words, the controller 110 fetches the coefficient data corresponding to the address in the annotated write command from the memory array 120.

[0148] The controller 110 of the storage device 100a performs a CF 1610 on the new data in the drive buffer (new data) 1602 and a set of stored coefficients from the coefficient table 1605. The input of the CF 1610 is the new data in the drive buffer (new data) 1602 and the set of coefficients extracted from the coefficient table 1605. The output of the CF 1610 is the calculation result of the CF 1610. At 1613, the controller 110 of the storage device 100a stores the calculation result of the CF 1610 in the drive buffer (result) 1603. In the example where the drive buffer (result) 1603 is the buffer 112, the host 101 or the other of the storage devices 100 can retrieve the calculation result from the drive buffer (result) 1603.

[0149] Figure 16B is a flow chart illustrating an example method 1600b for performing CF in a write operation according to some embodiments. Figure 1 、 16A 16B, method 1600b corresponds to method 1600a. Method 1600b may be executed by the controller 110 of the storage device 100a.

[0150] At 1621, the controller 110 receives a comment write command from the host 101 operatively coupled to the storage device 100a. The comment write command identifies the CF 1610 to be executed. At 1622, in response to receiving the comment write command, the controller 110 transfers new data from the host 101 (e.g., from host buffer (new data) 1601) to the drive buffer (e.g., drive buffer (new data) 1602) of the storage device 100a across the bus 105 and via the interface 140. At 1623, the controller 110 reads the stored coefficient data from the coefficient table 1605. As described, the stored coefficient data and the new data have different logical addresses.

[0151] At 1624, controller 110 executes CF 1610 on the new data and the old data to determine the calculation results. The transfer of new data from host 101 at 1622 and the extraction of coefficient data at 1623 can be performed incrementally based on one or more transfer unit sizes. Thus, CF 1610 can be performed incrementally for some of the new data already received in drive buffer (new data) 1602 and some of the corresponding coefficient data already read from coefficient table 1605, while the remaining new data is still being transferred to drive buffer (new data) 1602 and the remaining coefficient data is still being read. Thus, CF 1610 can be executed concurrently and in real time as new data is received, as old data is read, and as the calculation results are stored in drive buffer (result) 1603. At 1625, controller 110 of storage device 100a stores the calculation results of CF 1610 in a result drive buffer (e.g., drive buffer (result) 1603).

[0152] Figure 17A is a block diagram illustrating an example method 1700a for performing CF in a write operation according to some embodiments. Figure 1 and 17A , method 1700a can be performed by host 101 and storage device 100a. One of buffers 103, 107, or 109 includes host buffer (new data) 1701. Each of drive buffer (new data) 1702 and drive buffer (result) 1703 can be write buffer 114 or buffer 112. In some examples, drive buffer (new data) 1702 and drive buffer (result) 1703 are the same buffer (e.g., the same write buffer 114 or the same buffer 112) to save buffer resources. In some examples, drive buffer (stored data) 1705 can be buffer 112, write buffer 114, or read buffer 116 of storage device 100a. In method 1700a, controller 110 of storage device 100a performs CF 1710 on the new data received from host 101 and the stored data stored in drive buffer (stored data) 1705. The logical address corresponding to the new data is different from the logical address corresponding to the stored data. Neither the calculation result of the CF 1710 nor the new data is stored in the NVM (eg, the memory array 120) of the storage device 100a.

[0153] In method 1700a, host 101 submits a comment write command to controller 110 of storage device 100a over bus 105 and via interface 170. The comment write command includes a comment or indication identifying the type of CF 1710 to be performed on new data stored in host buffer (new data) 1701 and stored data stored in drive buffer (stored data) 1705. The comment write command identifies the new data using an address on bus 105 corresponding to host buffer (new data) 1701). The comment write command may also identify the logical address or buffer address of the stored data (of drive buffer (stored data) 1705).

[0154] The host 101 presents the host buffer (new data) 1701 to the controller 110 for writing. In response, at 1711, the controller 110 performs a data transfer to obtain the new data from the host buffer (new data) 1701 across the interface 140 through the bus 105 and stores the new data in the drive buffer (new data) 1702. At 1712, the controller 110 of the storage device 100a performs a buffer fetch to fetch the stored data from the drive buffer (stored data) 1705.

[0155] The controller 110 of the storage device 100a executes CF 1710 on the new data in the drive buffer (new data) 1702 and the stored data extracted from the drive buffer (stored data) 1705. The input of CF 1710 is the new data in the drive buffer (new data) 1702 and the stored data extracted from the drive buffer (stored data) 1705. The output of CF 1710 is the calculation result of CF 1710. At 1713, the controller 110 of the storage device 100a stores the calculation result of CF 1710 in the drive buffer (result) 1703.

[0156] Figure 17B is a flow chart illustrating an example method 1700b for performing CF in a write operation according to some embodiments. Figure 1 、 17A 17B, ​​method 1700b corresponds to method 1700a. Method 1700b may be executed by the controller 110 of the storage device 100a.

[0157] At 1721, the controller 110 receives a comment write command from the host 101 operatively coupled to the storage device 100a. The comment write command identifies the CF 1710 to be executed and the address of the stored data. At 1722, in response to receiving the comment write command, the controller 110 transfers the new data from the host 101 (e.g., from host buffer (new data) 1701) to the drive buffer (e.g., drive buffer (new data) 1702) of the storage device 100a across the bus 105 and via the interface 140. At 1723, the controller 110 extracts the stored data from the drive buffer (stored data) 1705.

[0158] At 1724, controller 110 executes CF 1710 on the new data and the stored data to determine the calculation results. The transfer of new data from host 101 at 1722 and the retrieval of stored data at 1723 can be performed incrementally based on one or more transfer unit sizes. Thus, CF 1710 can be executed incrementally for some of the new data already received in drive buffer (new data) 1702 and some of the corresponding stored data already retrieved from drive buffer (stored data) 1705, while the remainder of the new data is still being transferred to drive buffer (new data) 1702 and the remainder of the stored data is still being retrieved. Thus, CF 1710 can be executed concurrently and in real time as new data is received, stored data is retrieved, and calculation results are stored in drive buffer (result) 1703. At 1725, controller 110 of storage device 100a stores the calculation results of CF 1710 in a result drive buffer (e.g., drive buffer (result) 1703).

[0159] Figure 18A is a block diagram illustrating an example method 1800a for performing CF in a read operation according to some embodiments. Figure 1 and 18AMethod 1800a can be performed by host 101 and storage device 100a. One of buffers 103, 107, or 109 includes host buffer (result) 1801. NVM (saved data) 1804 refers to a memory location in memory array 120 of storage device 100a. In some examples, drive buffer (result) 1803 is a read buffer 116 used to temporarily store the calculation result of CF 1810, while drive buffer (result) 1802 is a buffer 112 used to transfer the calculation result to host buffer (result) 1801. In other examples, drive buffer (result) 1803 is not used, and the calculation result is directly stored by drive buffer (result) 1802 as buffer 112. In method 1800a, controller 110 of storage device 100a executes CF 1810 on the saved data stored in memory array 120, and the calculation result of CF 1810 is transferred to host 101. According to the sample form of CF discussed previously, method 1800a corresponds to a read with CF, where Operand1 is the location of host buffer 1801, Operand2 is the logical address of NVM (saved data) 1804, and OTYPE indicates that the logical address in Operand2 is used as an input parameter and Operand1 is used as an output parameter. In other words, the calculation function CF 1810 operates on the saved data at Operand2 and writes the calculation result to Operand1.

[0160] In method 1800a, host 101 submits a comment read command to controller 110 of storage device 100a via bus 105 and interface 140. The comment read command includes a comment or indication identifying the type of CF 1810 to be executed and identifying the logical address of the saved data. In response, at 1811, controller 110 of storage device 100a reads the saved data corresponding to the logical address from NVM (saved data) 1804. In other words, controller 110 of storage device 100a reads the saved data requested in the comment read command from memory array 120 (one or more of NAND flash memory devices 130a to 130n).

[0161] Controller 110 of storage device 100a executes CF 1810 on the saved data. The input of CF 1810 is the saved data read from NVM (saved data) 1804, and the output of CF 1810 is the calculation result of CF 1810. At 1812, controller 110 of storage device 100a stores the calculation result of CF 1810 in drive buffer (result) 1803. At 1813, controller 110 of storage device 100a may send the calculation result to drive buffer (result) 1802. At 1814, the calculation result is sent from drive buffer (result) 1802 to host buffer (result) 1801. For example, controller 110 may transfer the result from drive buffer (result) 1802 to host buffer (result) 1801 across interface 140. In some examples, the calculation result provided to host 101 corresponds to the logical address included in the annotated read command. In other words, the calculation result is provided back to the host 101 as read data.

[0162] Figure 18B is a flow chart illustrating an example method 1800b for performing CF in a read operation according to some embodiments. Figure 1 、 18A 18B, method 1800b corresponds to method 1800a. Method 1800b may be executed by the controller 110 of the storage device 100a.

[0163] At 1821, controller 110 receives a note read command from host 101 operatively coupled to storage device 100a. The note read command identifies the CF 1810 to be executed and includes the logical address of the stored data. At 1822, in response to receiving the note read command, controller 110 reads the stored data corresponding to the logical address from NVM (saved data) 1804. At 1823, controller 110 executes CF 1810 on the stored data to determine a calculation result. At 1824, controller 110 stores the calculation result in a drive buffer. For example, controller 110 may store the calculation result in drive buffer (result) 1803 and then transfer the calculation result to drive buffer (result) 1802. Alternatively, controller 110 may store the calculation result directly in drive buffer (result) 1802. At 1825, controller 110 transfers the calculation result to host 101 (e.g., to host buffer (result) 1801).

[0164] Reading the saved data from NVM (saved data) 1804 at 1822 can be performed incrementally based on the transfer unit size. Thus, CF 1810 can be executed incrementally for some of the saved data that has been read from NVM (saved data) 1804 while the remaining saved data is still being read. Thus, CF 1810 can be executed concurrently and in real time as saved data is read and calculation results are stored in drive buffer (result) 1803 or 1802.

[0165] Figure 19A is a block diagram illustrating an example method 1900a for performing CF in a read operation according to some embodiments. Figure 1 and 19A Method 1900a can be performed by host 101 and storage device 100a. One of buffers 103, 107, or 109 includes host buffer (saved data) 1901. NVM (saved data) 1904 refers to a memory location in memory array 120 of storage device 100a. Each of drive buffer (result) 1903 and drive buffer (saved data) 1902 is read buffer 116 or buffer 112. In some implementations, drive buffer (result) 1903 can be the same as drive buffer (saved data) 1902 to conserve buffer resources. In method 1900a, controller 110 of storage device 100a performs CF 1910 on the saved data stored in memory array 120 after the saved data is transferred to host 101. According to the sample form of CF discussed previously, method 1900a corresponds to a read with CF, where Operand1 is a location in host buffer 1901, Operand2 is a logical address of NVM (saved data) 1904, and OTYPE indicates that the logical address in Operand2 is used as an input parameter, Operand1 is used as an output parameter, and the calculation result is stored in temporary drive buffer 1903. In other words, the calculation function CF 1910 operates on the saved data at Operand2, writes the saved data to Operand1, and writes the calculation result to the temporary buffer.

[0166] In method 1900a, host 101 submits a comment read command to controller 110 of storage device 100a via bus 105 and interface 140. The comment read command includes a comment or indication identifying the type of CF 1910 to be executed and identifying the logical address of the saved data. In response, at 1911, controller 110 of storage device 100a reads the saved data corresponding to the logical address from NVM (saved data) 1904 into drive buffer (saved data) 1902. In other words, controller 110 of storage device 100a reads the saved data requested in the comment read command from memory array 120 (one or more of NAND flash memory devices 130a to 130n).

[0167] At 1912, the saved data is sent from the drive buffer (saved data) 1902 to the host buffer (saved data) 1901. For example, the controller 110 may transfer the saved data from the drive buffer (saved data) 1902 to the host buffer (saved data) 1901 across the interface 140. The saved data provided to the host 101 corresponds to the logical address included in the annotate read command.

[0168] After 1912, the controller 110 of the storage device 100a executes CF 1910 on the saved data stored in the drive buffer (saved data) 1902. The input of CF 1910 is the saved data, and the output of CF 1910 is the calculation result of CF 1910. At 1913, the controller 110 of the storage device 100a stores the calculation result of CF 1910 in the drive buffer (result) 1903. In other examples, the saved data is sent from the drive buffer (saved data) 1902 to the host buffer (saved data) 1901 while (in parallel or simultaneously) or after CF 1910 is executed.

[0169] Figure 19B is a flow chart illustrating an example method 1900b for performing CF in a read operation according to some embodiments. Figure 1 、 19A 19B, method 1900b corresponds to method 1900a. Method 1900b may be executed by the controller 110 of the storage device 100a.

[0170] At 1921, the controller 110 receives a comment read command from the host 101 operatively coupled to the storage device 100a. The comment read command identifies the CF 1910 to be executed and includes the logical address of the saved data. At 1922, in response to receiving the comment read command, the controller 110 reads the saved data corresponding to the logical address from the NVM (saved data) 1904 into the saved data drive buffer (drive buffer (saved data) 1902). At 1923, the controller 110 transfers the saved data from the saved data drive buffer to the host 101 to the host buffer (saved data) 1901. After 1923, the controller 110 executes CF 1910 on the saved data at 1924 to determine the calculation result. In other examples, before or during execution of 1923, the controller 110 executes CF 1910 on the saved data to determine the calculation result. At 1925 , the controller 110 stores the calculation results in a result drive buffer (eg, drive buffer (result) 1903 ) for later retrieval.

[0171] The reading of saved data from NVM (saved data) 1904 at 1922 and the transfer of saved data to host 101 at 1923 can be performed incrementally based on one or more transfer unit sizes. Thus, CF 1910 can be executed incrementally for some saved data that has already been read from NVM (saved data) 1904 while the remaining saved data is still being read. Thus, CF 1910 can be executed concurrently and in real time as saved data is read and transferred to host 101 and as calculation results are stored in drive buffer (result) 1903.

[0172] Figure 20A is a block diagram illustrating an example method 2000a for performing CF in a read operation according to some embodiments. Figure 1 and 20AMethod 2000a can be performed by host 101 and storage device 100a. One of buffers 103, 107, or 109 includes host buffer (result) 2001. NVM (saved data) 2004 refers to a first memory location in memory array 120 of storage device 100a. NVM (stored data) 2005 refers to a second memory location in memory array 120 of storage device 100a. In some examples, drive buffer (result) 2003 is a read buffer 116 for temporarily storing the calculation result of CF 2010, and drive buffer (result) 2002 is a buffer 112 for transferring the calculation result to host buffer (result) 2001. In other examples, drive buffer (result) 2003 is not used, and the calculation result is directly stored by drive buffer (result) 2002 as buffer 112. In method 2000a, controller 110 of storage device 100a executes CF 2010 on saved data and stored data stored in different memory locations in memory array 120, and the calculation result of CF 2010 is transmitted to host 101. The saved data saved in NVM (saved data) 2004 and the stored data saved in NVM (stored data) 2005 correspond to different logical addresses.

[0173] In method 2000a, host 101 submits a comment read command to controller 110 of storage device 100a via bus 105 and interface 140. The comment read command includes a comment or indication identifying the type of CF 2010 performed on the saved data and the stored data. The comment read command identifies the saved data using a first logical address and a first number of logical blocks and identifies the stored data using a second logical address and a second number of logical blocks. The comment read command may further include a flag or indication specifying the address (e.g., a PCIe address) of host buffer (result) 2001 into which the calculation result of CF 2010 is to be written.

[0174] In response, at 2011, the controller 110 of the storage device 100a reads the stored data corresponding to the first logical address from the NVM (saved data) 2004. In other words, the controller 110 of the storage device 100a reads the stored data requested in the comment read command from the first physical location of the memory array 120 (one or more of the NAND flash memory devices 130a to 130n). At 2012, the controller 110 of the storage device 100a reads the stored data corresponding to the second logical address from the NVM (stored data) 2005. In other words, the controller 110 of the storage device 100a reads the stored data requested in the comment read command from the second physical location of the memory array 120 (one or more of the NAND flash memory devices 130a to 130n).

[0175] The controller 110 of the storage device 100a executes CF 2010 on the saved data and the stored data. The inputs to CF 2010 are the saved data read from NVM (saved data) 2004 and the stored data read from NVM (stored data) 2005. The output of CF 2010 is the calculation result of CF 2010. At 2013, the controller 110 of the storage device 100a stores the calculation result of CF 2010 in drive buffer (result) 2003. At 2014, the controller 110 of the storage device 100a may send the calculation result to drive buffer (result) 2002. At 2015, the calculation result is sent from drive buffer (result) 2002 to host buffer (result) 2001. For example, the controller 110 may transfer the calculation result from drive buffer (result) 2002 to host buffer (result) 2001 across interface 140. In some examples, the calculation result provided to host 101 corresponds to a first logical address included in the annotation read command. In some examples, the calculation result provided to host 101 corresponds to a second logical address or another logical address included in the annotation read command.

[0176] Figure 20B is a flow chart illustrating an example method 2000b for performing CF in a read operation according to some embodiments. Figure 1 、 20A 20B, the method 2000b corresponds to the method 2000a. The method 2000b may be executed by the controller 110 of the storage device 100a.

[0177] At 2021, controller 110 receives a comment read command from host 101 operatively coupled to storage device 100a. The comment read command identifies the CF 2010 to be executed and includes a first logical address of saved data, a second logical address of stored data, and a flag or indication specifying the address (e.g., a PCIe address) of host buffer (result) 2001 to which the calculation result of CF 2010 is to be transferred. In response to receiving the comment read command, controller 110 reads the saved data corresponding to the first logical address from NVM (saved data) 2004 at 2022 and reads the stored data corresponding to the second logical address from NVM (stored data) 2005 at 2023. At 2024, controller 110 executes CF 2010 on the saved data and stored data to determine the calculation result. At 2025, controller 110 stores the calculation result in the drive buffer. For example, the controller 110 may store the calculation result in the drive buffer (result) 2003 and then transfer the calculation result to the drive buffer (result) 2002. Alternatively, the controller 110 may store the calculation result directly in the drive buffer (result) 2002. At 2026, the controller 110 transfers the calculation result to the host 101 (e.g., to the host buffer (result) 2001).

[0178] The reading of the saved data and the stored data at 2022 and 2023 can be performed incrementally based on the transfer unit size. Thus, CF 2010 can be executed incrementally for some of the saved data and corresponding stored data that have already been read, while the remaining saved data and stored data are still being read. Thus, CF 2010 can be executed concurrently and in real time as the saved data and stored data are read and as the calculation results are stored in the drive buffer (result) 2003 or 2002 and transferred to the host 101.

[0179] Figure 21A is a block diagram illustrating an example method 2100a for performing CF in a read operation according to some embodiments. Figure 1 and 21AMethod 2100a can be performed by host 101 and storage device 100a. One of buffers 103, 107, or 109 includes host buffer (saved data) 2101. NVM (saved data) 2104 refers to a first memory location in memory array 120 of storage device 100a. NVM (stored data) 2105 refers to a second memory location in memory array 120 of storage device 100a. Each of drive buffer (result) 2103 and drive buffer (saved data) 2102 is read buffer 116 or buffer 112. In some implementations, drive buffer (result) 2303 can be the same as drive buffer (saved data) 2102 to conserve buffer resources. In method 2100a, after the saved data is provided to host 101, controller 110 of storage device 100a performs CF 2110 on the saved data and stored data stored in different memory locations in memory array 120. The saved data saved in the NVM (saved data) 2104 and the stored data saved in the NVM (stored data) 2105 correspond to different logical addresses.

[0180] In method 2100a, host 101 submits a comment read command to controller 110 of storage device 100a via bus 105 and interface 140. The comment read command includes a comment or indication identifying the type of CF 2110 to be executed. The comment read command identifies the saved data using a first logical address and a first number of logical blocks and identifies the stored data using a second logical address and a second number of logical blocks. The comment read command may further include a flag or indication specifying the address (e.g., a PCIe address) of host buffer (result) 2101 into which the calculation result of CF 2110 is to be written.

[0181] In response, at 2111, the controller 110 of the storage device 100a reads the saved data corresponding to the first logical address from the NVM (saved data) 2104 into the drive buffer (saved data) 2102. In other words, the controller 110 of the storage device 100a reads the saved data requested in the annotated read command from the memory array 120 (one or more of the NAND flash memory devices 130a through 130n).

[0182] At 2112, the saved data is sent from the drive buffer (saved data) 2102 to the host buffer (saved data) 2101. For example, the controller 110 may transfer the saved data from the drive buffer (saved data) 2102 to the host buffer (saved data) 2101 across the interface 140. The saved data provided to the host 101 corresponds to the logical address included in the annotate read command.

[0183] After 2112, at 2113, the controller 110 of the storage device 100a reads the stored data corresponding to the second logical address from the NVM (stored data) 2105. In other words, the controller 110 of the storage device 100a reads the stored data requested in the annotated read command from the second physical location of the memory array 120 (one or more of the NAND flash memory devices 130a to 130n). In other examples, the saved data is sent from the drive buffer (saved data) 2102 to the host buffer (saved data) 2101 while (in parallel or simultaneously) or after the CF 2110 is executed.

[0184] The controller 110 of the storage device 100a executes CF 2110 on the saved data and the stored data. The input of CF 2110 is the saved data read from NVM (saved data) 2104 and the stored data read from NVM (stored data) 2105. The output of CF 2110 is the calculation result of CF 2110. At 2114, the controller 110 of the storage device 100a stores the calculation result of CF 2110 in the drive buffer (result) 2103.

[0185] Figure 21B is a flow chart illustrating an example method 2100b for performing CF in a read operation according to some embodiments. Figure 1 、 21A 21B, the method 2100b corresponds to the method 2100a. The method 2100b may be executed by the controller 110 of the storage device 100a.

[0186] At 2121, the controller 110 receives a note read command from the host 101 operatively coupled to the storage device 100a. The note read command identifies the CF 2110 to be executed and includes a first logical address of the saved data, a second logical address of the stored data, and a flag or indication specifying the address (e.g., a PCIe address) of the host buffer (result) 2101 to which the saved data is to be transferred. At 2122, in response to receiving the note read command, the controller 110 reads the saved data corresponding to the first logical address from the NVM (saved data) 2104 into a saved data drive buffer (drive buffer (saved data) 2102). At 2123, the controller 110 transfers the saved data from the saved data drive buffer to the host 101 to the host buffer (saved data) 2101. At 2124, the controller 110 reads the stored data corresponding to the second logical address from the NVM (stored data) 2105. After 2123, the controller 110 executes CF 2110 on the saved data and the stored data to determine the calculation result at 2125. In other examples, the controller 110 executes CF 2110 before or while (in parallel or simultaneously) transferring the data at 2123. At 2126, the controller 110 stores the calculation result in a result drive buffer (e.g., drive buffer (result) 2103) for later retrieval.

[0187] The reading of the saved data and the stored data at 2122 and 2124 and the transfer of the saved data to the host 101 at 2123 can be performed incrementally based on one or more transfer unit sizes. Thus, CF 2110 can be executed incrementally for some of the saved data and corresponding stored data that have already been read, while the remaining portion of the saved data and stored data is still being read. Thus, CF 2110 can be executed concurrently and in real time as the saved data and stored data are read and as the saved data is transferred to the host buffer (saved data) 2101.

[0188] Figure 22A is a block diagram illustrating an example method 2200a for performing CF in a read operation according to some embodiments. Figure 1 and 22AMethod 2200a can be performed by host 101 and storage device 100a. One of buffers 103, 107, or 109 includes host buffer (result) 2201. NVM (saved data) 2204 refers to a memory location in memory array 120 of storage device 100a. Coefficient table 2205 refers to a memory location in memory array 120 of storage device 100a or another suitable memory unit of storage device 100a. In some examples, drive buffer (result) 2203 is a read buffer 116 for temporarily storing the calculation results of CF 2210, while drive buffer (result) 2202 is a buffer 112 for transferring the calculation results to host buffer (result) 2201. In other examples, drive buffer (result) 2203 is not used, and the calculation results are directly stored by drive buffer (result) 2202 as buffer 112. In method 2200a, controller 110 of storage device 100a performs a calculation 2210 on the saved data and the data (e.g., a set of coefficients) stored in coefficient table 2205. The calculation result of CF 2210 is transmitted to host 101 at the address specified by the comment read command. The saved data and the coefficient data correspond to different logical addresses. In some examples, the logical address where the calculation result is to be stored is the same as the logical address of the saved data.

[0189] In method 2200a, host 101 submits a comment read command to controller 110 of storage device 100a via bus 105 and interface 140. The comment read command includes a comment or indication identifying the type of CF 2210 to be executed. The comment read command identifies the stored data using a first logical address and a first number of logical blocks. The comment read command identifies the address (e.g., logical address) of coefficient table 2205 using a second logical address and a second number of logical blocks. The comment read command may further include a flag or indication specifying the address (e.g., PCIe address) of host buffer (result) 2201 into which the calculation result of CF 2210 is to be written.

[0190] In response, at 2211, the controller 110 of the storage device 100a reads the stored data corresponding to the first logical address from the NVM (stored data) 2204. In other words, the controller 110 of the storage device 100a reads the stored data requested in the annotation read command from a first physical location of the memory array 120 (one or more of the NAND flash memory devices 130a through 130n). At 2212, the controller 110 of the storage device 100a performs a table fetch to retrieve a set of coefficients from the coefficient table 2205. In other words, the controller 110 of the storage device 100a reads the coefficient data requested in the annotation read command from a second physical location of the memory array 120 (one or more of the NAND flash memory devices 130a through 130n).

[0191] The controller 110 of the storage device 100a executes a CF 2210 on the saved data and coefficient data. The inputs to the CF 2210 are the saved data read from the NVM (saved data) 2204 and the coefficient data read from the coefficient table 2205. The output of the CF 2210 is the calculation result of the CF 2210. At 2213, the controller 110 of the storage device 100a stores the calculation result of the CF 2210 in the drive buffer (result) 2203. At 2214, the controller 110 of the storage device 100a may send the calculation result to the drive buffer (result) 2202. At 2215, the calculation result is sent from the drive buffer (result) 2202 to the host buffer (result) 2201. For example, the controller 110 may transfer the calculation result from the drive buffer (result) 2202 to the host buffer (result) 2201 across the interface 140. In some examples, the calculation result provided to host 101 corresponds to the first logical address or another logical address included in the annotation read command.

[0192] Figure 22B is a flow chart illustrating an example method 2200b for performing CF in a read operation according to some embodiments. Figure 1 、 22A 22B, the method 2200b corresponds to the method 2200a. The method 2200b may be executed by the controller 110 of the storage device 100a.

[0193] At 2220, the controller 110 receives a comment read command from the host 101 operatively coupled to the storage device 100a. The comment read command identifies the CF 2210 to be executed and includes a first logical address for the saved data, a second logical address for the coefficient data, and a flag or indication specifying the address (e.g., a PCIe address) of the host buffer (result) 2201 to which the calculation results of the CF 2210 are to be transferred. In response to receiving the comment read command, the controller 110 reads the saved data corresponding to the first logical address from the NVM (saved data) 2204 at 2222 and the coefficient data corresponding to the second logical address from the coefficient table 2205 at 2223. At 2224, the controller 110 executes the CF 2210 on the saved data and the coefficient data to determine the calculation results. At 2225, the controller 110 stores the calculation results in the drive buffer. For example, the controller 110 may store the calculation result in the drive buffer (result) 2203 and then transfer the calculation result to the drive buffer (result) 2202. Alternatively, the controller 110 may store the calculation result directly in the drive buffer (result) 2202. At 2226, the controller 110 transfers the calculation result to the host 101 (e.g., to the host buffer (result) 2201).

[0194] The reading of the saved data and coefficient data at 2222 and 2223 can be performed incrementally based on the transfer unit size. Thus, CF 2210 can be executed incrementally for some of the saved data and corresponding coefficient data that have already been read, while the remaining saved data and coefficient data are still being read. Thus, CF 2210 can be executed concurrently and in real time as the saved data and coefficient data are read and as calculation results are stored in drive buffer (result) 2203 or 2202 and transferred to host 101.

[0195] Figure 23A is a block diagram illustrating an example method 2300a for performing CF in a read operation according to some embodiments. Figure 1 and 23AMethod 2300a can be performed by host 101 and storage device 100a. One of buffers 103, 107, or 109 includes host buffer (saved data) 2301. NVM (saved data) 2304 refers to a memory location in memory array 120 of storage device 100a. Coefficient table 2205 refers to a memory location in memory array 120 of storage device 100a or another suitable memory unit of storage device 100a. Each of drive buffer (result) 2303 and drive buffer (saved data) 2302 is read buffer 116 or buffer 112. In some implementations, drive buffer (result) 2303 can be the same as drive buffer (saved data) 2302 to conserve buffer resources. In method 2300a, after the saved data is provided to host 101, controller 110 of storage device 100a performs CF 2310 on the saved data and the data stored in coefficient table 2205 (e.g., a set of coefficients). The stored data and coefficient data correspond to different logical addresses.

[0196] In method 2300a, host 101 submits a comment read command to controller 110 of storage device 100a via bus 105 and interface 140. The comment read command includes a comment or indication identifying the type of CF 2310 to be executed. The comment read command identifies the saved data using a first logical address and a first number of logical blocks. The comment read command identifies the address (e.g., logical address) of coefficient table 2305 using a second logical address and a second number of logical blocks. The comment read command may further include a flag or indication specifying the address (e.g., PCIe address) of host buffer (result) 2301 to which the saved data is to be written.

[0197] In response, at 2311, the controller 110 of the storage device 100a reads the saved data corresponding to the first logical address from the NVM (saved data) 2304 into the drive buffer (saved data) 2302. In other words, the controller 110 of the storage device 100a reads the saved data requested in the annotated read command from the memory array 120 (one or more of the NAND flash memory devices 130a through 130n).

[0198] At 2312, the saved data is sent from the drive buffer (saved data) 2302 to the host buffer (saved data) 2301. For example, the controller 110 may transfer the saved data from the drive buffer (saved data) 2302 to the host buffer (saved data) 2301 across the interface 140. The saved data provided to the host 101 corresponds to the logical address included in the annotated read command.

[0199] Following 2312, the controller 110 of the storage device 100a performs a table fetch at 2313 to retrieve a set of coefficients in the coefficient table 2305. In other words, the controller 110 of the storage device 100a reads the coefficient data requested in the annotated read command from a second physical location of the memory array 120 (one or more of the NAND flash memory devices 130a-130n).

[0200] The controller 110 of the storage device 100a executes CF 2310 on the stored data and coefficient data. The input of CF 2310 is the stored data read from NVM (stored data) 2304 and the coefficient data read from coefficient table 2305. The output of CF 2310 is the calculation result of CF 2310. At 2314, the controller 110 of the storage device 100a stores the calculation result of CF 2310 in the drive buffer (result) 2303.

[0201] Figure 23B is a flow chart illustrating an example method 2300b for performing CF in a read operation according to some embodiments. Figure 1 、 23A 23B, the method 2300b corresponds to the method 2300a. The method 2300b may be executed by the controller 110 of the storage device 100a.

[0202] At 2323, the controller 110 receives a comment read command from the host 101 operatively coupled to the storage device 100a. The comment read command identifies the CF 2310 to be executed and includes a first logical address of the saved data, a second logical address of the coefficient data, and a flag or indication specifying the address (e.g., a PCIe address) of the host buffer (result) 2301 to which the saved data is to be transferred. At 2322, in response to receiving the comment read command, the controller 110 reads the saved data corresponding to the first logical address from the NVM (saved data) 2304 into a saved data drive buffer (drive buffer (saved data) 2302). At 2323, the controller 110 transfers the saved data from the saved data drive buffer to the host 101 to the host buffer (saved data) 2301. At 2324, the controller 110 reads the coefficient data corresponding to the second logical address from the coefficient table 2305. After 2312, the controller 110 executes CF 2310 on the saved data and coefficient data to determine the calculation result at 2325. In other examples, the controller 110 executes CF 2310 before or during (parallel or simultaneous) execution of CF 2310. At 2326, the controller 110 stores the calculation result in a result drive buffer (e.g., drive buffer (result) 2303) for later retrieval.

[0203] The reading of the saved data and coefficient data at 2322 and 2324 and the transfer of the saved data to the host 101 at 2323 can be performed incrementally based on one or more transfer unit sizes. Thus, CF 2310 can be performed incrementally for some of the saved data and corresponding coefficient data that have been read while the remaining portion of the saved data and coefficient data is still being read. Thus, CF 2310 can be executed concurrently and in real time as the saved data and coefficient data are read and as the saved data is transferred to the host buffer (saved data) 2301.

[0204] Figure 24A is a block diagram illustrating an example method 2400a for performing CF in a read operation according to some embodiments. Figure 1 and 24A Method 2400a can be performed by host 101 and storage device 100a. One of buffers 103, 107, or 109 includes host buffer (result) 2401. NVM (saved data) 2404 refers to a memory location in memory array 120 of storage device 100a. Drive buffer (stored data) 2405 can be buffer 112, write buffer 114, or read buffer 116 of storage device 100a. In some examples, drive buffer (result) 2403 is read buffer 116 for temporarily storing calculation results of CF 2410, while drive buffer (result) 2402 is buffer 112 for transferring the calculation results to host buffer (result) 2401. In other examples, drive buffer (result) 2403 is not used, and the calculation results are directly stored by drive buffer (result) 2402 as buffer 112. In method 2400a, controller 110 of storage device 100a performs CF 2410 on saved data in a memory location in memory array 120 and stored data in a buffer, and the calculation result of CF 2410 is transmitted to host 101. The saved data saved in NVM (saved data) 2404 and the stored data saved in drive buffer (stored data) 2405 correspond to different logical addresses.

[0205] In method 2400a, host 101 submits a comment read command to controller 110 of storage device 100a via bus 105 and interface 140. The comment read command includes a comment or indication identifying the type of CF 2410 performed on the saved data and the stored data. The comment read command identifies the saved data using a first logical address and a first number of logical blocks. The comment read command identifies the stored data using a second logical address and a second number of logical blocks. Alternatively, the comment read command identifies the stored data using a buffer address of the stored data (of drive buffer (stored data) 2405). The comment read command may further include a flag or indication specifying the address (e.g., a PCIe address) of host buffer (result) 2401 to which the calculation result of CF 2410 is to be transferred.

[0206] In response, at 2411, the controller 110 of the storage device 100a reads the stored data corresponding to the first logical address from the NVM (saved data) 2404. In other words, the controller 110 of the storage device 100a reads the stored data requested in the annotated read command from the physical location of the memory array 120 (one or more of the NAND flash memory devices 130a to 130n). At 2412, the controller 110 of the storage device 100a performs a buffer fetch to fetch the stored data from the drive buffer (stored data) 2405 using the second logical address or buffer address.

[0207] The controller 110 of the storage device 100a executes a CF 2410 on the saved data and the stored data. The inputs to the CF 2410 are the saved data read from the NVM (saved data) 2404 and the stored data read from the drive buffer (stored data) 2405. The output of the CF 2410 is the calculation result of the CF 2410. At 2413, the controller 110 of the storage device 100a stores the calculation result of the CF 2410 in the drive buffer (result) 2403. At 2414, the controller 110 of the storage device 100a may send the calculation result to the drive buffer (result) 2402. At 2415, the calculation result is sent from the drive buffer (result) 2402 to the host buffer (result) 2401. For example, the controller 110 may transfer the calculation result from the drive buffer (result) 2402 to the host buffer (result) 2401 across the interface 140. In some examples, the calculation result provided to host 101 corresponds to the first logical address included in the annotation read command.

[0208] Figure 24B is a flow chart illustrating an example method 2400b for performing CF in a read operation according to some embodiments. Figure 1 、 24A24B, the method 2400b corresponds to the method 2400a. The method 2400b may be executed by the controller 110 of the storage device 100a.

[0209] At 2421, the controller 110 receives a note read command from the host 101 operatively coupled to the storage device 100a. The note read command identifies the CF 2410 to be executed and includes a first logical address of the saved data, a second logical address or buffer address of the stored data, and an indication of the address (e.g., a PCIe address) of the host buffer (result) 2401 to which the calculation result of the CF 2410 is to be transferred. In response to receiving the note read command, the controller 110 reads the saved data corresponding to the first logical address from the NVM (saved data) 2404 at 2422. At 2423, the controller 110 extracts the stored data corresponding to the second logical address or buffer address from the drive buffer (stored data) 2405.

[0210] At 2424, the controller 110 executes CF 2410 on the saved data and the stored data to determine a calculation result. At 2425, the controller 110 stores the calculation result in a drive buffer. For example, the controller 110 may store the calculation result in drive buffer (result) 2403 and then transfer the calculation result to drive buffer (result) 2402. Alternatively, the controller 110 may store the calculation result directly in drive buffer (result) 2402. At 2426, the controller 110 transfers the calculation result to the host 101 (e.g., to host buffer (result) 2401).

[0211] Reading the saved data and stored data at 2422 and 2423 can be performed incrementally based on the transfer unit size. Thus, CF 2410 can be executed incrementally for some of the saved data and corresponding stored data that have already been read, while the remaining saved data and stored data are still being read. Thus, CF 2410 can be executed concurrently and in real time as the saved data and stored data are read and as calculation results are stored in drive buffer (result) 2403 or 2402 and transferred to host 101.

[0212] Figure 25A is a block diagram illustrating an example method 2500a for performing CF in a read operation according to some embodiments. Figure 1 and 25AMethod 2500a can be performed by host 101 and storage device 100a. One of buffers 103, 107, or 109 includes host buffer (saved data) 2501. NVM (saved data) 2504 refers to a memory location in memory array 120 of storage device 100a. Drive buffer (stored data) 2505 can be buffer 112, write buffer 114, or read buffer 116 of storage device 100a. Each of drive buffer (result) 2503 and drive buffer (saved data) 2502 is read buffer 116 or buffer 112. In some implementations, drive buffer (result) 2503 can be the same as drive buffer (saved data) 2502 to conserve buffer resources. In method 2500a, after the saved data is transferred to host 101, controller 110 of storage device 100a performs CF 2510 on the saved data in the memory location in memory array 120 and the stored data in the buffer. In other examples, the controller 110 executes the CF 2510 before or when (in parallel or simultaneously) the saved data is transferred to the host 101. The saved data saved in the NVM (saved data) 2504 and the stored data saved in the drive buffer (stored data) 2505 correspond to different logical addresses.

[0213] In method 2500a, host 101 submits a comment read command to controller 110 of storage device 100a via bus 105 and interface 140. The comment read command includes a comment or indication identifying the type of CF 2510 to be executed. The comment read command identifies the saved data using a first logical address and a first number of logical blocks. The comment read command identifies the stored data using a second logical address and a second number of logical blocks. Alternatively, the comment read command identifies the stored data using a buffer address of the stored data (of drive buffer (stored data) 2505). The comment read command may further include a flag or indication specifying the address (e.g., a PCIe address) of host buffer (result) 2501 to which the calculation result of CF 2510 is to be transferred.

[0214] In response, at 2511, the controller 110 of the storage device 100a reads the saved data corresponding to the first logical address from the NVM (saved data) 2504 into the drive buffer (saved data) 2502. In other words, the controller 110 of the storage device 100a reads the saved data requested in the annotated read command from the memory array 120 (one or more of the NAND flash memory devices 130a through 130n).

[0215] At 2512, the saved data is sent from the drive buffer (saved data) 2502 to the host buffer (saved data) 2501. For example, the controller 110 may transfer the saved data from the drive buffer (saved data) 2502 to the host buffer (saved data) 2501 across the interface 140. The saved data provided to the host 101 corresponds to the first logical address included in the annotated read command.

[0216] After 2512 , the controller 110 of the memory device 100 a performs a buffer fetch at 2513 to fetch the stored data from the drive buffer (stored data) 2505 using the second logical address or buffer address.

[0217] The controller 110 of the storage device 100a executes CF 2510 on the saved data and the stored data. The input of CF 2510 is the saved data read from the NVM (saved data) 2504 and the stored data extracted from the drive buffer (stored data) 2505. The output of CF 2510 is the calculation result of CF 2510. At 2514, the controller 110 of the storage device 100a stores the calculation result of CF 2510 in the drive buffer (result) 2503.

[0218] Figure 25B is a flow chart illustrating an example method 2500b for performing CF in a read operation according to some embodiments. Figure 1 、 25A 25B, method 2500b corresponds to method 2500a. Method 2500b may be executed by controller 110 of storage device 100a.

[0219] At 2521, the controller 110 receives a note read command from the host 101 operatively coupled to the storage device 100a. The note read command identifies the CF 2510 to be executed and includes a first logical address of the saved data, a second logical address or buffer address of the stored data, and an indication of the address (e.g., a PCIe address) of the host buffer (result) 2501 to which the saved data is to be transferred. At 2522, in response to receiving the note read command, the controller 110 reads the saved data corresponding to the first logical address from the NVM (saved data) 2504 into a saved data drive buffer (drive buffer (saved data) 2502). At 2523, the controller 110 transfers the saved data from the saved data drive buffer to the host 101 to the host buffer (saved data) 2501. At 2524, the controller 110 extracts the stored data corresponding to the second logical address or buffer address from the drive buffer (stored data) 2505. After 2523, the controller 110 executes CF 2510 on the saved data and the stored data to determine the calculation result at 2525. In other examples, the controller 110 executes CF 2510 before or at the same time as (in parallel or simultaneously with) the execution of 2423. At 2526, the controller 110 stores the calculation result in a result drive buffer (e.g., drive buffer (result) 2503) for later retrieval.

[0220] The reading of the saved data and the stored data at 2522 and 2524 and the transfer of the saved data to the host 101 at 2523 can be performed incrementally based on one or more transfer unit sizes. Thus, the CF 2510 can be incrementally executed for some of the saved data and corresponding stored data that have already been read, while the remaining portion of the saved data and stored data is still being read. Thus, the CF 2510 can be executed concurrently and in real time as the saved data and stored data are read and as the saved data is transferred to the host buffer (saved data) 2501.

[0221] Figure 26 is a flow chart illustrating an example method 2600 for performing CF according to some embodiments. Figures 1 to 26 , the method 2600 may be executed by the controller 110 of the storage device 100a.

[0222] At 2610, the controller 110 of the storage device 100a receives a command from the host 101. The command identifies a CF to be executed by the storage device 100a. The command may be a comment write command, a comment read command, or another comment command that identifies the CF to be executed. The CF includes at least one of the following: addition, subtraction, multiplication, division, or GF math / arithmetic operations; AND, OR, NAND, NOR, NOT (invert), or XOR logical operations; AND, OR, or XOR Boolean (true / false result) operations; logical shift, arithmetic shift, or rotate bitwise operations; greater than, less than, or not equal to comparison operations; copy, find, or compare string operations; AVG(), FIRST(), LAST(), MAX(), MIN(), SUM() database query language functions; Reed-Solomon or erasure coding operations; data encryption or database table operations.

[0223] In response to receiving the command, the controller 110 of the memory device 100 a performs CF on at least one of internal data stored in the memory device 100 a or external data transmitted from the host 1010 to determine a calculation result at 2620 .

[0224] exist Figures 4A to 17B In some examples shown in , the command is a write command that identifies external data (e.g., new data). In such examples, performing CF on at least one of the internal data or the external data includes performing CF on the external data.

[0225] In some examples, the write command further identifies internal data in addition to the external data. In such examples, performing CF on at least one of the internal data or the external data includes performing CF on both the internal data and the external data. The internal data includes one or more of data stored in a non-volatile storage memory (e.g., memory array 120) of the memory device 100a, data stored in a drive buffer of the memory device 100a, or coefficient data stored in a coefficient table of the memory device 100a.

[0226] In some examples, a write command identifies the number of logical blocks and the logical address of the internal data. The write command further identifies the number of logical blocks and the logical address (or buffer address) of the external data. The number of logical blocks of the internal data and the number of logical blocks of the external data are the same in some cases and different in other cases.

[0227] In some examples, the controller 110 may write the external data or the calculation result of the CF to the non-volatile storage memory of the memory device 100a (e.g., the memory array 120). In some examples, the controller 110 may write the external data to the non-volatile storage memory of the memory device 100a before, during, or after performing the CF on the external data.

[0228] exist Figures 18A to 25B In some examples shown in FIG, the command is a read command identifying internal data. In such examples, executing a CF on at least one of the internal data or the external data includes executing a CF on the internal data. In some examples, controller 110 provides the internal data or the result of the calculation of the CF to host 101. The internal data is provided to host 101 before, during, or after executing the CF on the internal data.

[0229] In some examples, the internal data includes first internal data and second internal data. The read command identifies the first internal data (using a corresponding logical address and a number of logical blocks) and the second internal data (using a corresponding logical address (or buffer address) and a number of logical blocks). Executing CF on the internal data includes executing CF on the first internal data and the second internal data.

[0230] In some examples, the first internal data includes data stored in a nonvolatile storage memory (e.g., memory array 120) of storage device 100a. The second internal data includes one of data stored in a nonvolatile storage memory of storage device 100a, data stored in a drive buffer of storage device 100a, or coefficient data stored in a coefficient table of storage device 100a. In some examples, controller 110 provides the first internal data or the calculation result of CF to host 101. In some examples, controller 110 provides the first internal data to host 101 before performing CF on the first and second internal data.

[0231] In some examples, the read command identifies the number of logical blocks and the logical address of the first internal data. The read command further identifies the number of logical blocks and the logical address of the second internal data. The number of logical blocks of the first internal data and the number of logical blocks of the second internal data are the same in some cases and different in other cases.

[0232] In some arrangements, the storage device 100a executes the CFs described herein using one or more shared processors within the ASIC or circuitry of the controller 110 (the shared processors execute CFs as well as other functions of the controller 110), one or more separate dedicated processors within the ASIC or circuitry of the controller 110 (the dedicated processors execute only CFs), or one or more shared processors on a separate chip (coprocessor) attached to the ASIC or circuitry of the controller 110. In instances where multiple separate dedicated processors execute CFs, the processor of the controller 110 selects one or more of the multiple separate dedicated processors to execute a particular CF, e.g., based on the availability of the separate dedicated processors.

[0233] It should be understood that the specific order or hierarchy of steps in the disclosed processes is an example of an illustrative approach. Based on design preferences, it should be understood that the specific order or hierarchy of steps in the processes can be rearranged while remaining within the scope previously described. The accompanying methods present elements of the various steps in a sample order and are not meant to be limited to the specific order or hierarchy presented.

[0234] The preceding description of the disclosed embodiments is provided to enable those skilled in the art to make or use the disclosed subject matter. Various modifications to these embodiments will be readily apparent to those skilled in the art, and the general principles defined herein may be applied to other embodiments without departing from the spirit or scope of the present description. Therefore, the preceding description is not intended to be limited to the embodiments shown herein, but rather should be accorded the widest scope consistent with the principles and novel features disclosed herein.

[0235] The examples shown and described are provided merely as examples to illustrate the various features of the claims. However, the features shown and described with respect to any given example are not necessarily limited to that associated example, but may be used or combined with other examples shown and described. Furthermore, the claims are not intended to be limited by any one example.

[0236] The foregoing method descriptions and process flow diagrams are provided for illustrative purposes only and are not intended to require or imply that the steps of the various examples must be performed in the order presented. Those skilled in the art will appreciate that the order of steps in the foregoing examples can be performed in any order. Words such as "thereafter," "next," and the like are not intended to limit the order of the steps; these words are simply used to guide the reader through the description of the method. Furthermore, any reference to a singular element, such as with the articles "a," "an," or "the," should not be construed as limiting the element to the singular.

[0237] The various illustrative logical blocks, modules, circuits, and algorithmic steps described in conjunction with the examples disclosed herein may be implemented as electronic hardware, computer software, or a combination of both. To clearly illustrate this interchangeability of hardware and software, various illustrative components, blocks, modules, circuits, and steps have been described above generally in terms of their functionality. Whether this functionality is implemented as hardware or software depends on the specific application and the design constraints imposed on the overall system. A skilled person may implement the described functionality in different ways for each specific application, but such implementation decisions should not be interpreted as causing a departure from the scope of this disclosure.

[0238] The hardware for implementing the various illustrative logics, logic blocks, modules, and circuits described in conjunction with the examples disclosed herein may be implemented or performed using a general-purpose processor, a DSP, an ASIC, an FPGA, or other programmable logic device designed to perform the functions described herein, discrete gate or transistor logic, discrete hardware components, or any combination thereof. A general-purpose processor may be a microprocessor, but in an alternative embodiment, the processor may be any conventional processor, controller, microcontroller, or state machine. The processor may also be implemented as a combination of computing devices, such as a combination of a DSP and a microprocessor, a plurality of microprocessors, one or more microprocessors combined with a DSP core, or any other such configuration. Alternatively, some steps or methods may be performed by circuitry specific to a given function.

[0239] In some exemplary embodiments, the described functions may be implemented in hardware, software, firmware, or any combination thereof. If implemented in software, the functions may be stored as one or more instructions or codes on a non-transitory computer-readable storage medium or a non-transitory processor-readable storage medium. The steps of the methods or algorithms disclosed herein may be embodied in a processor-executable software module that may reside on a non-transitory computer-readable or processor-readable storage medium. A non-transitory computer-readable or processor-readable storage medium may be any storage medium that can be accessed by a computer or processor. By way of example and not limitation, such non-transitory computer-readable or processor-readable storage medium may include RAM, ROM, EEPROM, flash memory, CD-ROM or other optical drive storage device, magnetic drive storage device or other magnetic storage device, or any other medium that can be used to store desired program code in the form of instructions or data structures and that can be accessed by a computer. As used herein, drives and optical disks include compact discs (CDs), laser discs, optical disks, digital versatile discs (DVDs), floppy drives, and Blu-ray discs, where drives typically reproduce data magnetically, while optical disks reproduce data optically using lasers. Combinations of the above are also included within the scope of non-transitory computer-readable and processor-readable media. Additionally, the operations of a method or algorithm may reside as one or any combination or set of codes and / or instructions on a non-transitory processor-readable storage medium and / or computer-readable storage medium that can be incorporated into a computer program product.

[0240] The foregoing description of the disclosed examples is provided to enable one skilled in the art to make or use the present disclosure. Various modifications to these examples will be readily apparent to those skilled in the art, and the general principles defined herein may be applied to some examples without departing from the spirit or scope of the present disclosure. Therefore, the present disclosure is not intended to be limited to the examples shown herein, but is to be accorded the widest scope consistent with the appended claims and the principles and novel features disclosed herein.

Claims

1. A non-transitory computer-readable medium comprising computer-readable instructions that, when executed by at least one processor of a storage device, cause the processor to: Receiving a command from a host to read data from or write data to a non-volatile memory of the storage device, wherein the read or write command includes a set of parameters including: Compute function CF identifier, The location of the first and second data of the CF, an address type for one or both of the locations of the first and second data, wherein the address type is configured to specify one or both of the locations as bus-addressable physical memory or the non-volatile memory, and the number of first and second logical blocks of the first and second data, respectively, wherein the first and second logical blocks of the data for the CF are different in number; In response to receiving the command, executing the CF using the first and second data, wherein at least one of the first and second data includes internal data stored in the storage device or external data transferred from the host to determine a calculation result; storing the calculation result in a drive buffer of the storage device separate from the nonvolatile memory of the storage device; and Data is transferred between the drive buffer of the storage device and the host according to the command.

2. The non-transitory computer-readable medium of claim 1, wherein The CF includes one of a mathematical or arithmetic operation, a logical operation, a Boolean operation, a bitwise operation, a comparison operation, a string operation, a database query language function, a Reed-Solomon or erasure coding operation, a data encryption operation, or a database stabilization operation; The mathematical or arithmetic operation includes one or more of the following: addition, subtraction, multiplication, division or Galois Field GF; The logical operation includes one or more of the following: AND, OR, NAND, NOR, NOT, or XOR; The Boolean operations include one or more of the following: AND, OR, or XOR; The bitwise operation includes one or more of the following: logical shift, arithmetic shift or rotation; The comparison operation includes one or more of the following: greater than, less than, or not equal to; The string operations include one or more of: copying, searching, or comparing; and The database query language functions include one or more of the following: AVG(), FIRST(), LAST(), MAX(), MIN(), and SUM().

3. The non-transitory computer-readable medium of claim 1 , wherein The command is a write command that identifies the external data; and Executing the CF on at least one of the internal data or the external data includes executing the CF on the external data.

4. The non-transitory computer-readable medium of claim 1 , wherein The command is a write command that identifies the internal data and the external data; and Executing the CF on at least one of the internal data or the external data includes executing the CF on the internal data and the external data.

5. The non-transitory computer-readable medium of claim 4, wherein the internal data comprises: The coefficient data is stored in the coefficient table of the storage device.

6. The non-transitory computer-readable medium of claim 4, wherein The write command identifies the number of logical blocks of the internal data and the number of logical blocks of the external data; and The number of the logical blocks of the internal data and the number of the logical blocks of the external data are different. 7 . The non-transitory computer-readable medium of claim 1 , wherein the processor is further caused to write the external data or the calculation result of the CF to the non-volatile memory of the storage device.

8. The non-transitory computer-readable medium of claim 1, wherein the processor is further caused to write the external data to the non-volatile memory of the storage device before, when, or after executing the CF on the external data.

9. The non-transitory computer-readable medium of claim 1, wherein The command is a read command that identifies the internal data; and Executing the CF on at least one of the internal data or the external data includes executing the CF on the internal data.

10. The non-transitory computer-readable medium of claim 9, wherein the processor is further caused to provide the internal data or the calculation result of the CF to the host.

11. The non-transitory computer-readable medium of claim 9, wherein the processor is further caused to provide the internal data to the host before or while executing the CF on the internal data.

12. The non-transitory computer-readable medium of claim 9, wherein The internal data includes first internal data and second internal data; The read command identifies the first internal data and the second internal data; and Executing the CF on the internal data includes executing the CF on the first internal data and the second internal data.

13. The non-transitory computer-readable medium of claim 12, wherein The first internal data includes data stored in the non-volatile memory of the storage device; and The second internal data includes one of the following: data stored in the drive buffer of the storage device; or The coefficient data is stored in the coefficient table of the storage device.

14. The non-transitory computer-readable medium of claim 13, wherein the processor is further caused to provide the first internal data or the calculation result of the CF to the host.

15. The non-transitory computer-readable medium of claim 12, wherein The read command identifies the number of logical blocks of the first internal data and the number of logical blocks of the second internal data; and The number of the logical blocks of the first internal data and the number of the logical blocks of the second internal data are different.

16. A storage device comprising: non-volatile storage device; and a controller having a drive buffer separate from the non-volatile memory device and a processor, the processor being configured to: Receiving a command from a host to read data from or write data to the non-volatile storage device, wherein the read or write command includes a set of parameters including: Compute function CF identifier, The location of the first and second data of the CF, an address type for one or both of the locations of the first and second data, wherein the address type is configured to specify one or both of the locations as bus-addressable physical memory or the non-volatile memory, and the number of first and second logical blocks of the first and second data, respectively, wherein the first and second logical blocks of the data for the CF are different in number; In response to receiving the command, executing the CF using the first and second data, wherein at least one of the first and second data includes at least one of internal data stored in the storage device or external data transferred from the host to determine a calculation result; storing the calculation result in the driving buffer; and Data is transferred between the drive buffer and the host according to the command.

17. A method for memory operation, comprising: A controller of a storage device receives a command from a host to read data from or write data to a non-volatile storage device of the storage device, wherein the read or write command includes a set of parameters, including: Compute function CF identifier, The location of the first and second data of the CF, an address type for one or both of the locations of the first and second data, wherein the address type is configured to specify one or both of the locations as bus-addressable physical memory or the non-volatile memory, and the number of first and second logical blocks of the first and second data, respectively, wherein the first and second logical blocks of the data for the CF are different in number; In response to receiving the command, executing, by the controller, the CF using the first and second data, wherein at least one of the first and second data includes internal data stored in the storage device or external data transmitted from the host to determine a calculation result; storing the calculation result in a drive buffer of the storage device separate from the nonvolatile storage device; and Data is transferred between the drive buffer and the host according to the command.

Images