How to download VIP smartsearch?
DESIGNWARE_HOMEto required designware home location where VIP Smartsearch should be downloaded.
vip_smartsearch_<version>.runfile.
$DESIGNWARE_HOME/vip/svt/vip_smartsearch/<version>
How to install VIP Smartsearch?
Please refer to the fileVIP_Smartsearch_installation_and_usage_guide.pdfin
$DESIGNWARE_HOME/vip/svt/vip_smartsearch/<version>for installation steps.
Customer Support
For more details about VIP smartsearch tool, contact support_center@synopsys.com.Inheritance diagram for class svt_axi_transaction:
This is the base transaction type which contains all the physical attributes of the transaction like address, data, burst type, burst length, etc. It also provides the timing information of the transaction to the master & slave transactors, that is, delays for valid and ready signals with respect to some reference events.
The svt_axi_transaction also contains a handle to configuration object of type svt_axi_port_configuration , which provides the configuration of the port on which this transaction would be applied. The port configuration is used during randomizing the transaction.
|
||||||||||
Generates an SVT pattern object to represent the properties which are to be written to FSDB. The pattern is customized to contain only the fields necessary for the application and tranaction type.
Note: As a performance enhancement, property values in the pattern are pre-populated when the pattern is created. This allows the FSDB writer infrastructure to skip the get_prop_val_via_pattern step.
Return values - An svt_pattern instance containing entries to be written to FSDB | ||||||||||
|
|
||
calulates rchunkstrb[] and rchunknum[]
|
|
||
This method is used to delate object_type for bus_activity when bus _activity ends on the bus . This methid is used by pa writer class in generating XML/FSDB
|
|
||
Converts tag from wysiwyg format to right justified format
|
|
||
Converts tag from right justified format to wysiwyg format
|
|
||
Converts tag_update from wysiwyg format to right justified format
|
|
||
Converts tag_update from right justified format to wysiwyg format
|
|
||||||
Simple utility used to convert 'bit [1023:0]' property value representation into its equivalent string property value representation. Extended to support decoding of enum values.
prop_name - The name of the property being encoded. prop_val_string - The string describing the value to be encoded. prop_val - The bit vector encoding of prop_val_string. typ - Optional field type used to help in the encode effort.
Return values - The enum value corresponding to the desc. | ||||||
|
|
||||||||||
This method allocates a pattern containing svt_pattern_data instances for all of the primitive data fields in the object. The name is set to the corresponding field name, the value is set to 0.
Return values - An svt_pattern instance containing entries for all of the data fields. | ||||||||||
|
|
||||||||||||||
|
|
||||||||||||||
Extend the copy method to take care of the transaction fields and cleanup the exception xact pointers.
rhs - Source object to be copied. | ||||||||||||||
|
|
||||||||||||
Does a basic validation of this transaction object
| ||||||||||||
|
|
||||||
Simple utility used to convert string property value representation into its equivalent 'bit [1023:0]' property value representation. Extended to support encoding of enum values.
prop_name - The name of the property being encoded. prop_val_string - The string describing the value to be encoded. prop_val - The bit vector encoding of prop_val_string. typ - Optional field type used to help in the encode effort.
Return values - The enum value corresponding to the desc. | ||||||
|
|
||
Helper function for get_random_rchunkstrb_for_address to generate patterns of number of chunks transferred per data beat when rchunkstrb_pattern is RCHUNKV_RANDOM.
|
|
||
Method that returns the associative cache set index for the current transaction. Applicable only in case of coherent transactions, when svt_axi_port_configuration :: num_associative_cache_ways is set to 2. By default, it returns addr[("Num cache set index bits"-1):"Num byte offset bits"]. If the associative cache set index must be computed differently, this method must be overriden in an extended transaction class by the users. |
|
||
Method to obtain the associative cache tag for the current transaction. Applicable only in case of coherent transactions, when svt_axi_port_configuration :: num_associative_cache_ways is set to 2. By default, it returns the tagged address itself as the associative cache tag. If the associative cache tag must be computed differently, this method must be overriden in an extended transaction class by the users. |
|
||
Returns the address and lanes corresponding to the beat number
|
|
||
Returns the address and lanes corresponding to the beat number for atomic compare read data
|
|
||
Returns the address and lanes corresponding to the beat number for atomic compare write data
|
|
||
Returns the address and lanes corresponding to the beat number
|
|
||
Gets the beat number corresponding to an address
|
|
||
returns burst size aligned address
|
|
||
Gets the number of beats of data/resp to be sent.
|
|
||
Gets the number of beats for atomic_read_data in Atomic compare transactions
|
|
||
Gets the burst_size of a transaction.
|
|
||
Gets the burst_type of a transaction.
|
|
||
Returns the total number of bytes transferred in this transaction or beat number svt_axi_port_configuration :: get_byte_count_from_wstrb_enable set to 0, the byte count is calculated using burst_length and burst_size based on beat_num - Indicates the beat number for which the byte count is to be calculated. If set to -1, the total number of bytes for the entire transaction is calculated. If svt_axi_port_configuration :: get_byte_count_from_wstrb_enable is set to 1, the byte count is calculated using wstrb based on beat_num - Indicates the beat number for which the byte count is to be calculated. If set to -1, the total number of bytes for the entire transaction is calculated. Return values - The total number of bytes transferred in this transaction or beat number |
|
||
Returns the byte lanes on which data is driven for a given data width
|
|
||
Ensures that only valid lanes have chunkstrb asserted. In wysisyg format the constraints leave data[] and rchunkstrb[] open. This function is called in post_randomize to make sure that chunkstrb is asserted only for valid lanes
|
|
||
Gets the current byte lane based on the current data beat, address and burst size
|
|
||
Gets the current byte lane based on the current data beat, address and burst size
|
|
||
Gets the current byte lane based on the current data beat, address and burst size
|
|
||
Decodes the given AWCMO value and returns the transaction type. awcmo_val - The value on AWCMO |
|
||
Decodes the given snoop value(ARSNOOP/ACSNOOP) and returns the transaction type. This function can be used for the read address channel and the snoop address channel. snoop_val - The value on ARSNOOP/ACSNOOP |
|
||
Decodes the given snoop value(AWSNOOP) and returns the transaction type. This function can be used for the write address channel. snoop_val - The value on AWSNOOP |
|
||
Returns the encoding for ARSNOOP based on the transaction type Return values - The encoded value of ARSNOOP |
|
||
Returns the encoding for AWCMO based on the cmo_on_write_xact_type type Return values - The encoded value of AWCMO |
|
||
Returns the encoding for AWSNOOP based on the transaction type Return values - The encoded value of AWSNOOP |
|
||
Returns the encoding for AWSNOOP/ARSNOOP/ACSNOOP based on the transaction type Return values - The encoded value of AWSNOOP/ARSNOOP/ACSNOOP |
|
||
Gets the maximum byte address which is addressed by this transaction
convert_to_global_addr - Indicates if the min and max address of this transaction must be translated to a global address before checking for overlap use_tagged_addr - Indicates whether a tagged address is provided convert_to_slave_addr - Indicates whether the address should be converted to a slave address requester_name - Name of the master component from which the transaction originated Return values - Maximum byte address addressed by this transaction |
|
||||||||||||||
Returns the class name for the object used for logging.
| ||||||||||||||
|
|
||
Gets the minimum byte address which is addressed by this transaction
convert_to_global_addr - Indicates if the min and max address of this transaction must be translated to a global address before checking for overlap use_tagged_addr - Indicates whether a tagged address is provided convert_to_slave_addr - Indicates whether the address should be converted to a slave address requester_name - Name of the master component from which the transaction originated Return values - Minimum byte address addressed by this transaction |
|
||||||||||||
This method returns PA object which contains the PA header information for XML or FSDB.
uid - Optional string indicating the unique identification value for object. If not provided uses the 'get_uid' method to retrieve the value. typ - Optional string indicating the 'type' of the object. If not provided uses the type name for the class. parent_uid - Optional string indicating the UID of the object's parent. If not provided the method assumes there is no parent. channel - Optional string indicating an object channel. If not provided the method assumes there is no channel.
Return values - The requested object block description. | ||||||||||||
|
|
||
Ensures that only valid lanes have poison asserted. In wysisyg format the constraints leave data[] and poison[] open. This function is called in post_randomize to make sure that poison[] is asserted only for valid lanes
|
|
||||||||||||
HDL Support: For read access to public data members of this class.
| ||||||||||||
|
|
||
Generate random chunkstrb patterns based on the chunk_length, burst_length and burst_size since the constraints leave rchunknum[] and rchunkstrb[] open. This function is called in post_randomize to make sure that chunkstrb is generated for valid lanes in random pattern for both aligned and unaligned addresses.
|
|
||
Ensures that only chunks from valid lanes have chunkstrb asserted. since the constrains leave rchunknum[] and rchunkstrb[] open. This function is called in post_randomize to make sure that chunkstrb is asserted only for valid lanes in walking ones pattern. for both aligned and unaligned address.
|
|
||
Ensures that only valid lanes have tag_update asserted. In wysisyg format the constraints leave tag[] open. This function is called in post_randomize to make sure that tag is asserted only for valid lanes
|
|
||
Ensures that only valid lanes have tag_update asserted. In wysisyg format the constraints leave tag_update[] open. This function is called in post_randomize to make sure that tag_update is asserted only for valid lanes
|
|
||
Returns the channel on which a transaction will be transmitted Return values - The channel (READ/WRITE) on which this transaction will be transmitted. |
|
||||
This method is used in setting the unique identification id for the objects of bus activity This method returns a string which holds uid of bus activity object This is used by pa writer class in generating XML/FSDB
| ||||
|
|
||
Provided the valid number of chunks that are associated with a transaction.
|
|
||
returns lowest address of the transaction. For WRAP type of transaction it indicates starting address after transaction statisfies WRAP condition and wraps over to include lower addresses
|
|
||
Returns the index (of data or wstrb fields) corresponding to the wrap boundary
|
|
||
Returns the index (of atomic_read_data) corresponding to the wrap boundary for Atomic compare transaction
|
|
||
Ensures that only valid lanes have wstrb asserted. In wysisyg format the constraints leave data[] and wstrb[] open. This function is called in post_randomize to make sure that wstrb is asserted only for valid lanes
|
|
||
Returns 1 if the specified error_kind is there in transaction, else returns 0
|
|
||
returns 1 if status of all relevant phases of current transaction are assigned as ABORTED
|
|
||
Checks if the transaction crosses the 4kb boundary
|
|
||
Checks if the given address range overlaps with the address range of this transaction
min_addr - The minimum address of the address range be checked max_addr - The maximum address of the address range be checked convert_to_global_addr - Indicates if the min and max address of this transaction must be translated to a global address before checking for overlap use_tagged_addr - Indicates whether a tagged address is provided convert_to_slave_addr - Indicates whether the address should be converted to a slave address requester_name - Name of the master component from which the transaction originated Return values - Returns 1 if there is an address overlap, else returns 0. |
|
||
Returns 1 if current transaction is allocate transaction
|
|
||
Indicates if this transaction is applicable for updates in the FIFO rate control model Return values - Returns 1 if applicable, else returns 0 |
|
||
Returns 1 if current transaction is cacheable transaction
|
|
||
Determines if this transaction is a CMO transaction on Read channel
|
|
||
Determines if this transaction is a CMO transaction on Write channel
|
|
||
Determines if this transaction is a CMO transaction
|
|
||
Checks if the coherent transaction is DVM Sync
|
|
||
Indicates whether the current transaction is write cmo or not
|
|
||
Indicates whether the current transaction is write pcmo or not
|
|
||
Indicates whether the current transaction is write pcmo or not
|
|
||
Indicates whether the current transaction is writenosnp* cmo or not
|
|
||
Indicates whether the current transaction is writenosnpfull cmo or not
|
|
||
Indicates whether the current transaction is writenosnpptl cmo or not
|
|
||
Indicates whether the current transaction is writeuniqueptl or writeuniquefull cmo or not
|
|
||
Indicates whether the current transaction is writeuniquefull cmo or not
|
|
||
Indicates whether the current transaction is writeuniqueptl cmo or not
|
|
||
Returns 1 if current transaction is of device_type
|
|
||
Returns 1 if current transaction is DVM transaction
|
|
||
Calculates whether the transaction is partial or full cacheline access. returns 1, if transaction is full cacheline access. returns 0, if it is a partial cacheline access.
cacheline_size - indicates the value of the master cache line size |
|
||
Determines if this transaction is a PCMO transaction on write channel
|
|
||
returns 1 if current transaction is configured as realm
|
|
||
returns 1 if current transaction is configured as root or realm (value of AxNSE signal) physical addr range
|
|
||
returns 1 if current transaction is configured as secure access physical addr range
|
|
||
Indicates whether the current transaction is supported in CHI System monitor
|
|
||
returns 1 if transaction status fields are ABORTED, or it is dropped; otherwise returns 0
|
|
||
returns 1 if transaction status shows ended otherwise 0
|
|
||
Indicates the unaligned address
|
|
||
Limits the data to what can be transmitted if the address is unaligned. If the address is unaligned, we need to take care that data[0] and wstrb[0] are consistent with what can actually be driven on the bus. For example, for a 64 bit bus, if the address is 0x7, data can be sent only on 1 byte for the first beat. For a FIXED burst the address is same for all beats, so this operation needs to be done for all beats. For other bursts, only the first address can be unaligned, other beats are aligned addresses data_only - (Optional: default = 0) If this bit is set the operation is done only for data. beat_num - (Optional: default = -1) Applicable for a FIXED burst. When set to -1, masking is done for all beats, otherwise it is done only for the selected beat. |
|
||
Ensures that valid x,z,0,1 all four state datas are calculated with respect to data_mask values. This function is called under SVT_MEM_LOGIC_DATA macro define only, to make sure while masking valid x and z state data also considered towards masked data.
|
|
|
||
Ensures that valid x,z,0,1 all four state tags are calculated with respect to tag_mask values. This function is called under SVT_MEM_LOGIC_DATA macro define only, to make sure while masking valid x and z state tag also considered towards masked tag.
|
|
||||||||||
CONSTUCTOR: Create a new transaction instance, passing the appropriate argument values to the parent class.
name - Instance name of the transaction | ||||||||||
|
|
||
Returns the data in the atomic_compare_read_data_to_pack[] field as a byte stream based on the burst_type. The assumption is that atomic_read_data[] field of this class have been passed as arguments to atomic_compare_read_data_to_pack[] field. In the case of WRAP bursts the data is returned such that packed_atomic_compare_read_data[0] corresponds to the data for the wrap boundary. In the case of INCR bursts, the data as passed in atomic_compare_read_data_to_pack[] is directly packed to packed_data[]. atomic_compare_read_data_to_pack - Data to be packed packed_atomic_compare_read_data - [] Output byte stream with packed data |
|
||
Returns the data in the data_to_pack[] field as a byte stream based on the burst_type. The assumption is that either data[] or cache_write_data[] fields of this class have been passed as arguments to data_to_pack[] field. In the case of WRAP bursts the data is returned such that packed_data[0] corresponds to the data for the wrap boundary. In the case of INCR bursts, the data as passed in data_to_pack[] is directly packed to packed_data[]. data_to_pack - Data to be packed packed_data - [] Output byte stream with packed data |
|
||
Returns the data_user in the data_to_pack[] field as a byte stream based on the burst_type. The assumption is that data_user[] has been passed as arguments to data_to_pack[] field. In the case of WRAP bursts the data_user is returned such that packed_data[0] corresponds to the data for the wrap boundary. In the case of INCR bursts, the data_user as passed in data_to_pack[] is directly packed to packed_data[]. data_to_pack - Data to be packed packed_data - [] Output byte stream with packed data |
|
||
Returns the poison in the poison_to_pack[] field as a byte stream based on the burst_type. The assumption is that either poison[] or cache_write_poison[] fields of this class have been passed as arguments to data_to_pack5[] field. In the case of WRAP bursts the data is returned such that packed_poison[0] corresponds to the poison for the wrap boundary. In the case of INCR bursts, the poison as passed in poison_to_pack[] is directly packed to packed_poison[]. poison_to_pack - poison to be packed packed_poison - [] Output byte stream with packed poison |
|
||
Returns the tag in the tag_to_pack[] field as a byte stream based on the burst_type. The assumption is that either tag[] or cache_write_tag[] fields of this class have been passed as arguments to tag_to_pack[] field. In the case of WRAP bursts the tag is returned such that packed_tag[0] corresponds to the tag for the wrap boundary. In the case of INCR bursts, the tag as passed in tag_to_pack[] is directly packed to packed_tag[]. tag_to_pack - tag to be packed packed_tag - [] Output byte stream with packed tag |
|
||
Returns the tag_update in the tag_update_to_pack[] field as a byte stream based on the burst_type. In the case of WRAP bursts the tag_update is returned such that packed_tag_update[0] corresponds to the tag_update for the wrap boundary. In the case of INCR bursts, the wstrb as passed in tag_update_to_pack[] is directly packed to packed_tag_update[]. tag_update_to_pack - tag_update to be packed packed_tag_update - [] Output byte stream with packed tag_update |
|
||
Returns the wstrb in the wstrb_to_pack[] field as a byte stream based on the burst_type. In the case of WRAP bursts the wstrb is returned such that packed_wstrb[0] corresponds to the wstrb for the wrap boundary. In the case of INCR bursts, the wstrb as passed in wstrb_to_pack[] is directly packed to packed_wstrb[]. wstrb_to_pack - wstrb to be packed packed_wstrb - [] Output byte stream with packed wstrb |
|
||
Generates an SVT pattern object to represent the properties which are to be written to FSDB when the PA channel is RADDR, RDATA, WADDR, WDATA, or WRESP.
Return values - An svt_pattern instance containing entries to be written to FSDB |
|
||
Generates an SVT pattern object to represent the properties which are to be written to FSDB when a full tranaction is to be recorded. Note that not all properties are written. Instead, only properties needed for debug are added.
Return values - An svt_pattern instance containing entries to be written to FSDB |
|
||
Populates the partial data and byteen provided into data and byteen that is used to write into a full cacheline
|
|
||
Generates an SVT pattern object to represent the properties which are to be written to FSDB when the pa_format_type is set to FSDB_PERF_ANALYSIS.
Return values - An svt_pattern instance containing entries to be written to FSDB |
|
||
Generates an SVT pattern object to represent the properties which are to be written to FSDB when the PA channel is "STREAM DATA".
Return values - An svt_pattern instance containing entries to be written to FSDB |
|
||||||||||
post_randomize does the following 1) Aligns the address to no of Bytes for Exclusive Accesses
| ||||||||||
|
|
||||||||||
pre_randomize does the following 1) Tests the validity of the configuration 2) calculate the log_2 of master configs data_width
| ||||||||||
|
|
||||
Returns a string (with no line feeds) that reports the essential contents of the packet generally necessary to uniquely identify that packet.
prefix - (Optional: default = "") The string given in this argument becomes the first item listed in the value returned. It is intended to be used to identify the transactor (or other source) that requested this string. This argument should be limited to 8 characters or less (to accommodate the fixed column widths in the returned string). If more than 8 characters are supplied, only the first 8 characters are used. hdr_only - (Optional: default = 0) If this argument is supplied, and is '1', the function returns a 3-line table header string, which indicates which packet data appears in the subsequent columns. If this argument is '1', the prefix argument becomes the column label for the first header column (still subject to the 8 character limit). | ||||
|
|
||||||||||
Method to turn reasonable constraints on/off as a block.
| ||||||||||
|
|
||
Unsets the suspend_master_xact property
|
|
||
Sets the configuration property
|
|
||
Sets Combined Write and CMO type
|
|
||
mark end of transaction
|
|
||
This method is used to set object_type for bus_activity when bus_activity is getting started on the bus . This method is used by pa writer class in generating XML/FSDB
|
|
||||||||||||
HDL Support: For write access to public data members of this class.
| ||||||||||||
|
|
||
Sets the suspend_master_xact property
|
|
||||
Extend the svt_post_do_all_do_copy method to cleanup the exception xact pointers.
to - Destination class for the copy operation | ||||
|
|
||
Unpacks the data in data_to_unpack[] into utemp_datanpacked_data. For an INCR burst, the data is directly unpacked into unpacked_data For a WRAP burst, the data is unpacked such that unpacked_data[0] corresponds to the starting address. The assumption here is that data_to_unpack[] has a byte stream whose data starts from the address corresponding to the wrap boundary data_to_unpack - The data to unpack. unpacked_data - The unpacked data. |
|
||
Unpacks the data_user in data_to_unpack[] into utemp_datanpacked_data. For an INCR burst, the data_user is directly unpacked into unpacked_data For a WRAP burst, the data_user is unpacked such that unpacked_data[0] corresponds to the starting address. The assumption here is that data_to_unpack[] has a byte stream whose data_user starts from the address corresponding to the wrap boundary data_to_unpack - The data to unpack. unpacked_data - The unpacked data. |
|
||
Unpacks the poison in poison_to_unpack[] into unpacked_poison. For an INCR burst, the poison is directly unpacked into unpacked_poison For a WRAP burst, the poison is unpacked such that unpacked_poison[0] corresponds to the starting address. The assumption here is that poison_to_unpack[] has a byte stream whose poison starts from the address corresponding to the wrap boundary poison_to_unpack - The poison to unpack. unpacked_poison - The unpacked poison. |
|
||
Unpacks the wstrb in wstrb_to_unpack[] into unpacked_wstrb. For an INCR burst, the wstrb is directly unpacked into unpacked_wstrb For a WRAP burst, the wstrb is unpacked such that unpacked_wstrb[0] corresponds to the starting address. The assumption here is that wstrb_to_unpack[] has a byte stream whose wstrb starts from the address corresponding to the wrap boundary wstrb_to_unpack - The wstrb to unpack. unpacked_wstrb - The unpacked wstrb. |
|
||
unpacks tag into atomic_swap_tag and atomic_compare_tag into field. This is applicable for ATOMIC_COMPARE transactions only
|
|
||
waits for addr phase to end
|
|
||
waits for data phase to end
|
|
||
waits for transaction to end
|
|
||
waits for write resp phase to end
|
|
||
waits for slave transaction to update the memory
|
|
|
Represents the status of the read/write acknowledge sent via RACK/WACK for ACE interface. RACK/WACK is asserted for a single cycle. Following are the possible status types:
|
|
|
The variable represents AWADDR when xact_type is WRITE and ARADDR when xact_type is READ. The maximum width of this signal is controlled through macro SVT_AXI_MAX_ADDR_WIDTH. Default value of this macro is 64. To change the maximum width of this variable, user can change the value of this macro. Define the new value for the macro in file svt_axi_user_defines.svi, and then specify this file to be compiled by the simulator. Also, specify +define+SVT_AXI_INCLUDE_USER_DEFINES on the simulator compilation command line. Please consult User Guide for additional information, and consult VIP example for usage demonstration. The SVT_AXI_MAX_ADDR_WIDTH macro is only used to control the maximum width of the signal. The actual width used by VIP is controlled by configuration parameter svt_axi_port_configuration :: addr_width. |
|
|
This variable stores the timing information for address ready on read and write transactions. The simulation clock cycle number when the address valid and ready both are asserted i.e. handshake happens, is captured in this member. This information can be used for doing performance analysis. VIP updates the value of this member variable, user does not need to program this variable.
|
|
|
This variable stores the timing information for address ready on read and write transactions. The simulation time number when the address valid and ready both are asserted i.e. handshake happens, is captured in this member. This information can be used for doing performance analysis. VIP updates the value of this member variable, user does not need to program this variable.
|
|
|
This members applies to AWREADY signal delay for write transactions, and ARREADY signal delay for read transactions.
If configuration parameter svt_axi_port_configuration :: default_awready or svt_axi_port_configuration :: default_arready is FALSE, this member defines the AWREADY or ARREADY signal delay in number of clock cycles. The reference event used for this delay is reference_event_for_addr_ready_delay. If configuration parameter svt_axi_port_configuration :: default_awready or svt_axi_port_configuration :: default_arready is TRUE, this member defines the number of clock cycles for which AWREADY or ARREADY signal should be deasserted after each handshake, before pulling it up again to its default value. Applicable for ACTIVE SLAVE only. |
|
|
Represents the current status of the read or write address. Following are the possible status types.
|
|
|
This variable indicates that the transaction has already undergone PCIe ATS translation.
Active Master.
Active Slave, Passive components.
|
|
|
The variable holds the value for signals AWUSER/ARUSER. Applicable for all interface types. Enabled through port configuration parameters svt_axi_port_configuration :: aruser_enable and svt_axi_port_configuration :: awuser_enable.
|
|
|
This variable stores the cycle information for address valid on read and write transactions. The simulation clock cycle number when the address valid is asserted, is captured in this member. This information can be used for doing performance analysis. VIP updates the value of this member variable, user does not need to program this variable.
|
|
|
This variable stores the timing information for address valid on read and write transactions. The simulation time when the address valid is asserted, is captured in this member. This information can be used for doing performance analysis. VIP updates the value of this member variable, user does not need to program this variable.
|
|
|
This variable defines the number of cycles the AWVALID or ARVALID signal is delayed. The reference event for this delay is reference_event_for_addr_valid_delay. Applicable for ACTIVE MASTER only.
|
|
|
This variable stores the cycle information for address wakeup of read or write transaction. The simulation clock cycle number when the address wakeup is asserted, is captured in this member. This information can be used for doing performance analysis. VIP updates the value of this member variable, user does not need to program this variable.
|
|
|
This variable stores the timing information for address wakeup of read or write transaction. The simulation time when the address wakeup is asserted, is captured in this member. This information can be used for doing performance analysis. VIP updates the value of this member variable, user does not need to program this variable.
|
|
|
Indicates that the data as given in cache_write_data [] in this transaction needs to be allocated in the cache. Applicable only when transaction type is READUNIQUE or CLEANUNIQUE. Applicable when svt_axi_port_configuration :: axi_interface_type is set to AXI_ACE.
Applicable for ACTIVE MASTER only. |
|
|
The variable holds the value for ARADDRCHK. signals covered under this group {ARADDR}. The width of this signal is controlled by macro SVT_AXI_MAX_ADDR_WIDTH. |
|
|
Defines the chunk enable of a AXI5/ACE5LITE to enable read_data_chunking. When enable, slave will send read data in 128bits of chunk in random order. If disabled, slave will send read data without chunking as per AXI5/ACE5LITE protocol. Applicable when svt_axi_port_configuration :: rdata_chunking_enable is set to 1.
|
|
|
The variable holds the value for ARCTLCHK0. signals covered under this group {ARSIZE,ARBURST,ARLOCK,ARPROT,ARNSE}. |
|
|
The variable holds the value for ARCTLCHK1. signals covered under this group {ARREGION,ARCACHE,ARQOS}. |
|
|
The variable holds the value for ARCTLCHK2. signals covered under this group {ARDOMAIN,ARSNOOP,ARBAR}. |
|
|
The variable holds the value for ARCTLCHK3. signals covered under this group {ARVMIDEXT,ARCHUNKEN,ARTAGOP}. |
|
|
The variable holds the value for ARIDCHK. signals covered under this group {ARIDUNQ, ARID}. The width of this signal is controlled by macro SVT_AXI_MAX_ID_WIDTH. SVT_AXI_MAX_ID_WIDTH: ARID 1 : ARIDUNQ . |
|
|
The variable holds the value for ARLENCHK. signals covered under this group {ARLEN}. |
|
|
The variable holds the value for ARLOOPCHK. signals covered under this group {ARLOOP}. |
|
|
The variable holds the value for ARMMUCHK. signals covered under this group {ARMMUTAST,ARMMUFLOW,ARMMUSECSID,ARMMUSSIDV,ARMMUVALID}. |
|
|
The variable holds the value for ARMMUSID. signals covered under this group {ARMMUSID}. The width of this signal is controlled by macro SVT_AXI_MAX_MMUSID_WIDTH. |
|
|
The variable holds the value for ARMMUSSIDCHK. signals covered under this group {ARMMUSSID}. The width of this signal is controlled by macro SVT_AXI_MAX_MMUSSID_WIDTH. |
|
|
The variable holds the value for ARMPAMCHK. signals covered under this group {ARMPAM}. |
|
|
The variable holds the value for ARNSAIDCHK. signals covered under this group {ARNSAID}. |
|
|
The variable holds the value for ARREADYCHK. signals covered under this group {ARREADY}. |
|
|
The variable holds the value for ARTRACEHK. signals covered under this group {ARTRACE}. |
|
|
The variable holds the value for ARUSERCHK. signals covered under this group {ARUSER}. The width of this signal is controlled by macro SVT_AXI_MAX_ADDR_USER_WIDTH. |
|
|
The variable holds the value for ARVALIDCHK. signals covered under this group {ARVALID}. |
|
|
The variable represents ARVMIDEXT when svt_axi_port_configuration :: axi_interface_type is set to AXI_ACE or ACE_LITE with svt_axi_system_configuration :: DVMV8_1 or above. The maximum width of this signal is controlled through macro SVT_AXI_MAX_VMIDEXT_WIDTH. Default value of this macro is 4 based on DVMv8.1 architecture recomendation.
|
|
|
if this bit is set to '0' then AWAKEUP signal will be asserted before ARVALID or AWVALID with respect to awakeup_assert_delay. if this bit is set to '1' then AWAKEUP signal will be asserted after ARVALID or AWVALID with respect to awakeup_assert_delay. Applicable for ACTIVE MASTER only.
|
|
|
This member points to a barrier pair transaction associated to this current transaction. When associated_barrier_xact is null, it indicates that this current transaction is not a post-barrier transaction. When associated_barrier_xact is non-null, this current transaction will wait for responses from the barrier transactions in associated_barrier_xact, before it can be transmitted.
associated_barrier_xact can be set in the callback svt_axi_master_callback :: associate_xact_to_barrier_pair. In this callback, user can associate this transaction with a barrier transaction pair. Please refer to User Guide for more details on usage of this member. |
|
|
When this bit is set by user, it indicates that this transaction is a post-barrier transaction and that it needs to wait for responses from the barrier transaction pair indicated in associated_barrier_xact. associated_barrier_xact can be set in the callback svt_axi_master_callback :: associate_xact_to_barrier_pair. In this callback, user can associate this transaction with a barrier transaction pair.
Please refer to User Guide for more description. |
|
|
Represents the set index in the associative cache that contains the cacheline corresponding to the transaction address. Applicable only in case of coherent, cacheable transactions initiated from active ACE master VIP with an n-way associative cache (svt_axi_port_configuration :: num_associative_cache_ways > 0). Will be automatically populated by the active ACE master driver before the request is driven out on the interface and is a read-only field for users. In case of coherent transactions that allocate the cache, the value of this field is determined by the API "get_associative_cache_set_index". For all other coherent non-allocating transactions, the value of this field is determined by the properties of the corresponding cacheline. Default value: -1. |
|
|
Represents the Tag value of the associative cache entry that contains the cacheline corresponding to the transaction address. Applicable only in case of coherent, cacheable transactions initiated from active ACE master VIP with an n-way associative cache (svt_axi_port_configuration :: num_associative_cache_ways > 0). Will be automatically populated by the active ACE master driver before the request is driven out on the interface and is a read-only field for users. In case of coherent transactions that allocate the cache, the value of this field is determined by the API "get_associative_tag". For all other coherent non-allocating transactions, the value of this field is determined by the properties of the corresponding cacheline. Default value: 0. |
|
|
Represents the way number within the associative cache set that contains the cacheline corresponding to the transaction address. Applicable only in case of coherent, cacheable transactions initiated from active ACE master VIP with an n-way associative cache (svt_axi_port_configuration :: num_associative_cache_ways > 0). Will be automatically populated by the active ACE master driver before the request is driven out on the interface and is a read-only field for users. Default value: -1. |
|
|
This variable represents the compare data value for the atomic compare transactions. This will not be programmed by the user.This is an internal variable used for VIP internal consumption. This is populated by the Active Slave , Passive Slave and Passive Master VIP. This is programmed reliably by the slave or passive master component only after the start of the response phase. Therefore, these members are expected to be read/used only in write_response_phase_started callback or in a later callback such as write_respond_phase_ended/transaction_ended/item_observed_port
|
|
|
This variable represents the compare tag value for the atomic compare transactions. This must not be programmed by the user.This is an internal variable populated by the AXI SLAVE. Only populated if transfer size is 32 Bytes
|
|
|
This variable represents the compare write strobes value for the atomic compare transactions. This must not be programmed by the user.This is an internal variable populated by the AXI SLAVE.
|
|
|
This is a counter which is incremented for every beat. Useful when user would try to access the transaction class to know its current state. This represents the beat number for which the status is reflected in member data_status.
|
|
|
This variable represents the read data for the atomic load,swap and compare transactions. This data will be driven by the slave on the read data channel. APPLICABLE IN ALL MODES: If svt_axi_port_configuration :: wysiwyg_enable is set to 0 (default), the data must be stored right-justified by the user. The model will drive the data on the correct lanes. If svt_axi_port_configuration :: wysiwyg_enable is set to 1, the data is transmitted as programmed by user and is reported as seen on bus. No right-justification is used in this case. The maximum width of this signal is controlled through macro SVT_AXI_MAX_DATA_WIDTH. Default value of this macro is 1024. To change the maximum width of this variable, user can change the value of this macro. Define the new value for the macro in file svt_axi_user_defines.svi, and then specify this file to be compiled by the simulator. Also, specify +define+SVT_AXI_INCLUDE_USER_DEFINES on the simulator compilation command line. Please consult User Guide for additional information, and consult VIP example for usage demonstration. The SVT_AXI_MAX_DATA_WIDTH macro is only used to control the maximum width of the signal. The actual width used by VIP is controlled by configuration parameter svt_axi_port_configuration :: data_width. |
|
|
This variable stores the timing information for data ready on read and write transactions. The simulation clock cycle number when the data valid and ready both are asserted, is captured in this member. This information can be used for doing performance analysis. VIP updates the value of this member variable, user does not need to program this variable.
|
|
|
This variable stores the timing information for data ready on read and write transactions. The simulation time when the data valid and ready both are asserted, is captured in this member. This information can be used for doing performance analysis. VIP updates the value of this member variable, user does not need to program this variable.
|
|
|
Represents the status of the read or write data transfer. Following are the possible status types.
|
|
|
The variable holds the value for signals RUSER. Applicable only if svt_axi_port_configuration :: atomic_transactions_enable is set to1. Enabled through port configuration parameters svt_axi_port_configuration :: ruser_enable.
|
|
|
This variable represents the data check parity bit's on the read data channel for atomic transactions. It consists of a bit for each 8 data byte in the transaction data. This is only applicable for Atomic Load , Swap and Compare transactions and applicable when svt_axi_port_configuration :: check_type is set to ODD_PARITY_BYTE_DATA or ODD_PARITY_BYTE_ALL.
Active Master.
Active Slave.
Passive components.
|
|
|
|
|
|
This variable stores the cycle information for data valid on read and write transactions. The simulation clock cycle number when the data valid is asserted, is captured in this member. This information can be used for doing performance analysis. VIP updates the value of this member variable, user does not need to program this variable.
|
|
|
This variable stores the timing information for data valid on read and write transactions. The simulation time when the data valid is asserted, is captured in this member. This information can be used for doing performance analysis. VIP updates the value of this member variable, user does not need to program this variable.
|
|
|
This variable indicate whether the data check parity error is detected in the read of atomic transaction. This bit is set to 1, if parity error is deducted in a transaction. By default this is set to 0. This is only applicable for Atomic Load , Swap and Compare transactions and applicable when svt_axi_port_configuration :: check_type is set to ODD_PARITY_BYTE_DATA or ODD_PARITY_BYTE_ALL.
Active Master.
Active Slave.
Passive components.
|
|
|
This variable represents the data check parity error bit's with respect to valid read data of atomic transactions. Each bit of parity check data is calculated from every 8bit of data with 1bit if datachk. By default all bits are set to 'b1, if any parity error is detected the that particular bit is set to 0. This is only applicable for Atomic Load , Swap and Compare transactions and applicable when svt_axi_port_configuration :: check_type is set to ODD_PARITY_BYTE_DATA or ODD_PARITY_BYTE_ALL.
Active Master.
Active Slave.
Passive components.
|
|
|
This variable is only applicable for atomic transactions. MASTER in active mode: For Atomic LOAD , SWAP and COMPARE transactions specifies read data as seen on the RDATA bus.
SLAVE in active mode: This variable represents the read data for the atomic load,swap and compare transactions to be driven on the RDATA bus. PASSIVE MODE: This variable stores the read data as seen on RDATA bus. |
|
|
Array of poisonal value driven by the active slave on the read data channel for atomic transactions. This is only applicable for Atomic Load , Swap and Compare transactions.
Active Slave.
Passive components.
|
|
|
This variable represents the data that will be stored in the memory for atomic transactions after the atomic operation is performed. This is updated by slave agent for both the modes (active/passive). The value will be populated/expected only after successful completion of transaction and can be accessed by transaction_ended callback or item_observed_port. APPLICABLE IN ALL MODES: The SVT_AXI_MAX_DATA_WIDTH macro is only used to control the maximum width of the signal. The actual width used by VIP is controlled by configuration parameter svt_axi_port_configuration :: data_width.
|
|
|
This variable represents the swap data value for the atomic compare transactions. This will not be programmed by the user.This is an internal variable used for VIP internal consumption. This is programmed by slave component in ongoing atomic transaction internally. This is populated by the Active Slave , Passive Slave and Passive Master VIP. This is programmed reliably by the slave or passive master component only after the start of the response phase. Therefore, these members are expected to be read/used only in write_response_phase_started callback or in a later callback such as write_respond_phase_ended/transaction_ended/item_observed_port
|
|
|
This variable represents the swap tag value for the atomic compare transactions. This must not be programmed by the user.This is an internal variable populated by the AXI SLAVE. Only populated if transfer size is 32 Bytes
|
|
|
This variable represents the swap write strobes value for the atomic compare transactions. This must not be programmed by the user.This is an internal variable populated by the AXI SLAVE.
|
|
|
-
|
|
|
Represents the atomic access of a transaction. The variable holds the value for AWLOCK/ARLOCK. Following are the possible atomic types:
|
|
|
-
|
|
|
The variable represents configuration for parity value generation. When the value is set to '1', VIP generates the parity values for corresponding check signals and drives them. When the value is set to '0', and respective parity signal index are set to '1' in the user_inject_parity_signal_array, VIP drives the parity values provided by the user. Default Value : 1. |
|
|
The variable holds the value for AWADDRCHK. signals covered under this group {AWADDR}. The width of this signal is controlled by macro SVT_AXI_MAX_ADDR_WIDTH. |
|
|
Defines the delay in number of cycles for AWAKEUP signal assertion before or after ARVALID or AWVALID signal. Applicable for ACTIVE MASTER only
|
|
|
Defines the delay in number of cycles for AWAKEUP signal deassertion after ARVALID-ARREADY or AWVALID-AWREADY signal handshake. Applicable for ACTIVE MASTER only.
|
|
|
The variable holds the value for AWCTLCHK0. signals covered under this group {AWSIZE,AWBURST,AWLOCK,AWPROT,AWNSE}. |
|
|
The variable holds the value for AWCTLCHK1. signals covered under this group {AWREGION,AWCACHE,AWQOS}. |
|
|
The variable holds the value for AWCTLCHK2. signals covered under this group {AWDOMAIN,AWSNOOP,AWUNIQUE,AWBAR}. |
|
|
The variable holds the value for AWCTLCHK3. signals covered under this group {AWATOP,AWCMO,AWTAGOP}. |
|
|
The variable holds the value for AWIDCHK signal. singals covered under this group {AWIDUNQ,AWID}. The maximum width of the signal is controlled through macro 8. SVT_AXI_MAX_ID_WIDTH: AWID 1 : AWIDUNQ . |
|
|
The variable holds the value for AWLENCHK. signals covered under this group {AWLEN}. |
|
|
The variable holds the value for AWLOOPCHK. signals covered under this group {AWLOOP}. |
|
|
The variable holds the value for AWMMUCHK. signals covered under this group {AWMMUTAST,AWMMUFLOW,AWMMUSECSID,AWMMUSSIDV,AWMMUVALID}. |
|
|
The variable holds the value for AWMMUSIDCHK. signals covered under this group {AWMMUSID}. The width of this signal is controlled by macro SVT_AXI_MAX_MMUSID_WIDTH. |
|
|
The variable holds the value for AWMMUSSIDCHK. signals covered under this group {AWMMUSSID}. The width of this signal is controlled by macro SVT_AXI_MAX_MMUSSID_WIDTH. |
|
|
The variable holds the value for AWMPAMCHK. signals covered under this group {AWMPAM}. |
|
|
The variable holds the value for AWNSAIDCHK. signals covered under this group {AWNSAID}. |
|
|
The variable holds the value for AWREADYCHK signal. signals covered under this group {AWREADY}. |
|
|
The variable holds the value for AWSTASHLPIDCHK. signals covered under this group {AWSTASHLPID,AWSTASHLPIDEN}. |
|
|
The variable holds the value for AWSTASHNIDCHK. signals covered under this group {AWSTASHNID,AWSTASHNIDEN}. |
|
|
The variable holds the value for AWTRACECHK. signals covered under this group {AWTRACE}. |
|
|
The variable holds the value for AWUSERCHK. signals covered under this group {AWUSER}. The width of this signal is controlled by macro SVT_AXI_MAX_ADDR_USER_WIDTH. |
|
|
The variable holds the value for AWVALIDCHK signal. signals covered under this group {AWVALID}. |
|
|
This variable represents barrier transaction type. Applicable when svt_axi_port_configuration :: axi_interface_type is set to AXI_ACE or ACE_LITE.
|
|
|
The variable holds the value for BIDCHK. signals covered under this group {BIDUNQ,BID}. The maximum width of the signal is controlled through macro 8. SVT_AXI_MAX_ID_WIDTH: BID 1 : BIDUNQ . |
|
|
The variable holds the value for BLOOPCHK. signals covered under this group {BLOOP}. |
|
|
The variable holds the value for BREADYCHK. signals covered under this group {BREADY}. |
|
|
If configuration parameter svt_axi_port_configuration :: default_bready is FALSE, this member defines the BREADY signal delay in number of clock cycles. The reference event for this delay is reference_event_for_bready_delay.
If configuration parameter svt_axi_port_configuration :: default_bready is TRUE, this member defines the number of clock cycles for which BREADY signal should be deasserted after each handshake, before pulling it up again to its default value. Applicable for ACTIVE MASTER only. |
|
|
This variable specifies the response for write transaction. The variable holds the value for BRESP. Following are the possible response types:
MASTER ACTIVE MODE: Will Store the write response received from the slave. SLAVE ACTIVE MODE: The write response programmed by the user. PASSIVE MODE - MASTER/SLAVE: Stores the write response seen on the bus. |
|
|
The variable holds the value for BRESPCHK. signals covered under this group {BRESP,BCOMP,BPERSIST,BBUSY}. |
|
|
The variable holds the value for BTRACECHK. signals covered under this group {BTRACE}. |
|
|
The variable represents the actual length of the burst. For eg. burst_length = 1 means a burst of length 1.
If svt_axi_port_configuration :: axi_interface_type is AXI3, burst length of 1 to 16 is supported. If svt_axi_port_configuration :: axi_interface_type is AXI4, burst length of 1 to 256 is supported. |
|
|
Represents the burst size of a transaction . The variable holds the value for AWSIZE/ARSIZE.
|
|
|
Represents the burst type of a transaction. The burst type holds the value for AWBURST/ARBURST. Following are the possible burst types:
|
|
|
|
|
The variable holds the value for BUSERCHK. The maximum width of the signal is controlled through macro 4. signals covered under this group {BUSER}. |
|
|
The variable holds the value for BVALIDCHK. signals covered under this group {BVALID}. |
|
|
Defines the BVALID delay in terms of number of clock cycles. The reference event for this delay is reference_event_for_bvalid_delay.
Applicable for ACTIVE SLAVE only. |
|
|
Applicable when svt_axi_port_configuration :: axi_interface_type is set to AXI_ACE. Users who need to bypass lookup of cache to determine valid initial cache line states can set this property to 1. In order to randomize this property to 1, the user must switch off svt_axi_master_transaction :: reasonable_bypass_cache_lookup constraint. Setting this property will enable transactions to be sent out even if the initial cache state does not meet requirements set by ACE protocol. Please note that coherency is not guaranteed when this property is set
Applicable for ACTIVE MASTER only. |
|
|
Applicable when svt_axi_port_configuration :: axi_interface_type is set to AXI_ACE.
Indicates if update of cache must be bypassed for this transaction. A typical use model is to set this bit in pre_cache_update callback of the driver based on response received in the transaction. For example, if the response received is SLVERR, user may not want the driver to update the cache. When using this property, it is the user's responsibility that system coherency is not lost, since cache will not be updated. Applicable for ACTIVE MASTER only. |
|
|
Represents the cache support of a transaction. The variable holds the value for AWCACHE/ARCACHE.
Following values are supported in AXI3 mode:
Following values for ARCACHE are supported in AXI4 mode:
Following values for AWCACHE are supported in AXI4 mode:
|
|
|
Applicable when svt_axi_port_configuration :: axi_interface_type is set to AXI_ACE.
Represents data that needs to be stored to the cache if the allocate_in_cache bit is set for a READUNIQUE/CLEANUNIQUE transaction or if the transaction is MAKEUNIQUE. Applicable to masters in active mode. Refer section 3.6 of ACE specification. Writes in ACE are performed by removing all other copies of the cache line so that the master that is performing the write has a unique copy at the time of writing. Depending on whether a paritial or full update of a cache line is required a transaction such as READUNIQUE,MAKEUNIQUE or CLEANUNIQUE is sent. Some of these transactions such as READUNIQUE will return data (either from memory or the cache of some other master) and this will be available in the data[] field of this class. Other transactions such as MAKEUNIQUE and CLEANUNIQUE will not return any data. For a READUNIQUE transaction, if the allocate_in_cache bit is not set, the data available in data[] is written in cache. If the allocate_in_cache bit is set the data available in this variable is written to cache. Note however, that this variable is overwritten by the data that is received in data[] prior to writing in the cache. This is done because READUNIQUE is used for partial update of a cacheline when a master does not have a copy of the cacheline. So a user can actually populate this variable after a copy of this cacheline is received and not at the time of randomization. For a CLEANUNIQUE transaction, if the allocate_in_cache bit is set, the data in this variable is written to cache. For a MAKEUNIQUE transaction, the data in this variable is always written into the cache. Updating this variable is normally done in the pre_cache_update callback issued by the master driver after all the responses are received but prior to the RACK signal being driven. An important aspect of this variable is that this data is not driven on the physical bus. Applicable for ACTIVE MASTER only. |
|
|
Applicable only for master in ACTIVE mode. If this transaction was generated from a UVM TLM Generic Payload, this member indicates the GP from which this AXI transaction was generated
|
|
|
If set, the driver checks if this transaction accesses a location addressed by a previous transaction from this port or from some other master. If there are any such previous transactions, this transaction is blocked until all those transactions complete. Also, the driver does not pull any more transactions until this transaction is unblocked. If not set, this transaction is not checked for access to a location which was previously accessed by another transaction. When svt_axi_port_configuration :: axi_interface_type is set to AXI4_STREAM then setting of this attribute to 1 is not applicable, VIP will override it to 0. Applicable only when svt_axi_system_configuration :: overlap_addr_access_control_enable is set
Applicable for ACTIVE MASTER only |
|
|
Indicates that the data chunk length is being transferred. This signal is for interal use to calculate number of transafer for chunkinig Applicable when archunken and svt_axi_port_configuration :: rdata_chunking_enable is set to 1.
|
|
|
This variable represents the cmo on the write channel. Applicable when svt_axi_port_configuration :: axi_interface_type is set to ACE_LITE.
|
|
|
This variable represents the shareable coherent transaction types. Applicable when svt_axi_port_configuration :: axi_interface_type is set to AXI_ACE or ACE_LITE.
|
|
|
Array for the coherent read responses. Applicable when svt_axi_port_configuration :: axi_interface_type is set to AXI_ACE.
|
|
|
This field determines the relative timing of BTAGMATCH with respect to BCOMP. Applicable only for writes/Atomic transaction with tag_op set to TAG_FETCH_MATCH.
Applicable for ACTIVE SLAVE only. |
|
|
This is a counter which is incremented for every beat. Useful when user would try to access the transaction class to know its current state. This represents the beat number for which the status is reflected in member data_status.
|
|
|
This is a counter which is incremented for every chunk of databeat. Useful when user would try to access the transaction class to know its current state during chunking. This represents the chunk databeat transfer number.
|
|
|
Multibit array for different usages.
If cust_xact_flow[0] is set to '1', indicate that transaction should be drived immediately on the interface. This is aplicable only for AXI4 STREAM transactions. cust_xact_flow[31:1] bits are for future use. |
|
|
MASTER in active mode:
For write transactions this variable specifies write data to be driven on the WDATA bus. SLAVE in active mode: For read transactions this variable specifies read data to be driven on the RDATA bus. PASSIVE MODE: This variable stores the write or read data as seen on WDATA or RDATA bus.
APPLICABLE IN ALL MODES: If svt_axi_port_configuration :: wysiwyg_enable is set to 0 (default), the data must be stored right-justified by the user. The model will drive the data on the correct lanes. If svt_axi_port_configuration :: wysiwyg_enable is set to 1, the data is transmitted as programmed by user and is reported as seen on bus. No right-justification is used in this case. |
|
|
Indicates that data will start before address for write transactions. In data_before_addr scenario (i.e., when data_before_addr = '1'), addr and data channel related delay considerations are: 1) For programming address_channel related delay: awvalid_delay and reference_event_for_addr_valid_delay are used. (for more information, look for the description of these variables). reference_event_for_addr_valid_delay should be set FIRST_WVALID_DATA_BEFORE_ADDR. In data_before_addr scenarios reference_event_for_addr_delay should be set very carefully to FIRST_DATA_HANDSHAKE_DATA_BEFORE_ADDR as this may cause potential deadlock scenarios in SLAVE DUT where slave DUT waits for awvalid signal before driving wready signal. 2) For programming data_channel related delay: wvalid_delay[] and reference_event_for_first_wvalid_delay & reference_event_for_next_wvalid_delay are used. (for more information, look for the description of these variables). For wvalid_delay[0] - reference_event_for_first_wvalid_delay For remaining indices of wvalid_delay - reference_event_for_next_wvalid_delay In data_before_addr scenario, reference_event_for_first_wvalid_delay must be PREV_WRITE_DATA_HANDSHAKE, otherwise it will cause failure. .
|
|
|
This variable stores the timing information for the data channnel blocking ratio. The blocking cycle for a beat is defined as the number of cycles that valid was asserted, but corresponding ready was not asserted. This ratio is derived from data_valid_assertion_cycle and data_ready_assertion_cycle, calculated as sum of data ready blocking cycles divided by sum of data valid assertion cycles. This information can be used for doing performance analysis. VIP updates the value of this member variable, user does not need to program this variable.
|
|
|
This variable stores the timing information for data ready on read and write transactions. The simulation clock cycle number when the data valid and ready both are asserted, is captured in this member. This variable is also applicable for AXI4_STREAM protocol and it will hold tready assertion cycle. This information can be used for doing performance analysis. VIP updates the value of this member variable, user does not need to program this variable.
|
|
|
This variable stores the timing information for data ready on read and write transactions. The simulation time when the data valid and ready both are asserted, is captured in this member. This variable is also applicable for AXI4_STREAM protocol and it will hold tready assertion time. This information can be used for doing performance analysis. VIP updates the value of this member variable, user does not need to program this variable.
|
|
|
Represents the status of the read or write data transfer. Following are the possible status types.
|
|
|
The variable holds the value for signals WUSER/RUSER. Applicable for all interface types. Enabled through port configuration parameters svt_axi_port_configuration :: wuser_enable and svt_axi_port_configuration :: ruser_enable.
|
|
|
This variable represents the data check parity bit's with respect to valid data. It consists of a bit for each 8 data byte in the transaction data. Each bit of parity check data is calculated from every 8bit of data. Applicable when svt_axi_port_configuration :: check_type is set to ODD_PARITY_BYTE_DATA or ODD_PARITY_BYTE_ALL.
Active Master.
Active Slave.
Passive components.
|
|
|
|
|
|
This variable stores the cycle information for data valid on read and write transactions. The simulation clock cycle number when the data valid is asserted, is captured in this member. This variable is also applicable for AXI4_STREAM protocol and it will hold tvalid assertion cycle. This information can be used for doing performance analysis. VIP updates the value of this member variable, user does not need to program this variable.
|
|
|
This variable stores the timing information for data valid on read and write transactions. The simulation time when the data valid is asserted, is captured in this member. This variable is also applicable for AXI4_STREAM protocol and it will hold tvalid assertion time. This information can be used for doing performance analysis. VIP updates the value of this member variable, user does not need to program this variable.
|
|
|
This variable represents the shareability domain of coherent transactions. Applicable when svt_axi_port_configuration :: axi_interface_type is set to AXI_ACE or ACE_LITE.
|
|
|
Applicable when svt_axi_port_configuration :: axi_interface_type is set to AXI_ACE. Defines the delay between reception of DVM Sync and transmission of DVM Complete. Delay for master component in terms of number of clock cycles for generating DVM Complete transaction after receiving a DVM Sync transaction.
Applicable for ACTIVE MASTER only. |
|
|
Indicates the value of the source master which will be propogated in the ID field of the master and the corresponding slave transaction. Applicable for users who want to correlate master transactions to slave transactions in the system monitor. This parameter is applicable when svt_axi_port_configuration :: source_master_id_xmit_to_slaves_type is set to DYNAMIC_SOURCE_MASTER_ID_XMIT_TO_SLAVES. This property must be set by the user in a system monitor callback issued at the start of a transaction
|
|
|
This variable controls enabling of interleaving for the current transaction. In case of AXI4_STREAM interface type for active master, setting this variable to 1 is applicable only when svt_axi_port_configuration :: stream_interleave_depth is greater than 1. Example: svt_axi_port_configuration :: read_data_reordering_depth = 2 Requirement: Unless all beats of transaction 1 are sent out, the beats of 2nd transactions should not be sent. Solution: Program the enable_interleave = 0 for both the transaction 1. |
|
|
Indicates the endianness of the Outbound Write Data in an Atomic transaction.
|
|
|
Represents the status of coherent exclusive access. Following are the possible status types:
A combination of excl_access_status and excl_mon_status can be used to determine the reason for failure of exclusive store. Please refer to the User Guide for more description. |
|
|
Represents the status of master exclusive monitor, which indicates the cause of failure for a coherent exclusive store. It is valid only for exclusive store transaction, that is, CleanUnique. For all other transactions it is set to EXCL_MON_INVALID by default. Following are the possible status types:
A combination of excl_access_status and excl_mon_status can be used to determine the reason for failure of exclusive store. Please refer to the User Guide for more description. |
|
|
This variable represents the final cache line data. Applicable when svt_axi_port_configuration :: axi_interface_type is set to AXI_ACE or ACE_LITE. The final cache line data of a transaction is the data of the the line just before the transaction ended.
Applicable for ACTIVE MASTER only. |
|
|
This variable represents the final cache line state. Applicable when svt_axi_port_configuration :: axi_interface_type is set to AXI_ACE or ACE_LITE. The final cache line state of a transaction is the state of the the line just before the transaction ended. This variable is updated by the VIP, and is a read-only variable. User is not expected or supposed to modify this variable.
Applicable for ACTIVE MASTER only. |
|
|
Applicable when svt_axi_port_configuration :: axi_interface_type is set to AXI_ACE or ACE_LITE. Indicates if the cache line state needs to be forced to an invalid state even if that is not the recommended state, since it is permissible for a cache line which is in a clean state to be held in the invalid state. Valid only when: svt_axi_port_configuration :: cache_line_state_change_type is set to LEGAL_WITHOUT_SNOOP_FILTER_CACHE_LINE_STATE_CHANGE.
Applicable for ACTIVE MASTER only. |
|
|
Applicable when svt_axi_port_configuration :: axi_interface_type is set to AXI_ACE or ACE_LITE. Indicates if the cache line state needs to be forced to a shared state even if the actual state of the line is unique, since it is permissible for a cache line which is in the unique state to be held in the shared state. Valid only when: svt_axi_port_configuration :: cache_line_state_change_type is set to LEGAL_WITH_SNOOP_FILTER_CACHE_LINE_STATE_CHANGE or LEGAL_WITHOUT_SNOOP_FILTER_CACHE_LINE_STATE_CHANGE.
Applicable for ACTIVE MASTER only. |
|
|
Applicable when svt_axi_port_configuration :: axi_interface_type is set to AXI_ACE or ACE_LITE. Forces transactions which are not constrained to be of cacheline size by protocol to be of cacheline size. Currently applicable only to READONCE, WRITEUNIQUE, WRITENOSNOOP and READNOSNOOP transactions. Applicable to WRITENOSNOOP and READNOSNOOP only when svt_axi_port_configuration :: update_cache_for_non_coherent_xacts is set and svt_axi_port_configuration :: axi_interface_type is AXI_ACE. If this bit is set, READONCE and WRITEUNIQUE transactions will be forced to cache line size transactions. This has a dependency on svt_axi_port_configuration :: force_xact_to_cache_line_size_interface_type.
Applicable for ACTIVE MASTER only. |
|
|
The variable holds the value of AWID/WID/BID/ARID/RID signals. The maximum width of this signal is controlled through macro SVT_AXI_MAX_ID_WIDTH. Default value of this macro is 8. To change the maximum width of this variable, user can change the value of this macro. Define the new value for the macro in file svt_axi_user_defines.svi, and then specify this file to be compiled by the simulator. Also, specify +define+SVT_AXI_INCLUDE_USER_DEFINES on the simulator compilation command line. Please consult User Guide for additional information, and consult VIP example for usage demonstration. The SVT_AXI_MAX_ID_WIDTH macro is only used to control the maximum width of the signal. The actual width used by VIP is controlled by configuration parameter svt_axi_port_configuration :: id_width. |
|
|
Applicable when svt_axi_port_configuration :: toggle_ready_signals_during_idle_period is set. Applicable for slave VIP.
Indicates the number of cycles for which awready and arready should be high and low when the corresponding address channel is idle, that is, when AWVALID/ARVALID is low. This property helps to toggle the AWREADY/ARREADY signal during the idle period between the assertion of AWVALID/ARVALID signal of this transaction and the next transaction. This value may be assigned during randomization of the transaction object in the slave sequence. Values provided in even numbered indices indicate the number of clocks for which the ready signal must be driven low and the values in odd numbered indices indicate the number of clocks for which it must driven high. Values in this variable are applicable only until the corresponding valid is asserted. When AWVALID/ARVALID is observed on the interface, this delay is no longer applicable and the delay specified in addr_ready_delay is applied before asserting AWREADY/ARREADY. Note that toggling AWREADY/ARREADY during the idle period may lead to situations where the AWREADY/ARREADY signal is already asserted when the corresponding valid is sampled, even though the value of svt_axi_port_configuration :: default_awready or svt_axi_port_configuration :: default_arready is low. Similarly, AWREADY/ARREADY may be low when the corresponding valid is sampled, even though the value of svt_axi_port_configuration :: default_awready or svt_axi_port_configuration :: default_arready is high. In both these cases, addr_ready_delay is not applicable. The size of this array can be set to any value greater than 0, based on the number of times the user would like the signal to toggle during idle period. |
|
|
Applicable when svt_axi_port_configuration :: toggle_ready_signals_during_idle_period is set. Applicable for master VIP.
Indicates the number of cycles for which BREADY should be high and low when the write response channel is idle, that is, when BVALID is low. This property helps to toggle the BREADY signal during the idle period between the assertion of BVALID signal. The value for this property may be set when the transaction is randomized at the master or in a callback such as svt_axi_port_monitor_callback :: write_resp_phase_started. Values provided in even numbered indices indicate the number of clocks for which the ready signal must be driven low and the values in odd numbered indices indicate the number of clocks for which it must driven high. Values in this variable are applicable only until BVALID is asserted. When BVALID is observed on the interface, this delay is no longer applicable. The delay specified in bready_delay is applied before this attribute is applied. Note that toggling BREADY during the idle period may lead to situations where the BREADY signal is already asserted when BVALID is sampled, even though the value of svt_axi_port_configuration :: default_bready is low. Similarly, BREADY may be low when the corresponding valid is sampled, even though the value of svt_axi_port_configuration :: default_bready is high. In both these cases, bready_delay is not applicable. The size of this array can be set to any value greater than 0, based on the number of times the user would like the signal to toggle during idle period. |
|
|
This variable stores the timing information for wakeup of idle read or write channel. The simulation time when the wakeup is asserted, is captured in this member. This information can be used for doing performance analysis. VIP updates the value of this member variable, user does not need to program this variable.
|
|
|
This variable stores the timing information for wakeup of idle read or write channel. The simulation time when the wakeup is deasserted, is captured in this member. This information can be used for doing performance analysis. VIP updates the value of this member variable, user does not need to program this variable.
|
|
|
Applicable when svt_axi_port_configuration :: toggle_ready_signals_during_idle_period is set. Applicable for master VIP.
Indicates the number of cycles for which RREADY should be high and low when the read data channel is idle, that is, when RVALID is low. This property helps to toggle the RREADY signal during the idle period between the assertion of RVALID signal. Values provided in even numbered indices indicate the number of clocks for which the ready signal must be driven low and the values in odd numbered indices indicate the number of clocks for which it must driven high. Note that the values provided in this variable are applied for all read data beats. If the user requires a different set of delays during the idle period for each beat, the user must use the read_data_phase_started callback to change the values of this property for the corresponding beat. Once changed, the values will be applicable for all subsequent beats of the transaction unless it is is changed for a subsequent beat. Values in this variable are applicable only until RVALID is asserted. When RVALID is observed on the interface, this delay is no longer applicable. The delay specified in rready_delay [] is applied before this property is used. Note that toggling RREADY during the idle period may lead to situations where the RREADY signal is already asserted when the RVALID is sampled, even though the value of svt_axi_port_configuration :: default_rready is low. Similarly, RREADY may be low when the corresponding valid is sampled, even though the value of svt_axi_port_configuration :: default_rready is high. In both these cases, rready_delay [] is not applicable. The size of this array can be set to any value greater than 0, based on the number of times the user would like the signal to toggle during idle period. |
|
|
Applicable when svt_axi_port_configuration :: toggle_last_signals_during_idle_period is set. Applicable for AXI4 stream master VIP.
This is a bit vector array attribute with one element size equal to 16 and array size equal to the packet size i.e stream_burst_length. The value of an individual element of the array contains all the TLAST values to be driven during the idle period before the corresponding transfer. Value of 0 indicates the TLAST signal must be driven low and the value of 1 indicates the signal must be driven high. idle_tlast_value is valid only during TVALID is low. When TVALID is high, idle_tlast_value is not applicable. Consider the following example. idle_tlast_value[0] = 16’b0000 0000 1010 1010 Here, 16 = 16. idle_tlast_value[0] represents all the TLAST values to be driven before the first transfer of the packet. If tvalid_delay[0] = 5, there will be 5 clock cycles before the TVALID is asserted. Here, the valid values of idle_tlast_value[0] will be idle_tlast_value[0][4:0] = 5’b01010 and TLAST will be driven to LOW -> HIGH -> LOW -> HIGH-> LOW before TVALID assertion for the first transfer. |
|
|
Applicable when svt_axi_port_configuration :: toggle_ready_signals_during_idle_period is set. Applicable for slave VIP.
Indicates the number of cycles for which wready should be high and low when the write data channel is idle, that is, when WVALID is low. This property helps to toggle the WREADY signal during the idle period between the assertion of WVALID signal. Values provided in even numbered indices indicate the number of clocks for which the ready signal must be driven low and the values in odd numbered indices indicate the number of clocks for which it must driven high. Note that the values provided in this variable are applied for all write data beats. If the user requires a different set of delays during the idle period for each beat, the user must use the write_data_phase_started callback to change the values of this property for the corresponding beat. Once changed, the values will be applicable for all subsequent beats of the transactions unless it is is changed for a subsequent beat. Values in this variable are applicable only until WVALID is asserted. When WVALID is observed on the interface, this delay is no longer applicable and the delay specified in wready_delay [] is applied before asserting WREADY. Note that toggling WREADY during the idle period may lead to situations where the WREADY signal is already asserted when the WVALID is sampled, even though the value of svt_axi_port_configuration :: default_wready is low. Similarly, WREADY may be low when the corresponding valid is sampled, even though the value of svt_axi_port_configuration :: default_wready is high. In both these cases, wready_delay [] is not applicable. The size of this array can be set to any value greater than 0, based on the number of times the user would like the signal to toggle during idle period. |
|
|
|
This variable represents the initial cache line state. Applicable when svt_axi_port_configuration :: axi_interface_type is set to AXI_ACE or ACE_LITE. The initial cache line state of a transaction that is driven on the READ channel is populated just after the reception of the first beat of the response of a transaction. The initial cache line state of a transaction that is driven on the WRITE channel is populated just before the transaction is started. This variable is updated by the VIP, and is a read-only variable. User is not expected or supposed to modify this variable.
Applicable for ACTIVE MASTER only. |
|
|
Represents the various interleave pattern for a read and write transaction. The interleave_pattern gives flexibility to program interleave blocks with different patterns as mentioned below.
A Block is group of beats within a transaction. EQUAL_BLOCK : Drives equal distribution of blocks provided by equal_block_length variable. RANDOM_BLOCK : Drives the blocks programmed in random_interleave_array Please note that currently interleaving based on EQUAL_BLOCK is not supported. |
|
|
when this bit is set, it indicates that this transaction performed atomic operation and the result is stored in atomic_resultant_data.
|
|
|
Applicable when svt_axi_port_configuration :: axi_interface_type is set to AXI_ACE or ACE_LITE.
Indicates if the transaction is auto generated by the VIP. Transactions are auto-generated when: 1. The cache is full and an entry needs to be evicted from the cache. 2. User supplies a cache maintenance transaction and the protocol requires that the cache line is first written into memory before sending the cache maintenance transaction. This is a read-only member, which VIP uses to indicate whether the transaction is auto generated. It should not be modified by the user. Applicable for ACTIVE MASTER only. |
|
|
Applicable when svt_axi_port_configuration :: axi_interface_type is set to AXI_ACE or ACE_LITE.
Indicates if the transaction ended because the requested data was already available in the cache. This bit is set by the master, no action is taken if the user sets this bit. A transaction with this bit set was not sent out on the bus and therefore other components in the testbench will not detect this transaction. Applicable for ACTIVE MASTER only. |
|
|
Applicable when svt_axi_port_configuration :: axi_interface_type is set to AXI_ACE.
Indicates if a coherent transaction was dropped because the start state of the corresponding cache line is not as expected before transmitting the transaction. The expected start states for each of the transaction types are given in section 5 of the ACE specification. Applicable for ACTIVE MASTER only. |
|
|
This variable indicate whether the data check parity error is detected in the transaction. This bit is set to 1, if parity error is deducted in a transaction. By default this is set to 0. Applicable when svt_axi_port_configuration :: check_type is set to ODD_PARITY_BYTE_DATA or ODD_PARITY_BYTE_ALL.
Active Master.
Active Slave.
Passive components.
|
|
|
This variable represents the data check parity error bit's with respect to valid data, Each bit of parity check data is calculated from every 8bit of data with 1bit if datachk. By default all bits are set to 'b1, if any parity error is detected then that particular bit is set to 0. Applicable when svt_axi_port_configuration :: check_type is set to ODD_PARITY_BYTE_DATA or ODD_PARITY_BYTE_ALL. Active Master.
Active Slave.
Passive components.
|
|
|
A bit that must be set by the user to indicate that this transaction will be sent to the slave driver from the slave sequencer through the delayed_response_request_port of the slave driver. If the transaction is randomized before putting it into the delayed_response_request_port of the slave driver, then this bit must be set by the user. This bit must not be set for a transaction that is sent on the seq_item_port.
|
|
|
Indicates if the current data beat of a read transaction has rlast asserted.This is a sticky bit in that it remains set to 1 after the last data beat.
|
|
|
Indicates if the current data beat of a write transaction has wlast asserted. This is useful when data is received before addr and it is required to determine the last beat. This is a sticky bit in that it remains set to 1 after the last data beat.
|
|
|
This field indicates if write response with BPERSIST has been sent/received This is used for persistent CMOs on write channel where a write response with BPERSIST asserted is used to indicate that a transaction is observable at the point of persistence
|
|
|
Applicable when svt_axi_port_configuration :: axi_interface_type is set to AXI_ACE or ACE_LITE.
Indicates if the transaction is a result of a speculative read operation. A speculative read is defined as a read of a cache line that a master already holds in its cache. This is a read-only member, which VIP uses to indicate whether the transaction is a speculative read. Modifying the value of this member will not have any effect. Applicable for ACTIVE MASTER only. |
|
|
Indicates if TagMatch result has been computed in the Slave memory. Only applicable for Active Slave VIP. This is a Read only status attribute and should not be programmed by the user.
|
|
|
This field indicates if write/atomics response with TAGMATCH has been sent/received
|
|
|
This variable indicate whether the data check parity error is detected in the transaction. This bit is set to 1, if parity error is deducted in a transaction. By default this is set to 0. Applicable when svt_axi_port_configuration :: stream_check_type is set to STREAM_CHECK_TYPE_ODD_PARITY_BYTE_ALL.
Active Master:
Active Slave:
Passive components:
|
|
|
This variable represents the tdata check parity error bit's with respect to valid tdata, Each bit of parity check tdata is calculated from every 8bit of tdata with 1bit of tdatachk. By default all bits are set to 'b1, if any parity error is detected the that particular bit is set to 0. Applicable when svt_axi_port_configuration :: stream_check_type is set to STREAM_CHECK_TYPE_ODD_PARITY_BYTE_ALL. Active Master:
Active Slave:
Passive components:
|
|
|
This variable represents the tdest check parity error bit's with respect to valid tdest, Each bit of parity check tdest is calculated from every 8bit of tdest with 1bit of tdestchk. By default all bits are set to 'b1, if any parity error is detected the that particular bit is set to 0. Applicable when svt_axi_port_configuration :: stream_check_type is set to STREAM_CHECK_TYPE_ODD_PARITY_BYTE_ALL. Active Master:
Active Slave:
Passive components:
|
|
|
This variable represents the tid check parity error bit's with respect to valid tid, Each bit of parity check tid is calculated from every 8bit of tid with 1bit of tidchk. By default all bits are set to 'b1, if any parity error is detected the that particular bit is set to 0. Applicable when svt_axi_port_configuration :: stream_check_type is set to STREAM_CHECK_TYPE_ODD_PARITY_BYTE_ALL. Active Master:
Active Slave:
Passive components:
|
|
|
This variable represents the tkeep check parity error bit's with respect to valid tkeep, Each bit of parity check tkeep is calculated from every 8bit of tkeep with 1bit of tkeepchk. By default all bits are set to 'b1, if any parity error is detected the that particular bit is set to 0. Applicable when svt_axi_port_configuration :: stream_check_type is set to STREAM_CHECK_TYPE_ODD_PARITY_BYTE_ALL. Active Master:
Active Slave:
Passive components:
|
|
|
This variable represents the tstrb check parity error bit's with respect to valid tstrb, Each bit of parity check tstrb is calculated from every 8bit of tstrb with 1bit of tstrbchk. By default all bits are set to 'b1, if any parity error is detected the that particular bit is set to 0. Applicable when svt_axi_port_configuration :: stream_check_type is set to STREAM_CHECK_TYPE_ODD_PARITY_BYTE_ALL. Active Master:
Active Slave:
Passive components:
|
|
|
This variable represents the tuser check parity error bit's with respect to valid tuser, Each bit of parity check tuser is calculated from every 8bit of tuser with 1bit of tuserchk. By default all bits are set to 'b1, if any parity error is detected the that particular bit is set to 0. Applicable when svt_axi_port_configuration :: stream_check_type is set to STREAM_CHECK_TYPE_ODD_PARITY_BYTE_ALL. Active Master:
Active Slave:
Passive components:
|
|
|
This variable represents if the twakuep signal for a given transaction is asserted or not. It will be set to 1 when twakeup assertion for a particular transaction is detected. The default value of this attribute is 0. Applicable for Active Master, Active Slave, Passive Master and Passive slave. Only applicable when svt_axi_port_configuration :: stream_twakeup_signal = svt_axi_port_configuration :: STREAM_TWAKEUP_TRUE.
|
|
|
Represents the value of AWUNIQUE signal driven/sampled on the interface. Applicable when svt_axi_port_configuration :: awunique_enable is set. AWUNIQUE is asserted as per table C3-9 of section C3.1.4 on AWUNIQUE signal. The value in the randomized transaction may be overridden by the driver as per protocol requirements. For transactions where AWUNIQUE may be asserted or deasserted, the randomized value is driven.
|
|
|
This field defines the BCOMP value in the transaction. Indicates whether write transaction is observable at the completer. This is used to send the response to a tag Match operation. This is also used for persistent CMOs on Write channel.
|
|
|
Applicable when svt_axi_port_configuration :: axi_interface_type is set to AXI_ACE and svt_axi_port_configuration :: snoop_response_data_transfer_mode is set to SNOOP_RESP_DATA_TRANSFER_USING_WB_WC.
Indicates if this transaction is a WRITEBACK/WRITECLEAN auto-generated transaction which was generated to transfer snoop data. When svt_axi_port_configuration :: snoop_response_data_transfer_mode is set to SNOOP_RESP_DATA_TRANSFER_USING_WB_WC, snoop data from a dirty line is transferred using a WRITEBACK/WRITECLEAN transaction instead of the snoop data channel. All transactions which have this variable set will also have is_auto_generated set. |
|
|
Weight used to control distribution of longer bursts within transaction generation.
This controls the distribution of the length of the bursts using burst_length field |
|
|
Weight used to control distribution of long delays within transaction generation.
This controls the distribution of delays for the 'delay' fields (e.g., delays for asserting the ready signals). |
|
|
Represents the maximum byte address of this transaction. If tagging is enabled, this will be the maximum tagged address .
|
|
|
When this bit is set , it indicates that this transaction has updated the AXI Slave memory with write data and other properties.
|
|
|
Represents the minimum byte address of this transaction. If tagging is enabled, this will be the minimum tagged address .
|
|
|
This field defines the MPAM_NS value in MPAM.
|
|
|
This field defines the partition ID value in MPAM.
|
|
|
This field defines the Perfromance Monitor Group (PMG) value in MPAM.
|
|
|
If configuration parameter svt_axi_port_configuration :: default_bready is FALSE, this member defines the BREADY signal delay in number of clock cycles. The reference event for this delay is reference_event_for_bready_delay.
If configuration parameter svt_axi_port_configuration :: default_bready is TRUE, this member defines the number of clock cycles for which BREADY signal should be deasserted after each handshake, before pulling it up again to its default value. Applicable for ACTIVE MASTER only. |
|
|
This variable specifies the response for write transaction when there is more than one write response as in the case of PCMO. The variable holds the value for BRESP. Following are the possible response types:
MASTER ACTIVE MODE: Will Store the write response received from the slave. SLAVE ACTIVE MODE: The write response programmed by the user. PASSIVE MODE - MASTER/SLAVE: Stores the write response seen on the bus. |
|
|
Defines the BVALID delay in terms of number of clock cycles. The reference event for the first beat is reference_event_for_bvalid_delay. The reference event for the second beat is the write response handshake of the first beat Applicable for ACTIVE SLAVE only. |
|
|
This variable stores the cycle information for response ready on a write transaction. The simulation clock cycle number when the write response valid and ready both are asserted, is captured in this member. This information can be used for doing performance analysis. VIP updates the value of this member variable, user does not need to program this variable.
|
|
|
This variable stores the timing information for response ready on write transactions. The simulation time when the response valid and ready both are asserted, is captured in this member. This information can be used for doing performance analysis. VIP updates the value of this member variable, user does not need to program this variable.
|
|
|
This variable stores the cycle information for response valid on a write transaction. The simulation clock cycle number when the write response valid is asserted, is captured in this member. This information can be used for doing performance analysis. VIP updates the value of this member variable, user does not need to program this variable. This field is applicable only in ACE5 where write response can be sent in two beats for PCMOs. Note that all transactions will have the correct encoded value
|
|
|
This variable stores the timing information for response valid on write transactions. The simulation time when the response valid is asserted, is captured in this member. This information can be used for doing performance analysis. VIP updates the value of this member variable, user does not need to program this variable.
|
|
|
This field defines the Non-secure access identifier value of the AxNSAID signals in request address channels. Currently, only the default value of zero is supported. Typically use a default NSAID value of zero when accessing data that is not protected, or when they do not have an assigned NSAID value. Applicable when svt_axi_port_configuration :: enable_non_secure_access_identifiers is set to 1.
Active Master.
Active Slave.
Passive components.
|
|
|
Variable that holds the object_id of this transaction
|
|
|
|
Variables used in generating XML/FSDB for pa writer
|
|
|
Indicates that this master transaction is a partial write transaction and this transaction will be split by the interconnect into a full Read transaction followed by partial Write transaction to the corresponding slave. Applicable for users who want to correlate master transactions to slave transactions in the system monitor. This parameter is applicable when svt_axi_port_configuration :: partial_write_to_slave_read_and_write_association_enable is set to This property must be set by the user in a system monitor callback issued at the start of a transaction
|
|
|
Represents the phase type. Following are the possible transaction types:
Please note that WRITE and READ transaction type is valid for svt_axi_port_configuration :: axi_interface_type is AXI3/AXI4/AXI4_LITE |
|
|
MASTER in active mode:
For write transactions this variable specifies write data to be driven on the WDATA bus. SLAVE in active mode: For read transactions this variable specifies read data to be driven on the RDATA bus. PASSIVE MODE: This variable stores the write or read data as seen on WDATA or RDATA bus. axi5_protocol If read data chunking is enabled, then array size will be calculated based on chunk_length and represent the read data for each transfer. |
|
|
The variable holds the value for signals WUSER/RUSER as they are driven on the bus Applicable for all interface types. Enabled through port configuration parameters svt_axi_port_configuration :: wuser_enable and svt_axi_port_configuration :: ruser_enable.
|
|
|
MASTER in active mode:
For write transactions this variable specifies wstrb to be driven on the WSTRB bus. SLAVE in active mode: This variable stores the WSTRB as seen on WSTRB bus. PASSIVE MODE: This variable stores the WSTRB as seen on WSTRB bus. |
|
|
This field defines the Poison. This field is applicable for write data, read data. It consists of a bit for each 8 data byte in the transaction data, which when set indicates that set of corresponding 8 data bytes have been previously been corrupted. Applicable when svt_axi_port_configuration :: poison_enable is set to 1. If svt_axi_port_configuration :: wysiwyg_enable is set to 0 (default).
Active Slave.
Passive components.
|
|
|
The port configuration corresponding to this transaction
|
|
|
Represents port ID. Not currently supported.
|
|
|
This variable represents the prefinal cache line state. Applicable when svt_axi_port_configuration :: axi_interface_type is set to AXI_ACE or ACE_LITE. The prefinal cache line state of a transaction is the state of the cache just before cache is updated . This variable is updated by the VIP, and is a read-only variable. User is not expected or supposed to modify this variable.
Applicable for ACTIVE MASTER only. |
|
|
Represents the protection support of a transaction. The variable holds the value for AWPROT/ARPROT. The conventions of the enumeration are:
For the above conventions, following are the possible protection types:
|
|
|
The variable holds the value for AWQOS/ARQOS
|
|
|
Applicable when svt_axi_port_configuration :: axi_interface_type is set to AXI_ACE. Defines the RACK delay in terms of number of clock cycles. The reference event for this delay is reference_event_for_rack_delay.
Applicable for ACTIVE MASTER only. |
|
|
When the interleave_pattern is set to RANDOM_BLOCK, the user would program this array with blocks. There are default constraints, which the user can override and set their own block patterns. In case of AXI4_STREAM interface type for active master, programming this array is applicable only when svt_axi_port_configuration :: stream_interleave_depth is greater than 1. |
|
|
The variable holds the value for RCHUNKCHK. signals covered under this group {RCHUNKV,RCHUNKNUM,RCHUNKSTRB}. |
|
|
Array of read chunk number Indicates that the data chunk number is being transferred. Width of the rchunknum by default is 8 user can change width using svt_axi_port_configuration :: rchunknum_width signal. Applicable when archunken and svt_axi_port_configuration :: rdata_chunking_enable is set to 1.
|
|
|
Array of read chunk strobe Each bit of rchunkstrb represents 128bits of read data. Width of the rchunkstrb by default is 8 user can change width using svt_axi_port_configuration :: rchunkstrb_width signal. Applicable when archunken and svt_axi_port_configuration :: rdata_chunking_enable is set to 1.
|
|
|
This variable rchunkstrb_pattern indicates the pattern generated in the rchunkstrb[]. For ex. Consider burst_length = 1 and burst_size = BURST_SIZE_512BIT,
|
|
|
This signifies the validity of the rchunkstrb and rchunknum. rchunkv when set '1' indicates that read data will be sent in chunks. If this bit is disabled then the read data will not be sent in chunks as rchunkstrb and rchunknum is not valid. and the value of this bit will be driven on the interface signal "rchunkv". This is applicable for the Slave VIP. Macro SVT_RCHUNKV_ENABLE should be defined to drive rchunkv to a value of 1 otherwise VIP will always drive it to 0.
|
|
|
The variable holds the value for RDATACHK. signals covered under this group {RDATA}. The maximum width of the signal is controlled through macro 1024. |
|
|
This field defines the loopback value in read request. This corresponds to ARLOOP.
|
|
|
Defines reference event for AWREADY or ARREADY delay.
|
|
|
Defines a reference event from which the AWVALID or ARVALID delay should start. Following are the different reference events:
PREV_ADDR_VALID: Reference event is the previous AWVALID or ARVALID signal PREV_ADDR_HANDSHAKE: Reference event is previous read or write Address handshake FIRST_WVALID_DATA_BEFORE_ADDR: This is used when data_before_addr bit is set. The reference event for address valid to occur is the first wvalid of the current transaction. FIRST_DATA_HANDSHAKE_DATA_BEFORE_ADDR: This is used when data_before_addr bit is set. The reference event for address valid to occur is the first data handshake of the current transaction. PREV_LAST_DATA_HANDSHAKE: Reference event is previous read or write last data handshake to Address valid assertion. Reasonable constraint on reference_event_for_addr_delay in data_before_addr scenarios is added in svt_axi_transaction class to constraint the value of reference_event_for_addr_delay not to take FIRST_DATA_HANDSHAKE_DATA_BEFORE_ADDR. User may swicth off the constraint reasonable_reference_event_for_addr_delay by setting rand_mode to 0 incase they want reasonable_reference_event_for_addr_delay to take FIRST_DATA_HANDSHAKE_DATA_BEFORE_ADDR. In data_before_addr scenarios reference_event_for_addr_delay should be set very carefully to FIRST_DATA_HANDSHAKE_DATA_BEFORE_ADDR as this may cause potential deadlock scenarios in ACE SLAVE DUT where slave DUT waits for awvalid signal before driving wready signal. |
|
|
Defines a reference event for BREADY delay.
BVALID: Reference event is assertion of BVALID signal |
|
|
Defines a reference event for BVALID delay.
LAST_DATA_HANDSHAKE: Reference event for BVALID delay is completion of handshake for last write data. ADDR_HANDSHAKE: Reference event for BVALID delay is completion of handshake for address phase. |
|
|
Defines the reference events to delay the first rvalid signal. The delay must be programmed in rvalid_delay[0]. Following are the different events under this category:
READ_ADDR_VALID: Reference event for first RVALID is assertion of ARVALID signal READ_ADDR_HANDSHAKE: Reference event for first RVALID is completion of read address handshake |
|
|
Defines the reference events to delay the first wvalid signal. The delay must be programmed in wvalid_delay[0]. Following are the different events under this category:
WRITE_ADDR_VALID: Reference event for first WVALID is assertion of AWVALID signal WRITE_ADDR_HANDSHAKE: This event is applicable when write data is transmitted after write address, that is, when data_before_addr is set to 0. This reference event specifies the write address handshake. PREV_WRITE_DATA_HANDSHAKE: This event is applicable when write data is transmitted before write address, that is, when data_before_addr is set to 1. This reference event specifies the previous write data handshake. |
|
|
Defines the reference events to delay the RVALID signals from second beat onwards. Following are the different events under this category:
PREV_RVALID : Reference event to delay RVALID is assertion of previous rvalid. The delay timer starts as soon as previous valid signal is asserted. If previous data handshake does not complete before timer expires, the current transfer waits for the previous handshake to complete, and then immediately asserts rvalid. PREV_READ_HANDSHAKE : Reference event to delay RVALID is completion of previous read data handshake. |
|
|
Defines the reference events for WVALID delay from second beat onwards. Following are the different events under this category:
PREV_WVALID: Reference event for WVALID delay is assertion of previous wvalid. The delay timer starts as soon as previous valid signal is asserted. If previous data handshake does not complete before timer expires, the current transfer waits for the previous handshake to complete, and then immediately asserts wvalid. PREV_WRITE_HANDSHAKE: Reference event for WVALID delay is completion of previous data handshake. |
|
|
Applicable when svt_axi_port_configuration :: axi_interface_type is set to AXI_ACE.
Defines the reference event from which the RACK delay should start.
|
|
|
Defines the reference event for RREADY delay.
RVALID: Reference event for RREADY is assertion of RVALID signal MANUAL_RREADY: (Not supported currently) This event allows the user to generate RREADY patterns, in cycles, as follows: 1. The reference event for this delay is the beginning of the Address handshake. 2. The rready_delay[0] represents the following a. A value > 0 is the no. of cycles default rready signal is driven b. A value < 0 is the no. of cycles default rready signal is driven after toggling 3. The remaining rready_delay element represents no. of cycles to drive rready Example 1: For eg. RREADY pattern (cycles) = 1110011 and default_rready = 1 data_delay[0] = 3 Three cycles high (driving default_rready value) data_delay[1] = 2 Two cycles low (toggled previous RREADY value) data_delay[2] = 2 Two cycles high (toggled previous RREADY value) For eg. cycle pattern RREADY = 0001100 and default_rready = 1 data_delay[0] = -3 Three cycles low (toggled default_rready value) data_delay[1] = 2 Two cycles high (toggled previous RREADY value) data_delay[2] = 2 Two cycles low (toggled previous RREADY value) |
|
|
Defines the reference events for TVALID delay from second beat onwards. Following are the different events under this category:
PREV_TVALID: In this case, assertion of previous tvalid signal is considered as the reference event for TVALID delay. The delay timer starts as soon as previous tvalid signal is asserted. If previous tvalid-tready handshake does not complete before timer expires, the current transfer waits for the previous handshake to complete, and then immediately asserts tvalid. PREV_TVALID_TREADY_HANDSHAKE: Reference event for TVALID delay is completion of previous tvalid-tready handshake. |
|
|
Applicable when svt_axi_port_configuration :: axi_interface_type is set to AXI_ACE.
Defines the reference event from which the WACK delay should start.
|
|
|
Defines the reference events for WREADY delay.
WVALID: Reference event for WREADY is assertion of WVALID signal. MANUAL_WREADY: (Not supported currently) This event allows the user to generate WREADY patterns, in cycles, as follows : 1. The reference event for this delay is the beginning of the Address handshake. 2. The wready_delay[0] represents the following a. A value > 0 is the no. of cycles default wready signal is driven b. A value < 0 is the no. of cycles default wready signal is driven after toggling 3. The remaining wready_delay element represents no. of cycles to drive wready Example 1: For eg. WREADY pattern (cycles) = 1110011 and default_wready = 1 data_delay[0] = 3 Three cycles high (driving default_wready value) data_delay[1] = 2 Two cycles low (toggled previous WREADY value) data_delay[2] = 2 Two cycles high (toggled previous WREADY value) For eg. cycle pattern WREADY = 0001100 and default_wready = 1 data_delay[0] = -3 Three cycles low (toggled default_wready value) data_delay[1] = 2 Two cycles high (toggled previous WREADY value) data_delay[2] = 2 Two cycles low (toggled previous WREADY value) |
|
|
The variable holds the value for AWREGION/ARREGION
|
|
|
Sets the reordering priority of the current transaction within the set of transactions that are allowed access to read data channel based on svt_axi_port_configuration :: read_data_reordering_depth.
This member is applicable only when svt_axi_port_configuration :: reordering_algorithm is svt_axi_port_configuration :: PRIORITIZED. This value indicates the priority of sending the response to current transaction compared to remaining transactions within the depth indicated by svt_axi_port_configuration :: read_data_reordering_depth for read transactions or by svt_axi_port_configuration :: write_resp_reordering_depth for write transactions. Note that the value of this attribute should be within the following range: [1:svt_axi_port_configuration :: read_data_reordering_depth] for read transactions and [1:svt_axi_port_configuration :: write_resp_reordering_depth] for write transactions. If svt_axi_port_configuration :: reordering_priority_high_value is set to ‘1’ then, the transactions with highest value for this attribute will get higher priority. If svt_axi_port_configuration :: reordering_priority_high_value is set to ‘0’ then, the transactions with least value for this attribute will get higher priority. If there are more than one transactions with same priority, those transaction will be processed in the same order as they are received. Applicable for ACTIVE SLAVE only. |
|
|
Enum to represent the response sent by the completer on the corresponding Response channel. This transaction property is only applicable when use_external_port_monitor is set to 1. It is users responsibility to program this appropriately in external port monitor mode. Following are the possible values:
|
|
|
|
|
|
The variable holds the value for signal BUSER. Applicable for all interface types. Enabled through port configuration parameter svt_axi_port_configuration :: buser_enable.
|
|
|
The variable holds the value for RIDCHK. signals covered under this group {RIDUNQ,RID}. The maximum width of the signal is controlled through macro 8. SVT_AXI_MAX_ID_WIDTH: RID 1 : RIDUNQ . |
|
|
The variable holds the value for RLASTCHK. signals covered under this group {RLAST}. |
|
|
The variable holds the value for RLOOPCHK. signals covered under this group {RLOOP}. |
|
|
This variable represents targeted physical memory region and determines axnse/axpprot[1] values accordingly.
Active Master.
Active Slave.
Passive components.
|
|
|
The variable holds the value for RPOISONCHK. signals covered under this group {RPOISON}. The maximum width of the signal is controlled through macro 1024. |
|
|
The variable holds the value for RREADYCHK. signals covered under this group {RREADY}. |
|
|
If configuration parameter svt_axi_port_configuration :: default_rready is FALSE, this member defines the RREADY signal delay in number of clock cycles. The reference event for this delay is reference_event_for_rready_delay
If configuration parameter svt_axi_port_configuration :: default_rready is TRUE, this member defines the number of clock cycles for which RREADY signal should be deasserted after each handshake, before pulling it up again to its default value. Applicable for ACTIVE MASTER only. |
|
|
This array variable specifies the response for read transaction. The array holds the value for RRESP. Following are the possible response types:
MASTER ACTIVE MODE: Will Store the read responses received from the slave. SLAVE ACTIVE MODE: The read responses programmed by the user. PASSIVE MODE - MASTER/SLAVE: Stores the read responses seen on the bus. axi5_protocol If read data chunking is enabled, then array size will be calculated based on chunk_length and represent the read responses for each transfer. |
|
|
The variable holds the value for RRESPCHK. signals covered under this group {RRESP,RBUSY}. |
|
|
The variable holds the value for RTAGCHK. signals covered under this group {RTAG}. |
|
|
The variable holds the value for RTRACECHK. signals covered under this group {RTRACE}. |
|
|
The variable holds the value for RUSERCHK. signals covered under this group {RUSER}. The maximum width of the signal is controlled through macro 8. |
|
|
The variable holds the value for RVALIDCHK. signals covered under this group {RVALID}. |
|
|
Defines RVALID delay, in terms of number of clock cycles. The reference event for this delay is:
Applicable for ACTIVE SLAVE only. |
|
|
This variable represents the Secure Stream Identifier for the Untranslated Transactions.
Active Master.
Active Slave, Passive components.
|
|
|
Weight used to control distribution of short bursts within transaction generation.
This controls the distribution of the length of the bursts using burst_length field |
|
|
Weight used to control distribution of short delays within transaction generation.
This controls the distribution of delays for the 'delay' fields (e.g., delays for asserting the ready signals). |
|
|
This variable indicates the SMMU flow for managing translation faults for this transaction. Encoded as
Active Slave, Passive components.
|
|
|
This variable indicates the value of the AxMMUVALID signal. That indicates the validity of the untranslated address channel signals. This enables a mix of translated and untranslated transactions on the same interface
Active Slave, Passive components.
|
|
|
This field indicates the ID of the logical processor at the Stash target. Applicable only in stash type transactions.
|
|
|
This field indicates that the Stash_lpid field value must be considered as the Stash target. Applicable only in stash type transactions.
|
|
|
This field indicates the node ID of the stash target. Applicable only in stash type transactions.
|
|
|
This field indicates the stash_nid field has a valid Stash target value. Applicable only in stash type transactions.
|
|
|
Defines the burst length of a AXI4 Stream Packet. Applicable when svt_axi_port_configuration :: axi_interface_type is set to AXI4_STREAM.
|
|
|
This variable represents the Stream Identifier for the Untranslated Transactions. This is only applicable when svt_axi_port_configuration :: addr_translation_enable is set 1.
Active Master.
Active Slave, Passive components.
|
|
|
This variable represents the Substream Identifier for the Untranslated Transactions. This is only applicable when svt_axi_port_configuration :: addr_translation_enable is set 1 and sub_stream_id_valid is set to 1.
Active Master.
Active Slave, Passive components.
|
|
|
This variable indicates that the transaction has an substream identifier.
Active Master.
Active Slave, Passive components.
|
|
|
A bit that indicates that the testbench would like to suspend arready signal for a READ transaction until this bit is reset. This is applicable only when svt_axi_port_configuration :: default_arready is set to 0 svt_axi_transaction :: addr_ready_delay won't be applicable when this bit is set to 1
Applicable for ACTIVE SLAVE only. |
|
|
A bit that indicates that the testbench would like to suspend awready signal for a WRITE transaction until this bit is reset. This is applicable only when svt_axi_port_configuration :: default_awready is set to 0 svt_axi_transaction :: addr_ready_delay won't be applicable when this bit is set to 1
Applicable for ACTIVE SLAVE only. |
|
|
Indicates that data will start before address for write transactions, even though data_before_addr is set to 0. This is useful when awvalid is suspended for write transaction and respective transaction data is driven before resuming the suspended awvalid signal.
|
|
|
A bit array that indicates that the testbench would like to suspend write data beats and keep all beats suspended for a WRITE transaction until this bit is reset.
Applicable with svt_axi_port_configuration :: explicit_write_suspension_enable and for ACTIVE AXI4 MASTER only. |
|
|
A bit that indicates that the testbench would like to suspend response/data for a READ/WRITE/COHERENT transaction until this bit is reset. This bit is usually set by the testbench when it needs to provide response information to the driver (the slave driver expects the response information in 0 time), but the data to respond with is not yet known. The testbench can set this bit and put this transaction back into the input channel of the slave. The transaction's response/data will not be sent until this bit is reset. Once the data is available, the testbench can populate response fields and reset this bit, upon which the slave driver will send the response/data of this transaction.
Applicable for ACTIVE SLAVE only. |
|
|
A bit array that indicates that the testbench would like to suspend read data beats and keep all beats suspended for a READ transaction until this bit is reset. This bit array is usually set by the testbench when it needs to provide response information to the driver (the slave driver expects the response information in 0 time), but the data to respond with is not yet known. With this bit array, read interleaving and out of order responses can be specified. Note that suspend_response is prioritized to this bit array.
Applicable with svt_axi_port_configuration :: suspend_response_per_read_beat_enable and for ACTIVE SLAVE only. |
|
|
A bit that indicates that the testbench would like to suspend wready signal for a WRITE transaction until this bit is reset. This is applicable only when svt_axi_port_configuration :: default_wready is set to 0 svt_axi_transaction :: wready_delay won't be applicable when this bit is set to 1
Applicable for ACTIVE SLAVE only. |
|
|
A bit that indicates that the testbench would like to suspend the write addr phase until this bit is reset.
Applicable with svt_axi_port_configuration :: explicit_write_suspension_enable and for ACTIVE AXI4 MASTER only. |
|
|
This field defines the Memory Tag value in the transaction driven on the data channel for transactions. Every 4 bits of Tag correspond to one 16 byte chunk of data. MASTER in active mode:
For write transactions this variable specifies tags to be driven on the WTAG bus. SLAVE in active mode: For read transactions this variable specifies tags to be driven on the RTAG bus. PASSIVE MODE: This variable stores the tags as seen on WTAG or RTAG bus. |
|
|
Enum to represent the ‘Resp’ field in the TagMatch response. This field is only applicable for Write and Atomic transactions with TagOp in the request set to Match (TAG_FETCH_MATCH). Following are the possible values:
|
|
|
Enum to represent the operation to be performed on the tags present in the corresponding DATA channel. Following are the possible values:
|
|
|
This field defines the WTAGUPDATE value in the transaction. Only applicable when the Tag value is passed in the transaction and the tagop field in the transaction is set to Update. Each WTAGUPDATE bit corresponds to 4 bits of WTAG
|
|
|
Used to drive TDATA signals. Applicable when svt_axi_port_configuration :: axi_interface_type is set to AXI4_STREAM.
|
|
|
This variable represents the data check parity bit's with respect to valid tdata. It consists of a bit for each 8 bit in the transaction tdata. Each bit of parity check of tdata is calculated from every 8bit of tdata. Applicable when svt_axi_port_configuration :: stream_check_type is set to STREAM_CHECK_TYPE_ODD_PARITY_BYTE_ALL.
Active Master:
Active Slave:
Passive components:
|
|
|
TDEST provides routing information for the data stream. Applicable when svt_axi_port_configuration :: axi_interface_type is set to AXI4_STREAM.
|
|
|
|
This variable represents the parity check bit's with respect to valid tdest. It consists of a bit for each 8 bit in the transaction tdest. Each bit of parity check of tdest is calculated from every 8bit of tdest. Applicable when svt_axi_port_configuration :: stream_check_type is set to STREAM_CHECK_TYPE_ODD_PARITY_BYTE_ALL.
Active Master:
Active Slave:
Passive components:
|
|
|
The variable holds the value of TID signal. Applicable when svt_axi_port_configuration :: axi_interface_type is set to AXI4_STREAM.
|
|
|
|
This variable represents the parity check bit's with respect to valid tid. It consists of a bit for each 8 bit in the transaction tid. Each bit of parity check of tid is calculated from every 8bit of tid. Applicable when svt_axi_port_configuration :: stream_check_type is set to STREAM_CHECK_TYPE_ODD_PARITY_BYTE_ALL.
Active Master:
Active Slave:
Passive components:
|
|
|
TKEEP is the byte qualifier that indicates whether the content of the associated byte of TDATA is processed as part of the data stream. Applicable when svt_axi_port_configuration :: axi_interface_type is set to AXI4_STREAM.
|
|
|
|
This variable represents the check parity bit's with respect to valid tkeep. It consists of a bit for each 8 bit in the transaction tkeep. Each bit of parity check of tkeep is calculated from every 8bit of tkeep. Applicable when svt_axi_port_configuration :: stream_check_type is set to STREAM_CHECK_TYPE_ODD_PARITY_BYTE_ALL.
Active Master:
Active Slave:
Passive components:
|
|
|
Represents the total byte count of this transaction. .
|
|
|
|
|
|
If configuration parameter svt_axi_port_configuration :: default_tready is FALSE, this member defines the TREADY signal delay in number of clock cycles. The reference event for this delay is reference_event_for_tready_delay.
Please note that reference_event_for_tready_delay is not supported currently. Absolute value of tready_delay is considered for delay calculation with respect to tvalid signal. If configuration parameter svt_axi_port_configuration :: default_tready is TRUE, this member defines the number of clock cycles for which TREADY signal should be deasserted after each handshake, before pulling it up again to its default value. When the configuration parameter svt_axi_port_configuration :: toggle_ready_signals_during_idle_period is set to 1 then this attribute is inapplicable and the configuration attributes tready_assert_min_delay, tready_assert_max_delay, tready_deassert_min_delay and tready_deassert_max_delay are used to toggle the tready signal during the idle period. Applicable for ACTIVE SLAVE only. |
|
|
Used to drive TSTRB signal. The strobes are right aligned and the model will drive strobes on appropriate lanes. The model also takes care of the endianness while driving tstrb. Applicable when svt_axi_port_configuration :: axi_interface_type is set to AXI4_STREAM.
|
|
|
|
This variable represents the parity check bit's with respect to valid tstrb. It consists of a bit for each 8 bit in the transaction tstrb. Each bit of parity check of tstrb is calculated from every 8bit of tstrb. Applicable when svt_axi_port_configuration :: stream_check_type is set to STREAM_CHECK_TYPE_ODD_PARITY_BYTE_ALL.
Active Master:
Active Slave:
Passive components:
|
|
|
TUSER is user defined sideband information that can be transmitted alongside the data stream. Applicable when svt_axi_port_configuration :: axi_interface_type is set to AXI4_STREAM.
|
|
|
|
This variable represents the parity check bit's with respect to valid tuser. It consists of a bit for each 8 bit in the transaction tuser. Each bit of parity check of tuser is calculated from every 8bit of tuser. Applicable when svt_axi_port_configuration :: stream_check_type is set to STREAM_CHECK_TYPE_ODD_PARITY_BYTE_ALL.
Active Master:
Active Slave:
Passive components:
|
|
|
Defines the delay in number of clock cycles for TVALID signal. The reference event for this delay is: reference_event_for_tvalid_delay
|
|
|
This variable represents the delay between twakeup and tvalid assertions. It is applicable only for svt_axi_transaction :: twakeup_assert_mode set to TWAKEUP_BEFORE_TVALID/TWAKEUP_AFTER_TVALID. It is constrained in the range of svt_axi_port_configuration :: twakeup_assert_min_delay (default 1) to svt_axi_port_configuration :: twakeup_assert_max_delay (default 4). Only applicable when svt_axi_port_configuration :: stream_twakeup_signal = svt_axi_port_configuration :: STREAM_TWAKEUP_TRUE.
|
|
|
TWAKEUP_NONE indicates twakeup is disabled. TWAKEUP_BEFORE_TVALID indicates twakeup asserted before tvalid. TWAKEUP_DURING_TVALID indicates twakeup asserted during tvalid. TWAKEUP_AFTER_TVALID indicates twakeup asserted after tvalid. Only applicable when svt_axi_port_configuration :: stream_twakeup_signal = svt_axi_port_configuration :: STREAM_TWAKEUP_TRUE
|
|
|
This variable represents the least number of clock cycle to wait before deasserting the twakeup signal. It is recommended to deassert the twakeup only when no further transfers are required. It’s constrained in range of svt_axi_port_configuration :: twakeup_least_deassert_min_delay (default 0) and svt_axi_port_configuration :: twakeup_least_deassert_max_delay (default 5). Only applicable when svt_axi_port_configuration :: stream_twakeup_signal = svt_axi_port_configuration :: STREAM_TWAKEUP_TRUE
|
|
|
Represents the Unique ID indicator Feature. The variable holds the value of AWIDUNQ/BIDUNQ/ARIDUNQ/RIDUNQ signals. The Variable is used to indicate that there are no outstanding transactions going on with the same AWID/BID/ARID/RID respectively and it will remain unique till the transaction is completed. In order to use this feature, user need to pass the user defined macro at compile time +define+SVT_ACE5_ENABLE. Please consult User Guide for additional information, and consult VIP example for usage demonstration. The SVT_ACE5_ENABLE macro is only used to enable this feature and signals. The Signals can be configured and enabled by VIP configuration using parameter svt_axi_port_configuration :: unique_id_enable. |
|
|
The array holds the enable/disable configuration values for user inject parity support.
Set svt_axi_transaction :: auto_parity_gen_enable to '0' and user_inject_parity_signal_array[AWIDCHK_EN] = 1. |
|
|
Applicable when svt_axi_port_configuration :: axi_interface_type is set to AXI_ACE. Defines the WACK delay in terms of number of clock cycles. The reference event for this delay is reference_event_for_wack_delay.
Applicable for ACTIVE MASTER only. |
|
|
The variable holds the value for WDATACHK. signals covered under this group {WDATA}. The width of this signal is controlled by macro SVT_AXI_MAX_DATA_WIDTH. |
|
|
The variable holds the value for WLASTCHK. signals covered under this group {WLAST}. |
|
|
The variable holds the value for WPOISONCHK signals covered under this group {WPOISON}. The width of this signal is controlled by macro SVT_AXI_MAX_DATA_WIDTH. |
|
|
The variable holds the value for WREADYCHK. signals covered under this group {WREADY}. |
|
|
If configuration parameter svt_axi_port_configuration :: default_wready is FALSE, this member defines the WREADY signal delay in number of clock cycles. The reference event for this delay is reference_event_for_wready_delay.
If configuration parameter svt_axi_port_configuration :: default_wready is TRUE, this member defines the number of clock cycles for which WREADY signal should be deasserted after each handshake, before pulling it up again to its default value. Applicable for ACTIVE SLAVE only. |
|
|
This field defines the loopback value in write request. This corresponds to AWLOOP.
|
|
|
This variable stores the cycle information for response ready on a write transaction. The simulation clock cycle number when the write response valid and ready both are asserted, is captured in this member. This information can be used for doing performance analysis. VIP updates the value of this member variable, user does not need to program this variable.
|
|
|
This variable stores the timing information for response ready on write transactions. The simulation time when the response valid and ready both are asserted, is captured in this member. This information can be used for doing performance analysis. VIP updates the value of this member variable, user does not need to program this variable.
|
|
|
Represents the status of the write response transfer. Following are the possible status types.
|
|
|
This field determines the relative timing of BPERSIST with respect to BCOMP. Applicable only for PCMOs
Applicable for ACTIVE SLAVE only. |
|
|
This variable stores the cycle information for response valid on a write transaction. The simulation clock cycle number when the write response valid is asserted, is captured in this member. This information can be used for doing performance analysis. VIP updates the value of this member variable, user does not need to program this variable.
|
|
|
This variable stores the timing information for response valid on write transactions. The simulation time when the response valid is asserted, is captured in this member. This information can be used for doing performance analysis. VIP updates the value of this member variable, user does not need to program this variable.
|
|
|
-
|
|
|
This variable represents the type of the write transaction.
Active Master.
Active Slave.
Passive components.
|
|
|
Array of Write strobes. If svt_axi_port_configuration :: wysiwyg_enable is set to 0 (default), the wstrb must be stored right-justified by the user. The model will drive these strobes on the correct lanes. If svt_axi_port_configuration :: wysiwyg_enable is set to 1, the wstrb is transmitted as programmed by user and is reported as seen on bus. No right-justification is used in this case.
|
|
|
The variable holds the value for WSTRBCHK. signals covered under this group {WSTRB}. The width of this signal is controlled by macro SVT_AXI_MAX_DATA_WIDTH. |
|
|
The variable holds the value for WTAGCHK. signals covered under this group {WTAGUPDATE,WTAG}. |
|
|
The variable holds the value for WTRACECHK. signals covered under this group {WTRACE}. |
|
|
The variable holds the value for WUSERCHK. signals covered under this group {WUSER}. The width of this signal is controlled by macro SVT_AXI_MAX_DATA_WIDTH. |
|
|
The variable holds the value for WVALIDCHK. signals covered under this group {WVALID}. |
|
|
Defines the delay in number of cycles for WVALID signal. The reference event for this delay is:
|
|
|
The simulation time when the master or slave driver receives the transaction from the sequencer, is captured in this member. This information can be used for doing performance analysis. VIP updates the value of this member variable, user does not need to program this variable.
|
|
|
This variable stores the transaction consumed at driver timing information. The transaction consumed at driver time to begin time delay is calculated as the difference between begin_time and xact_consumed_by_driver_time. This information can be used for doing performance analysis. VIP updates the value of this member variable, user does not need to program this variable.
|
|
|
Represents the transaction type. Following are the possible transaction types:
Please note that WRITE and READ transaction type is valid for svt_axi_port_configuration :: axi_interface_type is AXI3/AXI4/AXI4_LITE and COHERENT transaction type is valid for svt_axi_port_configuration :: axi_interface_type is AXI_ACE. |
|
|
Weight used to control distribution of burst length to 1 within transaction generation.
This controls the distribution of the length of the bursts using burst_length field |
|
|
Weight used to control distribution of zero delay within transaction generation.
This controls the distribution of delays for the 'delay' fields (e.g., delays for asserting the ready signals). |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
constraint ace5_valid_ranges {
if(port_cfg.atomic_transactions_enable ==1'b1 && atomic_transaction_type inside{LOAD,SWAP,COMPARE} && xact_type == ATOMIC) { foreach(atomic_read_data[index]) { if(port_cfg.wysiwyg_enable ==1'b1){ atomic_read_data[index] == atomic_read_data[index] & ((1<<(port_cfg.data_width))-1);} } if(port_cfg.ruser_enable && port_cfg.wysiwyg_enable){ foreach(atomic_read_data_user[index]) { atomic_read_data_user[index] == atomic_read_data_user[index] & ((1<<(port_cfg.data_width))-1); } } foreach(atomic_swap_data[index]) { if(port_cfg.wysiwyg_enable ==1'b1){ atomic_swap_data[index] == atomic_swap_data[index] & ((1<<((port_cfg.data_width)))-1);} } foreach(atomic_compare_data[index]) { if(port_cfg.wysiwyg_enable ==1'b1){ atomic_compare_data[index] == atomic_compare_data[index] & ((1<<(port_cfg.data_width))-1);} } if(port_cfg.poison_enable ==1 && port_cfg.wysiwyg_enable ==1){ foreach(atomic_read_poison[index]) { if(port_cfg.data_width%64 == 0) { atomic_read_poison[index] == atomic_read_poison[index] & ((1<<(port_cfg.data_width/64))-1);} else { atomic_read_poison[index] == atomic_read_poison[index] & (((1<<(port_cfg.data_width/64)+1))-1);} }} } // atomic_transactions_enable if(port_cfg.axi_port_kind == svt_axi_port_configuration::AXI_MASTER && port_cfg.is_active) { if (port_cfg.cmo_on_write_enable == 0) coherent_xact_type != CMO; if(port_cfg.persist_cmo_enable != 1){ !(cmo_on_write_xact_type inside {CLEANSHAREDPERSIST_ON_WRITE, CLEANSHAREDDEEPPERSIST_ON_WRITE}); !(xact_type == COHERENT && coherent_xact_type == CLEANSHAREDPERSIST); } if(xact_type == COHERENT && (!(coherent_xact_type inside{CMO,WRITEPTLCMO,WRITEFULLCMO}))){ cmo_on_write_xact_type == CLEANINVALID_ON_WRITE; } } } |
|
|
constraint ace_valid_ranges {
} // ace_valid_ranges |
|
|
constraint atomic_xacts_valid_ranges {
if(!(port_cfg.axi_interface_type inside{svt_axi_port_configuration::AXI4,svt_axi_port_configuration::ACE_LITE}) || port_cfg.atomic_transactions_enable == 0) { xact_type != ATOMIC;} if(xact_type ==ATOMIC){ if(port_cfg.axi_port_kind == svt_axi_port_configuration::AXI_MASTER) { archunken == 0; if((barrier_type == NORMAL_ACCESS_RESPECT_BARRIER) || (barrier_type == NORMAL_ACCESS_IGNORE_BARRIER)){ if ((domain_type == NONSHAREABLE) || (domain_type == SYSTEMSHAREABLE)){ coherent_xact_type == WRITENOSNOOP;} else{ coherent_xact_type == WRITEUNIQUE;} } else{ coherent_xact_type == WRITEBARRIER;} if(burst_length > 1 && ! port_cfg.allow_multibeat_atomic_transactions_to_be_less_than_data_width){ (1 << burst_size) == port_cfg.data_width/8; } data.size() == burst_length; if(port_cfg.poison_enable ==1){ poison.size() == burst_length; } wstrb.size() == burst_length; if (!port_cfg.wysiwyg_enable) { foreach (wstrb[index]) { wstrb[index] == ((1 << (1 << burst_size)) - 1); } } awakeup_assert_delay ==0; if( atomic_xact_op_type inside{ATOMICLOAD_ADD,ATOMICLOAD_CLR,ATOMICLOAD_EOR,ATOMICLOAD_SET,ATOMICLOAD_SMAX,ATOMICLOAD_SMIN,ATOMICLOAD_UMAX,ATOMICLOAD_UMIN}){ atomic_transaction_type == LOAD; } if(atomic_xact_op_type inside{ATOMICSTORE_ADD,ATOMICSTORE_CLR,ATOMICSTORE_EOR,ATOMICSTORE_SET,ATOMICSTORE_SMAX,ATOMICSTORE_SMIN,ATOMICSTORE_UMAX,ATOMICSTORE_UMIN}) { atomic_transaction_type == STORE; } if(atomic_xact_op_type == ATOMICSWAP){ atomic_transaction_type == SWAP; } if(atomic_xact_op_type == ATOMICCOMPARE){ atomic_transaction_type == COMPARE; burst_size inside{0,1,2,3,4,5}; {((1 << burst_size)) * burst_length} inside {2,4,8,16,32}; if(burst_length << burst_size == 2 && addr[0]==1'b0){ burst_type == INCR;} else if(burst_length << burst_size == 4 && addr[1:0]==2'b0) { burst_type == INCR;} else if(burst_length << burst_size == 8 && addr[2:0]==3'b0) { burst_type == INCR;} else if(burst_length << burst_size == 16 && addr[3:0]==4'b0) { burst_type == INCR;} else if(burst_length << burst_size == 32 && addr[4:0]==5'b0) { burst_type == INCR;} else if(burst_length << burst_size == 2 && addr[0] !=1'b0){ burst_type == WRAP;} else if(burst_length << burst_size == 4 && addr[1:0] !=2'b0) { burst_type == WRAP;} else if(burst_length << burst_size == 8 && addr[2:0] !=3'b0) { burst_type == WRAP;} else if(burst_length << burst_size == 16 && addr[3:0] !=4'b0) { burst_type == WRAP;} else if(burst_length << burst_size == 32 && addr[4:0] !=5'b0) { burst_type == WRAP;} } atomic_transaction_type != NON_ATOMIC; if(atomic_transaction_type == COMPARE ){ atomic_swap_data.size() == burst_length; atomic_compare_data.size() == burst_length; atomic_compare_wstrb.size() == burst_length; atomic_swap_wstrb.size() == burst_length; if(tag_op == svt_axi_transaction::TAG_FETCH_MATCH && ((burst_length << burst_size) == 32)){ atomic_swap_tag.size() == burst_length; atomic_compare_tag.size() == burst_length; } else { atomic_swap_tag.size() == 0; atomic_compare_tag.size() == 0; } foreach(atomic_swap_data[index]) { if(port_cfg.wysiwyg_enable ==1'b1){ atomic_swap_data[index] == atomic_swap_data[index] & ((1<<(port_cfg.data_width))-1); } } foreach(atomic_compare_data[index]) { if(port_cfg.wysiwyg_enable ==1'b1){ atomic_compare_data[index] == atomic_compare_data[index] & ((1<<(port_cfg.data_width))-1); } } if (!port_cfg.wysiwyg_enable) { foreach (atomic_swap_data[index]) { atomic_swap_data[index] <= ((1 << ((1 << burst_size) << 3)) - 1); } } if (!port_cfg.wysiwyg_enable) { foreach (atomic_compare_data[index]) { atomic_compare_data[index] <= ((1 << ((1 << burst_size) << 3)) - 1); } } } else { atomic_swap_data.size() == 0; atomic_compare_data.size() == 0; atomic_compare_wstrb.size() == 0; atomic_swap_wstrb.size() == 0; atomic_swap_tag.size() == 0; atomic_compare_tag.size() == 0; } if(atomic_transaction_type ==LOAD){ atomic_xact_op_type inside{ATOMICLOAD_ADD,ATOMICLOAD_CLR,ATOMICLOAD_EOR,ATOMICLOAD_SET,ATOMICLOAD_SMAX,ATOMICLOAD_SMIN,ATOMICLOAD_UMAX,ATOMICLOAD_UMIN};} else if(atomic_transaction_type ==STORE){ atomic_xact_op_type inside{ATOMICSTORE_ADD,ATOMICSTORE_CLR,ATOMICSTORE_EOR,ATOMICSTORE_SET,ATOMICSTORE_SMAX,ATOMICSTORE_SMIN,ATOMICSTORE_UMAX,ATOMICSTORE_UMIN};} else if(atomic_transaction_type ==SWAP){ atomic_xact_op_type inside{ATOMICSWAP};} else if(atomic_transaction_type ==COMPARE){ atomic_xact_op_type inside{ATOMICCOMPARE};} if(atomic_transaction_type !=COMPARE){ burst_size inside {0,1,2,3}; {((1 << burst_size)) * burst_length} inside {1,2,4,8}; burst_type==INCR; if (burst_length << burst_size == 2) { addr[0] == 1'b0; } else if (burst_length << burst_size == 4) { addr[1:0] == 2'b0; } else if (burst_length << burst_size == 8) { addr[2:0] == 3'b0; } } else if(atomic_transaction_type == COMPARE){ burst_size inside {0,1,2,3,4,5}; if(burst_length << burst_size == 4){ addr[0] == 1'b0;} else if (burst_length << burst_size == 8) { addr[1:0] == 2'b0; } else if (burst_length << burst_size == 16) { addr[2:0] == 3'b0; } else if(burst_length << burst_size == 32){ addr[3:0] == 4'b0; } } if(atomic_transaction_type != COMPARE){ burst_type == INCR; burst_size inside {0,1,2,3}; } else if(atomic_transaction_type == COMPARE){ burst_type inside{INCR,WRAP}; burst_size inside{0,1,2,3,4,5}; } if(xact_type ==ATOMIC){ wvalid_delay.size() == burst_length; rready_delay.size() == burst_length; } } /* * 1) Constraint the atomic_read_data_trace_tag to 1 based on trace_tag value */ if(port_cfg.axi_port_kind == svt_axi_port_configuration:: AXI_SLAVE){ if(!(atomic_transaction_type inside{LOAD,SWAP,COMPARE})){ atomic_read_data.size() ==0; atomic_read_poison.size() ==0; atomic_read_data_user.size() ==0; } if(atomic_transaction_type inside{LOAD,SWAP} && xact_type == ATOMIC) { atomic_read_data.size() == burst_length; if(port_cfg.ruser_enable){atomic_read_data_user.size() == burst_length;} else {atomic_read_data_user.size() == 0;} atomic_read_poison.size() == burst_length; foreach(atomic_read_data[index]) { if(port_cfg.wysiwyg_enable ==1'b1){ atomic_read_data[index] == atomic_read_data[index] & atomic_read_data_mask; } } if(port_cfg.ruser_enable) { foreach(atomic_read_data_user[index]) { if(port_cfg.wysiwyg_enable ==1'b1){ atomic_read_data_user[index] == atomic_read_data_user[index] & atomic_read_data_mask; } } } if(port_cfg.poison_enable ==1){ if(port_cfg.data_width>64){ foreach(atomic_read_poison[index]) { if(port_cfg.wysiwyg_enable ==1'b1){ atomic_read_poison[index] == atomic_read_poison[index] & atomic_read_poison_mask;} }}} if (!port_cfg.wysiwyg_enable) { foreach (atomic_read_data[index]) { atomic_read_data[index] <= ((1 << ((1 << burst_size) << 3)) - 1); } } if(port_cfg.ruser_enable) { if (!port_cfg.wysiwyg_enable) { foreach (atomic_read_data_user[index]) { atomic_read_data_user[index] <= ((1 << ((1 << burst_size) << 3)) - 1); } } } if(port_cfg.poison_enable ==1){ if (!port_cfg.wysiwyg_enable) { if(burst_size>3){ foreach (atomic_read_poison[index]) { atomic_read_poison[index] <= ((1 << ((1 << burst_size) >> 3)) - 1); } }}} } if(atomic_transaction_type == COMPARE && xact_type ==ATOMIC){ if(burst_length > 1){ atomic_read_data.size() == burst_length/2; if(port_cfg.ruser_enable) {atomic_read_data_user.size() == burst_length/2;} else {atomic_read_data_user.size() == 0;} atomic_read_poison.size() == burst_length/2; } else { atomic_read_data.size() == 1; if(port_cfg.ruser_enable){atomic_read_data_user.size() == 1;} else {atomic_read_data_user.size() == 0;} atomic_read_poison.size() == 1; } foreach(atomic_read_data[index]) { if(port_cfg.wysiwyg_enable ==1'b1){ atomic_read_data[index] == atomic_read_data[index] & atomic_comp_read_data_mask; } } if(port_cfg.ruser_enable) { foreach(atomic_read_data_user[index]) { if(port_cfg.wysiwyg_enable ==1'b1){ atomic_read_data_user[index] == atomic_read_data_user[index] & atomic_comp_read_data_mask; } } } if(port_cfg.poison_enable ==1){ if(port_cfg.data_width>64){ foreach(atomic_read_poison[index]) { if(port_cfg.wysiwyg_enable ==1'b1){ atomic_read_poison[index] == atomic_read_poison[index] & atomic_read_poison_mask;} }}} if (!port_cfg.wysiwyg_enable) { foreach (atomic_read_data[index]) { atomic_read_data[index] <= ((1 << (((1 << burst_size)>>1) << 3)) - 1); } } if(port_cfg.ruser_enable) { if (!port_cfg.wysiwyg_enable) { foreach (atomic_read_data_user[index]) { atomic_read_data_user[index] <= ((1 << (((1 << burst_size)>>1) << 3)) - 1); } } } if(port_cfg.poison_enable ==1){ if (!port_cfg.wysiwyg_enable) { if(burst_size>3){ foreach (atomic_read_poison[index]) { atomic_read_poison[index] <= ((1 << ((1 << burst_size) >> 3)) - 1); } }}} } // atomic_transaction_type == COMPARE if(trace_tag ==1 && atomic_transaction_type inside{LOAD,SWAP,COMPARE} && xact_type == ATOMIC){ atomic_read_data_trace_tag == 1; } if(atomic_transaction_type inside{LOAD,SWAP,COMPARE} && xact_type == ATOMIC){ rvalid_delay.size() == burst_length; foreach (rvalid_delay[idx]) rvalid_delay[idx] inside {[0: 16]}; } wready_delay.size()==burst_length; } // axi_port_kind == AXI_SLAVE } // xact_type == atomic if(xact_type == ATOMIC && atomic_transaction_type inside{LOAD,SWAP} ){ rresp.size()== burst_length ; } if(xact_type == ATOMIC && atomic_transaction_type inside{COMPARE} ){ if(burst_length > 1){ rresp.size()== burst_length/2 ;} else { rresp.size() ==1;} } /* if(xact_type == ATOMIC) { if(burst_length > 1){ 1 << burst_size == data_width_in_bytes;} }*/ if(xact_type != ATOMIC) { atomic_read_data.size() == 0; atomic_read_poison.size() == 0; atomic_read_data_user.size() == 0; atomic_swap_data.size() == 0; atomic_compare_data.size() == 0; atomic_swap_wstrb.size() == 0; atomic_compare_wstrb.size() == 0; atomic_swap_tag.size() == 0; atomic_compare_tag.size() == 0; atomic_transaction_type == NON_ATOMIC; } if(xact_type ==ATOMIC){ atomic_type == NORMAL; random_interleave_array.size() == burst_length; random_interleave_array[0] == 1; } xact_type != READ_WRITE; converted_xact_type != READ_WRITE; transmitted_channel != ATOMIC; } // atomic_xacts_valid_ranges |
|
|
constraint axi3_4_valid_ranges {
if (port_cfg.axi_interface_type == svt_axi_port_configuration::AXI3) burst_length <= 16; else burst_length <= 256; if(port_cfg.ace_version == svt_axi_port_configuration::ACE_VERSION_1_0 && xact_type == COHERENT) { !(coherent_xact_type inside{CLEANSHAREDPERSIST,READONCECLEANINVALID,READONCEMAKEINVALID});} } // axi3_4_valid_ranges |
|
|
constraint axi4_stream_valid_ranges {
if (port_cfg.axi_port_kind == svt_axi_port_configuration::AXI_MASTER) { if (port_cfg.axi_interface_type == svt_axi_port_configuration::AXI4_STREAM) { if (!port_cfg.tid_enable) { tid == 0; } else { tid inside {[0 : ((1 << port_cfg.tid_width) -1)]}; } if (!port_cfg.tdest_enable) { tdest == 0; } else { tdest inside {[0 : ((1 << port_cfg.tdest_width) -1)]}; } if (!port_cfg.tlast_enable) { stream_burst_length == 1; } if(tdata_size_from_parent > 0) { stream_burst_length == tdata_size_from_parent; } } //AXI4_STREAM } //AXI_MASTER } // axi4_stream_valid_ranges |
|
|
constraint barrier_xacts_valid_range {
if(port_cfg.ace_version == svt_axi_port_configuration::ACE_VERSION_2_0 && port_cfg.axi_port_kind == svt_axi_port_configuration::AXI_MASTER && (port_cfg.axi_interface_type == svt_axi_port_configuration::AXI_ACE || port_cfg.axi_interface_type == svt_axi_port_configuration::ACE_LITE)){ barrier_type == NORMAL_ACCESS_RESPECT_BARRIER;} } |
|
|
constraint disable_constraint_first_wvalid_reference_event {
reference_event_for_first_wvalid_delay dist { WRITE_ADDR_VALID:=50000, WRITE_ADDR_HANDSHAKE:=1, PREV_WRITE_DATA_HANDSHAKE:=50000 }; } |
|
|
constraint fixed_burst_disable {
if(port_cfg.ace_version == svt_axi_port_configuration::ACE_VERSION_2_0 && (port_cfg.axi_interface_type == svt_axi_port_configuration::AXI4 || port_cfg.axi_interface_type == svt_axi_port_configuration::ACE_LITE) && port_cfg.fixed_burst_disable == svt_axi_port_configuration::FIXED_BURST_DISABLE_TRUE ) { burst_type != FIXED; } } |
|
|
constraint loopback_valid_ranges {
if (port_cfg.enable_loopback_signaling && port_cfg.axi_port_kind == svt_axi_port_configuration::AXI_MASTER && port_cfg.is_active) { write_request_loopback <= max_possible_write_request_loopback; read_request_loopback <= max_possible_read_request_loopback; } } |
|
|
constraint memory_tagging_valid_ranges {
if(port_cfg.axi_port_kind == svt_axi_port_configuration::AXI_MASTER){ if(port_cfg.mte_support_type != svt_axi_port_configuration::MTE_FALSE && port_cfg.use_external_port_monitor ==1){ if(transmitted_channel == WRITE || transmitted_channel == READ_WRITE) { if(port_cfg.mte_support_type == svt_axi_port_configuration::BASIC){ !(tag_op inside {TAG_TRANSFER,TAG_FETCH_MATCH}); if(xact_type == ATOMIC){ tag_op == TAG_INVALID;} if(xact_type == COHERENT) { if(coherent_xact_type inside {WRITENOSNOOP,WRITEUNIQUE,WRITELINEUNIQUE}){ tag_op inside {TAG_INVALID,TAG_UPDATE}; } else if (coherent_xact_type inside {CMO,WRITEPTLCMO,WRITEFULLCMO,WRITEUNIQUEPTLSTASH,WRITEUNIQUEFULLSTASH,STASHONCESHARED,STASHONCEUNIQUE,STASHTRANSLATION}){ tag_op ==TAG_INVALID;} } if(xact_type == WRITE){ tag_op inside {TAG_INVALID,TAG_UPDATE};} } if(port_cfg.mte_support_type == svt_axi_port_configuration::STANDARD){ tag_op inside {TAG_INVALID,TAG_UPDATE,TAG_TRANSFER,TAG_FETCH_MATCH}; if(xact_type == ATOMIC){ tag_op inside {TAG_INVALID,TAG_FETCH_MATCH}; } if(xact_type == COHERENT) { if(coherent_xact_type inside {WRITENOSNOOP}){ tag_op inside {TAG_INVALID,TAG_UPDATE,TAG_TRANSFER,TAG_FETCH_MATCH};} else if(coherent_xact_type inside {WRITEUNIQUE,WRITELINEUNIQUE}) { tag_op inside {TAG_INVALID,TAG_UPDATE};} else if (coherent_xact_type inside {WRITEPTLCMO,WRITEFULLCMO}){ tag_op inside {TAG_INVALID,TAG_TRANSFER,TAG_UPDATE};} else if (coherent_xact_type inside{CMO,WRITEUNIQUEPTLSTASH,WRITEUNIQUEFULLSTASH,STASHONCESHARED,STASHONCEUNIQUE,STASHTRANSLATION}){ tag_op == TAG_INVALID;} } if(xact_type == WRITE){ tag_op inside {TAG_INVALID,TAG_UPDATE,TAG_TRANSFER,TAG_FETCH_MATCH}; } } } if(transmitted_channel == READ) { tag_op inside {TAG_INVALID,TAG_TRANSFER,TAG_FETCH_MATCH}; if(xact_type == COHERENT) { if(coherent_xact_type == READNOSNOOP){ tag_op inside {TAG_INVALID,TAG_TRANSFER,TAG_FETCH_MATCH}; } else if (coherent_xact_type == READONCE){ tag_op inside {TAG_INVALID,TAG_TRANSFER};} else if (coherent_xact_type inside {READONCEMAKEINVALID,READONCECLEANINVALID,CLEANINVALID,MAKEINVALID,CLEANSHARED,CLEANSHAREDPERSIST,DVMMESSAGE,DVMCOMPLETE}){ tag_op ==TAG_INVALID;} } if(xact_type == READ){ tag_op inside {TAG_INVALID,TAG_TRANSFER,TAG_FETCH_MATCH}; } } if (tag_op != TAG_INVALID){ burst_type != FIXED; archunken == 0; //TODO: Currently this is a limitation if (port_cfg.unique_id_enable) { unique_id == 1; } (burst_length << burst_size) <= port_cfg.cache_line_size; (((addr >> burst_size) << burst_size) + (burst_length << burst_size)) <= ((addr/port_cfg.cache_line_size)*port_cfg.cache_line_size) + port_cfg.cache_line_size; if((xact_type == READ || (xact_type == COHERENT && coherent_xact_type == READNOSNOOP)) && tag_op == TAG_FETCH_MATCH){ burst_length inside {1,2,4,8,16}; if(burst_length > 1) { burst_size == log_base_2_data_width_in_bytes; } if(burst_type == INCR) { addr == (addr >> (burst_length << burst_size)) << (burst_length << burst_size); } if(burst_type == WRAP) { addr == (addr >> burst_size) << burst_size; } (burst_length << burst_size) == port_cfg.cache_line_size; if (port_cfg.cache_line_size <= (port_cfg.data_width/8)) { burst_length == 1; } } cache_type[3:2] != 2'b00; cache_type[1:0] == 2'b11; } if(tag_op == TAG_INVALID){ foreach(tag[i]) tag[i] == 0; } xact_type inside {READ,WRITE,COHERENT,ATOMIC}; if(xact_type == COHERENT){ coherent_xact_type inside {WRITENOSNOOP,WRITEUNIQUE,WRITELINEUNIQUE,CMO,WRITEUNIQUEPTLSTASH,WRITEUNIQUEFULLSTASH,STASHONCESHARED,STASHONCEUNIQUE,STASHTRANSLATION,WRITEPTLCMO,WRITEFULLCMO, READNOSNOOP,READONCE,READONCEMAKEINVALID,READONCECLEANINVALID,CLEANINVALID,MAKEINVALID,CLEANSHARED,CLEANSHAREDPERSIST,DVMMESSAGE,DVMCOMPLETE}; } if(tag_op == TAG_FETCH_MATCH && port_cfg.mte_support_type == svt_axi_port_configuration::STANDARD){ if(xact_type == ATOMIC && atomic_transaction_type == COMPARE){ (burst_length << burst_size) inside {16,32}; if((burst_length << burst_size) == 32) { atomic_compare_tag.size() == burst_length; atomic_swap_tag.size() == burst_length; } else { atomic_compare_tag.size() == 0; atomic_swap_tag.size() == 0; } } else { atomic_compare_tag.size() == 0; atomic_swap_tag.size() == 0; } } else { atomic_compare_tag.size() == 0; atomic_swap_tag.size() == 0; } } //external_port_monitor == 1 if(port_cfg.mte_support_type != svt_axi_port_configuration::MTE_FALSE && port_cfg.use_external_port_monitor == 0){ if(port_cfg.mte_support_type == svt_axi_port_configuration::BASIC){ if((xact_type == COHERENT && coherent_xact_type inside {WRITENOSNOOP, WRITEUNIQUE, WRITELINEUNIQUE}) || xact_type == WRITE){ tag_op inside {TAG_INVALID, TAG_UPDATE}; } else if((xact_type == COHERENT && coherent_xact_type inside {READNOSNOOP, READONCE}) || xact_type == READ){ tag_op inside {TAG_INVALID, TAG_TRANSFER}; } else{ tag_op == TAG_INVALID; } } else if(port_cfg.mte_support_type == svt_axi_port_configuration::STANDARD){ if(xact_type == WRITE){ tag_op inside {TAG_INVALID, TAG_UPDATE, TAG_TRANSFER, TAG_FETCH_MATCH}; } else if(xact_type == READ){ tag_op inside {TAG_INVALID, TAG_TRANSFER, TAG_FETCH_MATCH}; } else if(xact_type == ATOMIC){ tag_op inside {TAG_INVALID, TAG_FETCH_MATCH}; } else if(xact_type == COHERENT){ if(coherent_xact_type == WRITENOSNOOP){ tag_op inside {TAG_INVALID, TAG_UPDATE, TAG_TRANSFER, TAG_FETCH_MATCH}; } else if(coherent_xact_type inside {WRITEUNIQUE, WRITELINEUNIQUE}){ tag_op inside {TAG_INVALID, TAG_UPDATE}; } else if (coherent_xact_type inside {WRITEPTLCMO, WRITEFULLCMO}){ tag_op inside {TAG_INVALID, TAG_TRANSFER, TAG_UPDATE}; } else if (coherent_xact_type inside {PREFETCH}){ tag_op inside {TAG_INVALID, TAG_TRANSFER}; } else if (coherent_xact_type inside {READNOSNOOP}){ tag_op inside {TAG_INVALID, TAG_TRANSFER, TAG_FETCH_MATCH}; } else if (coherent_xact_type inside {READONCE}){ tag_op inside {TAG_INVALID, TAG_TRANSFER}; } else{ tag_op == TAG_INVALID; } } } if(transmitted_channel == READ){ tag.size == burst_length; tag_update.size == 0; if(tag_op == TAG_INVALID){ foreach(tag[i]){ tag[i] == 0; } } } else if(transmitted_channel == WRITE || transmitted_channel == READ_WRITE) { tag.size == burst_length; tag_update.size == burst_length; if(tag_op == TAG_INVALID){ foreach(tag[i]) tag[i] == 0; foreach(tag_update[i]) tag_update[i] == 0; } else if(tag_op == TAG_TRANSFER || tag_op == TAG_FETCH_MATCH){ foreach(tag_update[i]) tag_update[i] == 0; } } if (tag_op != TAG_INVALID){ burst_type != FIXED; archunken == 0; //TODO: Currently this is a limitation if (port_cfg.unique_id_enable) { unique_id == 1; } (burst_length << burst_size) <= port_cfg.cache_line_size; (((addr >> burst_size) << burst_size) + (burst_length << burst_size)) <= ((addr/port_cfg.cache_line_size)*port_cfg.cache_line_size) + port_cfg.cache_line_size; if((xact_type== READ || (xact_type == COHERENT && coherent_xact_type == READNOSNOOP)) && tag_op == TAG_FETCH_MATCH){ burst_length inside {1,2,4,8,16}; if(burst_length > 1) { burst_size == log_base_2_data_width_in_bytes; } if(burst_type == INCR) { addr == (addr >> (burst_length << burst_size)) << (burst_length << burst_size); } if(burst_type == WRAP) { addr == (addr >> burst_size) << burst_size; } (burst_length << burst_size) == port_cfg.cache_line_size; if (port_cfg.cache_line_size <= (port_cfg.data_width/8)) { burst_length == 1; } } cache_type[3:2] != 2'b00; cache_type[1:0] == 2'b11; } if(tag_op == TAG_FETCH_MATCH && port_cfg.mte_support_type == svt_axi_port_configuration::STANDARD){ if(xact_type == ATOMIC && atomic_transaction_type == COMPARE){ (burst_length << burst_size) inside {16,32}; if((burst_length << burst_size) == 32) { atomic_compare_tag.size() == burst_length; atomic_swap_tag.size() == burst_length; } else { atomic_compare_tag.size() == 0; atomic_swap_tag.size() == 0; } } else { atomic_compare_tag.size() == 0; atomic_swap_tag.size() == 0; } } else { atomic_compare_tag.size() == 0; atomic_swap_tag.size() == 0; } } //external_port_monitor = 0 } //port_kind = AXI_MASTER if(port_cfg.axi_port_kind == svt_axi_port_configuration::AXI_SLAVE){ if(port_cfg.mte_support_type != svt_axi_port_configuration::MTE_FALSE && port_cfg.use_external_port_monitor ==1){ if(port_cfg.use_external_port_monitor == 1){ if(transmitted_channel == READ){ if(tag_op == TAG_INVALID){ response_tag_op inside {TAG_INVALID,TAG_TRANSFER};} else if(tag_op == TAG_TRANSFER){ response_tag_op == TAG_TRANSFER}; } else if(transmitted_channel == READ_WRITE || transmitted_channel == WRITE){ response_tag_op == TAG_INVALID; } } else { response_tag_op == TAG_INVALID; } if(transmitted_channel == READ_WRITE || transmitted_channel == WRITE){ tag_match_resp inside{ MATCH_NOT_PERFORMED,MATCH_RESULT_IN_SEPARATE_RESPONSE,FAIL, PASS}; } else if(transmitted_channel == READ){ tag_match_resp == MATCH_NOT_PERFORMED; } } if(port_cfg.mte_support_type != svt_axi_port_configuration::MTE_FALSE && port_cfg.use_external_port_monitor == 0){ if((xact_type == COHERENT && coherent_xact_type inside {READNOSNOOP, READONCE}) || xact_type == READ){ tag.size == burst_length; } if((transmitted_channel == READ_WRITE || transmitted_channel == WRITE) && tag_op == TAG_FETCH_MATCH){ tag_match_resp inside{ MATCH_NOT_PERFORMED, MATCH_RESULT_IN_SEPARATE_RESPONSE, FAIL, PASS}; } else { tag_match_resp == MATCH_NOT_PERFORMED; } } } }//memory_tagging_valid_ranges |
|
|
constraint mpam_valid_ranges {
if (port_cfg.axi_port_kind == svt_axi_port_configuration::AXI_MASTER && port_cfg.is_active) { if (port_cfg.enable_mpam != svt_axi_port_configuration::MPAM_FALSE && port_cfg.rme_support == svt_axi_port_configuration::RME_FALSE) { mpam_ns[1] == 0; } if (port_cfg.enable_mpam == svt_axi_port_configuration::MPAM_FALSE) { mpam_partid == 0; mpam_perfmongroup == 0; mpam_ns[0] == prot_type[1]; } if (( 9 == 12) && (port_cfg.enable_mpam == svt_axi_port_configuration::MPAM_9_1)) { mpam_partid[(-1):(-3)] == 0; } } } |
|
|
constraint nsaid_valid_ranges {
if (port_cfg.enable_non_secure_access_identifiers ) { if (port_cfg.axi_port_kind == svt_axi_port_configuration::AXI_MASTER && port_cfg.is_active) { if (prot_type inside { DATA_SECURE_NORMAL, DATA_SECURE_PRIVILEGED, INSTRUCTION_SECURE_NORMAL, INSTRUCTION_SECURE_PRIVILEGED }) { non_secure_access_id == 0; } else { non_secure_access_id <= (1 << port_cfg.nsaid_width) - 1; } } } else { non_secure_access_id == 0; } } |
|
|
constraint prefetch_xact {
if (port_cfg.prefetch_xact_enable == 0 || xact_type != COHERENT) { coherent_xact_type != PREFETCH; } if (port_cfg.prefetch_xact_enable == 1 && xact_type == COHERENT) { if (coherent_xact_type == svt_axi_transaction::PREFETCH) { bresp inside {OKAY,SLVERR,DECERR}; } } } |
|
|
constraint reasonable_chunk_len {
solve burst_length before chunk_length; solve burst_size before chunk_length; if(port_cfg.axi_port_kind == svt_axi_port_configuration::AXI_SLAVE && port_cfg.rdata_chunking_enable){ if(archunken){ if(burst_size < 4){ chunk_length == 1; } else { chunk_length inside {[burst_length:(burst_length<<(burst_size - 4))]}; } } else { chunk_length == 1; } } } |
|
|
constraint reasonable_cust_xact_flow {
soft cust_xact_flow == 0; } |
|
|
constraint reasonable_no_interleaving {
if (port_cfg.axi_port_kind == svt_axi_port_configuration::AXI_SLAVE && port_cfg.prioritized_reordering_type == svt_axi_port_configuration::XACT_ADDR_HANDSHAKE_TO_RSP_DAT_VALID_DELAY) { enable_interleave == 0; start_new_interleave == 0; equal_block_length == 0; } } |
|
|
constraint reasonable_ranges_while_chunking {
solve chunk_length before rchunkstrb; solve chunk_length before rchunknum; if(port_cfg.axi_port_kind == svt_axi_port_configuration::AXI_SLAVE && port_cfg.rdata_chunking_enable == 1){ if(archunken){ rchunkstrb.size() == chunk_length; rchunknum.size() == chunk_length; } else { rchunkstrb.size() == 0; rchunknum.size() == 0; } } } |
|
|
constraint reasonable_reference_event_for_addr_delay {
if(data_before_addr){ reference_event_for_addr_valid_delay inside {FIRST_WVALID_DATA_BEFORE_ADDR};} } |
|
|
constraint reasonable_reference_event_for_addr_ready_delay {
reference_event_for_addr_ready_delay inside {ADDR_VALID}; } |
|
|
constraint rme_type_range {
solve rme_type before prot_type; if(port_cfg.axi_port_kind == svt_axi_port_configuration::AXI_MASTER && port_cfg.is_active){ if(port_cfg.rme_support == svt_axi_port_configuration::RME_TRUE){ if (port_cfg.addr_translation_enable){ if (secure_or_non_secure_stream == 'b00) { rme_type == NONE_ROOT_REALM; prot_type inside { DATA_NON_SECURE_NORMAL, DATA_NON_SECURE_PRIVILEGED, INSTRUCTION_NON_SECURE_NORMAL, INSTRUCTION_NON_SECURE_PRIVILEGED }; } else if(secure_or_non_secure_stream == 'b01) { rme_type == NONE_ROOT_REALM; } else if(secure_or_non_secure_stream == 'b10) { prot_type inside { DATA_NON_SECURE_NORMAL, DATA_NON_SECURE_PRIVILEGED, INSTRUCTION_NON_SECURE_NORMAL, INSTRUCTION_NON_SECURE_PRIVILEGED }; } } //addr translation_enable if (rme_type == ROOT) { prot_type inside { DATA_SECURE_NORMAL, DATA_SECURE_PRIVILEGED, INSTRUCTION_SECURE_NORMAL, INSTRUCTION_SECURE_PRIVILEGED }; } else if (rme_type == REALM) { prot_type inside { DATA_NON_SECURE_NORMAL, DATA_NON_SECURE_PRIVILEGED, INSTRUCTION_NON_SECURE_NORMAL, INSTRUCTION_NON_SECURE_PRIVILEGED }; } } //rme_support == RME_TRUE else if(port_cfg.rme_support == svt_axi_port_configuration::RME_FALSE){ rme_type == NONE_ROOT_REALM; if(port_cfg.cmo_on_write_enable || port_cfg.write_plus_cmo_enable) { cmo_on_write_xact_type != CLEANINVALIDPOPA_ON_WRITE; } if (port_cfg.addr_translation_enable){ if (secure_or_non_secure_stream == 'b0) { prot_type inside { DATA_NON_SECURE_NORMAL, DATA_NON_SECURE_PRIVILEGED, INSTRUCTION_NON_SECURE_NORMAL, INSTRUCTION_NON_SECURE_PRIVILEGED }; }//secure_or_non_secure_stream }//addr_translation_enable }//rme_support == RME_FALSE }//AXI_MASTER and is_active }//rme_type_range |
|
|
constraint untranslated_translation_valid_ranges {
solve sub_stream_id_valid before sub_stream_id; if (port_cfg.axi_port_kind == svt_axi_port_configuration::AXI_MASTER && port_cfg.is_active) { if (port_cfg.addr_translation_enable ) { if (port_cfg.untranslated_transactions == svt_axi_port_configuration::UNTR_V3 ) { addr_translated_from_pcie == 0; if (smmuvalid) { tag_op == TAG_INVALID; if (!sub_stream_id_valid) { sub_stream_id == 0; } if(secure_or_non_secure_stream ==0){ prot_type[1] == 1; } if (smmu_flow == SMMU_ATST){ if (port_cfg.rme_support == svt_axi_port_configuration::RME_TRUE) { secure_or_non_secure_stream inside {'b00,'b10}; } else{ secure_or_non_secure_stream == 0; } } } } else if (port_cfg.untranslated_transactions == svt_axi_port_configuration::UNTR_V2 ) { addr_translated_from_pcie == 0; if (!sub_stream_id_valid) { sub_stream_id == 0; } if(secure_or_non_secure_stream ==0){ prot_type[1] == 1; } if (smmu_flow == SMMU_ATST){ sub_stream_id_valid == 0; if (port_cfg.rme_support == svt_axi_port_configuration::RME_TRUE) { secure_or_non_secure_stream inside {'b00,'b10}; } else{ secure_or_non_secure_stream == 0; } } } else if (port_cfg.untranslated_transactions == svt_axi_port_configuration::UNTR_V1 ) { if (!sub_stream_id_valid) { sub_stream_id == 0; } if(secure_or_non_secure_stream ==0){ prot_type[1] == 1; } } if (port_cfg.rme_support == svt_axi_port_configuration::RME_TRUE) { secure_or_non_secure_stream inside {[0:2]}; } else { secure_or_non_secure_stream inside {[0:1]}; } } else { stream_id == 0; sub_stream_id == 0; secure_or_non_secure_stream == 0; addr_translated_from_pcie == 0; sub_stream_id_valid == 0; } } if (port_cfg.axi_port_kind == svt_axi_port_configuration::AXI_SLAVE && port_cfg.is_active) { if (port_cfg.addr_translation_enable ) { if (port_cfg.untranslated_transactions == svt_axi_port_configuration::UNTR_V3 ) { if (smmuvalid) { if (smmu_flow != SMMU_PRI){ bresp != TRANSFAULT; foreach (rresp[i]) rresp[i] != TRANSFAULT; foreach(multi_beat_bresp[i]) multi_beat_bresp[i] != TRANSFAULT; } else { foreach(rresp[i]) { if(i>0 && rresp[0] == TRANSFAULT) { rresp[i] == TRANSFAULT; } else if(i>0 && rresp[0] != TRANSFAULT) { rresp[i] != TRANSFAULT; } } foreach(multi_beat_bresp[i]) { if(i>0 && multi_beat_bresp[0] == TRANSFAULT) { multi_beat_bresp[i] == TRANSFAULT; } else if(i>0 && multi_beat_bresp[0] != TRANSFAULT) { multi_beat_bresp[i] != TRANSFAULT; } } } } else { bresp != TRANSFAULT; foreach (rresp[i]) rresp[i] != TRANSFAULT; foreach(multi_beat_bresp[i]) multi_beat_bresp[i] != TRANSFAULT; } } else if (port_cfg.untranslated_transactions == svt_axi_port_configuration::UNTR_V2 ) { if (smmu_flow != SMMU_PRI){ bresp != TRANSFAULT; foreach (rresp[i]) rresp[i] != TRANSFAULT; foreach(multi_beat_bresp[i]) multi_beat_bresp[i] != TRANSFAULT; } else { foreach(rresp[i]) { if(i>0 && rresp[0] == TRANSFAULT) { rresp[i] == TRANSFAULT; } else if(i>0 && rresp[0] != TRANSFAULT) { rresp[i] != TRANSFAULT; } } foreach(multi_beat_bresp[i]) { if(i>0 && multi_beat_bresp[0] == TRANSFAULT) { multi_beat_bresp[i] == TRANSFAULT; } else if(i>0 && multi_beat_bresp[0] != TRANSFAULT) { multi_beat_bresp[i] != TRANSFAULT; } } } } if (port_cfg.untranslated_transactions == svt_axi_port_configuration::UNTR_V1 ) { bresp != TRANSFAULT; foreach (rresp[i]) rresp[i] != TRANSFAULT; foreach(multi_beat_bresp[i]) multi_beat_bresp[i] != TRANSFAULT; } } } } |
|
|
constraint valid_archunken {
solve xact_type before archunken; solve xact_type before coherent_xact_type; solve coherent_xact_type before archunken; solve burst_size before archunken; solve burst_type before archunken; solve burst_length before archunken; solve addr before archunken; if(port_cfg.axi_port_kind == svt_axi_port_configuration::AXI_MASTER){ if(port_cfg.rdata_chunking_enable == 1 && (xact_type == READ || (xact_type == COHERENT && coherent_xact_type inside {READNOSNOOP, READONCE, READONCECLEANINVALID, READONCEMAKEINVALID})) && (burst_size >= BURST_SIZE_128BIT) && (((1<<burst_size) == (port_cfg.data_width/8)) || burst_length == 1) && (addr%16 == 0) && (burst_type inside {INCR,WRAP}) && (unique_id == 1)){ archunken inside {0,1}; } else { archunken == 0; } } } |
|
|
constraint valid_chunking {
if(port_cfg.axi_port_kind == svt_axi_port_configuration::AXI_MASTER && port_cfg.rdata_chunking_enable) { if(archunken){ xact_type inside {READ, COHERENT}; if(xact_type == COHERENT){ coherent_xact_type inside {READNOSNOOP, READONCE, READONCECLEANINVALID, READONCEMAKEINVALID}; } burst_size >= BURST_SIZE_128BIT; if((1<<burst_size) != (port_cfg.data_width/8)){ burst_length == 1; } addr%16 == 0; burst_type inside {INCR,WRAP}; if (port_cfg.unique_id_enable) { unique_id == 1; } } } } |
|
|
constraint valid_rchunkv {
rchunkv == 0; } |
|
|
Re-organised constraint blocks based on interface type. This will make it easy to turn-off the constraints based on interface type. It can result in significant run-time improvement.
| |
constraint wdata_optimistic_flow_valid_ranges {
if(port_cfg.wdata_optimistic_flow_control_enable && port_cfg.axi_port_kind == svt_axi_port_configuration::AXI_MASTER && xact_type == WRITE) { data_before_addr == 0; } } |
|
|
constraint write_deferrable {
if (port_cfg.writedeferrable_transaction == svt_axi_port_configuration::WDT_FALSE || !(xact_type inside {WRITE,COHERENT})) { write_xact_type == NORMAL_WRITE; coherent_xact_type != WRITEDEFERRABLE; !(bresp inside {PREFETCHED_DEFER,TRANSFAULT,UNSUPPORTED}); } if (port_cfg.writedeferrable_transaction == svt_axi_port_configuration::WDT_TRUE && (xact_type inside {WRITE,COHERENT})) { if ((xact_type == svt_axi_transaction::WRITE && write_xact_type == svt_axi_transaction::DEFERRABLE) || (xact_type == svt_axi_transaction::COHERENT && coherent_xact_type == svt_axi_transaction::WRITEDEFERRABLE)) { bresp inside {OKAY,SLVERR,DECERR,PREFETCHED_DEFER,TRANSFAULT,UNSUPPORTED}; } else { !(bresp inside {PREFETCHED_DEFER,TRANSFAULT,UNSUPPORTED}); } } foreach (multi_beat_bresp[i]) { !(multi_beat_bresp[i] inside {PREFETCHED_DEFER,TRANSFAULT,UNSUPPORTED}); } } |
|
|
constraint write_with_cmo_xacts_valid_ranges {
if(port_cfg.axi_port_kind == svt_axi_port_configuration::AXI_MASTER && port_cfg.is_active) { if(xact_type == COHERENT && (coherent_xact_type == WRITEPTLCMO || coherent_xact_type == WRITEFULLCMO)){ domain_type inside {INNERSHAREABLE,OUTERSHAREABLE,NONSHAREABLE}; atomic_type == NORMAL; cache_type[1] == 1; burst_type != FIXED; } if(port_cfg.axi_interface_type != svt_axi_port_configuration::ACE_LITE){ !(coherent_xact_type inside {CMO,WRITEPTLCMO,WRITEFULLCMO}); } if(port_cfg.write_plus_cmo_enable != 1){ !(coherent_xact_type inside {WRITEPTLCMO,WRITEFULLCMO}); } if(port_cfg.cmo_on_write_enable != 1){ coherent_xact_type != CMO; } if(port_cfg.persist_cmo_enable != 1){ !(cmo_on_write_xact_type inside {CLEANSHAREDPERSIST_ON_WRITE, CLEANSHAREDDEEPPERSIST_ON_WRITE}); } } } |