Method and system for dynamic submission data structures

Abstract

A system and associated method for a storage device driver includes a storage circuit and a processing circuit, wherein while the storage device driver is executing, the system receives a first request for a requested block size. The processing circuit causes the first request to be stored in a first data structure from a plurality of data structures. The processing circuit then determines a second data structure from the plurality of data structures based on the requested block size of a second request. The processing circuit causes the second request to be stored in the second data structure from the plurality of data structures.

Description

[Technical Field]

[0001] The present disclosure relates to systems and methods for dynamically storing instructions between data structures of storage device drivers, and more particularly, the present disclosure relates to improving instruction processing fairness and processor efficiency for processing units with greater data structure depth. Summary of the Invention

[0002] The present disclosure provides systems and methods for configuring dynamic submission data structures on storage devices, such as solid-state drive (SSD) devices, that have a large number of incoming requests during execution of a storage device driver. For example, in an SSD device having a storage circuit, a processing circuit, and memory (e.g., non-volatile memory), the data structures have a large data structure depth. The data structure depth of a data structure is the number of requests currently stored in the data structure. The dynamic submission data structure can be implemented at least in part on the storage circuit using software, hardware, or a combination thereof. In some embodiments, a large number of incoming requests can result in differences in the amount of stored memory in each of a plurality of data structures over time. This can lead to reduced processing fairness among stored requests, such that a bottlenecked request in a first data structure may wait longer to be processed than a request that was more recently stored in a second data structure with a smaller data structure depth. In some embodiments, the difference in data structure depth can also result in a reduction in the operational quality of storage device processing efficiency.

[0003] In some embodiments, any suitable device having processing circuitry that executes a device driver and is coupled to memory may use a dynamic submission data structure to improve the efficiency of processing requests when a large number of requests are received, hi some embodiments, the device may be, for example, any suitable storage device that may use a memory device driver.

[0004] In some embodiments, a storage device (e.g., a solid-state drive device) is provided that executes a storage device driver on a processing circuit and a storage circuit that are communicatively coupled to each other. In some embodiments, the processing circuit includes a processor, and the storage circuit includes a plurality of data structures. In some embodiments, the processing circuit (which may also be referred to as a storage device driver) receives a first request for a requested block size. The processing circuit causes the first request to be stored in a first data structure of the plurality of data structures. The processing circuit is further configured to determine a second data structure from the plurality of data structures based on the requested block size, and to store the second request in the second data structure from the plurality of data structures. [Brief explanation of the drawings]

[0005] The following description includes a description of figures that illustrate exemplary implementations of embodiments of the present disclosure. The figures are to be understood by way of example, and not by way of limitation. As used herein, reference to one or more "embodiments" should be understood as describing particular features, structures, and / or characteristics included in at least one implementation. Thus, phrases such as "in one embodiment" or "in an alternate embodiment" appearing herein are intended to describe various embodiments and implementations, and do not necessarily all refer to the same embodiment. However, they are not necessarily mutually exclusive.

[0006] [Figure 1] 1 shows an illustration of a storage device with a storage device driver and memory, in accordance with some embodiments of the present disclosure.

[0007] [Figure 2] 1 shows an illustration of a storage device driver with multiple data structures and processing circuits of a storage circuit, in accordance with some embodiments of the present disclosure.

[0008] [Figure 3] 1 shows an illustrative diagram of a storage device driver at three different times (time t1, time t2, and time t3) according to some embodiments of the present disclosure, depicting the storage device driver storing received first request data in a first data structure and dynamically storing received second request data in a second data structure.

[0009] [Figure 4] 10 shows a flowchart illustrating a process for dynamically storing a second request in a second data structure based on a request block size of the second request, according to some embodiments of the present disclosure.

[0010] [Figure 5] 10 shows a flowchart illustrating a process for determining whether to store requests in a second data structure based on a predetermined number of requests and a depth of a first data structure, according to some embodiments of the present disclosure.

[0011] [Figure 6] 10 shows a flowchart illustrating a process for determining whether to store a request in a second data structure based on a default data structure memory and a stored memory of a first data structure, according to some embodiments of the present disclosure. DETAILED DESCRIPTION OF THE INVENTION

[0012] According to the present disclosure, a storage device system and method are provided for dynamic submission data structures in a storage device driver. In particular, the present disclosure provides a system and method for large data structure depth in a storage device driver to improve system performance (e.g., improve processing efficiency when the storage device driver's data structures have a large number of outstanding requests). In some embodiments, the storage device driver includes a plurality of data structures, where the plurality of data structures is one of a plurality of buffers, a plurality of queues, a plurality of stacks, and a plurality of heaps. Each data structure of the plurality of data structures is configured to store a request received by the storage device driver. In some embodiments, the plurality of data structures may be part of a storage circuit of the storage device driver.

[0013] A system (e.g., a storage device) may include a processing circuit and a storage circuit having multiple data structures, where both the processing circuit and the storage circuit are contained within a storage device driver. In some embodiments, requests are driven over a network bus or interface. In some embodiments, the processing circuit of the system may be comprised of a processing unit (e.g., a processor) that can operate on a received first request, where the processing circuit receives the first request. When the first request is received by the processing circuit, the first request may be stored in a first data structure where it remains to be processed. In some embodiments, there may be a second data structure with far fewer outstanding requests to be processed, where the difference in data structure depth may result in a bottleneck in processing requests in the first data structure. In some embodiments, request processing may be completed by a single processor, resulting in a bottleneck in the first data structure and reduced processing fairness among requests for data structures with large differences in request depth. In some embodiments, request processing may be completed by multiple processors, e.g., with each processor assigned to a specific subset of the data structures. In such embodiments, data structures with large request depths may starve other data structures, causing some processors to idle and reducing system processing efficiency. According to the present disclosure, a dynamic request submission data structure for a storage device driver may enable improved processing efficiency for storage devices with a large number of received requests. In some embodiments of the foregoing example, where a first data structure has a large number of outstanding requests and a second data structure has fewer outstanding requests available, the processing circuitry may determine to dynamically store the second request in the second data structure to enable dynamic load balancing of requests among the multiple data structures by the storage device driver.

[0014] In some embodiments, the processor of the processing circuit may be a highly parallel processor capable of quickly accommodating a high bandwidth of requests (e.g., by starting simultaneous processing of a new request before the completion of a previous request).

[0015] In some embodiments, the systems and methods of the present disclosure may refer to an SSD storage system, including a storage device driver with multiple data structures for a network protocol interface, such as a non-volatile memory express (NVMe) buffer.

[0016] An SSD is a data storage device that uses integrated circuit assemblies as memory to persistently store data. SSDs have no moving mechanical components, which distinguishes them from traditional electromechanical magnetic disks, such as hard disk drives (HDDs) or floppy disks, which contain rotating disks and movable read / write heads. Compared to electromechanical disks, SSDs typically are more resistant to physical shock, operate quieter, and have shorter access times and lower latency.

[0017] Many types of SSDs use NAND-based flash memory, which retains data without power and includes some type of non-volatile storage technology. SSD Quality of Service (QoS) can refer to predictably low latency and consistently high input / output operations per second (IOPS) while processing read / write input / output (I / O) workloads. This means that latency or I / O command completion times must be within a specified range without unexpected outliers. Throughput or I / O rates may also need to be tightly controlled without causing sudden drops in performance levels.

[0018] The subject matter of the present disclosure may be better understood by reference to FIGS.

[0019] FIG. 1 shows an illustration of a storage device 100 having a storage device driver 101 and a memory 106 according to some embodiments of the present disclosure. In some embodiments, the storage device 100 may be a solid-state storage device (e.g., a solid-state drive device). In some embodiments, the storage device driver 101 includes a processing circuit 103 and a storage circuit 102 that stores a plurality of data structures 104. In some embodiments, each data structure is configured to dynamically store requests received by the storage device driver 101. In some embodiments, the processing circuit 103 may include a processor or any suitable processing unit. In some embodiments, the memory 106 may be non-volatile memory. It should be understood that embodiments of the present disclosure are not limited to SSDs. For example, in some embodiments, the storage device 100 may include a hard disk drive (HDD) device in addition to or instead of an SSD.

[0020] In some embodiments, storage device driver 101 receives at least one request 105 from a source. In some embodiments, the request source may be located external to storage device 100. In other embodiments, at least one request may originate from within storage device 100. In some embodiments, storage device driver 101 receives requests (e.g., requests 105) from both internal and external sources to storage device 100. According to the present disclosure, there may be instances of storage device 100 where there are a large number of requests (e.g., requests 105) received by storage device driver 101, such that each data structure of multiple data structures 104 has a large data structure depth that may result in additional latency due to bottlenecks in some data structures when the requests are processed.

[0021] Additionally, storage device 100 includes storage circuitry 102 and memory 106. In some embodiments, memory 106 includes any one or more of: Phase Change Memory (PCM), PCM and switch (PCMS), Ferroelectric Random Access Memory (FeRAM) or Ferroelectric Transistor Random Access Memory (FeTRAM), non-volatile memory such as Magnetoresistive Random Access Memory (MRAM), any other suitable memory, or any combination thereof. In some embodiments, processing circuitry 103 is communicatively coupled to storage circuitry 102 for storing and accessing requests in each data structure of multiple data structures 104. Additionally, in some embodiments, processing circuitry 103 is communicatively coupled to memory 106. In some embodiments, a data bus interface is used to transmit requests (e.g., request 105), addresses, or data associated with the requests. A data bus between memory 106 and processing circuitry 103 provides a network bus for reading or writing data through memory 106. In some embodiments, the processor of processing circuitry 103 may include a hardware processor, a software processor (e.g., a processor emulated using a virtual machine), or any combination thereof. The processor, also referred to herein as processing circuitry 103, may include any suitable software, hardware, or both for controlling storage device driver 101, storage circuitry 102, and multiple dynamic submission data structures. In some embodiments, the capabilities of the processor or processing circuitry 103 may also be referred to as the capabilities of storage device driver 101. Memory 106 may include hardware elements for non-transitory storage of instructions, commands, or requests.

[0022] Storage device driver 101 is configured to receive a first request (e.g., request 105) and store the first request in a first data structure of multiple data structures 104. In some embodiments, the first data structure may have a large data structure depth, which may cause increased latency and reduce processing efficiency of storage device 100. The data structure depth of a data structure is the number of requests currently stored in the data structure. In some embodiments, storage device driver 101 may determine a second data structure of multiple data structures 104 based on the request block size. Once storage device driver 101 determines the second data structure, storage device driver 101 stores the second request in the second data structure. In some embodiments of the present disclosure, storage device driver 101 receives a second request after the first request.

[0023] In some embodiments, each data structure in plurality of data structures 104 is the same type of data structure, for example, in some embodiments, plurality of data structures 104 is one of a plurality of buffers, a plurality of queues, a plurality of stacks, a plurality of heaps, or a plurality of any other suitable data structures.

[0024] A storage device (e.g., an SSD device) may include one or more packages of non-volatile memory dies, where each die includes storage cells. In some embodiments, the storage cells are organized into pages, and the pages are organized into blocks. Each storage cell may store one or more bits of information. In some embodiments, storage device 100 may further include a multi-core processor.

[0025] Although storage device 100 depicts one embodiment in which a storage device is configured with dynamic submission data structure capabilities in accordance with the present disclosure, it should be understood that any other suitable device may have dynamic submission data structures in a similar manner.

[0026] For brevity and clarity, and not by way of limitation, the present disclosure is provided in the context of a dynamic submission data structure for large data structure depths that provides the features and functionality disclosed herein. The dynamic submission data structure may be configured by any suitable software, hardware, or both for implementing such features and functionality. The dynamic submission data structure may be implemented at least in part in, for example, storage device 100 (e.g., as part of storage device driver 101 or any other suitable device that may provide increased efficiency with large data structure depths). For example, for a solid-state storage device (i.e., storage device 100), the dynamic submission data structure may be implemented in storage device driver 101. In some embodiments, the dynamic submission data structure may be implemented at least in part as part of the operating system for the system into which storage device driver 101 is integrated.

[0027] FIG. 2 shows an illustration of a storage device driver 101 having multiple data structures (e.g., 201, 202, 203, 204) in storage circuitry 102 and processing circuitry 103, according to some embodiments of the present disclosure. Although four data structures are shown in FIG. 2, the number of data structures is not limited to four, and any suitable number of data structures may be used. In some embodiments, the storage device driver is loaded onto an operating system of a storage device (e.g., storage device 100). In some embodiments, storage device driver 101 includes multiple data structures (e.g., 201, 202, 203, 204), where each data structure is configured to store data associated with a received request (e.g., request 105). Processing circuitry 103 may be interchangeably coupled to storage circuitry 102, thereby enabling the processing circuitry to access data stored in each of the multiple data structures (e.g., 201, 202, 203, 204).

[0028] In some embodiments, storage device driver 101 receives requests (e.g., request 105) from multiple sources. In some embodiments, the source of request 105 is from another device located external to storage device 100. In some embodiments, the source of request 105 may be located on storage device 100, such as an application programming interface (API). In some embodiments, storage device driver 101 can receive and process multiple requests (e.g., request 105) by using temporary memory, such as multiple data structures (e.g., 201, 202, 203, 204), to store multiple requests before they are processed.

[0029] In some embodiments, each data structure of the plurality of data structures (e.g., 201, 202, 203, 204) may store request data or an address pointing to the request data stored in memory (e.g., memory 106). In some embodiments, processing circuitry 103 may access the data structure depth of each data structure of the plurality of data structures (e.g., 201, 202, 203, 204) to monitor whether the data structure depth of the data structure exceeds a default number of requests determined by the storage device driver. In some embodiments, processing circuitry 103 may access the stored memory of each data structure of the plurality of data structures (e.g., 201, 202, 203, 204) to monitor whether the stored memory of any data structure of the plurality of data structures (e.g., 201, 202, 203, 204) exceeds the default data structure memory. In some embodiments, storage device driver 101 may use the default number of requests or the default data structure memory as a threshold to determine whether to dynamically move requests 105 stored in a first data structure of the plurality of data structures to a second data structure.

[0030] For example, storage device driver 101 may store the first request in first data structure 201, and storage device driver 101 may determine whether the data structure depth of first data structure 201 exceeds a predetermined number of requests. Storage device driver 101 may determine a second data structure 202 in which to store the second request. In some embodiments, storage device driver 101 determines a second data structure 202 where the data structure depth of second data structure 202 does not exceed the predetermined number of requests and there is more remaining available memory capacity than the block size of the second request. Generally, the block size of the second request is the maximum memory size of a received second request and, therefore, the maximum amount of data memory accessible by a single request. In some embodiments, if each data structure of the plurality of data structures (e.g., 201, 202, 203, 204) does not have enough available memory remaining to store the second request or has a data structure depth greater than the data structure depth of the first data structure 201, the second request may not be stored in the second data structure 202. However, once the storage device driver 101 determines the second data structure 202, the storage device driver causes the second data structure 202 to store the second request.

[0031] 3 shows an illustrative diagram 300 of storage device driver 101 at three different times (time t1, time t2, and time t3) according to some embodiments of the present disclosure, depicting storage device driver 101 storing a received first request 303 in a first data structure 301 and dynamically storing a received second request 305 in a second data structure 302. While diagram 300 shows storage device driver 101 with two data structures (i.e., first data structure 301 and second data structure 302), the multiple data structures of storage circuit 102 may include at least two data structures. In some embodiments, storage device driver 101 includes multiple data structures (e.g., 301 and 302), where each data structure is configured to store request data (e.g., first request data 306 and second request data 307) associated with a received request (e.g., first request 303 and second request 305). The processing circuitry 103 may be interchangeably coupled to the storage circuitry 102 such that the processing circuitry can access the data stored in each of the first data structure 301 and the second data structure 302. In some embodiments, the memory capacity of the first data structure 301 is the same as the memory capacity of the second data structure 302.

[0032] At time t1, storage device driver 101 receives first request 303. At that time, first data structure 301 has a data structure depth of seven stored entries, and second data structure 302 has a data structure depth of three stored entries. In some embodiments, storage device driver 101 determines default number of requests 304 before receiving first request 303. In other embodiments, storage device driver 101 may determine default number of requests 304 after receiving first request 303. The storage device driver determines that default number of requests 304 for the multiple data structures (i.e., first data structure 301, second data structure 302) is seven stored entries. The received first request 303 is stored in the first data structure by processing circuit 103 at time t2.

[0033] At time t2, the data of the received first request 303 is stored in the first data structure 301 as one of the stored data entries of the second data structure 302 is accessed and removed for use in processing. Additionally, a second request 305 is received by the storage device driver 101 at time t2. In some embodiments, the stored first request data 306 may include the first request data or an address that points to the first request data stored in memory (e.g., memory 106). Once the first request data 306 is stored in the first data structure 301, the data structure depth of the first data structure 301 becomes eight stored data entries, while the data structure depth of the second data structure 302 becomes two stored data entries. In some embodiments, the storage device driver 101 determines that the data structure depth of the first data structure 301 exceeds the default number of requests 304. Therefore, storage device driver 101 determines the second data structure based on the block size of second request 305 and the memory available in determined second data structure 302. In some embodiments, storage device driver 101 determines whether the data structure depth of second data structure 302 exceeds default number of requests 304. In the example shown in Figure 3, storage device driver 101 determines to dynamically store second request 305 in second data structure 302.

[0034] At time t3, storage device driver 101 stores second request 305 in second data structure 302. In some embodiments, stored second request data 307 may include the second request data or an address that points to the second request data stored in memory (e.g., memory 106).

[0035] In some embodiments, the storage device driver 101 may determine a default data structure memory instead of a default number of requests, and compare the stored memory of each data structure with the default data structure memory to determine whether a received request is dynamically stored in a second data structure.

[0036] 4 shows a flowchart illustrating a process 400 for dynamically storing a second request in a second data structure based on a requested block size of the second request, according to some embodiments of the present disclosure. In some embodiments, the referenced storage device driver, first request, and multiple data structures may be implemented as storage device driver 101, request 105, and multiple data structures 104, respectively. In some embodiments, process 400 may be modified, for example, by having stages rearranged, changed, added, and / or removed.

[0037] At step 402, the storage device driver receives a first request having a requested block size. The requested block size is the maximum memory size of the received first request and therefore the maximum amount of data memory accessible by a single request. In some embodiments of the present disclosure, the storage device driver receives the first request from a source. In some embodiments, the source of the first request may be located external to the storage device. In other embodiments, the first request may originate from within the storage device. In some embodiments, the storage device driver receives requests from both internal and external sources of the storage device. After receiving the first request, at step 404, the storage device driver then stores the first request in a first data structure.

[0038] At step 404, the storage device driver causes the first request to be stored in a first data structure of the plurality of data structures. The storage device driver may determine the first data structure in which the first request will be stored. In some embodiments, the determined first data structure may be the data structure of the plurality of data structures with the smallest data structure depth. In some embodiments, the first data structure may be randomly determined by the storage device driver. According to the present disclosure, the first data structure may be any given data structure of the plurality of data structures, where the given data structure has more available memory capacity than the requested block size. Once the first request is stored in the first data structure from the plurality of data structures, the storage device driver, at 406, determines a second data structure from the plurality of data structures based on the requested block size.

[0039] At step 406, the storage device driver determines a second data structure from the plurality of data structures based on the requested block size. In some embodiments, the storage device driver determines the second data structure from the plurality of data structures based on the requested block size and the data structure depth of each data structure in the plurality of data structures. In some embodiments, the storage device driver may use a default number of requests or a default data structure memory as a threshold for when to dynamically store a received second request for the second data structure. For example, if the data structure depth of the first data structure exceeds the default number of requests, the storage device driver may determine a second data structure to store the second request. In some embodiments, the storage device driver determines a second data structure where the data structure depth of the second data structure does not exceed the default number of requests and has more remaining available memory than the requested block size. In some embodiments, if each data structure of the plurality of data structures does not have enough remaining available memory to store the second request or has a data structure depth greater than the data structure depth of the first data structure, the second request cannot be stored in the second data structure. Once the storage device driver determines the second data structure, the storage device driver causes the second request to be stored in the second data structure in step 408 .

[0040] At step 408, the second request is stored in a second data structure. In some embodiments, the storage device driver copies data associated with the second request from the first data structure to the second data structure. In some embodiments, the storage device driver stores an address pointing to the second request in memory. In some embodiments, where the multiple data structures are one of multiple queues or multiple buffers, the storage device driver adds the second request to the end of the queue or buffer, which in such embodiments represents the second data structure. In other embodiments, where the multiple data structures are multiple stacks, the storage device driver stores the second request by pushing the request onto the top of the stack representing the second data structure.

[0041] 5 shows a flowchart illustrating a process for determining whether to store requests in a second data structure based on a predetermined number of requests and a depth of a first data structure, according to some embodiments of the present disclosure. In some embodiments, the referenced storage device driver, requests, and data structures may be implemented as storage device driver 101, requests 105, and data structures 104, respectively. In some embodiments, process 500 may be modified, for example, by rearranging, changing, adding, and / or removing stages.

[0042] At step 502, the storage device driver determines a default number of requests based on the request block size of the requests and the size of each data structure in the plurality of data structures. In some embodiments, the default number of requests may be determined by the storage device driver based on the rate at which the storage device driver receives requests. For example, assuming that the request block size is controlled and uniform in size for each data structure in the plurality of data structures, a high rate of received requests may cause the storage device driver to determine a lower default number of requests compared to a low rate of received requests. In such an example of a high rate of received requests, the storage device driver may determine a smaller default number of requests to ensure that the requests stored in a given data structure do not quickly accumulate. In some embodiments, the determined default number of requests is the same for each data structure in the plurality of data structures when the size of each data structure is the same for all data structures in the plurality of data structures. Once the default number of requests is determined, the storage device driver uses the default number of requests as a threshold at step 504.

[0043] In step 504, the storage device driver determines whether the depth of a first data structure from the plurality of data structures exceeds a predetermined number of requests. In some embodiments, the storage device driver compares the data structure depth of the first data structure to the determined predetermined number of requests. The storage device driver then determines the next step of process 500 in step 506 based on whether the data structure depth of the first data structure exceeds the predetermined number of requests.

[0044] At step 506, the storage device driver determines the next step of process 500 based on whether the data structure depth of the first data structure exceeds the default number of requests. If the data structure depth of the first data structure exceeds the default number of requests, the storage device driver at step 508 determines a second data structure from the plurality of data structures, where the data structure depth of the second data structure does not exceed the default number of requests. If the data structure depth of the first data structure does not exceed the default number of requests, the storage device driver may determine that further received requests are stored in the first data structure. However, in some embodiments, the storage device driver may determine a new default number of requests at 502.

[0045] At step 508, the storage device driver determines a second data structure from the plurality of data structures, where the depth of the second data structure does not exceed the predetermined number of requests. In some embodiments, the storage device driver may compare the data structure depth of the second data structure to the predetermined number of requests. Additionally, in some embodiments, the second data structure has more remaining memory available than the requested block size to ensure that the requests can be stored in the determined second data structure.

[0046] 6 shows a flowchart illustrating a process for determining whether to store a request in a second data structure based on a default data structure memory and a stored memory of a first data structure, according to some embodiments of the present disclosure. In some embodiments, the referenced storage device driver, request, and data structures may be implemented as storage device driver 101, request 105, and data structures 104, respectively. In some embodiments, process 600 may be modified, for example, by rearranging, changing, adding, and / or removing stages.

[0047] At step 602, the storage device driver determines a default data structure memory based on the request block size of the requests and the size of each data structure in the plurality of data structures. In some embodiments, the default data structure memory may be determined by the storage device driver based on the rate at which the storage device driver receives requests. For example, assuming that the request block size is controlled and uniform in size for each data structure in the plurality of data structures, a high rate of received requests may cause the storage device driver to determine a lower default data structure memory compared to a low rate of received requests. In such an example of a high rate of received requests, the storage device driver may determine a smaller default data structure memory to ensure that requests stored in a given data structure do not quickly accumulate. In some embodiments, the determined default data structure memory is the same for each data structure in the plurality of data structures when the size of each data structure is the same for all data structures in the plurality of data structures. Once the default data structure memory is determined, the storage device driver uses the default data structure memory as a threshold at step 604.

[0048] At step 604, the storage device driver determines whether the stored memory of a first data structure from the plurality of data structures exceeds the default data structure memory. In some embodiments, the stored memory of a data structure may be expressed as a percentage of the memory of the data structure currently storing the request. In some embodiments, the storage device driver compares the stored memory of the first data structure to the determined default data structure memory. The storage device driver then determines the next step of process 600 at step 606 based on whether the stored memory of the first data structure exceeds the default data structure memory.

[0049] At step 606, the storage device driver determines the next step of process 600 based on whether the stored memory of the first data structure exceeds the default data structure memory. If the stored memory of the first data structure exceeds the default data structure memory, the storage device driver at step 608 determines a second data structure from the plurality of data structures, where the stored memory of the second data structure does not exceed the default data structure memory. If the stored memory of the first data structure does not exceed the default data structure memory, the storage device driver may determine that further received requests are stored in the first data structure. However, in some embodiments, the storage device driver may determine a new default data structure memory at 602.

[0050] At step 608, the storage device driver determines a second data structure from the plurality of data structures, where the stored memory of the second data structure does not exceed the default data structure memory. In some embodiments, the storage device driver may compare the stored memory of the second data structure with the default data structure memory. Additionally, in some embodiments, the second data structure has more remaining available memory than the requested block size to ensure the request can be stored in the determined second data structure.

[0051] The terms "an embodiment," "embodiment," "embodiments," "the embodiment," "the embodiment," "the embodiments," "one or more embodiments," "some embodiments," and "one embodiment" mean "one or more embodiments (but not all)" unless expressly specified otherwise.

[0052] The terms "including," "comprising," "having," and variations thereof mean "including but not limited to," unless expressly specified otherwise.

[0053] An enumerated list of items does not imply that any or all of the items are mutually exclusive, unless expressly specified otherwise.

[0054] The terms "a," "an," and "the" mean "one or more," unless expressly specified otherwise.

[0055] Devices that are in communication with each other need not be in continuous communication with each other unless explicitly specified otherwise. In addition, devices that are in communication with each other may communicate directly or indirectly through one or more intermediaries.

[0056] A description of an embodiment with several components in communication with each other does not imply that all such components are required. On the contrary, various optional components are described to illustrate a wide variety of possible embodiments. Furthermore, although process steps, method steps, algorithms, or the like may be described in a sequential order, such processes, methods, and algorithms may be configured to function in alternative orders. In other words, any sequence or order of steps that may be described does not necessarily indicate a requirement that the steps be performed in that order. Steps of processes described herein may be performed in any order that is practical. Furthermore, some steps may be performed simultaneously.

[0057] Where a single device or article is described herein, it will be readily apparent that more than one device / article (whether they cooperate or not) may be used in place of the single device / article. Similarly, where more than one device or article (whether they cooperate or not) is described herein, it will be readily apparent that a single device / article may be used in place of the more than one device or article, or that a different number of devices / articles may be used in place of the number of devices or programs shown. The functionality and / or features of a device may alternatively be embodied by one or more other devices not explicitly described as having such functionality / features. Thus, other embodiments need not include the device itself.

[0058] At least some operations may be depicted in figures that show some events occurring in a certain order. In alternative embodiments, some operations may be performed in a different order, modified, or removed. Furthermore, steps may be added to the logic above and still be compatible with the described embodiment. Furthermore, operations described herein may occur sequentially, or some operations may be processed in parallel. Still further, operations may be performed by a single processing unit or by distributed processing units.

[0059] The foregoing description of various embodiments has been presented for purposes of illustration and description. It is not intended to be exhaustive or to be limited to the precise form disclosed. Many modifications and variations are possible in light of the above teaching.

Claims

1. a plurality of data structures for storing requests; and A processing circuit, receiving a plurality of requests including a first request and a second request, wherein each request of the plurality of requests is a requested block size; storing the first request in a first data structure from the plurality of data structures; determining a second data structure from the plurality of data structures based on the requested block size; storing the second request in the second data structure from the plurality of data structures; Processing Circuit A storage device driver comprising:

2. 2. The storage device driver of claim 1, wherein the plurality of data structures is one of a plurality of buffers, a plurality of queues, a plurality of stacks, and a plurality of heaps.

3. 2. The storage device driver of claim 1, wherein the first data structure is a data structure of the same type as the second data structure.

4. 2. The storage device driver of claim 1, wherein the plurality of data structures store Non-Volatile Memory Express (NVMe) requests and the storage device driver runs on a Solid State Drive (SSD) storage device.

5. The processing circuitry further comprises:

2. The storage device driver of claim 1, further comprising: determining a depth of the first data structure; and determining the depth of the second data structure further based on the depth of the first data structure.

6. The processing circuitry further comprises: determining whether the depth of the first data structure exceeds a predetermined number of requests; The storage device driver of claim 5 , wherein the determination of the second data structure is further based on a depth of the second data structure exceeding the predetermined number of requests.

7. The processing circuitry further comprises: The storage device driver of claim 6 , wherein the default number of requests is determined based on the requested block size of a request and the size of each data structure in the plurality of data structures.

8. To determine the second data structure, the processing circuitry further comprises: determining whether the stored memory of the data structure exceeds a default data structure memory; In response to the determination that the stored memory of the first data structure exceeds the default data structure memory, 2. The storage device driver of claim 1, wherein the second data structure is determined and the stored memory of the second data structure does not exceed the default data structure memory.

9. The processing circuitry 9. The storage device driver of claim 8, wherein the default data structure memory is determined based on the requested block size of a request and the size of each data structure in the plurality of data structures.

10. The processing circuitry The storage device driver of claim 1 , further comprising: determining the second data structure based on a depth of the second data structure.

11. The processing circuitry further comprises: determining the requested block size of the second request; 11. The storage device driver according to claim 10, wherein the second data structure is determined based on a data structure having the smallest depth among the plurality of data structures.

12. receiving, by the storage device driver, a plurality of requests including a first request, wherein each request of the plurality of requests is a requested block size; storing the first request in a first data structure from a plurality of data structures; determining, by the storage device driver, a second data structure from the plurality of data structures based on the requested block size; and storing a second request in the second data structure; A method for providing the above.

13. The method of claim 12 , wherein the plurality of data structures is one of a plurality of queues, a plurality of stacks, and a plurality of heaps.

14. The method of claim 12 , wherein the first data structure is a data structure of the same type as the second data structure.

15. 13. The method of claim 12, wherein the plurality of data structures stores Non-Volatile Memory Express (NVMe) requests and the storage device driver runs on a Solid State Drive (SSD) storage device.

16. 13. The method of claim 12, further comprising determining a depth of the first data structure, wherein determining the second data structure is further based on the depth of the first data structure.

17. determining whether the depth of the first data structure exceeds a predetermined number of requests; 17. The method of claim 16, wherein determining the second data structure is further based on a depth of the second data structure exceeding the predetermined number of requests.

18. 18. The method of claim 17, further comprising determining the default number of requests based on the request block size of a request and the size of each data structure in the plurality of data structures.

19. The step of determining the second data structure comprises: determining whether the stored memory of the first data structure exceeds a default data structure memory; and In response to determining that the stored memory of the first data structure exceeds the default data structure memory, determining the second data structure; 13. The method of claim 12, further comprising: wherein the stored memory of the second data structure does not exceed the default data structure memory.

20. 20. The method of claim 19, further comprising determining the default data structure memory based on the request block size of a request and a data structure memory of each data structure in the plurality of data structures.

21. 21. The method of claim 12, further comprising determining the second data structure further based on a depth of the second data structure.

22. determining the requested block size of the second request; and determining the second data structure based on a data structure having a smallest depth among the plurality of data structures; The method of claim 21 further comprising:

23. a storage circuit having a plurality of data structures for storing requests; and A processing circuit, receiving a plurality of requests including a first request, wherein each request of the plurality of requests is a requested block size; storing the first request in a first data structure from the plurality of data structures; determining a second data structure from the plurality of data structures based on the requested block size; storing a second request in the second data structure; Processing Circuit A system comprising:

24. 24. The system of claim 23, wherein the first data structure is a data structure of the same type as the second data structure.

25. 24. The system of claim 23, wherein the plurality of data structures store Non-Volatile Memory Express (NVMe) requests and the storage circuitry is located on a Solid State Drive (SSD) storage device.

26. The processing circuitry further comprises:

26. The system of claim 23, further comprising: determining a depth of the first data structure; and determining the depth of the second data structure further based on the depth of the first data structure.

27. The processing circuitry further comprises: determining whether the depth of the first data structure exceeds a predetermined number of requests; 27. The system of claim 26, wherein the determination of the second data structure is further based on a depth of the second data structure exceeding the predetermined number of requests.

Images