Management of event log information for storage subsystems

Abstract

A method of determining a set of log entries stored in a first event log associated with a memory subsystem that is subject to a wrap process, determining a pattern of log entries in the set of log entries, generating a log entry definition corresponding to the determined pattern of log entries, generating summary data representing the pattern of log entries, generating a summary log entry containing the summary data, and storing the summary log entry in a second event log that is not subject to the wrap process, and deleting the pattern of log entries from the first event log.

Description

Technical Field

[0001] The present disclosure relates generally to memory subsystems, and more particularly, to the management of event log information associated with 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. Generally speaking, a host system may use the memory subsystem to store data in 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 is a flow chart of an example method of managing event log entries associated with a memory subsystem according to some embodiments of the present disclosure.

[0006] Figure 3 is a flow chart of an example method of generating a summary log entry representing a pattern of event log entries associated with a memory subsystem according to some embodiments of the present disclosure.

[0007] Figure 4 An example event log management component is described that manages event log entries and multiple storage locations according to some embodiments of the present disclosure.

[0008] Figure 5A 、 5B and 5C illustrate an example group entry pattern of event log entries and generated corresponding summary log entries according to some embodiments of the present disclosure.

[0009] Figure 6A and 6B An example single entry schema illustrating an event log entry and a generated corresponding summary log entry according to some embodiments of the present disclosure.

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

[0011] Aspects of the present disclosure relate to the management of event log information associated with a memory subsystem. A memory subsystem is also referred to as a "memory device" hereinafter. 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), etc. In some embodiments, the memory subsystem may be a hybrid memory / storage device subsystem. Generally, a host system may use 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 data to be retrieved from the memory subsystem.

[0012] The memory subsystem may be monitored to identify events associated with the operation of the memory subsystem. Events are tracked and recorded in event log storage information associated with each event (hereinafter referred to as "event information"). An event log entry corresponding to an event may include multiple data fields for event data. Example data fields may include an event number, an event identifier, a power cycle count, a timestamp, an event type, a data byte length (Dlen), the temperature of the memory subsystem corresponding to the event, and a firmware version identifier (FWVer). In one embodiment, an event description may be derived from the event identifier, wherein a mapping (e.g., a table) identifies each event identifier and a corresponding event description. The event log undergoes a wrapping process, wherein, in response to exceeding a retention capacity threshold of a corresponding storage medium (e.g., NOR or NAND media), older log entries are replaced with newer entries in a first-in, first-out (FIFO) order. A limited number of event log entries may be stored before the wrapping process is performed. In embodiments, the event log may wrap multiple times, resulting in the deletion or replacement of multiple log entries.

[0013] Due to limitations on storage space availability, conventional management of a memory subsystem's event log results in the loss of important event information in older log entries. Deleted or discarded log entries may contain event information that is crucial for the memory subsystem's designer to gain a better understanding of the memory subsystem's performance history for debugging purposes or design improvements. An example conventional method of event log management involves saving a first set of event log entries when a wraparound occurs. In this example, a pointer identifying a storage location within the event log to begin the wraparound process is moved to a later location (e.g., after the first set of event log entries) so that the first set of event log entries is not removed and remains in the wrapped log. This method is implemented to save the first set of event log entries based on the assumption that the earliest event log entries associated with the memory subsystem are particularly important. However, a number of other event log entries that are not part of the first set of event log entries are discarded as part of the wraparound process applied to the storage location, resulting in a significant loss of event information.

[0014] Another conventional event log management method is to store certain event log entries (e.g., a first set of log entries identified as containing important event information) in a first storage location that is not subject to a wrapping process (e.g., a non-wrapping event log). According to this method, after the capacity of the first storage location is reached, subsequent event log entries are stored in a separate storage location (e.g., a second storage location) that is subject to a wrapping process (e.g., a wrapped event log). As a result, a large amount of event information is discarded from the second storage location due to the wrapping process.

[0015] Aspects of the present disclosure address the above-mentioned and other deficiencies by identifying patterns in event log entries of an event log stored in a storage location that is subject to a wrap-around process (also referred to as a "first event log"). In an embodiment, identifying the pattern enables multiple log entries to be aggregated and saved according to the wrap-around process. Saving the log entries corresponding to the identified pattern enables an increasing amount of event information that can be used to understand the history of the memory subsystem to be maintained. In an embodiment, useful event information can be recorded throughout the useful life of the memory subsystem by generating an aggregated log entry that contains aggregated data of multiple event log entries corresponding to the event log pattern. In an embodiment, the aggregated log entry may be stored in a storage location that is not subject to the wrap-around process. In an embodiment, the multiple log entries represented by the aggregated log entry may be discarded or deleted from the storage location that is subject to the wrap-around process.

[0016] In an embodiment, multiple log entry patterns may be identified, including group entry patterns and single entry patterns. A group entry pattern may represent multiple consecutive log entries that represent a collection of events that occurred as a group. For example, a group entry pattern may occur based on a primary workload or activity (e.g., data center environment activity) or due to a sequence of events executed in a pattern while a memory subsystem performs a task (e.g., a power reserve routine). Figure 5A The instance group entry mode is described in .

[0017] A single entry pattern may represent a single log entry repeated multiple times in succession. For example, a single entry pattern may be generated when the memory subsystem is going through an internal error handling routine (e.g., a NAND read error handling log). Figure 6A An example of single-entry mode is shown in .

[0018] In one embodiment, a log entry definition representing an identified pattern of log entries is generated. In one embodiment, summary data corresponding to the set of log entries in the pattern is generated. The log entry definition is populated with the summary data to generate the summary log entry. In one embodiment, the summary log entry is stored in an event log that is not subject to the wrapping process (also referred to as the "second event log"). In one embodiment, after storing the summary log entry representing the identified pattern of log entries in the storage location that is not subject to the wrapping process (i.e., the second event log), the set of log entries in the pattern is deleted from the storage location that is subject to the wrapping process (i.e., the first event log). Advantageously, storing the summary log entry in the non-wrapped second event log preserves additional event information. For example, preserving event information that would otherwise be deleted due to the wrapping process enables improved analysis of memory subsystem performance based on a greater amount of information, improved debugging operations, and the use of the preserved event information to identify design changes. Additionally, deleting the set of log entries from the wrapped event log (i.e., the first event log) creates additional storage space for other event log entries.

[0019] Figure 1 An example computing environment 100 including a memory subsystem 110 according to some embodiments of the present disclosure is described. Memory subsystem 110 may include media, such as memory components 112A through 112N. Memory components 112A through 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 an SSD. In some embodiments, memory subsystem 110 is a hybrid memory / storage device subsystem. Generally speaking, computing environment 100 may include a host system 120 that utilizes memory subsystem 110. For example, host system 120 may write data to and read data from memory subsystem 110.

[0020] Host system 120 may be a computing device, such as a desktop computer, laptop computer, network server, mobile device, or any other computing device that includes memory and processing devices. Host system 120 may include or be coupled to memory subsystem 110, such that host system 120 can read data from or write data to memory subsystem 110. Host system 120 may be coupled to 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 intervening components), whether wired or wireless, including connections such as electrical, optical, magnetic, and the like. 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, Fibre Channel, Serial Attached SCSI (SAS), and the like. The physical host interface may be used to transfer data between host system 120 and 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 use an NVM Express (NVMe) interface to access the memory components 112A to 112N. The physical host interface may provide an interface for transferring control, address, data, and other signals between the memory subsystem 110 and the host system 120.

[0021] Memory components 112A-112N may include any combination of different types of nonvolatile memory components and / or volatile memory components. An example of a nonvolatile memory component includes NAND-type flash memory. Each of memory components 112A-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 SLC and MLC portions of memory cells. Each of the memory cells may store one or more bits of data (e.g., a block of data) used by host system 120. Although nonvolatile memory components such as NAND-type flash memory are described, memory components 112A-112N may be based on any other type of memory, such as volatile memory. In some embodiments, memory components 112A-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-volatile (NOR) flash memory, electrically erasable programmable read-only memory (EEPROM), and a cross-point array of non-volatile memory cells. A 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 bulk 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 first erasing the non-volatile memory cells. Furthermore, the memory cells of memory components 112A-112N may be grouped into memory pages or data blocks, which may refer to the cells of a memory component used to store data.

[0022] A memory system controller 115 (hereinafter referred to as the "controller") can communicate with memory components 112A-112N to perform operations, such as reading, writing, or erasing data at memory components 112A-112N, as well as other such operations. Controller 115 may include hardware, such as one or more integrated circuits and / or discrete components, buffer memory, or a combination thereof. 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 other suitable processor. Controller 115 may include a processor (processing device) 117 configured to execute instructions stored in local memory 119. In the illustrated example, local memory 119 of controller 115 includes embedded memory configured to store instructions for executing various processes, operations, logic flows, and routines that control the operation of memory subsystem 110, including handling communications between memory subsystem 110 and host system 120. In some embodiments, local memory 119 may include memory registers that store memory pointers, fetched data, and the like. Local memory 119 may also include read-only memory (ROM) for storing microcode. Figure 1 The example memory subsystem 110 in FIG. 1 has been described 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).

[0023] In general, the controller 115 may receive commands or operations from the host system 120 and convert the commands or operations into instructions or appropriate 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 also include host interface circuitry to communicate with the host system 120 via a physical host interface. The host interface circuitry 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.

[0024] 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 controller 115 and decode the addresses to access the memory components 112A-112N.

[0025] Memory subsystem 110 includes an event log management component 113 that can be used to manage event logs associated with memory components 112A-112N. In some embodiments, controller 115 includes at least a portion of event log management component 113. For example, controller 115 may include a processor 117 (processing device) that is configured to execute instructions stored in local memory 119 for performing the operations described herein. In some embodiments, event log management component 113 is part of host system 120, an application, or an operating system.

[0026] The event log management component 113 can scan and analyze event logs associated with the memory subsystem. The event logs can be stored in a storage location that is subject to a wraparound process. In one embodiment, the event log management component 113 identifies a set of log entries in the event log that represent a pattern of event log entries. In one embodiment, the event log management component 113 generates a log entry definition corresponding to the identified pattern of log entries. The log entry definition can include multiple data fields representing the pattern, wherein the data fields are populated with summary data corresponding to the set of log entries in the pattern.

[0027] In an embodiment, the event log management component 113 determines the data type of each field of the set of log entries in the pattern. In an embodiment, the event log management component 113 identifies the data in each of the data fields as one of the following data types: a linearly varying data type, a non-linearly varying data type, and a non-numeric data type. In an embodiment, based on the data type identified for each data field, the event log management component 113 generates summary data. The event log management component 113 generates a summary log entry that includes a log entry definition populated with the summary data. The summary log entry is stored in an event log that is not subject to the wrapping process (e.g., a different event log and storage location than the storage location that is subject to the wrapping process). In an embodiment, the pattern of the log entry identified in the storage location that is subject to the wrapping process is deleted, thereby creating additional storage space for other event log entries.

[0028] According to an embodiment, generating summary log entries and storing the summary log entries in a non-wrapping storage location enables the preservation of event information representing the history and operation of the memory subsystem. In an embodiment, preserving the additional event information and preventing information wrapping produces a more robust historical representation of the performance of the memory subsystem for debugging and identifying design improvements. Further details regarding the operation of the event log management component 113 are described below.

[0029] Figure 2 An example method 200 for managing log entries of an event log (i.e., a first event log) that is subject to a wrap-around process is described according to some embodiments of the present disclosure. The method 200 may be performed by processing logic that may include hardware (e.g., a processing device, circuitry, 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 200 is performed by Figure 1 The event log management component 113 executes the following steps. Although shown in a specific sequence or order, the order of the processes may be modified unless otherwise specified. Therefore, the illustrated embodiments should be understood as examples only, 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.

[0030] As shown, at operation 210, processing logic determines a set of log entries stored in a first event log associated with the memory subsystem that is subject to a wrap process. In an embodiment, the first event log is configured to store a plurality of log entries corresponding to respective events associated with the memory subsystem. The first event log is subject to a wrap process such that the first event log is repeatedly wrapped (e.g., first-in entries are deleted and replaced with newest entries). In an embodiment, the wrap process may be performed in response to the available storage capacity of the first event log reaching a threshold amount of the total available storage capacity (i.e., a wrap threshold) that triggers the wrap process. For example, the first event log may be configured to wrap when the wrap threshold is met (e.g., the wrap process is performed in response to the available storage space reaching 10% of the total storage capacity).

[0031] In an embodiment, each log entry includes a plurality of data fields containing corresponding data. For example, a log entry may include: an event number field containing a monotonically increasing numeric value; an event identifier field containing a numeric description of the event; a power cycle count containing a count of the number of times the memory subsystem has been powered on at the time of the log entry; a timestamp field containing the time elapsed since the memory subsystem was powered on; an event type field containing a category of the event (e.g., significant event, general event, etc.); and a data byte length field containing the number of bytes used for the log entry in the corresponding event log storage location.

[0032] In an embodiment, method 200 may be executed before executing a wrap process on the first event log. In an embodiment, one or more operations of method 200 may be scheduled for execution in response to reaching a certain threshold of available storage space of the first event log (i.e., an available storage capacity threshold) that is greater than a wrap threshold. For example, the wrap process may be scheduled to initiate the first event log when the available storage space of the first event log reaches 10% (i.e., the wrap threshold). In this example, method 200 may be scheduled for execution when the available storage space of the first event log reaches 15% of the available storage capacity threshold. In an embodiment, the available storage capacity threshold is set to a value greater than the wrap threshold to avoid executing a wrap process on the first event log and the corresponding loss of one or more advanced log entries.

[0033] At operation 220, processing logic determines a pattern for the log entries in the set of log entries. In an embodiment, processing logic may maintain a collection or library of defined patterns. The log entries in the set of log entries may be scanned, analyzed, and compared to the defined patterns to identify matches. In an embodiment, processing logic may generate or produce a pattern based on the scan of the set of log entries. In this example, the generated pattern may be added to the library of defined patterns for subsequent scanning of the event log. In an embodiment, one or more data fields of the set of log entries may be placed in a buffer during the scan for comparison with subsequent log entries to determine whether duplication occurs in one or more data fields. For example, event description data fields and corresponding data may be checked and stored in a buffer for each set of log entries. Processing logic may review the buffer to determine whether a pattern exists in a series of event description data and identify the pattern of the log entries.

[0034] At operation 230, processing logic generates a log entry definition corresponding to a pattern of log entries. In an embodiment, the log entry definition includes multiple data fields corresponding to the log entry associated with the identified pattern. For example, the log entry definition may include all or a portion of the data fields of the corresponding log entry in the pattern. In an embodiment, processing logic determines the type of pattern associated with the identified pattern. For example, the identified pattern may be a group entry pattern that includes multiple consecutive log entries that appear as a group (e.g., a repeating ordered sequence of events). An example group entry pattern may include a collection of events corresponding to a power reserve routine. In another example, the identified pattern may be a single entry pattern that includes a single log entry that is repeated multiple times (e.g., continuously), where each repeated log entry does not add additional useful information. For example, certain data fields may be identified as containing "useful" information and processing logic may identify multiple log entries that have the same data in those data fields (e.g., predetermined data fields such as the event description field).

[0035] In an embodiment, the log entry definition includes a pattern description field to include a description of the pattern and / or an identification of the pattern type (e.g., group entry pattern type A, group entry pattern type B, group entry pattern type N, single entry pattern type X, single entry pattern type Y, etc.). In an embodiment, generating the log entry definition may include discarding or deleting one or more data fields included in a plurality of log entries for the identified pattern. For example, processing logic may identify one or more data fields of a set of log entries for the pattern that are associated with unused data, which unused data may be removed or discarded from the log entry definition representing the identified pattern.

[0036] At operation 240, processing logic generates summary data corresponding to the pattern of log entries. In an embodiment, the summary data is a summary or compressed representation of the data of the pattern of log entries. In an embodiment, the summary data may be generated based on an identification of a data type associated with data in a data field of the pattern of log entries. For example, the pattern of log entries may include five log entries representing a group entry pattern. Each of the five log entries includes a plurality of data fields that include corresponding event data. In this example, the summary data compresses or aggregates the event data of the five log entries so that the event data of the pattern can be captured and represented in the summary data, thereby using significantly less storage capacity.

[0037] At operation 250, processing logic generates a summary log entry containing the summary data. In an embodiment, the summary log entry is based on a log entry definition and corresponding data fields. In an embodiment, the data fields of the log entry definition are populated with the summary data to form the summary log entry.

[0038] At operation 260, processing logic stores the summary log entry in a second event log that is not subject to the wrap process. In an embodiment, the second event log is a storage location independent of the first event log (ie, an event log that is subject to the wrap process).

[0039] At operation 270, processing logic deletes the first pattern of log entries from the first event log. In an embodiment, deleting the pattern of log entries and corresponding data creates additional storage space in the first event log. In an embodiment, removing log entries corresponding to the identified pattern increases the amount of available space relative to a wrap threshold for triggering a wrap process.

[0040] Figure 3 An example method 300 is described for generating a summary log entry corresponding to a pattern of log entries identified in a first event log that is subject to a wrap-around process, according to some embodiments of the present disclosure. The method 300 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, the method 300 is performed by Figure 1 The event log management component 113 executes the following steps. Although shown in a specific sequence or order, the order of the processes may be modified unless otherwise specified. Therefore, the illustrated embodiments should be understood as examples only, 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.

[0041] At operation 310, processing logic determines data fields of a pattern of event log entries corresponding to the log entry definition. As described above, the pattern of the event log entry can be a single entry pattern or a group entry pattern corresponding to the log entry definition. In an embodiment, the single entry pattern includes multiple log entries corresponding to the same or a single repeating log entry, wherein each repeating log entry does not add useful event information relative to the other log entries in the repeating pattern. In an embodiment, the multiple log entries in the single entry pattern include identical data in one or more of the data fields (e.g., an event identifier field and an event description field). In an embodiment, the data in certain data fields of the multiple log entries in the single entry pattern are different, such as event numbers, timestamps, power cycle counts, etc. In an embodiment, the data fields may be identified based on each unique event identifier for each event log entry. In an embodiment, the data fields may be identified based on each unique event identifier for each event log entry. In an embodiment, the data fields may be identified based on each unique event identifier for each event log entry by processing logic (e.g., Figure 1The event log management component 113 may maintain a table or other data structure. In an embodiment, multiple event entries may share one or more data fields. In an embodiment, the corresponding data fields of the log entry are determined by the processing logic using the event identifier and may be used to aggregate the determined data fields to store the data contained therein, as described in detail below.

[0042] At operation 320, processing logic determines a data type for each of the data fields. In an embodiment, each of the data fields is identified as one of the following data types: a linearly varying data type, a non-linearly varying data type, or a non-numeric data type. In an embodiment, additional data types may be identified and the data fields may be scanned to determine the associated data type for each of the data fields. In an embodiment, the data type for each event is determined based on an event identifier associated with the event entry. In an embodiment, the data type for each event may be stored in a memory in the processing logic (e.g., Figure 1 The event log management component 113 may be stored in a memory of the event log management component 113 or may be accessed by the processing logic.

[0043] At operation 330, processing logic performs a summarization action on each of the data fields based on the corresponding data type to generate summary data. In one embodiment, the summarization action comprises a method or means for summarizing the data associated with the corresponding data field and generating summary data representing the data field of multiple log entries in the pattern. In one embodiment, for a data field comprising linearly varying data (i.e., a linearly varying data type), the summarization action may comprise determining the rate of change of a data variable associated with the data field. In one embodiment, the summarization action comprises summarizing the data in the linearly varying data field using a starting value, a step size, and an ending value. For example, the event number data field may comprise a monotonically increasing numerical value. For a pattern comprising multiple log entries (e.g., five log entries), the summarization action compresses or sums the data in the event number data fields of the five log entries to generate summary data (e.g., [event number 0 (starting value), 1 (step size), event number 4 (ending value)]).

[0044] In an example, for a data field containing nonlinearly varying data (i.e., a nonlinearly varying data type), the aggregation action includes performing a statistical analysis of the data to determine how the data varies in a variable. In an embodiment, the aggregation action may include identifying one or more of a geometric mean, a harmonic mean, or a standard mean of the data. In an embodiment, the aggregation action may include any suitable statistical analysis technique to evaluate the data of the nonlinearly varying data field and generate aggregated data (e.g., a geometric mean, a harmonic mean, or a standard mean of the data in the data field of multiple log entries of a pattern). For example, a temperature data field (i.e., a data field indicating the temperature of the memory subsystem at the time of the event log entry) is a nonlinearly varying data field containing data that may vary nonlinearly over time (e.g., a temperature data field). Figure 5A ).

[0045] In an example, for a data field containing non-numeric data (i.e., a non-numeric data type), the aggregation action includes listing all unique data values ​​in the order in which the log entries in the pattern appear. For example, for a firmware version (FWVer) field containing a non-numeric data value (e.g., Figure 5A ), identifying all changes in data values ​​that occur during a time period associated with a set of log entries for a pattern to generate firmware change values ​​(e.g., 0, 1, 2, etc.) as summary data of the firmware version data fields of multiple log entries for the pattern.

[0046] At operation 340, processing logic generates an aggregated log entry that includes aggregated data populated from a set of data fields defined by the log entry. In an embodiment, the data fields that are aggregated as part of the aggregated log entry are determined based on an event identifier corresponding to each event entry. In an embodiment, the aggregated log entry includes aggregated data for multiple log entries corresponding to a pattern. In an embodiment, the aggregated log entry is a single log entry configured to represent multiple log entries, thereby consuming a smaller amount of storage space in the event log than multiple different log entries for the pattern. In an embodiment, the aggregated log entry may discard or delete one or more data fields of the multiple log entries for the pattern. In an embodiment, the multiple data fields of the aggregated log entry may be determined based on an event identifier corresponding to the pattern of the log entry. For example, after determining the pattern of the event entry, the event identifier associated with the pattern may be determined, and the event identifier may be used to determine the data fields of the aggregated log entry.

[0047] In an embodiment, one or more data fields may be identified as irrelevant or redundant (e.g., extracted from a portion of the summary data set forth in another data field). In such cases, the data fields may be removed when generating the summary log entry. For example, a timestamp value field containing irrelevant information may be deleted and replaced with a timestamp range and corresponding summary data representing the timestamp range for the set of log entries in the pattern. In an embodiment, a summary log entry may have one or more additional data fields added to it compared to multiple log entries of a pattern. In an embodiment, a data field may be added to a summary log entry to include summary data that is not present in a data field in the log entry's pattern. For example, a separate log entry of a pattern may include a temperature value data field instead of a temperature range. The summary data may include a new data element indicating the temperature range of the multiple log entries in the pattern, and a new data field is added to the summary log entry to include the new summary data (e.g., temperature range data). In an embodiment, the summary log entry may include a description field that may include a pattern group type identifier and a unique description of the associated pattern of the log entry (e.g., pattern group type X / power reserve routine; pattern group type Y / NAND read error handling). In an embodiment, as described above with respect to Figure 2 As described, aggregated log entries may be stored in an event log that is not subject to a wraparound process, thereby preserving event information corresponding to multiple log entries of a pattern in an aggregated format.

[0048] Figure 4 An example of an event log management component 413 managing log entries of a first event log that is subject to a wraparound process 405 is shown in accordance with some embodiments of the present disclosure. In an embodiment, the event log management component 413 identifies a pattern of log entries 410 stored in the first event log 405. The event log management component 410 identifies a data type (e.g., a first data type 430A, a second data type 430B, a third data type 430C) for each of a plurality of log entries' data fields 420 (e.g., data field 1, data field 2, data field 3, data field 4, and data field N) in the pattern of log entries 410. In an embodiment, the event log management component 413 determines the data type of the data field based on an event identifier associated with the event entry.

[0049] In an embodiment, event log management component 413 generates a summary log entry 450 that represents the pattern of log entry 410. In an embodiment, the summary log entry contains data fields (e.g., data field 1, data field 2, data field 3, data field 5, and data field N) populated with summary data 460A, 460B, 460C. Figure 4In the example shown in , when generating the summary log entry 450, the event log management component 413 discards the data field of the log entry's pattern (i.e., data field 4 of the pattern of the log entry 410) and adds a new data field (i.e., data field 5 of the summary log entry 450). In an embodiment, the summary data is generated based on the corresponding data types (e.g., the first data type, the second data type, the third data type) of the corresponding data fields, as described above with respect to Figure 2 and 3 Describe in detail.

[0050] In an embodiment, the event log management component 413 stores the summarized log entries in a second event log that is not subject to the wrap-around process 440. In an embodiment, the event log management component 413 deletes a pattern of log entries 410 from the first event log 405 to create additional free storage space in the first event log 405. In an embodiment, the summarized log entries 450 are preserved and increase the amount of useful information related to the memory subsystem, which can be analyzed for debugging purposes or to identify design improvements.

[0051] Figure 5A An example event log stored in a first storage location that is subject to a wraparound process is described in accordance with some embodiments of the present disclosure. In the example, a plurality of event log entries comprising a plurality of data fields are stored in the event log. In an embodiment, a pattern is identified for log entry 510A. In an embodiment, a pattern identification process may be recursively applied to identify pattern 510A as a group entry pattern of a first pattern group type (e.g., pattern group type 2b) comprising six log entries repeated multiple times in an ordered sequence. In an embodiment, pattern 510A may be summarized in a summary log entry 550A, such as Figure 5B In an embodiment, pattern 510A may be identified as part of a larger group of entry patterns 510B of a second pattern group type (e.g., pattern group type 2c). In an embodiment, the entire pattern of entry 510B may be aggregated into aggregate log entry 550B, as shown in FIG. Figure 5C As shown in .

[0052] In this example, the first instance of the pattern 510A observed by the processing logic includes event numbers for event #1 through event #6. In this example, the pattern 510A includes a plurality of data fields, including an event identifier field, an event number field, a firmware version field, a power cycle count field, a temperature field, a data length field, a timestamp identifier field, a timestamp value field, a program / erase (PE) cycle count field, and an event description field.

[0053] Figure 5B 5. The following illustrates a summary log entry 550A generated to represent the schema 510A according to some embodiments of the present disclosure. Figure 5B As shown in , summary log entry 550A includes a plurality of data fields containing summary data based on the data of identified pattern 510A. In this example, summary log entry 550A includes: an event identifier field containing a new event identifier defined for the identified pattern; an event number containing a starting event number (e.g., event #1); an event number range containing values ​​for a range of event numbers in the summary pattern (e.g., event #1 - event #6 = 0x05); a firmware version field containing the firmware value at the last event in the pattern (e.g., FWVer value 1); a temperature field containing the temperature value at the last event in the pattern; a temperature range field containing the magnitude of the (highest - lowest) temperature in the pattern; a data length field containing the highest value in the pattern; a timestamp field containing the timestamp value of the last event in the pattern; a timestamp range field containing the magnitude of the (highest - lowest) timestamp in the pattern (i.e., the amount of elapsed time); and a PE cycles field containing the highest PE cycle value in the pattern (i.e., the PE cycle value of the last entry in the pattern, since such values ​​are monotonically increasing values).

[0054] like Figure 5B As shown in , certain data fields that are not present in the identified pattern of log entry 510A (e.g., event number range field, FWVer change field, temperature range field, and timestamp range field) may be added to summary log entry 550A along with corresponding data. In embodiments, data from log entries (e.g., Figure 5A One or more data fields (e.g., timestamp fields) of the identified pattern. Figure 5B As shown in the example of , summary log entry 550A includes summary data in the data fields of the log entry definition corresponding to identified pattern 510A, including an indication of the description field of the group entry pattern type (e.g., pattern group type 2b) of pattern 510A.

[0055] Figure 5C 5B illustrates a summary log entry 550B generated by an event log management component according to some embodiments of the present disclosure. Figure 5C As shown in , certain data fields that are not present in the identified pattern of log entry 510B (e.g., event number range field, FWVer change field, temperature range field, and timestamp range field) may be added to summary log entry 550A along with corresponding data. In embodiments, data from log entries (e.g., Figure 5A One or more data fields (e.g., timestamp fields) of the identified pattern. Figure 5CAs shown in the example of , summary log entry 550B includes summary data in the data fields of the log entry definition corresponding to identified pattern 510B, including an indication of the description field of the group entry pattern type (e.g., pattern group type 2c) of pattern 510B.

[0056] In an embodiment, log entry definitions may be stored and matched against the patterns of log entries 510A, 510B to generate corresponding aggregated log entries 550A and 550B. In another embodiment, log entry definitions may be generated based on the pattern type and data field type (e.g., if an existing log entry definition does not match the identified pattern), as described above with respect to Figure 2 and 3 Describe in detail. Figure 5B As shown in , the summary log entry 550A includes a description data field that includes data describing the identified pattern (e.g., pattern group type / pattern description). In an embodiment, the identified pattern description and the generated log entry definition can be added to the library as part of a firmware update for the memory subsystem.

[0057] Figure 6A An example event log stored in a first storage location that is subject to a wrap-around process according to some embodiments of the present disclosure is illustrated. The event log may include an example single entry pattern 610. In this example, the single entry pattern represents a plurality of consecutive event log entries that include at least a portion of repeating data (e.g., an event identifier (associated with an event description), power cycle, temperature, data length, and data in PE cycles). Figure 6B Description generated as representation Figure 6A An example of single entry mode aggregates log entries 650. Figure 6B As shown in , the description field contains data describing the pattern type (e.g., pattern type 3) associated with the identified pattern 610. As described above, the summary log entry 650 may drop one or more data fields (e.g., a timestamp value field, a temperature field, etc.) of the log entry for the identified pattern, and may add one or more fields (e.g., a FWVer change field, a temperature range field, a timestamp range field, etc.) that are not present in the log entry for the identified pattern.

[0058] Figure 7 An example machine illustrating a computer system 700 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 700 may correspond to a host system (e.g., Figure 1 ) that includes, is coupled to, or uses a memory subsystem (e.g., Figure 1 The memory subsystem 110 of FIG. 110 may be used to perform operations of the controller (eg, to execute an operating system to execute operations corresponding to the Figure 1 In some embodiments, the machine may be connected (e.g., using a network) to other machines. The machine may operate in the capacity of a server or a client machine in a client-server network environment, or as 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.

[0059] 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. Further, while a single machine is described, the term "machine" shall also be taken 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.

[0060] The example computer system 700 includes a processing device 702, a main memory 704 (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 706 (e.g., flash memory, static random access memory (SRAM), etc.), and a data storage system 718, which communicate with each other via a bus 730.

[0061] Processing device 702 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 another instruction set, or a combination of instruction sets. Processing device 702 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. Processing device 702 is configured to execute instructions 726 for performing the operations and steps discussed herein. Computer system 700 may further include a network interface device 708 for communicating over a network 720.

[0062] The data storage system 718 may include a machine-readable storage medium 724 (also referred to as a computer-readable medium) having stored thereon one or more sets of instructions 726 or software embodying any one or more of the methodologies or functions described herein. The instructions 726 may also reside, completely or at least partially, within the main memory 704 and / or within the processing device 702 during execution thereof by the computer system 700, the main memory 704 and the processing device 702 also constituting machine-readable storage media. The machine-readable storage medium 724, the data storage system 718, and / or the main memory 704 may correspond to Figure 1 Memory subsystem 110.

[0063] In one embodiment, instructions 726 include instructions for implementing instructions corresponding to an event log management component (e.g., Figure 1 The event log management component 113 of the present disclosure may be used to store instructions for the functions of the event log management component 113. Although the machine-readable storage medium 724 is shown as a single medium in the example embodiment, the term "machine-readable storage medium" should be considered to include a single medium or multiple media that store one or more sets of instructions. The term "machine-readable storage medium" should also be considered to include any medium that can store or encode a set of instructions for execution by a machine and cause 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 be limited to, solid-state memory, optical media, and magnetic media.

[0064] 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 others skilled in the art. An algorithm is here, and generally, considered to be a self-consistent sequence of operations that leads to a desired result. An operation is one that requires physical manipulation of physical quantities. These quantities are typically, but not necessarily, 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 common usage, to refer to these signals as bits, values, elements, symbols, characters, terms, numbers, or the like.

[0065] It should be borne in mind, however, that all of these and similar terms are to 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 a 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.

[0066] 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 on 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 memory (ROM), random access memory (RAM), EPROM, EEPROM, magnetic or optical cards, or any type of medium suitable for storing electronic instructions, each coupled to a computer system bus.

[0067] The algorithms and displays presented herein are not inherently related to any particular computer or other device. Various general-purpose systems may be used with programs according to the teachings herein, or it may prove convenient to construct more specialized devices for performing the methods. The structures of a variety of these systems will be presented as set forth in the description below. Additionally, the present disclosure is not described with reference to any particular programming language. It will be appreciated that the teachings of the present disclosure as described herein may be implemented using a variety of programming languages.

[0068] 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., computer-readable) medium includes a machine (e.g., 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, or the like.

[0069] 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 the embodiments of the present disclosure as set forth in the appended claims. Accordingly, the description and drawings are to be regarded in an illustrative rather than a restrictive sense.

Claims

1. A method for a memory subsystem, the method comprising: determining, by a processing device, a set of log entries stored in a first event log associated with the memory subsystem that is subject to a wrap process; determining a pattern of log entries in the set of log entries; generating a log entry definition corresponding to a schema of the log entry, the log entry definition comprising a plurality of data fields; generating summary data corresponding to the pattern of the log entries; generating a summary log entry including the summary data, wherein the summary log entry includes the plurality of data fields including the summary data; storing the aggregated log entry in a second event log that is not subject to the wrap process, wherein the aggregated log entry is preserved from deletion via the wrap process associated with the first event log; and A mode for deleting the log entry from the first event log by performing the wrap-around procedure with respect to the first event log.

2. The method according to claim 1, further comprising: determining a data type of a data field of a log entry of a pattern of the log entry based on an event identifier associated with the log entry, wherein the data type is one of a linearly varying data type, a non-linearly varying data type, or a non-numeric data type; and An aggregation action is performed on the data field based on the data type. 3 . The method of claim 1 , further comprising determining a pattern type of the pattern of the log entry, wherein the pattern type is one of a single entry pattern or a group entry pattern.

4. The method according to claim 1, further comprising: A data field is added to the log entry definition to include first summary data associated with another data field of the schema of the log entry, wherein the data field is not present in the schema of the log entry.

5. The method according to claim 1, further comprising: Determining data fields of the log entry's pattern that are discarded when generating the log entry definition, wherein the discarded data fields include data represented by a portion of the summarized data.

6. The method according to claim 1, further comprising: Determining whether an amount of available storage capacity of the first event log satisfies an available storage capacity threshold, wherein the mode of deleting the log entries from the first event log is responsive to determining that the amount of available storage capacity of the first event log does not satisfy the available storage capacity threshold.

7. The method according to claim 6, further comprising: The available storage capacity threshold is established based on a wrap threshold associated with the first event log.

8. A memory subsystem comprising: Memory components; and a processing device operatively coupled to the memory component to perform the following operations: determining a pattern of a plurality of event log entries of a first event log, the pattern corresponding to a log entry definition, the log entry definition comprising a plurality of data fields; determining a data type for each of the plurality of data fields; performing a summary action on each of the plurality of data fields based on a corresponding data type to generate summary data; generating a summary log entry comprising said summary data populated in a set of data fields defined by said log entry, storing the aggregated log entry in a second event log, wherein the second event log is not subject to a wrap-around process, wherein the aggregated log entry is preserved from being deleted via the wrap-around process associated with the first event log; and The mode of deleting the event log entry from the first event log by performing the wrap-around process with respect to the first event log.

9. The memory subsystem of claim 8, wherein to generate the aggregation action, the processing device further determines a rate of change of data corresponding to a linearly varying data type.

10. The memory subsystem of claim 8, wherein to generate the aggregation action, the processing device further determines one or more of a geometric mean, a harmonic mean, or a standard mean of data corresponding to the non-linearly varying data type.

11. The memory subsystem of claim 8, wherein to generate the summary action, the processing device further lists one or more data values ​​in an order in which the non-numeric data types appear.

12. The memory subsystem according to claim 8, wherein the processing device further performs the following operations: A plurality of event log entries of a first event log is scanned to identify a pattern of the event log entries, wherein the first event log is subject to the wrapping process.

13. A non-transitory computer-readable medium comprising instructions that, when executed by a processing device, cause the processing device to perform operations comprising: determining a set of log entries stored in a first event log associated with a memory subsystem that is subject to a wrap process; determining a pattern of log entries in the set of log entries; generating a log entry definition corresponding to a schema of the log entry, the log entry definition comprising a plurality of data fields; generating summary data corresponding to the pattern of the log entries; generating a summary log entry including the summary data, wherein the summary log entry includes the plurality of data fields including the summary data; storing the aggregated log entry in a second event log that is not subject to the wrap process, wherein the aggregated log entry is preserved from deletion via the wrap process associated with the first event log; and A mode for deleting the log entry from the first event log by performing the wrap-around procedure with respect to the first event log.

14. The non-transitory computer-readable medium of claim 13, the operations further comprising: determining a data type of a data field of a log entry of a pattern of the log entry based on an event identifier associated with the log entry, wherein the data type is one of a linearly varying data type, a non-linearly varying data type, or a non-numeric data type; and An aggregation action is performed on the data field based on the data type.

15. The non-transitory computer-readable medium of claim 13, the operations further comprising: A pattern type of the pattern of the log entry is determined, wherein the pattern type is one of a single entry pattern or a group entry pattern.

16. The non-transitory computer-readable medium of claim 13, the operations further comprising: A data field is added to the log entry definition to include first summary data associated with another data field of the schema of the log entry, wherein the data field is not present in the schema of the log entry.

17. The non-transitory computer-readable medium of claim 13, the operations further comprising: Determining data fields of the log entry's pattern that are discarded when generating the log entry definition, wherein the discarded data fields include data represented by a portion of the summarized data.

18. The non-transitory computer-readable medium of claim 13, the operations further comprising: A determination is made that an amount of available storage capacity of the first event log satisfies an available storage capacity threshold, wherein the available storage capacity threshold is established based on a wraparound threshold associated with the first event log.

Images