Non-volatile memory storage device simulation platform
By building a simulation platform and using simulation entities and kernel engines to perform logical relationships and message propagation of storage devices, the problem of long simulation time in existing memory systems is solved, and fast and efficient performance prediction and debugging are achieved.
Patent Information
- Application Number
- CN202211001184.4
- Authority / Receiving Office
- CN · China
- Patent Type
- Patents(China)
- Current Assignee / Owner
- Priority Date
- 2022-03-24
- Filing Date
- 2022-08-19
- Publication Date
- 2026-11-10
- Estimated Expiration
- 2042-08-19
AI Technical Summary
Existing memory system simulators are time-consuming and resource-intensive during product development, making it difficult to meet the needs of rapid debugging and performance prediction.
A simulation platform is provided, including a simulation entity, a relation manager processor, and a simulation kernel engine, which simulates storage devices through logical relationships and message propagation, and supports flexible component configuration and rapid testing.
It reduces memory system debugging time, improves simulation efficiency, enables accurate performance prediction and FW algorithm debugging at different stages, and supports testing of different versions.
Smart Images

Figure CN116841838B_ABST
Abstract
Description
Technical Field
[0001] Embodiments of this disclosure relate to a platform for storage device emulation. Background Technology
[0002] The computing environment paradigm has shifted to ubiquitous computing systems that can be used anytime, anywhere. Consequently, the use of portable electronic devices such as mobile phones, digital cameras, and laptops has increased rapidly. These portable electronic devices typically use memory systems with storage devices, or data storage devices. The data storage device serves as either the main memory or auxiliary memory in the portable electronic device.
[0003] Because memory devices have no moving parts, memory systems using them offer excellent stability and durability, high data access speeds, and low power consumption. Examples of memory systems with these advantages include Universal Serial Bus (USB) memory devices, memory cards with various interfaces such as Universal Flash Memory (UFS), and solid-state drives (SSDs). Memory systems can be tested using a variety of testing tools, including emulation tools. Summary of the Invention
[0004] In one aspect, the present invention provides a simulation system comprising: a set of simulation entities (SEs), including a host SE and a storage component SE corresponding to the hardware and software components of a storage device to be simulated; a relation manager processor configured to determine logical relationships between SEs selected from the set of SEs; and a simulation kernel engine configured to perform simulation using the selected SEs. Sequential messages are propagated among the selected SEs and to the simulation kernel engine, the sequential messages determining whether simulation conditions are complete.
[0005] In another aspect of the invention, a method for simulating a storage device is provided. The method provides a set of simulation entities (SEs) including a host SE and storage components SEs corresponding to the hardware and software components of the storage device to be simulated; selecting SEs from the set of SEs; determining logical relationships between the selected SEs; propagating sequence messages between the selected SEs and to a simulation kernel engine; and performing simulation using the selected SEs, wherein the sequence messages determine whether simulation conditions are complete.
[0006] Other aspects of the invention will become apparent from the following description. Attached Figure Description
[0007] Figure 1 This is a block diagram illustrating a simulation system that optionally communicates with a memory system according to an embodiment of the present invention.
[0008] Figure 2This is a circuit diagram illustrating a memory block of a memory device according to another embodiment of the present invention.
[0009] Figure 3 This is a diagram illustrating the state distribution of different types of cells in a memory device according to an embodiment of the present invention.
[0010] Figure 4 This is a diagram illustrating an independent simulation platform according to another embodiment of the present invention.
[0011] Figure 5 This is a sequence diagram according to yet another embodiment of the present invention.
[0012] Figure 6 This is a diagram illustrating the main loop of the simulated kernel.
[0013] Figure 7A This is a diagram illustrating the construction of a diagram showing the logical relationships between different simulated entities according to another embodiment of the present invention.
[0014] Figure 7B This is a diagram showing another chart for a specific simulation modification.
[0015] Figure 8 It is a timing diagram.
[0016] Figure 9 This is a diagram illustrating a simulation operation according to another embodiment of the present invention. Detailed Implementation
[0017] Various embodiments of the invention are described in more detail below with reference to the accompanying drawings. However, the invention may be embodied in different forms and should not be construed as limited to the embodiments set forth herein. Rather, these embodiments are provided so that this disclosure will convey the scope of the invention to those skilled in the art. Furthermore, references herein to “embodiment,” “another embodiment,” etc., are not necessarily directed to only one embodiment, and different references to any such phrases are not necessarily directed to the same embodiment. The term “embodiment” as used herein does not necessarily refer to all embodiments. Throughout this disclosure, the same reference numerals refer to the same parts in the drawings and embodiments of the invention.
[0018] This invention can be embodied in a variety of ways, including as a process; an apparatus; a system; a computer program product implemented on a computer-readable storage medium; and / or a processor, such as a processor adapted to execute instructions stored in and / or provided by memory linked to the processor. In this specification, these embodiments or any other form in which the invention may take place can be referred to as technology. Generally, the order of operation of the disclosed processes can be varied within the scope of this invention. Unless otherwise stated, components such as processors or memory described as suitable for performing a task can be implemented as general-purpose means or circuit components configured or otherwise programmed to perform the task at a given time, or as specific means or circuit components manufactured to perform the task. As used herein, the term "processor," etc., refers to one or more means, circuits, and / or processing cores adapted to process data such as computer program instructions.
[0019] The methods, processes, and / or operations described herein can be executed by code or instructions to be run by a computer, processor, controller, or other signal processing device. The computer, processor, controller, or other signal processing device can be the computer, processor, controller, or other signal processing device described herein or an element other than those described herein. Because the algorithms that form the basis of the methods (or the operation of the computer, processor, controller, or other signal processing device) are described herein, the code or instructions for implementing the operations of the method embodiments can convert a computer, processor, controller, or other signal processing device into a dedicated processor for performing the methods herein.
[0020] When implemented in software, the memory (or other storage device), controller, processor, device, module, unit, multiplexer, generator, logic circuit, interface, decoder, driver, generator, and other signal generators and signal processors shown in the figures (unless otherwise indicated) include simulation entities (i.e., software code) that simulate the activities and behavior of those components. Because this invention relates to software simulation, although (in one embodiment) the input parameters used for simulation can be provided by actual hardware devices, no actual hardware is required. Therefore, the system components depicted in the figures refer to portions of program code used for simulation. For example, to estimate the performance of a solid-state drive (SSD), a software-based model of a specific component of the SSD (memory, CPU, firmware, host controller, or even operating system) can be created. Such a model simulates the activities of a specified component. That is, in one embodiment of the invention, the model studies the effect of parameter variations on the characteristics / metrics (e.g., performance or power consumption) of the simulated component. For more detailed simulations, the component can be represented by more SEs to more accurately simulate these processes. The software model does not require actual (physical) devices to operate.
[0021] The following provides a detailed description of embodiments of the invention, along with accompanying drawings illustrating aspects of the invention. The invention is described in conjunction with these embodiments, but is not limited to any particular embodiment. The invention includes many alternatives, modifications, and equivalents. Numerous specific details are set forth in the following description to provide a thorough understanding of the invention. These details are provided for illustrative purposes; the invention may be practiced without some or all of these specific details, as described in the claims. For clarity, known technical materials in the art related to the invention have not been described in detail so as not to unnecessarily obscure the invention.
[0022] For example, non-volatile memory storage devices based on NAND flash memory (e.g., SSDs) are complex systems involving the interaction of hardware (HW) and firmware (FW). The final characteristics of the storage device (e.g., performance (latency and throughput), reliability, etc.) depend on the designed HW components, the implemented FW algorithms, and their parameters. Given the changing needs of customers and target workloads, storage device debugging is becoming an important part of the product development process.
[0023] Debugging actual storage devices adds considerable time and resources to the development process, especially at the end of the drive's lifespan. One possible solution to reduce this overhead is to use simulation models of the storage device, for example, for hypothesis analysis, debugging, bottleneck searching, and algorithm verification. In theory, simulation should reduce the time required to "debug" storage device prototypes and provide a cost-effective solution for predicting storage device characteristics and validating FW algorithms and prototype changes.
[0024] Since both the HW and FW layers are contributing factors to the characteristics of the storage device, in one embodiment of the present invention, the HW and FW components can be simulated not only in the early stages of product development and design, but also in the later stages of product design, to find weaknesses and improvements in the FW algorithm. Furthermore, the HW and FW components can be used with measurements from the actual product to debug simulation settings and / or discover potential performance issues, especially during product development.
[0025] Hardware and firmware components
[0026] Figure 1 This is a block diagram illustrating a simulation platform 15 according to an embodiment of the present invention. (Refer to...) Figure 1 The simulation platform 15 (optional but not mandatory) communicates with the components of the memory system 10, as shown by the dashed lines extending from the simulation platform 15 to the respective device components. Alternatively, the simulation platform 15 can be as follows: Figure 4 The separate, independent software platform shown can... Figure 1 The performance of the device shown is modeled.
[0027] Typically, simulation platform 15 utilizes a computer program to provide computer simulation that models the behavior of a physical system (e.g., a storage device) over time. For example, a simulation in one embodiment of the invention may model a read threshold voltage over time, or it may model how long the memory system 10 requires garbage collection. Program variables (state variables) represent the current or initial state of the physical system at the start of the simulation. For example, a simulation in one embodiment of the invention may have program variables representing the number of memory blocks or buffers available for reading and writing data. The simulation program typically modifies state variables to predict the evolution of the physical system over time. In one embodiment of the invention, the simulation SE is program code representing a mathematical algorithm for the functionality of the object of interest, executed by a kernel simulator. Various simulation entities used in the invention are detailed below. Attributes of the simulation entity (e.g., memory size or memory type) may be included in the model definition of the SE. The activities of one or more SEs may be simulated.
[0028] The simulation platform 15 has several attributes. During simulation execution, the simulation is preferably faster and simpler than the actual operation performed on a real semiconductor memory system. Regarding scalability, any simulation hardware / firmware component can preferably be added / removed or replaced with another version without affecting other simulation components. In this respect, the SEs are independent of each other, allowing them to interact with each other. This scalability allows the simulation platform 15 to support different products and accurately test different versions of the firmware algorithm. Regarding configurability, the values of any simulation HW / FW component parameters are changeable before running the simulation. This configurability allows the memory drive to be debugged for specific requirements.
[0029] The present invention is based on the recognition that existing simulators such as MQSim and Amber are based on holistic simulation (or on very detailed simulation for a specific purpose) and are either too detailed or too simple to meet the above preferences, and therefore have limited applicability, especially for metric estimation based on product development needs.
[0030] In the following description, the properties and activities of a simulation platform 15, which serves as a software-based engine for simulating the operation of components in a semiconductor memory system, will be described in detail. These properties and activities reflect the properties and activities of a simulation entity SE of a real device, such as the memory system 10 involved in the simulation. Because the simulation entity simulates performance related to the behavior of specific components, a description of the functionality of the memory system 10 (and its constituent components) is provided below, and the process by which the SE (in one embodiment of the invention) evaluates performance characteristics that affect (or may affect) those components will be understood.
[0031] The memory system 10, as the memory system SE, can be implemented using any of a variety of storage devices such as solid-state drives (SSDs) and memory cards. In various embodiments, in the simulation of the memory system 10, the memory system 10 can be one of a variety of components among electronic devices such as: computers, ultra-mobile personal computers (PCs) (UMPCs), workstations, netbook computers, personal digital assistants (PDAs), portable computers, network tablet PCs, wireless phones, mobile phones, smartphones, e-book readers, portable multimedia players (PMPs), portable gaming devices, navigation devices, black boxes, digital cameras, digital multimedia broadcasting (DMB) players, 3D televisions, smart televisions, digital audio recorders, digital audio players, digital picture recorders, digital picture players, digital video recorders, digital video players, storage devices for data centers, devices capable of receiving and transmitting information in a wireless environment, radio frequency identification (RFID) devices, and one of a variety of electronic devices for home networks, one of a variety of electronic devices for computer networks, one of a variety of electronic devices for telematics networks, and / or one of a variety of components for computing systems.
[0032] In the simulation of memory system 10, memory system 10 may include a simulated memory controller 100 and a simulated semiconductor memory device 200. Memory controller 100 can control all operations of semiconductor memory device 200.
[0033] In the simulation, the semiconductor memory device 200 can perform one or more erase, program, and read operations under the control of the memory controller 100. The semiconductor memory device 200 can receive commands (CMD), addresses (ADDR), and data (DATA) via input / output lines. The semiconductor memory device 200 can receive power (PWR) via power lines and control signals (CTRL) via control lines. Depending on the design and configuration of the memory system 10, the control signal CTRL may include, for example, command latch enable signals, address latch enable signals, chip enable signals, write enable signals, read enable signals, and other operational signals. In the simulation, the memory controller 100 and the semiconductor memory device 200 can be a single semiconductor device such as a solid-state drive (SSD). An SSD may include a storage device for storing data therein. When the semiconductor memory system 10 is used in an SSD or modeled as an SSD, the host device connected to the memory system 10 (e.g., Figure 1 The operating speed of the host machine.
[0034] The memory controller 100 and semiconductor memory device 200 in the simulation can be a single semiconductor device such as a memory card. For example, the memory controller 100 and semiconductor memory device 200 can be a PC card, Compact Flash (CF) card, Smart Media (SM) card, Memory Stick, Multimedia Card (MMC), Reduced Size Multimedia Card (RS-MMC), Micro Size Version of MMC (Micro MMC), Secure Digital (SD) card, Mini Secure Digital (Mini SD) card, Micro Secure Digital (Micro SD) card, Secure Digital Mass Capacity (SDHC) card, and / or Universal Flash Memory (UFS).
[0035] Return to reference Figure 1 In the simulation, memory device 200 can store data to be accessed by the host device. Memory device 200 can be a volatile memory device such as dynamic random access memory (DRAM) and / or static random access memory (SRAM), or a non-volatile memory device such as read-only memory (ROM), mask ROM (MROM), programmable ROM (PROM), erasable programmable ROM (EPROM), electrically erasable programmable ROM (EEPROM), ferroelectric random access memory (FRAM), phase-change RAM (PRAM), magnetoresistive RAM (MRAM), and / or resistive RAM (RRAM).
[0036] In the simulation, controller 100 can control the storage of data in memory device 200. For example, controller 100 can control memory device 200 in response to a request from host device. Controller 100 can provide data read from memory device 200 to host device and can store data provided by host device into memory device 200.
[0037] The controller 100 in the simulation may include a storage device 110 connected via a bus 160, a control component 120 which may be implemented as a processor such as a central processing unit (CPU), an error correction code (ECC) component 130, a host interface (I / F) 140, and a memory interface (I / F) 150.
[0038] The storage device 110 in the simulation can be used as working memory for the memory system 10 and the controller 100, and the storage device 110 can store data used to drive the memory system 10 and the controller 100. When the controller 100 controls the operation of the memory device 200, the storage device 110 can store data used by the controller 100 and the memory device 200 for operations such as read operations, write operations, programming operations and erase operations.
[0039] The storage device 110 in the simulation can be a volatile memory such as static random access memory (SRAM) or dynamic random access memory (DRAM). As described above, the storage device 110 can store data used by the host device in the storage device 200 for read and write operations. To store data, the storage device 110 may include program memory, data memory, write buffer, read buffer, mapping buffer, etc.
[0040] In the simulation, the control component 120 can control the general operation of the memory system 10 and, in response to write or read requests from the host device, control write or read operations on the memory device 200. The control component 120 can drive firmware or other program instructions, which may be called a flash translation layer (FTL), to control the operation of the memory system 10. For example, the FTL can perform operations such as logic-to-physical (L2P) mapping, wear leveling, garbage collection, and / or bad block handling. L2P mapping is called logical block addressing (LBA).
[0041] In the simulation, the ECC component 130 can detect and correct errors in the data read from the memory device 200 during a read operation. In one embodiment, when the number of error bits is greater than or equal to a threshold number of correctable error bits, the ECC component 130 may not correct the error bits, but instead outputs an error correction failure signal indicating that the correction of the error bits has failed.
[0042] The ECC component 130 in the simulation can perform error correction operations based on coding modulation such as low-density parity-check (LDPC) codes, Bose-Chaudhuri-Hocquenghem (BCH) codes, turbo codes, turbo product codes (TPC), Reed-Solomon (RS) codes, convolutional codes, recursive systematic codes (RSC), trellis-coded modulation (TCM), or block-coded modulation (BCM). However, error correction is not limited to these techniques. Thus, the ECC component 130 can include any and all circuits, systems, or devices suitable for error correction operations.
[0043] The host interface 140 in the simulation can communicate with the host device through one or more of the following interface standards or interfaces: Universal Serial Bus (USB), Multimedia Card (MMC), High-Speed Peripheral Component Interconnect (PCI-e or PCIe), Small Computer System Interface (SCSI), Serial SCSI (SAS), Serial Advanced Technology Attachment (SATA), Parallel Advanced Technology Attachment (PATA), Enhanced Small Disk Interface (ESDI), and Electronic Integrated Drive (IDE).
[0044] The simulated memory interface 150 can provide an interface between the controller 100 and the memory device 200, allowing the controller 100 to control the memory device 200 in response to requests from the host device. The memory interface 150 can generate control signals for the memory device 200 and process data under the control of the control component 120. In one embodiment, where the memory device 200 is a flash memory such as NAND flash memory, the memory interface 150 can generate control signals for the memory and process data under the control of the control component 120.
[0045] like Figure 2 The memory device 200 shown in the simulation may include a memory cell array 210, control circuitry 220, voltage generation circuitry 230, row decoder 240, page buffer array 250 (which may be in the form of a page buffer array), column decoder 260, and input / output (input / output) circuitry 270. The memory cell array 210 may include multiple memory blocks 211 capable of storing data. The voltage generation circuitry 230, row decoder 240, page buffer array 250, column decoder 260, and input / output circuitry 270 may form the peripheral circuitry of the memory cell array 210. The peripheral circuitry may perform programming, reading, or erasing operations on the memory cell array 210. The control circuitry 220 may control the peripheral circuitry.
[0046] The voltage generation circuit 230 in the simulation can generate operating voltages of various levels. For example, in an erase operation, the voltage generation circuit 230 can generate operating voltages of various levels, such as erase voltage and pass voltage.
[0047] In the simulation, the row decoder 240 can be electrically connected to the voltage generation circuit 230 and multiple memory blocks 211. The row decoder 240 can select at least one memory block among the multiple memory blocks 211 in response to the row address generated by the control circuit 220, and transmit the operating voltage supplied by the voltage generation circuit 230 to the selected memory block.
[0048] The page buffer array 250 in the simulation can be accessed via bit line BL ( Figure 3 (As shown) is connected to the memory cell array 210. The page buffer array 250 can precharge the bit line BL with a positive voltage in response to the page buffer control signal generated by the control circuit 220, and transfer data to and receive data from the selected memory block during programming and reading operations, or temporarily store the transferred data.
[0049] The simulated column decoder 260 can transmit data to and receive data from the page buffer 250, or it can transmit data to and receive data from the input / output circuit 270.
[0050] The input / output circuit 270 in the simulation can input from external devices (e.g., Figure 1 The memory controller 100 receives commands and addresses and transmits them to the control circuit 220 to transmit data from the external device to the column decoder 260, or outputs data from the column decoder 260 to the external device via the input / output circuit 270.
[0051] In the simulation, the control circuit 220 can control the peripheral circuits in response to commands and addresses.
[0052] Figure 2 This is a circuit diagram illustrating a memory block of a semiconductor memory device according to another embodiment of the present invention. For example, Figure 2 The storage block can be Figure 1 Any one of the memory blocks 211 in the memory cell array 210 shown.
[0053] Reference Figure 2 The simulated memory block 211 may include multiple word lines WL0 to WLn-1, a drain select line DSL, and a source select line SSL connected to the line decoder 240. These lines may be arranged in parallel, with multiple word lines arranged between DSL and SSL.
[0054] The simulated memory block 211 may further include multiple cell strings 221 respectively connected to bit lines BL0 to BLm-1. Each cell string may include one or more drain-select transistors (DSTs) and one or more source-select transistors (SSTs). In the illustrated embodiment, each cell string has one DST and one SST. Within the cell string, multiple memory cells or memory cell transistors MC0 to MCn-1 may be connected in series between the select transistors DST and SST. Each of the memory cells may be configured as a multi-level cell. For example, each of the memory cells may be configured as a single-level cell (SLC) storing 1 bit of data. Each of the memory cells may be configured as a multi-level cell (MLC) storing 2 bits of data. Each of the memory cells may be configured as a three-level cell (TLC) storing 3 bits of data. Each of the memory cells may be configured as a four-level cell (QLC) storing 4 bits of data.
[0055] In the simulation, the source of each SST in a cell string can be connected to the common source line CSL, and the drain of each DST can be connected to the corresponding bit line. The gate of an SST in a cell string can be connected to SSL, and the gate of a DST in a cell string can be connected to DSL. The gate of a memory cell in a cell string can be connected to the corresponding word line. That is, the gate of memory cell MC0 is connected to the corresponding word line WL0, the gate of memory cell MC1 is connected to the corresponding word line WL1, and so on. A group of memory cells connected to a specific word line can be called a physical page. Therefore, the number of physical pages in memory block 211 can correspond to the number of word lines.
[0056] The page buffer array 250 in the simulation may include multiple page buffers 251 connected to bit lines BL0 to BLm-1. Page buffers 251 may operate in response to page buffer control signals. For example, page buffers 251 may temporarily store data received through bit lines BL0 to BLm-1 or sense the voltage or current of the bit lines during read or verification operations.
[0057] In various embodiments of the present invention, the storage block 211 in the simulation may be a NAND flash memory cell. However, the storage block 211 is not limited to this cell type, but may include NOR flash memory cells. The memory cell array 210 may be implemented as a hybrid flash memory combining two or more types of memory cells, or as a 1-NAND flash memory with the controller embedded inside the memory chip.
[0058] Figure 3 This is a diagram illustrating the distribution of state or programming voltage (PV) levels of different types of cells in a memory device according to an embodiment of the present invention.
[0059] Reference Figure 3 Each memory cell in the simulation can be implemented using a specific type of cell, such as a single-level cell (SLC) for storing 1 bit of data, a multi-level cell (MLC) for storing 2 bits of data, a three-level cell (TLC) for storing 3 bits of data, or a four-level cell (QLC) for storing 4 bits of data. Typically, all memory cells in a particular memory device are of the same type, but that is not required.
[0060] The simulated SLC can include two states, P0 and P1. P0 indicates the erase state, and P1 indicates the programming state. Since the SLC can be set to one of the two different states, each SLC can program or store one bit according to the set encoding method. The MLC can include four states, P0, P1, P2, and P3. Among these states, P0 can indicate the erase state, and P1 through P3 can indicate the programming state. Since the MLC can be set to one of the four different states, each MLC can program or store two bits according to the set encoding method. The TLC can include eight states, P0 through P7. Among these states, P0 can indicate the erase state, and P1 through P7 can indicate the programming state. Since the TLC can be set to one of the eight different states, each TLC can program or store three bits according to the set encoding method. The QLC can include 16 states, P0 through P15. Among these states, P0 can indicate the erase state, and P1 through P15 can indicate the programming state. Since a QLC can be set to one of 16 different states, each QLC can program or store 4 bits according to the set encoding method.
[0061] Return to reference Figure 1 and Figure 2 The simulated memory device 200 may include multiple memory cells (e.g., NAND flash memory cells). Figure 2 As shown, memory cells are arranged in an array of rows and columns. Cells in each row are connected to word lines (e.g., WL0), while cells in each column are connected to bit lines (e.g., BL0). These word lines and bit lines are used for read and write operations. During a write operation in the simulation, when a word line is asserted, the data to be written ("1" or "0") is provided at the bit line. During a read operation in the simulation, the word line is asserted again, and the threshold voltage for each cell can then be obtained from the bit line. Multiple pages can share memory cells belonging to (i.e., connected to) the same word line. When the memory cells are implemented using MLC, the multiple pages include a most significant bit (MSB) page and a least significant bit (LSB) page. When the memory cells are implemented using TLC, the multiple pages include an MSB page, a middle significant bit (CSB) page, and an LSB page. When the memory cells are implemented using QLC, the multiple pages include an MSB page, a middle most significant bit (CMSB) page, a middle least significant bit (CLSB) page, and an LSB page. For example, an encoding scheme (e.g., Gray encoding) can be used to emulate memory cells to increase the capacity of a memory system 10 such as an SSD.
[0062] Simulation platform
[0063] In one embodiment of the invention, regarding the predicted responses that will occur when a simulation begins for a given existing memory attribute (e.g., the time to failure of memory blocks with or without wear leveling), the simulation platform 15 can discover weaknesses and improvements in the FW algorithm by running the simulation. In one embodiment of the invention, the simulation platform 15 provides flexibility in configuring simulation components according to the needs of different stages of product development and provides flexibility for testing actual devices.
[0064] Return to reference Figure 1 If a host requesting to write or read information from a storage device (such as memory system 10) is simulated by transmitting information about the data size and the address of the information to be written or read, then in the simulation, the storage device can perform internal read and write operations to optimize storage capacity, prevent / resolve NAND readability issues, update logic-to-physical address mappings, etc. Therefore, as the simulation platform 15 simulates host request operations and gathers information for future analysis, the simulation platform 15 can predict how to optimize storage capacity, prevent / resolve NAND readability issues, and update logic-to-physical address mappings.
[0065] Figure 4 This is a diagram illustrating a simulation platform 15 according to another embodiment of the present invention. To provide SE graph traversal and fast communication (faster than communication between actual hardware and firmware components) between simulated HW / FW components, in one embodiment of the invention, the simulation platform 15 stores a set of SEs in a repository 52 (in... Figure 5 The devices shown are 1SE, 2SE, 3SE, and 4SE, where each SE is an algorithm implementation of certain HW or FW components associated with a specific product or product group and / or a specific algorithm revision.
[0066] In graph traversal, a graph represents a non-linear data structure consisting of nodes and the edges connecting them. More specifically, a graph is a structure that corresponds to a set of objects, some of which are "related" to each other (e.g., through functional dependencies). Objects correspond to mathematical abstractions called vertices (also known as nodes or points), and each of the related vertex pairs is called an edge. Simulation kernels compose SE graphs and distribute messages between SEs. Graph traversal is a technique used to search for vertices in a graph.
[0067] The simulation platform 15 also includes a simulation kernel engine 54, which is programmed to: perform simulations, redirect messages to appropriate SEs, manage a set of SEs invoked for simulation, and calculate target metrics (e.g., latency, throughput, write amplification index, etc.). The simulation platform 15 also includes an SE relationship manager processor 56. This tool is programmed to construct an SE graph (from a set of SEs invoked for simulation) that displays edges based on the target simulation purpose and the product.
[0068] The diagram generated by the simulation kernel engine 54 can be implemented as a file with a suitable format generated by predefined scripts. This diagram provides SE relationships for use by the simulation kernel. If drawn for the user, this diagram provides a visualization tool for showing the logical relationships between selected SEs and their functionalities. The simulation platform 15 also stores one or more product configuration files in repository 58, which contain parameters and parameter values used for the simulation of the target product. If the software (FW) already has a configuration file, it can be used directly for simulation, or the simulation platform 15 can automatically acquire the required parameters directly from the FW code.
[0069] In one embodiment of the invention, in emulating a kernel engine (such as...) Figure 4 The SE (Search Engine) in a message-driven system, controlled by the simulation kernel engine (54), generates messages based on predefined workloads, for example. The predefined workloads implemented by the SE can represent established workload types, such as random or sequential data reads. Predefined workloads can also represent different data directions, reads or writes, or combinations thereof with various queue depths. For example, a workload combining random read and write can have a 70% write probability, with a block size of 4k and a queue depth of 32 commands.
[0070] In one embodiment of the invention, a message representing data is sent to a specific address. In a message-driven system, each component can have a unique “address” to which other components can send messages. Each of these SE components or receivers waits for messages and reacts to received messages. In one embodiment of the invention, message-driven simulation constitutes a simulation in which SEs interact with each other by sending messages. The “address” corresponds to an edge of the graph described above. This message-driven simulation can reconcile conflicting requirements of isolated models, facilitate the simulation kernel, and highly correlate the tempo of simulation speed. In one embodiment of the invention, the HW and FW of the storage device controller are designed as interactive SE components and can be represented as a graph. This graph reflects the cooperation between hardware and firmware. In one embodiment of the invention, the storage device is functionalized as a graph of Independent Emulation Entities (ISEs), where each ISE is an algorithmic implementation of an HW or FW component. In one embodiment of the invention, SEs interact with each other by sending messages corresponding to edges of the graph. For example, in Figure 5 There are two (2) edges SE1-SE2 and SE2-SE3.
[0071] In one embodiment of the invention, the simulation kernel engine 54 is responsible for composing the SE graph and distributing messages between SEs. For example, the simulation kernel may obtain a graph. The graph may be a file or other entity (such as an object). Based on the graph obtained during simulation by distributing messages between SEs, the simulation kernel creates SE entities and manages the relationships between SEs.
[0072] In one embodiment of the invention, simulation charts can be generated based on a chart creation script (i.e., a standalone application), or the charts can be generated by the user. For a specific simulation (e.g., for a specific SSD), a specific chart can be generated as a base or template. Regardless of how it is generated, the chart can be modified.
[0073] As an ISE, any HW / FW simulation entity can be added / removed or replaced with another version without affecting the rest of the simulation entities. Because SEs can operate independently, the number of graph nodes can be flexibly changed. This flexibility allows for simulations of varying levels of detail. The message-driven nature of the SEs allows them to operate independently, as message sending is the only way to interact with the receiving SE, regardless of the message's origin.
[0074] In one embodiment, Figure 4 The simulation platform 15 shown can be used as a standalone simulator. Alternatively, in another embodiment, Figure 4 The simulation platform 15 shown can be used to accept input from real existing hardware and firmware components in actual products.
[0075] In real storage devices, any internal operation (e.g., execution of firmware code, NAND operations, RAM access, HW engine operation, etc.) takes time to execute. The duration of internal operations can range from nanoseconds (for RAM access) to milliseconds (for NAND operations). While some operations may have a constant duration, others have durations that are distributed over time. Due to these considerable differences in the duration of internal operations, it is generally not necessary to simulate all driver hardware / firmware components for the target metric to achieve an acceptable level of accuracy. Therefore, storage device components differ in their timing metrics. Such metrics are reflected in the simulation platform 15 by the following types of SE:
[0076] 1. A Step Entity represents a time-consuming storage device component. Step Entities simulate various latencies in the hardware (HW). Step Entities receive messages and report the corresponding latencies to the simulation kernel to simulate HW overhead.
[0077] 2. State Entities Simulate FW / HW State Machines. This type of SE performs the simulation immediately. State transitions of state entities instruct the simulation kernel engine 54 to immediately execute the simulation without simulation overhead. State entities interact by sending messages to other state entities and step entities.
[0078] 3. Shared resource representation using the FW / HW algorithm. This type of SE typically does not consume a significant amount of simulation time. All shared resources can be simulated at once. The SE does not consume a large amount of simulation time. Shared resources can be shared among other SEs, but sending or receiving messages may not be permitted. A key requirement is that the latency of algorithm execution does not affect the target metric.
[0079] Regardless of the type of SE, messaging is the preferred way for SEs to interact with each other. To send a new message, an SE allocates a message from the emulation kernel by calling the emulation kernel engine 54 to send the message to another SE. The emulation kernel may have an application programming interface (API) for processing messages. SEs can use the emulation API as function calls to allocate, send, or release messages. SEs release messages after the relevant operations are complete and, if necessary, can send feedback to the caller after message processing. An SE can call the emulation kernel API to release a message, meaning that the message no longer belongs to the SE because the SE has completed the operation / emulation it was instructed to perform.
[0080] In one embodiment of the invention, a parent-child message relationship is utilized. The simulation kernel engine 54 tracks all release messages and allocation requests, and after releasing all child messages of the SEs, places the parent message into the completion queue of the corresponding SE. From an architectural perspective, the parent-child relationship characteristic represents the causal relationship of processes occurring within the storage device and can be tracked and / or visualized. Therefore, in one embodiment of the invention, there are two ways to send messages between SEs:
[0081] - Use parent-child relationship (PCR) when an SE needs to know the message released by another SE in order to take corresponding action.
[0082] - When the SE has nothing to do after the message is released, forwarding (FWD) is used. This FWD capability reduces the number of times the SE calls the emulation kernel engine 54, thereby improving emulation performance.
[0083] Suppose the user selects three SEs at SE relationship manager processor 56. Only SE1 generates the initial message and requires feedback on message completion. SE2 performs some actions and further forwards the incoming message. SE3 performs some actions and releases the incoming message. SE1 sends messages using a parent-child relationship, so the simulation kernel calls SE1 when releasing child messages. Since SE2 uses message forwarding, the simulation kernel does not need to call SE2 when releasing messages.
[0084] Figure 5 This is a sequence diagram according to another embodiment of the present invention. The sequence diagram shows the message process in a parent-child process, where an initial message or parent message M1 (e.g., writing data from the host to memory) generates a second message M2 (e.g., requesting confirmation that a memory block is available) that is sent to the second SE. The parent-child relationship reduces the time spent processing SE communication. The second SE takes action and forwards M2 to the third SE. Figure 5 As shown, at some point in this event sequence, no sub-messages are active, and when no sub-messages are active, the simulation kernel (simulation kernel engine 54) is invoked to start the simulation based on a set of SEs and message M1 is processed.
[0085] For example, let message A have two sub-messages named B1 and B2 (meaning that to complete the message actions, actions B1 and B2 must be completed). Action B1 is active until the SE receives a message indicating that action B1 is complete. Once action B1 is complete, message B1 is released. Once message B1 is released, it is no longer active. Message B2 follows the same process. Once all actions are completed (i.e., B1 and B2 are released), the actions for message A are complete, and the SE component that owns or initiated message A knows that all activities related to A have been completed.
[0086] In another example, if message M1 is an instruction to write data from the host to PRODUCT_A, then once selected... Figure 7A The five SEs shown in the SE diagram, whose attributes are passed to the simulation kernel engine 54, then... Figure 5 The message M2 will be released, which means that the action (in this case, the simulation writes data to PRODUCT_A associated with message M2) is complete, and SE can perform other actions.
[0087] Figure 6 This is a diagram describing the main loop of the simulation kernel. To improve simulation performance, the simulation kernel engine 54 can (on its main loop iterations) use SE only when needed, for example, for incoming / completed messages with SE present or timeouts defined by step entities. Figure 6 As shown, in the main loop, the simulation kernel engine 54 can invoke the entity that has received a new message for simulation by selecting the appropriate SE from the repository 52. In the main loop, branch point 702 determines whether the invoked simulation entity is a step entity or a state entity (as detailed above). If the simulation entity is a step entity, the simulation kernel engine 54 commands a delayed request. If the simulation entity is a state entity, the simulation kernel engine 54 passes the message to other state entities for the actions that need to be simulated. In branch 704 of the main loop, the simulation kernel engine 54 determines whether any entity has a new message. If there is a new message, the simulation kernel engine 54 returns to the top of the main loop to invoke the new entity for simulation. If there is no new message, the simulation kernel engine 54 continues to increment the simulation time, and if the timeout expires, the step entity can be invoked.
[0088] The simulation kernel engine 54 may not have an internal simulation time slice. Instead, simulation time is typically determined by the step entity itself. The simulation kernel engine 54 obtains the minimum latency requested by the step entity on the simulation cycle. This strategy minimizes the cost of switching between SEs and simplifies the simulation of parallel processes.
[0089] In one embodiment of the invention, during the simulation process, the SE synchronizes the simulation steps to know when to take subsequent actions. The software simulation can actually use different real-world time slices (determined by the SE) to prompt and remind when subsequent actions occur, without necessarily being tied to a schedule determined by a physical clock. In other words, the SE determines the simulation schedule.
[0090] Figure 7A This is a diagram illustrating the construction of a graph showing the logical relationships between different simulated entities according to another embodiment of the present invention. It is assumed that the target metric for the simulation is the host read command latency for a random read-only workload with a queue depth of 2. Furthermore, it is assumed that the target SSD (product name "A") has only two NAND dies, and that all host and storage device overheads for processing host commands, excluding NAND overhead, are equal to 0.
[0091] like Figure 7A As shown, the initial configuration file imports the properties of the memory system to be simulated. For example... Figure 7A As illustrated in the example, a host SE, two product SEs, two logical-to-physical address mapping SEs, and two step-delay SEs are available. The user, interacting with the SE relationship manager processor 56, then selects those SEs to be used in the simulation from the repository 52. As described above, with the user's assistance, such as... Figure 8 As shown on the right, a graph of SEs (from a set of SEs called for simulation) is constructed, where the host SE and its attributes (access type, command type, queue depth), product SE, and L2P SE are displayed together with the step delay SE. Figure 7A The SE diagram. In the example shown, the diagram illustrates the communication flow from one SE to another.
[0092] exist Figure 7A In the simulation shown in the configuration, the host is represented by the state entity "HOST_SE" because all hardware overhead is excluded and the state entity "HOST_SE" will preferably only generate commands (as described above) based on the specified workload and then send them. Figure 7AAbove, the target memory device component is represented as a single state entity named "PRODUCT_A_SE" because there is no other HW overhead besides NAND overhead. The primary purpose of the "PRODUCT_A_SE" state entity is to redirect incoming messages to the appropriate memory device die component, which is represented as one of the step entities with constant latency ("STEP_CONST_DELAY_1" or "STEP_CONST_DELAY_2") and limited overhead for read operations defined in the initial configuration file. For operation redirection, the "PRODUCT_A_SE" state entity can use the shared resource SE "L2P_RND_SE" of the simulation logical address to physical address translation table (L2P). In the example shown, "L2P_RND_SE" is a random number generator used to randomly select the target die for the model. With the help of the SE relational management processor 56, users can replace "L2P_RND_SE" with L2P_SNAPSHOT_SE (or other existing / new shared resources for L2P emulation), which can be a snapshot of L2P attributes from the real driver after prerequisites.
[0093] Suppose we need to simulate accessing DRAM to read L2P tables to improve the accuracy of host read command latency estimation. Furthermore, assume the DRAM read overhead is known and has a constant value. In this case, with the assistance of the SE relational management processor 56, the user can reconfigure the SE graph to... Figure 7B The diagram shown illustrates this reconfiguration (manifested as...). Figure 7A and Figure 7B The differences between the SE charts in the simulation platform 15 are an important aspect.
[0094] and Figure 7A The main difference compared to the initial configuration shown is the addition of a step entity "STEP_CONST_DELAY_3" to simulate DRAM read access with corresponding overhead. Furthermore, for the new simulation, the PRODUCT_A_SE status entity first sends the incoming message to "STEP_CONST_DELAY_3" to simulate physical address read overhead, and only sends the corresponding message to the appropriate SE responsible for NAND die read overhead simulation after the overhead has expired.
[0095] Figure 8 Shown in simulation Figure 7BThe SE diagram shows the sequence of SE calls made by the emulation kernel engine 54 during the configuration period (in time) (time scales are marked). With the aid of PCR or FWD transmissions (detailed above), at each time point, the emulation kernel engine 54 calls only the SEs required for the emulation (i.e., those selected by the user via the SE relationship management processor 56). Figure 8 The sequence is as follows: First, HOST_SE (the program code that processes HOST_SE via the emulation kernel engine 54) generates messages M1 and M2 and sends them to PRODUCT_A_SE via PCR. Second, PRODUCT_A_SE (the program code that processes PRODUCT_A_SE via the emulation kernel engine 54) sends M1 and M2 to STEP_CONST_DELAY_3 via PCR. Third, STEP_CONST_DELAY_3 (the program code that processes STEP_CONST_DELAY_3 via the emulation kernel engine 54) allocates overhead (memory resources) for the action on M1. Fourth, STEP_CONST_DELAY_3 (the program code that processes STEP_CONST_DELAY_3 via the emulation kernel engine 54) releases M1 and allocates overhead (memory resources) for the action on M2. Fifth, PRODUCT_A_SE defines the target simulation for M1's action through L2P_RND_SE (the program code for PRODUCT_A_SE and L2P_RND_SE is processed by the simulation kernel engine 54) and forwards message M1. Sixth, STEP_CONST_DELAY_1 allocates overhead (memory resources) to act on M1's action. Seventh, STEP_CONST_DELAY_3 releases message M2. Eighth, PRODUCT_A_SE defines the target simulation for M2's action through L2P_RND_SE (the program code for PRODUCT_A_SE and L2P_RND_SE is processed by the simulation kernel engine 54) and forwards message M2. Ninth, STEP_CONST_DELAY_2 allocates overhead (memory resources) to act on the actions of M1 and M2. Tenth, STEP_CONST_DELAY_3 releases message M1. Eleventh, HOST_SE (the program code that processes HOST_SE through the emulation kernel engine 54) releases M1 and generates message M3, sending M3 to PRODUCT_A_SE. Twelfth, PRODUCT_A_SE (the program code that processes PRODUCT_A_SE through the emulation kernel engine 54) sends message M3 to STEP_CONST_DELAY_3. Thirteenth, STEP_CONST_DELAY_3SE (the program code that processes PRODUCT_A_SE through the emulation kernel engine 54) allocates overhead (memory resources) to act on message M3.
[0096] In one embodiment of the invention, configurability is provided by product profiles and related tools such as the SE Relationship Manager Processor 56. Using the profiles, users can easily change the values of HW / FW component parameters before running another simulation. In one embodiment of the invention, scalability is provided by SE independence and its modular composition. The SE Relationship Manager Processor 56 allows users to include or exclude SEs based on the desired level of accuracy using charts. In one embodiment of the invention, simulation performance is provided by an effective sequence of invoked SEs, such that the simulation uses only SEs that affect the target metric used for estimation. For example, SEs that are "known" to affect the target metric are selected from previous simulations, documentation, theory, or assumptions, thereby facilitating modeling by selecting "better" SEs for the target metric to be modeled.
[0097] In one embodiment of the invention, a simulation system (or platform) for emulating a storage device is provided. Here, the simulation system (e.g., simulation system 2) includes a set of simulation entities (SEs), comprising host SEs and storage component SEs corresponding to the hardware and software components of the storage device to be simulated (e.g., repository 52). In this embodiment, the simulation system further includes a) a relationship manager processor (e.g., SE relationship manager processor 56) configured to determine logical relationships between SEs selected from the set of SEs, and b) a simulation kernel engine (such as kernel engine 54) configured to perform simulation using the selected (or invoked for simulation) SEs. In this embodiment, sequence messages propagate between the selected SEs and to the simulation kernel engine. The sequence messages determine whether simulation conditions are complete (and thus determine when to perform the simulation).
[0098] In one embodiment of the invention, the emulation kernel engine is configured such that a first SE among the selected SEs creates a first message and a second message, and the second message is forwarded to a second SE among the selected SEs.
[0099] In one embodiment of the present invention, the simulation kernel engine of the second SE performs at least one simulation action based on the second message, the simulation kernel engine forwards the second message to the third SE among the selected SEs, the simulation kernel engine of the third SE performs another simulation action based on the second message and releases the second message, and the simulation kernel engine completes the simulation in response to the release of the second message.
[0100] In one embodiment of the invention, the SE includes independent SEs, which can be exchanged for different simulations without affecting the operation of other SEs. In another embodiment, sequential messages can have a parent-child relationship with child messages generated in response to a previously generated parent message.
[0101] In one embodiment of the invention, the system may include a repository of configuration files (e.g., repository 58), wherein the configuration files store information about the attributes of different hardware and software components of different storage devices. The relationship manager processor 56 may be configured to construct a graph depicting the logical relationships between the selected SEs. The graph can be constructed by loading configuration information from the configuration files and loading the selected SEs. Further, the relationship manager processor 56 may be configured to provide a user with a visual depiction of the selected SEs, the logical relationships between the selected SEs, and the configuration information. The relationship manager processor 56 may be configured to accept user input to select an SE and a configuration file.
[0102] Figure 9 This is a diagram illustrating a simulation operation according to another embodiment of the present invention.
[0103] like Figure 9 As depicted, the method at 901 provides a set of emulation entities (SEs), including a host SE and storage component SEs corresponding to the hardware and software components of the storage device to be emulated. At 903, the method selects an SE from this set. At 905, the method determines the logical relationships between the selected SEs. At 907, the method propagates a sequence message among the selected SEs and to the emulation kernel engine; the sequence message determines whether the emulation conditions are complete (and therefore also determines when to perform the emulation). At 909, the method performs the emulation using the selected SEs.
[0104] In this method, propagating the sequential message includes: communicating with the simulation kernel engine to create a first message and a second message for a first SE among the selected SEs, and sending the second message to a second SE among the selected SEs. The method further involves, after the second SE performs at least one simulation action based on the second message, forwarding the second message to a third SE among the selected SEs, releasing the second message after the third SE performs another simulation action based on the second message, and completing the simulation in response to the release of the second message.
[0105] In this method, the storage component SE can be an independent SE, which can be exchanged (for different simulations) without affecting other SEs. In this method, the propagated messages can be sequential messages with a parent-child relationship to child messages generated in response to a previously generated parent message. In this method, a repository of configuration files can be stored and accessed. The configuration files contain information about the properties of different hardware and software components of different storage devices.
[0106] This method can further construct a diagram depicting the logical relationships between the selected SEs. Constructing the diagram may involve loading configuration information from a configuration file. In this method, a visual depiction of the selected SEs, the logical relationships between them, and the configuration information can be presented to the user, who can provide input (which is accepted) to select SEs and configuration files.
[0107] Although the foregoing embodiments have been shown and described in considerable detail for clarity and ease of understanding, the invention is not limited to the details provided. Those skilled in the art will appreciate from the foregoing disclosure that many alternative ways of carrying out the invention exist. Therefore, the disclosed embodiments are illustrative and not restrictive. The invention is intended to include all modifications and substitutions to the disclosed embodiments. Furthermore, the disclosed embodiments may be combined to form additional embodiments.
[0108] In fact, embodiments of the subject matter and functional operation described in this patent application can be implemented in various systems, digital electronic circuits, or in computer software, firmware, or hardware including the structures disclosed in this specification and their equivalents, or in combinations thereof. Embodiments of the subject matter described in this specification can be implemented as one or more computer program products, i.e., one or more modules of computer program instructions encoded on a tangible and non-transitory computer-readable medium for execution by a data processing device or for controlling the operation of a data processing device. The computer-readable medium can be a machine-readable storage device, a machine-readable storage substrate, a memory device, a composition of substances affecting machine-readable propagation signals, or combinations thereof. The terms "data processing unit" or "data processing device" encompass all devices, apparatuses, and machines for processing data, including, for example, programmable processors, computers, or multiple processors or computers. In addition to hardware, the device may also include code that creates an operating environment for the computer program in discussion, such as code constituting processor firmware, a protocol stack, a database management system, an operating system, or combinations thereof.
[0109] Computer programs (also known as programs, software, software applications, scripts, or code) can be written in any form of programming language, including compiled or interpreted languages, and can be deployed in any form, including as standalone programs or as modules, components, subroutines, or other units suitable for use in a computing environment. A computer program does not necessarily correspond to a file in a file system. A program may be stored as part of a file containing other programs or data (e.g., one or more scripts stored in a markup language document), in a single file dedicated to the program in question, or in multiple coordinating files (e.g., a file storing parts of one or more modules, subroutines, or code). Computer programs can be deployed to run on a single computer, located in one place, or distributed across multiple computers interconnected by a communications network.
[0110] The processes and logic flows described in this specification can be executed by one or more programmable processors that run one or more computer programs to perform functions by manipulating input data and generating output. The processes and logic flows can also be executed by dedicated logic circuitry, and the device can also be implemented as dedicated logic circuitry, such as an FPGA (Field-Programmable Gate Array) or an ASIC (Application-Specific Integrated Circuit).
[0111] Processors suitable for running computer programs include, for example, general-purpose and special-purpose microprocessors, and any one or more processors of any type of digital computer. Typically, a processor receives instructions and data from read-only memory or random access memory, or both. The basic components of a computer are a processor for executing instructions and one or more memory devices for storing instructions and data. Typically, a computer also includes one or more mass storage devices for storing data, such as magnetic disks, magneto-optical disks, or optical disks, or is operatively coupled to one or more mass storage devices to receive data from or send data to, or both. However, a computer does not need to have such devices. Computer-readable media suitable for storing computer program instructions and data include all forms of non-volatile memory, media, and memory devices, including, for example, semiconductor memory devices such as EPROM, EEPROM, and flash memory devices. The processor and memory may be supplemented by or incorporated into special-purpose logic circuitry.
[0112] Although this patent application includes numerous details, these details should not be construed as limiting the scope of any invention or potentially claimed protection, but rather as a description of features that may be specific to particular embodiments of a particular invention. Certain features described in the context of different embodiments in this patent application may also be implemented in combination in a single embodiment. Conversely, various features described in the context of a single embodiment may also be implemented separately in multiple embodiments or in any suitable sub-combination. Furthermore, although these features may be described above as functioning in certain combinations, in some cases, one or more features from that combination may be removed from the combination, and the combination may then involve sub-combinations or variations of sub-combinations.
[0113] Similarly, although operations are described in a specific order in the accompanying drawings, this should not be construed as requiring these operations to be performed in the specific order shown or sequentially, or to perform all of the shown operations to achieve the desired result. Furthermore, the separation of various system components in the embodiments described in this patent application should not be construed as requiring such separation in all embodiments.
[0114] Only some implementation schemes and examples are described, and other implementation schemes, improvements and variations can be derived based on the content described and shown in this patent application.
Claims
1. A simulation system, comprising: A set of simulation entities is a set of SEs, including the host SE and the storage component SEs corresponding to the hardware and software components of the storage device to be simulated; The relationship manager processor determines the logical relationships between the SEs selected from the set of SEs; as well as The simulation kernel engine uses the selected SE to perform the simulation. The sequential message propagates between the selected SEs and to the simulation kernel engine, and the sequential message determines whether the simulation conditions are complete.
2. The system according to claim 1, wherein, The simulation kernel engine creates a first message and a second message for the first SE in the selected SE, and The second message is forwarded to the second SE among the selected SEs.
3. The system according to claim 2, wherein, The simulation kernel engine of the second SE performs at least one simulation action based on the second message. The simulation kernel engine forwards the second message to the third SE among the selected SEs. The simulation kernel engine of the third SE performs another simulation action based on the second message and releases the second message. The simulation kernel engine completes the simulation in response to the release of the second message.
4. The system according to claim 1, wherein, The storage component SE includes independent SEs that can be swapped for different emulations without affecting other SEs.
5. The system according to claim 1, wherein, The sequential message and the child message generated in response to a previously generated parent message have a parent-child relationship.
6. The system of claim 1, further comprising a repository of configuration files, wherein the configuration files have information about the properties of different hardware and software components of different storage devices.
7. The system according to claim 6, wherein, The relationship manager processor constructs a graph depicting the logical relationships between the selected SEs.
8. The system according to claim 7, wherein, The relationship manager processor constructs the graph by loading configuration information from the configuration file and by loading the selected SE.
9. The system of claim 8, wherein the relationship manager processor provides the user with a visual depiction of the selected SE, the logical relationships between the selected SEs, and the configuration information.
10. The system of claim 8, wherein the relation manager processor accepts user input to select the SE and the configuration file.
11. A method for emulating a storage device, comprising: A set of simulation entities, namely a set of SEs, is provided, the set of SEs including host SEs and storage component SEs corresponding to the hardware and software components of the storage device to be simulated; Select an SE from the set of SEs; Determine the logical relationships between the selected SEs; Sequence messages are propagated between the selected SEs and to the simulation kernel engine, the sequence messages determining whether the simulation conditions are complete; and The simulation is performed using the selected SE.
12. The method of claim 11, wherein propagating the sequential message comprises: Communicate with the simulation kernel engine to create a first message and a second message for the first SE in the selected SE, and The second message is sent to the second SE among the selected SEs.
13. The method of claim 12, further comprising: After the second SE performs at least one simulation action based on the second message, it forwards the second message to the third SE among the selected SEs; After the third SE performs another simulation action based on the second message, it releases the second message, and The simulation is completed in response to the release of the second message.
14. The method of claim 11, wherein the storage component SE includes independent SEs that can be swapped for different emulations without affecting other SEs.
15. The method of claim 11, wherein propagating the sequential message comprises: Propagation and child messages generated in response to previously generated parent messages are sequential messages with parent-child relationships.
16. The method of claim 11, further comprising a repository for storing configuration files, wherein the configuration files have information about the properties of different hardware and software components of different storage devices.
17. The method of claim 16, further comprising constructing a graph depicting the logical relationships between the selected SEs.
18. The method of claim 17, wherein constructing the graph includes loading configuration information from the configuration file and loading the selected SE.
19. The method of claim 18, further comprising visually depicting the selected SE, the logical relationships between the selected SEs, and the configuration information.
20. The method of claim 18, further comprising accepting user input to select the SE and select the configuration file.
Citation Information
Patent Citations
Dynamic generation of formatted user interfaces in software environments
US20070256053A1
Enhanced execution speed to improve simulation performance
US20090089029A1
