Associating data types with stream identifiers to map to sequential write memory devices

Abstract

The present application relates to associating a data type with a stream identifier to map to a sequentially written memory device. A processing device is coupled to a plurality of IC die, and the processing device performs operations including: assigning a first stream identifier ID to a data type generated by the execution of an application within an operating system; associating a first file generated by the application with the first stream ID, wherein the first file is associated with the data type; allocating a first memory unit group of the plurality of IC die to the first file, wherein the first memory unit group is assigned the first stream ID; and causing the first file to be sequentially written to the first memory unit group of the plurality of IC die based on the first stream ID.

Description

Technical Field

[0001] Embodiments of the present disclosure relate generally to memory subsystems, and more particularly, to associating data types with stream identifiers for mapping onto sequentially written memory devices. Background Art

[0002] The memory subsystem may include one or more memory devices that store data. The memory devices may be, for example, non-volatile memory devices and volatile memory devices. In general, the host system may utilize the memory subsystem to store data at the memory devices and retrieve data from the memory devices. Summary of the invention

[0003] In one aspect, the present application provides a system comprising: a plurality of integrated circuit (IC) dies having memory cells; and a processing device coupled to the plurality of IC dies, the processing device performing operations comprising: assigning a first stream identifier (ID) to a first data type generated by execution of an application within an operating system; associating a first file generated by the application with the first stream ID, wherein the first file is associated with the first data type; allocating a first memory cell group of the plurality of IC dies to the first file, wherein the first stream ID is assigned to the first memory cell group; and sequentially writing the first file to the first memory cell group of the plurality of IC dies based on the first stream ID.

[0004] In another aspect, the present application further provides a system, comprising: a method, comprising: retrieving, by a processing device executing a file system of an operating system, a block group to be written to a plurality of integrated circuit (IC) dies, the block group being a contiguous portion of a file; accessing, by the processing device, block group metadata associated with the block group to determine, by the processing device, a stream identifier (ID) associated with the file assigned to the block group based on a data type; determining, by the processing device, whether there is available space in a memory cell group of the plurality of ICs assigned to the stream ID, the block group being allocated to the memory cell group; and in response to determining that there is available allocatable space in the memory cell group: accessing, by the processing device, a write pointer associated with the memory cell group in the block group metadata of the block group; and allocating, by the processing device, a contiguous range of physical addresses within the memory cell group for sequentially writing the block group beyond the write pointer.

[0005] In yet another aspect, the present application further provides a non-transitory computer-readable medium storing instructions that, when executed by a processing device, cause the processing device to perform operations including: assigning a first stream identifier (ID) to a data type generated due to execution of an operating system; associating a first file of system data generated by the operating system with the first stream ID, wherein the first file is associated with the data type; allocating a first memory cell group of a plurality of IC dies to the first file, wherein the first memory cell group is assigned the first stream ID; and causing the first file to be sequentially written to the first memory cell group of the plurality of IC dies based on the first stream ID. BRIEF DESCRIPTION OF THE DRAWINGS

[0006] The present disclosure will be more fully understood from the detailed description given below and from the accompanying drawings of various embodiments of the present disclosure.

[0007] Figure 1A An example computing system including a host and a memory subsystem according to an embodiment is described.

[0008] Figure 1B According to some embodiments Figure 1A Detailed block diagram of the computing system.

[0009] Figure 2 Schematic diagram of a computing system illustrating a host file system including stream identifiers (IDs) and data types and association of stream IDs with specific regions (or groups of memory cells) according to various embodiments.

[0010] Figure 3 Flowchart of a method for allocating groups of blocks that are contiguous portions of a file to groups (or zones) of memory cells according to some embodiments.

[0011] Figure 4 Flow diagram of a method for assigning stream IDs to application data types such that files of the data types are associated with stream IDs assigned to groups of memory cells in a sequentially written memory device according to an embodiment.

[0012] Figure 5 Flowchart of a method for assigning stream IDs to operating system data such that the system data is associated with stream IDs assigned to groups of memory cells in a sequentially written memory device according to an embodiment.

[0013] Figure 6 is a block diagram of an example computer system in which embodiments of the present disclosure may operate. DETAILED DESCRIPTION

[0014] Various aspects of the present disclosure are directed to associating data types with stream identifiers to map to sequentially written memory devices. The memory subsystem may be a storage device, a memory module, or a mixture of a storage device and a memory module. Figure 1A Examples of storage devices and memory modules are described. In general, a host system may utilize a memory subsystem that includes one or more components, such as a memory device, that stores data. The host system may provide data to be stored at the memory subsystem and may request data to be retrieved from the memory subsystem.

[0015] The memory subsystem may include multiple components, such as a memory device that can store data from a host system in a storage medium, such as an integrated circuit (IC) die having addressable memory cells that store data individually. Processing in some of today's memory subsystems is often performed by random allocations to the IC die and in small increments of data, such as four kilobytes (KB). These random allocations of pages or blocks of data include non-sequential and / or random writes to the IC die. This practice results in a high cost for memory (e.g., dynamic random access memory (DRAM), static random access memory (SRAM), or persistent memory) to store mapping data structures that track logical to physical (LTP) address mappings between the logical block address (LBA) space and the physical address space of the IC die. For example, the mapping overhead is approximately a gigabyte (GB) per terabyte (TB) of host addressable media, and therefore, a 16TB solid-state drive (SSD) requires a considerable 16GB of memory mapping overhead. In addition, periodic snapshots and logging are performed to maintain the mapping data structure throughout shutdown and unexpected power failure scenarios. This adds extra write overhead to the IC die and performance loss.

[0016] A storage stack is in the process of being modified to exploit the efficiency of sequential input-output (IO) memory devices. For example, a storage stack is included in a file system group data by location (e.g., by thread, process, or application) and writes data sequentially to a storage device. The file system may then write the differently located data to the storage device as parallel sequential streams, each stream having its own location. References to location may refer to time location or spatial location. Data with time location is data that the processor tends to access repeatedly at the same memory location within a short period of time, such as data that is written, overwritten, and fine-tuned at about the same time. Data with spatial location captures the tendency when a memory device references a particular memory location at a particular time, then the memory device is likely to reference a nearby memory location in the near future. In this case, the processor may attempt to determine the size and shape of the area around the current reference, where it is important to prepare the current reference for faster access for subsequent references. References to sequential location are special cases of spatial location that occur when data elements are arranged and accessed linearly (e.g., when traversing elements in a one-dimensional array).

[0017] When writing data with positioning sequentially, for simplicity, the data is written to a group of memory cells (also called a zone), where each zone can store multiple physical data blocks. Therefore, the mapping can be recorded at a higher granularity (megabytes instead of kilobytes) to map a specific data group to a zone in the LBA space, which significantly reduces the metadata recorded. The mapping space associated with the LBA space at this granularity can be called a zone name space (ZNS), and the memory device written in this way is called a ZNS memory device. In one example, the data group consists of multiple data blocks with positioning, where each data block corresponds to a physical block (e.g., an erase unit) of an IC die. In one embodiment, the size of the physical block (or erase unit) of the memory device is about 16 megabytes (MB). The memory cell group (or zone) can be at least two to four times (or more) the size of the physical block. Therefore, the zone can store at least 64MB of data (e.g., 64MB, 128MB, 256MB, 512MB or more), each of which is significantly larger than four kilobytes (KB).

[0018] In some host operating systems, the file system handles the management of files from the operating system, files from applications running on the operating system, and metadata generated by the file system, with the goal of organizing the files and allocating the space in the IC die necessary to write the files and metadata as they are generated. The file systems of some host operating systems (e.g., Linux, Unix, and the like) assign block groups (e.g., contiguous portions of a file, such as a series of LBAs) to a series of physical addresses of the IC die at which the block groups are stored. Files may be, for example, data files, metadata containing inodes, directory structures, free space managers, and the like, and other data structures (or objects) that can encapsulate data / metadata and be written to the IC die, which will be discussed in more detail. These file systems typically assign certain types of block groups to specific series of physical addresses of the IC die based on whether the block groups contain data or metadata, and attempt not to intermix data and metadata within these specific series of physical addresses.

[0019] In these host operating systems, the file system is not adapted to allocate files or block groups to zones or to sequentially write block groups, as is done within zones of a ZNS managed memory device. To date, sequential writes to ZNS managed memory devices have been managed at the memory device level by a memory subsystem controller (e.g., which acts as an intermediary between the host's file system and the storage device). Management within the memory subsystem controller adds a level of complexity, including LTP address mapping, recording metadata, and corresponding resource requirements for handling non-sequential IO writes, even though the majority of IO writes are sequential write operations.

[0020] At least some aspects of the present disclosure address the above and other deficiencies by configuring a host system (e.g., a file system of a host operating system) with the ability to assign stream IDs to specific data types and to specific metadata types and using the stream IDs to assign each region (e.g., a group of memory cells) to one of these specific data types or metadata types. In this manner, the file system uses data streams and their corresponding stream IDs for file / data structure management and storage allocation within the IC die of a ZNS-managed memory device.

[0021] In addition, the copy-on-write (COW) management of storage devices is generally best suited for sequential writes because once the data is written, it is not overwritten. More specifically, COW is a resource management technique in computer programming to efficiently implement a copy or copy operation on a modifiable resource in memory. If a resource is copied but not modified, a new resource does not have to be created; the resource can be shared between the copy and the original. In the case where the file system writes sequentially to the storage device, it is more efficient to use COW management to perform this operation. For example, similar types of data can be written as a group, and therefore can eventually be rewritten elsewhere as a group before becoming invalid and undergoing garbage collection (including erasure). Writing files of the same data type as the group can therefore minimize garbage collection and reduce write amplification. In addition, in some embodiments, the kernel of the host operating system includes device mapping logic, which can directly cause files to be written to the physical addresses of individual zones, and thus map logical addresses to the physical addresses of sequential write zones, thereby bypassing the need for the memory subsystem controller to handle this mapping.

[0022] Thus, in one embodiment, for example, a file system may assign a first stream identifier (ID) to a first data type generated by execution of an application within an operating system. Due to the association of the first file with the first data type, the file system may further associate the first file generated by the application with a first stream ID. In some embodiments, this is done via adding the stream ID to the file name or a metadata structure provided within the file (e.g., a data structure file). The file system may further allocate a first area (e.g., a group of memory cells) of the IC die to the first file associated with the first stream ID. The file system may then cause the first file (identified from among thousands of files) to be sequentially written to the first group of memory cells of the IC die based on the first stream ID. If, for example, a second file of another application with a different data type associated with a second stream ID is detected, the file system may cause the second file to be sequentially written to a second area to which the second stream ID has been assigned.

[0023] In another embodiment, the file system may assign a third stream ID to a third data type generated due to the execution of the operating system. The file system may associate a third file of system data generated by the operating system with the third stream ID, wherein the third file is associated with the third data type. The system data may be, for example, a system superblock of data or system metadata generated by the operating system. The file system may further assign a third zone (e.g., a group of memory cells) of the IC die to the third file associated with the third stream ID. The file system may then cause the third file to be sequentially written to the third zone of the IC die based on the third stream ID. Each of the first zone, the second zone, and the third zone may be at a different location in the ZNS memory device, but may still be sequentially written to each of them individually. Once a zone (e.g., the first zone) becomes fully written, the file system may allocate a new zone (e.g., a fourth zone), and files of a particular data type (e.g., the first data type) may continue to be sequentially written to the new zone. In doing so, the file system may assign the file (or block group of the file) to the fourth stream ID that was assigned to the fourth zone, so the first file is now assigned to the fourth zone.

[0024] Advantages of the present disclosure include, but are not limited to, significantly minimized garbage collection (limited to metadata) and reduced write amplification due to writing similar data type files in groups sequentially by zone. Additionally, load balancing of writes across multiple zones for different data types (e.g., by stream ID) enables predictable write performance, where writes are often a bottleneck in current file systems. Because organizing data type files into streams and directing those streams to be written at identified zones is done at the host's file system (including ZNS device mapping capabilities by the host operating system's kernel), advantages also include significant mapping overhead reduction and reduction in periodic snapshots and records that would otherwise be done to maintain mapping data structures in the event of power failures / shutdowns. Other advantages will be apparent to those skilled in the art of memory allocation and mapping to memory devices discussed below.

[0025] Figure 1A An example computing environment 100 including a memory subsystem 110 according to some embodiments of the present disclosure is illustrated. The memory subsystem 110 may include media such as one or more volatile memory devices (e.g., memory device 140), one or more non-volatile memory devices (e.g., memory device 130), or a combination of these. Each memory device 130 or 140 may be one or more memory components.

[0026] The memory subsystem 110 may be a storage device, a memory module, or a mixture of a storage device and a memory module. Examples of storage devices include solid-state drives (SSDs), flash drives, universal serial bus (USB) flash drives, embedded multimedia controller (eMMC) drives, universal flash memory (UFS) drives, secure digital (SD) cards, and hard disk drives (HDDs). Examples of memory modules include dual in-line memory modules (DIMMs), small outline DIMMs (SO-DIMMs), and various types of non-volatile dual in-line memory modules (NVDIMMs).

[0027] The computing system 100 may be a computing device, such as a desktop computer, a laptop computer, a network server, a mobile device, a vehicle (e.g., an airplane, a drone, a train, a car, or other transportation), a device with Internet of Things (IoT) capabilities, an embedded computer (e.g., an embedded computer included in a vehicle, industrial equipment, or a networked commercial device), or such a computing device that includes a memory and a processing device.

[0028] The computing system 100 may include a host system 120 coupled to one or more memory subsystems 110. In some embodiments, the host system 120 is coupled to memory subsystems 110 of different types. Figure 1A An example of a host system 120 coupled to one memory subsystem 110 is illustrated. As used herein, "coupled to" or "coupled with" generally refers to a connection between components or devices, which may be an indirect communication connection or a direct communication connection (e.g., without intervening components or devices), whether wired or wireless, including connections such as electrical connections, optical connections, magnetic connections, and the like.

[0029] The host system 120 may include a processor chipset and a software stack executed by the processor chipset. The processor chipset may include one or more cores, one or more caches, a memory controller (e.g., an NVDIMM controller), and a storage protocol controller (e.g., a PCIe controller, a SATA controller). The host system 120 uses the memory subsystem 110, for example, to write data to the memory subsystem 110 and read data from the memory subsystem 110.

[0030] The host system 120 may be coupled to the memory subsystem 110 via a physical host interface that may communicate on a system bus. Examples of the physical host interface 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, Fibre Channel, Serial Attached SCSI (SAS), a Double Data Rate (DDR) memory bus, a Small Computer System Interface (SCSI), a Dual In-line Memory Module (DIMM) interface (e.g., a DIMM socket interface supporting Double Data Rate (DDR)), an Open NAND Flash Interface (ONFI), Double Data Rate (DDR), Low Power Double Data Rate (LPDDR), or any other interface. The physical host interface may be used to transfer 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 may further utilize an NVM Express (NVMe) interface to access components (e.g., the memory device 130). The physical host interface may provide an interface for passing control, address, data, and other signals between the memory subsystem 110 and the host system 120 . Figure 1A Memory subsystem 110 is illustrated as an example. In general, host system 120 can access multiple memory subsystems via the same communication connection, multiple individual communication connections, and / or a combination of communication connections.

[0031] The memory devices 130, 140 may include any combination of different types of non-volatile memory devices and / or volatile memory devices. Volatile memory devices (e.g., memory device 140) may be, but are not limited to, random access memory (RAM), such as dynamic random access memory (DRAM) and synchronous dynamic random access memory (SDRAM).

[0032] Some examples of non-volatile memory devices (e.g., memory device 130) include NAND type flash memory and write-in-place memory, such as three-dimensional cross-point ("3D cross-point") memory. A cross-point array of non-volatile memory can be combined with a stackable cross-grid data access array to perform bit storage based on changes in body resistance. In addition, compared to many flash-based memories, cross-point non-volatile memory can perform write-in-place operations, where non-volatile memory cells can be programmed without pre-erasing the non-volatile memory cells. NAND type flash memory includes, for example, two-dimensional NAND (2D NAND) and three-dimensional NAND (3D NAND).

[0033] Each of the memory devices 130 may include one or more memory cell arrays. One type of memory cell, such as a single-level cell (SLC), may store one bit per cell. Other types of memory cells, such as multi-level cells (MLC), three-level cells (TLC), four-level cells (QLC), and five-level cells (PLC) may store multiple bits per cell. In some embodiments, each of the memory devices 130 may include one or more memory cell arrays, such as SLC, MLC, TLC, QLC, PLC, or any combination of such. In some embodiments, a particular memory device may include an SLC portion of a memory cell, and an MLC portion, a TLC portion, a QLC portion, or a PLC portion. The memory cells of the memory device 130 may be grouped into pages that may refer to logical units of a memory device for storing data. In the case of some types of memory (e.g., NAND), pages may be grouped to form blocks.

[0034] Although nonvolatile memory components such as NAND-type flash memory (e.g., 2D NAND, 3D NAND), and 3D cross-point nonvolatile memory cell arrays are described, the memory device 130 may be based on any other type of nonvolatile memory, such as read-only memory (ROM), phase-change memory (PCM), self-selected memory, other chalcogenide-based memories, ferroelectric transistor random access memory (FeTRAM), ferroelectric random access memory (FeRAM), magnetic random access memory (MRAM), spin transfer torque (STT)-MRAM, conductive bridging RAM (CBRAM), resistive random access memory (RRAM), oxide-based RRAM (OxRAM), non-OR (NOR) flash memory, and electrically erasable programmable read-only memory (EEPROM).

[0035] The memory subsystem controller 115 (or, for simplicity, controller 115) may communicate with the memory device 130 to perform operations, such as reading data, writing data, or erasing data and other such operations at the memory device 130. The memory subsystem controller 115 may include hardware, such as one or more integrated circuits and / or discrete components, buffer memory, or a combination thereof. The hardware may include digital circuitry with dedicated (i.e., hard-coded) logic to perform the operations described herein. The memory subsystem controller 115 may be a microcontroller, dedicated logic circuitry (e.g., a field programmable gate array (FPGA), an application specific integrated circuit (ASIC), etc.), or another suitable processor.

[0036] The memory subsystem controller 115 may include a processing device including one or more processors (e.g., processor 117) configured to execute instructions stored in a local memory 119. In the illustrated example, the local memory 119 of the memory subsystem controller 115 includes an embedded memory configured to store instructions for performing various processes, operations, logic flows, and routines that control the operation of the memory subsystem 110, including handling communications between the memory subsystem 110 and the host system 120.

[0037] In some embodiments, local memory 119 may include memory registers that store memory pointers, fetched data, etc. Local memory 119 may also include a read-only memory (ROM) for storing microcode. Although the example memory subsystem 110 in FIG. 1 has been illustrated as including a memory subsystem controller 115, in another embodiment of the present disclosure, the memory subsystem 110 does not include a memory subsystem 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).

[0038] In general, the memory subsystem controller 115 may receive commands or operations from the host system 120 and may convert the commands or operations into instructions or appropriate commands to achieve the desired access to the memory device 130. The memory subsystem 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 (e.g., logical block addresses (LBA), name space) and physical addresses (e.g., physical block addresses) associated with the memory device 130. The memory subsystem controller 115 may further 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 device 130, and convert responses associated with the memory device 130 into information for the host system 120.

[0039] The memory subsystem 110 may also include additional circuitry 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 memory subsystem controller 115 and decode the addresses to access the memory device 130.

[0040] In some embodiments, the memory device 130 includes a local media controller 135 that operates in conjunction with the memory subsystem controller 115 to perform operations on one or more memory cells of the memory device 130. An external controller (e.g., the memory subsystem controller 115) can manage the memory device 130 externally (e.g., perform media management operations on the memory device 130). In some embodiments, the memory subsystem 110 is a managed memory device, which is a raw memory device 130 with control logic (e.g., the local media controller 135) on the die and a controller (e.g., the memory subsystem controller 115) for memory management within the same memory device package. An example of a managed memory device is a managed NAND (MNAND) device.

[0041] The computing system 100 includes a file system 124 in a host system 120, which is configured with the file organization and storage allocation functionality discussed herein throughout the figures. In some embodiments, the host system 120 includes at least a portion of the file organization and storage allocation functionality. In other embodiments, or in combination, the controller 115 and / or processing device of the host system 120 includes at least a portion of the file organization and storage allocation functionality. For example, the controller and processing device (processor) of the host system 120 may be configured to execute instructions stored in a memory for performing operations of the file organization and storage allocation functionality described herein.

[0042] Figure 1B According to some embodiments Figure 1A Detailed block diagram of computing system 100 of FIG. 1. In various embodiments, host system 120 includes processing device 122, cache 123, and operating system 150, which has file system 124 (e.g., host file system), one or more applications 126, and kernel 128. Kernel 128 may include device mapping logic 133. In some embodiments, file system 124 includes file application programming interface (API) 138, stream assignor 142, storage allocator 146, and garbage collector (GC) 148. Garbage collector 148 may perform garbage collection of failed physical blocks of memory that can be erased and written again, such as a client in a COW architecture. In an embodiment, processing device 122 executes instructions to execute kernel 128, such as a kernel of operating system 150. File system 124 and application 126 may run on kernel 128, which may be considered as a controller of operating system 150.

[0043] In various embodiments, computing system 100 includes memory device 130A associated with a sequential namespace (e.g., ZNS) and memory device 130B associated with a non-sequential namespace (e.g., random NS). In one embodiment, memory device 130A is implemented as a TM (NVMe TM ) organization defined by the Zone Name Space (ZNS) solid-state device. The memory device 130A may be the previously mentioned storage device comprising a plurality of IC dies. Sequential writes to the zones (e.g., Zone 0, Zone 1 . . . Zone N-1) (which are also referred to herein as memory cell groups) are typically performed sequentially from the top (or smallest address) of the IC die to the bottom (or largest address) of the IC die, as illustrated by the patterned data blocks written to the illustrated zones. In these embodiments, the kernel 128 tracks the logical block numbers (or addresses) of the LBA space to the ZNS of the memory device 130A by a sequential relationship (e.g., by sequential physical addresses programmed to access zones (or memory cell groups) within the plurality of IC dies of the memory device 130A).

[0044] Write pointers (WPs) to regions of memory device 130A may be stored in cache 123 and readily accessed to determine whether an IO write request was directed to a WP and therefore sequential, or not directed to a WP and therefore non-sequential. The WPs may also be made available to file system 124 for purposes of storage space allocation within memory device 130A, which is also sequential (e.g., covering a contiguous range of physical addresses after the WP for each region), and therefore do not have to be overwritten at a later time.

[0045] In various embodiments, application 126 comprises different types of software programs or architectures that function differently with respect to the hardware and supporting software of computing system 100. In one embodiment, application 126 comprises, for example, a log structured merge (LSM) based architecture (e.g., a database (e.g., Apache Cassandra TM ), hierarchical event-driven architectures (e.g., SEDA), distributed storage and replication architectures (e.g., Amazon Dynamo), data and storage engine models (e.g., Google ), or other such storage engines designed to process and organize structured data (including big data). In some embodiments, using an LSM-based architecture as an example, the application 126 handles various files containing data and / or metadata of different data types (see Figure 2 ). Each application 126 may therefore create, access and / or manage files of one or more data types.

[0046] In some embodiments, the file API 138 is programmed to determine information (e.g., metadata) about different files from various sources (including information about different files from the application 126 (also referred to as user data)), operating system files (e.g., super blocks of data, system metadata, and the like), and file system metadata, which will be referenced Figure 2 Discussed in more detail. By accessing this metadata about these various files of different data types, the file API 138 can assist the file system 124 in organizing and allocating storage (in the memory device 130A) with respect to the various files or block groups.

[0047] For example, in these embodiments, the stream assignor 142 assigns different types of data (e.g., stored in different files or block groups) to different streams (e.g., stream IDs), each of which is assigned to a different specific series of physical addresses in the IC die of the memory device 130A, where the block groups are to be written. A block group (BG) can be understood as a continuous portion (or chunk) of a file (e.g., a series of LBAs) assigned to a continuous area of ​​the memory device 130A, which is reserved for files in the file system 124. This continuous area can be represented as a range of block numbers (e.g., physical addresses) or tracks on the count key memory device. Large files can be split into individually tracked block groups to make the allocation and management of files that are allocated and written to the memory device 130A in the necessary series feasible.

[0048] As an example, extents are allocated inside block groups (BGs) in a b-tree file system (Btrfs) file system, which is developed to run on the Linux kernel. A file may consist of zero or more extents, e.g., a file does not consist of extents if it is small enough and exists inside an index node. For example, assume that a large file of 10 gigabytes (GB) is chunked into 128 megabyte (MB) fragments. Multiple 128MB blocks of information may be grouped together as extents to an extent map that is linked to a larger file and contains metadata. The file system 124 may build and maintain an extent map to manage these extents or block groups. In some embodiments, the extent tree is intended to divide the available storage of the memory device 130A into several flexible allocation strategies. Each extent tree may own a segment of the underlying IC die and may be assigned to a series (or a single) of tree roots, directories, or inodes.

[0049] An index node is a data structure in a Unix-style file system that describes a file system object, such as a file or directory. Each index node stores the attributes and disk block location of the object's data. A directory is structured data that contains entries for itself, its parent, and each of its children. Policies can, for example, direct how a given allocation is spread across a tree of available extents, allowing an administrator to direct which portions of the file system 124 are striped, mirrored, or restricted to a given storage device.

[0050] In various embodiments, when allocating each zone, the stream assignor 142 may also assign a stream ID to each zone (e.g., a group of memory cells). To do this, the kernel 128 may provide visibility of the zone mapping to the file system 124 (based on the physical address). In order to track files (and / or block groups) of a particular data type to be allocated to a particular zone (e.g., to be written as a data group or stream), the stream assignor 142 may also associate the file (and block group) with a particular stream ID assigned to the particular zone. In one embodiment, the particular stream ID is added to the file name of the file or to the metadata of the block group. In another embodiment, the particular stream ID is added to a structured portion of the file or block group, for example, to a metadata structure built into each file or block group. Other methods of stream ID association are contemplated.

[0051] As discussed, the stream assigner 142 (and / or the allocator 146) may associate a block group assigned to a particular data type with a particular zone using a particular stream ID assigned to the zone. In this way, the block group becomes associated with the zone, for example, via a particular stream ID identifying the zone within the ZNS-based storage management. The file system 124 may perform this function in conjunction with an organizational structure that assigns files (and / or block groups) of the same data type to a particular zone, wherein each zone may contain one or more block groups of the same data type. In one embodiment, there is a one-to-one correspondence between block groups and assigned zones. Files may include, for example, data files, index nodes or tree roots, directories, and other data structures or objects that can encapsulate data / metadata and write to an IC die. In the case where a file is split into block groups, the file system 124 may assign a stream ID to each of these block groups associated with an identified zone to which the block group is assigned. When the assignment of files to the IC die of the memory device 130A is discussed herein, the assignment of any block groups that make up those files is understood to be the same or similar.

[0052] In various embodiments, storage allocator 146 allocates files (or groups of blocks) to zones (or groups of memory cells) according to the stream IDs associated with the files. For example, storage allocator 146 may allocate a particular (first) file to a first zone that has been assigned a first stream ID by stream assignor 142. To do so, file system 124 may associate the first file with the first stream ID. In this manner, files (or groups of blocks) that are part of a particular stream (determined by the stream ID) are continually written to the corresponding zone assigned to the particular stream ID.

[0053] When generating individual write IO requests for individual files (or block groups), the file system 124 may access the stream ID within the file name or the metadata of each file to determine which zone the file is associated with. The storage allocator 146 may then check whether there is available storage space in the associated zone. If there is enough available space for the file (or block group), the storage memory 146 may allocate a continuous range of physical addresses (e.g., disk areas) of sequential write files beyond the WP within the associated zone or memory unit group. After successfully allocating space, the file system 124 may then generate IO write requests for a continuous range of physical addresses in the associated zone. Reference will be made to Figure 3 This file allocation algorithm for block groups is discussed in more detail.By first allocating a contiguous range of physical addresses after the WP in each zone, IO write requests can be issued accordingly as sequential (ZNS) IO write requests and avoid unnecessary overwriting of data or handling of non-sequential IO requests.

[0054] Figure 2 Schematic diagram of a computing system 200 that includes a host file system association including a stream identifier (ID) and a data type and a stream ID and a specific area (or memory unit group) according to various embodiments. In various embodiments, the computing system 200 includes a file system 224 of an operating system 250, at least one application 226, and a kernel 228, and the file system 224, at least one application 226, and the kernel 228 can be executed by, for example, the processing device 122 ( Figure 1B ) is executed by a processing device. In one embodiment, the file system 224 is Figure 1B The file system 124 and the kernel 228 are Figure 1B In some embodiments, the application 226 is a reference Figure 1B The computing system 200 may further include a memory device 230A, which may have a configuration similar to that of the memory device 130A ( Figure 1B ) of a non-volatile memory device having multiple IC dies.

[0055] For the purpose of explanation, application 226 is a database based on LSM architecture (e.g., Cassandra TM ) or similar software applications. Thus, in this embodiment, application 226 handles files of several different data types, including, for example, administrative files 203, data files 205, commit log 207, and system log 209. Commit log 207 can be a record of transactions performed by the database application.

[0056] In some embodiments, the file system 224 may manage and make allocations for several data types, including but not limited to superblocks 210 of data and system metadata 215 (generated by the operating system 250), file system (FS) metadata 218 (e.g., inodes, tree roots, extent maps, and the like), and user data 220 (which in this example are different types of extents). Files generated by applications 226 may be associated with user data 220.

[0057] like Figure 2 As described in , the file system 224 may partition the file of each data type into different block groups (BGs) or series of block groups, and may assign each block group to a different area (e.g., a group of memory cells) in the memory device 230A, thereby generating a data stream (or metadata) for each data type as a group that is written separately to the assigned area. As described in reference Figure 1B As discussed, a stream ID may be assigned to each block group and to the zone to which the block group is assigned. The split files may also be associated with the same stream ID, for example, by tagging the files with the stream ID in some manner. In this manner, the mapping between block groups and zones is transitive and straight forward, and sequential writes to zones may be striped across the IC die according to block groups (or files), resulting in load balancing that enhances performance. At the same time, because each block group has the same data type, the data written to each zone is of the same type (or from the same application and therefore has data locality), has a similar lifespan, and is likely to be modified at about the same rate for the purpose of efficient garbage collection.

[0058] While the files / BGs of the superblock 210, the system metadata 214, the inodes (of the FS metadata 218), and the extent maps (of the FS metadata 218) can each be assigned to a separate stream (e.g., a different stream ID), the files / BGs of the user data 220 can include multiple data types that can be individually assigned to different stream IDs. Table 1 illustrates possible stream ID assignments for different types of user data 220 associated with the application 226 in different embodiments.

[0059] Data Types Stream ID Managing Files 0 Submit log 1 System log 2 Data Directory Group Based on LSM ID, for example, 3+

[0060] Table 1

[0061] Each LSM ID may be associated with a different data directory and therefore assigned a separate stream ID. Additional types of stream ID assignments for different data types are contemplated.

[0062] In various embodiments, the file system 224 generates IO write requests to the allocated contiguous range of physical addresses beyond the current WP. In some embodiments, the kernel 228 can use the device mapping logic 133 to intercept and direct these IO write requests to start sequential writing to the appropriate area at the current area WP, otherwise the IO write request is handled as a non-sequential write request. In other embodiments, the device mapping logic 133 is integrated within the file system 224, which can directly manage the device mapping to the appropriate area.

[0063] Once a zone becomes fully written, e.g., there is no room for further sequential IO writes, the file system 224 may allocate a new zone to which files / BGs of a particular data type may continue to be sequentially written. Assume that a first stream ID (e.g., stream ID_0) is assigned to the zone that becomes full, and a first file / BG is assigned to the zone with the first stream ID. In response to the memory cell group becoming fully written, the file system 224 may allocate a second memory cell group (new zone) of the IC die to the file / BG. The file system 224 may further assign a second stream assigned to the new (e.g., second) zone to the first file / BG. The file system 224 may further cause additional files / BGs in the file / BG to be sequentially written to the second memory cell group based on the second stream ID.

[0064] Figure 3 1 is a flow chart of a method 300 for allocating groups of blocks that are contiguous portions of a file to groups of memory cells (or zones) according to some embodiments. The method 300 may be performed by processing logic, which 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, the method 300 is performed by Figures 1A to 2 The processes of FIG. 1 and FIG. 2 are performed by the host system 120 (e.g., via execution of the file system 124 or 224 by the processing device 122). Although shown in a particular order or sequence, the order of the processes may be modified unless otherwise specified. Therefore, it should be understood that the illustrated embodiments are merely examples, and the illustrated processes may be performed in a different order, and some processes may be performed in parallel. In addition, one or more processes may be omitted in various embodiments. Therefore, not all processes are required in every embodiment. Other process flows are possible.

[0065] At operation 310, processing logic retrieves a block group (BG) of an IC die (eg, of memory device 130A or 230A) to be written to a memory device. A block group may be a contiguous portion partitioned from a file to be written to a memory device.

[0066] At operation 320, processing logic determines whether to assign a block group to a data stream. To do so, processing logic may, for example, access block group metadata associated with a BG to determine a stream identifier (ID) associated with a file assigned to the BG according to the data type.

[0067] In response to retrieving the stream ID, at operation 330, processing logic determines whether there is available space in the memory cell group (area) to which the BG is to be written. If there is space, then at operation 340, processing logic accesses the write pointer associated with the memory cell group to which the stream ID has been assigned within the block group metadata. Additionally, at operation 345, processing logic allocates a contiguous range of physical addresses within the memory cell group that are sequentially written to the BG beyond the write pointer.

[0068] In some embodiments, the processing logic may also assign the memory cell group to a file associated with the data type via an association of a stream ID with the block group and with the memory cell group. The processing logic may further generate an input-output (IO) write request that will cause the block group to be sequentially written to a contiguous range of physical addresses of the memory cell group starting at the write pointer.

[0069] Returning to operation 320, in response to the block group of the file not being allocated to a stream (e.g., the block group metadata does not contain a stream ID), or returning to operation 330, in response to the absence of available space in the memory unit group to which the file is allocated, processing logic transitions to operation 335. At operation 335, processing logic determines whether there is a second memory unit group available for new allocation (e.g., allocating a new block group). If not, then at operation 350, processing logic performs legacy block group allocation to include garbage collection, block segmentation, random writes, and the like.

[0070] If at operation 335, there is an available second memory cell group with space for BG allocation, then at operation 360, processing logic allocates the BG to the second memory cell group (e.g., available area). At operation 365, processing logic assigns a second stream ID associated with the second memory cell group to the block group.

[0071] The method 300 may then loop back to operation 330, where the processing logic determines that there is available allocatable space in the second memory cell group (available area). At operation 340, the processing logic accesses a second write pointer associated with the second memory cell group in the block group metadata. And, at operation 345, the processing logic allocates a contiguous range of physical addresses of sequential write block groups beyond the second write pointer within the second memory cell group.

[0072] Method 300 may loop back to operation 310, where processing logic retrieves a second block group (BG) to be written to the IC die of the memory device, the second block group being associated with the second file. In one embodiment, at operation 320, processing logic accesses block group metadata associated with the second block group to determine that the second block group has not yet been allocated to a memory cell group, causing processing logic to transition again to operation 335. At operation 335, processing logic determines that there is a second memory cell group available for new allocation (e.g., which may be an available area). At operation 360, processing logic allocates the second block group to the second memory cell group. At operation 365, processing logic assigns a second stream ID associated with the second memory cell group to the second block group.

[0073] The method 300 may again loop back to operation 330, where processing logic determines that there is available allocatable space in the second memory cell group. At operation 340, processing logic accesses a second write pointer associated with the second memory cell group within block group metadata associated with the second block group. At operation 345, processing logic allocates a contiguous range of physical addresses within the second memory cell group that are sequentially written to the second block group beyond the second write pointer.

[0074] Figure 4 4 is a flow chart of a method for assigning a stream ID to an application data type so that a file of the data type is associated with a stream ID assigned to a group of memory cells in a sequentially written memory device according to an embodiment. The method 400 may be performed by processing logic, which may include hardware (e.g., a processing device, a circuit system, a dedicated logic, a programmable logic, a 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, the method 400 is performed by Figures 1A to 2The processes of FIG. 1 and FIG. 2 are performed by the host system 120 (e.g., via execution of the file system 124 or 224 by the processing device 122). Although shown in a particular order or sequence, the order of the processes may be modified unless otherwise specified. Therefore, it should be understood that the illustrated embodiments are merely examples, and the illustrated processes may be performed in a different order, and some processes may be performed in parallel. In addition, one or more processes may be omitted in various embodiments. Therefore, not all processes are required in every embodiment. Other process flows are possible.

[0075] At operation 410, processing logic assigns a first stream identifier (ID) to a first data type generated by execution of an application within an operating system. The application may be a software program running on the operating system. In one embodiment, the application is a database based on the LSM architecture.

[0076] At operation 420, the processing logic associates a first file (or BG) generated by the application with a first stream ID, wherein the first file (or BG) is associated with a first data type. Figures 1B to 2 Various types of user data that may be considered different data types for the purposes of assigning different flow IDs are discussed.

[0077] At operation 430, processing logic allocates a first memory cell group of the plurality of IC dies to a first file (or BG), wherein the first memory cell group is assigned a first stream ID. The first memory cell group may be a first region or contiguous area of ​​a memory device such as memory device 130A or 230A.

[0078] At operation 440 , processing logic causes a first file to be sequentially written to a first group of memory cells of a plurality of IC dies based on the first stream ID.

[0079] At operation 450, processing logic determines whether the first memory cell group becomes fully written, for example, before further allocating the first file to another memory cell group has occurred. If the answer is no, then method 400 loops back to operation 430 and continues allocating and writing to the first memory cell group, as previously described.

[0080] If the answer is yes at operation 450, then at operation 460, processing logic allocates a second memory cell group of the plurality of dies to the first file, wherein the second memory cell group is assigned a second stream ID. At operation 470, processing logic associates the first file with the second stream ID, and at operation 480, processing logic causes the first file of the first files to be sequentially written to the second memory cell group based on the second stream ID.

[0081] In some embodiments, the application is a log structured merge (LSM) based architecture that handles multiple data types, the multiple data types including a first data type, such as management data, a specific data directory of a specific type of data file, a commit log, or a system based log. In these embodiments, the processing logic may further assign another (e.g., third) stream ID to a third data type in the multiple data types and associate a third file with the third stream ID, wherein the third file corresponds to the third data type. The processing logic may further assign a third memory cell group of the multiple IC dies to the third file, wherein the third stream ID is assigned to the third memory cell group. The processing logic may further cause the third file to be sequentially written to the third memory cell group of the multiple IC dies based on the third stream ID.

[0082] In some embodiments, the operations performed by the processing logic are performed by a file system of an operating system. The processing logic may further assign a fourth stream ID to the file system and associate a fourth file of file system metadata generated by the file system with the fourth stream ID. The processing logic may further assign a fourth memory cell group of a plurality of die to a fourth file associated with the fourth stream ID, wherein the fourth stream ID is assigned to the fourth memory cell group. The processing logic may further cause the fourth file to be sequentially written to the fourth memory cell group of a plurality of IC die based on the fourth stream ID. In some embodiments, the file system metadata includes at least one of an index node, an extent tree, or an extent map.

[0083] In some embodiments, the operations performed are performed by a file system of an operating system. The processing logic may further assign a fifth stream ID to system metadata generated by execution of the operating system, and associate a fifth file containing the system metadata with the fifth stream ID. The processing logic may further assign a fifth memory cell group of the plurality of IC dies to the fifth file, wherein the fifth stream ID is assigned to the fifth memory cell group. The processing logic may further cause the fifth file to be sequentially written to the fifth memory cell group of the plurality of IC dies based on the fifth stream ID.

[0084] Figure 5 Flowchart of a method 500 for assigning stream IDs to operating system data so that the system data is associated with a stream ID assigned to a group of memory cells in a sequentially written memory device according to an embodiment. The method 500 may be performed by processing logic, which may include hardware (e.g., a processing device, a circuit system, a dedicated logic, a programmable logic, a 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, the method 500 is performed by Figures 1A to 2The processes of FIG. 1 and FIG. 2 are performed by the host system 120 (e.g., via execution of the file system 124 or 224 by the processing device 122). Although shown in a particular order or sequence, the order of the processes may be modified unless otherwise specified. Therefore, it should be understood that the illustrated embodiments are merely examples, and the illustrated processes may be performed in a different order, and some processes may be performed in parallel. In addition, one or more processes may be omitted in various embodiments. Therefore, not all processes are required in every embodiment. Other process flows are possible.

[0085] At operation 510, processing logic assigns a first stream identifier (ID) to a data type generated due to execution of an operating system. This data type may include, for example, system data. The operation performed by processing logic may be performed by a file system of the operating system, and the system data may be data generated by the operating system or one of the superblocks of system metadata.

[0086] At operation 520, processing logic associates a first file of system data generated by an operating system with a first stream ID, wherein the first file is associated with a data type.

[0087] At operation 530 , processing logic allocates a first group of memory cells of the plurality of IC dies to a first file, wherein the first group of memory cells is assigned a first stream ID.

[0088] At operation 540 , processing logic causes sequential writing of the first file to a first group of memory cells of the plurality of IC dies based on the first stream ID.

[0089] 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 host system (e.g., Figures 1A to 1B ) that includes, is coupled to, or utilizes a memory subsystem (e.g., Figure 1A 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.

[0090] 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 a set (or multiple sets of instructions) to perform any one or more of the methodologies discussed herein.

[0091] 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) (e.g., 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.

[0092] The processing device 602 represents one or more general-purpose processing devices, such as a microprocessor, a central processing unit, or the like. More specifically, the processing device may 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. The processing device 602 may also be one or more special-purpose 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. The processing device 602 is configured to execute instructions 626 for performing the operations and steps discussed herein. The computer system 600 may further include a network interface device 608 to communicate on a network 620.

[0093] The data storage system 618 may include a machine-readable storage medium 624 (also referred to as a non-transitory computer-readable medium) on which is stored one or more sets of instructions 626 or software embodying any one or more of the methodologies 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 thereof 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 1A Memory subsystem 110.

[0094] In one embodiment, the instructions 626 include instructions for implementing the Figures 1A to 1BThe machine-readable storage medium 624 is a functional instruction of the file system 124. Although the machine-readable storage medium 624 is shown as a single medium in the example embodiment, the term "non-transitory 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. Therefore, the term "machine-readable storage medium" should be considered to include, but not limited to, solid-state memory, optical media, and magnetic media.

[0095] 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 most effectively convey the substance of their work to others skilled in the art. Here, and in general, an algorithm is conceived to be a self-consistent sequence of operations that produces a desired result. Operations are those requiring physical manipulation of physical quantities. Typically, but not necessarily, these quantities are in the form of electrical or magnetic signals capable of being stored, combined, compared, and otherwise manipulated. At times, it has proven convenient, primarily for reasons of common usage, to refer to these signals as bits, values, elements, symbols, characters, terms, numbers, or the like.

[0096] It should be borne in mind, however, that all of these and similar terms should 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 data represented as physical (electronic) quantities within the computer system's registers and memories and transforms that data into other data similarly represented as physical quantities within the computer system's memories or registers or other such information storage systems.

[0097] The present disclosure also relates to an apparatus for performing the operations described herein. This apparatus may be specially constructed for the intended 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 floppy disks, optical disks, CD-ROMs and magnetic optical disks, read-only memories (ROMs), random access memories (RAMs), EPROMs, EEPROMs, magnetic or optical cards, or any type of medium suitable for storing electronic instructions, each coupled to a computer system bus.

[0098] The algorithms and displays presented herein are not inherently related to any particular computer or another device. Various general purpose systems may be used with programs according to the teachings herein, or it may prove convenient to construct a more specialized device to perform the method. The structures for various these systems will be presented as described below. In addition, the present disclosure is described without 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.

[0099] 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., non-transitory 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 component, etc.

[0100] 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 present description and drawings should be viewed in an illustrative rather than a restrictive sense.

Claims

1. A memory system, comprising: a plurality of integrated circuit dies having memory cells; as well as a processing device coupled to the plurality of integrated circuit dies, the processing device performing operations comprising: assigning a first stream identifier to a first data type generated by execution of an application within the operating system; associating a first file generated by the application with the first stream identifier, wherein the first file is associated with the first data type; allocating a first group of memory cells of the plurality of integrated circuit dies to the first file, wherein the first group of memory cells is assigned the first stream identifier; causing sequential writing of the first file to the first groups of memory cells of the plurality of integrated circuit dies based on the first stream identifier; as well as Wherein in response to the first memory cell group becoming fully written, the operations further include: allocating a second group of memory cells of the plurality of integrated circuit dies to the first file, wherein the second group of memory cells is assigned a second stream identifier; associating the first file with the second stream identifier; and Additional first files in the first files are sequentially written to the second group of memory cells based on the second stream identifier.

2. The memory system of claim 1, wherein the operations further comprise associating a group of blocks with the first group of memory cells using the first stream identifier, the group of blocks being a contiguous portion of one of the first files.

3. The memory system of claim 1 , wherein the operations performed are performed by a file system of the operating system and further comprising: assigning a third stream identifier to the file system; associating a second file of file system metadata generated by the file system with the third stream identifier; allocating a third group of memory cells of the plurality of integrated circuit dies to the second file, wherein the third group of memory cells is assigned the third stream identifier; as well as The second file is caused to be sequentially written to the third group of memory cells of the plurality of integrated circuit dies based on the third stream identifier.

4. The memory system of claim 3, wherein the file system metadata comprises one of an index node or an extent map.

5. The memory system of claim 1 , wherein the operations performed are performed by a file system of the operating system and further comprising: assigning a third stream identifier to system metadata generated by execution of the operating system; associating a second file containing the system metadata with the third stream identifier; allocating a third group of memory cells of the plurality of integrated circuit dies to the second file, wherein the third group of memory cells is assigned the third stream identifier; as well as The second file is caused to be sequentially written to the third group of memory cells of the plurality of integrated circuit dies based on the third stream identifier.

6. The memory system of claim 1 , wherein the application comprises a log-structured merge LSM-based architecture, the log-structured merge LSM-based architecture handles a plurality of data types including the first data type, the operation further comprising: assigning a third stream identifier to a second data type of the plurality of data types; associating a second file with the third stream identifier, wherein the second file corresponds to the second data type; allocating a third group of memory cells of the plurality of integrated circuit dies to the second file, wherein the third group of memory cells is assigned the third stream identifier; as well as The second file is caused to be sequentially written to the third group of memory cells of the plurality of integrated circuit dies based on the third stream identifier.

7. The memory system of claim 6, wherein the plurality of data types include one or more of administrative data, a specific data directory for specific types of data files, a commit log, or a system-based log.

8. A method for operating a memory, the method comprising: Retrieving, by a processing device executing a file system of an operating system, a group of blocks to be written to the plurality of integrated circuit dies, the group of blocks being a contiguous portion of a file; accessing, by the processing device, chunk group metadata associated with the chunk group to determine, based on a data type, a stream identifier associated with the file that is assigned to the chunk group; determining, by the processing device, whether there is available space in a group of memory cells of the plurality of integrated circuits assigned to the stream identifier, the group of blocks being allocated to the group of memory cells; as well as In response to determining that there is available allocatable space in the memory cell group: accessing, within the block group metadata of the block group, a write pointer associated with the group of memory cells; as well as allocating, by the processing device, a continuous range of physical addresses within the memory cell group that are written to the block group in a sequential manner beyond the write pointer; as well as In response to the group of memory cells becoming fully written: allocating a second group of memory cells of the plurality of integrated circuit dies to the file, wherein the second group of memory cells is assigned a second stream identifier; associating the file with the second stream identifier; as well as Causing, by the processing device, sequential writing of additional consecutive portions of the file to the second group of memory cells based on the second stream identifier.

9. The method according to claim 8, further comprising: assigning, via an association of the stream identifier with the group of blocks and with the group of memory cells, the group of memory cells to the file associated with the data type; as well as An input-output (IO) write request is generated that will cause the group of blocks to be sequentially written to the contiguous range of physical addresses of the group of memory cells starting at the write pointer.

10. The method of claim 8, further comprising, in response to determining that there is no allocatable space in the group of memory cells available for the group of blocks: determining that there is a second group of memory cells available for new allocation; assigning the block group to the second memory cell group; as well as The second stream identifier associated with the second group of memory cells is assigned to the group of blocks.

11. The method according to claim 10, further comprising: Determining that there is available allocatable space in the second memory unit group; accessing within the block group metadata a second write pointer associated with the second group of memory cells; as well as A contiguous range of physical addresses for sequentially writing to the group of blocks beyond the second write pointer is allocated within the second group of memory cells.

12. The method according to claim 8, further comprising: retrieving a second group of blocks to be written to the plurality of integrated circuit dies, the second group of blocks being associated with a second file; accessing block group metadata associated with the second block group to determine that the second block group has not been allocated to a memory cell group; determining that a third group of memory cells exists that is available for new allocation; assigning the second block group to the third memory cell group; as well as A third stream identifier associated with the third group of memory cells is assigned to the second group of blocks.

13. The method according to claim 12, further comprising: determining that there is available allocatable space in the third memory unit group; accessing, within the block group metadata associated with the second block group, a second write pointer associated with the third group of memory cells; as well as A contiguous range of physical addresses for sequentially writing to the second group of blocks beyond the second write pointer is allocated within the third group of memory cells.

14. A non-transitory computer-readable medium storing instructions that, when executed by a processing device, cause the processing device to perform operations comprising: assigning a first stream identifier to a data type resulting from execution of the operating system; associating a first file of system data generated by the operating system with the first stream identifier, wherein the first file is associated with the data type; allocating a first group of memory cells of a plurality of integrated circuit dies to the first file, wherein the first group of memory cells is assigned the first stream identifier; causing sequential writing of the first file to the first groups of memory cells of the plurality of integrated circuit dies based on the first stream identifier; as well as wherein in response to the first memory cell group becoming fully written: allocating a second group of memory cells of the plurality of integrated circuit dies to the first file, wherein the second group of memory cells is assigned a second stream identifier; associating the first file with the second stream identifier; as well as Additional first files in the first files are sequentially written to the second group of memory cells based on the second stream identifier.

15. The non-transitory computer-readable medium of claim 14, wherein the operations further comprise associating a group of blocks with the first group of memory cells using the first stream identifier, the group of blocks being a contiguous portion of one of the first files.

16. The non-transitory computer-readable medium of claim 14, wherein the operation performed is performed by a file system of the operating system, and the system data is one of data generated by the operating system or a superblock of system metadata.

17. The non-transitory computer-readable medium of claim 16, wherein the first stream identifier is assigned to a superblock of the data, and the operations further comprise: assigning a third stream identifier to the system metadata; associating a second file containing the system metadata with the third stream identifier; allocating a third group of memory cells of the plurality of integrated circuit dies to the second file, wherein the third group of memory cells is assigned the second stream identifier; as well as The second file is caused to be sequentially written to the third group of memory cells of the plurality of integrated circuit dies based on the third stream identifier.

18. The non-transitory computer-readable medium of claim 14, wherein the processing device also executes an application within the operating system, and the operations further comprise: assigning a third stream identifier to a second data type generated by execution of the application; associating a second file generated by the application with the third stream identifier, wherein the second file is associated with the second data type; allocating a third group of memory cells of the plurality of integrated circuit dies to the second file, wherein the third group of memory cells is assigned the third stream identifier; as well as The second file is caused to be sequentially written to the third group of memory cells of the plurality of integrated circuit dies based on the third stream identifier.

19. The non-transitory computer-readable medium of claim 14, wherein the operations performed execute a file system within the operating system, and the operations further comprise: assigning a third stream identifier to the file system; associating a second file of file system metadata generated by the file system with the third stream identifier; allocating a third group of memory cells of the plurality of integrated circuit dies to the second file, wherein the third group of memory cells is assigned the third stream identifier; as well as The second file is caused to be sequentially written to the third group of memory cells of the plurality of integrated circuit dies based on the third stream identifier.

Images