Per cursor LUN sequencing
By assigning a unique generator to each cursor and identifying its associated LUN sequence, the problem of multiple cursor conflicts in the memory subsystem is solved, and the parallelism and speed of operations are improved.
Patent Information
- Application Number
- CN201980084909.0
- Authority / Receiving Office
- CN · China
- Patent Type
- Patents(China)
- Current Assignee / Owner
- Priority Date
- 2018-11-30
- Filing Date
- 2019-11-22
- Publication Date
- 2024-11-22
- Estimated Expiration
- 2039-11-22
AI Technical Summary
In the memory subsystem, multiple cursors are prone to conflict when performing memory operations on the same LUN sequence, resulting in a decrease in parallelism and speed of the memory subsystem.
Each cursor is assigned a unique generator to identify its associated LUN sequence, thereby avoiding conflicts when performing memory operations and increasing parallelism and speed of operations.
By using different LUN sequences to perform memory operations, the probability of conflict between cursors is reduced, and the operation efficiency and speed of the memory subsystem is improved.
Smart Images

Figure CN113302582B_ABST
Abstract
Description
Technical Field
[0001] Embodiments of the present disclosure relate generally to memory subsystems, and more particularly, to per-cursor logical unit number (LUN) sequencing in memory subsystems. Background Art
[0002] The memory subsystem may be a storage system, such as a solid state drive (SSD) or a hard disk drive (HDD). The memory subsystem may be a memory module, such as a dual in-line memory module (DIMM), a small outline DIMM (SO-DIMM), or a non-volatile dual in-line memory module (NVDIMM). The memory subsystem may include one or more memory components that store data. The memory components may be, for example, non-volatile memory components and volatile memory components. In general, the host system may utilize the memory subsystem to store data at the memory components and retrieve data from the memory components. BRIEF DESCRIPTION OF THE DRAWINGS
[0003] The present disclosure will be more fully understood from the detailed description given below and the accompanying drawings of various embodiments of the present disclosure.
[0004] Figure 1 An example computing environment including a memory subsystem according to some embodiments of the present disclosure is described.
[0005] Figure 2 Another example computing environment including a memory subsystem according to some embodiments of the present disclosure is described.
[0006] Figure 3 A LUN sequence according to an embodiment of the present disclosure is described.
[0007] Figure 4 A channel sequence according to an embodiment of the present disclosure is described.
[0008] Figure 5 is a flow diagram of an example method of performing operations on a storage component using a LUN sequence according to some embodiments.
[0009] Figure 6 is a block diagram of an example machine of a computer system in which embodiments of the present disclosure may operate. DETAILED DESCRIPTION
[0010] Aspects of the present disclosure are directed to per-cursor logical unit number (LUN) sequencing in a memory subsystem. A memory subsystem is also referred to hereinafter as a "memory device". An example of a memory subsystem is a storage device coupled to a central processing unit (CPU) via a peripheral interconnect (e.g., an input / output bus, a storage area network). Examples of storage devices include solid-state drives (SSDs), flash drives, universal serial bus (USB) flash drives, and hard disk drives (HDDs). Another example of a memory subsystem is a memory module coupled to a CPU via a memory bus. Examples of memory modules include dual in-line memory modules (DIMMs), small outline DIMMs (SO-DIMMs), non-volatile dual in-line memory modules (NVDIMMs), and the like. In some embodiments, the memory subsystem is a hybrid memory / storage subsystem. In general, a host system may utilize a memory subsystem that includes one or more memory components. The host system may provide data to be stored at the memory subsystem, and may request to retrieve data from the memory subsystem.
[0011] Multiple cursors may be used by the memory subsystem to perform memory operations, such as write operations that write data from a host system to the memory subsystem. The cursor is responsible for keeping track of when, where, or in what order operations are performed on one or more memory components. The cursor may include software (e.g., firmware), hardware, or a combination thereof that manages the execution of memory operations (e.g., determining where, when, and in what order data is written to the memory component). In some conventional memory subsystems, memory operations may be performed on a sequence of logical unit numbers (LUNs) (e.g., memory cells) of memory components, where each of the multiple cursors uses the same LUN sequence. In some memory subsystems, only one memory operation may be performed on a LUN at a given instance. Cursors using the same LUN sequence typically conflict where at least two cursors attempt to perform memory operations on the same LUN at the same time. In such cases, one cursor waits to perform a memory operation on a LUN until another cursor completes performing a memory operation on the same LUN, which reduces the parallelism and speed of the memory subsystem.
[0012] For example, cursor A writes to the memory components in the order given by the LUN sequence {0,1,2,3,4}, and cursor B writes to the memory components in the order given by the same LUN sequence {0,1,2,3,4}. Both cursors A and B perform write operations in an order starting with LUN 0, then LUN 1, then LUN 2, and so on. If both cursors begin write operations at approximately the same time, cursors A and B may conflict at each LUN in the LUN sequence.
[0013] Aspects of the present disclosure address the above and other challenges by assigning a generator to each of a plurality of cursors. In an embodiment, the generator may be unique to each of the cursors. The respective generator may be used to identify a LUN sequence for each of the cursors, each LUN sequence associated with the respective cursor being a unique LUN sequence. The cursor may perform memory operations on a set of LUNs associated with a memory component in an order provided by the respective LUN sequence to reduce the probability of cursor conflicts when performing memory operations.
[0014] Identifying LUN sequences on a per-cursor basis improves the operation of the memory subsystem by improving the parallelism and speed of memory operation execution. For example, by executing memory operations using different LUN sequences rather than the same LUN sequence, a cursor can write to more LUNs in parallel more frequently and avoid conflicts with other cursors.
[0015] Figure 1 An example computing environment 100 including a memory subsystem 110 is described according to some embodiments of the present disclosure. The memory subsystem 110 may include media, such as memory components 112A to 112N. The memory components 112A to 112N may be volatile memory components, non-volatile memory components, or a combination of such components. In some embodiments, the memory subsystem is a storage system. An example of a storage system is a solid state drive (SSD). In general, the computing environment 100 may include a host system 120 that uses the memory subsystem 110. In some embodiments, the host system 120 may write data to the memory subsystem 110 and read data from the memory subsystem 110. In some embodiments, the memory subsystem 110 is a hybrid memory / storage device system.
[0016] The host system 120 may be a computing device, such as a desktop computer, a laptop computer, a network server, a mobile device, or such computing devices that include a memory and a processing device. The host system 120 may include or be coupled to the memory subsystem 110 so that the host system 120 can read data from the memory subsystem 110 or write data to the memory subsystem 110. The host system 120 may be coupled to the memory subsystem 110 via a physical host interface. As used herein, "coupled to" generally refers to a connection between components, which may be an indirect communication connection or a direct communication connection (e.g., without an intermediate component), whether wired or wireless, including connections such as electrical connections, optical connections, magnetic connections, etc. Examples of physical host interfaces include, but are not limited to, a Serial Advanced Technology Attachment (SATA) interface, a Peripheral Component Interconnect Express (PCIe) interface, a Universal Serial Bus (USB) interface, a Fibre Channel, a Serial Attached SCSI (SAS), etc. The physical host interface may be used to transmit data between the host system 120 and the memory subsystem 110. When the memory subsystem 110 is coupled to the host system 120 through a PCIe interface, the host system 120 can further utilize an NVM Express (NVMe) interface to access the memory components 112A to 112N. The physical host interface can provide an interface for transferring control, address, data, and other signals between the memory subsystem 110 and the host system 120.
[0017] Memory components 112A to 112N may include any combination of different types of non-volatile memory components or volatile memory components. Examples of non-volatile memory components include negative-and (NAND) type flash memory. Each of memory components 112A to 112N may include one or more memory cell arrays, such as single-level cells (SLC) or multi-level cells (MLC) (e.g., triple-level cells (TLC) or quad-level cells (QLC)). In some embodiments, a particular memory component may include both an SLC portion and an MLC portion of a memory cell. Each of the memory cells may store data bits (e.g., data blocks) for use by the host system 120. Although non-volatile memory components such as NAND type flash memory are described, memory components 112A to 112N may be based on any other type of memory, such as volatile memory. In some embodiments, the memory components 112A to 112N may be, but are not limited to, random access memory (RAM), read-only memory (ROM), dynamic random access memory (DRAM), synchronous dynamic random access memory (SDRAM), phase change memory (PCM), magnetic random access memory (MRAM), or non-(NOR) flash memory, electrically erasable programmable read-only memory (EEPROM), and cross-point arrays of non-volatile memory cells. The cross-point array of non-volatile memory may be combined with a stackable cross-grid data access array to perform bit storage based on changes in body resistance. In addition, in contrast to many flash-based memories, the cross-point non-volatile memory may perform write-in-place operations, where the non-volatile memory cells may be programmed without pre-erasing the non-volatile memory cells. Furthermore, the memory cells of the memory components 112A to 112N may be grouped into memory pages or data blocks, which may refer to cells of a memory component used to store data.
[0018] The controller 115 may communicate with the memory components 112A to 112N to perform operations, such as reading data, writing data, or erasing data and other such operations at the memory components 112A to 112N. The controller 115 may include hardware, such as one or more integrated circuits and / or discrete components, buffer memory, or a combination thereof. The controller 115 may be a microcontroller, a dedicated logic circuit (e.g., a field programmable gate array (FPGA), an application-specific integrated circuit (ASIC), etc.), or other suitable processor. The controller 115 may include a processor (processing device) 117 configured to execute instructions stored in a local memory 119. In the illustrated example, the local memory 119 of the controller 115 includes an embedded memory configured to store instructions for executing various processes, operations, logic flows, and routines for controlling the operation of the memory subsystem 110 (including handling the communication between the memory subsystem 110 and the host system 120). In some embodiments, the local memory 119 may include memory registers that store memory pointers, extracted data, etc. The local memory 119 may also include a read-only memory (ROM) for storing microcode. Although Figure 1 The example memory subsystem 110 in FIG. 1 has been illustrated as including a controller 115, but in another embodiment of the present disclosure, the memory subsystem 110 may not include a controller 115 and may instead rely on external control (e.g., provided by an external host or by a processor or controller separate from the memory subsystem).
[0019] In general, the controller 115 may receive commands or operations from the host system 120 and may convert the commands or operations into instructions or suitable commands to achieve the desired access to the memory components 112A to 112N. The controller 115 may be responsible for other operations such as wear leveling operations, garbage collection operations, error detection and error correction code (ECC) operations, encryption operations, cache operations, and address translation between logical block addresses and physical block addresses associated with the memory components 112A to 112N. The controller 115 may additionally include a host interface circuit system to communicate with the host system 120 via a physical host interface. The host interface circuit system may convert commands received from the host system into command instructions to access the memory components 112A to 112N, and convert responses associated with the memory components 112A to 112N into information for the host system 120.
[0020] The memory subsystem 110 may include a logical unit number (LUN) sequencing component 113 (e.g., circuitry, dedicated logic, programmable logic, firmware, etc.) to perform the operations described herein. In some embodiments, the LUN sequencing component 113 may assign a corresponding generator to each of the cursors. The generator may be used to identify a LUN sequence for each of the cursors. The cursors may perform memory operations on a set of LUNs associated with the memory components 112A to 112N in an order provided by the LUN sequence associated with each cursor. Performing memory operations on a set of LUNs in an order provided by the LUN sequence reduces the probability of cursor conflicts when performing memory operations.
[0021] The memory subsystem 110 may also include additional circuits or components not illustrated. In some embodiments, the memory subsystem 110 may include a cache or buffer (e.g., DRAM), and address circuitry (e.g., row decoders and column decoders) that may receive addresses from the controller 115 and decode the addresses to access the memory components 112A to 112N.
[0022] Figure 2 Another example computing environment 200 including a memory subsystem according to some embodiments of the present disclosure is illustrated. Figure 1 Elements of computing environment 100 may be used to help illustrate Figure 2 For example, the computing environment 200 includes Figure 1 The computing environment 200 includes a host system 120, a controller 115, and memory components 112A-112N (collectively referred to herein as "memory components 112"). It can be noted that the computing environment 200 is provided for illustrative purposes and not for limiting purposes. In an embodiment, the computing environment 200 may include Figure 1 Some, all, none, more, or different elements of computing environment 100. It may also be noted that the memory subsystem 210 of computing environment 200 may include Figure 1 Some, all, none, more, or different elements of the memory subsystem 110.
[0023] In some embodiments, the memory components 112A-112N may include non-volatile memory components, such as solid-state non-volatile memory components (e.g., NAND devices). The solid-state non-volatile memory components described herein are provided for illustrative and non-limiting purposes. Aspects of the present disclosure may generally be applied to other types of non-volatile memory devices, such as disk storage devices, or other types of memory devices. In some embodiments, the memory component 112 may include a set of logical unit numbers (LUNs) 220. A LUN may refer to a memory unit. In some embodiments, a memory unit may be a die of the memory component 112. In other embodiments, the memory unit may be a different amount of memory. In some embodiments, each LUN in the LUN set 220 may be the same amount of memory. A single memory component 112 may include one or more dies configured in a discrete package. As illustrated, the LUN set includes 16 LUNs numbered LUN 0 to LUN 15. In other embodiments, the LUN set may include any number of LUNs.
[0024] In some embodiments, a LUN of a memory component 112 may be divided into smaller memory units. For example, a LUN may include multiple memory blocks. A memory block may refer to the smallest unit of a memory component 112 that can be erased in response to an erase operation. For example, LUN 0 may include memory blocks 0 to N. A memory block may include multiple pages of memory. A memory page may refer to the smallest unit of a memory component 112 that can be written to in response to a write operation. For example, block 0 of LUN 0 may include page 0 to page N. An erase operation removes data from one or more blocks of a memory component 112, and a write operation writes data to one or more pages of a memory device 112.
[0025] In one embodiment, one or more channels 230 couple the controller 115 to the memory component 112. A channel may refer to a connection or coupling between two elements of a computing environment, such as a connection or coupling between a controller 115 and a memory component 112. Channels 230 illustrate eight channels numbered channel 0 through channel 7. In other embodiments, the memory subsystem 210 may include any number of channels. In some embodiments, the number of channels used to connect to the memory component 112 may change, for example, because the channels of the computing environment 200 are dynamically repurposed for other uses.
[0026] In some embodiments, the channels 230 may be used by the controller 115 to communicate with the memory component 112. For example, the controller 115 may perform one or more memory operations, such as a write operation, a read operation, an erase operation, a map operation, or garbage collection, on the memory component 112. The communication between the controller 115 and the memory component 112 using the channels may use any number of communication protocols, such as protocols that comply with the Open NAND Flash Interface (ONFi) specification. For example, the controller 115 may use an appropriate channel 230 to perform a write operation that writes data received from the host system 120 to a corresponding LUN of the memory component 112.
[0027] In some embodiments, data may be "striped" across memory components 112, such as across multiple LUNs in LUN set 220. Striping (also referred to herein as "block striping") may refer to the process of dividing a body of data into smaller units and spreading the smaller data units across multiple memory components 112. For example, controller 115 may receive data from host system 120. Write operations may be performed on the received data in a manner in which controller 115 stripes the data across memory components 112. For example, data may be written on page 0 of block 0 of LUN 0, data may be written on page 0 of block 1 of LUN 1, data may be written on page 0 of block 0 of LUN 2, and so on, until the data has been written to the entire memory component 112. Data striped across multiple LUNs may be referred to as block striping. Block striping may improve the performance of memory subsystem 110. For example, writing in parallel across multiple LUNs may improve parallelism and improve the speed at which memory components 112 may be written. It may be noted that for some implementations, no more than one memory operation may be performed on a single LUN at a given instance. For example, a read or write operation (but not both) may be performed on LUN 0 at a given instance.
[0028] In some embodiments, the controller 115 may implement one or more cursors to assist the memory component 112 in performing one or more memory operations. The cursor may include software (e.g., firmware), hardware, or a combination thereof that manages the execution of memory operations. For example, a cursor may manage write operations that stripe data across the memory component 112. The cursor may manage the sequence of LUNs for which block striping is performed or be responsible for keeping track of the cursor's position (e.g., which LUN is performing a write operation), among other functions.
[0029] In an embodiment, multiple cursors may be implemented by the controller 115. In an example, the controller 115 may use different cursors to perform different memory operations. For example, the controller 115 may implement a cursor for garbage collection, a cursor for performing write operations, and so on. In another example, the controller 115 may implement multiple cursors to perform a single memory operation. For example, the controller 115 may implement multiple cursors (e.g., multiple host cursors) to perform a write operation to write data received from the host system 120 to the memory component 112.
[0030] In some embodiments, the cursor may perform memory operations on the memory component 112 in a specific sequence (e.g., a LUN sequence). The LUN sequence may refer to the order of LUNs for which the cursor performs memory operations. For example, a LUN sequence for a set of 16 LUNs may be {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}, where each integer in the sequence refers to a corresponding LUN in the LUN set 220. When performing a write operation using the LUN sequence, the cursor may write to LUN 0, then to LUN 1, then to LUN 2, and so on, in the order provided by the LUN sequence. It may be noted that the cursor may write to multiple LUNs in parallel. For example, with three available channels, the cursor may write to LUN 0 to LUN 2 in parallel, then to LUN 3 to LUN 5, and so on, in the order provided by the LUN sequence.
[0031] As described above, some memory subsystems assign the same LUN sequence to each cursor, which increases the probability of cursor collision when performing memory operations. A collision may refer to an instance in which two cursors attempt to perform one or more memory operations on the same LUN in parallel. In an embodiment in which a single memory operation may be performed on a LUN at a given instance, two cursors "collide" when they attempt to perform a memory operation on the same LUN at the same time. In such instances, only the first cursor may perform the associated memory operation on the LUN while the second cursor waits to perform a memory operation until the first cursor completes its respective operation. For example, two cursors that perform operations on a LUN set 220 using the same LUN sequence (e.g., LUN sequence {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15}) have a higher probability of collision at one or more LUNs than a scenario in which the two cursors perform respective memory operations using different LUN sequences.
[0032] Figure 3 An example of LUN sequencing 300 according to an embodiment of the present disclosure is illustrated. Figure 1 Computing environment 100 and Figure 2Elements of computing environment 200 may be used to help illustrate Figure 3 LUN sequencing 300 shows a plurality of unique LUN sequences 315A-315H (collectively referred to herein as "LUN sequences 315"). Each of the unique LUN sequences contains a single instance of each LUN in LUN set 220. As illustrated, each LUN sequence is unique in that the order of the LUNs in the sequence is not the same for any two of the LUN sequences 315.
[0033] In an embodiment, each cursor may perform a memory operation on the memory component 112 using a different LUN in the LUN sequence 315. As described above, cursors that perform memory operations in different orders (in different orders) using different LUN sequences 315) reduce the probability that two or more of the cursors will conflict when performing memory operations. For example, the first cursor may be assigned LUN sequence 315A, and the second cursor may be assigned LUN sequence 315B. The first cursor and the second cursor may perform write operations on the memory component 112 at approximately the same time. The first cursor and the second cursor begin writing data on LUN 0 in view of the corresponding LUN sequence 315, which may cause a conflict. After writing to LUN 0, the first cursor moves to LUN 1, then LUN 2, then LUN 3, and so on. After writing to LUN 0, the second cursor moves to LUN 3, LUN 6, LUN 9, and so on, which does not overlap with the corresponding LUN for the first cursor and reduces the probability of conflict.
[0034] In some embodiments, the LUN sequence 315 may share properties with a finite cyclic group. A finite cyclic group may be a finite group of objects generated from a single element. A finite cyclic group contains a set of objects, such as a sequence of LUN sets, that can be derived from a single reversible associative operation. A finite cyclic group may use a generator (g) such that each object in the group may be obtained by repeatedly applying the group operation or its inverse to the generator.
[0035] In an embodiment, the LUNs (e.g., LUN 0-LUN 15) in the LUN set 220 of the memory subsystem 210 may be numbered 0 to N, where N is the number of LUNs in the LUN set 220 (e.g., N=16 LUNs). If the LUNs are represented by integers (e.g., integers 0-15) and are considered to be a finite cyclic group of integers (e.g., {0, 1, 2, 3, 4, 5, 6, ... 15} or a set of integers modulo N), then a generator of the group is any member "g" of the group, where all members of the group can be expressed as a multiple of "g" (i.e., for some integer n, all members of the group can be expressed as m=n*g). Any integer whose greatest common divisor (gcd) with N is 1 (e.g., gcd(a, N)=1, where "a" is an integer in the group)) may be considered a generator. In addition, in some embodiments where multiple generators are selected to generate sequences that do not have similar subsequences, each pair of generators may also have a gcd of 1 (i.e., the only gcd between two generators is 1). An example of a similar subsequence can be expressed using the generators 3 and 9 in the Z / {16} set. Both 3 and 9 are relatively prime to 16. The sequence for 3 conflicts with or is identical to the sequence for 9 every third number, which may cause undesirable conflicts. The sequence for 3 is {0,3,6,9,12,15,2,5,8,11,14,1,4,7,10,13}, and the sequence for 9 is {0,9,2,11,4,13,6,15,8,1,10,3,12,5,14,7}.
[0036] For example, Figure 3 Generators 310 (e.g., 1, 3, 5, 7, 15, 13, 11, 9) and LUN sequences 315 associated with each of the generators 310 are shown. LUN sequence 315A is an ordered sequence of LUNs 0 to 15. Generator 1 is always a generator because the gcd of 1 and N (N=16) is always 1. The integer "2" is not a generator because N (e.g., N=16) has a common divisor of 2, so the gcd of 2 and 16 is not 1. The integer 3 is a generator because the gcd of 3 and N (N=16) is always 1. It can be noted that the generator and N can be considered to be relatively prime because the only common divisor between the generator and N is 1. It can also be noted that, as illustrated, negative integers can be used as generators. It can be noted that Figure 3 The "Z" in is the set of all integers.
[0037] In some implementations, the LUN sequence 315 may be determined using the corresponding generators 310. For example, the LUN sequence 315B may be determined using an integer modulo set N, where N is the number of LUNs (e.g., N=16) and the integer set is an ordered sequence of LUNs 0-15 multiplied by the generator. For example, the integer set may be {0g, 1g, 2g, 3g, 4g, 5g, 6g, 7g, 8g, 9g, 10g, 11g, 12g, 13g, 14g, 15g}. For example, 0g for g=3 is 0, and 0 modulo 16 is 0 (e.g., the remainder of 0 / 16 is 0), where 0 is the first number in the LUN sequence 315A. In another example, 6g for g=3 is 18, and 18 modulo 16 is 2 (e.g., the remainder of 18 / 16 is 2). Each number in the LUN sequence 315B may be determined in a manner similar to that described above. It may be noted that the above operations (eg, algorithms) for generating the LUN sequence 315 are provided for illustrative purposes rather than limiting purposes, and one or more operations may be used to generate the LUN sequence 315 using the generator 310, such as with respect to Figure 5 Further description.
[0038] Figure 4 Channel sequencing 400 is illustrated according to an embodiment of the present disclosure. Figure 1 Computing environment 100, Figure 2 Computing environment 200 and Figure 3 The elements of LUN Sequencing 300 may be used to help illustrate Figure 4 The channel sequencing 400 illustrates a plurality of unique LUN sequences 315 and associated channel sequences 420 .
[0039] As described above, the controller 115 communicates with the LUN set 220 (e.g., LUN 0-LUN 15) via channels 230. Each channel 230 may be coupled to one or more LUNs. In an embodiment, a cursor that performs a memory operation on a sequence of LUNs (e.g., one of the LUN sequence 315) may access a specific channel to perform a memory operation on a specific LUN in the LUN sequence 315.
[0040] For example, to perform write operations in the order indicated by LUN sequence 315A (e.g., {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15}), the cursor may access the channels (e.g., as shown in FIG. 1 ) in the order indicated by channel sequence 420A (e.g., {0,1,2,3,4,5,6,7}+{0,1,2,3,4,5,6,7}). Figure 2 ). For example, to access LUN 0, the cursor may use channel 0, to access LUN 1, the cursor may use channel 1, to access LUN 2, the cursor may use channel 2, and so on.
[0041] In an embodiment, the channel sequence 420 may be determined for a given LUN sequence 315 so that the cursor can access each channel once before repeating (e.g., accessing the channel again). Given a set of channels (M), the generator of a finite cyclic group of channels may be any number whose gcd with M is 1. Positive prime numbers less than M selected for the LUN sequence 315 may also be prime generators for the channel sequence 420. If the number of LUNs (e.g., N=16) is an even multiple of the number of channels (e.g., M=8) and the number of channels is a power of 2, then all odd numbers will be generators for the channel sequence 420. In some embodiments, the number of LUNs may be increased with "virtual" LUNs so that the number of LUNs is an even number of the number of channels. Virtual LUNs may be placeholders and may instruct the cursor to skip virtual LUNs when performing memory operations. Negative prime numbers selected as generators for the LUN sequence 315 may also be generators for the channel sequence 420.
[0042] In an embodiment, channel sequence 420 may be determined in a manner similar to determining LUN sequence 315. Channel sequence 420 may be determined by a set of integers modulo M, where M is the number of channels (e.g., M=8) and the set of integers is LUN sequence 315. For example, for g=3, LUN sequence 315A is {0, 3, 6, 9, 12, 15, 2, 5, 8, 11, 14, 1, 4, 7, 10, 13}. For LUN 0 in LUN sequence 315B, 0 modulo 8 is (e.g., the remainder of 0 / 8 is 0), where 0 is the first number in channel sequence 420B. For LUN 9 in LUN sequence 315B, 9 modulo 8 is 1 (e.g., the remainder of 9 / 8 is 1), where 1 is the fourth number in channel sequence 420B. The entire channel sequence 420B includes {0,3,6,1,4,7,2,5}+{0,3,6,1,4,7,2,5}, which includes a channel sequence in which all channels can be used once to access the LUNs in the order provided by LUN sequence 315B before repeating.
[0043] Figure 5 is a flow chart of an example method of performing operations on a storage component using a LUN sequence according to some embodiments. Method 500 may be performed by processing logic that may include hardware (e.g., a processing device, a circuit system, dedicated logic, programmable logic, microcode, hardware of a device, an integrated circuit, etc.), software (e.g., instructions running or executed on a processing device), or a combination thereof. In some embodiments, method 500 may be performed by Figure 1 or Figure 2It may be noted that in other embodiments, method 500 may include the same, different, additional, or fewer operations performed in the same or different order. The elements of the foregoing figures may be used to help illustrate Figure 5 .
[0044] At block 505, processing logic identifies a generator 310 to generate a LUN sequence 315 for a logical unit number (LUN) set 220 associated with a memory component 112. In some embodiments, each of the LUN sequences 315 is a unique sequence. In some embodiments, the memory component 112 is a non-volatile memory component. In some embodiments, the generator is a unique integer ranging from 1 to the number of LUNs in the LUN set 220 (e.g., N-1 or 0 to 15). In some embodiments, the generator 310 may be determined at manufacturing time and stored in a memory accessible by the controller 115. In other embodiments, the generator may be stored using a memory device such as the one described above. Figure 3 The operations described determine the generators.
[0045] At block 510, processing logic assigns each of the cursors a corresponding generator in the generators 310. The cursors are used to perform operations on the memory components 112. In some embodiments, the cursors are multiple host cursors that perform memory operations on behalf of the host system 120. In some embodiments, the operations are memory operations, such as write operations that write data from the host system 120 to the memory components 112. In some embodiments, the write operations stripe the data across the memory components 112.
[0046] At block 515, processing logic identifies a sequence for each of the cursors in a plurality of LUN sequences 315 based on the corresponding generator (g) assigned to the cursor. In an embodiment, each sequence in the LUN sequences 315 references a single instance of each LUN (e.g., LUNs 0-15) in the LUN set 220. In an embodiment, each sequence in the LUN sequences 315 is a unique LUN sequence in which the order of the LUNs is different from each other sequence in the LUN sequences 315.
[0047] In some implementations, processing logic may store the LUN sequence 315 in a memory accessible by the controller 115 and access the LUN sequence 315 using the generator as an identifier to identify the LUN sequence 315 .
[0048] In other embodiments, the generators are available to the cursor to generate the LUN sequence 315. In an embodiment, processing logic implements an operation (e.g., a LUN sequencing algorithm) that generates the corresponding LUN sequence in the LUN sequence 315 using the corresponding generator 310 assigned to the cursor as a variable. In some embodiments, the operation that uses the corresponding generator as a variable to generate a unique LUN sequence divides each of a set of multiples of the corresponding generator (e.g., multiples of the generator (g) using a multiplier in the range from 0 to N-1, where N is the number of LUNs) by the number of LUNs in the LUN set 220 (i.e., N) to generate a remainder (e.g., a first value). The remainder identifies a LUN in the LUN sequence.
[0049] For example, for the LUN sequence 315A, the generator (g) is 1. Multiples of 1 are 0, 1, 2, 3, 4, 5, ... 15. Each of the multiples can be divided by the number of LUNs of the LUN set 220 (e.g., N=16) (e.g., 1 / 16, 2 / 16, 3 / 16, ..., 15 / 16). The remainder of the division is the LUN sequence 315A (e.g., {0, 1, 2, 3, 4, ..., 15}). In another example, for the LUN sequence 315B, the generator (g) is 3. Multiples of 3 are 0, 3, 6, 9, ..., 45. Each of the multiples can be divided by the number of LUNs of the LUN set 220 (e.g., N=16) (e.g., 0 / 16. 3 / 16. 19 / 16, ..., 45 / 16). The remainder of the division is the LUN sequence 315B (eg, {0, 3, 6, 9, ..., 13}).
[0050] At block 520, processing logic determines a channel sequence 420 for each of the LUN sequences 315. The channels 230 couple a processing device (e.g., controller 115) to the LUN sets 220 of the memory component 112. In some implementations, the cursor performs operations on the LUN sets 220 in the order provided by the LUN sequences 315 by accessing the LUN sets 220 in the order provided by the corresponding channel sequences 420.
[0051] In some implementations, a mapping of LUNs (eg, LUNs 0-15) to the corresponding channels 230 may be stored in a memory (eg, a lookup table) accessible to the controller 115. The controller may use the mapping to identify the corresponding channels to perform operations on the corresponding LUNs.
[0052] In other embodiments, the cursor may generate the channel sequence 420 by implementing an operation (e.g., a channel sequencing algorithm). In an embodiment, to generate the channel sequence, the processing logic may divide each number in the LUN sequence 315 by the number of channels (e.g., M=8) to generate a remainder (e.g., a second value). The remainder identifies a channel in the channel sequence. For example, the LUN sequence 315B for the generator (g=3) is {0, 3, 6, 9, 12, 15, 2, 5, 8, 11, 14, 1, 4, 7, 10, 13}. If the number of channels is 8 (e.g., M=8), then each number in the LUN sequence 315B is divided by 8, and the remainder is a channel in the channel sequence 420B. Figure 4 Additional examples of operations to generate channel sequence 420 are described.
[0053] At block 525, processing logic performs operations on storage components 112 using LUN sequences 315. In an embodiment, performing operations on storage components 112 in the order provided by LUN sequences 315 reduces the probability of cursors conflicting when performing operations (e.g., compared to cursors using the same LUN sequence). In an embodiment, each of the cursors performs operations on LUN sets 220 in the order provided by the LUN sequence 315 associated with each of the cursors.
[0054] Figure 6 An example machine illustrating a computer system 600 may be executed within which a set of instructions for causing the machine to perform any one or more of the methodologies discussed herein may be executed. In some embodiments, the computer system 600 may correspond to a computer that includes or uses a memory subsystem (e.g., Figure 1 The memory subsystem 110 or Figure 2 The memory subsystem 210 of the controller may be used to execute the operation of the controller (for example, to execute the operating system to correspond to Figure 1 or Figure 2 The LUN sequencing component 113 performs operations) of the host system (for example, Figure 1 or Figure 2 In some embodiments, the machine may be connected (e.g., using a network) to other machines in a LAN, an intranet, an extranet, and / or the Internet. The machine may operate in the capacity of a server or a client machine in a client-server network environment, or in the capacity of a peer machine in a peer-to-peer (or distributed) network environment, or as a server or a client machine in a cloud computing infrastructure or environment.
[0055] The machine may be a personal computer (PC), a tablet PC, a set-top box (STB), a personal digital assistant (PDA), a cellular phone, a network appliance, a server, a network router, a switch or a bridge, or any machine capable of executing (sequentially or otherwise) a set of instructions that specify actions to be taken by the machine. In addition, while a single machine is described, the term "machine" should also be construed to include any collection of machines that individually or collectively execute one (or more) sets of instructions to perform any one or more of the methodologies discussed herein.
[0056] The example computer system 600 includes a processing device 602, a main memory 604 (e.g., read-only memory (ROM), flash memory, dynamic random access memory (DRAM) such as synchronous DRAM (SDRAM) or Rambus DRAM (RDRAM)), etc.), a static memory 606 (e.g., flash memory, static random access memory (SRAM), etc.), and a data storage system 618, which communicate with each other via a bus 630.
[0057] Processing device 602 represents one or more general processing devices, such as a microprocessor, a central processing unit, etc. More specifically, the processing device can be a complex instruction set computing (CISC) microprocessor, a reduced instruction set computing (RISC) microprocessor, a very long instruction word (VLIW) microprocessor, or a processor that implements other instruction sets, or a processor that implements a combination of instruction sets. Processing device 602 can also be one or more special processing devices, such as an application specific integrated circuit (ASIC), a field programmable gate array (FPGA), a digital signal processor (DSP), a network processor, or the like. Processing device 602 is configured to execute instructions 626 for performing the operations and steps discussed herein. Computer system 600 may additionally include a network interface device 608 to communicate on a network 620.
[0058] The data storage system 618 may include a machine-readable storage medium 624 (also referred to as a computer-readable medium) on which is stored one or more sets of instructions 626 or software embodying any one or more of the methods or functions described herein. The instructions 626 may also reside, completely or at least partially, within the main memory 604 and / or within the processing device 602 during execution by the computer system 600, the main memory 604 and the processing device 602 also constituting machine-readable storage media. The machine-readable storage medium 624, the data storage system 618, and / or the main memory 604 may correspond to Figure 1 The memory subsystem 110 or Figure 2 Memory subsystem 210.
[0059] In one embodiment, instructions 626 include implementing functionality corresponding to LUN sequencing (e.g., Figure 1 or Figure 2 The machine-readable storage medium 624 is shown as a single medium in the example implementation as a single medium, but the term "machine-readable storage medium" should be considered to include a single medium or multiple media storing one or more sets of instructions. The term "machine-readable storage medium" should also be considered to include any medium capable of storing or encoding a set of instructions for execution by a machine and causing the machine to perform any one or more of the methods of the present disclosure. The term "machine-readable storage medium" should therefore be considered to include, but not be limited to, solid-state memory, optical media, and magnetic media.
[0060] Some portions of the previous detailed description have been presented in terms of algorithms and symbolic representations of operations on data bits within a computer memory. These algorithmic descriptions and representations are the means by which those skilled in the art of data processing can most effectively convey the substance of their work to other skilled in the art. In this article, and generally, an algorithm is conceived as a self-consistent sequence of operations that generate a desired result. An operation is an operation that requires physical manipulation of physical quantities. Typically (but not necessarily), these quantities take the form of electrical or magnetic signals that can be stored, combined, compared, and otherwise manipulated. It has been demonstrated that it is sometimes convenient to refer to these signals as bits, values, elements, symbols, characters, terms, numbers, etc., primarily for common reasons.
[0061] It should be borne in mind, however, that all of these and similar terms will be associated with the appropriate physical quantities and are merely convenient labels applied to these quantities. The present disclosure may refer to the actions and processes of a computer system or similar electronic computing device that manipulates and transforms data represented as physical (electronic) quantities within the computer system's registers and memories into other data similarly represented as physical quantities within the computer system's memories or registers or other such information storage systems.
[0062] The present disclosure also relates to an apparatus for performing the operations described herein. This apparatus may be specially constructed for the desired purpose, or it may comprise a general purpose computer selectively activated or reconfigured by a computer program stored in the computer. Such a computer program may be stored in a computer readable storage medium, such as, but not limited to, any type of disk, including a floppy disk, an optical disk, a CD-ROM, and a magnetic optical disk, a read-only memory (ROM), a random access memory (RAM), an EPROM, an EEPROM, a magnetic card or an optical card, or any type of medium suitable for storing electronic instructions, each of which is connected to a computer system bus.
[0063] The algorithms and displays presented herein are not inherently related to any particular computer or other device. Various general purpose systems may be used in conjunction with the programs according to the teachings herein, or it may prove convenient to construct a more specialized device to perform the method. The structures of various such systems will be presented as set forth in the description below. In addition, the present disclosure is not described with reference to any particular programming language. It should be appreciated that the teachings of the present disclosure as described herein may be implemented using various programming languages.
[0064] The present disclosure may be provided as a computer program product or software, which may include a machine-readable medium having stored thereon instructions that can be used to program a computer system (or other electronic device) to perform a process according to the present disclosure. A machine-readable medium includes any mechanism for storing information in a form readable by a machine (e.g., a computer). In some embodiments, a machine-readable (e.g., a computer-readable) medium includes a machine (e.g., a computer) readable storage medium, such as a read-only memory ("ROM"), a random access memory ("RAM"), a magnetic disk storage medium, an optical storage medium, a flash memory device, etc.
[0065] In the foregoing description, embodiments of the present disclosure have been described with reference to specific example embodiments thereof. It will be apparent that various modifications may be made thereto without departing from the broader spirit and scope of embodiments of the present disclosure as set forth in the appended claims. Accordingly, the specification and drawings should be viewed in an illustrative rather than a restrictive sense.
[0066] As used herein, the words "example" or "exemplary" refer to use as examples, examples or illustrations. Any aspect or design described herein as "example" or "exemplary" is not necessarily to be interpreted as superior or superior to other aspects or designs. In fact, the use of the words "example" or "exemplary" is intended to present concepts in a specific way. As used in this application, the term "or" is intended to mean an inclusive "or" rather than an exclusive "or". That is, unless otherwise specified or obvious from the context, "X includes A or B" is intended to represent any natural inclusive arrangement. That is, if X includes A; X includes B; or X includes A and B, then "X includes A or B" is satisfied under any of the aforementioned examples. In addition, the article "a / an" as used in this application and the appended claims can generally be interpreted as meaning "one or more", unless otherwise specified or clearly visible from the context to represent a singular form. In addition, the use of the terms "embodiment" or "one embodiment" or "example" or "one example" throughout the text is not intended to represent the same embodiment or example, unless described as such. The terms “first,” “second,” “third,” “fourth,” etc. as used herein are intended as labels to distinguish different elements and may not necessarily have ordinal meanings according to their numerical names.
Claims
1. A memory system, wherein include: multiple memory components; and A processing device, coupled to the plurality of memory components, the processing device performing the following operations: identifying a generator for generating a plurality of LUN sequences for a set of logical unit numbers (LUNs) associated with the plurality of storage components; assigning a corresponding one of the generators to each of a plurality of cursors, wherein the cursors are used to perform memory operations on the plurality of memory components; identifying a sequence in the plurality of LUN sequences for each of the cursors based on the corresponding generator assigned to the cursor; and The memory operations are performed on the plurality of memory components using the plurality of LUN sequences, wherein each of the cursors performs the memory operations on the set of LUNs in an order provided by the LUN sequences associated with each of the cursors. 2 . The memory system of claim 1 , wherein each of the LUN sequences is a unique LUN sequence.
3. The memory system of claim 1 , wherein to identify the sequence for each of the cursors in the plurality of LUN sequences based on the corresponding generator assigned to the cursor, the processing device further performs the following operations: An operation of generating the LUN sequence using the corresponding generator as a variable is performed.
4. The memory system according to claim 3, wherein in order to implement the operation of using the corresponding generator as the variable to generate the LUN sequence, the processing device further performs the following operation: The operation is performed on each of the plurality of multiples of the corresponding generator using the number of LUNs in the LUN set to generate a first value, wherein the first value identifies a LUN in the sequence of LUNs.
5. The memory system according to claim 1, wherein the processing device further performs the following operations: A channel sequence is determined for each of the plurality of LUN sequences, wherein the channels couple the processing device to the set of LUNs of the plurality of memory components, wherein the cursor performs the memory operations on the set of LUNs in an order provided by the corresponding channel sequence by accessing the set of LUNs in an order provided by the LUN sequence.
6. The memory system according to claim 5, wherein in order to determine the channel sequence for each of the plurality of LUN sequences, for each of the plurality of LUN sequences, the processing device further performs the following operations: An operation is performed on each number in the sequence of LUNs using the number of channels used to generate a second value, wherein the second value identifies a channel in the sequence of channels.
7. The memory system of claim 1, wherein the memory operation is a write operation of writing data from a host system to the plurality of memory components.
8. The memory system of claim 7, wherein the write operation stripes the data across the plurality of memory components.
9. The memory system of claim 1, wherein the plurality of cursors comprises a plurality of host cursors that perform write operations on behalf of a host system.
10. The memory system of claim 1, wherein each of the generators is a unique integer in a range from one to the number of LUNs in the LUN set.
11. The memory system of claim 1, wherein each of the plurality of LUN sequences references a single instance of each LUN in the LUN set.
12. The memory system of claim 1, wherein performing the memory operations on the plurality of memory components in an order provided by the plurality of LUN sequences reduces a probability that the cursors will conflict when performing the memory operations.
13. The memory system of claim 1, wherein the plurality of memory components comprises non-volatile memory devices.
14. A method for sequencing logical unit numbers (LUNs), wherein include: identifying a generator for generating a plurality of LUN sequences for a set of LUNs associated with a plurality of storage components; assigning a corresponding one of the generators to each of a plurality of cursors, wherein the cursors are used to perform memory operations on the plurality of memory components; identifying a sequence in the plurality of LUN sequences for each of the cursors based on the corresponding generator assigned to the cursor; and The memory operations are performed, by a processing device, on the plurality of memory components using the plurality of LUN sequences, wherein each of the cursors performs the memory operations on the set of LUNs in an order provided by the LUN sequences associated with each of the cursors.
15. The method of claim 14, wherein to identify the sequence for each of the cursors in the plurality of LUN sequences based on the corresponding generator assigned to the cursor, the method further include: An operation of generating the LUN sequence using the corresponding generator as a variable is performed.
16. The method according to claim 15, wherein in order to implement the operation of using the corresponding generator as the variable to generate the LUN sequence, the method further include: The operation is performed on each of the plurality of multiples of the corresponding generator using the number of LUNs in the LUN set to generate a first value, wherein the first value identifies a LUN in the sequence of LUNs.
17. The method according to claim 14, further comprising: include: A channel sequence is determined for each of the plurality of LUN sequences, wherein the channels couple the processing device to the set of LUNs of the plurality of memory components, wherein the cursor performs the memory operations on the set of LUNs in an order provided by the corresponding channel sequence by accessing the set of LUNs in an order provided by the LUN sequence.
18. A non-transitory computer-readable medium comprising instructions that, in response to execution by a processing device, cause the processing device to perform operations comprising: identifying a generator for generating a plurality of LUN sequences for a set of logical unit numbers (LUNs) associated with a plurality of storage components; assigning a corresponding one of the generators to each of a plurality of cursors, wherein the cursors are used to perform memory operations on the plurality of memory components; identifying a sequence in the plurality of LUN sequences for each of the cursors based on the corresponding generator assigned to the cursor; and The memory operations are performed, by the processing device, on the plurality of memory components using the plurality of LUN sequences, wherein each of the cursors performs the memory operations on the set of LUNs in an order provided by the LUN sequences associated with each of the cursors.
19. The non-transitory computer-readable medium of claim 18, wherein to identify the sequence for each of the cursors in the plurality of LUN sequences based on the corresponding generator assigned to the cursor, the operation further include: An operation of generating the LUN sequence using the corresponding generator as a variable is performed.
20. The non-transitory computer-readable medium of claim 19, wherein in order to implement the operation of using the corresponding generator as the variable to generate the LUN sequence, the operation further include: The operation is performed on each of the plurality of multiples of the corresponding generator using the number of LUNs in the LUN set to generate a first value, wherein the first value identifies a LUN in the sequence of LUNs.
21. The non-transitory computer readable medium of claim 18, wherein the operation further include: A channel sequence is determined for each of the plurality of LUN sequences, wherein the channels couple the processing device to the set of LUNs of the plurality of memory components, wherein the cursor performs the memory operations on the set of LUNs in an order provided by the corresponding channel sequence by accessing the set of LUNs in an order provided by the LUN sequence.
22. A memory system, wherein include: multiple memory components; and A processing device, coupled to the plurality of memory components, the processing device performing the following operations: Assigning a corresponding generator from a plurality of generators to each of a plurality of cursors, wherein the cursors are used to perform storage operations on a set of logical unit numbers (LUNs) associated with the plurality of storage components; identifying a plurality of LUN sequences based on the plurality of generators, wherein each of the cursors is associated with one of the plurality of the LUN sequences; and The memory operations are performed on the LUN sets associated with the plurality of memory components using the plurality of LUN sequences, wherein performing the memory operations on the LUN sets in an order provided by the plurality of LUN sequences reduces a probability of a conflict between the cursors when performing the memory operations.
23. The memory system of claim 22, wherein each of the LUN sequences is a unique LUN sequence.
24. The memory system of claim 22, wherein to identify the sequence for each of the cursors in the plurality of LUN sequences based on the corresponding generator assigned to the cursor, the processing device further performs the following operations: An operation of generating the LUN sequence using the corresponding generator as a variable is performed.
25. The memory system according to claim 24, wherein in order to implement the operation of using the corresponding generator as the variable to generate the LUN sequence, the processing device further performs the following operation: The operation is performed on each of the plurality of multiples of the corresponding generator using the number of LUNs in the LUN set to generate a first value, wherein the first value identifies a LUN in the sequence of LUNs.
