Observer-based UVM verification platform information interaction method, system and equipment
By adopting an observer-based interaction method in the UVM verification platform, using python monitoring threads to monitor the UVM simulation log in real time and notify the observer, the problem of low data interaction efficiency in the UVM verification platform is solved, and efficient reference model data transmission and Logical decoupling.
Patent Information
- Application Number
- CN202411285735.3
- Authority / Receiving Office
- CN · China
- Patent Type
- Applications(China)
- Current Assignee / Owner
- Filing Date
- 2024-09-13
- Publication Date
- 2024-12-13
AI Technical Summary
In the existing UVM verification platform, the data interaction between the reference model and the UVM verification platform is inefficient and the logical coupling is serious, resulting in complex business logic and handshake operations, which affects the efficiency of data transmission.
The UVM verification platform information interaction method is adopted based on observers, and the UVM simulation log is monitored in real time through python monitoring threads, stored in the dictionary, and notified the observer to update, cancel the active handshake operation, and realize transaction-level broadcasting and independent data transmission.
It greatly improves the data interaction efficiency of reference model, supports flexible addition and configuration of observers, reduces the active operation of the UVM verification platform, and improves the independence and efficiency of data transmission.
Smart Images
Figure CN119127532A_ABST
Abstract
Description
Technical Field
[0001] The invention belongs to the technical field of chip verification, and relates to an observer-based UVM verification platform information interaction method, system and device. Background Art
[0002] The complexity of contemporary chip design is increasing. UVM verification methodology has become the mainstream verification method for chip verification. In order to broaden the functional scope of the UVM verification platform, the powerful Python language has received widespread attention. Common functions of Python language in digital chip verification include reference models and data processing scripts. When used as a reference model, the common process is to receive the simulation configuration and data of the UVM verification platform, process them to obtain the expected results, and then compare them with the test results of the UVM verification platform. However, when using Python language to provide reference model functions, the functions of the various parts of the reference model are severely coupled and easily affect each other. The reference model does not support transaction-level modeling, resulting in too scattered data transmission. The handshake mechanism between the reference model and the UVM verification platform is too complicated. Therefore, there is still a technical problem of low efficiency of reference model data interaction. Summary of the invention
[0003] In view of the problems existing in the above-mentioned traditional methods, the present invention proposes an observer-based UVM verification platform information interaction method, an observer-based UVM verification platform information interaction system, a computer device and a computer-readable storage medium, which can effectively improve the reference model data interaction efficiency.
[0004] In order to achieve the above objectives, the embodiments of the present invention adopt the following technical solutions:
[0005] On the one hand, a UVM verification platform information interaction method based on an observer is provided, comprising the steps of:
[0006] Get the UVM simulation log path of the UVM verification platform;
[0007] During the simulation verification process of the chip under test by the UVM verification platform, a python monitoring thread is created to monitor the UVM simulation log of the UVM verification platform in real time according to the UVM simulation log path; the python monitoring thread is created using the python standard library;
[0008] The simulation information captured when real-time monitoring of UVM simulation logs is stored in the dictionary as the observer;
[0009] When the state of the dictionary being observed changes, a notification is sent to all observers in the observer list; the observers in the observer list include a reference model based on Python, and the notification is used to instruct the observer to update its own internal dictionary;
[0010] The reference model updated by the dictionary uses the simulation information in the dictionary for post-processing and outputs the obtained result information to the python log file;
[0011] Get result information from python log file through UVM testbench.
[0012] On the other hand, an observer-based UVM verification platform information interaction system is also provided, including:
[0013] A path acquisition module is used to obtain the UVM simulation log path of the UVM verification platform;
[0014] The monitoring creation module is used to create a python monitoring thread to monitor the UVM simulation log of the UVM verification platform in real time according to the UVM simulation log path during the simulation verification process of the chip under test on the UVM verification platform; the python monitoring thread is created using the python standard library;
[0015] An information transfer module is used to store the simulation information captured when real-time monitoring of UVM simulation logs in a dictionary as an observer;
[0016] The observation notification module is used to send notifications to all observers in the observer list when the state of the observed dictionary changes; the observers in the observer list include a reference model based on Python, and the notification is used to instruct the observer to update its internal dictionary;
[0017] A post-processing module, used to perform post-processing using the simulation information in the dictionary through the reference model updated by the dictionary and output the obtained result information to a python log file;
[0018] The result acquisition module is used to obtain result information from the python log file through the UVM verification platform.
[0019] On the other hand, a computer device is provided, including a memory and a processor, wherein the memory stores a computer program, and when the processor executes the computer program, the steps of the above-mentioned observer-based UVM verification platform information interaction method are implemented.
[0020] On the other hand, a computer-readable storage medium is provided, on which a computer program is stored. When the computer program is executed by a processor, the steps of the above-mentioned observer-based UVM verification platform information interaction method are implemented.
[0021] One of the above technical solutions has the following advantages and beneficial effects:
[0022] The above-mentioned observer-based UVM verification platform information interaction method, system and device design a python-based reference model framework based on the observer mode, rationally decouple the logic trigger of the reference model and the business logic itself, support adding or reducing observers according to verification requirements without affecting other functional logics, and can flexibly add, delete and configure triggers and business logic, build a dictionary-based transaction-level reference model, fully automatically implement transaction-level broadcasting between reference models, cancel the handshake operation actively initiated by the UVM verification platform, and monitor in real time by the python monitoring thread, so that data transmission is independently initiated by the python-based reference model, which greatly improves the reference model data interaction efficiency. BRIEF DESCRIPTION OF THE DRAWINGS
[0023] In order to more clearly illustrate the embodiments of the present invention or the technical solutions in the conventional technology, the drawings required for use in the embodiments or the conventional technology descriptions are briefly introduced below. Obviously, the drawings described below are only some embodiments of the present invention. For ordinary technicians in this field, other drawings can be obtained based on these drawings without paying any creative work.
[0024] Figure 1 A schematic diagram of a UVM verification platform information interaction method based on an observer in one embodiment;
[0025] Figure 2 A schematic diagram of the information interaction principle of an observer-based UVM verification platform information interaction method in one embodiment;
[0026] Figure 3 A schematic diagram of an information interaction process based on Python monitoring thread in one embodiment;
[0027] Figure 4 A schematic diagram of the observer model principle in one embodiment;
[0028] Figure 5 A schematic flow chart of an information interaction method of a UVM verification platform based on an observer in another embodiment;
[0029] Figure 6 Schematic diagram of the module architecture of an observer-based UVM verification platform information interaction system in one embodiment. DETAILED DESCRIPTION
[0030] In order to make the purpose, technical scheme and advantages of the present invention clearer, the present invention is further described in detail below in conjunction with the accompanying drawings and Examples. It should be understood that the specific embodiments described herein are only used to explain the present invention and are not intended to limit the present invention. Unless otherwise defined, all technical and scientific terms used herein have the same meaning as those generally understood by those skilled in the art of the present invention. The terms used in the specification of the present invention are only for the purpose of describing specific embodiments and are not intended to limit the present invention.
[0031] It should be noted that the reference to "embodiment" in this article means that the specific features, structures or characteristics described in conjunction with the embodiment may be included in at least one embodiment of the present invention. The presentation of this phrase at various locations in the specification does not necessarily refer to the same embodiment, nor is it an independent or alternative embodiment that is mutually exclusive with other embodiments. It will be appreciated by those skilled in the art that the embodiments described herein may be combined with other embodiments. The term "and / or" used in the specification of the present invention and the appended claims refers to any combination of one or more of the associated listed items and all possible combinations, and includes these combinations.
[0032] The following will describe the implementation of the present invention in detail with reference to the accompanying drawings in the embodiment diagram of the present invention.
[0033] It should be briefly explained that the verification system and test case used in the embodiments of the present invention have used UVM (Universal Verification Methodology) verification methodology, the key feature of UVM verification methodology is reusable components and standardized hierarchy on the one hand, and its SystemVerilog class library on the other hand, the UVM verification platform built based on UVM verification methodology is one of mainstream chip verification platforms, and its reference model used in the simulation verification process is a reference model designed using python language, which can be called and executed by specific python script.
[0034] In the traditional information exchange method, the UVM verification platform needs to continuously and actively write various key information generated by the simulation process into intermediate files to initiate a handshake with the python script to establish a communication connection between the UVM verification platform and the python script to transfer key information. After the intermediate file is written, the python script needs to be started at the right time to ensure the accuracy of the information exchange logic.
[0035] The various key information generated during the simulation process is written into the intermediate file and interacts with the Python script through the intermediate file. This mechanism is usually used for tasks such as automated verification, analysis of simulation results, and report generation. Specifically, the key information generated during the simulation process may include configuration and parameters, simulation results, coverage data, assertion and error reports, and performance indicators.
[0036] Configuration and parameters, such as configuration parameters such as clock frequency, reset time, and test vectors of input signals, as well as configuration of the verification environment, such as bus model and protocol stack settings. Simulation results, such as time series data of input / output signals used to analyze the timing relationship of signals, are used to verify whether the register configuration and state changes meet the expected register values at specific times during the simulation process, such as the rising or falling edge of a signal, the occurrence point of register write or read operations, and other event trigger points. Coverage data, such as tracking the test coverage of each functional module in the design under test to ensure that all functions are verified, and code coverage, including line coverage, condition coverage, and path coverage, are used to ensure that the test cases fully cover the design code. Assertions and error reports, such as the verification results of UVM assertions, can include records of assertion passes and fails, as well as errors and warning information detected during the simulation process for subsequent analysis. Performance indicators, such as delay time measurements of critical paths for performance analysis, throughput measurements such as the rate of data transmission and the execution speed of processor instructions.
[0037] After obtaining key information, Python scripts can usually be used to perform tasks such as automated analysis and report generation, automated regression testing, dynamic adjustment and optimization, and data visualization. For example, Python scripts can process data signals in simulation results and generate statistical data, waveforms, and timing diagrams. Python scripts can also automatically generate verification reports based on simulation results, including coverage analysis, assertion result summary, and performance analysis. For automated regression testing, for example, Python scripts can automatically compare current simulation results with previous benchmark results to check whether there is performance degradation or errors; or, for example, trigger regression testing, that is, based on the analysis results, the automated regression testing process can be started to perform additional verification tasks. For dynamic adjustment and optimization, for example, based on simulation results, Python scripts can generate new configuration files, adjust simulation parameters or test cases to optimize simulation efficiency or coverage; if the simulation involves adaptive or machine learning models, Python scripts can dynamically adjust model parameters for online optimization. For data visualization, for example, Python scripts can visualize simulation data and generate waveform graphs, trend graphs, and heat maps, etc., for a more intuitive understanding of simulation results. Python scripts can also perform interactive analysis, such as with the help of Jupyter Notebook (interactive notebook) or other tools, to provide an interactive data analysis platform.
[0038] Python script can also transfer the actual input data extracted from the simulation process to the reference model to verify whether the behavior of the reference model is consistent with expectations, thereby ensuring the accuracy of the reference model under various input conditions; or perform real-time comparative analysis, such as by transmitting the intermediate results or state information in the simulation to the reference model, Python script can compare the output of the design under test (DUT, Device Under Test) and the reference model in real time to check whether there is deviation or error. However, the above-mentioned traditional interaction mode through intermediate files can cause the UVM verification platform to produce too much handshake logic, resulting in serious coupling of its business logic and handshake logic, and the platform actions are complicated, which also limits the full play of the powerful functions of the python script. The present invention studies the UVM verification platform and the python script interaction mode based on python threads, designs a reference model framework based on python based on the observer mode, and reasonably decouples the logic triggering and business logic of the reference model itself, to solve the problems existing in the above traditional interaction mode.
[0039] In one embodiment, Figure 1 As shown, a UVM verification platform information interaction method based on an observer is provided, which may include the following processing steps S10 to S20:
[0040] S10, obtaining the UVM simulation log path of the UVM verification platform;
[0041] S12, during the simulation verification process of the UVM verification platform on the chip under test, create a python monitoring thread to monitor the UVM simulation log of the UVM verification platform in real time according to the UVM simulation log path; the python monitoring thread is created using the python standard library;
[0042] S14, storing the simulation information captured when real-time monitoring of the UVM simulation log in a dictionary as an observer;
[0043] S16, when the state of the dictionary as the observed object changes, a notification is sent to all observers in the observer list; the observers in the observer list include a reference model based on Python, and the notification is used to instruct the observer to update its own internal dictionary;
[0044] S18, performing post-processing using the simulation information in the dictionary using the reference model updated by the dictionary and outputting the obtained result information to a python log file;
[0045] S20, obtain result information from the python log file through the UVM verification platform.
[0046] It can be understood that, in the process of simulation verification of chip under test, UVM verification platform will print various key information (in the present embodiment, may be called simulation information) produced by simulation process to log file (called UVM simulation log) by default, because the log file also can constantly increase new key information in simulation process, directly reading the log file will cause the information read to be incomplete. So the present embodiment uses python standard library (subprocess) to create a python monitoring thread after research, monitors the log file produced by UVM verification platform in real time, and when there is simulation information output, python monitoring thread can capture the information.
[0047] After the Python monitoring thread obtains the key data and configuration and other simulation information generated by the UVM verification platform, it is stored in the dictionary as the observer. When the state of the dictionary as the observer changes, all observers that depend on it will be notified and automatically update their internal dictionaries. When a certain configuration or a group of configurations in its internal dictionary meets the triggering conditions of an observer, the observer can call the corresponding reference model function, such as Figure 2 shown.
[0048] Observers such as the reference model can use the simulation information in the updated dictionary to perform subsequent predetermined data processing or use it as the input of the reference model for processing. The result information obtained after processing is output to the python log file. After that, the UVM verification platform only needs to obtain the required result information from the python log file. In this way, the UVM verification platform eliminates the need to write simulation information into an intermediate file and send it to the python script. The information interaction changes from active to passive. The information that the UVM verification platform needs to transmit is monitored and obtained in real time by the python monitoring thread. In addition, it should be noted that if Figure 3 In the new information interaction schematic diagram shown, this technical means only needs to call methods in the Python standard library, such as the getcwd method of the Python standard library os, the Popen method and stdout method of the Python standard library subprocess, the search method of the Python standard library re, and the Python standard library logging. There is no need to install other libraries, so it is more convenient to use.
[0049] Specifically, first use the getcwd method of python standard library os to obtain the UVM simulation log path, so that the subsequent python monitoring thread can know the location of the UVM simulation log of the UVM verification platform, then use the Popen method of python standard library subprocess to create a python monitoring thread, then use the stdout method to read the standard output stream of the subprocess (such as the subprocess responsible for UVM simulation log printing), to capture the simulation information that the UVM verification platform continuously generates during the simulation verification process in real time, and then use the search method of python standard library re to find the key characters needed by (python script) (i.e. the key information required for post-processing), so far a monitoring output of the python monitoring thread is completed.
[0050] After the Python script directly obtains the required key characters from the Python monitoring thread, it can use these simulation information to perform the post-processing required by the reference model, such as executing subsequent predetermined data processing or inputting key information to the reference model and other post-processing work. The Python script can use the Python standard library logging to output the result information generated after processing to the Python log file; after the UVM verification platform is configured, it will automatically read the Python log file in a loop until it reads the result information with the indication (i.e., the pre-agreed characters, which can be customized by the user, as long as it can instruct the UVM verification platform to jump out of the reading loop), and then jump out of the reading loop, so that the UVM verification platform can directly obtain the result information it needs from the Python log file.
[0051] The above-mentioned observer-based UVM verification platform information interaction method designs a python-based reference model framework based on the observer mode, rationally decouples the logic trigger of the reference model and the business logic itself, supports adding or reducing observers according to verification requirements without affecting other functional logics, and can flexibly add, delete and configure triggers and business logic. A dictionary-based transaction-level reference model is constructed, and transaction-level broadcast between reference models is fully automatically realized. The handshake operation actively initiated by the UVM verification platform is canceled, and the Python monitoring thread monitors in real time, so that data transmission is independently initiated by the python-based reference model, which greatly improves the reference model data interaction efficiency.
[0052] It should be noted that the observed base class observed uses the Find_key() method (usually used to find the corresponding key in the data structure according to specific conditions. For example, in Python, the corresponding key can be found according to the specific value by traversing the key-value pairs of the dictionary. This method can be implemented through list derivation and the items() method of the dictionary) to receive the dictionary, and all observers who observe this dictionary are added to the observer list through the add() method. If the state of the dictionary as the observer changes, all observers will be notified through the notifyAll() method. The introduction of these methods can be as follows: The add() method is used to add observers to the observer list. The remove() method is used to delete observers from the list. The notifyAll() method is used to notify all observers to update the status. The Find_key() method is used to get data and configuration lists from the dictionary, and then call the NotifyAll() method to update the status of the dictionary inside all observers.
[0053] The observer base class observer is used to observe the observed class. The observer defines an update() method. When the state of the observed dictionary changes, the update() method in the notifyAll() method will update the dictionaries inside all observers. The update() method is used to update the data in the dictionary inside the internal observer, such as Figure 4 shown.
[0054] In one embodiment, Figure 5 As shown, the above step S20 may further include the following steps:
[0055] S22, when the UVM verification platform completes the simulation verification of the chip under test or the python monitoring thread monitors the custom key string, the python monitoring thread is terminated and the occupied resources are released.
[0056] It can be understood that in this embodiment, the python monitoring thread can use the existing re.search() method to monitor in real time whether the last line newly added to the UVM simulation log contains a specified variable name. When the value of the variable name meets the condition for closing the thread, the existing subprocess.termiante() method can be used to close the python monitoring thread.
[0057] In the present embodiment, or the UVM verification platform and the python monitoring thread may jointly agree on a flag string, when the python monitoring thread checks the monitored new content and finds the flag string, the python monitoring thread may be closed using the existing subprocess.termiante() method. Or a child thread may be separately initiated, specifically for monitoring the variables or flag strings used to control the end of the python monitoring thread in the UVM simulation log, and the triggering python monitoring thread of the child thread ends when the variable or flag string is monitored.
[0058] In the present embodiment, or the timeout mechanism can also be used to realize the termination and resource release of the python monitoring thread: the UVM verification platform can set a timeout, and when the simulation timeout ends, the python monitoring thread will also automatically end therewith. Wherein, whether the python monitoring thread ends normally (simulation ends), or is forced to end (monitoring a specified flag), as long as after the captured data is processed, the thread is closed after being output to the python log file, because the required result information has been put into the python log file and resources will not be leaked.
[0059] It should be understood that although Figure 1 and Figure 5 The steps in the method are shown in sequence as indicated by the arrows, but the steps are not necessarily executed in the order indicated by the arrows. Unless otherwise specified in this document, there is no strict order restriction for the execution of the steps, and the steps can be executed in other orders. Figure 1 and Figure 5 At least part of the steps may include multiple sub-steps or multiple stages. These sub-steps or stages are not necessarily executed at the same time, but can be executed at different times. The execution order of these sub-steps or stages is not necessarily sequentially, but can be executed in turn or alternately with other steps or at least part of the sub-steps or stages of other steps.
[0060] In one embodiment, Figure 6As shown, an observer-based UVM verification platform information interaction system 100 is provided, which may include a path acquisition module 11, a monitoring creation module 13, an information transmission module 15, an observation notification module 17, a post-processing module 19 and a result acquisition module 21. Among them, the path acquisition module 11 is used to obtain the UVM simulation log path of the UVM verification platform. The monitoring creation module 13 is used to create a python monitoring thread to monitor the UVM simulation log of the UVM verification platform in real time according to the UVM simulation log path during the simulation verification process of the UVM verification platform on the chip under test; the python monitoring thread is created using the python standard library. The information transmission module 15 is used to store the simulation information captured when the UVM simulation log is monitored in real time in the dictionary as the observer. The observation notification module 17 is used to send a notification to all observers in the observer list when the state of the dictionary as the observer changes; the observer in the observer list includes a reference model based on python, and the notification is used to instruct the observer to update its internal dictionary. The post-processing module 19 is used to use the simulation information in the dictionary to perform post-processing through the reference model after the dictionary is updated and output the obtained result information to the python log file. The result acquisition module 21 is used to obtain result information from the python log file through the UVM verification platform.
[0061] The above-mentioned observer-based UVM verification platform information interaction system 100 designs a python-based reference model framework based on the observer mode, rationally decouples the logic trigger of the reference model from the business logic itself, supports adding or reducing observers according to verification requirements without affecting other functional logics, and can flexibly add, delete and configure triggers and business logic, constructs a dictionary-based transaction-level reference model, fully automatically implements transaction-level broadcasting between reference models, cancels the handshake operation actively initiated by the UVM verification platform, and is monitored in real time by the python monitoring thread, so that data transmission is independently initiated by the python-based reference model, which greatly improves the reference model data interaction efficiency.
[0062] In one embodiment, the above-mentioned observer-based UVM verification platform information interaction system 100 may also include a thread termination module, which is used to terminate the python monitoring thread and release occupied resources when the UVM verification platform completes the simulation verification of the chip under test or the python monitoring thread monitors a custom key string.
[0063] Regarding the specific limitation of the UVM verification platform information interaction system 100 based on the observer, please refer to the corresponding limitation of the UVM verification platform information interaction method based on the observer above, which will not be repeated here. Each module in the above-mentioned UVM verification platform information interaction system 100 based on the observer can be implemented in whole or in part by software, hardware and a combination thereof. Each of the above-mentioned modules can be embedded in or independent of a device with a data processing function in the form of hardware, or can be stored in the memory of the aforementioned device in the form of software, so that the processor can call and execute the operations corresponding to the above modules. The aforementioned device can be, but is not limited to, various types of verification computer devices already available in the art.
[0064] In one embodiment, a computer device is provided, including a memory and a processor, wherein the memory stores a computer program, and the processor implements the following processing steps when executing the computer program: obtaining a UVM simulation log path of a UVM verification platform; during the simulation verification process of a chip under test by the UVM verification platform, creating a python monitoring thread to monitor the UVM simulation log of the UVM verification platform in real time according to the UVM simulation log path; the python monitoring thread is created using a python standard library; the simulation information captured when the UVM simulation log is monitored in real time is stored in a dictionary as an observer; when the state of the dictionary as an observer changes, a notification is sent to all observers in an observer list; the observers in the observer list include a reference model based on python, and the notification is used to instruct the observer to update its own internal dictionary; the reference model after the dictionary is updated uses the simulation information in the dictionary for post-processing and outputs the obtained result information to a python log file; and the result information is obtained from the python log file through the UVM verification platform.
[0065] In one embodiment, when the processor executes the computer program, the added steps or sub-steps in each embodiment of the above-mentioned observer-based UVM verification platform information interaction method can also be implemented.
[0066] In one embodiment, a computer-readable storage medium is provided, on which a computer program is stored. When the computer program is executed by a processor, the following processing steps are implemented: obtaining a UVM simulation log path of a UVM verification platform; during the simulation verification process of a chip under test by the UVM verification platform, creating a python monitoring thread to monitor the UVM simulation log of the UVM verification platform in real time according to the UVM simulation log path; the python monitoring thread is created using a python standard library; the simulation information captured when the UVM simulation log is monitored in real time is stored in a dictionary as an observer; when the state of the dictionary as an observer changes, a notification is sent to all observers in an observer list; the observers in the observer list include a reference model based on python, and the notification is used to instruct the observer to update its own internal dictionary; the reference model after the dictionary is updated uses the simulation information in the dictionary for post-processing and outputs the obtained result information to a python log file; and the result information is obtained from the python log file through the UVM verification platform.
[0067] In one embodiment, when the computer program is executed by a processor, the steps or sub-steps added in each embodiment of the above-mentioned observer-based UVM verification platform information interaction method can also be implemented.
[0068] Those skilled in the art can understand that all or part of the processes in the above-mentioned embodiments can be completed by instructing the relevant hardware through a computer program. The computer program can be stored in a non-volatile computer-readable storage medium. When the computer program is executed, it can include the processes of the embodiments of the above-mentioned methods. Among them, any reference to memory, storage, database or other media used in the embodiments provided by the present invention can include non-volatile and / or volatile memory. Non-volatile memory can include read-only memory (ROM), programmable ROM (PROM), electrically programmable ROM (EPROM), electrically erasable programmable ROM (EEPROM) or flash memory. Volatile memory can include random access memory (RAM) or external cache memory. As an illustration and not limitation, RAM is available in many forms, such as static RAM (SRAM), dynamic RAM (DRAM), synchronous DRAM (SDRAM), double data rate SDRAM (DDRSDRAM), enhanced SDRAM (ESDRAM), synchronous link (Synchlink) DRAM (SLDRAM), memory bus dynamic random access memory (RambusDRAM, referred to as RDRAM) and interface dynamic random access memory (DRDRAM).
[0069] The technical features of the above embodiments may be combined arbitrarily. To make the description concise, not all possible combinations of the technical features in the above embodiments are described. However, as long as there is no contradiction in the combination of these technical features, they should be considered to be within the scope of this specification.
[0070] The above embodiments only express several implementation methods of the present invention, and the descriptions thereof are relatively specific and detailed, but they cannot be understood as limiting the scope of protection of the invention. It should be pointed out that, for those of ordinary skill in the art, several modifications and improvements can be made without departing from the concept of the present invention, which all belong to the scope of protection of the present invention. Therefore, the scope of protection of the present invention shall be subject to the attached claims.
Claims
1. A UVM verification platform information interaction method based on an observer, characterized in that: Includes steps: Get the UVM simulation log path of the UVM verification platform; During the simulation verification process of the chip under test by the UVM verification platform, a python monitoring thread is created to monitor the UVM simulation log of the UVM verification platform in real time according to the UVM simulation log path; the python monitoring thread is created using the python standard library; The simulation information captured when the UVM simulation log is monitored in real time is stored in a dictionary as an observer; When the state of the dictionary as the observed object changes, a notification is sent to all observers in the observer list; the observers in the observer list include a reference model based on Python, and the notification is used to instruct the observer to update its own internal dictionary; The reference model updated by the dictionary uses the simulation information in the dictionary for post-processing and outputs the obtained result information to the python log file; The result information is obtained from the python log file through the UVM verification platform.
2. The UVM verification platform information interaction method based on the observer according to claim 1, characterized in that, After the step of obtaining the result information from the python log file through the UVM verification platform, the step further includes: When the UVM verification platform completes the simulation verification of the chip under test or the Python monitoring thread monitors a customized key string, the Python monitoring thread is terminated and the occupied resources are released.
3. An observer-based UVM verification platform information interaction system, characterized in that: include: A path acquisition module is used to obtain the UVM simulation log path of the UVM verification platform; A monitoring creation module is used to create a python monitoring thread to monitor the UVM simulation log of the UVM verification platform in real time according to the UVM simulation log path during the simulation verification process of the chip under test on the UVM verification platform; the python monitoring thread is created using the python standard library; An information transfer module is used to store the simulation information captured when the UVM simulation log is monitored in real time in a dictionary as an observer; An observation notification module, used to send a notification to all observers in an observer list when the state of the observed dictionary changes; the observers in the observer list include a reference model based on Python, and the notification is used to instruct the observer to update its own internal dictionary; A post-processing module, used to perform post-processing using the simulation information in the dictionary through the reference model updated by the dictionary and output the obtained result information to a python log file; A result reading module is used to obtain the result information from the python log file through the UVM verification platform.
4. The UVM verification platform information interaction system based on the observer according to claim 3, characterized in that, Also includes: The thread ending module is used for ending the python monitoring thread and releasing occupied resources when the UVM verification platform completes the simulation verification of the chip under test or the python monitoring thread monitors a custom key string.
5. A computer device comprising a memory and a processor, wherein the memory stores a computer program, wherein: When the processor executes the computer program, the steps of the observer-based UVM verification platform information interaction method according to claim 1 or 2 are implemented.
6. A computer-readable storage medium having a computer program stored thereon, characterized in that: When the computer program is executed by a processor, the steps of the observer-based UVM verification platform information interaction method according to claim 1 or 2 are implemented.