System and method for prefetching data
By introducing dual-mode persistent memory and software-assisted prefetch instructions in the storage system, the prefetch step size is optimized, and the performance problems caused by the delay of non-volatile storage media in the storage system are solved, achieving faster data access and system response.
Patent Information
- Application Number
- CN202410506201.2
- Authority / Receiving Office
- CN · China
- Patent Type
- Applications(China)
- Current Assignee / Owner
- Priority Date
- 2023-08-07
- Filing Date
- 2024-04-25
- Publication Date
- 2024-11-12
AI Technical Summary
Existing storage systems have latency problems when accessing storage devices, especially because the high latency of nonvolatile storage media affects system performance and responsiveness.
By introducing dual-mode persistent memory in the computing system, using volatile memory as cache memory, prefetching data from non-volatile storage media to volatile storage media, and using software-assisted prefetch instructions to optimize the prefetch step size Reduce delay.
Effectively reduces memory access latency, improves system performance and responsiveness, and reduces competition through multiple prefetch request queues, improving system scalability.
Smart Images

Figure CN118939179A_ABST
Abstract
Description
[0001] This application claims priority to and the benefit of U.S. Patent Application No. 63 / 465,494, filed on May 10, 2023, entitled “Software-Assisted Prefetcher for Dual-Mode Persistent Memory with Host-Accessible Prefetch Queues,” and U.S. Patent Application No. 18 / 231,122, filed on August 7, 2023, the entire contents of which are incorporated herein by reference. Technical Field
[0002] One or more aspects according to embodiments of the present disclosure relate to a storage device, and more particularly, to pre-fetching data stored in the storage device. Background Art
[0003] Applications may interact with storage devices or memory devices (collectively referred to as storage devices) to read (or load) and write (or store) data. Latency is often involved when accessing storage devices. The type of latency involved may depend on the storage medium included in the storage device. Certain storage media have lower latency than other storage media. Therefore, it may be desirable to manage the storage of data in the storage device in order to improve overall system performance and responsiveness.
[0004] The above information disclosed in this Background section is only for enhancement of understanding of the background of the present disclosure and therefore it may contain information that does not form the prior art. Summary of the invention
[0005] One or more embodiments of the present invention are directed to a computing system, the computing system comprising: a storage device including a first queue, a first storage medium, and a second storage medium; a processor configured to communicate with the storage device; and a memory coupled to the processor. The memory stores instructions, which, when executed by the processor, cause the processor to: execute a first command for moving first data stored in the storage device; and based on the first command, store a first address associated with the first data in the first queue. The storage device is configured to: retrieve the first address from the first queue, retrieve the first data from the first storage medium based on the first address, and store the first data to the second storage medium.
[0006] According to some embodiments, the instructions further cause the processor to: modify a pointer identifying a location in the first queue based on storing the first address in the first queue.
[0007] According to some embodiments, the first command includes a second command for pre-fetching data stored in a location associated with the first address.
[0008] According to some embodiments, the first storage medium includes non-volatile memory and the second storage medium includes volatile memory.
[0009] According to some embodiments, the first queue is mapped to a user space associated with the application, wherein the first command is executed in the user space.
[0010] According to some embodiments, a first command is generated by a first application, wherein the instruction further causes the processor to: execute a second command for moving second data stored in a storage device, wherein the second command is generated by a second application; based on the second command, store a second address associated with the second data in a first queue, wherein the storage device is configured to: retrieve the second address from the first queue, retrieve the second data from the first storage medium based on the second address, and store the second data to the second storage medium.
[0011] According to some embodiments, the first command comprises a first call to an operating system and the second command comprises a second call to the operating system, wherein the operating system is configured to manage storing the first address and the second address in the first queue.
[0012] According to some embodiments, the first queue is assigned to the first application and the second queue is assigned to the second application.
[0013] According to some embodiments, the processor is configured to modify a pointer associated with the first queue based on storing the first address in the first queue.
[0014] One or more embodiments of the present disclosure relate to a computing system, comprising: a storage device, including a first storage medium and a second storage medium; a processor, configured to communicate with the storage device; and a memory, coupled to the processor, the memory storing instructions, which, when executed by the processor, cause the processor to: identify a value for prefetching data; run an application; measure performance of the application; modify the value based on the performance; and determine that the performance meets a standard.
[0015] According to some embodiments, the value is a step size of the second memory block to be prefetched relative to the first memory block used by the application.
[0016] According to some embodiments, the value is identified in a prefetch command included in the application.
[0017] According to some embodiments, the storage device comprises a queue, wherein the address identified based on the value is stored in the queue based on the prefetch command.
[0018] According to some embodiments, the storage device is configured to retrieve the address from a queue, retrieve data from a first storage medium based on the address, and store the data to a second storage medium.
[0019] According to some embodiments, the application comprises a pre-fetch command for identifying the value, wherein the instructions causing the processor to measure the performance comprise instructions causing the processor to measure a runtime of the application.
[0020] According to some embodiments, the instructions causing the processor to modify the value include instructions causing the processor to randomly modify the value.
[0021] One or more embodiments of the present disclosure also relate to a method, the method comprising: executing, by a processor, a first command for moving first data stored in a storage device including a first queue, a first storage medium, and a second storage medium; and based on the first command, storing, by the processor, a first address associated with the first data in the first queue. The storage device is configured to: retrieve the first address from the first queue, retrieve the first data from the first storage medium based on the first address, and store the first data in the second storage medium.
[0022] One or more embodiments of the present disclosure also relate to a method, comprising: identifying, by a processor communicating with a storage device, a value for prefetching data; running an application by the processor; measuring performance of the application by the processor; modifying the value based on the performance by the processor; and determining, by the processor, that the performance meets a standard.
[0023] These and other features, aspects and advantages of the embodiments of the present disclosure will be more fully understood when considered with reference to the following detailed description, appended claims and accompanying drawings.Of course, the actual scope of the invention is defined by the appended claims. BRIEF DESCRIPTION OF THE DRAWINGS
[0024] Non-limiting and non-exhaustive embodiments of the present disclosure are described with reference to the following figures, wherein like reference numerals refer to like components throughout the various views unless otherwise specified.
[0025] Figure 1 is a block diagram of a system for prefetching data according to one or more embodiments;
[0026] Figure 2 depicts a block diagram of a storage controller according to one or more embodiments;
[0027] Figure 3 depicts another block diagram of a storage controller according to one or more embodiments;
[0028] Figure 4 depicts example procedures that may be performed by an application according to one or more embodiments;
[0029] Figure 5 depicts multiple programs that may contend for a prefetch request queue according to one or more embodiments;
[0030] Figure 6 depicts a storage device including two or more prefetch request queues according to one or more embodiments;
[0031] Figure 7 depicts a flow chart of a process for prefetching data according to one or more embodiments;
[0032] Figure 8 Depicting example code for a program including a call to a storage prefetch function according to one or more embodiments;
[0033] Fig. 9 Describes the instructions for performing a prefetch step size adjustment before performing a prefetch step size adjustment according to one or more embodiments. Figure 8 A table showing the timing of prefetching data blocks during an example program and the timing of when the data blocks are needed for calculation;
[0034] Fig.10 Depicting an example of performing a prefetch step size adjustment according to one or more embodiments. Figure 8 A table of pre-fetch timings of data blocks during an example program of and timings of when data blocks are needed for computation; and
[0035] Fig.11 A flow diagram of a process for prefetch optimization is depicted in accordance with one or more embodiments. DETAILED DESCRIPTION
[0036] Hereinafter, example embodiments will be described in more detail with reference to the accompanying drawings, wherein the same reference numerals always represent the same elements. However, the present disclosure may be implemented in various different forms and should not be construed as being limited to the embodiments shown herein. On the contrary, these embodiments are provided as examples so that the present disclosure will be thorough and complete, and the aspects and features of the present disclosure will be fully conveyed to those skilled in the art. Therefore, unnecessary processing, elements and techniques for a complete understanding of the aspects and features of the present disclosure by those of ordinary skill in the art may not be described. Unless otherwise stated, throughout the accompanying drawings and written descriptions, the same reference numerals represent the same elements, and therefore, their descriptions may not be repeated. In addition, in the accompanying drawings, the relative sizes of elements, layers and regions may be exaggerated and / or simplified for clarity.
[0037] Embodiments of the present disclosure are described below with reference to block diagrams and flow charts. Therefore, it should be understood that each frame of the block diagram and flow chart can be implemented in the form of a computer program product, an overall hardware embodiment, a combination of hardware and a computer program product, and / or an apparatus, system, computing device, computing entity, etc., for executing instructions, operations, steps, and similar words (e.g., executable instructions, instructions for execution, program codes, etc.) on a computer-readable storage medium. For example, the retrieval, loading, and execution of the code can be performed sequentially so that one instruction is retrieved, loaded, and executed at a time. In some example embodiments, retrieval, loading, and / or execution can be performed in parallel so that multiple instructions are retrieved, loaded, and / or executed together. Therefore, such an embodiment can produce a specially configured machine for executing the steps or operations specified in the block diagram and flow chart. Therefore, the block diagram and flow chart support various combinations of embodiments for executing specified instructions, operations, or steps.
[0038] Generally speaking, an application running on a host computing device (referred to as a "host") may need to store data to and load data from a storage device. Latency is often involved in accessing a storage device. The latency involved may vary depending on the storage medium storing the data to be retrieved. For example, a storage device may have both a volatile storage medium (e.g., dynamic random access memory (DRAM)) and a non-volatile storage medium (e.g., NAND flash memory). The latency of a volatile storage medium may be lower than the latency of a non-volatile storage medium. It may be desirable to use a volatile storage medium to store blocks, groups of blocks, or pages (collectively referred to as "blocks") of data that are expected to be accessed by the host in the near future.
[0039] Generally speaking, embodiments of the present disclosure relate to systems and methods for prefetching data from a NVM of a storage device to a faster storage medium (e.g., DRAM) of the storage device. The faster storage medium can be used as a cache memory of the storage device. Prefetching can be via software prefetch instructions (or commands). Prefetch instructions can be manually coded by a program developer and inserted into a program. Prefetch instructions can also be generated by a compiler during the compilation of the program and inserted into the program. In some embodiments, prefetch instructions can cause data to be loaded into a device cache before the program uses the data to perform calculations.
[0040] In some embodiments, the storage device includes one or more prefetch request queues that store memory addresses of data blocks to be prefetched. In some embodiments, the prefetch request queues are mapped to the user space of the host. Exposing the queues to the host may allow applications running in user space to access the queues to write memory addresses to be prefetched into the queues. The storage device may read the memory addresses from the queues and prefetch the data identified by the memory addresses into the storage cache memory. Allowing applications to write to the queues may simplify the design of the storage device.
[0041] In some embodiments, the insertion of the prefetch address into the prefetch request queue is managed by the host's operating system (OS) kernel. For example, this may be desirable if two or more applications include prefetch instructions that enable the two or more applications to access the prefetch request queue (e.g., simultaneously).
[0042] In some embodiments, contention for a prefetch request queue by two or more applications can be handled by allowing the OS kernel to manage the queue (e.g., rather than an application running in user space). Applications competing for the prefetch request queue can make calls to the OS kernel to handle prefetching of data. In this regard, the OS kernel can serialize the processing of prefetch instructions from two or more applications. This can allow the prefetch request queue to be accessed by one application at a time.
[0043] As the number of applications grows, maintaining a single prefetch request queue shared by the applications can increase contention for the queue. In some embodiments, the storage system includes two or more prefetch request queues assigned to different applications. For example, a first queue in the queue can be assigned to a first application, and a second queue in the queue can be assigned to a second application. Two or more queues can be exposed to the host, allowing the host to write the address of the data to be prefetched to the appropriate queue based on the application in the request.
[0044] In some embodiments, a prefetch instruction included in the application identifies a data block to be prefetched. For example, if the data required by the application for the current computation is data block N, the prefetch instruction may be used to prefetch the next data block N+1. In some cases, the storage device may be slow to prefetch data from the NVM into the device cache. In such a case, the prefetched data may not be in the device cache until the application is ready to use the data for computation.
[0045] In some embodiments, systems and methods for prefetching data include software prefetch instructions that are adjusted to improve performance of an application that includes the prefetch instructions. The adjustment may include identifying a selected prefetch step size (e.g., the distance of a memory block to be prefetched relative to a memory block currently in use). As discussed above, due to the latency of the NVM, if the prefetch step size is too close, the application may execute a command to use the data in the prefetch command before the prefetch process is completed.
[0046] In some embodiments, the identification of the optimal prefetch step size may be based on an optimization algorithm that measures the performance of the application based on different prefetch step sizes. The performance of the application may include the runtime or execution time of the application, but the embodiments are not limited thereto. Additional performance parameters may include cache hit or miss ratios, translation lookaside buffer (TLB) hit or miss ratios, branch mispredictions during program execution, and the like. Different prefetch step sizes may be tried until the performance of the application meets a threshold performance.
[0047] Figure 1 1 is a block diagram of a system for prefetching data according to one or more embodiments. The system may include a host computing device ("host") 100 coupled to a storage device 102 via one or more data communication links 104. In some embodiments, the data communication link 104 may include various common interfaces (such as, for example, Ethernet, a universal serial bus (USB), and / or any wired data communication link or wireless data communication link).
[0048] The host 100 may include a processor 106, a memory 108, and a host interface 110. The processor 106 may be configured to run one or more applications or programs (used interchangeably herein) 112 based on instructions stored in the memory 108. The application 112 may be any application configured to send a request (e.g., a data access request) to the storage device 102. For example, the application 112 may be a big data analysis application, an e-commerce application, a database application, a machine learning application, etc. Data requests (such as, for example, load requests and store requests) may be generated during the execution of the application 112. The application may use the results of the data requests to generate outputs.
[0049] The application 112 may communicate with the storage device 102 via the host interface 110. The host interface 110 may include a physical connection and software instructions that may be executed by the processor 106. In some embodiments, the host interface 110 allows the host 100 and the storage device 102 to send and receive data using a protocol such as, for example, CXL, but the embodiments are not limited thereto. The performance of the application 112 may depend on how quickly the requested data is retrieved by the storage device 102 and returned to the application 112.
[0050] In addition to or instead of CXL, the host interface 110 may use other protocols (such as, Cache Coherent Interconnect for Accelerators (CCIX), Dual In-line Memory Module (DIMM) interface, Small Computer System Interface (SCSI), Non-Volatile Memory Express (NVMe), Peripheral Component Interconnect Express (PCIe), Remote Direct Memory Access (RDMA) over Ethernet, Serial Advanced Technology Attachment (SATA), Fibre Channel, Serial Attached SCSI (SAS), NVMe over a network (NVMe-oF), iWARP protocol, wireless bandwidth protocol, 5G wireless protocol, Wi-Fi protocol, Bluetooth protocol, etc.).
[0051] Storage device 102 may take the form of a solid-state drive (SSD), persistent memory, etc. In some embodiments, storage device 102 includes (or is embodied as) an SSD with cache coherence and / or compute capabilities. In some embodiments, storage device 102 includes (or is embodied as) a dual-mode persistent memory with dual-mode access to its storage space. In a first mode, storage device 102 may be accessed as a disk storage device at a block-level granularity (e.g., via CXL.io). In a second mode, storage device 102 may be accessed as a device-attached memory at a byte-level granularity (e.g., via CXL.mem or CXL.cache).
[0052] In some embodiments, the storage device 102 includes a storage controller 116, a storage memory 118, and a non-volatile memory (NVM) 120. The storage memory 118 may be a high-performance memory of the storage device 102, and may include (or may be) a volatile memory (e.g., such as DRAM), but the present disclosure is not limited thereto, and the storage memory 118 may be any suitable type of high-performance volatile or non-volatile memory. Although a single storage memory 118 is depicted for simplicity, those skilled in the art will recognize that the storage device 102 may include other local memories for temporarily storing other data of the storage device.
[0053] In some embodiments, storage memory 118 is used and managed as cache memory. In this regard, storage memory (also referred to as cache) 118 may store a copy of data stored in NVM 120. For example, data to be accessed by application 112 in the near future may be copied from NVM 120 to storage memory 118 to allow data to be retrieved from storage memory 118 (rather than NVM 120). In some embodiments, storage memory 118 has a lower access latency than NVM 120. Therefore, in some embodiments, accessing data from storage memory 118 helps improve overall system performance and responsiveness. Accessing data from storage memory 118 may also support a second mode of access (e.g., byte granularity) of storage device 102. For example, NVM 120 may naturally operate in a first access mode (e.g., block granularity). Nevertheless, the storage device may service read operations at byte granularity by performing a block read from NVM 120 to storage memory 118 and returning the result of the request to the host. Similarly, write operations at byte-level granularity may be buffered in storage memory 118 for block writes to NVM 120 until a threshold or condition is met.
[0054] NVM 120 may persistently store data received, for example, from host 100. NVM 120 may include, for example, NAND flash memory, but the present disclosure is not limited thereto, and NVM 120 may include any suitable type of memory (e.g., magnetic disk, tape, optical disk, etc.) for persistently storing data according to the implementation of storage device 102.
[0055] The storage controller 116 may be connected to the NVM 120 and the storage memory 118 through one or more storage interfaces 122a, 122b (collectively referred to as 122). The storage controller 116 may receive input / output (I / O) requests (e.g., load requests or storage requests) from the host 100, and transmit commands to and from the NVM 120 and / or the storage memory 118 to perform the I / O requests. In this regard, the storage controller 116 may include at least one processing component embedded thereon, the at least one processing component being used to interface with the host 100, the storage memory 118, and the NVM 120. The processing component may include, for example, a digital circuit (e.g., a microcontroller, a microprocessor, a digital signal processor, or a logic device (e.g., a field programmable gate array (FPGA), an application specific integrated circuit (ASIC), etc.)) that is capable of executing (e.g., via firmware and / or software) data access instructions to provide access to and from data stored in storage memory 118 or NVM 120 in accordance with the data access instructions.
[0056] In some embodiments, the storage controller 116 includes an interface module for interfacing with the host 100. The interface module may include physical connections as well as software instructions executable by a processing component of the storage controller 116. In some embodiments, the interface module allows the storage device 102 to exchange data with the host 100 using a protocol such as, for example, CXL, CCIX, DIMM, SCSI, NVMe, PCIe, RDMA over Ethernet, SATA, Fibre Channel, SAS, NVMe-oF, iWARP protocol, wireless broadband protocol, 5G wireless protocol, Wi-Fi protocol, Bluetooth protocol, etc.
[0057] In some embodiments, the application 112 executed by the processor 106 includes data prefetch instructions that allow the storage controller 116 to prefetch data from the NVM 120 to the storage memory 118. In some embodiments, the prefetch instructions are manually coded by the program developer and inserted into the application / program 112. In some embodiments, the prefetch instructions are generated by a compiler during compilation of the program and inserted into the application / program 112. Prefetching of data may entail retrieving data from the NVM 120 to the storage memory 118, for example, before the application 112 needs the data to perform a calculation.
[0058] Figure 2A block diagram of a storage controller 116a is depicted according to one or more embodiments. The storage controller 116a includes an NVM controller 200, a cache controller 202, a storage prefetch engine (or prefetcher) 204, and a prefetch request queue 206. Although the NVM controller 200, the cache controller 202, and the storage prefetch engine 204 are assumed to be separate components, those skilled in the art will recognize that one or more of the components may be combined or integrated into a single component, or further subdivided into further subcomponents, without departing from the spirit and scope of the inventive concept.
[0059] In some embodiments, NVM controller 200, cache controller 202, and / or storage prefetch engine 204 may include, for example, a digital circuit (e.g., a microcontroller, a microprocessor, a digital signal processor, or a logic device (e.g., a field programmable gate array (FPGA), an application specific integrated circuit (ASIC), etc. (collectively referred to as a processor)). The digital circuit may include a memory that stores instructions (e.g., software, firmware, and / or hardware code) for execution by the processor.
[0060] In some embodiments, the NVM controller 200 is configured to receive a data access request from the host 100. Using CXL as an example, the data access request may be a disk request based on the CXL.io protocol 212, which allows the NVM 120 to be accessed by the host CPU as a disk storage device. In some embodiments, the NVM controller 200 includes a flash translation layer (FTL) 208 that receives the data access request and interfaces with the NVM 120 to read data from the NVM and write data to the NVM. In this regard, the FTL 208 may convert a disk block address included in the data access request into a flash block address. In doing so, the FTL 208 may participate in wear leveling to move data around the storage cells of the NVM 120 to evenly distribute writes to the NVM 120.
[0061] Referring again to CXL as an example, the data access request may be a memory request based on the CXL.mem or CXL.cache protocol 214 that allows NVM 120 to be accessed by the host CPU as device-attached memory.
[0062] In some embodiments, the storage prefetch engine 204 is configured to retrieve a memory address from a prefetch request queue 206, wherein the memory address identifies data to be prefetched from the NVM 120 to the storage memory 118. The memory address may be retrieved from a location in the queue 206 marked by a head pointer 220. In some embodiments, the storage prefetch engine 204 communicates with a cache controller 202 to retrieve the data stored in the memory address. In this regard, the cache controller 202 may communicate with the NVM controller 200 to access and return data from the NVM 120. In this regard, the cache controller 202 or the FTL 208 may be configured to convert the requested memory block address into a flash block address. The NVM controller 200 may retrieve the data from the flash block address and forward the data to the cache controller 202. The cache controller may select a cache address (e.g., a cache line 210) for storing the data and store the data in the cache address.
[0063] In some embodiments, the pre-fetch request queue 206 is stored in the storage memory 118 of the storage device 102a. In some embodiments, the pre-fetch request queue 206 is mapped to the user space of the host 100 through a shared address (or memory) interface (or space) 216. For example, the pre-fetch request queue 206 can be mapped to a memory mapped I / O (MMIO) space (or base address register (bar)). MMIO can use the same address space to address the memory of the pre-fetch request queue 206 and the main memory 108. The CPU instructions for accessing the main memory 108 can be used to access the pre-fetch request queue 206. In this regard, the storage device 102a can monitor the address bus of the CPU and respond to any CPU access to the address assigned to the pre-fetch request queue 206.
[0064] In some embodiments, the pre-fetch request queue 206 is mapped to a user space as a host managed device memory (HDM). In this regard, the pre-fetch request queue 206 may be mapped to a system coherent address space accessible to the host 100 and the storage device 102a.
[0065] In some embodiments, the host 100 accesses the pre-fetch request queue 206 via the shared address interface 216 to store the memory addresses of the blocks to be pre-fetched by the storage device 102a. The memory addresses are stored in the location of the pre-fetch request queue 206 based on the identification of the tail pointer 218. In some embodiments, the tail pointer 218 is updated by the host 100. In some embodiments, the head pointer 220 is updated by the storage device 102.
[0066] Figure 3 A block diagram of a storage controller 116b is depicted in accordance with one or more embodiments. Figure 3The storage controller 116b includes at least a first pre-fetch request queue 206a and a second pre-fetch request queue 206b. Figure 3 The storage controller 116b may be connected to Figure 2 The first pre-fetch request queue 206a and the second pre-fetch request queue 206b may be mapped to the host via a shared address interface 216. In some embodiments, the application 112 may select one of the first pre-fetch request queue 206a and the second request queue 206b to store the address to be pre-fetched. The use of multiple queues 206 helps to reduce contention when accessing the queues. In some embodiments, the selection of the queues may be performed by an operating system or application 112 running on the host 100. The selection may be based on quality of service (QoS) considerations. In some embodiments, the queues 206 (e.g., by a system administrator) are assigned different priorities, and applications with higher priorities (also assigned by a system administrator or programmer) are assigned to higher priority queues for faster processing. In some embodiments, the queues 206 are assigned the same priority.
[0067] Figure 4 An example program 400 that can be executed by an application 112 according to one or more embodiments is depicted. In some embodiments, the program 400 can be used to retrieve data from a storage device 102a and perform calculations using the retrieved data. The calculations can be performed via a calculation function 402. The calculation function 402 can use a data block N 404. The execution of the calculation function 402 can cause a data access request for data block N 404 to be sent to the data storage device 102. The program 400 may need to wait for the return of data block N 404 in order to perform the calculation function. Therefore, the execution of the program 400 may depend on the latency of the storage device 102a in returning the requested data block. If the requested data block is returned from the storage memory 118 (e.g., a cache hit), the latency may be lower. If the requested data block is returned from the NVM 120 (e.g., a cache miss), the latency may be higher.
[0068] To reduce memory access latency of storage device 102a, program 400 may invoke storage prefetch functionality 406 that causes storage device 102a to prefetch data block N+1 408 from NVM 120 to storage memory 118 before the compute function 402 needs the data for performing the computation. In this manner, when a load command for data block N 404 is received by storage device 102a when the compute function 402 is invoked, the requested data block may already be prefetched and resident in storage device 118, thereby allowing the data to be retrieved and returned from storage device 118 instead of NVM 120.
[0069] In some embodiments, the storage prefetch function 406 is executed in user space 410. The storage prefetch function 406 includes a copy command 412 that causes the address of the data block to be prefetched (referred to as the prefetch address) to be stored in the prefetch request queue 206.
[0070] In some embodiments, the prefetch request queue 206 is exposed to user space 410 as a mapped queue 206c. Exposing the prefetch request queue 206 to user space allows the prefetch function 406 to access the queue 206 to store addresses. In some embodiments, the copy command 412 in the prefetch function 406 identifies the mapped queue 206c to direct the command to the mapped queue 206c.
[0071] In some embodiments, the storage prefetch function 406 identifies a file range of data blocks to be prefetched and converts the file range to a physical address (e.g., a logical block address (LBA)). The converted physical address may be stored as a prefetch address in the prefetch request queue 206. In some embodiments, the prefetch address is stored at the end of the queue identified by the tail pointer 218. In some embodiments, the storage prefetch function modifies the tail pointer 218 based on storing the new address in the prefetch request queue 206. For example, the end of the queue identified by the tail pointer 218 may be increased by 1.
[0072] In some embodiments, the head pointer 220 of the prefetch request queue 206 is modified by the storage prefetch manager 204. For example, when a prefetch address is retrieved from the prefetch request queue 206, the storage prefetch manager 204 may increment the head pointer 220, and the data stored in the prefetch address is retrieved from the NVM 120 and stored in the storage memory 118.
[0073] Figure 5 Depicts multiple programs that may contend for the prefetch request queue 206 according to one or more embodiments. For example, a first example program 500a and a second example program 500b may be executed by the host 100 (e.g., simultaneously) in the user space 410. The first program 500a and the second program 500b may include a first storage prefetch function 502a and a second storage prefetch function 502b, respectively. The first storage prefetch function 502a and the second storage prefetch function 502b may contend for the prefetch request queue 206 to store a first prefetch address and a second prefetch address, respectively, into the queue.
[0074] In some embodiments, contention for the prefetch request queue 206 may be resolved by handing management of the queue 206 to the OS kernel 500. In this regard, the prefetch request queue 206 is exposed to the OS kernel 500 as a mapped queue 206d. In some embodiments, the OS kernel 500 executes a system prefetch function 502 that addresses the mapped queue 206d to insert the address of the data to be prefetched.
[0075] In some embodiments, when prefetching is to be performed, the first program 500a and the second program 500b call the system prefetch functions 502a, 502b. In some embodiments, the OS kernel 500 serializes the execution of the system prefetch functions of the first program 500a and the second program 500b. This allows the prefetch request queue 206 to be accessed by one program at a time.
[0076] In some embodiments, the system prefetch function 502 issues a copy command 504 for inserting a prefetch address into the queue 206. The inserted prefetch address may be, for example, a physical address identified by the OS kernel 500 based on the memory address identified by the programs 500a, 500b. In some embodiments, the OS kernel 500 directs the copy command 504 to the mapping queue 206d to insert the converted physical addresses for the first program 500a and the second program 500b (e.g., serially) into the queue 206. Thus, the queue 206 may store physical addresses to be prefetched for both the first program 500a and the second program 500b.
[0077] As the number of applications competing for a single queue 206 increases, serializing access to a single queue 206 may result in undesirable delays in storing prefetch addresses in the queue. Therefore, in some embodiments, contention for the prefetch request queue 206 by two or more applications is resolved by providing two or more prefetch request queues in the storage device.
[0078] Figure 6 Depicted is a storage device 102c including two or more prefetch request queues 206e to 206g according to one or more embodiments. In some embodiments, the prefetch request queues 206e to 206g are assigned (e.g., by an operating system) to applications 600a to 600c executed by the host 100. In some embodiments, a first prefetch request queue 206e is assigned to a first application 600a, a second prefetch request queue 206f is assigned to a second application 600b, and a third prefetch request queue 206g is assigned to a third application 600c. The prefetch request queues 206e to 206g may be mapped to mapped queues 206h to 206j in user space 410 for access by the corresponding applications 600a to 600c. Thus, Figure 6Embodiments of may avoid serializing OS kernel 500 access to a single queue.
[0079] In some embodiments, the prefetch request queues 206e-206g may be assigned priorities based on, for example, QoS considerations. Example QoS considerations may include, for example, application runtime, allocated memory bandwidth, throughput, etc. A programmer or system administrator may assign QoS levels to queues based on one or more of the QoS considerations. The storage prefetch engine 204 may select the order in which the queues 206e-206g are serviced based on the QoS considerations.
[0080] Figure 7 A flow chart depicts a process for prefetching data in accordance with one or more embodiments. The process begins, and in act 700, the processor 106 executes a prefetch instruction (e.g., a first command) included in an application. In some embodiments, the prefetch instruction is executed in user space 410. The prefetch instruction may identify, for example, an address of data to be prefetched, and an identifier of a prefetch request queue (e.g., mapping queues 206c, 600a-600c) in which the prefetch address (e.g., the first address) is to be stored.
[0081] In some embodiments, the prefetch instruction includes the address of the data to be prefetched.The identification and management of the prefetch request queue in which the prefetch addresses are to be stored is left to the OS kernel 500.
[0082] In action 702, the prefetch address is stored in the prefetch request queue 206. The prefetch address may be a physical address converted from a logical address provided by the application. In some embodiments, the prefetch instruction calls a prefetch function in user space. The prefetch function may include a command for storing the prefetch address in the mapping queue 206c or 206h to 206j. In response to the command, the prefetch address may be stored in the prefetch request queue 206 or 206e to 206g in the storage device 102.
[0083] In some embodiments, the prefetch instruction invokes a storage prefetch function 502 executed by the OS kernel 500. The storage prefetch function 502 may manage storing prefetch addresses into a prefetch request queue (e.g., mapping queue 206d) so that access attempts to the queue by two or more applications are serialized by the OS kernel 500.
[0084] In action 704, the storage prefetch engine 204 retrieves and processes the prefetch addresses stored in the prefetch request queue 206 or 206e-206g. In some embodiments, the storage prefetch engine 204 may check the storage memory 118 to determine whether the data to be prefetched already resides in the storage memory 118. If the associated data already resides in the storage memory 118, the prefetch address may be discarded (and not processed).
[0085] In act 706, the data identified by the pre-fetch address is retrieved from the NVM 120. In this regard, the FTL 208 may translate the pre-fetch address into a location in the NAND where the data is stored.
[0086] In act 708, the retrieved data is stored in the storage memory 118. The data can then be quickly retrieved for use by the application when a calculation needs to be performed based on the data.
[0087] It should be understood that the systems and methods for prefetching data described herein provide various advantages, including: 1) they allow the host 100 to access a prefetch request queue to store prefetch addresses in the queue; 2) (for example, in the case of a cache hit) they help reduce memory access latency and can further improve overall system performance and responsiveness; 3) prefetch instructions can be inserted into the program using existing compilers; 4) using multiple queues can help reduce contention and improve scalability.
[0088] Prefetch Optimization
[0089] In some embodiments, systems and methods for prefetching data include software prefetch instructions that are adjusted to maximize the performance of an application that includes the prefetch instructions. The adjustment may include identifying an optimal prefetch step size (e.g., the step size of a memory block to be prefetched relative to a memory block currently in use). The adjustment may help prevent the use of a prefetch step size that is too close to a memory block currently in use.
[0090] Figure 8 Depicting example code for a program 800 that includes a call to a storage prefetch function 802 that identifies a memory block to be prefetched via a prefetch step value 804 relative to a current block N. In the example code for program 800, the prefetch step 804 is "1." Thus, the storage prefetch function 802 causes a prefetch of the next data block N+1 to be used by a compute function 806 while the compute function is processing the current data block N.
[0091] In some cases, prefetching data from NVM 120 into storage memory 118 may be slow. In such cases, the prefetched data may not be in storage memory 118 before the program is ready to use the data in compute function 806. Therefore, it may be desirable to adjust the prefetch step size X 808 identified in storage prefetch function 810 to have an optimal value for optimizing the performance of the program 812 that includes the prefetch function.
[0092] Fig. 9 Depicts the execution of instructions before adjusting the prefetch step size 804 according to one or more embodiments. Figure 8Table 900 shows the timing of pre-fetching of data blocks during the example process 800 and the timing of when the data blocks are needed for calculation. Fig. 9 In the example of FIG. 8 , it is assumed that the time required to complete prefetching data from NVM 120 to storage memory 118 is equal to the time required to execute two iterations of program loop 912 included in program 800 .
[0093] Table 900 may include iteration numbers 902 of loop 912. For one or more of the iteration numbers, table 900 may also include corresponding prefetch blocks 904, prefetched blocks 906, compute requirement blocks 908, and in-cache flags 910. Prefetch blocks 904 may indicate block numbers that were commanded to be prefetched by storage prefetch function 802 during iterations of loop 912. Prefetched blocks 906 may indicate block numbers that were prefetched during iterations of the loop. Compute requirement blocks 908 may indicate block numbers that were required to perform compute function 806 during iterations of loop 912. In-cache flags may indicate whether blocks that were required to perform compute function 806 during iterations of loop 912 reside in storage memory 118.
[0094] exist Fig. 9 In the example program 800 of , the prefetch step size is "1". Therefore, at iteration 0 (n=0) of loop 912, the prefetch block 904 identified by the storage prefetch function 802 is 1 (n+1=0+1=1). As indicated in the prefetched blocks portion 914 of the table corresponding to iteration 2, because two iterations of the loop are required to complete the prefetch, the prefetching of data is completed in iteration 2. Therefore, data block 1 does not appear in the storage memory 118 until iteration 2.
[0095] However, as indicated in the compute required blocks portion 916 of the table, the compute function 806 requires data block 1 for computation in iteration 1 of loop 912. Since the prefetch of block 1 has not yet completed at iteration 1, it results in a cache miss (e.g., the data is not in storage memory 118). Therefore, for iteration 1, the in-cache flag 910 is set to "N" 918.
[0096] As shown in table 900 , the example program 800 with a prefetch stride 804 of “1” results in cache misses for all iterations of loop 912 due to the access latency of NVM 120 .
[0097] Fig.10 Depicts the instructions for performing the following after adjusting the prefetch step size X 808 to "2" according to one or more embodiments. Figure 81000 shows the timing of prefetching of data blocks and when the data blocks are needed for computation during an example program 812. Again, assume that the time required to complete prefetching data from NVM 120 to storage memory 118 is equal to the time required to execute two iterations of program loop 1012 included in program 812.
[0098] At iteration 0 (n=0) of loop 1012, the prefetch block 1004 identified in storage prefetch function 810 is 2 (n+2=0+2=2). As indicated in the prefetched blocks portion 1014 of the table corresponding to iteration 2, because two iterations of the loop are required to complete the prefetch, the prefetching of data is completed in iteration 2. Therefore, data block 2 appears in storage memory 118 starting with iteration 2.
[0099] As indicated in the compute required blocks portion 1018 of the table, the compute function 1016 does not require data block 2 for computation prior to iteration 2 of loop 1012. Since at iteration 2, the prefetch of block 2 has already completed, it results in a cache hit (e.g., the data is in storage memory 118). Therefore, for iteration 2, the in-cache flag 1010 is set to "Y" 1020.
[0100] As shown in table 1000, the example program 812 with an optimized prefetch stride 808 of "2" results in cache hits for all other iterations of the loop after iteration 2. However, iterations 0 and 1 result in cache misses, as indicated by the in-cache flag 101 being set to "N" 1022, "N" 1024 for iterations 0 and 1.
[0101] Fig.11 A flow chart depicts a process for prefetch optimization according to one or more embodiments. The process may be performed, for example, by host processor 106 based on instructions stored in memory 108 .
[0102] The process begins, and in act 1100, a prefetch step value is identified. In some embodiments, the prefetch step value is a random number selected within given constraints (e.g., minimum and maximum values), but embodiments are not limited thereto. For example, instead of randomly selecting a prefetch step value, the value may be selected in a more systematic manner. For example, the values may be selected so that they increase (or decrease) in a straight line.
[0103] In some embodiments, the selection of the stride value may be based on the application and / or the resource. For example, the stride value may be selected based on the data access pattern of the application and / or the properties of the hardware used to execute the application (e.g., memory access latency). For example, one application with one type of data access pattern may require one stride value, and another application with a different access pattern may require a different stride value. In another example, the stride of an application executed by a CPU may have one stride value, and another application executed on a GPU may have another stride value.
[0104] In act 1102, an application (eg, program 800) is compiled and run. For example, the application may be compiled using feedback directed optimization (FDO).
[0105] In action 1104, the performance of the application is measured. The performance of the application can be measured by measuring the runtime of the application. In this regard, when the application begins to run, a start time can be identified, and when the application completes running, an end time can be identified.
[0106] In action 1106, a determination may be made as to whether the goal has been met. In some embodiments, the goal is considered met if the performance of the application meets the criteria. For example, if the difference between the end time and the start time is below a threshold, the performance of the application may meet the criteria.
[0107] If the target has not been met, processing returns to act 1100 and processing repeats with a different step value. In some embodiments, the FDO is configured to select a new step value using one of the methods described above and recompile the program based on measured application performance to achieve better performance.
[0108] If the target is met, the storage prefetch function 810 uses the identified stride value to prefetch the data block.
[0109] In some embodiments, prefetch optimization according to one or more embodiments is performed by a computing storage device (CSD) having an embedded processor and a storage medium. For example, execution of an application, monitoring of the performance of the application, adjustment of the step value, and / or recompiling the application based on the adjusted step value may be performed by the CSD.
[0110] One or more embodiments of the present disclosure may be implemented in one or more processors. The term processor may refer to one or more processors and / or one or more processing cores. One or more processors may be hosted in a single device or distributed on multiple devices (e.g., on a cloud system). The processor may include, for example, an application specific integrated circuit (ASIC), a general-purpose central processing unit (CPU) or a dedicated central processing unit (CPU), a digital signal processor (DSP), a graphics processing unit (GPU), and a programmable logic device (such as a field programmable gate array (FPGA)). In the processor, as used herein, each function is either performed by hardware configured (i.e., hardwired) to perform the function, or by more general hardware (such as a CPU) configured to execute instructions stored in a non-temporary storage medium (e.g., a memory). The processor may be manufactured on a single printed circuit board (PCB) or distributed on several interconnected PCBs. The processor may include other processing circuits; for example, the processing circuit may include two processing circuits interconnected on the PCB: an FPGA and a CPU.
[0111] It will be understood that although the terms "first", "second", "third", etc. may be used herein to describe various elements, components, regions, layers and / or parts, these elements, components, regions, layers and / or parts should not be limited by these terms. These terms are only used to distinguish one element, one component, one region, one layer or one part from another element, another component, another region, another layer or another part. Therefore, without departing from the spirit and scope of the inventive concept, the first element, first component, first region, first layer or first part discussed herein may be referred to as the second element, second component, second region, second layer or second part.
[0112] The terms used herein are only used to describe the purpose of specific embodiments and are not intended to limit the inventive concept. In addition, unless explicitly stated, the embodiments described herein are not mutually exclusive. In some embodiments, aspects of the embodiments described herein may be combined.
[0113] As used herein, the terms "substantially," "about," and similar terms are used as terms of approximation rather than terms of degree, and are intended to take into account the inherent variations in measurements or calculations that those of ordinary skill in the art would recognize.
[0114] As used herein, unless the context clearly indicates otherwise, the singular form is also intended to include the plural form. It will also be understood that when used in this specification, the terms "include" and / or "comprise" illustrate the existence of the features, wholes, steps, operations, elements and / or components of the description, but do not exclude the existence or addition of one or more other features, wholes, steps, operations, elements, components and / or their groups. As used herein, the term "and / or" includes any and all combinations of one or more of the associated listed items. When expressions such as "at least one of..." are after the list of elements, the entire list of elements is modified without modifying the individual elements in the list. In addition, the use of "may" when describing the embodiments of the inventive concept represents "one or more embodiments of the present disclosure". In addition, the term "exemplary" is intended to represent an example or description. As used herein, the term "use" may be considered to be synonymous with the term "utilize".
[0115] Although exemplary embodiments of systems and methods for prefetching data have been specifically described and illustrated herein, many modifications and variations will be apparent to those skilled in the art. Therefore, it will be understood that systems and methods for prefetching data constructed according to the principles of the present disclosure may be implemented in a manner different from that specifically described herein. The disclosure is further defined in the appended claims and their equivalents.
[0116] The system and method for prefetching data may include one or more combinations of the features set forth in the following claims.
[0117] Statement 1. A computing system comprising: a storage device including a first queue, a first storage medium, and a second storage medium; a processor configured to communicate with the storage device; and a memory coupled to the processor, the memory storing instructions that, when executed by the processor, cause the processor to: execute a first command for moving first data stored in the storage device; and based on the first command, store a first address associated with the first data in a first queue, wherein the storage device is configured to: retrieve the first address from the first queue, retrieve the first data from the first storage medium based on the first address, and store the first data to the second storage medium.
[0118] Statement 2. The system of statement 1, wherein the instructions further cause the processor to: modify a pointer identifying a location in the first queue based on storing the first address in the first queue.
[0119] Statement 3. The system of statement 1 wherein the first command includes a second command for prefetching data stored in a location associated with the first address.
[0120] Statement 4. The system of statement 1 wherein the first storage medium comprises non-volatile memory and the second storage medium comprises volatile memory.
[0121] Statement 5. The system of statement 1, wherein the first queue is mapped to a user space associated with an application, wherein the first command is executed in the user space.
[0122] Statement 6. A system according to statement 1, wherein the first command is generated by a first application, and wherein the instructions also cause the processor to: execute a second command for moving second data stored in a storage device, wherein the second command is generated by a second application; based on the second command, store a second address associated with the second data in a first queue, wherein the storage device is configured to: retrieve the second address from the first queue, retrieve the second data from the first storage medium based on the second address, and store the second data to the second storage medium.
[0123] Statement 7. The system of statement 6, wherein the first command comprises a first call to an operating system and the second command comprises a second call to the operating system, wherein the operating system is configured to manage storing the first address and the second address in the first queue.
[0124] Statement 8. The system of statement 6 wherein the first queue is assigned to a first application and the second queue is assigned to a second application.
[0125] Statement 9. The system of statement 1 wherein the processor is configured to modify a pointer associated with the first queue based on storing the first address in the first queue.
[0126] Statement 10. A computing system comprising: a storage device including a first storage medium and a second storage medium; a processor configured to communicate with the storage device; and a memory coupled to the processor, the memory storing instructions that, when executed by the processor, cause the processor to: identify a value for prefetching data; run an application; measure performance of the application; modify the value based on the performance; and determine that the performance meets a criterion.
[0127] Statement 11. The system of statement 10, wherein the value is a step size of the second memory block to be prefetched relative to the first memory block used by the application.
[0128] Statement 12. The system of statement 10 wherein the value is identified in a prefetch command included in the application.
[0129] Statement 13. The system of statement 12, wherein the storage device includes a queue, wherein the address identified based on the value is stored in the queue based on the prefetch command.
[0130] Statement 14. The system of statement 13 wherein the storage device is configured to retrieve the address from a queue, retrieve data from a first storage medium based on the address, and store the data to a second storage medium.
[0131] Statement 15. The system of statement 10, wherein the application includes a prefetch command that identifies the value, and wherein the instructions that cause the processor to measure performance include instructions that cause the processor to measure a runtime of the application.
[0132] Statement 16. The system of statement 10 wherein said instructions causing a processor to modify said value comprise instructions causing a processor to randomly modify said value.
[0133] Statement 17. A method comprising: executing, by a processor, a first command for moving first data stored in a storage device comprising a first queue, a first storage medium, and a second storage medium; and based on the first command, storing, by the processor, a first address associated with the first data in the first queue, wherein the storage device is configured to: retrieve the first address from the first queue, retrieve the first data from the first storage medium based on the first address, and store the first data in the second storage medium.
[0134] Statement 18. Based on storing the first address in the first queue, modifying a pointer identifying a location in the first queue.
[0135] Statement 19. The method of statement 17 wherein the first command includes a second command for prefetching data stored in a location associated with the first address.
[0136] Statement 20. The method of statement 17 wherein the first storage medium comprises non-volatile memory and the second storage medium comprises volatile memory.
[0137] Statement 21. The method of statement 17, wherein the first queue is mapped to a user space associated with an application, wherein the first command is executed in the user space.
[0138] Statement 22. A method according to statement 17, wherein the first command is generated by a first application, and the method further includes: executing a second command for moving second data stored in a storage device, wherein the second command is generated by a second application; based on the second command, storing a second address associated with the second data in a first queue, wherein the storage device is configured to: retrieve the second address from the first queue, retrieve the second data from the first storage medium based on the second address, and store the second data to the second storage medium.
[0139] Statement 23. The method of statement 22, wherein the first command comprises a first call to an operating system and the second command comprises a second call to the operating system, wherein the operating system is configured to manage storing the first address and the second address in the first queue.
[0140] Statement 24. The method of statement 22 wherein the first queue is assigned to a first application and the second queue is assigned to a second application.
[0141] Statement 25. The method of statement 17, further comprising:
[0142] Based on storing the first address in the first queue, a pointer associated with the first queue is modified.
[0143] Statement 26. A method comprising: identifying, by a processor in communication with a storage device, a value for prefetching data; running, by the processor, an application; measuring, by the processor, a performance of the application; modifying, by the processor, the value based on the performance; and determining, by the processor, that the performance satisfies a criterion.
[0144] Statement 27. The method of statement 26 wherein the value is a step size of the second memory block to be prefetched relative to the first memory block used by the application.
[0145] Statement 28. The method of statement 26 wherein the value is identified in a prefetch command included in the application.
[0146] Statement 29. The method of statement 28 wherein the storage device includes a queue, wherein the address identified based on the value is stored in the queue based on a prefetch command.
[0147] Statement 30. The method of statement 29 wherein the storage device is configured to retrieve the address from a queue, retrieve data from a first storage medium of the storage device based on the address, and store the data to a second storage medium of the storage device.
[0148] Statement 31. The method of statement 26 wherein the application includes a prefetch command that identifies the value, and wherein measuring the performance includes measuring a runtime of the application.
[0149] Statement 32. The method of statement 26 wherein modifying the value comprises randomly modifying the value.
Claims
1. A computing system, include: A storage device, comprising a first queue, a first storage medium, and a second storage medium; a processor configured to communicate with a storage device; as well as A memory, coupled to the processor, the memory storing instructions that, when executed by the processor, cause the processor to: executing a first command for moving first data stored in a storage device; and Based on a first command, a first address associated with first data is stored in a first queue, wherein the storage device is configured to: retrieve the first address from the first queue, retrieve the first data from a first storage medium based on the first address, and store the first data to a second storage medium.
2. The computing system according to claim 1, in, The instructions also cause the processor to: Based on storing the first address in the first queue, a pointer identifying a location in the first queue is modified.
3. The computing system according to claim 1, in, The first command includes a second command for prefetching data stored in a location associated with the first address.
4. The computing system according to claim 1, in, The first storage medium includes a non-volatile memory, and the second storage medium includes a volatile memory.
5. The computing system according to claim 1, in, The first queue is mapped to a user space associated with the application, wherein the first command is executed in the user space.
6. The computing system according to claim 1, in, The first command is generated by the first application, wherein the instructions further cause the processor to: executing a second command for moving second data stored in the storage device, wherein the second command is generated by a second application; Based on the second command, a second address associated with the second data is stored in the first queue, wherein the storage device is configured to: retrieve the second address from the first queue, retrieve the second data from the first storage medium based on the second address, and store the second data to the second storage medium.
7. The computing system according to claim 6, in, The first command includes a first call to an operating system and the second command includes a second call to the operating system, wherein the operating system is configured to manage storing the first address and the second address in the first queue.
8. The computing system according to claim 6, in, The first queue is assigned to the first application and the second queue is assigned to the second application.
9. The computing system according to claim 1, in, The processor is configured as: Based on storing the first address in the first queue, a pointer associated with the first queue is modified.
10. A computing system, include: A storage device comprising a first storage medium and a second storage medium; a processor configured to communicate with a storage device; as well as A memory, coupled to the processor, the memory storing instructions that, when executed by the processor, cause the processor to: identifying a value for prefetching data; Run the application. Measure the performance of your application; Based on the performance, modifying the value; and It is determined that the performance meets the criteria.
11. The computing system according to claim 10, in, The value is the step size of the second memory block to be prefetched relative to the first memory block used by the application.
12. The computing system according to claim 10, in, The value is identified in a prefetch command included in the application.
13. The computing system according to claim 12, in, The storage device includes a queue, wherein the address identified based on the value is stored in the queue based on the prefetch command.
14. The computing system of claim 13, in, The storage device is configured to retrieve the address from the queue, retrieve data from the first storage medium based on the address, and store the data to the second storage medium.
15. The computing system according to claim 10, in, The application includes a prefetch command that identifies the value, wherein the instructions that cause the processor to measure performance include instructions that cause the processor to measure a runtime of the application.
16. The computing system of claim 10, in, The instructions causing the processor to modify the value include instructions causing the processor to randomly modify the value.
17. A method for pre-fetching data, include: executing, by the processor, a first command for moving first data stored in a storage device including a first queue, a first storage medium, and a second storage medium; as well as Based on the first command, the processor stores a first address associated with the first data in the first queue, wherein the storage device is configured to: retrieve the first address from the first queue, retrieve the first data from the first storage medium based on the first address, and store the first data in the second storage medium.
18. The method according to claim 17, further comprising: include: Based on storing the first address in the first queue, a pointer identifying a location in the first queue is modified.
19. The method according to claim 17, in, The first command includes a second command for prefetching data stored in a location associated with the first address.
20. The method according to claim 17, in, The first storage medium includes a non-volatile memory, and the second storage medium includes a volatile memory.
