Vehicle gauge chip PKI verification system and verification method based on UVM and python

Abstract

The invention relates to a vehicle gauge chip PKI verification system and verification method based on UVM and python, because a PKI module supports large number operation, systemverilog cannot directly realize large number complex operation, and the large number can only be divided into decimal numbers for operation through a specific algorithm, after research in the scheme, a UVM verification platform and a python platform are determined to be combined, so that the verification efficiency of the vehicle gauge chip PKI verification system is improved, and the verification efficiency of the vehicle gauge chip PKI verification system is improved. Therefore, a special python reference model is compiled by ingeniously utilizing the characteristic that a python platform can directly perform large number operation, the configuration data in the UVM simulation log file is continuously monitored through the monitoring thread script, the configuration data does not need to be written into an intermediate file in a UVM verification environment, then the intermediate file is read by the python reference model for handshake, and the operation efficiency is improved. Therefore, the verification efficiency is effectively improved, and complete verification of the PKI (algorithm) module is efficiently realized.

Description

Technical Field

[0001] This invention belongs to the field of chip verification technology, and relates to an automotive-grade chip PKI verification system and method based on UVM and Python. Background Technology

[0002] As automotive chips become increasingly demanding in terms of security and connectivity, PKI (Public Key Infrastructure) modules are becoming more and more important. The role of a PKI module is to implement functions such as public key encryption, private key decryption, digital signature verification, and basic mathematical operations. It can protect secure communication between devices, protect data from man-in-the-middle attacks or other security threats, and ensure device authentication, data encryption, and integrity through encryption and signing. Furthermore, it can protect data transmission during remote firmware updates in automobiles, ensuring the integrity and security authentication of remote firmware update files and preventing malware injection. PKI hardware supports hardware acceleration, making encryption, decryption, and signature verification operations more efficient. PKI can also reduce the CPU's computational burden, improving system performance and response speed.

[0003] Therefore, thorough verification of the PKI module is essential. However, since the PKI module supports large number operations, with calculation parameters up to 4096 bits in length and results up to 8192 bits in length, the SystemVerilog language used in the UVM verification environment cannot directly perform complex calculations on large-bit-width data parameters. The conventional approach is to split the large-bit-width data and then perform calculations using a specific algorithm, but this process is quite complex. Therefore, how to achieve efficient PKI verification has become one of the technical problems to be solved. Summary of the Invention

[0004] To address the problems existing in the above-mentioned traditional technologies, this invention proposes an automotive-grade chip PKI verification system based on UVM and Python, as well as an automotive-grade chip PKI verification method based on UVM and Python, which can achieve efficient automotive-grade chip PKI verification.

[0005] To achieve the above objectives, the embodiments of the present invention adopt the following technical solutions: On the one hand, a PKI verification system for automotive-grade chips based on UVM and Python is provided, including a Python reference model and a top-level file of a UVM verification environment created based on the UVM verification methodology. The top-level file includes a test case base class and a design under test instantiated based on the design code of the PKI module under test. The test case base class is used to instantiate PKI environment components and PKI process task components. The Python reference model communicates with the PKI process components. The PKI process task component is used to start an external Python reference model, continuously attempt to read parameter data from the Python log file generated by the Python reference model until a pre-defined end marker is read, then obtain all parameter data of the selected large number arithmetic algorithm and the address of the registers of the design under test (DUT), and write the obtained parameter data to the corresponding address through a backdoor based on the register address; the PKI process task component is also used to write random configuration data generated by its internal PKI global configuration component to the registers of the DUT through the register model, and print the random configuration data to the simulation log file; the PKI process task component is also used to check the interrupt and other flag bits of the DUT based on the random configuration data, and compare it with the expected results obtained from the Python log file to obtain the verification results; The Python reference model includes a monitoring thread script, a dictionary, and a data processing module. The monitoring thread script monitors all configuration data in the UVM simulation log and writes all configuration data into the dictionary. The dictionary is used to pass the configuration data to the data processing module for processing. Finally, all parameter data, addresses, and expected results of the selected large number arithmetic algorithm are written to the Python log file.

[0006] On the other hand, a UVM and Python-based automotive-grade chip PKI verification method is also provided, which is applied to an automotive-grade chip PKI verification system based on UVM and Python. The automotive-grade chip PKI verification system includes a Python reference model and a top-level file of a UVM verification environment created based on the UVM verification methodology. The top-level file includes a test case base class and a design under test instantiated based on the design code of the PKI module under test. The test case base class is used to instantiate PKI environment components and PKI process task components. The Python reference model communicates with the PKI process components. The Python reference model includes a monitoring thread script, a dictionary, and a data processing module. The monitoring thread script monitors all configuration data in the UVM simulation log and writes all configuration data into the dictionary. The dictionary is used to pass the configuration data to the data processing module for processing. Finally, all parameter data, addresses, and expected results of the selected large number arithmetic algorithm are written to the Python log file. The above-mentioned automotive-grade chip PKI verification method based on UVM and Python includes the following steps: After the UVM verification environment completes the initialization of the clock, it starts the created test cases and enters the verification process. Random configuration data is generated through the PKI process task component and printed in the UVM simulation log; Start the Python reference model using the PKI process task component; When the PKI process task component reads the agreed-upon end marker from the Python log file, obtains all the parameter data of the selected large number arithmetic algorithm and the address of the register of the design under test, it writes the obtained parameter data to the corresponding address through a backdoor based on the address of the register. The PKI process task component writes the random configuration data generated by its internal PKI global configuration component into the register of the design under test through a register model, and prints the random configuration data to the simulation log file. After the PKI process task component checks the interruption and other flag bits of the design under test based on random configuration data, it compares the results with the expected results obtained from the Python log file to obtain the verification results.

[0007] One of the above technical solutions has the following advantages and beneficial effects: The aforementioned automotive-grade chip PKI verification system and method based on UVM and Python suffer from several drawbacks. The PKI module supports large number operations, while SystemVerilog cannot directly perform complex large number calculations. Instead, it relies on specific algorithms to break down large numbers into smaller ones. This approach is hardware-intensive and not convenient for verification. This solution combines the UVM verification platform with the Python platform, cleverly utilizing Python's ability to directly perform large number operations to develop a dedicated Python reference model. A monitoring thread script continuously monitors the configuration data in the UVM simulation log file, eliminating the need for the UVM verification environment to write configuration data into an intermediate file before the Python reference model reads the intermediate file for handshaking. This significantly improves verification efficiency and solves the problem of SystemVerilog's inability to directly perform complex large number calculations in a concise and efficient manner, effectively achieving complete verification of the PKI (algorithm) module. Attached Figure Description

[0008] To more clearly illustrate the technical solutions in the embodiments of the present invention or the conventional technology, the drawings used in the description of the embodiments or the conventional technology will be briefly introduced below. Obviously, the drawings described below are only some embodiments of the present invention. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0009] Figure 1 This is a block diagram of a PKI verification system for automotive-grade chips based on UVM and Python, as shown in one embodiment. Figure 2 This is a schematic diagram of the verification workflow of an automotive-grade chip PKI verification system based on UVM and Python in one embodiment. Figure 3 This is a flowchart illustrating the interaction between a Python reference model and the UVM verification environment of the UVM verification platform in one embodiment. Figure 4 This is a flowchart illustrating a method for verifying automotive-grade chips using UVM and Python, as described in one embodiment. Detailed Implementation

[0010] To make the objectives, technical solutions, and advantages of this invention clearer, the invention will be further described in detail below with reference to the accompanying drawings and embodiments. It should be understood that the specific embodiments described herein are merely illustrative and not intended to limit the invention. Unless otherwise defined, all technical and scientific terms used herein have the same meaning as commonly understood by one of ordinary skill in the art to which this invention pertains. The terminology used in this specification is for the purpose of describing particular embodiments only and is not intended to limit the invention.

[0011] It should be noted that, in this document, the reference to "embodiment" means that a specific feature, structure, or characteristic described in connection with an embodiment may be included in at least one embodiment of the invention. The presentation of this phrase in various places throughout the specification does not necessarily refer to the same embodiment, nor is it a separate or alternative embodiment mutually exclusive with other embodiments. Those skilled in the art will understand that the embodiments described herein can be combined with other embodiments. The term "and / or" as used in this specification and the appended claims refers to any combination of one or more of the associated listed items, and all possible combinations thereof.

[0012] The embodiments of the present invention will now be described in detail with reference to the accompanying drawings.

[0013] In one embodiment, such as Figure 1As shown, a PKI verification system for automotive-grade chips based on UVM and Python is provided, including a Python reference model and a top-level file for a UVM verification environment created based on the UVM verification methodology. The top-level file includes a test case base class and a design under test (DUT) instantiated from the design code of the PKI module under test. The test case base class is used to instantiate PKI environment components and PKI process task components. The Python reference model communicates with the PKI process components. The PKI process task component starts the external Python reference model, continuously attempts to read parameter data from the Python log file generated by the Python reference model, until a pre-defined end marker is encountered, then obtains all parameter data for the selected large number arithmetic algorithm and the address of the registers of the DUT, and writes the obtained parameter data to the corresponding address via a backdoor based on the register address. The PKI process task component also writes random configuration data generated by its internal PKI global configuration component into the registers of the DUT through a register model and prints the random configuration data to the simulation log file. The PKI process task component further checks the interrupt and other flag bits of the DUT based on the random configuration data and compares it with the expected results obtained from the Python log file to obtain the verification results.

[0014] The Python reference model includes a monitoring thread script, a dictionary, and a data processing module. The monitoring thread script monitors all configuration data in the UVM simulation log and writes all configuration data into a dictionary. The dictionary is used to pass the configuration data to the data processing module for processing. Finally, all parameter data, addresses, and expected results of the selected large number arithmetic algorithm are written to the Python log file.

[0015] It is understandable that the design of each component in the aforementioned automotive-grade chip PKI verification system based on UVM and Python follows existing UVM verification methodologies. Based on the detailed verification requirements of the PKI module functions, a verification system is built on the UVM verification platform to configure the corresponding functional components and complete basic operations such as connection and connectivity testing between components to ensure normal data flow between components during the verification process. This embodiment sends the PKI module's data and configuration to a Python reference model (i.e., a reference model component written in Python) outside the UVM verification environment. The Python reference model performs large number operations, and a monitoring thread script obtains the PKI module's configuration. This eliminates the need for additional intermediate files, thus improving overall efficiency and solving the problem that SystemVerilog cannot perform large-bit-width data operations in the UVM verification environment.

[0016] Specifically, such as Figure 1As shown, the top-level file (TB) of the UVM verification environment created based on the UVM verification methodology includes a test case base class (pki_base_test) and a Design Under Test (DUT) instantiated from the design code of the PKI module under test. The test case base class is used to instantiate the PKI environment component (pki_env) and the PKI process task component (pki_process). The clock signals and reset signals required during the operation of the UVM verification environment can be provided by the existing clock and reset components in the UVM verification environment. After the UVM verification environment completes clock initialization, the created test cases can be started to verify the design under test. The Python reference model outside the UVM verification environment is a reference model component written using the feature of Python scripts that can directly perform large number operations. The Python reference model communicates with the PKI process components.

[0017] The PKI workflow task component is used to launch an external Python reference model (this task is denoted as `run_pki_ref_py`). The Python reference model uses its internal monitoring thread script to continuously monitor the UVM simulation logs of the UVM verification environment during the simulation. After launching the external Python reference model, the PKI workflow task component continuously attempts to read parameter data from the Python log files generated by the Python reference model until a pre-defined end marker is encountered, obtaining all parameter data for the selected algorithm and the addresses of one or more registers (memory). Based on the register addresses, the obtained parameter data is then written to the corresponding addresses via a backdoor (this task is denoted as `set_mem_param_from_py`). Subsequently, the PKI workflow task component writes random configuration data generated by its internal PKI global configuration component (`pki_global_cfg`) into the registers of the design under test through the register model of the UVM verification environment, and prints the random configuration data to a simulation log file (a type of log file in UVM simulation logs) for monitoring by the monitoring thread script in the Python reference model (this task is denoted as `reg_cfg`). Finally, the PKI process task component will be used to check the interrupts and other flags of the design under test (which can be called the actual results) based on the random configuration data. Then, it will compare these results with the expected results of the Python reference model obtained from the Python log file (i.e., the interrupts and other flags expected by the Python reference model based on the random configuration data) to determine if the two results are consistent, thus obtaining the verification results. Figure 2 The diagram shows the verification workflow of an automotive-grade chip PKI verification system based on UVM and Python.

[0018] The Python reference model includes a monitoring thread script, a dictionary, and a data processing module. The monitoring thread script monitors all configuration data in the UVM simulation log and writes all configuration data into the dictionary. The dictionary is used to pass the configuration data to the data processing module for processing. Finally, all parameter data, addresses, and expected results of the selected algorithm (i.e., the existing large number arithmetic algorithm) are written to the Python log file.

[0019] The aforementioned automotive-grade chip PKI verification system based on UVM and Python suffers from several drawbacks. The PKI module supports large number operations, while SystemVerilog cannot directly perform complex large number calculations. Instead, it relies on specific algorithms to break down large numbers into smaller ones. This approach is hardware-intensive and inconvenient for verification. This solution combines the UVM verification platform with the Python platform, cleverly leveraging Python's ability to directly perform large number operations to develop a dedicated Python reference model. A monitoring thread script continuously monitors the configuration data in the UVM simulation log file, eliminating the need for the UVM verification environment to write configuration data into an intermediate file before the Python reference model reads and performs the handshake. This significantly improves verification efficiency and solves the problem of SystemVerilog's inability to directly perform complex large number calculations in a concise and efficient manner, effectively achieving complete verification of the PKI (algorithm) module.

[0020] It should be noted that the specific flowchart of the interaction between the Python reference model and the UVM verification environment of the UVM verification platform can be shown as follows: Figure 3 As shown, the monitoring thread in Python corresponds to the monitoring thread maintained by the monitoring thread script. For a detailed explanation, please refer to the existing implementation process of the monitoring thread and Python script based on Python in the UVM verification. This manual will not elaborate further.

[0021] In one embodiment, the PKI environment component includes a PKI global configuration component, a coverage component, and a PKI monitor. The PKI global configuration component sets basic constraints on access to all registers of the design under test (DUT). These constraints include the type of randomly generated large number arithmetic algorithm, the algorithm's bit width, adjustment factors, and its security configuration. The coverage component generates functional coverage of the DUT. The PKI monitor checks for alarm signals from the DUT.

[0022] Understandable, such as Figure 1As shown, in this embodiment, the PKI environment component Pki_env creates a PKI global configuration component pki_global_cfg, a coverage component (i.e., cov), and a PKI monitor (i.e., pki_mon). The PKI global configuration component Pki_global_cfg is used to impose basic constraints on all register accesses of the design under test, including constraints such as the type of randomly generated large number arithmetic algorithm, algorithm bit width, adjustment factor, and its security configuration. The coverage component is used to generate functional coverage of the design under test, further ensuring the completeness of functional verification. The PKI monitor is used to check for DMA (Direct Memory Access) alarms in the design under test.

[0023] In one embodiment, the aforementioned automotive-grade chip PKI verification system based on UVM and Python may further include a Makefile, which is used to connect the file list of the design under test and the file list of the UVM verification environment. The Makefile includes compiler macros and coverage collection options.

[0024] It is understood that a Makefile was also written and a corresponding compilation tool was selected in this embodiment to connect the file list of the design under test and the file list of the UVM verification environment. Compilation macros and coverage collection options were also added. The Makefile script can also be used to automatically run test cases a specified number of times in the UVM verification environment. The specific Makefile script writing and running process can be understood by referring to the relevant implementation process of existing Makefiles in this field, and will not be elaborated in this specification.

[0025] Each component in the aforementioned automotive-grade chip PKI verification system based on UVM and Python can be implemented entirely or partially through software, hardware, or a combination thereof. These components can be embedded in hardware or independently of a device with data processing capabilities, or stored in software within the memory of the aforementioned device, allowing the processor to call and execute the operations corresponding to each module. The aforementioned device can be, but is not limited to, various types of chip verification computers already existing in the field.

[0026] In one embodiment, a UVM and Python-based automotive-grade chip PKI verification method is provided, applied to an automotive-grade chip PKI verification system based on UVM and Python. This system includes a Python reference model and a top-level file for a UVM verification environment created using the UVM verification methodology. The top-level file includes a test case base class and a design-to-test (DUT) instantiated from the design code of the PKI module under test. The test case base class is used to instantiate PKI environment components and PKI process task components. The Python reference model communicates with the PKI process components. The Python reference model includes a monitoring thread script, a dictionary, and a data processing module. The monitoring thread script monitors all configuration data in the UVM simulation log and writes all configuration data into the dictionary. The dictionary passes the configuration data to the data processing module for processing. Finally, all parameter data, addresses, and expected results of the selected large number arithmetic algorithm are written to the Python log file.

[0027] like Figure 4 As shown, the automotive-grade chip PKI verification method based on UVM and Python includes the following steps S10 to S20: S10, After the UVM verification environment completes the initialization clock, it starts the created test cases and enters the verification process. S12, generates random configuration data through the PKI process task component and prints it in the UVM simulation log; S14, Start the Python reference model through the PKI process task component; S16, when the PKI process task component reads the agreed end marker from the Python log file, obtains all the parameter data of the selected large number arithmetic algorithm and the address of the register of the design under test, and writes the obtained parameter data to the corresponding address through a backdoor according to the address of the register. S18, through the PKI process task component, writes the random configuration data generated by its internal PKI global configuration component into the register of the design under test through the register model, and prints the random configuration data to the simulation log file; S20, after the PKI process task component checks the interruption and other flag bits of the design under test according to the random configuration data, it compares the results with the expected results obtained from the Python log file to obtain the verification results.

[0028] The aforementioned automotive-grade chip PKI verification method based on UVM and Python suffers from several drawbacks. The PKI module supports large number operations, while SystemVerilog cannot directly perform complex large number calculations. Instead, it relies on specific algorithms to break down large numbers into smaller ones. This approach is hardware-oriented and not convenient for verification. This solution combines the UVM verification platform with the Python platform, cleverly utilizing Python's ability to directly perform large number operations to create a dedicated Python reference model. A monitoring thread script continuously monitors the configuration data in the UVM simulation log file, eliminating the need for the UVM verification environment to write configuration data into an intermediate file before the Python reference model reads the file for handshaking. This significantly improves verification efficiency and solves the problem of SystemVerilog's inability to directly perform complex large number calculations in a concise and efficient manner, effectively achieving complete verification of the PKI (algorithm) module.

[0029] In one embodiment, the PKI environment component includes a PKI global configuration component, a coverage component, and a PKI monitor. The PKI global configuration component sets basic constraints on access to all registers of the design under test (DUT). These constraints include the type of random large number arithmetic algorithm, the algorithm's bit width, adjustment factors, and its security configuration. The coverage component generates functional coverage of the DUT, and the PKI monitor checks for alarm signals from the DUT.

[0030] In one embodiment, the above-mentioned automotive-grade chip PKI verification system also includes a Makefile, which is used to connect the file list of the design under test and the file list of the UVM verification environment. The Makefile includes compiler macros and coverage collection options.

[0031] For specific limitations regarding the UVM and Python-based automotive-grade chip PKI verification method, please refer to the corresponding limitations of the UVM and Python-based automotive-grade chip PKI verification system mentioned above, which will not be repeated here.

[0032] It should be understood that although Figure 4 The steps are shown sequentially as indicated by the arrows, but these steps are not necessarily executed in the order indicated by the arrows. Unless otherwise specified in this document, there is no strict order in which these steps are executed; they can be performed in other orders. Figure 4At least some 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 sequential, but can be executed in turn or alternately with other steps or at least some of the sub-steps or stages of other steps.

[0033] Those skilled in the art will understand that all or part of the processes in the methods of the above embodiments can be implemented by a computer program instructing related hardware. The computer program can be stored in a non-volatile computer-readable storage medium. When executed, the computer program can include the processes of the embodiments of the above methods. Any references to memory, storage, databases, or other media used in the embodiments provided by this 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. By way of illustration and not limitation, RAM is available in various forms, such as static RAM (SRAM), dynamic RAM (DRAM), synchronous DRAM (SDRAM), dual data rate SDRAM (DDRSDRAM), enhanced SDRAM (ESDRAM), synchronous link DRAM (SLDRAM), memory bus DRAM (RDRAM), and interface DRAM (DRDRAM), etc.

[0034] The technical features of the above embodiments can be combined in any way. For the sake of brevity, 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.

[0035] The above embodiments merely illustrate several implementation methods of the present invention, and their descriptions are relatively specific and detailed, but they should not be construed as limiting the scope of protection of the invention. It should be noted that those skilled in the art can make various modifications and improvements without departing from the concept of the present invention, and all such modifications and improvements fall within the scope of protection of the present invention. Therefore, the scope of protection of the present invention should be determined by the appended claims.

Claims

1. A car chip PKI verification system based on UVM and python, characterized by: The invention comprises a python reference model and a top-level file of a UVM verification environment created based on a UVM verification methodology, wherein the top-level file comprises a test case base class and a design to be tested instantiated based on a design code of a PKI module to be tested, wherein the test case base class is used to instantiate a PKI environment component and a PKI process task component, and the python reference model is communicatively connected with the PKI process component; The PKI process task component is used to start an external python reference model, and continuously try to read parameter data from the python log file generated by the python reference model until the agreed end sign is read, and then all parameter data of the selected large number operation algorithm and the address of the register of the design to be tested are obtained, and the obtained parameter data is written to the corresponding address through the backdoor method according to the address of the register; the PKI process task component is also used to write the random configuration data generated by the internal PKI global configuration component of the PKI into the register of the design to be tested through the register model, and print the random configuration data into the simulation log file, and the PKI process task component is also used to check the interrupt and other flag bits of the design to be tested according to the random configuration data, and compare them with the expected results obtained from the python log file to obtain the verification result; The python reference model includes a monitoring thread script, a dictionary and a data processing module. The monitoring thread script is used to monitor all configuration data in the UVM simulation log and write all configuration data into the dictionary. The dictionary is used to pass the configuration data to the data processing module for processing. Finally, all parameter data, addresses and expected results of the selected large number operation algorithm obtained are written into the python log file.

2. According to claim 1, the automotive chip PKI verification system based on UVM and python is characterized in that: The PKI environment component includes a PKI global configuration component, a coverage component and a PKI monitor; The PKI global configuration component is used to perform basic constraints on all accesses to the registers of the design to be tested, wherein the basic constraints include the type of random large number operation algorithm, the algorithm bit width, the adjustment factor and its security configuration; The coverage component is used to generate functional coverage of the design under test, and the PKI monitor is used to check the alarm signal of the design under test.

3. The automotive chip PKI verification system based on UVM and python according to claim 1 or 2, characterized in that: The invention also includes a prepared Makefile file, wherein the Makefile file is used to connect the file list of the design to be tested and the file list of the UVM verification environment, and the Makefile file is added with compilation macros and coverage collection options.

4. A PKI verification method for automotive chips based on UVM and python, characterized in that: Applied to a UVM and python-based automotive chip PKI verification system, the automotive chip PKI verification system includes a python reference model and a top-level file of a UVM verification environment created based on a UVM verification methodology, the top-level file includes a test case base class and a design to be tested instantiated based on the design code of the PKI module to be tested, the test case base class is used to instantiate a PKI environment component and a PKI process task component, and the python reference model is communicatively connected with the PKI process component; The python reference model includes a monitoring thread script, a dictionary and a data processing module, wherein the monitoring thread script is used to monitor all configuration data in the UVM simulation log and write all configuration data into the dictionary, and the dictionary is used to transfer the configuration data to the data processing module for processing, and finally all parameter data, addresses and expected results of the selected large number operation algorithm obtained are written into the python log file; The automotive chip PKI verification method based on UVM and python includes the following steps: After the UVM verification environment completes the initialization clock, the created test case is started to enter the verification process; Generate random configuration data through the PKI process task component and print it in the UVM simulation log; Start the python reference model through the PKI process task component; When the PKI process task component reads the agreed end sign from the python log file, it obtains all parameter data of the selected large number operation algorithm and the address of the register of the design to be tested, and writes the obtained parameter data to the corresponding address through the backdoor method according to the address of the register; The PKI process task component writes the random configuration data generated by the PKI global configuration component inside the PKI process task component into the register of the design to be tested through the register model, and prints the random configuration data into the simulation log file; After checking the interrupt and other flag bits of the design to be tested according to the random configuration data through the PKI process task component, the verification result is compared with the expected result obtained from the python log file.

5. According to claim 4, the UVM and python-based automotive chip PKI verification method is characterized in that: The PKI environment component includes a PKI global configuration component, a coverage component and a PKI monitor; The PKI global configuration component is used to perform basic constraints on all accesses to the registers of the design to be tested, wherein the basic constraints include the type of random large number operation algorithm, the algorithm bit width, the adjustment factor and its security configuration; The coverage component is used to generate functional coverage of the design under test, and the PKI monitor is used to check the alarm signal of the design under test.

6. The automotive chip PKI verification method based on UVM and python according to claim 4 or 5, characterized in that: The automotive chip PKI verification system also includes a written Makefile file, which is used to connect the file list of the design to be tested and the file list of the UVM verification environment. The Makefile file adds compilation macros and coverage collection options.

Images