Verification environment configuration method and device, electronic device, and storage medium

Abstract

A configuration method and device of a verification environment, an electronic device, and a storage medium. The configuration method of the verification environment includes reading a configuration file, obtaining a construction program of the verification environment, and traversing a plurality of class members to perform configuration processing on the plurality of class members to configure the verification environment. The configuration processing includes determining at least one simulation parameter corresponding to each class member according to configuration information corresponding to the simulation parameter, and setting the class member according to the at least one simulation parameter. The configuration method automatically reads the configuration file and inputs the simulation parameter into the verification environment, has flexible configuration and strong scalability, can arbitrarily add or delete class members that need to be configured, supports accurate configuration, supports differentiated configuration when the same class is instantiated into different objects, and improves simulation running speed without complex parameter import and code parsing.

Description

Technical Field

[0001] Embodiments of this disclosure relate to a method for configuring a verification environment, a device for configuring a verification environment, an electronic device, and a non-transitory computer-readable storage medium. Background Technology

[0002] Chip verification involves using appropriate verification languages, tools, or methods to verify, before chip production, whether the chip design meets the defined chip specifications, whether risks have been fully mitigated, and whether all defects have been identified and corrected. The main tasks of chip verification include writing test stimuli, setting up the verification environment, or using an existing verification environment to verify and regress the device under test. For example, the verification environment may be built based on UVM (Universal Verification Methodology) or a high-level hardware language such as System Verilog. Summary of the Invention

[0003] At least one embodiment of this disclosure provides a method for configuring a verification environment, comprising: a method for configuring a verification environment, comprising: reading a configuration file, wherein the configuration file includes multiple simulation parameters for constructing the verification environment and configuration information corresponding to the multiple simulation parameters respectively; obtaining a construction program for the verification environment, wherein the construction program includes multiple class members; traversing the multiple class members and performing configuration processing on the multiple class members to configure the verification environment; wherein the configuration processing includes: determining at least one simulation parameter corresponding to each class member according to the configuration information corresponding to the multiple simulation parameters respectively; and setting the class member according to the corresponding at least one simulation parameter.

[0004] For example, in at least one embodiment of this disclosure, a method for configuring a verification environment is provided. The construction program includes at least one top-level class, and each class member is located in the at least one top-level class or in a subclass of the at least one top-level class. The method involves traversing the multiple class members and performing configuration processing on the multiple class members to configure the verification environment. This includes: starting from the at least one top-level class, traversing the multiple class members in the order from the top-level class to the subclass, and performing configuration processing on the multiple class members sequentially to configure the verification environment.

[0005] For example, in at least one embodiment of this disclosure, a method for configuring a verification environment is provided. Starting from the at least one top-level class, the plurality of class members are traversed in order from the top-level class to the subclasses, and configuration processing is performed on the plurality of class members in sequence to configure the verification environment. The method includes: for any top-level class, determining whether there are class members in the any top-level class; in response to the existence of class members in the any top-level class, performing the configuration processing on all class members in the any top-level class; in response to the fact that the any top-level class includes at least one subclass, traversing all class members in the at least one subclass in the any top-level class, and performing the configuration processing on all class members in the at least one subclass in the any top-level class, until all the plurality of class members have been traversed.

[0006] For example, in at least one embodiment of this disclosure, a method for configuring a verification environment is provided. The configuration information corresponding to each simulation parameter includes the name and hierarchical relationship of the simulation parameter. Based on the configuration information corresponding to the plurality of simulation parameters, at least one simulation parameter corresponding to each class member is determined, including: determining the name of the class member and the class inheritance relationship of the class member in the construction program; initializing the class member; traversing the plurality of simulation parameters, and determining at least one simulation parameter that matches the name and class inheritance relationship of the initialized class member based on the name and hierarchical relationship corresponding to the plurality of simulation parameters respectively.

[0007] For example, in at least one embodiment of this disclosure, a method for configuring a verification environment is provided. Initializing the class member includes: determining the type of the class member; setting an initial value for the class member in response to the class member's type not being an array; and creating a corresponding array based on the array structure defined by the class member in response to the class member's type being a fixed-length array, and setting the initial values ​​of the elements included in the corresponding array.

[0008] For example, in at least one embodiment of this disclosure, a method for configuring a verification environment is provided. Initializing the class member further includes: marking the class member in response to the class member being a variable-length array; and after traversing all class members whose type is not a variable-length array, determining the class member whose depth information is recorded, creating a variable-length array corresponding to the marked class member based on the value of the class member whose depth information is recorded, and setting the initial value of the elements of the corresponding variable-length array.

[0009] For example, in at least one embodiment of this disclosure, a method for configuring a verification environment is provided, wherein the configuration information corresponding to each simulation parameter further includes the configuration value of the simulation parameter, and setting the class member according to the corresponding at least one simulation parameter includes: updating the value of the class member according to the configuration value of the at least one simulation parameter.

[0010] For example, in at least one embodiment of this disclosure, a method for configuring a verification environment is provided, which sets the class member according to the corresponding at least one simulation parameter, and further includes: randomly disabling the class member.

[0011] For example, in at least one embodiment of this disclosure, a method for configuring a verification environment is provided. The configuration information corresponding to each simulation parameter includes the name, hierarchical relationship, and configuration value of the simulation parameter. Reading the configuration file includes: reading the configuration file and reading the name, configuration value, and hierarchical relationship of each simulation parameter into the verification environment.

[0012] For example, in at least one embodiment of this disclosure, a method for configuring a verification environment is provided, wherein the hierarchical relationship of each simulation parameter represents the class inheritance relationship of the class members corresponding to the simulation parameter in the construction program.

[0013] For example, in at least one embodiment of this disclosure, a method for configuring a verification environment is provided, wherein the configuration process further includes: performing full variable randomization on the plurality of class members.

[0014] At least one embodiment of this disclosure provides a configuration apparatus for a verification environment, comprising: a reading unit configured to read a configuration file, wherein the configuration file includes multiple simulation parameters for constructing the verification environment and configuration information corresponding to the multiple simulation parameters; an acquisition unit configured to acquire a construction program for the verification environment, wherein the construction program includes multiple class members; and a processing unit configured to traverse the multiple class members and perform configuration processing on the multiple class members to configure the verification environment; wherein the configuration processing includes: determining at least one simulation parameter corresponding to each class member based on the configuration information corresponding to the multiple simulation parameters; and setting the class member based on the corresponding at least one simulation parameter.

[0015] At least one embodiment of this disclosure provides an electronic device, including: a memory that non-transitoryly stores computer-executable instructions; and a processor configured to run the computer-executable instructions, wherein the computer-executable instructions, when run by the processor, implement a configuration method for a verification environment according to any embodiment of this disclosure.

[0016] At least one embodiment of this disclosure provides a non-transitory computer-readable storage medium, wherein the non-transitory computer-readable storage medium stores computer-executable instructions, which, when executed by a processor, implement a configuration method for a verification environment according to any embodiment of this disclosure. Attached Figure Description

[0017] To more clearly illustrate the technical solutions of the embodiments of this disclosure, the accompanying drawings of the embodiments will be briefly described below. Obviously, the drawings described below only relate to some embodiments of this disclosure and are not intended to limit this disclosure.

[0018] Figure 1 A schematic flowchart illustrating a method for configuring a verification environment, provided for at least one embodiment of this disclosure;

[0019] Figure 2A A schematic structural diagram of a construction procedure provided for at least one embodiment of this disclosure;

[0020] Figure 2B A schematic diagram of a configuration file provided in at least one embodiment of this disclosure is shown;

[0021] Figure 3 A schematic flowchart illustrating the configuration process provided in at least one embodiment of this disclosure;

[0022] Figure 4 A flowchart illustrating a method for configuring a verification environment provided in at least one embodiment of this disclosure;

[0023] Figure 5 A schematic block diagram of a configuration apparatus for a verification environment provided for at least one embodiment of the present disclosure;

[0024] Figure 6 A schematic diagram of an electronic device provided for at least one embodiment of this disclosure;

[0025] Figure 7 This is a schematic diagram of a non-transitory computer-readable storage medium provided for at least one embodiment of the present disclosure. Detailed Implementation

[0026] To make the objectives, technical solutions, and advantages of the embodiments of this disclosure clearer, the technical solutions of the embodiments of this disclosure will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some, not all, of the embodiments of this disclosure. All other embodiments obtained by those skilled in the art based on the described embodiments of this disclosure without creative effort are within the scope of protection of this disclosure.

[0027] Unless otherwise defined, the technical or scientific terms used in this disclosure shall have the ordinary meaning understood by one of ordinary skill in the art to which this disclosure pertains. The terms "first," "second," and similar terms used in this disclosure do not indicate any order, quantity, or importance, but are merely used to distinguish different components. Terms such as "comprising" or "including" mean that the element or object preceding the word encompasses the elements or objects listed following the word and their equivalents, without excluding other elements or objects. Terms such as "connected" or "linked" are not limited to physical or mechanical connections, but can include electrical connections, whether direct or indirect. Terms such as "upper," "lower," "left," and "right" are used only to indicate relative positional relationships, and these relative positional relationships may change accordingly when the absolute position of the described object changes. To keep the following description of the embodiments of this disclosure clear and concise, detailed descriptions of some known functions and components are omitted.

[0028] Different verification environments can be configured using different environment variables to verify different functions and scenarios of the object under test.

[0029] Currently, during simulation, simulation parameters need to be transmitted to the verification environment first. These parameters vary depending on the function and scenario to be verified, and may include, for example, configuration values ​​for registers. For instance, simulation parameters can be passed to the verification environment using the command "$value$plusargs". Then, corresponding parsing code is written in the build program to parse the simulation parameters, configuring the corresponding class members in the verification environment to the values ​​specified by the simulation parameters. This allows the verification environment to be configured according to the simulation parameters, and then it can verify the corresponding function or simulate the corresponding scenario based on the environment variables specified by the simulation parameters.

[0030] However, this approach has the following problems: the input process is very complex, and the command line for inputting simulation parameters can be very long when there are many input parameters; the parsing is complex and requires writing corresponding parsing code in the build program, making it difficult to maintain a consistent coding style; when a class is instantiated into different objects, the configuration values ​​obtained in different objects are the same, so this method cannot support differentiated configurations when the same class is instantiated into different objects; it does not support configuring class members of the array type; and it cannot perform full variable randomization, resulting in poor randomness and difficulty in converging the verification coverage.

[0031] At least one embodiment of this disclosure provides a method for configuring a verification environment, a device for configuring a verification environment, an electronic device, and a non-transitory computer-readable storage medium. The method for configuring the verification environment includes: reading a configuration file, wherein the configuration file includes multiple simulation parameters for constructing the verification environment and configuration information corresponding to each of the multiple simulation parameters; obtaining a construction program for the verification environment, wherein the construction program includes multiple class members; traversing the multiple class members and performing configuration processing on the multiple class members to configure the verification environment; wherein the configuration processing includes: determining at least one simulation parameter corresponding to each class member based on the configuration information corresponding to each of the multiple simulation parameters; and setting the class member based on the corresponding at least one simulation parameter.

[0032] This configuration method eliminates the need for writing additional input parameter command lines and related parsing code. It automatically reads the configuration file and imports the simulation parameters into the verification environment. The configuration is flexible and highly scalable, allowing for the addition or deletion of class members that need to be configured. It supports precise configuration and differentiated configurations when the same class is instantiated into different objects. Integration with the object under test is simpler, as the same configuration file can be used regardless of whether the object under test is the entire chip or a part of the circuit. Since it eliminates the need for complex parameter import and parsing code, this configuration method improves simulation speed.

[0033] The method for configuring a verification environment provided in at least one embodiment of this disclosure can be applied to a configuration device for a verification environment provided in at least one embodiment of this disclosure. This configuration device can be configured on an electronic device. The electronic device can be a personal computer, a mobile terminal, or a hardware device such as a mobile phone or tablet computer.

[0034] The embodiments of this disclosure will now be described in detail with reference to the accompanying drawings, but this disclosure is not limited to these specific embodiments.

[0035] Figure 1 This is a schematic flowchart illustrating a method for configuring a verification environment, provided for at least one embodiment of the present disclosure.

[0036] For example, this verification environment can be used for any circuit that needs to be tested or verified, such as chip verification or unit testing. For example, if the chip is a system on chip, unit testing is used to verify parts of the circuitry in the system on chip.

[0037] For example, the configuration method of this verification environment can be applied to the verification of all stages of circuit design, such as functional simulation verification, back-end timing verification, hardware simulation acceleration platform verification, etc., and this disclosure does not limit it.

[0038] like Figure 1 As shown, the method for configuring a verification environment provided in at least one embodiment of this disclosure includes steps S10 to S30.

[0039] In step S10, the configuration file is read. For example, the configuration file includes multiple simulation parameters for building the verification environment and the configuration information corresponding to each simulation parameter.

[0040] In step S20, the verification environment build program is obtained.

[0041] For example, a program that sets up a verification environment is called a build program, and build programs are written in languages ​​such as System Verilog.

[0042] A class is a fundamental concept in System Verilog. Similar to other object-oriented languages, classes are key to object-oriented programming. For example, a class can define methods (functions and tasks) and is a structure that encapsulates methods and class members.

[0043] For example, a program may include multiple class members. Class members are the member variables of a class. Class members defined in a class include their attributes, data types, and names. For example, attributes may include static and local, data types may include arrays and numeric variables, array types may include fixed-length arrays or variable-length arrays, and numeric variables may include integer and floating-point types.

[0044] For example, relationships between classes include class inheritance; a subclass can inherit class members and methods from its parent class. For more information on concepts such as classes, class members, and relationships between classes, please refer to the documentation on programming languages ​​used in programmable code; it will not be elaborated upon here. In step S30, multiple class members are traversed, and configuration processing is performed on each member to configure the verification environment.

[0045] For example, the configuration information for each simulation parameter includes the parameter's name, hierarchical relationship, and configuration value.

[0046] For example, the names of simulation parameters can correspond to the names of the class members corresponding to the simulation parameters according to preset rules. For example, the name of a simulation parameter can be the same as the name of the class member corresponding to that simulation parameter.

[0047] For example, the hierarchical relationship of simulation parameters represents the class inheritance relationship of the class members corresponding to the simulation parameters in the constructor.

[0048] For example, the configuration value of a simulation parameter is the specific value that the class member corresponding to the simulation parameter is configured to in the current verification environment. Thus, based on different configuration values ​​of the simulation parameter, the corresponding class member can be configured with specific values ​​in different verification environments. By setting different configuration values ​​for the simulation parameter, different verification environments can be set, thereby verifying different functions or simulating different scenarios.

[0049] For example, step S10 may include: reading the configuration file and reading the name, configuration value, and hierarchical relationship of each simulation parameter into the verification environment.

[0050] For example, the filename of the configuration file is passed to the verification environment, all contents of the configuration file are read, and the contents are parsed in the verification environment to read the name, configuration value, and hierarchical relationship of each simulation parameter into the verification environment.

[0051] Figure 2A A schematic structural diagram of a construction procedure provided for at least one embodiment of this disclosure.

[0052] like Figure 2A As shown, in some embodiments, the construction process includes class A0 and class A1, both of which include class B. Class B in class A0 and class B in class A1 are different objects obtained by instantiating the same class (e.g., class B) in different locations.

[0053] For ease of distinction, in the following text, subclass B that inherits from class A0 will be described as class B(1) (that is... Figure 2A In the box class A0, class B is located in the box class A0. The subclass B that inherits from class A1 is described as class B(2) (that is, Figure 2A The class B located in box class A1 is used only to distinguish between the two classes B, but does not represent the class name.

[0054] like Figure 2A As shown, class A0 contains class member MEM2, and class A1 contains class member MEM3.

[0055] For example, such as Figure 2A As shown, class B(1), which inherits from class A0, contains class members MEM0 and MEM1. Class B(2), which inherits from class A1, also contains class members MEM0 and MEM1. These are different objects obtained by instantiating class B in different locations. For ease of distinction, class member MEM0 in class B(1) is labeled as MEM0(1), class member MEM1 in class B(1) is labeled as MEM1(1), class member MEM0 in class B(2) is labeled as MEM0(2), and class member MEM1 in class B(2) is labeled as MEM1(2). This label is only used to distinguish class members located in different classes B, but does not represent the name of the class member.

[0056] Therefore, for class member MEM2, its class inheritance relationship can be represented as "A0.MEM2", indicating that class member MEM2 is located in class A0. For class member MEM3, its class inheritance relationship can be represented as "A1.MEM3", indicating that class member MEM3 is located in class A1. For class members MEM0(1) and MEM1(1), their class inheritance relationship can be represented as "A0.B.MEM0" and "A0.B.MEM1", indicating that class members MEM0(1) and MEM1(1) are located in class B(1) which inherits from class A0. For class members MEM0(2) and MEM1(2), their class inheritance relationship can be represented as "A1.B.MEM0" and "A1.B.MEM1", indicating that class members MEM0(2) and MEM1(2) are located in class B(2) which inherits from class A1.

[0057] certainly, Figure 2A The diagram shown is a schematic representation. The program may include more classes and more class members, as well as more other class inheritance relationships. This disclosure does not impose any limitations on this.

[0058] Figure 2B A schematic diagram of a configuration file provided in at least one embodiment of this disclosure is shown. For example, the configuration file is for... Figure 2A The build process shown.

[0059] like Figure 2B As shown in the first line, for the simulation parameter MEM0(1) corresponding to the class member MEM0(1), the configuration information corresponding to the simulation parameter MEM0(1) includes the name "MEM0", the configuration value "V0", and the hierarchical relationship "A0.B.MEM0". The hierarchical relationship "A0.B.MEM0" indicates the class inheritance relationship of the class member MEM0(1) corresponding to the simulation parameter MEM0(1) in the construction program, that is, it is located in class B which inherits from class A0. For example, here the configuration value V0 is a numeric data of any data type, such as integer, floating point, etc., and this disclosure does not impose any restrictions on it.

[0060] like Figure 2B As shown in the second line, for the simulation parameter MEM1(1) corresponding to the class member MEM1(1), the configuration information corresponding to the simulation parameter MEM1(1) includes the name "MEM1", the configuration value "V1", and the hierarchical relationship "A0.B.MEM1". The hierarchical relationship "A0.B.MEM1" indicates the class inheritance relationship of the class member MEM1(1) corresponding to the simulation parameter MEM1(1) in the construction program, that is, it is located in class B which inherits from class A0. For example, the configuration value V1 here is a numeric data of any data type, such as integer, floating point, etc., which is not restricted in this disclosure.

[0061] like Figure 2B As shown in the fifth line, for the simulation parameter MEM2 corresponding to the class member MEM2, the configuration information for simulation parameter MEM2 includes the name "MEM2", the configuration value "V4", and the hierarchical relationship "A0.MEM2". The hierarchical relationship "A0.MEM2" indicates the class inheritance relationship of the class member MEM2 corresponding to simulation parameter MEM2 in the construction program, that is, it is located in class A0. In addition, the configuration information for simulation parameter MEM2 also includes the type of simulation parameter MEM2. For example, the type of simulation parameter MEM2 is an array, that is, the type of the class member MEM2 corresponding to simulation parameter MEM2 is an array. The configuration file indicates that the element with index 0 in the class member MEM2 corresponding to simulation parameter MEM2 needs to be configured as V4. For example, here the configuration value V4 is numeric data of any data type, such as integer, floating-point, etc., and this disclosure does not impose any restrictions on it.

[0062] like Figure 2B As shown in the sixth line of the configuration file, the element with index 2 in the class member MEM2 corresponding to the simulation parameter MEM2 needs to be configured as V5.

[0063] like Figure 2B As shown in line 7, for the simulation parameter MEM3 corresponding to class member MEM3, the configuration information for simulation parameter MEM3 includes the name "MEM2", the configuration value "V5", and the hierarchical relationship "A1.MEM3". The hierarchical relationship "A1.MEM3" indicates the class inheritance relationship of the class member MEM3 corresponding to simulation parameter MEM3 in the construction program, that is, it is located in class A1. In addition, the configuration information for simulation parameter MEM3 also includes the type of simulation parameter MEM3. For example, if the type of simulation parameter MEM3 is an array, that is, the type of class member MEM3 corresponding to simulation parameter MEM3 is an array, in the configuration file, the configuration information for simulation parameter MEM3 is expressed as "A1.MEM3[*]=V6", which indicates that all elements of class member MEM3 corresponding to simulation parameter MEM3 need to be configured as V6. For example, here the configuration value V6 is a numeric data of any data type, such as integer, floating-point, etc., and this disclosure does not impose any restrictions on it.

[0064] For a description of the simulation parameters MEM0(2) and their configuration information corresponding to class member MEM0(2), and the simulation parameters MEM1(2) and their configuration information corresponding to class member MEM1(2), please refer to the above content, and it will not be repeated here.

[0065] Of course, it should be noted that, Figure 2BThe diagram shown is a schematic representation of a configuration file. Those skilled in the art can also use other forms to record simulation parameters and their configuration information, and this disclosure does not impose any restrictions on this.

[0066] After writing the simulation parameters and their configuration information in the above form into the configuration file, the configuration file is read in step S10. Then, in step S30, the configuration values ​​of the simulation parameters are configured to the corresponding class members according to the configuration information of the simulation parameters.

[0067] This approach allows for flexible configuration of any class members. Members can be added or deleted at will by modifying the configuration file. It is highly readable, and the configured environment variables can be clearly identified during subsequent review and verification. Furthermore, regardless of whether the object under test is a portion of the circuit or the entire chip, if some of its class members have the same name and class inheritance relationship, the configuration file for the simulation parameters corresponding to those members can be reused, simplifying the verification configuration integrated into the chip.

[0068] In addition, such as Figure 2A As shown, in the traditional approach, it is not possible to configure different values ​​for class member MEM0(1) and class member MEM0(2). However, as Figure 2B The configuration file shown can configure the value of class member MEM0(1) to V0 and the value of class member MEM0(2) to V1 after steps S10 to S30, thereby achieving precise configuration. No matter how many times the class is instantiated, the specified configuration value can be accurately set for the class members in the objects after different instantiations of the class.

[0069] For example, the constructor includes at least one top-level class, and each class member is located in at least one top-level class or in a subclass of at least one top-level class.

[0070] For example, such as Figure 2A As shown, a top-level class can include class A0 and class A1. A top-level class means that it is the outermost class, and there is no code block surrounding it outside. A top-level class can be a parent class, that is, a subclass that inherits from the top-level class. Alternatively, a top-level class may not have any subclasses, but a top-level class does not necessarily refer only to a base class.

[0071] For example, class B(1) is a subclass of top-level class A0, and class B(2) is a subclass of top-level class A1. For example, class member MEM2 is located in top-level class A0, and class member MEM3 is located in top-level class A1. For example, class member MEM0(1) is located in subclass B(1) of top-level class A0, and class member MEM0(2) is located in subclass B(2) of top-level class A1.

[0072] For example, step S30 may include: starting from at least one top-level class, traversing multiple class members in the order from the top-level class to the subclasses, and performing configuration processing on the multiple class members in turn to configure the verification environment.

[0073] For example, starting from at least one top-level class, traversing multiple class members in order from the top-level class to the subclasses, and performing configuration processing on the multiple class members in turn to configure the verification environment, may include: for any top-level class, determining whether any class member exists in any top-level class; in response to the existence of a class member in any top-level class, performing configuration processing on all class members in any top-level class; in response to any top-level class including at least one subclass, traversing all class members in at least one subclass of any top-level class, and performing configuration processing on all class members in at least one subclass of any top-level class, until all multiple class members have been traversed.

[0074] For example, in some embodiments, with Figure 2A Taking the construction process shown as an example, the top-level class A0 is first parsed to determine whether there are class members in the top-level class A0. For example, if there is a class member MEM2 in the top-level class A0, configuration processing is performed on the class member MEM2. Then, configuration processing is performed on all other class members in the top-level class A0 in turn until all class members in the top-level class A0 have been traversed.

[0075] Then, since the top-level class A0 includes subclass B(1), it is necessary to traverse all class members in subclass B(1) and perform configuration processing on all class members in subclass B(1) until all class members in subclass B(1) have been traversed.

[0076] Then, if subclass B(1) includes another subclass (e.g., subclass C), that is, subclass C inherits from subclass B(1), then the above operation is continued on subclass C until no subclass exists in a subclass.

[0077] For example, if subclass B(1) does not include any other subclasses besides subclass C, then the traversal of all class members of subclass B(1) and its subclasses is completed.

[0078] For example, if the top-level class A0 also includes a subclass D, then the traversal process similar to that of subclass B(1) continues to be performed on subclass D until the traversal of all class members of subclass D and its subclasses is completed.

[0079] For example, if the top-level class A0 does not include any subclasses other than subclass B(1) and subclass D, then the traversal of all class members in the top-level class A0 and its subclasses is completed.

[0080] Then, continue the above process for the top-level class A1 until all class members in the constructor have been traversed.

[0081] For example, if the top-level class A0 does not contain any subclasses, then after traversing all class members in the top-level class A0, the above operation is performed on the top-level class A1, until all class members in the constructor have been traversed.

[0082] It should be noted that this disclosure does not impose specific restrictions on the traversal order of the top-level class, nor on the traversal order of subclasses and / or class members within each top-level class, nor on the traversal order of subclasses and / or class members within each subclass. The traversal order can be set according to the actual situation. For example, in some embodiments, the above process can be performed on the top-level class A1 first, and then on the top-level class A0. However, regardless of the order, the traversal is generally performed from the top-level class to the subclasses until all class members have been traversed.

[0083] Figure 3 A schematic flowchart illustrating the configuration process provided for at least one embodiment of this disclosure.

[0084] The following is combined with Figure 3 This disclosure provides at least one embodiment of the execution process for configuration processing.

[0085] like Figure 3 As shown, the configuration process includes at least steps S301-S302.

[0086] In step S301, at least one simulation parameter corresponding to each class member is determined based on the configuration information corresponding to the multiple simulation parameters.

[0087] In step S302, class members are set according to at least one corresponding simulation parameter.

[0088] For example, step S301 may include: determining the name of the class member and the class inheritance relationship of the class member in the constructor; initializing the class member; traversing multiple simulation parameters, and determining at least one simulation parameter that matches the name and class inheritance relationship of the initialized class member based on the name and hierarchical relationship of the multiple simulation parameters respectively.

[0089] For example, in some embodiments, initializing a class member may include: determining the type of the class member; setting an initial value for the class member in response to the class member's type not being an array; and creating a corresponding array based on the array structure defined by the class member in response to the class member's type being a fixed-length array, and setting the initial values ​​of the elements included in the corresponding array.

[0090] For example, in some embodiments, initializing class members may further include: marking class members in response to the class member being a variable-length array; and after traversing all class members whose type is not a variable-length array, determining the class members whose depth information is recorded, creating a variable-length array corresponding to the marked class members based on the value of the class members whose depth information is recorded, and setting the initial values ​​of the elements of the corresponding variable-length array.

[0091] For example, the types of class members include arrays and non-arrays. Non-arrays include any type such as floating-point and integer, while arrays include fixed-length arrays and variable-length arrays.

[0092] For example, the length of a fixed-length array is fixed and known. For example, if a class member is defined as: int a[5], it means that the class member is a fixed-length array, the array name is a, the length of the array is 5, and all 5 elements are integer variables.

[0093] For example, a variable-length array means that the length of the array can be changed. For instance, if a class member is defined as `int a[b]`, it means that the class member is a variable-length array, the array name is `a`, the array length is `b`, and all `b` elements are integer variables. For example, `b` is an integer class member, and its specific value can be specified in the class, such as defining `int b = 5`. Alternatively, the specific value of `b` can also be configured through a configuration file; for example, defining only `int b` in the class indicates that `b` is an integer variable, and its specific value is determined by the configuration file.

[0094] For example, for a specific class member (hereinafter referred to as class member 1), first determine whether the type of class member 1 is a variable-length array. If not, when the type of class member 1 is not an array, set the initial value of class member 1. For example, the initial value can be specifically chosen as needed, such as all 0s or all Fs. When the type of class member 1 is an array and it is a fixed-length array, create a corresponding array according to the array structure defined by class member 1, allocate an address space of the corresponding length for class member 1, so that subsequent matching operations (i.e., matching class members with simulation parameters) can be performed; at the same time, it is also necessary to set the initial values ​​of the elements included in the created array, such as setting all element values ​​to all 0s or all Fs.

[0095] Next, the multiple simulation parameters read in step S10 are traversed. Based on the names and hierarchical relationships of the multiple simulation parameters, at least one simulation parameter that matches the name and class inheritance relationship of the initialized class member 1 is determined as at least one simulation parameter corresponding to class member 1. For example, when the type of class member 1 is not an array, class member 1 corresponds to one simulation parameter. When the type of class member 1 is an array, class member 1 may correspond to one or more simulation parameters. For example, class member MEM2 corresponds to two simulation parameters, and class member MEM3 corresponds to one simulation parameter.

[0096] For example, the name of the simulation parameter is set to be the same as the name of class member 1. The hierarchical relationship of the simulation parameters represents the class inheritance relationship of class member 1. Therefore, all simulation parameters can be traversed. Based on the hierarchical relationship of the simulation parameters, it can be determined whether the class member corresponding to the simulation parameter belongs to the class where class member 1 is located, and based on the name of the simulation parameter, it can be determined whether it corresponds to class member 1. If both conditions are met, it is determined that the simulation parameter is a simulation parameter that matches class member 1.

[0097] For example, with Figure 2A and Figure 2B For example, when configuring class member MEM0(1), multiple simulation parameters are traversed. It is found that the hierarchical relationship of simulation parameter MEM0(1) indicates that the class member corresponding to simulation parameter MEM0(1) belongs to class B(1), that is, it belongs to the class where class member MEM0(1) is located. Furthermore, the name "MEM0" of simulation parameter MEM0(1) is the same as the name "MEM0" of class member MEM0(1). It is determined that simulation parameter MEM0(1) is a simulation parameter that matches class member MEM0(1).

[0098] For example, if the type of class member 1 is a variable-length array, since the length of the variable-length array is still unknown, it may need to be configured through a configuration file. In this case, class member 1 can be marked first and not processed yet. After all class members whose type is not a variable-length array have been traversed, the class member that records the depth information of class member 1 (for example, class member 2) is determined. Based on the value of class member 2, the variable-length array corresponding to class member 1 is created. Then, the initial values ​​of the elements of the created variable-length array are set, for example, all element values ​​are set to all 0 or all F, etc.

[0099] For example, taking class member 1 as defined as `int a[b]`, since only `int b` is defined in the class, the specific value of `b` needs to be obtained through a configuration file. Therefore, configuration processing can be performed on all class members whose type is not a variable-length array to obtain the configuration value of the simulation parameter corresponding to `b`. This allows the creation of an array to allocate a certain length of address space for class member 1, enabling subsequent matching and other operations. For example, step S302 may include: updating the value of the class member based on the configuration value of at least one simulation parameter.

[0100] For example, obtain the configuration values ​​of simulation parameters and update the values ​​of class members to the corresponding configuration values ​​of simulation parameters.

[0101] For example, refer to Figure 2B For class member MEM0(1), update the value of class member MEM0(1) from the initial value to V0; for class member MEM0(2), update the value of class member MEM0(2) from the initial value to V2; for class member MEM2, update the element at index 0 of class member MEM2 to V4, and update the element at index 2 of class member MEM2 to V5; for class member MEM3, update all elements of class member MEM3 to V6.

[0102] For example, step S302 may also include: performing random closing of class members.

[0103] For example, class members can be randomly disabled so that they are no longer in a random state, and set to a configured value, such as the configuration value specified in the corresponding simulation parameter in the configuration file.

[0104] Of course, there may be no corresponding simulation parameters for class members that do not require configuration. However, since the class members have already been initialized, this will not affect the operation of the build program. In other words, if one or more simulation parameters corresponding to a class member are found, the value of the class member is updated according to the configuration values ​​corresponding to these simulation parameters; if no simulation parameters corresponding to a class member are found, the process is skipped, or the class member is randomly disabled.

[0105] For example, in other embodiments, class members may not be marked when it is found that the type of a class member is a variable-length array. After all class members whose type is not a variable-length array have been traversed (that is, all of these class members have performed configuration processing), the traversal operation is performed again. When it is found that the type of a class member is a variable-length array, an array is created and subsequent matching, updating the value of the class member, and other operations are performed.

[0106] For example, in other embodiments, matching can be performed first on class members whose type is not array. After all class members whose type is not array have been matched, matching can then be performed on all class members whose type is array. For example, when matching all class members whose type is array, array members can be marked during the first round of traversal, and then the marked class members can be matched. Alternatively, a second round of traversal can be performed, and when a class member whose type is array is found, the array is created and subsequent matching, updating the value of the class member, and other operations can be performed.

[0107] The configuration method provided in at least one embodiment of this disclosure is capable of configuring array-type class members, whereas current configuration methods cannot transmit configuration values ​​to array-type class members. Furthermore, this configuration method eliminates the need for additional code to transmit and parse simulation parameters, thereby improving simulation execution speed and verification efficiency.

[0108] For example, configuration processing may also include performing full variable randomization on multiple class members.

[0109] For example, performing full-variable randomization on multiple class members could involve grouping all top-level classes into a related class, assigning random values ​​to the class members in that class using a random function, and also using constraints to limit the range of these random values ​​so that the values ​​of the class members are valid, thereby adding randomness to the class members.

[0110] Fully variable randomization can randomize the validation environment, improve its randomness, and make coverage convergence faster.

[0111] Figure 4 A flowchart illustrating a method for configuring a verification environment provided in at least one embodiment of this disclosure.

[0112] The following is combined with Figure 4 This document describes in detail the process of configuring a verification environment according to at least one embodiment of the present disclosure.

[0113] First, the configuration file is read to load the configuration information corresponding to the various simulation parameters contained in the configuration file into the verification environment. The specific process is as described in step S10, and will not be repeated here.

[0114] Next, the process of building the verification environment is obtained, as described in step S20, and will not be repeated here.

[0115] Next, iterate through all class members and perform configuration processing on all class members.

[0116] For example, when performing configuration processing, for a member of a processed class, the member is first initialized. For example, if the type of the member is not an array, the initial value of the member is set; if the type of the member is a fixed-length array, the array is created first, and then the initial value of the created array is set; if the type of the member is a variable-length array, the member is marked as not to be processed for the time being.

[0117] Next, all simulation parameters are traversed. Based on the configuration information corresponding to each simulation parameter, at least one simulation parameter corresponding to the processed class member is determined. For example, it is determined whether the hierarchical relationship of the simulation parameter matches the class inheritance relationship of the processed class member, that is, whether the class member corresponding to the simulation parameter belongs to the class of the processed class member; it is also determined whether the name of the simulation parameter matches the name of the processed class member, that is, whether the class member corresponding to the simulation parameter is indeed the processed class member. If both conditions are met, then the simulation parameter is determined to be the simulation parameter corresponding to the processed class member. This process determines one or more simulation parameters corresponding to the processed class member.

[0118] Next, obtain the configuration values ​​of the simulation parameters and update the values ​​of the class members to the configuration values ​​of the simulation parameters.

[0119] Then, randomly disable the members of the processed class.

[0120] Repeat the above process until the configuration processing of all class members whose type is not a variable-length array is completed.

[0121] Next, for all marked class members, determine the class members that record the depth information of the marked class members, create a variable-length array corresponding to the marked class members based on the value of the class members that record the depth information, and set the initial value of the variable-length array.

[0122] Then, consistent with the processing method for class members of non-array types and fixed-length array types, the simulation parameters corresponding to these marked class members are determined, and the marked class members are set according to the simulation parameters, until the traversal of all class members is completed.

[0123] Finally, after iterating through all class members, all class members are randomly processed using all variables. This completes the configuration of the verification environment, which can simulate predefined scenarios to verify the functionality of the object under test.

[0124] At least one embodiment of this disclosure also provides a configuration apparatus for a verification environment. Figure 5 This is a schematic block diagram of a configuration apparatus for a verification environment provided for at least one embodiment of the present disclosure.

[0125] like Figure 5As shown, the configuration device 500 for verifying the environment may include: a reading unit 501, an acquisition unit 502, and a processing unit 503.

[0126] For example, these modules can be implemented through hardware (e.g., circuit) modules, software modules, or any combination of both. The following embodiments are the same and will not be described again. For example, these units can be implemented through a central processing unit (CPU), graphics processing unit (GPU), tensor processor (TPU), field-programmable gate array (FPGA), or other forms of processing units with data processing capabilities and / or instruction execution capabilities, as well as corresponding computer instructions.

[0127] The reading unit 501 is configured to read the configuration file, which includes multiple simulation parameters for building the verification environment and the configuration information corresponding to each simulation parameter.

[0128] The acquisition unit 502 is configured to acquire the build program of the verification environment, wherein the build program includes multiple class members.

[0129] Processing unit 503 is configured to traverse multiple class members and perform configuration processing on the multiple class members to configure the verification environment.

[0130] For example, the configuration process may include: determining at least one simulation parameter corresponding to each class member based on the configuration information corresponding to multiple simulation parameters; and setting the class member based on the corresponding at least one simulation parameter.

[0131] For example, the reading unit 501, the acquiring unit 502, and the processing unit 503 may include code and programs stored in memory; the processor may execute the code and programs to implement some or all of the functions of the reading unit 501, the acquiring unit 502, and the processing unit 503 as described above. For example, the reading unit 501, the acquiring unit 502, and the processing unit 503 may be dedicated hardware devices used to implement some or all of the functions of the reading unit 501, the acquiring unit 502, and the processing unit 503 as described above. For example, the reading unit 501, the acquiring unit 502, and the processing unit 503 may be a circuit board or a combination of multiple circuit boards used to implement the functions described above. In the embodiments of this application, the circuit board or the combination of multiple circuit boards may include: (1) one or more processors; (2) one or more non-temporary memories connected to the processor; and (3) processor-executable firmware stored in memory.

[0132] It should be noted that the reading unit 501 can be used to implement Figure 1 The step S10 shown, the acquisition unit 502 can be used to implement Figure 1 The processing unit 503 can be used to implement step S20 shown. Figure 1 The step S30 is shown. Therefore, for a detailed description of the functions that the reading unit 501, reading unit 502, and processing unit 503 can achieve, please refer to the relevant descriptions of steps S10 to S30 in the embodiments of the above-described verification environment configuration method; repeated details will not be repeated here. Furthermore, the verification environment configuration device 500 can achieve similar technical effects to the aforementioned verification environment configuration method, and will not be described further here.

[0133] It should be noted that, in the embodiments of this disclosure, the configuration device 500 of the verification environment may include more or fewer circuits or units, and the connection relationship between the various circuits or units is not limited and can be determined according to actual needs. The specific configuration of each circuit or unit is not limited; it can be constructed from analog devices, digital chips, or other suitable methods according to circuit principles.

[0134] At least one embodiment of this disclosure also provides an electronic device. Figure 6 This is a schematic diagram of an electronic device provided for at least one embodiment of the present disclosure.

[0135] For example, such as Figure 6 As shown, the electronic device includes a processor 601, a communication interface 602, a memory 603, and a communication bus 604. The processor 601, communication interface 602, and memory 603 communicate with each other via the communication bus 604. The processor 601, communication interface 602, and memory 603 can also communicate with each other via a network connection. This disclosure does not limit the type and function of the network. It should be noted that... Figure 6 The components of the electronic device shown are merely exemplary and not limiting; the electronic device may have other components depending on the actual application requirements.

[0136] For example, memory 603 is used to store computer-readable instructions non-transitory. When processor 601 executes the computer-readable instructions, it implements the configuration method for the verification environment according to any of the above embodiments. For specific implementations and explanations of each step of the configuration method for the verification environment, please refer to the embodiments of the configuration method for the verification environment described above, and they will not be repeated here.

[0137] For example, other implementations of the verification environment configuration method implemented by the processor 601 executing computer-readable instructions stored in the memory 603 are the same as those mentioned in the foregoing method embodiment section, and will not be repeated here.

[0138] For example, the communication bus 604 can be a Peripheral Component Interconnect Standard (PCI) bus or an Extended Industry Standard Architecture (EISA) bus. This communication bus can be divided into an address bus, a data bus, a control bus, etc. For ease of illustration, only one thick line is used to represent it in the figure, but this does not indicate that there is only one bus or one type of bus.

[0139] For example, communication interface 602 is used to enable communication between electronic devices and other devices.

[0140] For example, processor 601 and memory 603 can be located on the server side (or in the cloud).

[0141] For example, processor 601 can control other components in an electronic device to perform desired functions. Processor 601 can be a central processing unit (CPU), network processor (NP), tensor processor (TPU), or graphics processing unit (GPU) with data processing and / or program execution capabilities; it can also be a digital signal processor (DSP), application-specific integrated circuit (ASIC), field-programmable gate array (FPGA), or other programmable logic devices, discrete gate or transistor logic devices, or discrete hardware components. The central processing unit (CPU) can be based on x86 or ARM architectures, etc.

[0142] For example, memory 603 may include any combination of one or more computer program products, which may include various forms of computer-readable storage media, such as volatile memory and / or non-volatile memory. Volatile memory may include, for example, random access memory (RAM) and / or cache memory. Non-volatile memory may include, for example, read-only memory (ROM), hard disk, erasable programmable read-only memory (EPROM), portable compact disc read-only memory (CD-ROM), USB memory, flash memory, etc. One or more computer-readable instructions may be stored on the computer-readable storage medium, and processor 601 may execute the computer-readable instructions to implement various functions of the electronic device. Various application programs and various data may also be stored in the storage medium.

[0143] For example, a detailed description of the process of configuring the verification environment by the electronic device can be found in the relevant description in the embodiments of the verification environment configuration method, and repeated descriptions will not be repeated here.

[0144] Figure 7 This is a schematic diagram of a non-transitory computer-readable storage medium provided for at least one embodiment of the present disclosure. For example, such as Figure 7As shown, the storage medium 700 can be a non-transitory computer-readable storage medium on which one or more computer-readable instructions 701 can be stored non-transitory. For example, when the computer-readable instructions 701 are executed by a processor, one or more steps in the configuration method of the verification environment described above can be performed.

[0145] For example, the storage medium 700 can be applied in the aforementioned electronic device. For instance, the storage medium 700 may include the memory 603 in the electronic device 600.

[0146] For example, the storage medium may include a memory card for a smartphone, a storage component for a tablet computer, a hard disk for a personal computer, random access memory (RAM), read-only memory (ROM), erasable programmable read-only memory (EPROM), portable compact disc read-only memory (CD-ROM), flash memory, or any combination of the above storage media, or other suitable storage media.

[0147] For example, the description of storage medium 700 can be found in the description of memory in the embodiments of the electronic device, and repeated descriptions will not be repeated here.

[0148] The following points should be noted regarding this disclosure:

[0149] (1) The accompanying drawings of the embodiments of this disclosure only involve the structures involved in the embodiments of this disclosure. Other structures can be referred to the general design.

[0150] (2) For clarity, the thickness and dimensions of layers or structures are enlarged in the accompanying drawings used to describe embodiments of the invention. It will be understood that when an element such as a layer, film, region, or substrate is referred to as being “above” or “below” another element, the element may be “directly” located “above” or “below” the other element, or there may be intermediate elements present.

[0151] (3) Where there is no conflict, the embodiments of this disclosure and the features in the embodiments can be combined with each other to obtain new embodiments.

[0152] The above description is only a specific embodiment of this disclosure, but the protection scope of this disclosure is not limited thereto. The protection scope of this disclosure should be determined by the protection scope of the claims.

Claims

1. A method for configuring a verification environment, comprising: Read the configuration file, wherein the configuration file includes multiple simulation parameters for constructing the verification environment and configuration information corresponding to the multiple simulation parameters respectively. The configuration information corresponding to each simulation parameter includes the name of the simulation parameter and the hierarchical relationship of the class inheritance relationship of the class members corresponding to the simulation parameter in the construction program. Obtain the build program for the verification environment, wherein the build program includes multiple class members; Iterate through the multiple class members and perform configuration processing on the multiple class members to configure the verification environment; The configuration process includes: Based on the configuration information corresponding to the multiple simulation parameters, at least one simulation parameter is determined for each class member. The name of the at least one simulation parameter is the same as the name of the class member, the hierarchical relationship of the at least one simulation parameter matches the class inheritance relationship of the class member, and the class members in different instances obtained by instantiating the same class have different class inheritance relationships. The class members are set according to at least one corresponding simulation parameter; Specifically, based on the configuration information corresponding to the multiple simulation parameters, at least one simulation parameter corresponding to each class member is determined, including: Determine the names of the class members and their class inheritance relationships in the constructor; initialize the class members; Iterate through the multiple simulation parameters, and determine at least one simulation parameter that matches the name and class inheritance relationship of the initialized class member based on the names and hierarchical relationships of the multiple simulation parameters.

2. The configuration method according to claim 1, wherein, The construction process includes at least one top-level class, and each class member is located in the at least one top-level class or in a subclass of the at least one top-level class. Traverse the multiple class members and perform configuration processing on the multiple class members to configure the verification environment, including: Starting from the at least one top-level class, the plurality of class members are traversed in order from the top-level class to the subclasses, and configuration processing is performed on the plurality of class members in turn to configure the verification environment.

3. The configuration method according to claim 2, wherein, Starting from the at least one top-level class, the plurality of class members are traversed in order from the top-level class to the subclasses, and configuration processing is performed on the plurality of class members in sequence to configure the verification environment, including: For any given top-level class, determine whether any class member exists in that top-level class; In response to the existence of class members in any of the top-level classes, the configuration processing is performed on all class members in any of the top-level classes; In response to any top-level class including at least one subclass, all class members in the at least one subclass of the top-level class are traversed, and the configuration processing is performed on all class members in the at least one subclass of the top-level class until all class members have been traversed.

4. The configuration method according to claim 1, wherein, Initializing the class members includes: Determine the type of the class members; In response to the fact that the type of the class member is not an array, the initial value of the class member is set; In response to the fact that the type of the class member is a fixed-length array, a corresponding array is created according to the array structure defined by the class member, and the initial values ​​of the elements included in the corresponding array are set.

5. The configuration method according to claim 4, wherein, Initializing the class members also includes: In response to the fact that the type of the class member is a variable-length array, the class member is marked; and After traversing all class members whose type is not a variable-length array, determine the class members that record the depth information of the marked class members, and create a variable-length array corresponding to the marked class members based on the value of the class members that record the depth information. Set the initial values ​​of the elements of the corresponding variable-length array.

6. The configuration method according to claim 1, wherein, The configuration information for each simulation parameter also includes the configuration value of that simulation parameter. Based on at least one corresponding simulation parameter, the class members are set, including: Update the value of the class member based on the configuration value of the at least one simulation parameter.

7. The configuration method according to claim 6, wherein, Setting the class members based on at least one corresponding simulation parameter further includes: The class members are randomly disabled.

8. The configuration method according to any one of claims 1-7, wherein, The configuration information for each simulation parameter includes the parameter's name, hierarchical relationship, and configuration value. Read the configuration file, including: The configuration file is read, and the name, configuration value, and hierarchical relationship of each simulation parameter are read into the verification environment.

9. The configuration method according to any one of claims 1-7, wherein, The configuration process also includes: Perform full variable randomization on the multiple class members.

10. A configuration apparatus for a verification environment, comprising: The reading unit is configured to read a configuration file, wherein the configuration file includes multiple simulation parameters for constructing the verification environment and configuration information corresponding to the multiple simulation parameters respectively. The configuration information corresponding to each simulation parameter includes the name of the simulation parameter and the hierarchical relationship of the class inheritance relationship of the class members corresponding to the simulation parameter in the construction program. The acquisition unit is configured to acquire the construction program of the verification environment, wherein the construction program includes multiple class members; The processing unit is configured to traverse the plurality of class members and perform configuration processing on the plurality of class members to configure the verification environment; The configuration process includes: Based on the configuration information corresponding to the multiple simulation parameters, at least one simulation parameter is determined for each class member. The name of the at least one simulation parameter is the same as the name of the class member, the hierarchical relationship of the at least one simulation parameter matches the class inheritance relationship of the class member, and the class members in different instances obtained by instantiating the same class have different class inheritance relationships. The class members are set according to at least one corresponding simulation parameter; Specifically, based on the configuration information corresponding to the multiple simulation parameters, at least one simulation parameter corresponding to each class member is determined, including: Determine the names of the class members and their class inheritance relationships in the constructor; initialize the class members; Iterate through the multiple simulation parameters, and determine at least one simulation parameter that matches the name and class inheritance relationship of the initialized class member based on the names and hierarchical relationships of the multiple simulation parameters.

11. An electronic device, comprising: Memory stores computer-executable instructions non-transiently; The processor is configured to run computer-executable instructions. The computer-executable instructions are executed by the processor to implement the configuration method of the verification environment according to any one of claims 1-9.

12. A non-transitory computer-readable storage medium, wherein, The non-transitory computer-readable storage medium stores computer-executable instructions that, when executed by a processor, implement the configuration method of the verification environment according to any one of claims 1-9.

Images