Patent Description:
Semiconductor memory devices include volatile memory devices and nonvolatile memory devices. The volatile memory devices may lose their stored contents when powered off, while they have high read and write speeds. Conversely, since the nonvolatile memory devices retain their stored contents even when powered off, the nonvolatile memory devices are used to store contents that need (or are desired) to be maintained regardless of whether power is supplied or not.

For example, the volatile memory device includes a static RAM (SRAM), a dynamic RAM (DRAM), a synchronous DRAM (SDRAM), or the like. The nonvolatile memory devices retain their stored contents even when powered off. For example, the nonvolatile memory devices include a read only memory (ROM), a programmable ROM (PROM), an electrically programmable ROM (EPROM), an electrically erasable and programmable ROM (EEPROM), a flash memory, a phase change RAM (PRAM), a magnetic RAM (MRAM), a resistive RAM (RRAM), a ferroelectric RAM (FRAM), and the like. Flash memories may be classified into NOR flash memory and NAND flash memory. Relevant prior art documents are identified by <CIT>, <CIT>, <CIT> <CIT>, <CIT>, <CIT> and <CIT>.

Example embodiments of the present disclosure provide a computational storage device having an improved operation performance and a method for operating the device.

However, example embodiments of the present disclosure are not restricted to the one set forth herein. The above and other aspects of the present disclosure will become more apparent to one of ordinary skill in the art to which the present disclosure pertains by referencing the detailed description of the present disclosure given below.

According to an example embodiment of the present disclosure, there is provided a method for operating a computational storage device, comprising: receiving, by a storage controller, a first computing namespace setting instruction from a first host device; receiving, by the storage controller, a second computing namespace setting instruction from a second host device; receiving, by the storage controller, a first program from the first host device; receiving, by the storage controller, a second program from the second host device; receiving, by the storage controller, a fused execution command, the fused execution command indicating to process a first computation using the first program in the first computing namespace and, indicating to in response to a first computation result of processing the first computation, process a second computation using the second program in the second computing namespace; processing, by a first accelerator, the first computation; storing, by the storage controller, in a buffer memory the first computation result obtained by processing the first computation; providing, by the storage controller, data stored in the buffer memory to a second accelerator different from the first accelerator, in response to an amount of data stored in the buffer memory exceeding a range; and processing, by the second accelerator, the second computation on the data provided from the buffer memory.

According to another example embodiment of the present disclosure, there is provided a computational storage device comprising: a nonvolatile memory configured to store data; a storage controller configured to control the nonvolatile memory; a first accelerator comprised in a first computing namespace, and configured to process a first computation according to a first execution command received from a first host device on the data by using a first program provided from the first host device; and a second accelerator comprised in a second computing namespace, and configured to process a second computation according to a second execution command received from a second host device on the data by using a second program provided from the second host device, wherein the storage controller is configured to receive a fused execution command, the fused execution command indicating to process the first computation using the first program in the first computing namespace and indicating to, in response to a first computation result of processing the first computation, process the second computation using the second program in the second computing namespace, control the first accelerator such that the first computation is processed on the data, store in a buffer memory a first computation result obtained by processing the first computation, provide data stored in the buffer memory to the second accelerator, in response to an amount of data stored in the buffer memory exceeding a range, and control the second accelerator such that the second computation is processed on the data stored in the buffer memory.

According to another example embodiment of the present disclosure, there is provided a computational storage device comprising a nonvolatile memory configured to store data, a storage controller configured to control the nonvolatile memory, a first accelerator in a first computing namespace, and configured to process first computation according to a first execution command received from a first host device on the data by using a first program provided from the first host device, a second accelerator in a second computing namespace, and configured to process second computation according to a second execution command received from a second host device on the data by using a second program provided from the second host device and a volatile memory configured to store at least a part of data stored in the nonvolatile memory, wherein the storage controller is configured to receive a fused execution command , the fused execution command indicating to process the first computation using the first program in the first computing namespace and indicating to, in response to the first computation result of processing the first computation, process the second computation using the second program in the second computing namespace, control the first accelerator such that the first computation is processed on the data stored in the volatile memory, store the first computation result obtained by processing the first computation in a buffer memory different from the volatile memory, provide data stored in the buffer memory to the second accelerator, in response to an amount of data stored in the buffer memory exceeding a range, control the second accelerator such that the second computation is processed on the data stored in the buffer memory, and store a computation result obtained by processing the second computation in the volatile memory.

The above and other aspects and features of the present disclosure will become more apparent by describing in detail example embodiments thereof with reference to the attached drawings, in which:.

Hereinafter, example embodiments according to the present disclosure will be described with reference to the accompanying drawings.

<FIG> is a block diagram of a memory system according to some example embodiments.

Referring to <FIG>, a memory system <NUM> may include a host device <NUM> and a storage device <NUM>.

The host device <NUM> may include a host controller <NUM> and a host memory <NUM>. The host controller <NUM> may control the overall operation of the host device <NUM>. In some example embodiments, the host controller <NUM> may include a plurality of entities or tenants driven by a plurality of virtual machines (VM). The entities or tenants driven by different virtual machines may independently control the storage device <NUM>.

The host memory <NUM> may temporarily store data transmitted from the outside, data to be transmitted to the storage device <NUM>, or data transmitted from the storage device <NUM>. In some example embodiments, the host device <NUM> may be implemented as an application processor (AP). However, the example embodiment is not limited thereto.

The storage device <NUM> may be, for example, a computational storage device.

The storage device <NUM> may include a Field Programable Gate Array (FPGA) <NUM>, a storage controller <NUM>, a buffer memory <NUM>, and a nonvolatile memory <NUM>.

The storage device <NUM> may include storage media for storing data according to a request from the host device <NUM>. As one example, the storage device <NUM> may include at least one of a solid state drive (SSD), an embedded memory, or a removable external memory. When the storage device <NUM> is the SSD, the storage device <NUM> may be a device conforming to the nonvolatile memory express (NVMe) standard. When the storage device <NUM> is the embedded memory or the external memory, the storage device <NUM> may be a device conforming to the universal flash storage (UFS) standard or the embedded multi-media card (eMMC) standard. The storage device <NUM> and the host device <NUM> may each generate and transmit a packet conforming to an adopted standard protocol.

When the nonvolatile memory <NUM> of the storage device <NUM> includes a flash memory, the flash memory may include a 2D NAND memory array or a 3D (or vertical) NAND (VNAND) memory array. As another example, the storage device <NUM> may include various other types of nonvolatile memories. For example, a magnetic RAM (MRAM), a spin-transfer torque MRAM, a conductive bridging RAM (CBRAM), a ferroelectric RAM (FeRAM), a phase RAM (PRAM), a resistive memory (resistive RAM) and various other types of memories may be applied to the storage device <NUM>.

The FPGA <NUM> may perform various types of computations, calculations, and the like on data stored in the buffer memory <NUM>. In some example embodiments, the FPGA <NUM> may include a plurality of accelerators that perform various types of computations, calculations, and the like on the data stored in the buffer memory <NUM> based on the execute command provided from the host device <NUM>.

The FPGA <NUM> may perform computation using data temporarily stored in the buffer memory <NUM> by using the algorithm mapped to a hardware logic configuration. In some example embodiments, the FPGA <NUM> may perform computation using data stored in the nonvolatile memory <NUM> without intervention of the host device <NUM>.

The storage controller <NUM> may include a host interface (I/F) <NUM>, a memory interface (I/F) <NUM>, and a central processing unit (CPU) <NUM>. In addition, the storage controller <NUM> may further include a flash translation layer (FTL) <NUM>, a packet manager (PCK MNG) <NUM>, a buffer memory (BUF MEM) <NUM>, an error correction code (ECC) engine <NUM>, an advanced encryption standard (AES) engine (AES ENG) <NUM>, a direct memory access (DMA) engine <NUM>, a queue control engine (QCE) <NUM>, and a flow controller (FC) <NUM>.

The storage controller <NUM> may further include a working memory in which the flash translation layer (FTL) <NUM> is loaded, and data write and read operations to the nonvolatile memory (NVM) <NUM> may be controlled by the CPU <NUM> executing the flash translation layer.

The host interface <NUM> may transmit and receive a packet to and from the host device <NUM>. The packet transmitted from the host device <NUM> to the host interface <NUM> may include a command or data to be written to the nonvolatile memory <NUM>, or the like, and the packet transmitted from the host interface <NUM> to the host device <NUM> may include a response to the command, data read from the nonvolatile memory <NUM>, or the like.

The memory interface <NUM> may transmit data to be written to the nonvolatile memory <NUM> or may receive data read from the nonvolatile memory <NUM>. The memory interface <NUM> may be implemented to conform to standard conventions such as Toggle or open NAND flash interface (ONFI).

The flash translation layer <NUM> may perform various functions such as address mapping, wear-leveling, and garbage collection. Restated, the flash translation layer <NUM> may be configured to perform address mapping, wear-leveling, and garbage collection. The address mapping operation is an operation of converting a logical address received from the host device <NUM> into a physical address used to actually store data in the nonvolatile memory <NUM>. The wear-leveling is a technique for preventing or reducing excessive deterioration of a specific block by equally using blocks in the nonvolatile memory <NUM>. For example, the wear-leveling may be implemented by a firmware technique for balancing erase counts of physical blocks. The garbage collection is a technique for ensuring an available capacity in the nonvolatile memory <NUM> by copying valid data of a block to a new block and then erasing the existing block.

The packet manager <NUM> may generate a packet corresponding to the protocol of the interface agreed with the host device <NUM>, or may parse various information from the packet received from the host device <NUM>.

The buffer memory <NUM> may temporarily store data to be written to the nonvolatile memory <NUM> or data to be read from the nonvolatile memory <NUM>. The buffer memory <NUM> may be provided in the storage controller <NUM>, or may be provided outside the storage controller <NUM>.

The ECC engine <NUM> may perform an error detection and correction function for the data read from the nonvolatile memory <NUM>. Specifically, the ECC engine <NUM> may generate parity bits for data to be written to the nonvolatile memory <NUM>, and the parity bits generated as described above may be stored in the nonvolatile memory <NUM> together with the write data. When reading data from the nonvolatile memory <NUM>, the ECC engine <NUM> may correct the error of the read data using the parity bits read from the nonvolatile memory <NUM> together with the read data, and may output the read data of which the error has been corrected.

The AES engine <NUM> may perform at least one of an encryption operation or a decryption operation for data inputted to the storage controller <NUM> using a symmetric-key algorithm.

The DMA engine <NUM> may read or fetch data blocks from the buffer memory <NUM> so that the accelerator of the FPGA <NUM> may perform computation. Although it is illustrated in the drawing that the DMA engine <NUM> is included in the storage controller <NUM>, the example embodiments are not limited thereto, and the DMA engine <NUM> may be implemented inside the FPGA <NUM>, or may be implemented outside the storage controller <NUM>.

The queue control engine <NUM> may manage the execute command provided from the host device <NUM>. The queue control engine <NUM> may select an accelerator to process computation according to the execution command provided from the host device <NUM> among a plurality of accelerators included in the storage device <NUM>, and may control the selected accelerator to process the computation according to the execution command. A specific operation thereof will be described later.

Although it is illustrated in the drawing that the queue control engine <NUM> is included in the storage controller <NUM>, the example embodiments are not limited thereto, and the queue control engine <NUM> may be implemented inside the FPGA <NUM>, or may be implemented outside the storage controller <NUM>.

The flow controller <NUM> may be used when the execution command provided from the host device <NUM> is a fused execution command (for example, a complex command formed by "fusing" together simpler commands). When the execution command provided from the host device <NUM> is a fused execution command, for example, a plurality of computational processes according to the fused execution command may be performed at a high speed while minimizing or reducing access to the buffer memory <NUM> by the flow controller <NUM>.

Although it is illustrated in the drawings the flow controller <NUM> is an additional component separate from the DMA engine <NUM>, the example embodiments are not limited thereto, and the flow controller <NUM> may be implemented while being integrated with the DMA engine <NUM>, if necessary. A detailed description of the flow controller <NUM> will be made later.

The buffer memory <NUM> may buffer data stored in the nonvolatile memory <NUM>. Further, the buffer memory <NUM> may buffer data transferred from the FPGA <NUM> (e.g., data that has been subjected to the computational process by an accelerator). That is, when the FPGA <NUM> uses the data stored in the nonvolatile memory <NUM>, the buffer memory <NUM> may temporarily store it so that the FPGA <NUM> may use the data stored in the nonvolatile memory <NUM>. In some example embodiments, the buffer memory <NUM> may include, for example, a volatile memory such as a dynamic random access memory (DRAM), but the example embodiments are not limited thereto.

The nonvolatile memory <NUM> may store the data provided from the host device <NUM> and the data required (or alternatively, used) when the FPGA <NUM> performs computation. Hereinafter, an example embodiment of the nonvolatile memory <NUM> will be described in more detail.

<FIG> is a block diagram of the nonvolatile memory of <FIG>.

Referring to <FIG>, the nonvolatile memory <NUM> may include a memory cell array <NUM>, an address decoder (ADDR Decoder) <NUM>, a voltage generator <NUM>, a read/write circuit <NUM>, a control logic circuit <NUM>, and the like.

The memory cell array <NUM> may be connected to the address decoder <NUM> through word lines WL. The memory cell array <NUM> may be connected to the read/write circuit <NUM> through bit lines BL. The memory cell array <NUM> may include a plurality of memory cells. For example, memory cells arranged in a row direction may be connected to the same word line WL, and memory cells arranged in a column direction may be connected to the same bit line BL.

The address decoder <NUM> may be connected to the memory cell array <NUM> through the word lines WL. The address decoder <NUM> may operate under the control of the control logic circuit <NUM>. The address decoder <NUM> may receive the address ADDR from the storage controller <NUM>. The address decoder <NUM> may receive from the voltage generator <NUM> a voltage required (or alternatively, used) for an operation such as program or read.

The address decoder <NUM> may decode a row address among the received addresses ADDR. The address decoder <NUM> may select the word line WL using the decoded row address. A decoded column address DCA may be provided to the read/write circuit <NUM>. For example, the address decoder <NUM> may include a row decoder, a column decoder, an address buffer, and the like.

The voltage generator <NUM> may generate a voltage required (or alternatively, used) for an access operation under the control of the control logic circuit <NUM>. For example, the voltage generator <NUM> may generate a program voltage and a program verification voltage which are required (or alternatively, used) to perform a program operation. For example, the voltage generator <NUM> may generate read voltages required (or alternatively, used) to perform a read operation, and generate an erase voltage and an erase verification voltage required (or alternatively, used) to perform an erase operation. In addition, the voltage generator <NUM> may provide a voltage required (or alternatively, used) to perform each operation to the address decoder <NUM>.

The read/write circuit <NUM> may be connected to the memory cell array <NUM> through the bit lines BL. The read/write circuit <NUM> may exchange the data DATA with the storage controller <NUM>. The read/write circuit <NUM> may operate under the control of the control logic circuit <NUM>. The read/write circuit <NUM> may receive the decoded column address DCA from the address decoder <NUM>. The read/write circuit <NUM> may select the bit line BL using the decoded column address DCA.

For example, the read/write circuit <NUM> may program the received data DATA into the memory cell array <NUM>. The read/write circuit <NUM> may read data from the memory cell array <NUM> and provide the read data to the outside (e.g., the storage controller <NUM>). For example, the read/write circuit <NUM> may include components such as a sense amplifier, a write driver, a column select circuit, a page buffer, and the like. That is, the read/write circuit <NUM> may buffer the data DATA received from the storage controller <NUM> in a page buffer, and program the buffered data DATA into the memory cell array <NUM>.

The control logic circuit <NUM> may be connected to the address decoder <NUM>, the voltage generator <NUM>, and the read/write circuit <NUM>. The control logic circuit <NUM> may control the operation of the nonvolatile memory <NUM>. The control logic circuit <NUM> may operate in response to the control signal CRTL and the command CMD (e.g., write command and read command) provided from the storage controller <NUM>.

<FIG> is a block diagram of the storage controller and the nonvolatile memory of <FIG>.

Referring to <FIG>, the storage device <NUM> may include the storage controller <NUM> and the nonvolatile memory <NUM>. The storage device <NUM> may support a plurality of channels CH1 to CHm, and the storage controller <NUM> and the nonvolatile memory <NUM> may be connected by the plurality of channels CH1 to CHm. For example, the storage device <NUM> may be implemented as a storage device such as a solid state drive (SSD).

The nonvolatile memory <NUM> may include a plurality of nonvolatile memory devices NVM11 to NVMmn. Each of (or alternatively, at least one of) the nonvolatile memory devices NVM11 to NVMmn may be connected to one of the plurality of channels CH1 to CHm through a corresponding way. For example, the nonvolatile memory devices NVM11 to NVM1n may be connected to a first channel CH1 through ways W11 to Win, and the nonvolatile memory devices NVM21 to NVM2n may be connected to a second channel CH2 through ways W21 to W2n. In an example embodiment, each of (or alternatively, at least one of) the nonvolatile memory devices NVM11 to NVMmn may be implemented as an arbitrary memory unit capable of operating according to an individual command from the storage controller <NUM>. For example, each of (or alternatively, at least one of) the nonvolatile memory devices NVM11 to NVMmn may be implemented as a chip or a die, but the present disclosure is not limited thereto.

The storage controller <NUM> may transmit and receive signals to and from the nonvolatile memory <NUM> through the plurality of channels CH1 to CHm. For example, the storage controller <NUM> may transfer commands CMDa to CMDm, addresses ADDRa to ADDRm, and data DATAa to DATAm to the nonvolatile memory <NUM> through the channels CH1 to CHm, or may receive data DATAa to DATAm from the nonvolatile memory <NUM>.

The storage controller <NUM> may select one of the nonvolatile memory devices connected to the corresponding channel through the channels, and may transmit and receive signals to and from the selected nonvolatile memory device. For example, the storage controller <NUM> may select the nonvolatile memory device NVM11 among the nonvolatile memory devices NVM11 to NVMln connected to the first channel CH1. The storage controller <NUM> may transmit the command CMDa, the address ADDRa, and the data DATAa to the selected nonvolatile memory device NVM11 through the first channel CH1, or may receive the data DATAa from the selected nonvolatile memory device NVM11.

The storage controller <NUM> may transmit and receive signals to and from the nonvolatile memory <NUM> in parallel through different channels. For example, the storage controller <NUM> may transmit the command CMDb to the nonvolatile memory <NUM> through the second channel CH2 while transmitting the command CMDa to the nonvolatile memory <NUM> through the first channel CH1. For example, the storage controller <NUM> may receive the data DATAb from the nonvolatile memory <NUM> through the second channel CH2 while receiving the data DATAa from the nonvolatile memory <NUM> through the first channel CH1.

The storage controller <NUM> may control the overall operation of the nonvolatile memory <NUM>. The storage controller <NUM> may control each of (or alternatively, at least one of) the nonvolatile memory devices NVM11 to NVMmn connected to the channels CH1 to CHm by transmitting signals to the channels CH1 to CHm. For example, the storage controller <NUM> may control the selected one of the nonvolatile memory devices NVM11 to NVMln by transmitting the command CMDa and the address ADDRa to the first channel CH1.

Each of (or alternatively, at least one of) the nonvolatile memory devices NVM11 to NVMmn may operate under the control of the storage controller <NUM>. For example, the nonvolatile memory device NVM11 may program the data DATAa according to the command CMDa, the address ADDRa, and the data DATAa provided to the first channel CH1. For example, the nonvolatile memory device NVM21 may read the data DATAb according to the command CMDb and the address ADDRb provided to the second channel CH2, and may transfer the read data DATAb to the storage controller <NUM>.

Although <FIG> illustrates that the nonvolatile memory <NUM> communicates with the storage controller <NUM> through m channels and includes n nonvolatile memory devices corresponding to the channels, the number of channels and the number of nonvolatile memory devices connected to one channel may be variously changed.

<FIG> is an example circuit diagram illustrating the memory cell array of <FIG>.

Referring to <FIG>, a plurality of cell strings NS11, NS21, NS31, NS12, NS22, NS32, NS13, NS23, and NS33 may be arranged in a first direction x and a second direction y on a substrate. The plurality of cell strings NS11, NS21, NS31, NS12, NS22, NS32, NS13, NS23, and NS33 may have a shape extending in a third direction z. The plurality of cell strings NS11, NS21, NS31, NS12, NS22, NS32, NS13, NS23, and NS33 may be connected in common to a common source line CSL formed on or in the substrate.

The common source line CSL is shown as being connected to the lowermost end of the plurality of cell strings NS11, NS21, NS31, NS12, NS22, NS32, NS13, NS23, and NS33 in the third direction z. However, it is sufficient that the common source line CSL is electrically connected to the lowermost end of the plurality of cell strings NS11, NS21, NS31, NS12, NS22, NS32, NS13, NS23, and NS33 in the third direction z, and the common source line CSL is not limited to being physically located at the lower end of the plurality of cell strings NS11, NS21, NS31, NS12, NS22, NS32, NS13, NS23, and NS33. In addition, the plurality of cell strings NS1, NS21, NS31, NS12, NS22, NS32, NS13, NS23, and NS33 are shown to be arranged in a <NUM> x <NUM> array in this drawing, but the arrangement shape and the number of the plurality of cell strings arranged in the memory cell array <NUM> are not limited thereto.

Some of the cell strings NS11, NS12, and NS13 may be connected to a first ground select line GSL1. Some of the cell strings NS21, NS22, and NS23 may be connected to a second ground select line GSL2. Some of the cell strings NS31, NS32, and NS33 may be connected to a third ground select line GSL3.

In addition, some of the cell strings NS1 <NUM>, NS12, and NS13 may be connected to a first string select line SSL1. Some of the cell strings NS21, NS22, and NS23 may be connected to a second string select line SSL2. Some of the cell strings NS31, NS32, and NS33 may be connected to a third string select line SSL3.

Each of (or alternatively, at least one of) the plurality of cell strings NS <NUM><NUM>, NS21, NS31, NS12, NS22, NS32, NS13, NS23, and NS33 may include a string select transistor SST connected to each of (or alternatively, at least one of) the string select lines. In addition, each of (or alternatively, at least one of) the plurality of cell strings NS11, NS21, NS31, NS12, NS22, NS32, NS13, NS23, and NS33 may include a ground select transistor GST connected to each of (or alternatively, at least one of) the ground select lines.

One end of the ground select transistor in each of (or alternatively, at least one of) the plurality of cell strings NS11, NS21, NS31, NS12, NS22, NS32, NS13, NS23, and NS33 may be connected to the common source line CSL. In addition, each of (or alternatively, at least one of) the plurality of cell strings NS11, NS21, NS31, NS12, NS22, NS32, NS13, NS23, and NS33 may have a plurality of memory cells sequentially stacked in the third direction z between the ground select transistor and the string select transistor. Although not shown in the drawing, each of (or alternatively, at least one of) the plurality of cell strings NS11, NS21, NS31, NS12, NS22, NS32, NS13, NS23, and NS33 may include dummy cells between the ground select transistor and the string select transistor. In addition, the number of the string select transistors included in each string is not limited to this drawing.

For example, the cell string NS11 may include a ground select transistor GST11 disposed at the lowermost end in the third direction z, a plurality of memory cells M1 1_1 to M1 1_8 sequentially stacked on the ground select transistor GST11 in the third direction z, and a string select transistor SST11 stacked on the uppermost memory cell M1 <NUM><NUM> in the third direction z. In addition, the cell string NS21 may include a ground select transistor GST21 disposed at the lowermost end in the third direction z, a plurality of memory cells M21_1 to M21_8 sequentially stacked on the ground select transistor GST21 in the third direction z, and a string select transistor SST21 stacked on the uppermost memory cell M21_8 in the third direction z. In addition, the cell string NS31 may include a ground select transistor GST31 disposed at the lowermost end in the third direction z, a plurality of memory cells M31_1 to M31_8 sequentially stacked on the ground select transistor GST31 in the third direction z, and a string select transistor SST31 stacked on the uppermost memory cell M31_8 in the third direction z. The configuration of the other strings may also be similar thereto.

The memory cells positioned at the same height in the third direction z from the substrate or the ground select transistor may be electrically connected in common through each word line. For example, the memory cells formed at the same height as the memory cells M11_1, M21_1, and M31_1 may be connected to a first word line WL1. In addition, the memory cells formed at the same height as the memory cells M11_2, M21_2, and M31 <NUM> may be connected to a second word line WL2. Hereinafter, since the arrangement and structure of the memory cells connected to a third word line WL3 to an eighth word line WL8 are similar to or the same as the above, a description thereof will be omitted.

One end of each string select transistor of the plurality of cell strings NS11, NS21, NS31, NS12, NS22, NS32, NS13, NS23, and NS33 may be connected to a bit line BL1, BL2, or BL3. For example, the string select transistors SST11, SST21, and SST31 may be connected to the bit line BL1 extending in the second direction y. A description of the other string select transistors connected to the bit lines BL2 or BL3 is also similar to or the same as the above, and thus a description thereof will be omitted.

The memory cells corresponding to one string (or ground) select line and one word line may form one page. A write operation and a read operation may be performed on a page basis. Each of (or alternatively, at least one of) the memory cells in each page may store two or more bits. Bits written to the memory cells of each page may form logical pages.

The memory cell array <NUM> may be provided as a three-dimensional memory array. The three-dimensional memory array may be monolithically formed on one or more physical levels of arrays of the memory cells having an active area disposed on a substrate (not shown) and a circuit involved in the operation of the memory cells. The circuit involved in the operation of the memory cells may be located within or on the substrate. Being monolithically formed means that layers of each level of the three-dimensional array may be deposited directly on the lower level layers of the three-dimensional array.

<FIG> is a flowchart illustrating an operation of a memory system according to some example embodiments. <FIG> are diagrams for explaining the operation of the memory system shown in <FIG>.

Referring to <FIG> and <FIG>, the host device <NUM> transmits to the storage controller <NUM> a setting instruction that instructs setting of a computing namespace (CNS) for processing a command of the host device <NUM> (step S100).

Then, the storage controller <NUM> that has received the setting instruction sets the computing namespace (CNS) for processing the command of the host device <NUM> in the storage device <NUM> (step S110).

Referring to <FIG>, in some example embodiments, the computing namespace (CNS) may include a command queue <NUM>, a queue control engine (QCE) <NUM>, a DMA engine <NUM>, an accelerator (FPGA) <NUM>, and a buffer memory (DRAM) <NUM>. However, the example embodiments are not limited thereto, and some illustrated components of the computing namespace (CNS) may be omitted, if necessary, and components that are not illustrated may be added to the computing namespace (CNS).

For example, in some example embodiments, the computing namespace (CNS) may be configured to include the command queue <NUM>, the DMA engine <NUM>, and the accelerator <NUM>.

The command queue <NUM> may store an execution command for driving the accelerator <NUM> that is provided from the host device <NUM>. In some example embodiments, the execution command may be, for example, an execution command conforming to nonvolatile memory express (NVMe) standards. In some example embodiments, the execution command may be an execution command conforming to NVMe technical proposal (TP) <NUM> (NVMe TP <NUM> Computational Programs Command Set Specification), but the example embodiments are not limited thereto.

The command queue <NUM> may sequentially store execution commands provided from the host device <NUM>, and may output the stored execution commands in a first-in-first-out (FIFO) manner, for example.

In some example embodiments, the command queue <NUM> may be provided in, for example, the buffer memory <NUM> (see <FIG>). In some example embodiments, the command queue <NUM> may be implemented by implementing the buffer memory <NUM> (see <FIG>) using an SRAM, but the example embodiments are not limited thereto.

The queue control engine <NUM> may manage execution commands stored in the command queue <NUM>. The queue control engine <NUM> may fetch the execution command stored in the command queue <NUM>, and control the accelerator <NUM> to perform computation according to the fetched execution command.

When it is determined that the accelerator <NUM> is in an idle state or is capable of performing a computational process, the queue control engine <NUM> may control the accelerator <NUM> to process computation according to the execution command stored in the command queue <NUM>.

In some example embodiments, the queue control engine <NUM> may manage the command queue <NUM> as a circular queue, and recognize that a new execution command has been stored when a queue index increases.

In some example embodiments, the queue control engine <NUM> may be implemented in the form of the queue control engine <NUM> in the storage controller <NUM> of <FIG>, but the example embodiments are not limited thereto.

The DMA engine <NUM> may read or fetch data from the buffer memory <NUM> so that the accelerator may process computation according to an execution command. In some example embodiments, the DMA engine <NUM> may be implemented in the form of the DMA engine <NUM> in the storage controller <NUM> of <FIG>, but example embodiments are not limited thereto.

The accelerator <NUM> may be implemented in the form of an FPGA (using an FPGA), for example, and may process computation according to an execution command under the control of the queue control engine <NUM>. In some example embodiments, the FPGA <NUM> of <FIG> may be used to implement the accelerator <NUM>. In some example embodiments, a plurality of accelerators <NUM> may be arranged, and the accelerators <NUM> may be used to set different computing namespaces (CNS).

The buffer memory <NUM> may provide data required (or alternatively, used) for the accelerator <NUM> to process computation according to an execution command, and may store the computational process result of the accelerator <NUM>. In some example embodiments, the buffer memory <NUM> may be implemented as a DRAM, for example. In some example embodiments, the buffer memory <NUM> may be implemented using the buffer memory <NUM> of <FIG>, but the example embodiments are not limited thereto.

Although the example embodiment in which the command queue <NUM>, the queue control engine <NUM>, the DMA engine <NUM>, and the accelerator <NUM> are implemented in the form of hardware has been described above, the example embodiments are not limited thereto. If necessary, at least one of the command queue <NUM>, the queue control engine <NUM>, the DMA engine <NUM>, and the accelerator <NUM> may operate while being implemented as software.

The storage controller <NUM> that has received the setting instruction may set required (or alternatively, used) computational resources in the storage device <NUM> as the computing namespace (CNS) for processing the command of the host device <NUM> in response to the setting instruction. The computing namespace (CNS) may be a computing namespace (CNS) conforming to the NVMe standards, but the example embodiments are not limited thereto.

Further, the computing namespace (CNS), which means a set of computational resources in the storage device <NUM> that are required (or alternatively, used) to process the command of the host device <NUM>, is another concept distinguished from a NVM namespace for dividing and managing the area of the nonvolatile memory <NUM> (see <FIG>) or a memory namespace for dividing and managing the area of the buffer memory <NUM> (see <FIG>).

Referring to <FIG> and <FIG>, the storage controller <NUM> that has completed the setting of the computing namespace (CNS) responds to the host device <NUM> that the setting of the computing namespace (CNS) has been completed (step S120).

Next, the host device <NUM> instructs the storage controller <NUM> to load a program to be used in the set computing namespace (CNS) (step S130). Then, in response thereto, the storage controller <NUM> loads the program in the set computing namespace (CNS) (step S140), and responds to the host device <NUM> that the loading of the program has been completed (step S150).

For example, referring to <FIG>, the host device <NUM> instructs the storage controller <NUM> to load a program in slot <NUM> of the computing namespace CNS1 (step S130). In response thereto, the storage controller <NUM> loads the program in slot <NUM> of the computing namespace CNS1 (step S140), and responds to the host device <NUM> that the loading of the program has been completed (step S150).

The illustrated computing namespaces CNS1 and CNS2, which are defined using the computational resources in the storage device <NUM>, are concepts distinguished from NVM namespaces NVM NS1 and NVM NS2 for dividing and managing the area of the nonvolatile memory NVM, or memory namespaces MNS1 and MNS2 for dividing and managing the area of the buffer memory, as described above.

Next, referring to <FIG> and <FIG>, the host device <NUM> instructs the storage controller <NUM> to activate the loaded program (step S160). In response thereto, the storage controller <NUM> activates the loaded program (step S170), and responds to the host device <NUM> that the program activation has been completed (step S180).

For example, referring to <FIG>, the host device <NUM> instructs the storage controller <NUM> to activate the program loaded in slot <NUM> of the computing (compute) namespace CNS1 (step S160). If the program is loaded in both slot <NUM> and slot <NUM> of the computing namespace CNS1, the host device <NUM> may instruct the storage controller <NUM> to activate the program loaded in any one of slot <NUM> and slot <NUM> of the computing namespace CNS1.

In response to the instruction for activating the program loaded in slot <NUM> of the computing namespace CNS1, the storage controller <NUM> activates the program loaded in slot <NUM> of the computing namespace CNS1 (step S170), and responds to the host device <NUM> that the activation has been completed (step S180).

Next, referring to <FIG> and <FIG>, the host device <NUM> transmits execution commands using the activated program to the storage controller <NUM> (step S190). In response thereto, the storage controller <NUM> processes computation according to the received execution commands (e.g. using the program and the computing namespace CNS) (step S200), and responds to the host device <NUM> that the computational process according to the execution commands has been completed (step S210).

For example, referring to <FIG>, the execution command received from the host device <NUM> is stored in the command queue <NUM>, and the queue control engine <NUM> fetches the execution command stored in the command queue <NUM> (step S201).

Then, the queue control engine <NUM> controls the DMA engine <NUM> so that the accelerator <NUM> may process the computation according to the fetched execution command (step S202). The DMA engine <NUM> controls the buffer memory (that may correspond to the buffer memory <NUM> of <FIG>, for example, and is referred to as "DRAM" in the following description) and the accelerator <NUM> (step S203), so that input data IDATA stored in the DRAM is provided to the accelerator <NUM> (step S204).

Thereafter, the accelerator <NUM> processes the computation according to the fetched execution command on the input data IDATA, and stores processed data PDATA that is the result thereof in the DRAM (step S205). At this time, the accelerator <NUM> may process the computation according to the fetched execution command using the program activated in the computing namespace in advance. The computation processed by the accelerator <NUM> may be, for example, data compression, data decompression, data filtering, data value comparison, or the like, but the example embodiments are not limited thereto.

Here, the input data IDATA stored in the DRAM may be data that is required (or alternatively, used) for a computational process and loaded in the DRAM among the data stored in the nonvolatile memory <NUM> (see <FIG>). Further in some example embodiments, the processed data PDATA stored in the DRAM may be stored again in the nonvolatile memory <NUM> (see <FIG>), if necessary.

Referring to <FIG> and <FIG>, in the present example embodiment, the host device may include a first virtual machine <NUM> and a second virtual machine <NUM>. That is, in the present example embodiment, each of (or alternatively, at least one of) the virtual machines <NUM> and <NUM> may serve as a host device. In one example, the storage controller <NUM> may receive instructions from first and second host devices. In the following description, the first and second host devices are described as first and second virtual machines, <NUM>, <NUM>, but the inventive concept is not limited thereto.

Referring to <FIG> and <FIG>, the first virtual machine <NUM> associated with a first tenant transmits to the storage controller <NUM> a setting instruction that instructs setting of the first computing namespace CNS1 for processing the command of the first virtual machine <NUM> (step S300).

Referring to <FIG> and <FIG>, the storage controller <NUM> that has received the setting instruction sets the first computing namespace CNS1 for processing the command of the first virtual machine <NUM> in the storage device <NUM>. In some example embodiments, the first computing namespace CNS1 may include a command queue 510a, a queue control engine (QCE) 520a, a DMA engine 530a, an accelerator (FPGA) 540a, and a buffer memory (DRAM) <NUM>.

In some example embodiments, the first computing namespace CNS1 may be set to include the command queue 510a, the DMA engine 530a, and the accelerator 540a, except the queue control engine 520a and the buffer memory <NUM>.

At this time, the command queue 510a stores the execution commands provided from the first virtual machine <NUM>, and the components of the first computing namespace CNS1 are used to process computation according to the execution commands received from the first virtual machine <NUM>.

Referring to <FIG> and <FIG>, the storage controller <NUM> that has completed the setting of the first computing namespace CNS1 responds to the first virtual machine <NUM> that the setting of the first computing namespace CNS1 has been completed. Hereinafter, redundant description of the above-described response signals (steps S120, S150, S180, and S210 of <FIG>) will be omitted for simplicity of description. Further, detailed illustration of the operations that may be sufficiently inferred from the above description with reference to <FIG> is omitted in <FIG>.

Next, the second virtual machine <NUM> associated with a second tenant transmits to the storage controller <NUM> a setting instruction that instructs the setting of the second computing namespace CNS2 for processing the command of the second virtual machine <NUM> (step S310).

Referring to <FIG> and <FIG>, the storage controller <NUM> that has received the setting instruction sets the second computing namespace CNS2 for processing the command of the second virtual machine <NUM> in the storage device <NUM>. In some example embodiments, the second computing namespace CNS2 may include a command queue 510b, a queue control engine (QCE) 520b, a DMA engine 530b, an accelerator (FPGA) 540b, and a buffer memory (DRAM) <NUM>.

In some example embodiments, the second computing namespace CNS2 may be set to include the command queue 510b, the DMA engine 530b, and the accelerator 540b, except the queue control engine 520b and the buffer memory <NUM>.

At this time, the command queue 510b stores the execution commands provided from the second virtual machine <NUM>, and the components of the second computing namespace CNS2 are used to process computation according to the execution commands received from the second virtual machine <NUM>.

Next, referring to <FIG> and <FIG>, the first virtual machine <NUM> instructs the storage controller <NUM> to load a first program (PRG1) to be used in the first computing namespace CNS1 (step S320). Then, the second virtual machine <NUM> instructs the storage controller <NUM> to load a second program (PRG2) to be used in the second computing namespace CNS2 (step S330).

For example, referring to <FIG>, the first virtual machine <NUM> may instruct the storage controller <NUM> to load a first program PRG1 in slot <NUM> of the first computing namespace CNS1, and in response thereto, the storage controller <NUM> may load the first program PRG1 in slot <NUM> of the first computing namespace CNS1, and respond to the first virtual machine <NUM> that the loading of the first program PRG1 has been completed.

Further, the second virtual machine <NUM> may instruct the storage controller <NUM> to load a second program PRG2 in slot <NUM> of the second computing namespace CNS2, and in response thereto, the storage controller <NUM> may load the second program PRG2 in slot <NUM> of the second computing namespace CNS2, and respond to the second virtual machine <NUM> that the loading of the second program PRG2 has been completed.

Next, referring to <FIG> and <FIG>, the first virtual machine <NUM> instructs the storage controller <NUM> to activate the first program PRG1 loaded in the first computing namespace CNS1 (step S340). Then, the second virtual machine <NUM> instructs the storage controller <NUM> to activate the second program PRG2 loaded in the second computing namespace CNS2 (step S350).

Further, for example, at least one of the first virtual machine <NUM> and the second virtual machine <NUM> transmits a fused execution command (EX CMD) using the activated first program and second program to the storage controller <NUM> (step S360).

For example, referring to <FIG>, the fused execution command may be identified by referring to a fused bit FBIT included in each of (or alternatively, at least one of) the execution commands CMD1, CMD2, CMD3, and CMD4. For example, the execution command CMD1 and the execution command CMD4 may be execution commands that are processed alone because the fused bits FBIT thereof have a bit value of <NUM>, and the execution command CMD2 and the execution command CMD3 may be fused execution commands that are processed in association with each other because the fused bits FBIT thereof have a bit value of <NUM>.

In some example embodiments, the fused execution command may be identified by referring to the fused bit FBIT included in each of (or alternatively, at least one of) the execution commands CMD1, CMD2, CMD3, and CMD4 in a different manner. For example, when the bit value of the fused bit FBIT of the execution command is <NUM>, the corresponding execution command may be identified as an execution command that is processed alone, and when the bit value of the fused bit FBIT of the execution command is <NUM>, n (n being a natural number) execution commands provided later may be recognized as fused execution commands.

That is, the fused execution command is identified simply by referring to the fused bit FBIT included in each of (or alternatively, at least one of) the execution commands CMD1, CMD2, CMD3, and CMD4, and the specific identification method thereof is not limited to the illustrated example embodiment.

The fused execution command including the execution command CMD2 and the execution command CMD3 may be the execution command that instructs (or indicates) processing of a first computation using the first program PRG1 in the first computing namespace CNS1 where the computation according to the execution command CMD2 is to be processed, and then instructs, in response to the computation result thereof (the processing of the first computation using the first program PRG1), instructs (or indicates) processing of a second computation using the second program PRG2 in the second computing namespace CNS2 where the computation according to the execution command CMD3 is to be processed.

For example, when the execution command CMD2 is a command related to data decryption and the execution command CMD3 is a command related to data filtering, the fused execution command including the execution command CMD2 and the execution command CMD3 may be the execution command that instructs (or indicates) the execution of data decryption using the first program PRG1 related to the data decryption in the first computing namespace CNS1, and then instructs (or indicates) the execution of filtering of the decrypted data using the second program PRG2 for filtering data according to a predetermined (or alternatively, desired) standard in the second computing namespace CNS2.

Next, referring to <FIG> and <FIG>, the storage controller <NUM> processes computation according to the received fused execution command using the first computing namespace CNS <NUM> in which the first program PRG1 is activated and the second computing namespace CNS2 in which the second program PRG2 is activated (step S370).

For example, referring to <FIG>, the execution command CMD2 is stored in the command queue 510a, and the execution command CMD3 is stored in the command queue 510b.

The queue control engine 520a controls the DMA engine 530a to process computation according to the execution command CMD2 stored in the command queue 510a. Accordingly, the input data IDATA stored in the buffer memory <NUM> is transmitted to an input buffer (SRAM1) SR1 of the accelerator 540a (step S372). The accelerator 540a processes computation according to the execution command CMD2 and outputs the result thereof to the output buffer (SRAM2) SR2, and the data stored in the output buffer SR2 is transmitted to the buffer memory 221a of the flow controller (FC) <NUM> under the control of the DMA engine 530a, for example (step S373).

The queue control engine 520b controls the DMA engine 530b to process computation according to the execution command CMD3 stored in the command queue 510b. When the amount of data stored in the buffer memory 221a of the flow controller <NUM> (data subjected to computation according to the execution command CMD2) exceeds a predetermined (or alternatively, desired) range (e.g. exceeds a predetermined or desired level), the DMA engine 530b transmits the data stored in the buffer memory 221a of the flow controller <NUM> to the input buffer (SRAM1) SR3 of the accelerator 540b (step S374). In some example embodiments, when the buffer memory 221a of the flow controller <NUM> is full of data, the DMA engine 530b may transfer the data stored in the buffer memory 221a of the flow controller <NUM> to the input buffer SR3 of the accelerator 540b. Further, in some example embodiments, when the amount of data stored in the buffer memory 221a exceeds a predetermined (or alternatively, desired) range, the flow controller <NUM> may transfer the data stored in the buffer memory 221a to the input buffer SR3 of the accelerator 540b.

The accelerator 540b processes computation according to the execution command CMD3 and outputs the result thereof to the output buffer (SRAM4) SR4, and the data stored in the output buffer SR4 is stored in the form of the processed data PDATA in the buffer memory <NUM> under the control of the DMA engine 530b, for example (step S375).

For example, when the execution command CMD2 is a data decryption command and the execution command CMD3 is a data filtering command, the encrypted input data IDATA stored in the buffer memory <NUM> (the input data may be, for example, data transmitted from the nonvolatile memory <NUM> (see <FIG>)) may be stored in the buffer memory 221a of the flow controller <NUM> while being decrypted by the accelerator 540a, and the decrypted data may be filtered according to a predetermined (or alternatively, desired) standard by the accelerator 540b and the decrypted and filtered data may be stored in the form of the processed data PDATA in the buffer memory <NUM>.

In some example embodiments, the buffer memory <NUM> may include a DRAM. The input buffer SR1 and the output buffer SR2 of the accelerator 540a, the input buffer SR3 and the output buffer SR4 of the accelerator 540b, and the buffer memory 221a of the flow controller <NUM> may include an SRAM. However, the example embodiments of the present disclosure are not limited thereto. In an example, the buffer memory 221a is separated from the DRAM <NUM>.

<FIG> is a diagram illustrating effects of a comparative memory system.

<FIG> is a diagram illustrating an operation of processing computation according to a fused execution command in a memory system different from the above-described memory system. Referring to <FIG>, in a memory system different from the above-described memory system, after the input data IDATA stored in a buffer memory <NUM> is subjected to processing according to the first computation by the accelerator (ACC #<NUM>) <NUM>, the result thereof is stored in the form of intermediate data MDATA in the buffer memory <NUM>. Further, after the intermediate data MDATA stored in the buffer memory <NUM> is subjected to processing according to the second computation by the accelerator (ACC #<NUM>) <NUM>, the result thereof is stored in the form of the processed data PDATA in the buffer memory <NUM>. That is, if the number of execution commands included in the fused execution command is m (m being a natural number greater than or equal to <NUM>), at least <NUM> accesses to the buffer memory <NUM> including a DRAM are required (or alternatively, used).

The excessive accesses to the buffer memory <NUM> may adversely affect the computational performance of the computational storage device, thereby deteriorating the operation performance of the computational storage device. On the other hand, in the computational storage device according to the present example embodiment, there is no need to store intermediate data MDATA in the buffer memory <NUM> or to read the intermediate data MDATA from the buffer memory <NUM>, so that the operation performance of the computational storage device may be improved.

<FIG> are diagrams for describing an operation of a memory system according to some example embodiments. In the following description, redundant description of the above-described example embodiments will be omitted while focusing on differences.

Referring to <FIG>, the flow controller <NUM> of the memory system <NUM> according to the present example embodiment may include a first buffer memory (B <NUM>) 222a and a second buffer memory (B2) 222b.

The operation of the memory system <NUM> will be described as follows.

The DMA engine 530a controls the buffer memory <NUM> (step S401), and the input data IDATA stored in the buffer memory <NUM> is transmitted to the input buffer (SRAM1) SR1 of the accelerator 540a (step S402). The accelerator 540a processes the computation according to the first execution command on the data stored in the input buffer SR1 and outputs the result thereof to the output buffer (SRAM2) SR2, and the data stored in the output buffer SR2 is transmitted to the first buffer memory 222a of the flow controller <NUM> under the control of the DMA engine 530a (step S403). Accordingly, as shown in <FIG>, data is sequentially stored in the first buffer memory 222a.

When the amount of data stored in the first buffer memory 222a exceeds a predetermined (or alternatively, desired) range (for example, when the first buffer memory 222a is full), the DMA engine 530a or the flow controller <NUM> transmits the data stored in the first buffer memory 222a to the input buffer (SRAM1) SR3 of the accelerator 540b (step S404). At the same time, the data stored in the output buffer SR2 of the accelerator 540a is transmitted to the second buffer memory 222b of the flow controller <NUM> under the control of the DMA engine 530a, for example. That is, as shown in <FIG>, the operation of transmitting the data stored in the first buffer memory 222a to the input buffer SR3 of the accelerator 540b, and the operation of storing the data transmitted from the output buffer SR2 of the accelerator 540a in the second buffer memory 222b may be simultaneously or contemporaneously performed.

Thereafter, if the amount of data stored in the second buffer memory 222b exceeds a predetermined (or alternatively, desired) range (for example, if the second buffer memory 222b is full), the DMA engine 530a or the flow controller <NUM> transmits the data stored in the buffer memory 222b to the input buffer SR3 of the accelerator 540b. At the same time, the data stored in the output buffer SR2 of the accelerator 540a is transmitted to the first buffer memory 222a of the flow controller <NUM> under the control of the DMA engine 530a, for example. That is, as shown in <FIG>, the operation of transmitting the data stored in the second buffer memory 222b to the input buffer SR3 of the accelerator 540b, and the operation of storing the data transmitted from the output buffer SR2 of the accelerator 540a in the first buffer memory 222a may be simultaneously or contemporaneously performed.

Next, the accelerator 540b processes the computation according to the second execution command on the data stored in the input buffer SR3 and outputs the result thereof to the output buffer (SRAM2) SR4, and the data stored in the output buffer SR4 is stored in the form of the processed data PDATA in the buffer memory <NUM> under the control of the DMA engine 530b, for example (step S405).

That is, in the present example embodiment, the data is transferred while switching the first and second buffer memories 222a and 222b of the flow controller <NUM>, so that it is possible to perform a required (or alternatively, used) operation within a short time with a smaller amount than an actually required (or alternatively, used) buffer memory amount.

<FIG> is a diagram of a data center including a storage device according to some example embodiments.

Referring to <FIG>, a data center <NUM> is a facility that collects various types of data and provides services, and may be referred to as a data storage center. The data center <NUM> may be a system for operating a search engine and a database, or may be a computing system used in a government institution or a company such as a bank. The data center <NUM> may include application servers <NUM> to 3100n and storage servers <NUM> to <NUM>. The number of application servers <NUM> to 3100n and the number of storage servers <NUM> to <NUM> may be variously selected according to some example embodiments, and the number of application servers <NUM> to 3100n and the number of storage servers <NUM> to <NUM> may be different from each other.

The application server <NUM> or the storage server <NUM> may include at least one of processors <NUM> and <NUM> and memories <NUM> and <NUM>. When describing the storage server <NUM> as an example, the processor <NUM> may control the overall operation of the storage server <NUM>, and access the memory <NUM> to execute instructions and/or data loaded in the memory <NUM>. The memory <NUM> may be a double data rate synchronous DRAM (DDR SDRAM), a high bandwidth memory (HBM), a hybrid memory cube (HMC), a dual in-line memory module (DIMM), an Optane DIMM, and/or a nonvolatile DIMM (NVMDIMM). According to an example embodiment, the number of the processors <NUM> and the number of the memories <NUM> included in the storage server <NUM> may be variously selected. In one example embodiment, the processor <NUM> and the memory <NUM> may be provided as a processor-memory pair. In one example embodiment, the number of processors <NUM> and the number of memories <NUM> may be different. The processor <NUM> may include a single core processor or a multiple core processor. The above description of the storage server <NUM> may be similarly applied to the application server <NUM>. According to an example embodiment, the application server <NUM> may not include the storage device <NUM>. The storage server <NUM> may include at least one storage device <NUM>. The number of storage devices <NUM> included in the storage server <NUM> may be variously selected according to some example embodiments.

In some example embodiments, the storage device <NUM> may include the storage device <NUM> described with reference to <FIG>.

The application servers <NUM> to 3100n and the storage servers <NUM> to <NUM> may communicate with each other through the network <NUM>. The network <NUM> may be implemented using a Fiber Channel (FC), Ethernet, or the like. In this case, FC is a medium used for relatively high-speed data transmission, and an optical switch that provides high performance/high availability may be used. The storage servers <NUM> to <NUM> may be provided as file storage, block storage, or object storage according to an access method of the network <NUM>.

In one example embodiment, the network <NUM> may be a storage-only network such as a storage area network (SAN). As one example, the SAN may an FC-SAN that uses an FC network and is implemented according to FC Protocol (FCP). For another example, the SAN may be an IP-SAN that uses a TCP/IP network and is implemented according to an iSCSI (SCSI over TCP/IP or Internet SCSI) protocol. In another example embodiment, the network <NUM> may be a general network such as the TCP/IP network. For example, the network <NUM> may be implemented according to a protocol such as FC over Ethernet (FCoE), network attached storage (NAS), NVMe over Fabrics (NVMe-oF), or the like.

Hereinafter, a description will be given focusing on the application server <NUM> and the storage server <NUM>. The description of the application server <NUM> may also be applied to another application server 3100n, and the description of the storage server <NUM> may also be applied to another storage server <NUM>.

The application server <NUM> may store data requested to be stored by a user or a client in one of the storage servers <NUM> to <NUM> through the network <NUM>. In addition, the application server <NUM> may acquire data requested to be read by a user or a client from one of the storage servers <NUM> to <NUM> through the network <NUM>. For example, the application server <NUM> may be implemented as a web server, a database management system (DBMS), or the like.

The application server <NUM> may access a memory 3120n or a storage device 3150n included in another application server 3100n through the network <NUM>, or may access the memories <NUM> to <NUM> or the storage devices <NUM> to <NUM> included in the storage servers <NUM> to <NUM> through the network <NUM>. Accordingly, the application server <NUM> may perform various operations on data stored in the application servers <NUM> to 3100n and/or the storage servers <NUM> to <NUM>. For example, the application server <NUM> may execute a command for moving or copying data between the application servers <NUM> to 3100n and/or the storage servers <NUM> to <NUM>. At this time, the data may be transferred from the storage devices <NUM> to <NUM> of the storage servers <NUM> to <NUM> to the memories <NUM> to 3120n of the application servers <NUM>-3100n directly or through the memories <NUM> to <NUM> of the storage servers <NUM> to <NUM>. Data moving through the network <NUM> may be encrypted data for security or privacy.

Referring to the storage server <NUM> as an example, an interface <NUM> may provide a physical connection between the processor <NUM> and a controller <NUM> and a physical connection between a Network InterConnect (NIC) <NUM> and the controller <NUM>. For example, the interface <NUM> may be implemented in a direct attached storage (DAS) method in which the storage device <NUM> is directly connected with a dedicated cable. In addition, for example, the interface <NUM> may be implemented as various types of interfaces, such as advanced technology attachment (ATA), serial ATA (SATA), external SATA (e-SATA), small computer small interface (SCSI), serial attached SCSI (SAS), peripheral component interconnection (PCI), PCI express (PCIe), NVM express (NVMe), IEEE <NUM>, universal serial bus (USB), secure digital (SD) card, multi-media card (MMC), embedded multi-media card (eMMC), universal flash storage (UFS), embedded universal flash storage (eUFS), and/or compact flash (CF) card.

The storage server <NUM> may further include a switch <NUM> and the NIC <NUM>. The switch <NUM> may selectively connect the processor <NUM> to the storage device <NUM> or may selectively connect the NIC <NUM> to the storage device <NUM> under the control of the processor <NUM>.

In one example embodiment, the NIC <NUM> may include a network interface card, a network adapter, or the like. The NIC <NUM> may be connected to the network <NUM> through a wired interface, a wireless interface, a Bluetooth interface, an optical interface, or the like. The NIC <NUM> may include an internal memory, a digital signal processor (DSP), a host bus interface, or the like, and may be connected to the processor <NUM> and/or the switch <NUM> through the host bus interface. The host bus interface may be implemented as one of the examples of the interface <NUM> described above. In one example embodiment, the NIC <NUM> may be integrated with at least one of the processor <NUM>, the switch <NUM>, and the storage device <NUM>.

In the storage servers <NUM> to <NUM> or the application servers <NUM> to 3100n, the processor may send a command to the storage devices <NUM> to 3150n, <NUM> to <NUM> or the memories <NUM> to 3120n, <NUM> to <NUM> to program or read data. In this case, the data may be data that has been error-corrected through an error correction code (ECC) engine. The data may be data that has been processed by data bus inversion (DBI) or data masking (DM), and may include cyclic redundancy code (CRC) information. The data may be encrypted data for security or privacy.

The storage devices <NUM> to 3150n and <NUM> to <NUM> may transmit a control signal and a command/address signal to NAND flash memory devices <NUM> to <NUM> in response to a read command received from the processor. Accordingly, when data is read from the NAND flash memory device <NUM> to <NUM>, a read enable (RE) signal may serve to be inputted as a data output control signal and to output data to the DQ bus. The data strobe signal (DQS) may be generated by using the RE signal. The command and address signals may be latched in the page buffer according to the rising edge or falling edge of a write enable (WE) signal.

The controller <NUM> may overall control the operation of the storage device <NUM>. In one example embodiment, the controller <NUM> may include a static random access memory (SRAM). The controller <NUM> may write data to the NAND flash <NUM> in response to a write command, or read data from the NAND flash <NUM> in response to a read command. For example, the write command and/or the read command may be provided from the processor <NUM> in the storage server <NUM>, the processor <NUM> in another storage server <NUM>, or the processors <NUM> to 3110n in the application servers <NUM> to 3100n. The DRAM <NUM> may temporarily store (buffer) data to be written to the NAND flash <NUM> or data read from the NAND flash <NUM>. In addition, the DRAM <NUM> may store metadata. Here, the metadata is data generated by the controller <NUM> to manage the user data or the NAND flash <NUM>. The storage device <NUM> may include a secure element (SE) for security or privacy.

Any of the elements and/or functional blocks disclosed above may include or be implemented in processing circuitry such as hardware including logic circuits; a hardware/software combination such as a processor executing software; or a combination thereof. For example, the packet manager <NUM>, the host controller <NUM>, the control logic <NUM>, the storage controller <NUM>, accelerator <NUM>, the processor <NUM>, <NUM>, and controller <NUM> may be implemented as processing circuitry. The processing circuitry specifically may include, but is not limited to, a central processing unit (CPU), an arithmetic logic unit (ALU), a digital signal processor, a microcomputer, a field programmable gate array (FPGA), a System-on-Chip (SoC), a programmable logic unit, a microprocessor, application-specific integrated circuit (ASIC), etc. The processing circuitry may include electrical components such as at least one of transistors, resistors, capacitors, etc. The processing circuitry may include electrical components such as logic gates including at least one of AND gates, OR gates, NAND gates, NOT gates, etc..

Processor(s), controller(s), and/or processing circuitry may be configured to perform actions or steps by being specifically programmed to perform those action or steps (such as with an FPGA or ASIC) or may be configured to perform actions or steps by executing instructions received from a memory, or a combination thereof.

Claim 1:
A method for operating a computational storage device, comprising:
receiving, by a storage controller (<NUM>), a first computing namespace setting instruction from a first host device;
receiving, by the storage controller, a second computing namespace setting instruction from a second host device;
receiving, by the storage controller, a first program from the first host device;
receiving, by the storage controller, a second program from the second host device;
receiving, by the storage controller, a fused execution command, the fused execution command indicating to process a first computation using the first program in the first computing namespace and, indicating to, in response to a first computation result of processing the first computation, process a second computation using the second program in the second computing namespace;
processing, by a first accelerator (<NUM>, 540a), the first computation;
storing, by the storage controller, in a buffer memory (<NUM>) the first computation result obtained by processing the first computation;
providing, by the storage controller, data stored in the buffer memory to a second accelerator (<NUM>, 540b) different from the first accelerator, in response to an amount of data stored in the buffer memory exceeding a range; and
processing, by the second accelerator, the second computation on the data provided from the buffer memory.