DE102018113885A1 - Memory-efficient persistent key-value memory for non-volatile memory - Google Patents

Abstract

Aspects of the disclosure provide a memory-efficient persistent key-value storage for a solid-state device (SSD). The methods and apparatus provide a non-volatile memory (NVM) and key-value memory (KVS) processor. Non-volatile memory (NVM) is configured to store a key-value data structure. The KVS processor is configured to receive a key value store (KVS) command from a host. The KVS processor is also configured to perform a key value store (KVS) operation in the key value data structure based on the received KVS command. Performing the key-value memory (KVS) operation may include using an index structure to process the key-value data structure based on the received KVS instruction. The KVS processor is further configured to provide a response to the host based on the KVS operation.

Description

CROSS REFERENCE TO RELATED APPLICATION (S)

This application claims the priority and benefit of the provisional US Application No. 62 / 519,094 filed on 13 June 2017 with reference No SDA-3265P-US (WDT-1209P) and entitled "MEMORY EFFICIENT PERSISTENT KEY-VALUE STORE FOR NON-VOLATILE MEMORIES", the entire contents of which are hereby incorporated by reference ,

AREA

The present invention relates to nonvolatile memory, and more particularly to memory efficient persistent key value memory for nonvolatile memory.

INTRODUCTION

Key-value memory (KVS) is often used in various large-scale data-intensive database applications. These database applications have random accesses to large datasets and, because of their high scalability and simplicity, have opted for key-value storage rather than a traditional relational database. Several researches have been conducted on flash-based KVS to exploit the flash characteristics to improve performance and reduce the main memory consumption of the host or main computer. This KVS activity is to keep key-value (KV) pairs in Flash and an index structure (or metadata per KV pair) in main memory (for example, dynamic random access memory or DRAM) for fast inserts , Delete, and lookup operations. However, the power of KVS is still limited by the large input / output (I / O) overhead and input memory (flash is about 100x slower than DRAM) and main memory size, since the amount of digital data is two every two Doubled in years and by 2020 to 44 zettabytes (44 billion gigabytes) increases.

Memory size represents a challenging scalability and performance challenge due to the relatively slow growth in DRAM capacity compared to the fast-growing key-value (KV) datasets. More than 10 to 250-fold slowdown due to increasing I / O "In-Storage-Linked-List-Traversal" due to hash table collisions was observed for different KV workloads.

Emerging technologies with fast byte-addressable non-volatile memory (eNVM) technologies such as ReRAM and 3D Xpoint have been designed to deliver two-fold higher performance than Flash. However, the existing solid state device (SSD) architecture optimizes the flash characteristics and is not sufficient to fully exploit the full potential of eNVM due to architecture and I / O interfaces (such as PCIe, SATA) limitations exploit.

To improve memory performance and reduce host main memory requirements for KVS, an improved SSD architecture is proposed that provides better performance in processing large key-value records.

SUMMARY

In one aspect, a solid state device (SSD) comprising a nonvolatile memory (NVM) and a key value memory (KVS) processor is disclosed. Non-volatile memory (NVM) is configured to store a key-value data structure. The KVS processor is configured to receive a key value store (KVS) command from a host or host computer. The KVS processor is also configured to perform a key value memory (KVS) operation on the key value data structure based on the received KVS command. Performing the key value memory (KVS) operation may include using an index structure to process the key value data structure based on the received KVS instruction. The KVS processor is further configured to provide a response to the host based on the KVS operation.

In another aspect, a method of operating a solid state device (SSD) is disclosed. The method stores a key value data structure on nonvolatile memory (NVM) of the SSD. The method receives a key value store (KVS) command from the host. The method identifies an entry of an index structure based on the received KVS instruction in the SSD. The method identifies a set of key value data from the key value data structure based on the identified entry. The method processes one or more key-value data from the identified group of key-value data based on the received KVS command in the SSD. The method provides the host with a response based on the processing of the one or more key-value data.

In another aspect, an apparatus for operating a solid state device (SSD) is disclosed. The apparatus comprises means for nonvolatile storage of a key value data structure and means for key value memory (KVS) processing. The means for key value memory (KVS) processing comprise means for receiving a key value memory (KVS) command from a host, means for performing a key value memory (KVS) operation on the key value data structure based on the received KVS command, and means for providing or Provide a response to the host based on the KVS operation. The means for performing the key value memory (KVS) operation include generating a hash value based on the received KVS instruction.

list of figures

• 1 FIG. 12 shows a block diagram of a solid state device (SSD) including a key value memory (KVS) processor in accordance with embodiments of the present disclosure.
• 2 shows a block diagram of a key value memory (KVS) processor in accordance with embodiments of the present disclosure.
• 3 shows a diagram of a device architecture between a host and a solid state device (SSD) in accordance with embodiments of the present disclosure.
• 4 FIG. 12 is a diagram of a multi-stranded device architecture between a host and a solid state device (SSD) in accordance with embodiments of the present disclosure. FIG.
• 5 FIG. 12 shows a flow chart of a method for processing a key value store (KVS) command from a host through a solid state device (SSD) in accordance with embodiments of the present disclosure.
• 6 FIG. 12 is a flowchart of a method for processing a non-key-value memory (KVS) command from a host through a solid-state device (SSD) in accordance with embodiments of the present disclosure.
• 7 (which the 7A-7C 5) shows a flowchart of a GET command from a host through a solid state device (SSD) in accordance with embodiments of the present disclosure.
• 8th (which the 8A-8C 5) shows a flowchart of a PUT or issue command from a host through a solid state device (SSD) in accordance with embodiments of the present disclosure.
• 9 (which the 9A-9B 5) shows a flow chart of another PUT or issue command from a host through a solid state device (SSD) in accordance with embodiments of the present disclosure.
• 10 (which the 10A-10C 5) shows a flowchart of a DELETE command from a host through a solid state device (SSD) in accordance with embodiments of the present disclosure.
• 11 FIG. 12 shows an exemplary flowchart of a method for processing various instructions from a host through a solid state device (SSD) in accordance with embodiments of the present disclosure.
• twelve FIG. 12 shows an exemplary flowchart for processing a key value store (KVS) command from a host through a solid state device (SSD) in accordance with embodiments of the present disclosure.

DETAILED DESCRIPTION

The present disclosure provides a solid state device (SSD) comprising a nonvolatile memory (NVM) and a key value memory (KVS) processor. Non-volatile memory (NVM) is configured to store a key data structure. The KVS processor is configured to receive a key value store (KVS) command from a host. Examples of key value store (KVS) commands include a get command, a put command, and a delete command. The KVS processor is also configured to perform a key value memory (KVS) operation on the key value data structure based on the received KVS command. Performing the key value memory (KVS) operation may include using an index structure to process the key value data structure based on the received KVS instruction. The KVS processor is further configured to provide a response to the host based on the KVS operation.

Other approaches to KVS processing mainly use caching and efficient indexing schemes to improve performance and reduce I / O overhead, while the disclosed solid state device (SSD) handles both the key-value data and can keep the index structure in the SSD, thereby reducing the amount of key-value data that is transferred to a host. In addition, the disclosed methods may outsource key value memory operations on the SSD to take advantage of the low latency, high internal bandwidth of NVM, and parallelism across multiple controllers. The disclosed SSD may implement indexing capability within the SSD and has an in-memory or memory-based processing engine (such as a KVS processor) of key value operations such as Get, Put, and Delete or Delete implemented to work efficiently with key-value (KV) records.

1 shows a block diagram of a system 100 that has a solid-state device (SSD) with key-value storage (KVS) processing functionality. The system 100 has a solid state device (SSD) 102 and a host 104 on. The SSD 102 is a storage device (such as an SSD storage device). The SSD 102 is with the host 104 over one or more connections 106 coupled. The one or more connections 106 provide physical input / output (I / O) data connections between the SSD 102 and the host 104 ready. Data between the SSD 102 and the host 104 hiking, can be referred to as I / O effort. Data may include instructions, commands, and / or answers.

The host 104 may be any system and / or device that has a need for data storage or retrieval and a compatible interface for communicating with the SSD. For example, the host 104 a computing device, a personal computer, a portable computer, a workstation, a server, a router, a network device, a personal digital assistant (PDA), a digital camera, a digital telephone, or combinations thereof. The host 104 can have multiple hosts. The host 104 can one from the SSD 102 be separate (such as physically separate) device. In some embodiments, the host may 104 the SSD 102 exhibit. In other embodiments, the SSD is 102 opposite the host 104 removed or contained in a remote computer system that communicates with the host 104 is coupled. For example, the host 104 with the SSD 102 communicate over a wireless communication link.

The host 104 delivers commands to the SSD 102 for data transfer between the host 104 and the SSD 102 , For example, the host 104 a write command to the SSD 102 for writing data to or into the SSD 102 , or a read command to the SSD 102 for reading data from or from the SSD 102 deliver. The SSD 102 can be a response to the write command or the read command to the host 104 over one or more connections 106 deliver. As described below, the SSD 102 various types of instructions, key-value memory (KVS) instructions and non-key-value memory (KVS) instructions from the host 104 include, process. KVS commands and non-KVS commands are described below.

The SSD storage device 102 indicates a host interface or an interface 110 , a bridge 112 , a buffer 114 , a crossbar or traverse 116 , a key value memory (KVS) processor 118 , a processor 120 (or alternatively an NVM processor 120 ), a random access memory (RAM) 122 , a non-volatile memory interface or interface (NVM interface) 124 (which may also be referred to as a flash memory interface) and nonvolatile memory (NVM) 126 , such as a NAND flash memory.

The host interface 110 is with the processor 120 across the bridge 112 and the cross bar 116 coupled. It should be noted that the host interface 110 different with the processor 120 can be coupled. For example, the host interface 110 with the processor 120 be directly coupled. In another example, the host interface 110 with the processor 120 across the bridge 112 be coupled without them with the cross bar 116 must be coupled. The host interface 110 facilitates communication between the host 104 and other components of the SSD 102 such as the processor 120 and / or the KVS processor 118 , The host interface 110 may be any type of communication interface, such as an Integrated Drive Electronics (IDE) interface, a Universal Serial Bus (USB) interface, a Serial Peripheral (SP) interface, an Advanced Technology Attachment ( ATA) or Serial Advanced Technology Attachment (SATA) interface, a Small Computer System Interface (SCSI), an IEEE 1394 (Firewire) interface, or the like.

The bridge 112 is with the key value memory (KVS) processor 118 over the buffer 114 coupled. In some embodiments, the bridge 112 a part of the host interface 110 be. The buffer 114 Helps manage the flow of data between the KVS processor 118 and the bridge 112 , The KVS processor 118 is with the processor 120 over the cross bar 116 coupled. The KVS processor 118 may represent one or more KVS processors. In some embodiments, the KVS processor is 118 with the processor 120 coupled without crossing the crossbar 116 to run. The cross bar 116 Helps to manage the flow of data between the KVS processor 118 and the processor 120 migrates, and the data flow between the bridge 112 and the processor 120 , The various components or components of the SSD 102 can communicate with each other using a communication protocol (such as an Advance eXtensible Interface (AXI) protocol). In some embodiments, the cross-bar 116 a part of the bridge 112 be.

The bridge 112 is configured to determine whether commands are from the host 104 (via the host interface 110 ) Are KVS commands or non-KVS commands. If the commands are non-KVS commands, the bridge may 112 the commands to the processor 120 over the cross bar 116 conduct or send. If the commands are KVS commands, the bridge can 112 the commands to the KVS processor 118 conduct or send. The KVS commands are issued by the KVS processor 118 processed, and the processed KVS commands are then sent to the processor 120 directed or sent. Examples of KVS instructions include a Get command, a Put command, and a Delete command. Examples of the processing of KVS commands are at least below 2 . 5 . 7A-7C . 8A-8B . 9A-9C and 10A-10C described. Thus, a functionality is the SSD 102 provides the possibility of processing various types of commands. This allows the SSD 102 operating and working with a larger number of devices, systems, hosts and / or applications than other SSDs. In addition, the ability to process key-value data on the SSD reduces the I / O overhead between the host and the SSD, thus accelerating the overall performance of the SSD.

The processor 120 is with the RAM memory 112 as with the NVM 126 via the NVM interface 124 coupled. The processor 120 controls the operation of the SSD 102 , In various aspects, the processor receives 120 Commands from the host 104 via the host interface 110 and performs the commands (such as KVS commands, non-KVS commands) to transfer data between the host 104 and the NVM 126 transferred to. As mentioned above, if the instruction is a KVS instruction, the processor may be 120 Commands by the KVS processor 118 receive. In addition, the processor can 120 reading from and writing to or to the memory 122 manage to perform the various functions performed by the processor 120 and the cached information stored in the memory 122 is stored, maintained and managed.

The processor 120 and / or the KVS processor 118 For example, any type of processing device, such as a microprocessor, a microcontroller, an enclosed controller, a logic circuit, software, firmware, or the like, may be used to control the operation of the SSD 102 , exhibit. In some aspects, some or all of the functions can be considered here by the processor 120 instead of being handled by another component of the SSD 102 be performed. For example, the SSD 102 a microprocessor, a microcontroller, an enclosed controller, a logic circuit, software, firmware, or any type of processing device for performing one or more of the functions referred to herein as by the processor 120 be performed, described, have. In some embodiments, the KVS processor 118 a part of the processor 120 be. In other aspects, one or more functions are referred to herein as by the processor 120 are performed instead of the host 104 carried out. In yet other aspects, some or all of the functions may be considered here by the processor 120 instead be performed by other components, such as a processor in a hybrid drive containing both non-volatile memory elements and magnetic memory elements.

The memory 122 may be any memory, computing device or system capable of storing data. For example, the memory 122 a Random Access Memory (RAM), a Dynamic Random Access Memory (DRAM), a Double Data Rate (DDR) DRAM, a Static Random Access Memory (SRAM), a Synchronous Dynamic Random Access Memory (SDRAM), Flash Memory, Erasable Programmable Read Only Memory (EPROM), Electrically Erasable Programmable Read Only Memory (EEPROM), or the like. In various embodiments, the processor uses 120 the memory 122 or part of it to data during data transfer between the host 104 and the NVM 126 save. For example, the memory 122 or part of the memory 122 a cache.

The NVM 126 receives data from the processor 120 via the NVM interface 124 and saves the data. The NVM 126 may be any type of nonvolatile memory, such as a flash memory system, a NAND type flash memory, a solid state device (SSD), a flash memory card, a Secure Digital (SD) card, a Universal Serial Bus (USB), Storage device, a CompactFlash card, a SmartMedia Device, a flash memory array or the like.

KEY-only memory (KVS) processor

As mentioned above, this includes the SSD 102 a key value memory (KVS) processor 118 , the SSD 102 allows KVS commands to be processed on key value (KV) databases. KV databases arrange data as a single opaque collection. This allows more flexibility in the type of data that can be stored. In addition, a KV database uses less memory for the same number of records than other database structures, such as relational databases (RBD). KVS commands are used to access KV databases. KVS commands are commands that are specific to KV databases. These KVS instructions perform very specific functions with respect to a KV database. Outside the KV database, these KVS commands do not work. Examples of KVS commands are get commands, put commands, and delete commands.

2 shows a block diagram of the KVS processor 118 , The KVS processor 118 may represent one or more KVS processors. The KVS processor 118 is configured to perform a key value store (KVS) operation on a key value data structure based on a KVS instruction. A key value memory (KVS) operation may have a hash operation, which is described at least below 7A-7C and twelve is described.

The KVS processor 118 has one or more key-value storage (KVS) cores 200 , a hash control 202 , a planner 204 , an indexer 206 , a distributor or referrer 208 and a Direct Memory Access (DMA) control 210 on. The KVS cores 200 are with the hash control 202 , the planner 204 , the indexer 206 , the distributor 208 and the DMA controller 210 coupled. The DMA control 210 is with the cross bar 116 coupled. The hash control 202 is with the planner 204 coupled.

The planner 204 manages commands from the host 104 (via the host interface 110 , the bridge 112 , the buffer 1140 ) and answers the host 104 , The planner 204 can commands 220 from or out of the buffer 114 receive and plan under First-In-First-Out (FIFO). In the same way, the planner 204 reply 222 to the buffer 114 Send under First-In-First-Out (FIFO). In some embodiments, the planner may 204 Apply round-robin scheduling to the various commands. The planner 204 can issue commands to different cores of KVS cores 200 conduct. This allows the KVS processor 118 to process several commands in parallel. The planner 204 can also schedule commands to be processed sequentially by the same core when hash collision occurs in KV records. As the KV records increase, hash collisions also increase. A hash collision will continue at least in the below 7A-7C described.

The hash control 202 performs hash calculations on KVS commands. A hash calculation may include a hash value based on a key associated with a command received from the host. In some embodiments, a hash calculation may include using a hash function to map data (eg, keys) of any size to data (eg, hash value) of a specified size. The hash function can be used to map a key to a key-value data structure, where the key with an index structure can be used to point to a group (eg, bucket) in the key-value data structure that contains one or more combinations of one Keys and a value stores. The number of possible keys is usually greater than the number of entries (eg hash values) in the index structure. Each entry (eg hash value) in the index structure points to a specific location (eg group, container, a specific key-value combination of the group) in the key-value data structure. The specific location may be a particular location of a key-value combination of the group. A hash function can generate the same hash value for different keys, known as a hash collision. Thus, different keys may be part of the same group (eg, container) in the key value data structure. A specific location (eg, group, container) in the key value data structure may store more than one combination of a key and a value (eg, one or more combinations of a stored key and a stored value). A particular location of the key-value data structure may include one or more physical addresses. In some embodiments, a particular location of the key-value data structure may refer to a location of the key-value data structure or to multiple locations of the key-value data structure. The hashing or disassembling will continue at least in the below 7A-7C described.

The indexer 206 is configured to look up an index structure and provides a physical address location of a particular group (eg, container) for the key-value data structure. The indexer 206 also leads one Update of new physical addresses for an index structure by. The indexer 206 can also use a bitmap structure to provide a valid pointer check.

The distributor 208 is configured to include available and retrievable and used blocks (eg, storage blocks), memory blocks (memory blocks) inside the SSD 102 manage. The distributor 208 can storage blocks inside the SSD 102 distribute or assign and / or cancel their distribution or assignment. The distributor 208 can use a bitmap structure to manage the memory blocks. The DMA control 210 is configured to transfer data to and from the NVM to / from local storage via the crossbar 116 to load and / or store. The KVS cores 200 are configured to perform various KVS commands, such as a Get command, a Put command, and a Delete command. The KVS cores 200 can change the index structure from the hash control 202 receive. The KVS cores 200 can with the indexer 206 communicate to get or receive physical address pointers. The KVS cores 200 can with the dma control 210 communicate to load data to or into local storage. The KVS cores 200 can with the distributor 208 communicate to perform a distribution and / or the suspension of the distribution of blocks.

DEVICE OR BZW. DEVICE ARCHITECTURE

3 and 4 illustrate how data may be packaged and processed on the device or device side (eg, host device) when the device (eg, host) is coupled to an SSD having KVS functionality. In a traditional system host, any access to the stored data through the system software I / O stack or stack will cause significant overhead to the operating system and data system. In the 3 and 4 described device architecture (s) improve the existing software stack by providing direct access to the key value storage data to improve overall performance. 3 FIG. 12 is a diagram of an exemplary device architecture between a host and a solid state device (SSD) having KVS functionality. FIG. The device or device architecture 300 has an application layer 302 , a key-value (KVS) library layer 304 , an input / output (I / O) stack layer 306 (eg, data system and operating system I / O stack) and a device or device driver layer 308 on. The device or device architecture 300 enables a device or a device (eg host) with a solid state device (SSD) 320 communicate that has KVS functionality.

The application layer 302 specifies or determines special commands and data (eg web browser commands, data from web pages). The KVS library layer 304 has a command for obtaining, updating, outputting and / or deleting data stored in a key value data structure. Commands for the KVS library layer 304 have a Get command, a Put command and a Delete command. The KVS library layer 304 translates the data of the application layer 302 so that they can be processed in a key-value data structure. The I / O stack layer 306 can translate KVS addresses into device or device addresses. For example, the I / O stack layer 306 Translate key value data structure addresses into device or device addresses (eg host addresses). The device or device driver layer 308 is an interface that allows the device or device (eg host) with the memory 320 to communicate. The memory 320 In some embodiments, the SSD 102 be.

As in 3 an application may be shown on or in a device (eg, host) that supports the device architecture 300 has to communicate with an SSD in several ways. In one embodiment, the application (eg browser application) may be with the memory 320 through the application layer 302 , the KVS library layer 304 , the I / O stack layer 306 and the device or driver layer 308 communicate. In some embodiments, the application (eg browser application) may be with the memory 320 through the application layer 302 and the KVS library layer 304 communicate by one or more functionalities and / or translations of other architectural layers of the device architecture 300 bypassed or bridged. For example, some or all KVS commands must be from or out of the KVS library layer 304 not translated. This is possible because of the memory 320 Has KVS functionality, reducing memory 320 capable of the KVS library layer 304 , such as KVS commands.

4 FIG. 12 shows a diagram of an exemplary device architecture between a host and a solid state device (SSD) having KVS functionality with multiple strings between the host and the SSD. 4 shows a host running an SSD through multiple communication channels (eg channel 1 , Channel 2 , ... channel N), each channel having a string. The first strand 400 uses the first channel 1 , of the second strand 410 uses the second channel 2 and the third strand 420 uses a third channel N. The strands can be operated in parallel. Each strand has the application layer 302 , the key-value storage (KVS) library layer 304 , the input / output (I / O) stack layer 306 , and the device driver layer 308 on. Each thread may include a ring register, a command queue (eg, KVS commands), and a reply queue.

EXAMPLE EXHAUST PHRASES BZW. PROCESS SEQUENCES OF A SOLID STATE DEVICE (SSD) PROCESSING KEY VALUE MEMORY (KVS) COMMANDS AND NON-KVS COMMANDS

5 and 6 illustrate flow sequences of a solid-state device (SSD) that processes a key-value memory (KVS) command and a non-KVS command. The sequence sequences shown in FIGS. 5 and 6 may be of any SSD described in the present disclosure, such as the SSD 102 , be performed. For the sake of clarity, the in 5 and 6 Sequence sequences shown not necessarily all components or components of the SSD, the in 5 and 6 performs described operations. For example, one or more of the described data (eg, command, response) may pass through one or more buffers and / or one or more crossbars as they are moved between the various components of the SSD. In some embodiments, the in 5 and 6 Sequences shown have other operations performed by the SSD.

FIG. 5 illustrates a sequence of operations 500 passing through an SSD 501 that with a host (eg host 104 ) is performed. The sequence of events 500 includes the processing of KVS commands by the SSD 501 , The SSD 501 has a host interface 502 , a bridge 504 , a key value memory (KVS) processor 506 , a processor 508 and a nonvolatile memory (NVM) 510 on. In one aspect, the NVM is implemented as a NAND memory.

As in 5 shown sends the host interface 502 a key value memory (KVS) command to the bridge 504 (at 512 ). The KVS command can be through the host interface 502 from or from a host (eg 104 ) are received. Examples of KVS instructions include a Get command, a Put command, and a Delete command. In some embodiments, KVS instructions are instructions that do not have the physical address (s) of data to be processed (eg, an instruction free of physical address information) when the instruction is transmitted by the host and / or through the host SSD is received. The bridge 504 determined (at 514 ) that the command is a KVS command and sends (at 516 ) the KVS command to the KVS processor 506 , The KVS processor 506 processed (at 518 ) the KVS instruction, which involves performing a hash calculation to generate a hash value, and using an index structure to identify a location (eg, group, key-value combination) in the key-value data structure. In some embodiments, identifying the location includes identifying a physical address of a combination of a key and a value in the NVM 510 , In some embodiments, identifying the location includes identifying a physical address associated with a group of combinations of a key and a value in the NVM 510 is associated or connected.

The KVS processor 506 sends (at 520 ) a command comprising an address of the data to the processor 508 , The processor 508 processed (at 522 ) the command from or from the KVS processor 506 , The processor 508 sends (at 524 ) command to the NVM 510 , The NVM 510 engages (at 526 ) to the data based on the command to. Accessing the data may involve reading the data at a specific physical address of the NVM 510 and / or writing data to a specific physical address of the NVM 510 include.

The NVM 510 sends (at 528 ) the response to the command to the processor 508 where the answer is processed (at 530 ). The response may include data (eg, key, value, pointer, acknowledgment, error). The processor 508 sends (at 532 ) the answer to the KVS processor 506 , The KVS processor 506 processed (at 534 ) the answer and send (at 536 ) the answer to the bridge 504 , The bridge 504 processed (at 538 ) the answer and send (at 540 ) the response to the host interface 502 , The host interface 502 sends the response to the host (eg 104 ). The above sequence of events 500 can often be executed sequentially or in parallel with other commands (eg KVS commands, non-KVS commands).

FIG. 6 shows a sequence of operations 600 passing through the SSD 501 that with a host (eg host 104 ) is performed. The sequence of events 600 includes the processing of non-KVS commands by the SSD 501 , The SSD 501 includes the host interface 502 , the bridge 504 , the Key Value Memory (KVS) processor 506 , the processor 508 and non-volatile memory (NVM) 510 ,

As in 6 shown sends the host interface 502 (at 612 ) a non-key-value memory (KVS) command to the bridge 504 , The non-KVS command can be through the host interface 502 from a host (eg 104 ) are received. Non-KVS commands include commands that are not specifically limited to a key value storage database. That is, non-KVS commands are commands that can be used in non-key-value storage databases. Examples of non-KVS commands include read commands and / or write commands. In some embodiments, non-KVS instructions are instructions that include a physical address (or addresses) of the data that is to be processed when the instruction is transmitted by the host and / or received by the SSD. The bridge 504 determined (at 614 ) that the command is a non-KVS command and sends (at 616 ) the non-KVS command to the processor 508 , In some embodiments, the non-KVS command may include address information (eg, a physical address of data in or on the NVM 510 ). The non-KVS command bypasses or bypasses the KVS processor 506 , The processor 508 processed (at 622 ) the non-KVS command from or from the bridge 504 , The processor 508 sends (at 524 ) command to the NVM 510 , The NVM 510 engages (at 626 ) to the data based on the command to. Accessing the data may involve reading the data at a specific physical address of the NVM 510 and / or writing data to a specific physical address of the NVM 510 include.

The NVM 510 sends (at 628 ) the response to the command to the processor 508 where the answer is processed (at 630 ) becomes. The answer may include various data (eg, key, value, pointer, acknowledgment, error). The processor 508 sends (at 632 ) the answer to the bridge 504 , The answer bypasses or bypasses the KVS processor 506 , The bridge 504 processed (at 638 ) the answer and send (at 640 ) the response to the host interface 502 , The host interface 502 sends the response to the host (eg 104 ). The above sequence of events 600 can be performed several times sequentially or in parallel with other commands (eg KVS commands, non-KVS commands).

7 (which the 7A-7C includes) shows a flow sequence of a solid state device (SSD) performing a key value memory (KVS) command. In particular shows 7 a sequence of a get command from or from a host performed by an SSD.

As in 7A As shown, the SSD receives a Get command 710 from a host. The get or get command 710 specifies the SSD to get a value that can be set with a key ( K3 ) is associated or associated. The KVS processor 700 of the SSD performs a hash operation on the key ( K3 ), which has a hash value 720 generated. The hash value 720 is then on or in the index structure 704 used to group out or from the key-value data structure 702 to identify. In this particular case, the hash value shows 720 to an entry in the index structure 704 , the group 0 identified. group 0 points to the keys ( K1 ) - and value ( V1 )-Combination 730 in the key-value data structure 702 , In some embodiments, the entry of the index structure comprises the group 0 a pointer that is a physical address of the combination 730 from a key ( K1 ) and a value ( V1 ) in the key-value data structure 702 (which is stored in the NVM of the SSD). The group of a key-value data structure may be empty or comprise one or more key-value data (eg combination of a key and a value). Even if the pointer in the index structure 704 on the combination 730 from a key ( K1 ) and a value ( V1 ), the pointer may act as a pointer to the group 0 the key-value data structure 702 to be viewed as. Different embodiments may be the index structure 704 store differently. The SSD calls the combination 730 from a conclusion ( K1 ) and a value ( V1 ) from or from the key-value data structure 702 and read them, and then compare the key ( K1 ) of the combination 730 with the key ( K3 ) of the command 710 , In this case, the keys do not match and the SSD retrieves the next combination of a key and a value. The next combination of a key and value is indicated by a pointer, which is the combination of the key ( K1 ) and the value ( V1 ) is determined. The pointer may be a physical address of the next combination of a key and a value. In this example, the next combination of a key and a value is the combination of a key ( K2 ) and a value ( V2 ).

7B shows the SSD that the combination 732 from the key ( K2 ) and the value ( V2 ), which is also part of the group 0 is. The SSD calls the combination 732 from the key ( K2 ) and the value ( V2 ) from the key-value data structure 702 and read them, and compare the key ( K2 ) of the combination 732 then with the key ( K3 ) of the command 710 , The keys also do not match this time, and the SSD retrieves the next combination of a key and a value. The location of the next combination of a key and a value is as a pointer (eg physical address pointer) in the combination 732 from the key ( K2 ) and the value ( V2 ) saved. The pointer points to the combination of the key ( K3 ) and the value ( V3 ).

7C shows the SSD that the combination 732 from the key ( K2 ) and the value ( V2 ), which is also part of the group 0 is (which may mean that they are part of the same container). The SSD calls the combination 734 from the key ( K3 ) and the value ( V3 ) from or from the key-value data structure 702 and read them, and then compare the key ( K3 ) of the combination 734 from the key and the value with the key ( K3 ) of the command 710 , The keys now match, and the SSD provides an answer 740 to the host, where the answer is the value ( V3 ) from the combination 734 from the key and the value.

In this configuration, due to the hash collision, multiple combinations of a key and a value are in the same group (eg, container). Among other processing operations, all combinations of a key and a value are over the connection 106 to the host 104 which creates unnecessary I / O overhead between the SSD and the host. This slows down the overall performance of the SSD. However, by only transmitting the combination of a key and a value that matches, the I / O overhead between the SSD and the host is significantly reduced. While the processors (eg, KVS processor) of the SSD are likely to be slower than the processors of the host, the benefit achieved by not having to transmit all the combinations of a key and a value outweighs any disadvantages caused by the use of a key Processor, which is located on or in the SSD can arise, especially in cases where the database is very large and there is a high occurrence of hash collision in the records. The above scenario also applies to other types of KVS commands.

8th (which the 8A-8B includes) shows a flow sequence of a solid state device (SSD) performing a key value memory (KVS) command. In particular shows 8th a sequence of a put command from a host performed by an SSD, the put command comprising writing a new combination of a key and a value.

As in 8A As shown, the SSD receives a put command 810 from a host. The put or output command 810 Specifies the SSD to store a new combination of a key and a value. In particular, the put or issue command specifies 810 saving a combination 834 from a key ( K5 ) and a value ( V5 ). The KVS processor 800 of the SSD performs a hash operation on the key ( K5 ), which gives a hash value 820 is produced. The hash value 820 will then be on the index structure 804 applied to a group from or out of the key-value data structure 802 to identify. In this particular case, the hash value shows 820 to an entry in the index structure 804 , the group 1 identified. group 1 points to the combination 830 from the key ( K4 ) and the value ( V4 ) in the key-value data structure 802 , In some embodiments, the entry comprises the index structure for group 1 a pointer containing a physical address of the combination 830 from the key ( K4 ) and the value ( V4 ) in the key-value data structure 802 is. The key-value data structure 802 is stored in the NVM of the SSD. The group of a key-value data structure may be empty or comprise one or more key-value data (eg combination of a key and a value). Even if the pointer in the index structure 804 on the combination 830 from the key ( K4 ) and the value ( V4 ) - shows, the pointer can be used as a pointer to the group 1 the key-value data structure 802 to be viewed as. The SSD calls the combination 830 from the key ( K4 ) and the value ( V4 ) 830 from or out of the key-value data structure 802 and read them, and then compare the key ( K4 ) of the combination 830 with the key ( K5 ) of the command 810 , In this case, the keys do not match and the SSD retrieves the next combination of a key and a value from the group. The next combination of a key and a value is specified by a pointer that appears at the combination of the key ( K4 ) and the value ( V4 ) is located. The pointer may be a physical address of the next combination of a key and a value. However, in this example, there is no other combination of a key and a value in the group 1 , Because in the group 1 no other combination of a key and a value, the SSD can be the combination 834 from the key ( K5 ) and the value ( V5 ) after the combination 830 from the key ( K4 ) and the value ( V4 ) Add.

8B shows the SSD that the combination 834 from the key ( K5 ) and the value ( V5 ) into or onto the key-value data structure 802 the NVM writes. The SSD may include a memory block (or memory blocks) (eg, physical addresses) for the combination 834 from the key ( K5 ) and the value ( V5 ) before adding the combination 834 from the key ( K5 ) and the value ( V5 ) writes. The SSD updates the pointer of the combination 830 from the key ( K4 ) and the value ( V4 ), making the pointer to the physical address of the combination 834 from the key ( K5 ) and the value ( V5 ) shows. Once the combination 834 from the key ( K5 ) and ( V5 ), the SSD may respond 840 to the host deliver. The answer 840 can be a confirmation that the combination 834 from the key ( K5 ) and the value ( V5 ) in or on the key-value data structure 802 has been stored. In some embodiments, instead of a pointer, the combination may 834 from the key ( K5 ) and the value ( V5 ) have any indicator or indication that it is the last combination of a key and a value in the group. In some embodiments, if there is no pointer to the combination of a key and a value, it can be assumed that this is the last combination of a key and a value in the group.

9 (which the 9a-9C includes) shows a flow sequence of a solid state device (SSD) performing a key value memory (KVS) command. Especially 9 Fig. 12 shows a sequence of a put command from a host performed by an SSD, the put command comprising updating a combination of a key and a value.

As in 9A As shown, the SSD receives a put command 910 from a host. The put or output command 910 Specifies the SSD to store a combination of a key and a value. In particular, the put or output command 910 specifies the storage of a combination of the key ( K5 ) and the value ( V6 ). The KVS processor 900 of the SSD performs a hash operation on the key ( K5 ) that has a hash value 920 generated. The hash value 920 will then be on the index structure 904 applied to a group from or out of the key-value data structure 902 to identify. In this particular case, the hash value shows 920 to an entry in the index structure 904 , the group 1 identified. group 1 points to the combination 930 from the key ( K4 ) and the value ( V4 ) in the key-value data structure 902 , In some embodiments, the entry is the index structure for group 1 a pointer to, which is a physical address of the combination 930 from the key ( K4 ) and the value ( V4 ) in the key-value data structure 902 is. The key-value data structure 902 is stored in the NVM of the SSD. The group of or from a key-value data structure may be empty or comprise one or more key-value data (eg combination of a key and a value). Even if the pointer in the index structure 904 on a combination 930 from the key ( K4 ) and the value ( V4 ), the pointer may act as a pointer to the group 1 from or out of the key-value data structure 902 to be viewed as. The SSD calls the combination 930 from the key ( K4 ) and the value ( V4 ) from or out of the key-value data structure 902 and read them, and then compare the key ( K4 ) of the combination 930 with the key ( K5 ) of the command 910 , In this case, the keys do not match and the SSD retrieves the next combination of a key and a value in the group. The next combination of a key and a value is specified by a pointer that appears in the combination 930 from the key ( K4 ) and the value ( V4 ) is located. The pointer may be a physical address of the next combination of a key and a value in the group. In this example, the next combination of a key and a value is the combination of the key ( K5 ) and the value ( V5 ).

9B shows the SSD that the combination 932 from the key ( K5 ) and the value ( V5 ), which is also part of the group 1 is. The SSD calls the combination 932 from the key ( K5 ) and the value ( V5 ) from or out of the key-value data structure 902 and read them, and then compare the key ( K5 ) of the combination 932 from the key and the value with the key ( K5 ) of the command 910 , The keys match this time, and the SSD updates the combination 932 from the key ( K5 ) and the value ( V5 ), so that V5 by V6 was replaced. The combination 934 from the key ( K5 ) and the value ( V6 ) - now has the previous combination 932 replaced from the key and the value.

9C shows the SSD that the combination 934 from the ( K5 ) and the value ( V6 ) into or onto the key-value data structure 902 the NVM writes. The combination of the key and the value may be at or in a different physical address of the NVM or in the same physical address as the previous combination 932 saved from the key and the value. The SSD may also need to use the pointer of the combination of the key ( K4 ) and the value ( V4 ), so that the pointer to the physical address of the combination 934 from the key ( K5 ) and the value ( V6 ) shows. Once the combination of the key ( K5 ) and the ( V6 ) and / or the pointer has been updated, the SSD may respond 940 deliver to the host. The answer 940 may be a confirmation that the combination of the key ( K5 ) and the value ( V6 ) in the key-value data structure 902 has been stored. If necessary, the combination of the key ( K5 ) and the value ( V6 ) include a pointer pointing to a different combination of a key and a value in the group.

10 (which the 10A-10C includes) shows a flow sequence of a solid state device (SSD) performing a key value memory (KVS) command. In particular shows 10 a Sequence of a delete command from a host performed by the SSD.

As in 10A As shown, the SSD receives a clear command 1010 from a host. The delete command 1010 specifies the SSD to remove a combination of a key and a value. In particular, the delete command specifies 1010 the deletion of a combination of the key ( K2 ) and the value ( V2 ). The KVS processor 1000 of the SSD performs a hash operation on the key ( K2 ), which gives a hash value 1020 is produced. The hash value 1020 is then on or in the index structure 1004 used to group out or from the key-value data structure 1002 to identify. In this particular case, the hash value shows 1020 to an entry in the index structure 1004 , the group 0 identified. group 0 points to the combination 1030 from the key ( K1 ) and the value ( V1 ) in the key-value data structure 1002 , In some embodiments, the entry comprises the index structure for group 0 a pointer that is a physical address of the combination 1030 from the key ( K1 ) and the value ( V1 ) in the key-value data structure 1002 is. The key-value data structure 1002 is stored in the NVM of the SSD. The group of a key-value data structure may be empty or comprise one or more key-value data (eg combination of a key and a value). Even if the pointer in the index structure 1004 on the combination 1030 from the key ( K1 ) and the value ( V1 ), the pointer may be used as a pointer to the group 0 the key-value data structure 1002 to be viewed as. The SSD calls the combination 1030 from the key ( K1 ) and the value ( V1 ) from or from the key-value data structure 1002 and read them, and then compare the key ( K1 ) of the combination 1030 from the key and the value with the key ( K5 ) of the command 1010 , In this case, the keys do not match and the SSD retrieves the next combination of a key and a value from the group. The next combination of a key and a value is specified by a pointer that appears in the combination 1030 from the key ( K1 ) and the value ( V1 ) is located. The pointer may be a physical address of the next combination of a key and a value. In this example, the next combination of a key and a value from or from the group is the combination of the key ( K2 ) and the value ( V2 ).

10B shows the SSD that the combination 1032 from the key ( K2 ) and the value ( V2 ), which is also part of the group 0 is. The SSD calls the combination 1032 from the key ( K2 ) and the value ( V2 ) from or from the key-value data structure 1002 and read them, and then compare the key ( K2 ) of the combination 1032 from the key and the value with the key ( K2 ) of the command 1010 , The keys match this time.

The SSD can do one of several things. In one embodiment, the SSD may be the pointer of the combination 1030 from the key ( K1 ) and the value ( V1 ) to update to the physical address of the combination 1034 from the key ( K3 ) and the value ( V3 ) instead of the combination 1032 from the key ( K2 ) and the value ( V2 ) to show. This effectively removes the combination 1032 from the key ( K2 ) and the value ( V2 ) from or from the key-value data structure 1002 without actually deleting it from or from the physical address of the NVM. In some embodiments, the SSD may determine the distribution of the memory block (s) (eg, physical address) on which the combination 1032 from the key ( K2 ) and the value ( V2 ), meaning that the particular memory block (or memory blocks) is no longer from or through the key-value data structure 1002 is used and is available for storing new data.

10C shows the SSD, which is the pointer of the combination 1030 updated from the key and the value, so he on the combination 1034 from the key and the value instead of the combination 1032 from the key and the value shows. After updating the pointer, the SSD may respond 1040 deliver to the host. The answer 1040 can be a confirmation that the combination 1032 from the key ( K2 ) and the value ( V2 ) in the key-value data structure 1002 was deleted include. In other embodiments, the SSD may be the physical address of the combination 1032 from the key and the value override to the combination 1032 from the key and the value from the key-value data structure 1002 to delete. In such a case, the SSD would still be the pointer of the combination 1030 from the key and the value update, so he on the combination 1034 from the key and the value shows.

EXAMPLE FLOW DIAGRAMS OF METHOD OF PROCESSING KEYWORK STORAGE (KVS) ERRORS AND NON-KVS COMMUNICATIONS THROUGH A SOLID STATE DEVICE (SSD)

11 and twelve Figure 12 shows flowcharts of methods for processing a key-value memory (KVS) command and a non-KVS command through a solid-state device (SSD). The in the 11 and twelve The methods shown may be implemented by any SSD described in the present disclosure, such as the SSD 102 , be performed. Also show for the sake of clarity in the 11 and twelve not necessarily all operations performed by the SSD. In some embodiments, those may be incorporated into the 11 and twelve shown methods include other operation that can be performed by the SSD. In some embodiments, the order of the methods may be changed.

11 shows a flowchart of a method 1100 to process one or more commands received from a host. The procedure 1100 can by an SSD (eg 104 . 501 ) be performed. The method receives (at 1102) a command from a host. The command may be through a host interface (eg 110 ) are received. The method determines (at 1104 ), whether the command is a key value memory (KVS) command. The determination can be through the bridge 112 and / or the host interface 110 be performed. The procedure 1100 can determine whether the command is a KVS command by looking at whether the command includes commands that can only be used by a key-value (KV) database or not. In some embodiments, the method may determine whether the command is a KVS command by looking to see if the command is specifically a Get command, a Put command, or a Delete Command includes or not. In some embodiments, if the instruction includes a get instruction, an issue instruction, or a delete instruction, the method may determine that the instruction is a KVS instruction.

If the procedure determines (at 1104 ) that the command is not a KVS command, the method may continue to access a particular location of a key-value data structure in nonvolatile memory (NVM) 1108 ). Examples of non-KVS instructions may include a read command and / or a write command. The access (at 1108 ) to the key value data structure can be performed by the NVM processor. The access (at 1108 ) to the key value data structure may include reading a physical address of the NVM and / or writing to a physical address of the NVM.

If the procedure determines (at 1104 ) that the command is a KVS command, the method continues to perform a key value memory (KVS) operation with an index structure 1106 ) to identify a particular location of a key-value data structure in nonvolatile memory (NVM). The implementation (at 1106 ) of the KVS operations may include performing one or more hash calculations and / or hash operations to identify one or more hash values that may correspond to entries of an index structure. An example of performing a KVS operation is in twelve described. Once the KVS surgery is performed (at 1106 ), (intervenes) 1108 ) assigns the method to the key-value data structure in or on the NVM based on the KVS operation, the index structure, and the key-value data structure. The method provides (at 1110 ) a response to a host based on the retrieved data. The procedure 1100 from 11 can be performed iteratively for multiple commands (eg KVS commands and / or non-KVS commands).

twelve shows a flowchart of a method 1200 to process one or more KVS commands received from a host. Examples of the procedure 1200 from twelve are in the 7-10 illustrated. The received command is a KVS command that includes a key. The procedure 1200 can by an SSD (eg 104 . 501 ) be performed. The method may begin after a command comprising a key has been received from a host. The method may begin after the method determines that the command that was received is a KVS command. The command may be through a host interface (eg 110 ) are received. The procedure introduces (at 1202 ) hashed or hashed a key in the instruction received by an SSD. The hash operation calculates a hash value based on the key that accompanies the command (eg KVS command). The hash operation can map a key of any size to data (eg, hash value) of a specified size. The hash operation may include a hash function (eg, Jenkins hash function). The hash function may be used to map a key to a key-value data structure, where the key with an index structure may be used to point to a group (eg, bin) in the key-value data structure in which one or more of the combinations of a key and a value are stored. The number of possible keys is typically greater than the number of entries (eg hash values) in the index structure. Each entry (eg hash value) of the index structure points to a specific location or group (eg, container) of key value data (eg, combination of a key and a value) in the key value data structure. For example, each entry may be a pointer that provides a physical address of a combination of a key and a value in the particular group of key-value data. This physical address may represent the location of the particular group, even if not all combinations of a key and a value are stored at this physical address. A hash Function can generate the same hash value for different keys. Thus, a particular location or group (eg, container) of key value data in the key value data structure may store more than one combination of a key and a value. It should be understood that although the different combinations of a key and a value may be part of the same location or group of key-value data from the key-value data structure, they may be stored in different physical addresses of the storage device. A group of key-value data may be empty or comprise one or more combinations of a key and a value.

The procedure identifies (at 1204 ) an entry or a group of the index structure based on the hash operation. Each entry or group is associated with a hash value. The identified entry or group may point to a group of key-value data comprising one or more combinations of a key and a value. In some embodiments, the group of key value data may be empty. The procedure identifies (at 1206 ) collects a set of key-value data based on the identified entry of the index structure, and intervenes (at 1206 ) to at least one combination of a key and a value from the identified set of key-value data from the key-value data structure. Once the group of key-value data has been identified, the method may process the identified group of key-value data, including accessing, retrieving, comparing, and / or storing key-value data. Accessing the at least one combination of a key and a value may include reading and / or writing data to a particular location (eg, physical address) of the NVM. The method determines (at 1208 whether the key associated with the received command matches the retrieved combination of a key and a value from the identified group.

If the keys match, then the procedure continues with the delivery (at 1212 ) of a response comprising a value from the retrieved combination of a key and a value. In some embodiments, the delivery of a response may include writing the combination of a key and a value at a particular location of the key-value data structure. However, if the keys do not match, the procedure (at 1210 ), if there is another combination of a key and a value for the identified group of key-value data. If the procedure determines (at 1210 ) that there is no other combination of a key and a value for the group returns (at 1212 ) the method is a response that includes an error message and / or a deviation message.

If the procedure determines (at 1210 ) that there is another combination of a key and a value for the identified group of key-value data, the method continues to determine (at 1208 ), whether the key associated with the received command matches another key from the other retrieved combination of a key and a value from the identified group of key value data. The procedure 1200 out twelve can be done iteratively for multiple commands.

While the above description includes many specific embodiments of the invention, it should not be construed as limiting the scope of the invention, but as examples of specific embodiments thereof. Accordingly, the scope of the invention should be determined not by the illustrated embodiments, but by the appended claims and their equivalents.

The various features and methods described above may be used independently or combined in various ways. All possible combinations and subcombinations are intended to be within the scope of this disclosure. Additionally, certain method, event, state, or processing blocks may be omitted in some implementations. Also, the methods and processes described herein are not limited to any particular sequence, and the blocks or states relating thereto may be performed in other suitable sequences. For example, described tasks or events may be performed in a different order than specifically disclosed, or multiple may be combined into a single block or state. The example tasks or events may be performed serially, in parallel, or in any other suitable manner. Tasks or events may be added to or removed from the disclosed embodiments. The example systems and components described herein may be configured differently than described. For example, elements may be added, removed, or rearranged as compared to the disclosed exemplary embodiments.

QUOTES INCLUDE IN THE DESCRIPTION

This list of the documents listed by the applicant has been generated automatically and is included solely for the better information of the reader. The list is not part of the German patent or utility model application. The DPMA assumes no liability for any errors or omissions.

Cited patent literature

• US 62/519094 [0001]

Claims (22)

Solid state device (SSD), which includes: a nonvolatile memory (NVM) configured to store a key value data structure; and a key-value memory (KVS) processor configured to: receive a key value store (KVS) command from a host or host computer; perform a key value memory (KVS) operation on the key value data structure based on the received KVS instruction; and to provide a response to the host based on the KVS operation. SSD after Claim 1 wherein the KVS command is selected from the group consisting of a Get command, a Put command, and a Delete command. SSD after Claim 1 wherein the key value memory (KVS) operation comprises using an index structure to process the key value data structure based on the received KVS instruction. SSD after Claim 1 further comprising: a processor coupled to the NVM; and a bridge configured to: receive a command from the host; send the command to the KVS processor if the command is the KVS command; and send the command to the processor if the command is a non-KVS command. SSD after Claim 1 wherein performing the KVS operation comprises performing a get command, the performing of the get command comprising: generating a hash value based on the KVS command, the KVS command requesting for a certain value associated with a particular key; Identifying a particular location in the key-value data structure using the hash value and an index structure; and retrieving at least one combination of a stored key and a stored value from the particular location in the key value data structure. SSD after Claim 5 wherein providing the response to the host comprises providing the stored value associated with the stored key. SSD after Claim 5 wherein the particular location in the key value data structure stores a plurality of combinations of stored keys and stored values, the particular location comprising a plurality of physical addresses. SSD after Claim 7 wherein performing the KVS operation further comprises iteratively comparing each stored key and stored value combination at the particular location of the key value data structure until a particular stored key matches the particular key from the KVS instruction. SSD after Claim 1 and further comprising a command scheduler configured to schedule a plurality of received KVS commands in a particular order to be processed by the KVS processor. SSD after Claim 1 further comprising a hash controller configured to perform one or more hash operations of the received KVS instructions. Method of operating a solid-state device (SSD) comprising: Storing a key-value data structure in nonvolatile memory (NVM); Receiving a key value store (KVS) command from a host; Identifying an entry of an index structure based on the received KVS instruction on the SSD; Identifying a group of key-value data from the key-value data structure based on the identified entry; Processing one or more key-value data from the identified group of key-value data based on the received KVS command on the SSD; and Providing a response to the host based on the processing of the one or more key-value data. Method according to Claim 11 wherein the KVS command is selected from the group consisting of a Get command, a Put command, and a Delete command. Method according to Claim 11 wherein identifying the entry of the index structure comprises generating a hash value based on the received KVS instruction on the SSD. Method according to Claim 11 wherein receiving the KVS instruction comprises: receiving a command from the host on the bridge of the SSD; Sending the command to a KVS processor of the SSD if the command is the KVS command; and sending the command to a processor of the SSD if the command is a non-KVS command. Method according to Claim 11 further comprising generating a hash value based on the KVS instruction, the KVS instruction comprising a request for a particular value associated with a particular key, wherein identifying the group of key value data comprises Identifying a particular location in the key-value data structure comprises; and wherein processing the one or more key value data comprises retrieving at least one combination of stored key and stored value in the particular location in the key value data structure. Method according to Claim 15 wherein providing the response to the host comprises providing the stored value associated with the stored key. Method according to Claim 15 wherein processing one or more key value data comprises iteratively comparing each stored key value and stored value combination in a plurality of locations in the key value data structure until a particular stored key matches the particular key of the KVS command. Method according to Claim 11 further comprising generating a hash value based on the KVS instruction, the KVS instruction including a request to store a particular value with a particular key; wherein identifying the group of key value data comprises identifying a particular location in the key value data structure; and wherein processing the one or more key value data comprises storing the determined key and the particular combination of values in the particular location in the key value data structure. Method according to Claim 11 further comprising generating a hash value based on the KVS instruction, the KVS instruction including a request to delete a particular value with a particular key; wherein identifying the group of key value data comprises identifying a particular location in the key value data structure; and wherein processing the one or more key value data comprises deleting a pointer pointing to a particular location in which the combination of the particular key and the particular value is stored. Device for operating a solid-state device (SSD), comprising: Means for non-volatile storage of a key-value data structure; and Key value memory (KVS) processing means comprising: Means for receiving a key value store (KVS) command from a host; Means for performing a key value memory (KVS) operation on the key value data structure based on the received KVS command, the means for performing the key value memory (KVS) operation comprising generating a hash value based on the received KVS command; and Means for providing or providing a response to the host based on the KVS operation. Device after Claim 20 ; wherein the KVS command is selected from the group consisting of a Get command, a Put command and a Delete command. Device after Claim 20 wherein the means for performing the key value memory (KVS) operation comprises using an index structure to process the key value data structure based on the received KVS instruction.

Images