VIP Smartsearch

X
  • VIP Smartsearch is a framework that supports search within VIP reference documents using query in natural language. It facilitates reordering of search results and keeps record of user’s decision for the ordering of result display and applies that in search of same query on subsequent usage.

  • How to download VIP smartsearch?

    1. Get VIP Smartsearch (Available as a seperate run file).
    2. Set environment variable 
      DESIGNWARE_HOME
      to required designware home location where VIP Smartsearch should be downloaded.
    3. Run 
      vip_smartsearch_<version>.run
      file.
      VIP Smartsearch will be downloaded to the location 
      $DESIGNWARE_HOME/vip/svt/vip_smartsearch/<version>

  • How to install VIP Smartsearch?

    Please refer to the file 
    VIP_Smartsearch_installation_and_usage_guide.pdf
    in 
    $DESIGNWARE_HOME/vip/svt/vip_smartsearch/<version>
    for installation steps.

  • Customer Support

    For more details about VIP smartsearch tool, contact support_center@synopsys.com.
    Mention your queries along with below details and send email to above email id.
    Product: Verification IP
    Sub Product: <vip_title>
    Tool: VIP Smartsearch
13 August 2024, Copyright © 2024 Synopsys, Inc.

AMBA CHI-C SVT UVM Documentation - Sequence Page

Comprehensive Inheritance diagram for sequence classes:

Summary of Sequences defined in AMBA CHI-C SVT UVM Documentation:

Product Base Group
amba_svt CHI_SYS_OUTSTANDING
CHI_SYS_FLOW_CTRL
CHI_SYS_SINGLE_RN
CHI_RN
CHI_RN_BASE
CHI_SYS_EXCLUSIVE_ACCESS
CHI_SYS_HAZARD
CHI_SYS_BASE
CHI_LINK_SVC
CHI_LINK_SVC_BASE
CHI_PROTOCOL_SERVICE
CHI_PROTOCOL_SERVICE_BASE
CHI_IC_SN_MEM
CHI_IC_SN_BASE
CHI_SN_MEM
CHI_SN_NULL
CHI_SN_BASE
CHI_IC_SNP
CHI_IC_SNP_BASE
CHI_SNP
CHI_SNP_BASE
CHI_RN_NULL
Ungrouped Sequences

Product: amba_svt - Sequence Details:

Sequence Group Sequence Subgroup Sequences Sequences Description
CHI_SYS_OUTSTANDING
* Outstanding transactions feature virtual sequences generate transactions from RN agents to verify the maximum outstanding transaction capability of a home node within the interconnect. Controls to specify the outstanding transaction limits of the targeted home node are provided in these sequences. The categories of transaction types covered include: Reads, Writes, Copyback, CMOs, Atomics.
CHI_OUTSTANDING_RD_TYPE
* Read type transaction specific flow control feature virtual sequences
 svt_chi_system_protocol_flow_ctrl_read_outstanding_diff_rn_diff_hn_virtual_sequence #- This sequence requires at least two different HN node to be present in the Interconnect.
#- This sequence requires two initiating active and participating RN.
#- If another active and participating RN-F exists, perform cache
initialization to a randomly selected two different HN's.
#- Initiate maximum number of Read type transactions with
svt_chi_rn_transaction :: suspend_comp_ack set to 1 from two initiating RN's to randomly
selected different HN's in non blocking mode.
#- The addresses of these Read transactions are such that:
  • Same as initialized cache line addresses if cache initialization is performed
  • Otherwise, random addresses targeting the different HN's
#- Once the RN receives the responses for all the outstanding transactions from
different HN, svt_chi_rn_transaction :: suspend_comp_ack is set to 0 for all the outstanding
transactions.
This ensures that the CompAck for these transactions can be resumed
from different RN.
#- Check that the different HN responds properly for all outstanding Read type
transactions and these are completed successfully.
.		 --
CHI_SYS_OUTSTANDING
* Outstanding transactions feature virtual sequences generate transactions from RN agents to verify the maximum outstanding transaction capability of a home node within the interconnect. Controls to specify the outstanding transaction limits of the targeted home node are provided in these sequences. The categories of transaction types covered include: Reads, Writes, Copyback, CMOs, Atomics.
CHI_OUTSTANDING_RD_TYPE
* Read type transaction specific flow control feature virtual sequences
 svt_chi_system_protocol_flow_ctrl_read_outstanding_diff_rn_same_hn_virtual_sequence #- This sequence requires at least one HN node to be present in the Interconnect.
#- This sequence requires two initiating active and participating RN.
#- If another active and participating RN-F exists, perform cache
initialization to a randomly selected HN.
#- Initiate maximum number of Read type transactions with
svt_chi_rn_transaction :: suspend_comp_ack set to 1 from two initiating RN's to randomly
selected HN in non blocking mode.
#- The addresses of these Read transactions are such that:
  • Same as initialized cache line addresses if cache initialization is performed
  • Otherwise, random addresses targeting the same HN
#- Once the RN receives the responses for all the outstanding transactions from
HN, svt_chi_rn_transaction :: suspend_comp_ack is set to 0 for all the outstanding
transactions.
This ensures that the CompAck for these transactions can be resumed
from different RN.
#- Check that the HN responds properly for all outstanding Read type
transactions and these are completed successfully.
.		 --
CHI_SYS_OUTSTANDING
* Outstanding transactions feature virtual sequences generate transactions from RN agents to verify the maximum outstanding transaction capability of a home node within the interconnect. Controls to specify the outstanding transaction limits of the targeted home node are provided in these sequences. The categories of transaction types covered include: Reads, Writes, Copyback, CMOs, Atomics.
CHI_OUTSTANDING_RD_TYPE
* Read type transaction specific flow control feature virtual sequences
 svt_chi_system_protocol_flow_ctrl_read_outstanding_same_rn_same_hn_virtual_sequence #- This sequence requires at least one HN node to be present in the Interconnect.
#- This sequence requires one initiating active and participating RN.
#- If another active and participating RN-F exists, perform cache
initialization to a randomly selected HN.
#- Initiate maximum number of Read type transactions with
svt_chi_rn_transaction :: suspend_comp_ack set to 1 from initiating RN to randomly
selected HN in non blocking mode.
#- The addresses of these Read transactions are such that:
  • Same as initialized cache line addresses if cache initialization is performed
  • Otherwise, random addresses targeting the same HN
#- Once the RN receives the responses for all the outstanding transactions from
HN, svt_chi_rn_transaction :: suspend_comp_ack is set to 0 for all the outstanding
transactions.
This ensures that the CompAck for these transactions can be resumed
from RN.
#- Check that the HN responds properly for all outstanding Read type transactions
and these are completed successfully.
.		 --
CHI_SYS_OUTSTANDING
* Outstanding transactions feature virtual sequences generate transactions from RN agents to verify the maximum outstanding transaction capability of a home node within the interconnect. Controls to specify the outstanding transaction limits of the targeted home node are provided in these sequences. The categories of transaction types covered include: Reads, Writes, Copyback, CMOs, Atomics.
CHI_OUTSTANDING_WR_TYPE
* Write type transaction specific flow control feature virtual sequences
 svt_chi_system_protocol_flow_ctrl_write_outstanding_diff_rn_diff_hn_virtual_sequence #- This sequence requires at least two HN nodes to be present in the Interconnect. #- This sequence requires two initiating active and participating RNs. #- If another active and participating RN-F exists, perform cache initialization to two randomly selected HNs. #- Initiate Write type transactions with svt_chi_rn_transaction :: suspend_wr_data set to 1 each from both the initiating RNs, 128 each to randomly selected two HNs from each of the RN in non blocking mode.
#- The addresses of these write transactions are such that:
  • Same as initialized cache line addresses if cache initialization is performed
  • Otherwise, random addresses targeting both the HNs
#- Once the RNs receive the responses for all the outstanding transactions from both of the HNs, svt_chi_rn_transaction :: suspend_wr_data is set to 0 for all the outstanding transactions.
This ensures that the NonCopyBackWrData for these transactions can be resumed from the RNs. #- Check that both of the HNs respond properly for all outstanding write type transactions and these are completed successfully. .		 txn_is_non_secure_access
Description-Unavailable
CHI_SYS_OUTSTANDING
* Outstanding transactions feature virtual sequences generate transactions from RN agents to verify the maximum outstanding transaction capability of a home node within the interconnect. Controls to specify the outstanding transaction limits of the targeted home node are provided in these sequences. The categories of transaction types covered include: Reads, Writes, Copyback, CMOs, Atomics.
CHI_OUTSTANDING_WR_TYPE
* Write type transaction specific flow control feature virtual sequences
 svt_chi_system_protocol_flow_ctrl_write_outstanding_diff_rn_same_hn_virtual_sequence #- This sequence requires at least one HN node to be present in the Interconnect. #- This sequence requires two initiating active and participating RN. #- If another active and participating RN-F exists, perform cache initialization to a randomly selected HN. #- Initiate 128 Write type transactions with svt_chi_rn_transaction :: suspend_wr_data set to 1 from each of the two initiating RNs to the randomly selected HN in non blocking mode.
#- The addresses of these write transactions are such that:
  • Same as initialized cache line addresses if cache initialization is performed
  • Otherwise, random addresses targeting the same HN
#- Once the RNs receive the responses for all the outstanding transactions from HN, svt_chi_rn_transaction :: suspend_wr_data is set to 0 for all the outstanding transactions.
This ensures that the NonCopyBackWrData for these transactions can be resumed from both the RNs. #- Check that the HN responds properly for all outstanding write type transactions and these are completed successfully. .		 --
CHI_SYS_OUTSTANDING
* Outstanding transactions feature virtual sequences generate transactions from RN agents to verify the maximum outstanding transaction capability of a home node within the interconnect. Controls to specify the outstanding transaction limits of the targeted home node are provided in these sequences. The categories of transaction types covered include: Reads, Writes, Copyback, CMOs, Atomics.
CHI_OUTSTANDING_WR_TYPE
* Write type transaction specific flow control feature virtual sequences
 svt_chi_system_protocol_flow_ctrl_write_outstanding_same_rn_same_hn_virtual_sequence #- This sequence requires at least one HN node to be present in the Interconnect. #- This sequence requires one initiating active and participating RN. #- If another active and participating RN-F exists, perform cache initialization to a randomly selected HN. #- Initiate maximum number of Write type transactions with svt_chi_rn_transaction :: suspend_wr_data set to 1 from initiating RN to randomly selected HN in non blocking mode.
#- The addresses of these write transactions are such that:
  • Same as initialized cache line addresses if cache initialization is performed
  • Otherwise, random addresses targeting the same HN
#- Once the RN receives the responses for all the outstanding transactions from HN, svt_chi_rn_transaction :: suspend_wr_data is set to 0 for all the outstanding transactions.
This ensures that the NonCopyBackWrData for these transactions can be resumed from RN. #- Check that the HN responds properly for all outstanding write type transactions and these are completed successfully. .		 --
CHI_SYS_OUTSTANDING
* Outstanding transactions feature virtual sequences generate transactions from RN agents to verify the maximum outstanding transaction capability of a home node within the interconnect. Controls to specify the outstanding transaction limits of the targeted home node are provided in these sequences. The categories of transaction types covered include: Reads, Writes, Copyback, CMOs, Atomics.
CHI_OUTSTANDING_CPBK_TYPE
* CopyBack type transaction specific flow control feature virtual sequences
 svt_chi_system_protocol_flow_ctrl_copyback_outstanding_diff_rn_diff_hn_virtual_sequence #- This sequence requires atleast two HN nodes to be present in the Interconnect. #- This sequence requires atleast two initiating active and participating RN-Fs. #- Inititate maximum number of MAKEUNIQUE transactions from existing active and participating different RN-Fs, to perform cache initialization to a randomly selected different HNs. #- Initiate maximum number of COPYBACK type transactions with svt_chi_rn_transaction :: suspend_wr_data set to 1 from initiating RN-Fs to randomly selected HNs in non blocking mode.
#- The addresses of these COPYBACK transactions are such that:
  • Same as initialized cache line addresses if cache initialization is performed
#- The RN-Fs of these COPYBACK transactions are such that:
  • Same as RN-Fs from which cache initialization is performed
#- Once the RN-Fs receives the responses for all the outstanding transactions from HNs, svt_chi_rn_transaction :: suspend_wr_data is set to 0 for all the outstanding transactions.
This ensures that the CopyBackWrData for these transactions can be resumed from RN-Fs. #- Check that the HNs responds properly for all outstanding COPYBACK type transactions and these are completed successfully. . #- This sequence does not support EVICT and WRITEEVICTFULL transactions.
 --
CHI_SYS_OUTSTANDING
* Outstanding transactions feature virtual sequences generate transactions from RN agents to verify the maximum outstanding transaction capability of a home node within the interconnect. Controls to specify the outstanding transaction limits of the targeted home node are provided in these sequences. The categories of transaction types covered include: Reads, Writes, Copyback, CMOs, Atomics.
CHI_OUTSTANDING_CPBK_TYPE
* CopyBack type transaction specific flow control feature virtual sequences
 svt_chi_system_protocol_flow_ctrl_copyback_outstanding_diff_rn_same_hn_virtual_sequence #- This sequence requires atleast one HN node to be present in the Interconnect. #- This sequence requires atleast two initiating active and participating RN-Fs. #- Inititate maximum number of MAKEUNIQUE transactions from existing active and participating different RN-Fs, to perform cache initialization to a randomly selected HN. #- Initiate maximum number of COPYBACK type transactions with svt_chi_rn_transaction :: suspend_wr_data set to 1 from initiating RN-Fs to randomly selected HN in non blocking mode.
#- The addresses of these COPYBACK transactions are such that:
  • Same as initialized cache line addresses if cache initialization is performed
#- The RN-Fs of these COPYBACK transactions are such that:
  • Same as RN-Fs from which cache initialization is performed
#- Once the RN-Fs receives the responses for all the outstanding transactions from the HN, svt_chi_rn_transaction :: suspend_wr_data is set to 0 for all the outstanding transactions.
This ensures that the CopyBackWrData for these transactions can be resumed from RN-Fs. #- Check that the HN responds properly for all outstanding COPYBACK type transactions and these are completed successfully. . #- This sequence does not support EVICT and WRITEEVICTFULL transactions.
 --
CHI_SYS_OUTSTANDING
* Outstanding transactions feature virtual sequences generate transactions from RN agents to verify the maximum outstanding transaction capability of a home node within the interconnect. Controls to specify the outstanding transaction limits of the targeted home node are provided in these sequences. The categories of transaction types covered include: Reads, Writes, Copyback, CMOs, Atomics.
CHI_OUTSTANDING_CPBK_TYPE
* CopyBack type transaction specific flow control feature virtual sequences
 svt_chi_system_protocol_flow_ctrl_copyback_outstanding_same_rn_same_hn_virtual_sequence #- This sequence requires atleast one HN node to be present in the Interconnect. #- This sequence requires atleast one initiating active and participating RN-F. #- Inititate maximum number of MAKEUNIQUE transactions from existing active and participating RN-F, to perform cache initialization to a randomly selected HN. #- Initiate maximum number of COPYBACK type transactions with svt_chi_rn_transaction :: suspend_wr_data set to 1 from the initiating RN-F to the randomly selected HN in non blocking mode.
#- The addresses of these COPYBACK transactions are such that:
  • Same as initialized cache line addresses if cache initialization is performed
#- The RN-F of these COPYBACK transactions are such that:
  • Same as RN-F from which cache initialization is performed
#- Once the RN-F receives the responses for all the outstanding transactions from HN, svt_chi_rn_transaction :: suspend_wr_data is set to 0 for all the outstanding transactions.
This ensures that the CopyBackWrData for these transactions can be resumed from RN-F. #- Check that the HN responds properly for all outstanding COPYBACK type transactions and these are completed successfully. . #- This sequence does not support EVICT and WRITEEVICTFULL transactions.
 --
CHI_SYS_OUTSTANDING
* Outstanding transactions feature virtual sequences generate transactions from RN agents to verify the maximum outstanding transaction capability of a home node within the interconnect. Controls to specify the outstanding transaction limits of the targeted home node are provided in these sequences. The categories of transaction types covered include: Reads, Writes, Copyback, CMOs, Atomics.
CHI_OUTSTANDING_CMO_TYPE
* CMO type transaction specific flow control feature virtual sequences
 svt_chi_system_protocol_flow_ctrl_cmo_outstanding_diff_rn_diff_hn_virtual_sequence #- This sequence requires at least two HN nodes to be present in the Interconnect.
#- This sequence requires two initiating active and participating RN.
#- If another active and participating RN-F exists, perform cache
initialization to a randomly selected different HN's.
#- Initiate maximum number of CMO type transactions with svt_chi_rn_transaction::
suspend_comp_ack set to 1 from selected initiating RN to randomly selected
different HN's in non blocking mode.
#- The addresses of these CMO transactions are such that:
  • Same as initialized cache line addresses if cache initialization is performed
  • Otherwise, random addresses targeting the different HN's
#- Once the selected RN receives the responses for all the outstanding transactions
from selected HN, svt_chi_rn_transaction :: suspend_comp_ack is set to 0 for all the
outstanding transactions.
This ensures that the CompAck for these transactions can be resumed
from selected RN.
#- Check that the selected HN responds properly for all outstanding CMO type
transactions and these are completed successfully.
.		 --
CHI_SYS_OUTSTANDING
* Outstanding transactions feature virtual sequences generate transactions from RN agents to verify the maximum outstanding transaction capability of a home node within the interconnect. Controls to specify the outstanding transaction limits of the targeted home node are provided in these sequences. The categories of transaction types covered include: Reads, Writes, Copyback, CMOs, Atomics.
CHI_OUTSTANDING_CMO_TYPE
* CMO type transaction specific flow control feature virtual sequences
 svt_chi_system_protocol_flow_ctrl_cmo_outstanding_diff_rn_same_hn_virtual_sequence #- This sequence requires at least one HN node to be present in the Interconnect.
#- This sequence requires two initiating active and participating RN.
#- If another active and participating RN-F exists, perform cache
initialization to a randomly selected HN.
#- Initiate max_num_outstanding_cmo_xacts_at_hn/2 or max_num_outstanding_xacts_at_hn/2 number of CMO type transactions with svt_chi_rn_transaction::
suspend_comp_ack set to 1 from selected initiating RN to randomly selected HN
in non blocking mode.
#- The addresses of these CMO transactions are such that:
  • Same as initialized cache line addresses if cache initialization is performed
  • Otherwise, random addresses targeting the same HN
#- Once the selected RN receives the responses for all the outstanding transactions
from HN, svt_chi_rn_transaction :: suspend_comp_ack is set to 0 for all the
outstanding transactions.
This ensures that the CompAck for these transactions can be resumed
from selected RN.
#- Check that the HN responds properly for all outstanding CMO type transactions
and these are completed successfully.
.		 --
CHI_SYS_OUTSTANDING
* Outstanding transactions feature virtual sequences generate transactions from RN agents to verify the maximum outstanding transaction capability of a home node within the interconnect. Controls to specify the outstanding transaction limits of the targeted home node are provided in these sequences. The categories of transaction types covered include: Reads, Writes, Copyback, CMOs, Atomics.
CHI_OUTSTANDING_CMO_TYPE
* CMO type transaction specific flow control feature virtual sequences
 svt_chi_system_protocol_flow_ctrl_cmo_outstanding_same_rn_same_hn_virtual_sequence #- This sequence requires at least one HN node to be present in the Interconnect.
#- This sequence requires one initiating active and participating RN.
#- If another active and participating RN-F exists, perform cache
initialization to a randomly selected HN.
#- Initiate maximum number of CMO type transactions with
svt_chi_rn_transaction :: suspend_comp_ack set to 1 from initiating RN to randomly
selected HN in non blocking mode.
#- The addresses of these CMO transactions are such that:
  • Same as initialized cache line addresses if cache initialization is performed
  • Otherwise, random addresses targeting the same HN
#- Once the RN receives the responses for all the outstanding transactions from
HN, svt_chi_rn_transaction :: suspend_comp_ack is set to 0 for all the outstanding
transactions.
This ensures that the CompAck for these transactions can be resumed
from RN.
#- Check that the HN responds properly for all outstanding CMO type transactions
and these are completed successfully.
.		 --
CHI_SYS_OUTSTANDING
* Outstanding transactions feature virtual sequences generate transactions from RN agents to verify the maximum outstanding transaction capability of a home node within the interconnect. Controls to specify the outstanding transaction limits of the targeted home node are provided in these sequences. The categories of transaction types covered include: Reads, Writes, Copyback, CMOs, Atomics.
CHI_OUTSTANDING_ATOMIC_TYPE
* Atomic type transaction specific flow control feature virtual sequences
 svt_chi_system_protocol_flow_ctrl_atomic_outstanding_diff_rn_diff_hn_virtual_sequence #- This sequence requires at least two HN nodes to be present in the Interconnect. #- This sequence requires two initiating active and participating RNs. #- If another active and participating RN-F exists, perform cache initialization to two randomly selected HNs. #- Initiate Atomic type transactions with svt_chi_rn_transaction :: suspend_wr_data set to 1 each from both the initiating RNs, 128 each to randomly selected two HNs from each of the RN in non blocking mode.
#- The addresses of these atomic transactions are such that:
  • Same as initialized cache line addresses if cache initialization is performed
  • Otherwise, random addresses targeting both the HNs
#- Once the RNs receive the responses for all the outstanding transactions from both of the HNs, svt_chi_rn_transaction :: suspend_wr_data is set to 0 for all the outstanding transactions.
This ensures that the NonCopyBackWrData for these transactions can be resumed from the RNs. #- Check that both of the HNs respond properly for all outstanding atomic type transactions and these are completed successfully. .		 --
CHI_SYS_OUTSTANDING
* Outstanding transactions feature virtual sequences generate transactions from RN agents to verify the maximum outstanding transaction capability of a home node within the interconnect. Controls to specify the outstanding transaction limits of the targeted home node are provided in these sequences. The categories of transaction types covered include: Reads, Writes, Copyback, CMOs, Atomics.
CHI_OUTSTANDING_ATOMIC_TYPE
* Atomic type transaction specific flow control feature virtual sequences
 svt_chi_system_protocol_flow_ctrl_atomic_outstanding_diff_rn_same_hn_virtual_sequence #- This sequence requires at least one HN node to be present in the Interconnect. #- This sequence requires two initiating active and participating RN. #- If another active and participating RN-F exists, perform cache initialization to a randomly selected HN. #- Initiate 128 Atomic type transactions with svt_chi_rn_transaction :: suspend_wr_data set to 1 from each of the two initiating RNs to the randomly selected HN in non blocking mode.
#- The addresses of these atomic transactions are such that:
  • Same as initialized cache line addresses if cache initialization is performed
  • Otherwise, random addresses targeting the same HN
#- Once the RNs receive the responses for all the outstanding transactions from HN, svt_chi_rn_transaction :: suspend_wr_data is set to 0 for all the outstanding transactions.
This ensures that the NonCopyBackWrData for these transactions can be resumed from both the RNs. #- Check that the HN responds properly for all outstanding atomic type transactions and these are completed successfully. .		 --
CHI_SYS_OUTSTANDING
* Outstanding transactions feature virtual sequences generate transactions from RN agents to verify the maximum outstanding transaction capability of a home node within the interconnect. Controls to specify the outstanding transaction limits of the targeted home node are provided in these sequences. The categories of transaction types covered include: Reads, Writes, Copyback, CMOs, Atomics.
CHI_OUTSTANDING_ATOMIC_TYPE
* Atomic type transaction specific flow control feature virtual sequences
 svt_chi_system_protocol_flow_ctrl_atomic_outstanding_same_rn_same_hn_virtual_sequence #- This sequence requires at least one HN node to be present in the Interconnect. #- This sequence requires one initiating active and participating RN. #- If another active and participating RN-F exists, perform cache initialization to a randomly selected HN. #- Initiate maximum number of Atomic type transactions with svt_chi_rn_transaction :: suspend_wr_data set to 1 from initiating RN to randomly selected HN in non blocking mode.
#- The addresses of these atomic transactions are such that:
  • Same as initialized cache line addresses if cache initialization is performed
  • Otherwise, random addresses targeting the same HN
#- Once the RN receives the responses for all the outstanding transactions from HN, svt_chi_rn_transaction :: suspend_wr_data is set to 0 for all the outstanding transactions.
This ensures that the NonCopyBackWrData for these transactions can be resumed from RN. #- Check that the HN responds properly for all outstanding atomic type transactions and these are completed successfully. .		 --
CHI_SYS_FLOW_CTRL
* Flow control feature virtual sequences generate transactions with same Transaction ID from one or more RN agents to verify flow control protocol requirements of a home node within the interconnect. Transaction types covered include: Reads, Writes, Copyback, CMOs. Also PrefetchTarget transaction type mixed with reads and writes are generated with controllable aspects for Transaction ID values.
CHI_FLOW_CTRL_RD_TYPE
* Read type transaction specific flow control feature virtual sequences
 svt_chi_system_protocol_flow_ctrl_read_resp_same_txnid_diff_rn_diff_hn_virtual_sequence #- Optionally program a randomly selected RN to send two MAKEUNIQUE transaction targeted to
randomly selected different target IDs when number of RN-F is 3 or more incase of RN-F test
or number of RN-F is atleast 1 incase of RN-I test.
#- Program other two randomly selected RNs to send a read type coherent transaction
with same TxnID simultaneously to above selected different target IDs of MAKEUNIQUE transactions if MAKEQNIQUE transaction is sent for initilization.
#- If MAKEQNIQUE transaction is not sent for initilization program two randomly
selected different RNs to send a read type coherent transaction with same TxnID simultaneously
to randomly selected different target IDs.
#- Check that the HN's responds with same TxnId to respective RNs.
.		 --
CHI_SYS_FLOW_CTRL
* Flow control feature virtual sequences generate transactions with same Transaction ID from one or more RN agents to verify flow control protocol requirements of a home node within the interconnect. Transaction types covered include: Reads, Writes, Copyback, CMOs. Also PrefetchTarget transaction type mixed with reads and writes are generated with controllable aspects for Transaction ID values.
CHI_FLOW_CTRL_RD_TYPE
* Read type transaction specific flow control feature virtual sequences
 svt_chi_system_protocol_flow_ctrl_read_resp_same_txnid_diff_rn_same_hn_virtual_sequence #- Optionally program a randomly selected RN to send two MAKEUNIQUE transaction targeted to
randomly selected same target IDs when number of RN_F is 3 or more incase of RN_F test
or number of RN_F is atleast 1 incase of RN_I test.
#- Program other two randomly selected RNs to send a read type coherent transaction
with same TxnID simultaneously to above selected same target IDs of MAKEUNIQUE transactions if MAKEQNIQUE transaction is sent for initilization.
#- If MAKEQNIQUE transaction is not sent for initilization program two randomly
selected different RNs to send a read type coherent transaction with same TxnID simultaneously
to randomly selected same target IDs.
#- Check that the HN's responds with same TxnId to respective RNs.
.		 --
CHI_SYS_FLOW_CTRL
* Flow control feature virtual sequences generate transactions with same Transaction ID from one or more RN agents to verify flow control protocol requirements of a home node within the interconnect. Transaction types covered include: Reads, Writes, Copyback, CMOs. Also PrefetchTarget transaction type mixed with reads and writes are generated with controllable aspects for Transaction ID values.
CHI_FLOW_CTRL_WR_TYPE
* Write type transaction specific flow control feature virtual sequences
 svt_chi_system_protocol_flow_ctrl_write_resp_same_txnid_diff_rn_diff_hn_virtual_sequence #- Program two MAKEUNIQUE transaction from one randomly selected RN targeted to different HN.
#- Program two randomly selected different RN VIP to drive a write transaction with same
Txnid simultaneously to randomly selected different HN Nodes of
MAKEUNIQUE transactions.
#- Check the HN responds with same Txnid to respective RN's.
.		 --
CHI_SYS_FLOW_CTRL
* Flow control feature virtual sequences generate transactions with same Transaction ID from one or more RN agents to verify flow control protocol requirements of a home node within the interconnect. Transaction types covered include: Reads, Writes, Copyback, CMOs. Also PrefetchTarget transaction type mixed with reads and writes are generated with controllable aspects for Transaction ID values.
CHI_FLOW_CTRL_WR_TYPE
* Write type transaction specific flow control feature virtual sequences
 svt_chi_system_protocol_flow_ctrl_write_resp_same_txnid_diff_rn_same_hn_virtual_sequence #- Program two MAKEUNIQUE transaction from one randomly selected RN targeted to same HN.
#- Program two randomly selected different RN VIP to drive a write transaction with same
Txnid simultaneously to randomly selected same HN Nodes of
MAKEUNIQUE transactions.
#- Check the HN responds with same Txnid to respective RN's.
.		 --
CHI_SYS_FLOW_CTRL
* Flow control feature virtual sequences generate transactions with same Transaction ID from one or more RN agents to verify flow control protocol requirements of a home node within the interconnect. Transaction types covered include: Reads, Writes, Copyback, CMOs. Also PrefetchTarget transaction type mixed with reads and writes are generated with controllable aspects for Transaction ID values.
CHI_FLOW_CTRL_WR_TYPE
* Write type transaction specific flow control feature virtual sequences
 svt_chi_system_protocol_flow_ctrl_writeunique_suspend_compack_virtual_sequence #- This sequence requires at least one HN node to be present in the Interconnect.
#- This sequence requires one initiating active and participating RN.
#- Initiate WRITEUNIQUEFULL/WRITEUNIQUEPTL type transactions with
svt_chi_rn_transaction :: suspend_comp_ack set to 1 from initiating RN.
#- Wait for the Initiating RN to transmit the DATA flits without waiting for Compack
#- Resume the suspended Compack after the DATA flits are transmitted.
  • This ensures that the expcompack s sent after all the DATA flits are transmitted on to interface.
.		 --
CHI_SYS_FLOW_CTRL
* Flow control feature virtual sequences generate transactions with same Transaction ID from one or more RN agents to verify flow control protocol requirements of a home node within the interconnect. Transaction types covered include: Reads, Writes, Copyback, CMOs. Also PrefetchTarget transaction type mixed with reads and writes are generated with controllable aspects for Transaction ID values.
CHI_FLOW_CTRL_CPBK_TYPE
* CopyBack type transaction specific flow control feature virtual sequences
 svt_chi_system_protocol_flow_ctrl_copyback_resp_same_txnid_diff_rn_diff_hn_virtual_sequence #- Program the any two randomly selected RNs to drive a MakeUnique transaction targeted
to randomly selected different HN.
#- Program the above selected RNs to drive a CopyBack transactions simultaneously with
same TxnId and address same as of MakeUnique transactions.
#- Check the HN responds with same Txnid to respective RN's.
#- Program a randomly selected RN to drive a ReadShared transaction to verify CopyBack
transaction.
. #- This sequence does not support EVICT and WRITEEVICTFULL transactions.
 --
CHI_SYS_FLOW_CTRL
* Flow control feature virtual sequences generate transactions with same Transaction ID from one or more RN agents to verify flow control protocol requirements of a home node within the interconnect. Transaction types covered include: Reads, Writes, Copyback, CMOs. Also PrefetchTarget transaction type mixed with reads and writes are generated with controllable aspects for Transaction ID values.
CHI_FLOW_CTRL_CPBK_TYPE
* CopyBack type transaction specific flow control feature virtual sequences
 svt_chi_system_protocol_flow_ctrl_copyback_resp_same_txnid_diff_rn_same_hn_virtual_sequence #- Program the any two randomly selected RNs to drive a MakeUnique transaction targeted
to randomly selected same HN.
#- Program the above selected RNs to drive a CopyBack transactions simultaneously with
same TxnId and address same as of MakeUnique transactions.
#- Check the HN responds with same Txnid to respective RN's.
#- Program a randomly selected RN to drive a ReadShared transaction to verify CopyBack
transaction.
. #- This sequence does not support EVICT and WRITEEVICTFULL transactions.
 --
CHI_SYS_FLOW_CTRL
* Flow control feature virtual sequences generate transactions with same Transaction ID from one or more RN agents to verify flow control protocol requirements of a home node within the interconnect. Transaction types covered include: Reads, Writes, Copyback, CMOs. Also PrefetchTarget transaction type mixed with reads and writes are generated with controllable aspects for Transaction ID values.
CHI_FLOW_CTRL_CMO_TYPE
* CMO type transaction specific flow control feature virtual sequences
 svt_chi_system_protocol_flow_ctrl_cmo_resp_same_txnid_diff_rn_diff_hn_virtual_sequence #- Program two MakeUnique transactions from one randomly selected RN_F targeted to
different HN Nodes.
#- Program two randomly selected different RN VIP to drive any CMO type transaction
with same Txnid simultaneously to above selected same HN Nodes of
MakeUnique transactions.
#- Check the HN's respond with same Txnid to respective RN's.
#- For CleanShared, CleanInvalid transactions, Program Read transactions from
above first selected RN_F to compare Read data with data of above MakeUnique
transactions
.		 --
CHI_SYS_FLOW_CTRL
* Flow control feature virtual sequences generate transactions with same Transaction ID from one or more RN agents to verify flow control protocol requirements of a home node within the interconnect. Transaction types covered include: Reads, Writes, Copyback, CMOs. Also PrefetchTarget transaction type mixed with reads and writes are generated with controllable aspects for Transaction ID values.
CHI_FLOW_CTRL_CMO_TYPE
* CMO type transaction specific flow control feature virtual sequences
 svt_chi_system_protocol_flow_ctrl_cmo_resp_same_txnid_diff_rn_same_hn_virtual_sequence #- Program two MakeUnique transactions from one randomly selected RN_F targeted to
same HN Node.
#- Program two randomly selected different RN VIP to drive any CMO type transaction
with same Txnid simultaneously to above selected same HN Node of MakeUnique
transactions.
#- Check the HN responds with same Txnid to respective RN's.
#- For CleanShared, CleanInvalid transactions, Program Read transactions from
above first selected RN_F to compare Read data with data of above MakeUnique
transactions
.		 --
CHI_SYS_FLOW_CTRL
* Flow control feature virtual sequences generate transactions with same Transaction ID from one or more RN agents to verify flow control protocol requirements of a home node within the interconnect. Transaction types covered include: Reads, Writes, Copyback, CMOs. Also PrefetchTarget transaction type mixed with reads and writes are generated with controllable aspects for Transaction ID values.
CHI_FLOW_CTRL_PREFETCHTGT_TYPE
* PREFETCHTGT type transaction specific flow control feature virtual sequences
 svt_chi_system_protocol_flow_ctrl_prefetchtgt_read_outstanding_virtual_sequence #- This sequence requires at least one HN node to be present in the Interconnect. #- This sequence requires one initiating active and participating RN. #- If another active and participating RN-F exists, perform cache initialization to a randomly selected HN. #- Initiate a Read type transactions with
svt_chi_rn_transaction :: suspend_comp_ack set to 1 from initiating RN to randomly selected HN in non blocking mode.
#- Initiate a PREFETCHTGT type transaction to the same address of read transaction address.
  • Txn_id of a PREFETCHTGT transaction is set to below values based on sel_txnid_type_enum, which can be controlled through config DB or random value by default
    • when sel_txnid_type_enum == TXNID_SAME_AS_PREFETCHTGT i.e txn_id is same as read transaction txn_id
    • when sel_txnid_type_enum == TXNID_NOT_SAME_AS_PREFETCHTGT i.e txn_id is not same as read transaction txn_id
#- Wait for the PREFETCHTGT transaction to end, Once it ends svt_chi_rn_transaction :: suspend_comp_ack is set to 0 for the outstanding read transaction.
This ensures that the CompAck for the above Read transaction can be resumed
from RN.

#- Check that the HN responds properly for PREFETCHTGT and Read transactions and these are completed successfully. .

 sel_txnid_type
Description-Unavailable
CHI_SYS_FLOW_CTRL
* Flow control feature virtual sequences generate transactions with same Transaction ID from one or more RN agents to verify flow control protocol requirements of a home node within the interconnect. Transaction types covered include: Reads, Writes, Copyback, CMOs. Also PrefetchTarget transaction type mixed with reads and writes are generated with controllable aspects for Transaction ID values.
CHI_FLOW_CTRL_PREFETCHTGT_TYPE
* PREFETCHTGT type transaction specific flow control feature virtual sequences
 svt_chi_system_protocol_flow_ctrl_prefetchtgt_write_outstanding_virtual_sequence #- This sequence requires at least one HN node to be present in the Interconnect. #- This sequence requires one initiating active and participating RN. #- If another active and participating RN-F exists, perform cache initialization to a randomly selected HN. #- Initiate a Write type transactions with svt_chi_rn_transaction :: suspend_wr_data set to 1 from initiating RN to randomly selected HN in non blocking mode.
#- Initiate a PREFETCHTGT type transaction to the same address of write transaction address.
  • Txn_id of a PREFETCHTGT transaction is set to below values based on sel_txnid_type_enum, which can be controlled through config DB or random value by default
    • when sel_txnid_type_enum == TXNID_SAME_AS_PREFETCHTGT i.e txn_id is same as Write transaction txn_id
    • when sel_txnid_type_enum == TXNID_NOT_SAME_AS_PREFETCHTGT i.e txn_id is not same as Write transaction txn_id
#- Wait for the PREFETCHTGT transaction to end, Once it ends svt_chi_rn_transaction :: suspend_wr_data is set to 0 for the outstanding write transaction.
This ensures that the NonCopyBackWrData for the above write transaction can be resumed from RN.

#- Check that the HN responds properly for PREFETCHTGT and Write transactions and these are completed successfully. .

 sel_txnid_type
Description-Unavailable
CHI_SYS_SINGLE_RN
* Transaction specific single node virtual sequences generates a given transaction type from a single RN agent. All the transaction types are covered, with controllable aspects such as selecting the initiating RN, addressing mode.
CHI_SINGLE_RN_BASE
* Base sequence for transaction specific single node virtual sequences
 svt_chi_system_single_node_rn_coherent_transaction_base_virtual_sequence Base sequence for all the single node RN coherent transaction type derived virtual sequences.
If node_index is programmed through config DB, the value of node_index gets priority over the results of the below settings. If a given derived RN coherent transaction virtual sequence can be initiated from either RN-F or RN-I or both types of nodes as per CHI specification, the following controls can be used from the test through config DB programming.
  • select_rn_f_node: When set to 1, randomly one of the active and participating RN-F nodes will be the initiator.
  • select_rn_i_node: When set to 1, randomly one of the active and participating RN-I nodes will be the initiator.
  • select_rn_d_node: When set to 1, randomly one of the active and participating RN-D nodes will be the initiator.
  • If select_rn_f_node, select_rn_d_node and select_rn_i_node are together 1 or 0: randomly one of the active and participating RN-F/RN-I nodes will be the initiator.
Following is the user interface for programming the address ranges. This is supported currently only for single non coherent transaction type sequences. Note that both these attributes need to be programmed together through config DB. The address generated will be in the range [start_addr:end_addr]. It is required to ensure that start_addr <= end_addr. Typically, this can be used to target the address ranges that correspond to HN-I. Note that when hn_index is programmed using config DB, the start_addr and end_addr values will be ignored. Refer to documentation of hn_index.
  • start_addr: Start address for the address range
  • end_addr: End address range for the address range
Following is the user interface to generate transactions to a given Home Node index. This is supported currently only for single non coherent transaction type sequences. Note that when this attribute is programmed through config DB, values of start_addr and end_addr will be ignored.
  • hn_index: Index of home node to which transactions should be generated to
node_index
Represents the RN from which the sequence will be initiated. This can be controlled through config DB.

CHI_SYS_SINGLE_RN
* Transaction specific single node virtual sequences generates a given transaction type from a single RN agent. All the transaction types are covered, with controllable aspects such as selecting the initiating RN, addressing mode.
CHI_SINGLE_RN_RD_TYPE
* Read type transaction specific single node virtual sequences
 svt_chi_system_single_node_cleanunique_virtual_sequence This sequence initiates CleanUnique transaction from the RN-F node specified with node_index, which can be a random node or a specific node configured by the user. Before sending each CleanUnique transaction, cachelines of peer node are initialized to random, valid states. --
CHI_SYS_SINGLE_RN
* Transaction specific single node virtual sequences generates a given transaction type from a single RN agent. All the transaction types are covered, with controllable aspects such as selecting the initiating RN, addressing mode.
CHI_SINGLE_RN_RD_TYPE
* Read type transaction specific single node virtual sequences
 svt_chi_system_single_node_makeunique_virtual_sequence This sequence initiates MakeUique transaction from the RN-F node specified with node_index, which can be a random node or a specific node configured by the user. Before sending each MakeUnique transaction, cachelines of peer node are initialized to random, valid states. --
CHI_SYS_SINGLE_RN
* Transaction specific single node virtual sequences generates a given transaction type from a single RN agent. All the transaction types are covered, with controllable aspects such as selecting the initiating RN, addressing mode.
CHI_SINGLE_RN_RD_TYPE
* Read type transaction specific single node virtual sequences
 svt_chi_system_single_node_readclean_virtual_sequence This sequence initiates ReadClean transaction from the RN-F node specified with node_index, which can be a random node or a specific node configured by the user. Before sending each ReadShard transaction, cachelines of peer node are initialized to random, valid states. --
CHI_SYS_SINGLE_RN
* Transaction specific single node virtual sequences generates a given transaction type from a single RN agent. All the transaction types are covered, with controllable aspects such as selecting the initiating RN, addressing mode.
CHI_SINGLE_RN_RD_TYPE
* Read type transaction specific single node virtual sequences
 svt_chi_system_single_node_readnosnp_virtual_sequence This sequence initiates ReadNoSnp transaction from the RN node specified with node_index, which can be a random node or a specific node configured by the user. Before sending each ReadNoSnp transaction, cachelines of peer node are initialized to random, valid states. --
CHI_SYS_SINGLE_RN
* Transaction specific single node virtual sequences generates a given transaction type from a single RN agent. All the transaction types are covered, with controllable aspects such as selecting the initiating RN, addressing mode.
CHI_SINGLE_RN_RD_TYPE
* Read type transaction specific single node virtual sequences
 svt_chi_system_single_node_readonce_virtual_sequence This sequence initiates ReadOnce transaction from the RN-F node specified with node_index, which can be a random node or a specific node configured by the user. Before sending each ReadOnce transaction, cachelines of peer node are initialized to random, valid states. --
CHI_SYS_SINGLE_RN
* Transaction specific single node virtual sequences generates a given transaction type from a single RN agent. All the transaction types are covered, with controllable aspects such as selecting the initiating RN, addressing mode.
CHI_SINGLE_RN_RD_TYPE
* Read type transaction specific single node virtual sequences
 svt_chi_system_single_node_readshared_virtual_sequence This sequence initiates ReadShared transaction from the RN-F node specified with node_index, which can be a random node or a specific node configured by the user. Before sending each ReadShard transaction, cachelines of peer node are initialized to random, valid states. --
CHI_SYS_SINGLE_RN
* Transaction specific single node virtual sequences generates a given transaction type from a single RN agent. All the transaction types are covered, with controllable aspects such as selecting the initiating RN, addressing mode.
CHI_SINGLE_RN_RD_TYPE
* Read type transaction specific single node virtual sequences
 svt_chi_system_single_node_readunique_virtual_sequence This sequence initiates ReadUnique transaction from the RN-F node specified with node_index, which can be a random node or a specific node configured by the user. Before sending each ReadUnique transaction, cachelines of peer node are initialized to random, valid states. --
CHI_SYS_SINGLE_RN
* Transaction specific single node virtual sequences generates a given transaction type from a single RN agent. All the transaction types are covered, with controllable aspects such as selecting the initiating RN, addressing mode.
CHI_SINGLE_RN_PFT_TYPE
* CHI-B PrefetchTarget type transaction specific single node virtual sequences
 svt_chi_system_single_node_prefetchtgt_virtual_sequence This sequence initiates prefetchtgt transactions from specified node_index, which can be a random node or a specific node configured by the user. --
CHI_SYS_SINGLE_RN
* Transaction specific single node virtual sequences generates a given transaction type from a single RN agent. All the transaction types are covered, with controllable aspects such as selecting the initiating RN, addressing mode.
CHI_B_SINGLE_RN_RD_TYPE
* CHI-B Read type transaction specific single node virtual sequences
 svt_chi_system_single_node_readnotshareddirty_virtual_sequence This sequence initiates ReadNotSharedDirty transaction from the RN-F node specified with node_index, which can be a random node or a specific node configured by the user. Before sending each ReadShard transaction, cachelines of peer node are initialized to random, valid states. --
CHI_SYS_SINGLE_RN
* Transaction specific single node virtual sequences generates a given transaction type from a single RN agent. All the transaction types are covered, with controllable aspects such as selecting the initiating RN, addressing mode.
CHI_B_SINGLE_RN_RD_TYPE
* CHI-B Read type transaction specific single node virtual sequences
 svt_chi_system_single_node_readoncecleaninvalid_virtual_sequence This sequence initiates ReadOnceCleanInvalid transaction from the RN-F node specified with node_index, which can be a random node or a specific node configured by the user. Before sending each ReadOnceCleanInvalid transaction, cachelines of peer node are initialized to random, valid states. --
CHI_SYS_SINGLE_RN
* Transaction specific single node virtual sequences generates a given transaction type from a single RN agent. All the transaction types are covered, with controllable aspects such as selecting the initiating RN, addressing mode.
CHI_B_SINGLE_RN_RD_TYPE
* CHI-B Read type transaction specific single node virtual sequences
 svt_chi_system_single_node_readoncemakeinvalid_virtual_sequence This sequence initiates ReadOnceMakeInvalid transaction from the RN-F node specified with node_index, which can be a random node or a specific node configured by the user. Before sending each ReadOnceMakeInvalid transaction, cachelines of peer node are initialized to random, valid states. --
CHI_SYS_SINGLE_RN
* Transaction specific single node virtual sequences generates a given transaction type from a single RN agent. All the transaction types are covered, with controllable aspects such as selecting the initiating RN, addressing mode.
CHI_B_SINGLE_RN_RD_TYPE
* CHI-B Read type transaction specific single node virtual sequences
 svt_chi_system_single_node_readspec_virtual_sequence This sequence initiates ReadSpec transaction from the RN-F node specified with node_index, which can be a random node or a specific node configured by the user. Before sending each ReadSpec transaction, cachelines of peer node are initialized to random, valid states. --
CHI_SYS_SINGLE_RN
* Transaction specific single node virtual sequences generates a given transaction type from a single RN agent. All the transaction types are covered, with controllable aspects such as selecting the initiating RN, addressing mode.
CHI_B_SINGLE_RN_CMO_TYPE
* CHI-B CMO type transaction specific single node virtual sequences
 svt_chi_system_single_node_cleansharedpersist_virtual_sequence This sequence initiates CleanSharedPersist transaction from the RN node specified with node_index, which can be a random node or a specific node configured by the user. Before sending each CleanSharedPersist transaction, cachelines of peer node are initialized to random, valid states. --
CHI_SYS_SINGLE_RN
* Transaction specific single node virtual sequences generates a given transaction type from a single RN agent. All the transaction types are covered, with controllable aspects such as selecting the initiating RN, addressing mode.
CHI_SINGLE_RN_ATOMICSTORE_TYPE
* CHI-B AtomicStore type transaction specific single node virtual sequence
 svt_chi_system_single_node_atomicstore_transaction_virtual_sequence #- This sequence requires one initiating active and participating RN-F.
#- If one or more active and participating RN-F exists, perform cache
initialization to a randomly selected HN.
#- Program the RN to initiate random Atomic Store transaction from randomly selected RN_F.
.		 --
CHI_SYS_SINGLE_RN
* Transaction specific single node virtual sequences generates a given transaction type from a single RN agent. All the transaction types are covered, with controllable aspects such as selecting the initiating RN, addressing mode.
CHI_SINGLE_RN_ATOMICSTORE_TYPE
* CHI-B AtomicStore type transaction specific single node virtual sequence
 svt_chi_system_single_node_rn_atomic_transaction_ordering_virtual_sequence #- This sequence requires one initiating active and participating RN-F.
#- If one or more active and participating RN-F exists, perform cache
initialization to a randomly selected HN.
#- Program the RN to initiate random Atomic transaction from randomly selected RN_F
with order_type set to REQ_ORDERING_REQUIRED.
.		 selected_atomic_xact_type
Description-Unavailable
CHI_SYS_SINGLE_RN
* Transaction specific single node virtual sequences generates a given transaction type from a single RN agent. All the transaction types are covered, with controllable aspects such as selecting the initiating RN, addressing mode.
CHI_SINGLE_RN_ATOMICLOAD_TYPE
* CHI-B AtomicLoad type transaction specific single node virtual sequence
 svt_chi_system_single_node_atomicload_transaction_virtual_sequence #- This sequence requires one initiating active and participating RN-F.
#- If one or more active and participating RN-F exists, perform cache
initialization to a randomly selected HN.
#- Program the RN to initiate random Atomic Load transaction from randomly selected RN_F.
.		 --
CHI_SYS_SINGLE_RN
* Transaction specific single node virtual sequences generates a given transaction type from a single RN agent. All the transaction types are covered, with controllable aspects such as selecting the initiating RN, addressing mode.
CHI_SINGLE_RN_ATOMICSWAP_TYPE
* CHI-B AtomicSwap type transaction specific single node virtual sequence
 svt_chi_system_single_node_atomicswap_transaction_virtual_sequence #- This sequence requires one initiating active and participating RN-F.
#- If one or more active and participating RN-F exists, perform cache
initialization to a randomly selected HN.
#- Program the RN to initiate random Atomic Swap transaction from randomly selected RN_F.
.		 --
CHI_SYS_SINGLE_RN
* Transaction specific single node virtual sequences generates a given transaction type from a single RN agent. All the transaction types are covered, with controllable aspects such as selecting the initiating RN, addressing mode.
CHI_SINGLE_RN_ATOMICCOMPARE_TYPE
* CHI-B AtomicCompare type transaction specific single node virtual sequence
 svt_chi_system_single_node_atomiccompare_transaction_virtual_sequence #- This sequence requires one initiating active and participating RN-F.
#- If one or more active and participating RN-F exists, perform cache
initialization to a randomly selected HN.
#- Program the RN to initiate random Atomic Compare transaction from randomly selected RN_F.
.		 --
CHI_SYS_SINGLE_RN
* Transaction specific single node virtual sequences generates a given transaction type from a single RN agent. All the transaction types are covered, with controllable aspects such as selecting the initiating RN, addressing mode.
CHI_SINGLE_RN_WR_TYPE
* Write type transaction specific single node virtual sequences
 svt_chi_system_single_node_stashonceshared_virtual_sequence This sequence initiates StashOnceShared transaction from the RN node specified with node_index, which can be a random node or a specific node configured by the user. --
CHI_SYS_SINGLE_RN
* Transaction specific single node virtual sequences generates a given transaction type from a single RN agent. All the transaction types are covered, with controllable aspects such as selecting the initiating RN, addressing mode.
CHI_SINGLE_RN_WR_TYPE
* Write type transaction specific single node virtual sequences
 svt_chi_system_single_node_stashonceunique_virtual_sequence This sequence initiates StashOnceUnique transaction from the RN node specified with node_index, which can be a random node or a specific node configured by the user. --
CHI_SYS_SINGLE_RN
* Transaction specific single node virtual sequences generates a given transaction type from a single RN agent. All the transaction types are covered, with controllable aspects such as selecting the initiating RN, addressing mode.
CHI_SINGLE_RN_WR_TYPE
* Write type transaction specific single node virtual sequences
 svt_chi_system_single_node_write_followed_by_cmo_virtual_sequence This sequence initiates Write transaction followed by CMO targeting the same address from the RN-F node specified with node_index, which can be a random node or a specific node configured by the user. The transactions will be targeted to a random address that is serviced by the target HN specfied with target_hn_node_idx_0. If the target_hn_node_idx_0 is not configured by the user, it will be set to its default value '0'. --
CHI_SYS_SINGLE_RN
* Transaction specific single node virtual sequences generates a given transaction type from a single RN agent. All the transaction types are covered, with controllable aspects such as selecting the initiating RN, addressing mode.
CHI_SINGLE_RN_WR_TYPE
* Write type transaction specific single node virtual sequences
 svt_chi_system_single_node_writenosnpfull_virtual_sequence This sequence initiates WriteNoSnpFull transaction from the RN node specified with node_index, which can be a random node or a specific node configured by the user. --
CHI_SYS_SINGLE_RN
* Transaction specific single node virtual sequences generates a given transaction type from a single RN agent. All the transaction types are covered, with controllable aspects such as selecting the initiating RN, addressing mode.
CHI_SINGLE_RN_WR_TYPE
* Write type transaction specific single node virtual sequences
 svt_chi_system_single_node_writenosnpptl_virtual_sequence This sequence initiates WriteNoSnpPtl transaction from the RN node specified with node_index, which can be a random node or a specific node configured by the user. --
CHI_SYS_SINGLE_RN
* Transaction specific single node virtual sequences generates a given transaction type from a single RN agent. All the transaction types are covered, with controllable aspects such as selecting the initiating RN, addressing mode.
CHI_SINGLE_RN_WR_TYPE
* Write type transaction specific single node virtual sequences
 svt_chi_system_single_node_writeuniquefull_virtual_sequence This sequence initiates WriteUniqueFull transaction from the RN node specified with node_index, which can be a random node or a specific node configured by the user. --
CHI_SYS_SINGLE_RN
* Transaction specific single node virtual sequences generates a given transaction type from a single RN agent. All the transaction types are covered, with controllable aspects such as selecting the initiating RN, addressing mode.
CHI_SINGLE_RN_WR_TYPE
* Write type transaction specific single node virtual sequences
 svt_chi_system_single_node_writeuniquefullstash_virtual_sequence This sequence initiates WriteUniqueFullStash transaction from the RN node specified with node_index, which can be a random node or a specific node configured by the user. --
CHI_SYS_SINGLE_RN
* Transaction specific single node virtual sequences generates a given transaction type from a single RN agent. All the transaction types are covered, with controllable aspects such as selecting the initiating RN, addressing mode.
CHI_SINGLE_RN_WR_TYPE
* Write type transaction specific single node virtual sequences
 svt_chi_system_single_node_writeuniqueptlstash_virtual_sequence This sequence initiates WriteUniquePtlStash transaction from the RN node specified with node_index, which can be a random node or a specific node configured by the user. --
CHI_SYS_SINGLE_RN
* Transaction specific single node virtual sequences generates a given transaction type from a single RN agent. All the transaction types are covered, with controllable aspects such as selecting the initiating RN, addressing mode.
CHI_SINGLE_RN_WR_TYPE
* Write type transaction specific single node virtual sequences
 svt_chi_system_single_node_writeuniqueptl_virtual_sequence This sequence initiates WriteUniquePtl transaction from the RN node specified with node_index, which can be a random node or a specific node configured by the user. --
CHI_SYS_SINGLE_RN
* Transaction specific single node virtual sequences generates a given transaction type from a single RN agent. All the transaction types are covered, with controllable aspects such as selecting the initiating RN, addressing mode.
CHI_SINGLE_RN_CPBK_TYPE
* CopyBack type transaction specific single node virtual sequences
 svt_chi_system_single_node_evict_virtual_sequence This sequence initiates Evict transaction from the RN-F node specified with node_index, which can be a random node or a specific node configured by the user. Before sending each Evict transaction, cachelines of peer node are initialized to random, valid states. --
CHI_SYS_SINGLE_RN
* Transaction specific single node virtual sequences generates a given transaction type from a single RN agent. All the transaction types are covered, with controllable aspects such as selecting the initiating RN, addressing mode.
CHI_SINGLE_RN_CPBK_TYPE
* CopyBack type transaction specific single node virtual sequences
 svt_chi_system_single_node_writebackfull_virtual_sequence This sequence initiates WriteBackFull transaction from the RN-F node specified with node_index, which can be a random node or a specific node configured by the user. Before sending each WriteBackFull transaction, cachelines of peer node are initialized to random, valid states. --
CHI_SYS_SINGLE_RN
* Transaction specific single node virtual sequences generates a given transaction type from a single RN agent. All the transaction types are covered, with controllable aspects such as selecting the initiating RN, addressing mode.
CHI_SINGLE_RN_CPBK_TYPE
* CopyBack type transaction specific single node virtual sequences
 svt_chi_system_single_node_writebackptl_virtual_sequence This sequence initiates WriteBackPlt transaction from the RN-F node specified with node_index, which can be a random node or a specific node configured by the user. Before sending each WriteBackPlt transaction, cachelines of peer node are initialized to random, valid states. --
CHI_SYS_SINGLE_RN
* Transaction specific single node virtual sequences generates a given transaction type from a single RN agent. All the transaction types are covered, with controllable aspects such as selecting the initiating RN, addressing mode.
CHI_SINGLE_RN_CPBK_TYPE
* CopyBack type transaction specific single node virtual sequences
 svt_chi_system_single_node_writecleanfull_virtual_sequence This sequence initiates WriteCleanFull transaction from the RN-F node specified with node_index, which can be a random node or a specific node configured by the user. Before sending each WriteCleanFull transaction, cachelines of peer node are initialized to random, valid states. --
CHI_SYS_SINGLE_RN
* Transaction specific single node virtual sequences generates a given transaction type from a single RN agent. All the transaction types are covered, with controllable aspects such as selecting the initiating RN, addressing mode.
CHI_SINGLE_RN_CPBK_TYPE
* CopyBack type transaction specific single node virtual sequences
 svt_chi_system_single_node_writecleanptl_virtual_sequence This sequence initiates WriteCleanPtl transaction from the RN-F node specified with node_index, which can be a random node or a specific node configured by the user. Before sending each WriteCleanPtl transaction, cachelines of peer node are initialized to random, valid states. --
CHI_SYS_SINGLE_RN
* Transaction specific single node virtual sequences generates a given transaction type from a single RN agent. All the transaction types are covered, with controllable aspects such as selecting the initiating RN, addressing mode.
CHI_SINGLE_RN_CPBK_TYPE
* CopyBack type transaction specific single node virtual sequences
 svt_chi_system_single_node_writeevictfull_virtual_sequence This sequence initiates WriteEvictFull transaction from the RN-F node specified with node_index, which can be a random node or a specific node configured by the user. Before sending each WriteEvictFull transaction, cachelines of peer node are initialized to random, valid states. --
CHI_SYS_SINGLE_RN
* Transaction specific single node virtual sequences generates a given transaction type from a single RN agent. All the transaction types are covered, with controllable aspects such as selecting the initiating RN, addressing mode.
CHI_SINGLE_RN_CMO_TYPE
* CMO type transaction specific single node virtual sequences
 svt_chi_system_single_node_cleaninvalid_virtual_sequence This sequence initiates CleanInvalid transaction from the RN node specified with node_index, which can be a random node or a specific node configured by the user. Before sending each CleanInvalid transaction, cachelines of peer node are initialized to random, valid states. --
CHI_SYS_SINGLE_RN
* Transaction specific single node virtual sequences generates a given transaction type from a single RN agent. All the transaction types are covered, with controllable aspects such as selecting the initiating RN, addressing mode.
CHI_SINGLE_RN_CMO_TYPE
* CMO type transaction specific single node virtual sequences
 svt_chi_system_single_node_cleanshared_virtual_sequence This sequence initiates CleanShared transaction from the RN node specified with node_index, which can be a random node or a specific node configured by the user. Before sending each CleanShared transaction, cachelines of peer node are initialized to random, valid states. --
CHI_SYS_SINGLE_RN
* Transaction specific single node virtual sequences generates a given transaction type from a single RN agent. All the transaction types are covered, with controllable aspects such as selecting the initiating RN, addressing mode.
CHI_SINGLE_RN_CMO_TYPE
* CMO type transaction specific single node virtual sequences
 svt_chi_system_single_node_makeinvalid_virtual_sequence This sequence initiates MakeInvalid transaction from the RN node specified with node_index, which can be a random node or a specific node configured by the user. Before sending each MakeInvalid transaction, cachelines of peer node are initialized to random, valid states. --
CHI_SYS_SINGLE_RN
* Transaction specific single node virtual sequences generates a given transaction type from a single RN agent. All the transaction types are covered, with controllable aspects such as selecting the initiating RN, addressing mode.
CHI_SINGLE_RN_DVM_TYPE
* DVM type transaction specific single node virtual sequences
 svt_chi_system_single_node_dvm_virtual_sequence This sequence initiates DVM operations followed by a DVM sync from the RN node specified with node_index, which can be a random node or a specific node configured by the user.The above sequence is repeated for sequence_length. The sequence terminates only when each of the DVM syncs sent out from a port are received from the interconnect. --
CHI_SYS_SINGLE_RN
* Transaction specific single node virtual sequences generates a given transaction type from a single RN agent. All the transaction types are covered, with controllable aspects such as selecting the initiating RN, addressing mode.
CHI_SINGLE_RN_BARRIER_TYPE
* BARRIER type transaction specific single node virtual sequences
 chi_rn_barrier_directed_virtual_sequence chi_rn_barrier_directed_virtual_sequence is used by test to provide initiator scenario information to the RN agent present in the System Env. This class defines a sequence in which pre barrier transactions, followed by barrier transactions, followed by post barrier transactiosn are generated. sequence_length
Parameter that controls the number of transactions that will be generated

CHI_SYS_SINGLE_RN
* Transaction specific single node virtual sequences generates a given transaction type from a single RN agent. All the transaction types are covered, with controllable aspects such as selecting the initiating RN, addressing mode.
CHI_SINGLE_RN_BARRIER_TYPE
* BARRIER type transaction specific single node virtual sequences
 svt_chi_system_barrier_sequence svt_chi_system_barrier_sequence The sequence sends number of pre-barrier store transaction, controlled by num_pre_barrier_stores knobe from RN Node followed by ECBARRIER or EOBARRIER transaction. After sending Barrier transaction initiating node send a post barrier store to user controlled address (post_barrier_store_address) with a specific value (post_barrier_store_data).

User can configure the number of nodes that observe (poll) post_barrier_store_address to be updated with post_barrier_store_data. When the observing node find expected data at post_barrier_store_address, mean the post-barrier store transaction has reached the endpoint, which implies all the pre-barrier store must have finish.

As a check the observing nodes initiate load transaction corresponging to all the pre-barrier store transaction, and check for data integrity between the pre-barrier store and post-barrier load.

num_pre_barrier_stores
Description-Unavailable
initiating_node_index
Description-Unavailable
num_observers
Description-Unavailable
barrier_xact
Description-Unavailable
CHI_SYS_SINGLE_RN
* Transaction specific single node virtual sequences generates a given transaction type from a single RN agent. All the transaction types are covered, with controllable aspects such as selecting the initiating RN, addressing mode.
CHI_SINGLE_RN_ORDERED_NONCOHERENT_TYPE
* Ordered Non-Coherent transaction specific single node virtual sequences
 svt_chi_system_req_order_noncoherent_xact_directed_virtual_sequence svt_chi_system_req_order_noncoherent_xact_directed_virtual_sequence is used by test to provide initiator scenario information to the RN agent present in the System Env. This sequence generates an Ordered CHI WRITENOSNP followed by an Ordered CHI READNOSNP If the number of request order streams > 1, READs are sent with stream ID 0, while the WRITEs are sent with stream ID 1. Users can configure the number of streams by programming the parameter svt_chi_node_configuration :: num_req_order_streams for the RN. --
CHI_RN
* CHI RN transaction sequences generate various types of CHI RN transactions (Reads, Writes, DVM, Atomics, CMOs, Exclusive access pairs), with configurable aspects such as targeting a specific address range, targeting a home node. These sequences are also invoked by various system level virtual sequences. These sequences need to be executed on RN agent transaction sequencer.
CHI_RN_DIRECTED
* Directed sequences for RN transaction
 svt_chi_rn_atomic_type_transaction_directed_sequence Abstract: This class defines a sequence that sends Atomic type transactions. Execution phase: main_phase Sequencer: RN agent sequencer

This sequence also provides the following attributes which can be controlled through config DB:

  • sequence_length: Length of the sequence
  • enable_outstanding: Control outstanding transactions from sequences


Usage Guidance::
======================================================================
[1] General Controls
  a) seq_order_type:

  b) use_seq_is_non_secure_access:

  • '0'  // Do Not consider seq_is_non_secure_access attribute/i>
  • '1'  // Consider seq_is_non_secure_access attribute for transaction physical address spaces


[2] To generate an Atomic Transaction targeting specific address range, the below sequence's properties MUST be programmed:

  In case of targeting a specific address, min_addr and max_addr must be programmed to same value

  If there are any prior transactions targeting a specific cache line, ensure subsequent transactions have same attributes wherever required

  • min_addr ----> Address of prior executed transaction
  • max_addr ----> Address of prior executed transaction
  • seq_snp_attr_snp_domain_type ----> Same property value from prior executed transaction
  • seq_mem_attr_allocate_hint ----> Same property value from prior executed transaction
  • seq_is_non_secure_access ----> Same property value from prior executed transaction


[3] To generate an Atomic Transaction targeting specific HN Node, the below sequence's properties MUST be programmed:


sequence_length
Parameter that controls the number of transactions that will be generated

CHI_RN
* CHI RN transaction sequences generate various types of CHI RN transactions (Reads, Writes, DVM, Atomics, CMOs, Exclusive access pairs), with configurable aspects such as targeting a specific address range, targeting a home node. These sequences are also invoked by various system level virtual sequences. These sequences need to be executed on RN agent transaction sequencer.
CHI_RN_DIRECTED
* Directed sequences for RN transaction
 svt_chi_rn_cmo_type_transaction_directed_sequence Abstract: This class defines a sequence that sends CMO type transactions. Execution phase: main_phase Sequencer: RN agent sequencer

This sequence also provides the following attributes which can be controlled through config DB:

  • sequence_length: Length of the sequence
  • seq_exp_comp_ack: Control Expect CompAck bit of the transaction from sequences
  • seq_suspend_comp_ack: Control suspend_comp_ack response from sequences
  • enable_outstanding: Control outstanding transactions from sequences


Usage Guidance::
======================================================================
[1] General Controls   a) use_seq_is_non_secure_access:

  • '0'  // Do Not consider seq_is_non_secure_access attribute/i>
  • '1'  // Consider seq_is_non_secure_access attribute for transaction physical address spaces


[2] To generate a CMO Transaction targeting specific address range, the below sequence's properties MUST be programmed:

  In case of targeting a specific address, min_addr and max_addr must be programmed to same value

  If there are any prior transactions targeting a specific cache line, ensure subsequent transactions have same attributes wherever required

  • min_addr ----> Address of prior executed transaction
  • max_addr ----> Address of prior executed transaction
  • seq_snp_attr_snp_domain_type ----> Same property value from prior executed transaction
  • seq_snp_attr_is_snoopable ----> Same property value from prior executed transaction
  • seq_mem_attr_allocate_hint ----> Same property value from prior executed transaction
  • seq_is_non_secure_access ----> Same property value from prior executed transaction


[3] To generate a CMO Transaction targeting specific HN Node, the below sequence's properties MUST be programmed:


sequence_length
Parameter that controls the number of transactions that will be generated

CHI_RN
* CHI RN transaction sequences generate various types of CHI RN transactions (Reads, Writes, DVM, Atomics, CMOs, Exclusive access pairs), with configurable aspects such as targeting a specific address range, targeting a home node. These sequences are also invoked by various system level virtual sequences. These sequences need to be executed on RN agent transaction sequencer.
CHI_RN_DIRECTED
* Directed sequences for RN transaction
 svt_chi_rn_copyback_type_transaction_directed_sequence Abstract: This class defines a sequence that sends CopyBack type transactions. Execution phase: main_phase Sequencer: RN agent sequencer

This sequence also provides the following attributes which can be controlled through config DB:

  • sequence_length: Length of the sequence
  • seq_suspend_wr_data: Control suspend_wr_data response from sequences
  • enable_outstanding: Control outstanding transactions from sequences


Usage Guidance::
======================================================================
[1] General Controls
  a) seq_order_type:

  b) seq_copyback_req_order_enable:

  • '0'  // Do Not Enable Ordering
  • '1'  // Enable Ordering

  c) use_seq_is_non_secure_access:

  • '0'  // Do Not consider seq_is_non_secure_access attribute/i>
  • '1'  // Consider seq_is_non_secure_access attribute for transaction physical address spaces


[2] To generate a CopyBack Transaction targeting specific address range, the below sequence's properties MUST be programmed:

  In case of targeting a specific address, min_addr and max_addr must be programmed to same value

  If there are any prior transactions targeting a specific cache line, ensure subsequent transactions have same attributes wherever required

  • min_addr ----> Address of prior executed transaction
  • max_addr ----> Address of prior executed transaction
  • seq_snp_attr_snp_domain_type ----> Same property value from prior executed transaction
  • seq_mem_attr_allocate_hint ----> Same property value from prior executed transaction
  • seq_is_non_secure_access ----> Same property value from prior executed transaction


[3] To generate a CopyBack Transaction targeting specific HN Node, the below sequence's properties MUST be programmed:


sequence_length
Parameter that controls the number of transactions that will be generated

CHI_RN
* CHI RN transaction sequences generate various types of CHI RN transactions (Reads, Writes, DVM, Atomics, CMOs, Exclusive access pairs), with configurable aspects such as targeting a specific address range, targeting a home node. These sequences are also invoked by various system level virtual sequences. These sequences need to be executed on RN agent transaction sequencer.
CHI_RN_DIRECTED
* Directed sequences for RN transaction
 svt_chi_rn_makeunique_cache_initialization_directed_sequence Abstract: Sends MAKEUNIQUE transactions from an RN Execution phase: main_phase Sequencer: RN agent sequencer

This sequence also provides the following attributes which can be controlled through config DB:

  • sequence_length: Length of the sequence
  • seq_exp_comp_ack: Control Expect CompAck bit of the transaction from sequences
  • seq_suspend_comp_ack: Control Suspend CompAck bit of the transaction
  • enable_outstanding: Control outstanding transactions from sequences


Usage Guidance::
======================================================================
[1] General Controls   a) use_seq_is_non_secure_access:

  • '0'  // Do Not consider seq_is_non_secure_access attribute/i>
  • '1'  // Consider seq_is_non_secure_access attribute for transaction physical address spaces


[2] To generate a MakeUnique Cache Initialization Transaction targeting specific address range, the below sequence's properties MUST be programmed:

  In case of targeting a specific address, min_addr and max_addr must be programmed to same value

[3] To generate a MakeUnique Cache Initialization Transaction targeting specific HN Node, the below sequence's properties MUST be programmed:

  If there is requirement to generate unique address, then additionaly below sequence's property to programmed as per below:
  • set_unique_addr_value == 1

sequence_length
Parameter that controls the number of transactions that will be generated

CHI_RN
* CHI RN transaction sequences generate various types of CHI RN transactions (Reads, Writes, DVM, Atomics, CMOs, Exclusive access pairs), with configurable aspects such as targeting a specific address range, targeting a home node. These sequences are also invoked by various system level virtual sequences. These sequences need to be executed on RN agent transaction sequencer.
CHI_RN_DIRECTED
* Directed sequences for RN transaction
 svt_chi_rn_prefetchtgt_type_transaction_directed_sequence Abstract: This class defines a sequence that sends Prefetchtgt type transactions. Execution phase: main_phase Sequencer: RN agent sequencer

This sequence also provides the following attributes which can be controlled through config DB:

  • sequence_length: Length of the sequence
  • enable_outstanding: Control outstanding transactions from sequences


Usage Guidance::
======================================================================
[1] To generate a PrefetchTgt Transaction targeting specific address range, the below sequence's properties MUST be programmed:

  In case of targeting a specific address, min_addr and max_addr must be programmed to same value

[2] To generate a PrefetchTgt Transaction targeting specific HN Node, the below sequence's properties MUST be programmed:


[3] To generate a PrefetchTgt Transaction targeting with respect to prior Write/Read Transaction's Address, the below sequence's properties MUST be programmed:


sequence_length
Parameter that controls the number of transactions that will be generated

CHI_RN
* CHI RN transaction sequences generate various types of CHI RN transactions (Reads, Writes, DVM, Atomics, CMOs, Exclusive access pairs), with configurable aspects such as targeting a specific address range, targeting a home node. These sequences are also invoked by various system level virtual sequences. These sequences need to be executed on RN agent transaction sequencer.
CHI_RN_DIRECTED
* Directed sequences for RN transaction
 svt_chi_rn_read_type_transaction_directed_sequence Abstract: This class defines a sequence that sends Read type transactions. Execution phase: main_phase Sequencer: RN agent sequencer

This sequence also provides the following attributes which can be controlled through config DB:

  • sequence_length: Length of the sequence
  • seq_exp_comp_ack: Control Expect CompAck bit of the transaction from sequences
  • seq_suspend_wr_data: Control suspend_wr_data response from sequences
  • enable_outstanding: Control outstanding transactions from sequences


Usage Guidance::
======================================================================
[1] General Controls
  a) seq_order_type:

  b) by_pass_read_data_check:

  • '0'  // Perform Read Data Integrity Check
  • '1'  // Bypass Read Data Integrity Check

  c) use_seq_is_non_secure_access:

  • '0'  // Do Not consider seq_is_non_secure_access attribute/i>
  • '1'  // Consider seq_is_non_secure_access attribute for transaction physical address spaces


[2] To generate a CHI RN Read Transaction targeting specific address range, the below sequence's properties MUST be programmed:

  In case of targeting a specific address, min_addr and max_addr must be programmed to same value

  If there are any prior transactions targeting a specific cache line, ensure subsequent transactions have same attributes wherever required

  • min_addr ----> Address of prior executed transaction
  • max_addr ----> Address of prior executed transaction
  • seq_snp_attr_snp_domain_type ----> Same property value from prior executed transaction
  • seq_mem_attr_allocate_hint ----> Same property value from prior executed transaction
  • seq_is_non_secure_access ----> Same property value from prior executed transaction


[3] To generate a CHI RN Read Transaction targeting a specific HN Node, the below sequence's properties MUST be programmed:


sequence_length
Parameter that controls the number of transactions that will be generated

CHI_RN
* CHI RN transaction sequences generate various types of CHI RN transactions (Reads, Writes, DVM, Atomics, CMOs, Exclusive access pairs), with configurable aspects such as targeting a specific address range, targeting a home node. These sequences are also invoked by various system level virtual sequences. These sequences need to be executed on RN agent transaction sequencer.
CHI_RN_DIRECTED
* Directed sequences for RN transaction
 svt_chi_rn_write_type_transaction_directed_sequence Abstract: This class defines a sequence that sends Write type transactions. Execution phase: main_phase Sequencer: RN agent sequencer

This sequence also provides the following attributes which can be controlled through config DB:

  • sequence_length: Length of the sequence
  • seq_exp_comp_ack: Control Expect CompAck bit of the transaction from sequences
  • seq_suspend_wr_data: Control suspend_wr_data response from sequences
  • enable_outstanding: Control outstanding transactions from sequences


Usage Guidance::
======================================================================
[1] General Controls
  a) seq_order_type:

  b) use_seq_is_non_secure_access:

  • '0'  // Do Not consider seq_is_non_secure_access attribute/i>
  • '1'  // Consider seq_is_non_secure_access attribute for transaction physical address spaces


[2] To generate a CHI RN Write Transaction targeting specific address range, the below sequence's properties MUST be programmed:

  In case of targeting a specific address, min_addr and max_addr must be programmed to same value

  If there are any prior transactions targeting a specific cache line, ensure subsequent transactions have same attributes wherever required

  • min_addr ----> Address of prior executed transaction
  • max_addr ----> Address of prior executed transaction
  • seq_snp_attr_snp_domain_type ----> Same property value from prior executed transaction
  • seq_mem_attr_allocate_hint ----> Same property value from prior executed transaction
  • seq_is_non_secure_access ----> Same property value from prior executed transaction


[3] To generate a CHI RN Write Transaction targeting specific HN Node, the below sequence's properties MUST be programmed:


sequence_length
Parameter that controls the number of transactions that will be generated

CHI_RN
* CHI RN transaction sequences generate various types of CHI RN transactions (Reads, Writes, DVM, Atomics, CMOs, Exclusive access pairs), with configurable aspects such as targeting a specific address range, targeting a home node. These sequences are also invoked by various system level virtual sequences. These sequences need to be executed on RN agent transaction sequencer.
CHI_RN_COHERENT
* Coherent sequences for RN transaction
 svt_chi_rn_coherent_transaction_base_sequence svt_chi_rn_coherent_transaction_base_sequence start_addr
defines start address of the supported address range of current RN

end_addr
defines end address of the supported address range of current RN

seq_order_type
defines the order_type field that is to be set in the transactions generated by this sequence
seq_data_size
defines the data_size field that is to be set in the transactions generated by this sequence This is applicable only when use_seq_data_size is set to 1. It is required to ensure that this is constrained from test such that data_size is valid for the given transaction type.

seq_p_crd_return_on_retry_ack
Indicates the p_crd_return_on_retry_ack of the transactions generated by this sequence
use_directed_addr
Indicates that the addresses provided in directed_addr_mailbox should be used for the transactions generated by this sequence
generate_unique_txn_id
Indicates whether unique txn_id should be generated for each transaction.
CHI_RN
* CHI RN transaction sequences generate various types of CHI RN transactions (Reads, Writes, DVM, Atomics, CMOs, Exclusive access pairs), with configurable aspects such as targeting a specific address range, targeting a home node. These sequences are also invoked by various system level virtual sequences. These sequences need to be executed on RN agent transaction sequencer.
CHI_RN_DVM
* DVM sequences for RN transaction
 svt_chi_rn_transaction_dvm_sync_sequence svt_chi_rn_transaction_dvm_sync_sequence

This sequence will use svt_chi_rn_transaction_dvm_write_semantic_sequence to generate a random number of DVMOP write semantic transcations followed by a DVMOP sync.

 dvm_lpid_pattern
Description-Unavailable
dvm_lpid
Description-Unavailable
CHI_RN
* CHI RN transaction sequences generate various types of CHI RN transactions (Reads, Writes, DVM, Atomics, CMOs, Exclusive access pairs), with configurable aspects such as targeting a specific address range, targeting a home node. These sequences are also invoked by various system level virtual sequences. These sequences need to be executed on RN agent transaction sequencer.
CHI_RN_DVM
* DVM sequences for RN transaction
 svt_chi_rn_transaction_dvm_write_semantic_sequence svt_chi_rn_transaction_dvm_write_semantic_sequence

This sequence creates a random DVM write semantic request with control over the dvm_message_type field. User can control the number of DVMOP write semantic transcations to generate by constraining the dvm_write_semantic_length field from the test.

 --
CHI_RN
* CHI RN transaction sequences generate various types of CHI RN transactions (Reads, Writes, DVM, Atomics, CMOs, Exclusive access pairs), with configurable aspects such as targeting a specific address range, targeting a home node. These sequences are also invoked by various system level virtual sequences. These sequences need to be executed on RN agent transaction sequencer.
CHI_RN_BARRIER
* BARRIER sequences for RN transaction
 svt_chi_rn_ecbarrier_sequence RN transaction ECBARRIER sequence --
CHI_RN
* CHI RN transaction sequences generate various types of CHI RN transactions (Reads, Writes, DVM, Atomics, CMOs, Exclusive access pairs), with configurable aspects such as targeting a specific address range, targeting a home node. These sequences are also invoked by various system level virtual sequences. These sequences need to be executed on RN agent transaction sequencer.
CHI_RN_BARRIER
* BARRIER sequences for RN transaction
 svt_chi_rn_eobarrier_sequence RN transaction EOBARRIER sequence --
CHI_RN
* CHI RN transaction sequences generate various types of CHI RN transactions (Reads, Writes, DVM, Atomics, CMOs, Exclusive access pairs), with configurable aspects such as targeting a specific address range, targeting a home node. These sequences are also invoked by various system level virtual sequences. These sequences need to be executed on RN agent transaction sequencer.
CHI_RN_ORDERING
* ORDERING sequences for RN transaction
 svt_chi_rn_go_noncoherent_sequence RN transaction non-coherent transaction type sequence that exercises global observability for pre-barrier transactions --
CHI_RN
* CHI RN transaction sequences generate various types of CHI RN transactions (Reads, Writes, DVM, Atomics, CMOs, Exclusive access pairs), with configurable aspects such as targeting a specific address range, targeting a home node. These sequences are also invoked by various system level virtual sequences. These sequences need to be executed on RN agent transaction sequencer.
CHI_RN_EXCLUSIVE
* Exclusive sequences for RN transaction
 svt_chi_rn_exclusive_access_sequence Abstract: This class defines a sequence for exclusive access support. Execution phase: main_phase Sequencer: RN agent sequencer

This sequence also provides the following attributes which can be controlled through config DB:

  • sequence_length: Length of the sequence
  • seq_exp_comp_ack: Control Expect CompAck bit of the transaction from sequences
  • enable_outstanding: Control outstanding transactions from sequences


Usage Guidance::
======================================================================
[1] General Controls
  a) seq_xact_type_excl:

  b) seq_order_type:

  c) by_pass_read_data_check:

  • '0'  // Perform Read Data Integrity Check
  • '1'  // Bypass Read Data Integrity Check

  d) use_seq_is_non_secure_access:

  • '0'  // Do Not consider seq_is_non_secure_access attribute/i>
  • '1'  // Consider seq_is_non_secure_access attribute for transaction physical address spaces


[2] To generate Exclusive Transaction targeting specific address range, the below sequence's properties MUST be programmed:

  In case of targeting a specific address, min_addr and max_addr must be programmed to same value

  If there are any prior transactions targeting a specific cache line, ensure subsequent transactions have same attributes wherever required

  • min_addr ----> Address of prior executed transaction
  • max_addr ----> Address of prior executed transaction
  • seq_snp_attr_snp_domain_type ----> Same property value from prior executed transaction
  • seq_mem_attr_allocate_hint ----> Same property value from prior executed transaction
  • seq_is_non_secure_access ----> Same property value from prior executed transaction

  For NON-COHERENT Exclusive, the Load-Store pair MUST have same control signals that is memory and snoop attributes

  • seq_mem_attr_is_early_wr_ack_allowed ----> Same property value from prior executed transaction
  • seq_mem_attr_mem_type ----> Same property value from prior executed transaction
  • seq_mem_attr_is_cacheable ----> Same property value from prior executed transaction
  • seq_mem_attr_allocate_hint ----> Same property value from prior executed transaction
  • seq_snp_attr_is_snoopable ----> Same property value from prior executed transaction

[3] To generate Exclusive Transaction targeting specific HN Node, the below sequence's properties MUST be programmed:


[4] Based on communication nodes, below sequence's properties MUST be programmed:
  For RN-F Node and COHERENT Transaction
  a) For any CHI ISSUE version:

  b) Additional Constraint for CHI ISSUE 'A':

  For RN-F Node and NON-COHERENT Transaction

  For RN-I or RN-D Node


seq_xact_type_excl
Description-Unavailable
sequence_length
Parameter that controls the number of transactions that will be generated

byte_enable
Defines the byte enable

data_in_cache
Stores the data written in Cache

seq_mem_attr_is_early_wr_ack_allowed
This field defines the 'Early Write Acknowldege' field for the transaction.
  • Value of 1 indicates that Early Write Acknowledge is allowed
  • Value of 0 indicates that Early Write Acknowledge is disallowed

seq_mem_attr_mem_type
This field indictes the memory type associated with the transaction.

seq_mem_attr_is_cacheable
This field defines the cacheable field of transaction.
When set, it indicates a cacheable transaction for which the system cache, when present, must be looked up in servicing this transaction.
seq_mem_attr_allocate_hint
This field defines Allocate hint for the transaction.
When set, it indicates that the transaction may allocate in the system cache, when present.
seq_snp_attr_is_snoopable
This field defines if the transaction is snoopable or non-snoopable.

seq_snp_attr_snp_domain_type
This field defines the snoop domain of the transaction.

seq_is_non_secure_access
This field defines the is non secure attribute of the transaction.

use_seq_is_non_secure_access
This field determines if seq_is_non_secure_access is used to constrain transaction's is_non_secure_access field

seq_lpid
lpid

seq_data_size
data_size

by_pass_read_data_check
Flag used to bypass read data check

seq_order_type
Order type for transaction is no_ordering_required

seq_xact_type_read
Parameter that controls the type of transaction that will be generated

seq_xact_type_write
Description-Unavailable
CHI_RN_BASE
* Base sequences for RN transaction sequences. Base sequences have infrastructure, configurable aspects, utilities that are required for the extended RN transaction sequences. In general, users are not expected to use these base sequences directly.
CHI_RN_BASE_RDM
* Base sequence for all CHI RN transaction sequences
 svt_chi_rn_transaction_random_sequence svt_chi_rn_transaction_random_sequence

This sequence creates a random svt_chi_rn_transaction request.

 sequence_length
Controls the number of random transactions that will be generated

is_sni_interface
Controls whether the generated transactions are only for SN node

CHI_RN_BASE
* Base sequences for RN transaction sequences. Base sequences have infrastructure, configurable aspects, utilities that are required for the extended RN transaction sequences. In general, users are not expected to use these base sequences directly.
CHI_RN_BASE_RDM
* Base sequence for all CHI RN transaction sequences
 svt_chi_rn_transaction_xact_type_sequence svt_chi_rn_transaction_xact_type_sequence

This sequence creates a random svt_chi_rn_transaction request with control over the xact_type field.

 xact_type
Controls the transaction type of the generated transactions

CHI_RN_BASE
* Base sequences for RN transaction sequences. Base sequences have infrastructure, configurable aspects, utilities that are required for the extended RN transaction sequences. In general, users are not expected to use these base sequences directly.
-- svt_chi_rn_transaction_base_sequence svt_chi_rn_transaction_base_sequence: This is the base class for svt_chi_rn_transaction sequences. All other svt_chi_rn_transaction sequences are extended from this sequence.

The base sequence takes care of managing objections if extended classes or sequence clients set the manage_objection bit to 1.


Usage Guidance::
======================================================================
[1] To generate a CHI RN Transaction targeting a specific address range, the below sequence's properties MUST be programmed:

  In case of targeting a specific address, min_addr and max_addr must be programmed to same value

[2] To generate a CHI RN Transaction targeting a specific HN Node, the below sequence's properties MUST be programmed:


sequence_length
Sequence length in used to constrain the sequence length in sub-sequences

CHI_SYS_EXCLUSIVE_ACCESS
* Exclusive access feature virtual sequences generate scenarios from RN agents to verify various Exclusive Access requirements of a home node within interconnect.
-- svt_chi_system_protocol_flow_ctrl_exclusive_access_virtual_sequence Abstract:
This sequence generates traffic to test the exclusive access feature support.
#- Program a randomly selected RN1 to send an exclusive load type transaction
with an LPID followed by an exclusive store transaction with the same LPID and address
set to same value as that of exclusive load transaction.
#- Optionally program to send MAKEUNIQUE transaction targeted to
randomly selected RN with address of randomly selected first HN Node. #- Optionally program a randomly selected RN2 to intervene the exclusive sequence from RN1.
#- Supports both coherent and non coherent transactions.
.		 target_hn_i_node_index_0
Represents the HN-I node to which the transaction will be sent

CHI_SYS_HAZARD
* Hazard feature virtual sequences generate various address hazard scenarios from RN agents to verify related hazard resolution aspects of a home node within the interconnect.
-- svt_chi_system_protocol_flow_ctrl_hn_atomic_atomic_hazard_directed_virtual_sequence Abstract: svt_chi_system_protocol_flow_ctrl_hn_atomic_atomic_hazard_directed_virtual_sequence provides a sequence to test how components handle various hazard conditions applicable for atomic transactions 1. Send MAKEUNIQUE transaction to random address from random RN 2. Send atomic type of transactions to the above same address from two different RN's. 3. Check the order in which the two requests are processed by HN. . sequence_length
Parameter that controls the number of transactions that will be generated

enable_outstanding
Description-Unavailable
CHI_SYS_HAZARD
* Hazard feature virtual sequences generate various address hazard scenarios from RN agents to verify related hazard resolution aspects of a home node within the interconnect.
-- svt_chi_system_protocol_flow_ctrl_hn_atomic_cmo_hazard_directed_virtual_sequence Abstract: svt_chi_system_protocol_flow_ctrl_hn_atomic_cmo_hazard_directed_virtual_sequence provides a sequence to test how components handle various hazard conditions applicable for atomic and cmo transactions 1. Send MAKEUNIQUE transaction to random address from random RN 2. Send atomic type of transaction to the same address from different RN 3. Send cmo type of transaction to the same address from different RN 4. Check the order in which the two requests are processed by HN. . sequence_length
Parameter that controls the number of transactions that will be generated

enable_outstanding
Description-Unavailable
CHI_SYS_HAZARD
* Hazard feature virtual sequences generate various address hazard scenarios from RN agents to verify related hazard resolution aspects of a home node within the interconnect.
-- svt_chi_system_protocol_flow_ctrl_hn_atomic_copyback_hazard_directed_virtual_sequence Abstract: svt_chi_system_protocol_flow_ctrl_hn_atomic_copyback_hazard_directed_virtual_sequence provides a sequence to test how components handle various hazard conditions applicable for atomic and copyback transactions 1. Initialize the cacheline using MAKEUNIQUE transaction from RN 2. Send atomic type of transaction to the same address from different RN. 3. Send Copyback type of transaction to the same address from same RN from which the MAKEUNIQUE transaction initiated. 4. Check the order in which the two requests are processed by HN. . sequence_length
Parameter that controls the number of transactions that will be generated

enable_outstanding
Description-Unavailable
CHI_SYS_HAZARD
* Hazard feature virtual sequences generate various address hazard scenarios from RN agents to verify related hazard resolution aspects of a home node within the interconnect.
-- svt_chi_system_protocol_flow_ctrl_hn_atomic_read_hazard_directed_virtual_sequence Abstract: svt_chi_system_protocol_flow_ctrl_hn_atomic_read_hazard_directed_virtual_sequence provides a sequence to test how components handle various hazard conditions applicable for atomic and read transactions 1. Send MAKEUNIQUE transaction to random address from random RN 2. Send atomic type of transaction to the same address from different RN 3. Send read type of transaction to the same address from different RN 4. Check the order in which the two requests are processed by HN. . sequence_length
Parameter that controls the number of transactions that will be generated

enable_outstanding
Description-Unavailable
CHI_SYS_HAZARD
* Hazard feature virtual sequences generate various address hazard scenarios from RN agents to verify related hazard resolution aspects of a home node within the interconnect.
-- svt_chi_system_protocol_flow_ctrl_hn_atomic_write_hazard_directed_virtual_sequence Abstract: svt_chi_system_protocol_flow_ctrl_hn_atomic_write_hazard_directed_virtual_sequence provides a sequence to test how components handle various hazard conditions applicable for atomic and write transactions 1. Send MAKEUNIQUE transaction to random address from random RN 2. Send atomic type of transaction to the same address from different RN 3. Send write type of transaction to the same address from different RN 4. Check the order in which the two requests are processed by HN. . sequence_length
Parameter that controls the number of transactions that will be generated

enable_outstanding
Description-Unavailable
CHI_SYS_HAZARD
* Hazard feature virtual sequences generate various address hazard scenarios from RN agents to verify related hazard resolution aspects of a home node within the interconnect.
-- svt_chi_system_protocol_flow_ctrl_hn_cmo_cmo_hazard_directed_virtual_sequence Abstract: svt_chi_system_protocol_flow_ctrl_hn_cmo_cmo_hazard_directed_virtual_sequence provides a sequence to test how components handle various hazard conditions applicable for CMO transactions 1. Initialize the cacheline using MAKEUNIQUE followed by WRITEBACKFULL transaction from RN to the random address. 2. Send different types of cmo transactions to the same address from RN0 and RN1. 3. Check the order in which the two requests are processed by HN. . sequence_length
Parameter that controls the number of transactions that will be generated

enable_outstanding
Description-Unavailable
CHI_SYS_HAZARD
* Hazard feature virtual sequences generate various address hazard scenarios from RN agents to verify related hazard resolution aspects of a home node within the interconnect.
-- svt_chi_system_protocol_flow_ctrl_hn_cmo_copyback_hazard_directed_virtual_sequence Abstract: svt_chi_system_protocol_flow_ctrl_hn_cmo_copyback_hazard_directed_virtual_sequence provides a sequence to test how components handle various hazard conditions applicable for copyback and snoop transactions 1. Send MAKEUNIQUE transaction to random address from random RN 2. Send CMO type of transaction to the same address from different RN 3. Send copyback type of transaction to the same address from the same RN from which MAKEUNIQUE transaction initiated. 4. Check the order in which the two requests are processed by HN. . sequence_length
Parameter that controls the number of transactions that will be generated

enable_outstanding
Description-Unavailable
CHI_SYS_HAZARD
* Hazard feature virtual sequences generate various address hazard scenarios from RN agents to verify related hazard resolution aspects of a home node within the interconnect.
-- svt_chi_system_protocol_flow_ctrl_hn_cmo_read_hazard_directed_virtual_sequence Abstract: svt_chi_system_protocol_flow_ctrl_hn_cmo_read_hazard_directed_virtual_sequence provides a sequence to test how components handle various hazard conditions applicable for CMO and read transactions 1. Initialize the cacheline using MAKEUNIQUE transaction from RN to the random address. 2. Send cmo type of transaction to the same address from different RN 3. Send read type of transaction to the same address from different RN 4. Check the order in which the two requests are processed by HN. . sequence_length
Parameter that controls the number of transactions that will be generated

enable_outstanding
Description-Unavailable
CHI_SYS_HAZARD
* Hazard feature virtual sequences generate various address hazard scenarios from RN agents to verify related hazard resolution aspects of a home node within the interconnect.
-- svt_chi_system_protocol_flow_ctrl_hn_cmo_write_hazard_directed_virtual_sequence Abstract: svt_chi_system_protocol_flow_ctrl_hn_cmo_write_hazard_directed_virtual_sequence provides a sequence to test how components handle various hazard conditions applicable for CMO and write transactions 1. Initialize the cacheline using MAKEUNIQUE transaction from RN to the random address. 2. Send cmo type of transaction to the same address from different RN 3. Send write type of transaction to the same address from different RN 4. Check the order in which the two requests are processed by HN. . sequence_length
Parameter that controls the number of transactions that will be generated

enable_outstanding
Description-Unavailable
CHI_SYS_HAZARD
* Hazard feature virtual sequences generate various address hazard scenarios from RN agents to verify related hazard resolution aspects of a home node within the interconnect.
-- svt_chi_system_protocol_flow_ctrl_hn_copyback_snoop_hazard_directed_virtual_sequence Abstract: svt_chi_system_protocol_flow_ctrl_hn_copyback_snoop_hazard_directed_virtual_sequence provides a sequence to test how components handle various hazard conditions applicable for copyback and snoop transactions 1. Send MAKEUNIQUE transaction to random address from random RN 2. Send read type of transaction to the same address from different RN 3. Send copyback type of transaction to the same address from the same RN from which MAKEUNIQUE transaction initiated. 4. Check the order in which the two requests are processed by HN. . sequence_length
Parameter that controls the number of transactions that will be generated

enable_outstanding
Description-Unavailable
CHI_SYS_HAZARD
* Hazard feature virtual sequences generate various address hazard scenarios from RN agents to verify related hazard resolution aspects of a home node within the interconnect.
-- svt_chi_system_protocol_flow_ctrl_hn_makeunique_makeunique_hazard_directed_virtual_sequence Abstract: svt_chi_system_protocol_flow_ctrl_hn_makeunique_makeunique_hazard_directed_virtual_sequence provides a sequence to test the ability of components to handle hazard conditions: 1. Initialize the cacheline using MAKEUNIQUE followed by WRITEBACKFULL transaction from RN to the random address. 2. Send a MAKEUNIQUE transaction from both RN0 and RN1 to the same address. The interconnect should sequence these transactions correctly 3. Check the order in which the two requests are processed by HN. 4. If sequenced correctly, both RNs should not be in UD state; only one RN should be in UD state. This is checked in the sequence. . sequence_length
Parameter that controls the number of transactions that will be generated

enable_outstanding
Description-Unavailable
CHI_SYS_HAZARD
* Hazard feature virtual sequences generate various address hazard scenarios from RN agents to verify related hazard resolution aspects of a home node within the interconnect.
-- svt_chi_system_protocol_flow_ctrl_hn_read_copyback_hazard_directed_virtual_sequence Abstract: svt_chi_system_protocol_flow_ctrl_hn_read_copyback_hazard_directed_virtual_sequence provides a sequence to test how components handle various hazard conditions applicable for copyback and snoop transactions 1. Send MAKEUNIQUE transaction to random address from random RN 2. Send read type of transaction to the same address from different RN 3. Send copyback type of transaction to the same address from the same RN from which MAKEUNIQUE transaction initiated. 4. Check the order in which the two requests are processed by HN. . sequence_length
Parameter that controls the number of transactions that will be generated

enable_outstanding
Description-Unavailable
CHI_SYS_HAZARD
* Hazard feature virtual sequences generate various address hazard scenarios from RN agents to verify related hazard resolution aspects of a home node within the interconnect.
-- svt_chi_system_protocol_flow_ctrl_hn_read_read_hazard_directed_virtual_sequence Abstract: svt_chi_system_protocol_flow_ctrl_hn_read_read_hazard_directed_virtual_sequence provides a sequence to test how components handle various hazard conditions applicable for read transactions 1. Send MAKEUNIQUE transaction to random address from random RN 2. Send read type of transactions to the above same address from two different RN's. 3. Check the order in which the two requests are processed by HN. . sequence_length
Parameter that controls the number of transactions that will be generated

enable_outstanding
Description-Unavailable
CHI_SYS_HAZARD
* Hazard feature virtual sequences generate various address hazard scenarios from RN agents to verify related hazard resolution aspects of a home node within the interconnect.
-- svt_chi_system_protocol_flow_ctrl_hn_read_write_hazard_directed_virtual_sequence Abstract: svt_chi_system_protocol_flow_ctrl_hn_read_write_hazard_directed_virtual_sequence provides a sequence to test how components handle various hazard conditions applicable for read and write transactions 1. Send MAKEUNIQUE transaction to random address from random RN 2. Send read type of transaction to the same address from different RN 3. Send write type of transaction to the same address from different RN 4. Check the order in which the two requests are processed by HN. . sequence_length
Parameter that controls the number of transactions that will be generated

enable_outstanding
Description-Unavailable
CHI_SYS_HAZARD
* Hazard feature virtual sequences generate various address hazard scenarios from RN agents to verify related hazard resolution aspects of a home node within the interconnect.
-- svt_chi_system_protocol_flow_ctrl_hn_write_copyback_hazard_directed_virtual_sequence Abstract: svt_chi_system_protocol_flow_ctrl_hn_write_copyback_hazard_directed_virtual_sequence provides a sequence to test how components handle various hazard conditions applicable for write and copyback transactions 1. Initialize the cacheline using MAKEUNIQUE transaction from RN 2. Send write type of transaction to the same address from different RN. 3. Send Copyback type of transaction to the same address from same RN from which the MAKEUNIQUE transaction initiated. 4. Check the order in which the two requests are processed by HN. . sequence_length
Parameter that controls the number of transactions that will be generated

enable_outstanding
Description-Unavailable
CHI_SYS_HAZARD
* Hazard feature virtual sequences generate various address hazard scenarios from RN agents to verify related hazard resolution aspects of a home node within the interconnect.
-- svt_chi_system_protocol_flow_ctrl_hn_write_write_hazard_directed_virtual_sequence Abstract: svt_chi_system_protocol_flow_ctrl_hn_write_write_hazard_directed_virtual_sequence provides a sequence to test how components handle various hazard conditions applicable for read transactions 1. Initialize the cacheline using MAKEUNIQUE followed by WRITEBACKFULL transaction from RN to the random address. 2. Send different types of write transactions to the same address from different RN's. 3. Check the order in which the two requests are processed by HN. . sequence_length
Parameter that controls the number of transactions that will be generated

enable_outstanding
Description-Unavailable
CHI_SYS_BASE
* Base system virtual sequences have infrastructure, configurable aspects, utilities that are required for the extended system virtual sequences, as well as some of the RN transaction sequences. In general, users are not expected to use these base sequences directly. This grouping include cache initialization and invalidation virtual sequences as well.
 -- svt_chi_system_base_virtual_sequence This sequence creates a reporter reference.
This sequence setups up configuraion awareness related infrastructure to the derived sequences.
This sequence also provides the following attributes which can be controlled through config DB:
  • sequence_length: Length of the sequence
  • silent: Control the messages from sequences
--
CHI_SYS_BASE
* Base system virtual sequences have infrastructure, configurable aspects, utilities that are required for the extended system virtual sequences, as well as some of the RN transaction sequences. In general, users are not expected to use these base sequences directly. This grouping include cache initialization and invalidation virtual sequences as well.
 -- svt_chi_system_rn_coherent_transaction_base_virtual_sequence This is the base sequence for: --
CHI_SYS_BASE
* Base system virtual sequences have infrastructure, configurable aspects, utilities that are required for the extended system virtual sequences, as well as some of the RN transaction sequences. In general, users are not expected to use these base sequences directly. This grouping include cache initialization and invalidation virtual sequences as well.
 -- svt_chi_system_cacheline_initialization_virtual_sequence This sequence initializes the cache line of all masters.
  • The rn_xact for which cache is to be initialized must be input to this sequence.
  • The sequence checks if the cache line is already one of the spec permitted states for the rn_xact type. If legal, nothing is done by this sequence. If not legal, then the next steps are performed.
  • invalidate_all_cachelines: send makeunique from initiating RN-F; send invalidate xact (writeback if current state is dirty, evict if current state is clean)
  • get_random_initial_cachestate: get the random legal initial cacheline state for the xact type. Based on this, the next steps are performed.
    • If get_random_initial_cachestate returns 'Invalid' state: send readshared from the peer RN-Fs.).
    • If get_random_initial_cachestate returns a Unique state: send makeunique from initiating RN-F.
    • If get_random_initial_cachestate returns a Shared state: send makeunique from initiating RN-F; send readshared from the peer RN-Fs; If the initiating rn-f cacheline state is not valid, send makeunique from initiating RN-F. If bypass_silent_cache_line_state_transition is set to 0: update status of cacheline silently to shared.
  • If clean cache line is required for the coherent xact, send writeclean xact from the initiating RN-F.
--
CHI_SYS_BASE
* Base system virtual sequences have infrastructure, configurable aspects, utilities that are required for the extended system virtual sequences, as well as some of the RN transaction sequences. In general, users are not expected to use these base sequences directly. This grouping include cache initialization and invalidation virtual sequences as well.
 -- svt_chi_system_cacheline_invalidation_virtual_sequence This sequence invalidates the cache line of a RN F node. It checks the state of the cache line and initiaties the appropriate transaction If the cacheline state is dirty, a WRITEBACK is initiated. If the cacheline state is clean, an EVICT is initiated. --
CHI_SYS_BASE
* Base system virtual sequences have infrastructure, configurable aspects, utilities that are required for the extended system virtual sequences, as well as some of the RN transaction sequences. In general, users are not expected to use these base sequences directly. This grouping include cache initialization and invalidation virtual sequences as well.
 -- svt_chi_system_single_node_rn_atomic_transaction_base_virtual_sequence This sequence setups the basic attributes and methods which are used by the derived sequences to initiate atomic tranasctions.
 atomic_xact_type
Description-Unavailable
selected_atomic_xact_type
Description-Unavailable
CHI_SYS_BASE
* Base system virtual sequences have infrastructure, configurable aspects, utilities that are required for the extended system virtual sequences, as well as some of the RN transaction sequences. In general, users are not expected to use these base sequences directly. This grouping include cache initialization and invalidation virtual sequences as well.
 -- svt_chi_system_protocol_flow_ctrl_xact_hazard_virtual_sequence This sequence allows to initiate transactions to achieve hazard sceanrios. This sequence cannot be used directly, however, the derived sequences need to be used. --
CHI_LINK_SVC
* CHI Link service transaction sequences are executed on agent's Link service sequencer. These sequences generate service requests to Link layer driver to exercise Link activation, deactivation scenarios, to verify related aspects of the link partner DUT.
 -- svt_chi_link_service_activate_sequence svt_chi_link_service_active_sequence

This sequence creates an activate svt_chi_link_service request.

 --
CHI_LINK_SVC
* CHI Link service transaction sequences are executed on agent's Link service sequencer. These sequences generate service requests to Link layer driver to exercise Link activation, deactivation scenarios, to verify related aspects of the link partner DUT.
 -- svt_chi_link_service_deactivate_sequence svt_chi_link_service_deactivate_sequence

This sequence creates a deactivate svt_chi_link_service request.

 min_cycles_in_deactive
Controls the number of cycles that the sequence will be in the deactive state

CHI_LINK_SVC
* CHI Link service transaction sequences are executed on agent's Link service sequencer. These sequences generate service requests to Link layer driver to exercise Link activation, deactivation scenarios, to verify related aspects of the link partner DUT.
 -- svt_chi_link_service_random_sequence svt_chi_link_service_random_sequence

This sequence creates a random svt_chi_link_service request.

 --
CHI_LINK_SVC_BASE
* Base sequences for CHI link service transaction sequences. Base sequences have infrastructure, configurable aspects, utilities that are required for the extended Link service sequences. In general, users are not expected to use these base sequences directly.
-- svt_chi_link_service_base_sequence svt_chi_link_service_base_sequence: CHI Link Service Base sequences Base sequences have infrastructure, configurable aspects, utilities that are required for the extended Link service sequences. In general, users are not expected to use these base sequences directly.

The base sequence takes care of managing objections if extended classes or sequence clients set the manage_objection bit to 1.

 sequence_length
Sequence length in used to constrain the sequence length in sub-sequences

CHI_PROTOCOL_SERVICE
* CHI Protocol service sequences are executed on agent's Protocol service sequencer. These sequences generate service requests to Protocol layer driver to exercise System Coherency entry & exit scenarios, to verify related aspects of the link partner DUT.
 -- svt_chi_protocol_service_coherency_entry_sequence svt_chi_protocol_service_coherency_entry_sequence This sequence creates a coherency_entry svt_chi_protocol_service request. --
CHI_PROTOCOL_SERVICE
* CHI Protocol service sequences are executed on agent's Protocol service sequencer. These sequences generate service requests to Protocol layer driver to exercise System Coherency entry & exit scenarios, to verify related aspects of the link partner DUT.
 -- svt_chi_protocol_service_coherency_exit_sequence svt_chi_protocol_service_coherency_exit_sequence This sequence creates a coherency_exit svt_chi_protocol_service request. --
CHI_PROTOCOL_SERVICE
* CHI Protocol service sequences are executed on agent's Protocol service sequencer. These sequences generate service requests to Protocol layer driver to exercise System Coherency entry & exit scenarios, to verify related aspects of the link partner DUT.
 -- svt_chi_protocol_service_random_coherency_exit_sequence svt_chi_protocol_service_random_coherency_exit_sequence:
  • This sequence generates Coherency Exit service requests.
  • Number of Coherency Exit service requests to be generated will be inferred from the attribute sequence_length which can be set to zero or greater than zero.
  • sequence_length set to zero causes the sequence to run throughout the simulation.
  • This sequence does not raise and drop objections, so will not block simulation exit directly.
  • Delay attributes to control the number of clock cycles before sequence initiates subsequent coherency exit service request from the sequence, which can be set through config DB:
    • Minimum delay in clock cycles to initiate a Coherency Exit request from the point where the Sysco interface enters COHERENCY_ENABLED_STATE is inferred from the attribute coherency_exit_svc_req_min_delay.
    • Maximum delay in clock cycles to initiate a Coherency Exit request from the point where the Sysco interface enters COHERENCY_ENABLED_STATE is inferred from the attribute coherency_exit_svc_req_max_delay.
  • The above mentioned attributes (sequence_length, coherency_exit_svc_req_min_delay, coherency_exit_svc_req_min_delay) can be set through config DB.
  • Functionality: (following steps will be in a loop of sequence_length or forever loop if sequence_length is set to 0)
    • Wait for coherency state to be COHERENCY_ENABLED_STATE
      • Note that entry to coherency enabled state is expected to happen due to RN transaction sequencer sending a cacheable transaction to RN protocol driver, which causes the driver to initiate Coherency entry.
    • Apply random delay between the programmed min and max delays
    • Initiate Coherency Exit service request
  • This sequence will run on the svt_chi_protocol_service_sequencer.
  • Default Values: (Note: Required values can be programmed through config DB)
    • sequence_length set to value between 1 and 10 upon randomization
    • coherency_exit_svc_req_min_delay set to 1000
    • coherency_exit_svc_req_max_delay set to 2000
--
CHI_PROTOCOL_SERVICE
* CHI Protocol service sequences are executed on agent's Protocol service sequencer. These sequences generate service requests to Protocol layer driver to exercise System Coherency entry & exit scenarios, to verify related aspects of the link partner DUT.
 -- svt_chi_protocol_service_random_sequence svt_chi_protocol_service_random_sequence

This sequence creates a random svt_chi_protocol_service request.

 sequence_length
Controls the number of random transactions that will be generated

CHI_PROTOCOL_SERVICE_BASE
* Base sequences for CHI protocol service transaction sequences. Base sequences have infrastructure, configurable aspects, utilities that are required for the extended Protocol service sequences. In general, users are not expected to use these base sequences directly.
-- svt_chi_protocol_service_base_sequence svt_chi_protocol_service_base_sequence: This is the base class for svt_chi_protocol_service based sequences. All other svt_chi_protocol_service sequences are extended from this sequence.

The base sequence takes care of managing objections if extended classes or sequence clients set the manage_objection bit to 1.

 sequence_length
Sequence length in used to constrain the sequence length in sub-sequences

CHI_IC_SN_MEM
* CHI IC SN transaction memory response sequences set up the ICN Full Subordinate (ICN FS) VIP transaction response related attributes (delays, flows etc.), by referring to the dependent aspects such as reading from and write to ICN FS VIP memory contents (data, tags, poison etc.), agent status. These sequences need to be executed on IC SN transaction sequencer.
 -- svt_chi_ic_sn_read_data_interleave_response_sequence Class svt_chi_ic_sn_read_data_interleave_response_sequence defines a reactive sequence that will be used by the CHI ICN FS VIP Driver and IC SN XACT sequencer.
The test that is registering this sequence is expected to configure the CHI ICN FS VIP appropriately to exercise read data interlaving feature.
The sequence receives a response request of type svt_chi_ic_sn_transaction from the IC SN xact sequencer. It suspends the response of the received read transactions, and enables the interleaving of read data for those transactions. Once required number of transactions are suspended, the sequence resumes these transactions by resetting suspend_response field. The updated transaction is provided to the CHI Interconnect driver within the CHI Interconnect env. The CHI ICN FS VIP driver applies the interleaving of the read transactions accordingly.		 --
CHI_IC_SN_MEM
* CHI IC SN transaction memory response sequences set up the ICN Full Subordinate (ICN FS) VIP transaction response related attributes (delays, flows etc.), by referring to the dependent aspects such as reading from and write to ICN FS VIP memory contents (data, tags, poison etc.), agent status. These sequences need to be executed on IC SN transaction sequencer.
 -- svt_chi_ic_sn_reordering_response_sequence Class svt_chi_ic_sn_reordering_response_sequence defines a reactive sequence that will be used by the CHI ICN FS VIP Driver and IC SN XACT sequencer.
The test that is registering this sequence is expected to configure the CHI ICN FS VIP appropriately to exercise the reordering feature.
The sequence receives a response request of type svt_chi_ic_sn_transaction from the IC SN xact sequencer. It suspends the response of the received transactions. Once required number of transactiosn are suspended, the sequence resumes these transactions by resetting suspend_response field. The updated transaction is provided to the CHI Interconnect driver within the CHI Interconnect env. The CHI ICN FS VIP driver applies the reordering of the transaction responses accordingly.		 --
CHI_IC_SN_MEM
* CHI IC SN transaction memory response sequences set up the ICN Full Subordinate (ICN FS) VIP transaction response related attributes (delays, flows etc.), by referring to the dependent aspects such as reading from and write to ICN FS VIP memory contents (data, tags, poison etc.), agent status. These sequences need to be executed on IC SN transaction sequencer.
 -- svt_chi_ic_sn_suspend_response_resume_after_delay_sequence Class svt_chi_ic_sn_suspend_response_resume_after_delay_sequence defines a reactive sequence that will be used by the CHI ICN FS VIP Driver and IC SN XACT sequencer.

The sequence receives a response request of type svt_chi_ic_sn_transaction from the IC SN xact sequencer. It suspends the response of the very first request recieved and resumes it back by resetting suspend_response field after certain number of clock cycle delays. . The updated transaction is provided to the CHI Interconnect driver within the CHI Interconnect env.

--
CHI_IC_SN_MEM
* CHI IC SN transaction memory response sequences set up the ICN Full Subordinate (ICN FS) VIP transaction response related attributes (delays, flows etc.), by referring to the dependent aspects such as reading from and write to ICN FS VIP memory contents (data, tags, poison etc.), agent status. These sequences need to be executed on IC SN transaction sequencer.
 -- svt_chi_ic_sn_suspend_response_sequence Class svt_chi_ic_sn_suspend_response_sequence defines a reactive sequence that will be used by the CHI ICN FS VIP Driver and IC SN XACT sequencer.

The sequence receives a response request of type svt_chi_ic_sn_transaction from the IC SN xact sequencer. It suspends the response of the very first request recieved and resumes it back by resetting suspend_response field after certain number of clock cycle delays. . The updated transaction is provided to the CHI Interconnect driver within the CHI Interconnect env.

--
CHI_IC_SN_MEM
* CHI IC SN transaction memory response sequences set up the ICN Full Subordinate (ICN FS) VIP transaction response related attributes (delays, flows etc.), by referring to the dependent aspects such as reading from and write to ICN FS VIP memory contents (data, tags, poison etc.), agent status. These sequences need to be executed on IC SN transaction sequencer.
 -- svt_chi_ic_sn_dvm_outstanding_suspend_response_resume_after_delay_sequence Class svt_chi_ic_sn_suspend_response_resume_after_delay_sequence defines a reactive sequence that will be used by the CHI ICN FS VIP Driver and IC SN XACT sequencer.

The sequence receives a response request of type svt_chi_ic_sn_transaction from the IC SN xact sequencer. It suspends the response of the very first request recieved and resumes it back by resetting suspend_response field after certain number of clock cycle delays. . The updated transaction is provided to the CHI Interconnect driver within the CHI Interconnect env.

--
CHI_IC_SN_MEM
* CHI IC SN transaction memory response sequences set up the ICN Full Subordinate (ICN FS) VIP transaction response related attributes (delays, flows etc.), by referring to the dependent aspects such as reading from and write to ICN FS VIP memory contents (data, tags, poison etc.), agent status. These sequences need to be executed on IC SN transaction sequencer.
 -- svt_chi_ic_sn_transaction_memory_sequence Class svt_chi_ic_sn_transaction_memory_sequence defines a reactive sequence that will be used by the CHI ICN FS VIP Driver and IC SN XACT sequencer.

The sequence receives a response request of type svt_chi_ic_sn_transaction from the IC SN xact sequencer. . The updated transaction is provided to the CHI Interconnect driver within the CHI Interconnect env.

--
CHI_IC_SN_BASE
* Base sequences for CHI IC SN transaction response sequences, relevant only for Interconnect Full Subordinate(ICN FS) VIP component. Base sequences have infrastructure, configurable aspects, utilities that are required for the extended IC SN transaction response sequences. In general, users are not expected to use these base sequences directly.
-- svt_chi_ic_sn_transaction_base_sequence svt_chi_ic_sn_transaction_base_sequence: This is the base class for svt_chi_ic_sn_transaction sequences. All other svt_chi_ic_sn_transaction sequences are extended from this sequence. svt_chi_ic_sn_transaction sequences will be used by CHI ICN FS VIP driver, CHI IC SN XACT sequencer.

The base sequence takes care of managing objections if extended classes or sequence clients set the manage_objection bit to 1.

 --
CHI_SN_MEM
* CHI SN transaction memory response sequences set up the SN response related attributes (delays, flows etc.), by referring to the dependent aspects such as reading from and write to SN memory contents (data, tags, poison etc.), agent status. These sequences need to be executed on SN transaction sequencer.
 -- svt_chi_sn_transaction_memory_sequence Class svt_chi_sn_transaction_memory_sequence defines a reactive sequence that a testbench may use to make use of CHI memory within the CHI SN agent.

The sequence receives a response request of type svt_chi_sn_transaction from the SN sequencer. It then:

  • updates the response fields
  • In case of WriteNoSnp*, updates the SN memory with data in the transaction
  • IN case of ReadNoSnp, updates the data in the transaction with the data in SN memory
The updated transaction is provided to the SN protocol layer driver within the SN agent. IN case of WriteNoSnp*, the data is updated into the memory only when the transaction is complete successfully without any errors.		 --
CHI_SN_NULL
* Null sequence for SN transaction, that does not process and send any transaction
 -- svt_chi_sn_transaction_null_sequence svt_chi_sn_transaction_null_sequence

This class creates a null sequence which can be associated with a sequencer but generates no traffic.

 --
CHI_IC_SNP
* CHI IC Snoop transaction sequences generate various types of CHI IC Snoop transactions (including Stash, Fwd, DVM snoops), with configurable aspects such as addressing mode.
 -- svt_chi_ic_dvm_snoop_transaction_random_sequence Class svt_chi_ic_dvm_snoop_transaction_random_sequence defines a snoop sequence that will be used by the CHI ICN VIP Driver and IC SNOOP XACT sequencer.

The sequence generates a DVM request of type svt_chi_ic_snoop_transaction from the IC SNOOP xact sequencer within interconnect env.

 sequence_length
Parameter that controls the number of transactions that will be generated

CHI_IC_SNP
* CHI IC Snoop transaction sequences generate various types of CHI IC Snoop transactions (including Stash, Fwd, DVM snoops), with configurable aspects such as addressing mode.
 -- svt_chi_ic_snoop_transaction_directed_sequence Class svt_chi_ic_snoop_transaction_directed_sequence defines a directed snoop sequence that will be used by the CHI ICN VIP Driver and IC SNOOP XACT sequencer.

The sequence generates a request of type svt_chi_ic_snoop_transaction from the IC SNOOP xact sequencer within interconnect env.

 snp_addr_mode
Snoop address mode

base_addr
Base address: used as it is for FIXED mode, used as base for INCR mode

snp_txn_id_pattern
Snoop txn_id pattern

base_txn_id
Base txn_id: used as it is for FIXED pattern, used as base for INCR pattern

sequence_length
Parameter that controls the number of transactions that will be generated

CHI_IC_SNP
* CHI IC Snoop transaction sequences generate various types of CHI IC Snoop transactions (including Stash, Fwd, DVM snoops), with configurable aspects such as addressing mode.
 -- svt_chi_ic_snoop_transaction_random_sequence Class svt_chi_ic_snoop_transaction_random_sequence defines a snoop sequence that will be used by the CHI ICN VIP Driver and IC SNOOP XACT sequencer.

The sequence generates a request of type svt_chi_ic_snoop_transaction from the IC SNOOP xact sequencer within interconnect env.

 sequence_length
Parameter that controls the number of transactions that will be generated

CHI_IC_SNP
* CHI IC Snoop transaction sequences generate various types of CHI IC Snoop transactions (including Stash, Fwd, DVM snoops), with configurable aspects such as addressing mode.
 -- svt_chi_ic_stash_snoop_transaction_directed_sequence Class svt_chi_ic_stash_snoop_transaction_directed_sequence defines a directed stash snoop sequence that will be used by the CHI ICN VIP Driver and IC SNOOP XACT sequencer.

The sequence generates a request of type svt_chi_ic_snoop_transaction from the IC SNOOP xact sequencer within interconnect env.

 sequence_length
Parameter that controls the number of transactions that will be generated

CHI_IC_SNP_BASE
* Base sequences for CHI IC Snoop transaction sequences, relevant only for Interconnect Full Subordinate(ICN FS) VIP component. Base sequences have infrastructure, configurable aspects, utilities that are required for the extended IC Snoop transaction sequences. In general, users are not expected to use these base sequences directly.
-- svt_chi_ic_snoop_transaction_base_sequence svt_chi_ic_snoop_transaction_base_sequence: This is the base class for svt_chi_ic_snoop_transaction sequences. All other svt_chi_ic_snoop_transaction sequences are extended from this sequence. svt_chi_ic_snoop_transaction sequences will be used by CHI ICN VIP component. CHI IC SN Snoop xact sequencer and the Interconnect driver will be using it.

The base sequence takes care of managing objections if extended classes or sequence clients set the manage_objection bit to 1.

 --
CHI_SNP
* CHI Snoop transaction response sequences set up the delays and snoop response related attributes, by referring to the other dependent aspects such as cache state and contents (data, tags, poison etc.), agent status. These sequences need to be executed on RN agent snoop transaction sequencer.
 -- svt_chi_rn_directed_snoop_response_sequence Abstract:
Class svt_chi_rn_directed_snoop_response_sequence defines a sequence class that the testbench uses to provide snoop response to the RN agent present in the System agent.
The sequence receives a response object of type svt_chi_rn_snoop_transaction from RN snoop sequencer. The sequence class then sets up the snoop response attributes and provides it to the RN driver within the RN agent.
Execution phase: main_phase
Sequencer: RN agent snoop sequencer

The basis for setting up the snoop response based on snoop request type is as per "Table 6-2 Snooped cache response to snoop requests" of CHI Specification.

The handle to Cache of the RN agent is retrieved from the RN agent and following method is invoked to read the cache line corresponding to the received snoop request address: read_line_by_addr(req_resp.addr,index,data,byte_enable,is_unique,is_clean,age).
Then the output values from the above method is_unique, is_clean are used to know the state of the cacheline.
The state of cache line is used to setup the snoop response attributes based on the following information:
is_unique is_clean init_state read_status
0 0 I 0
0 0 SD 1
0 1 SC 1
1 0 UD 1
1 1 UC 1

datatransfer Data includes
0 no
1 yes

passdirty PD
0 no
1 yes

isshared final_state
0 I
1 anything other than I

Following are the attributes of the snoop resonse that are set accordingly, based on the Snp Request type:

Wherever there are more than one possible values for setting of these response attributes, the response attribute values are set randomly.

 --
CHI_SNP
* CHI Snoop transaction response sequences set up the delays and snoop response related attributes, by referring to the other dependent aspects such as cache state and contents (data, tags, poison etc.), agent status. These sequences need to be executed on RN agent snoop transaction sequencer.
 -- svt_chi_rn_snoop_response_sequence svt_chi_rn_snoop_response_sequence:
  • Provide a coherent response based on the local cache in the RN instance.
  • This is the default snoop response sequence registered by active RN agent.
  • Class svt_chi_rn_snoop_response_sequence defines a sequence class that the testbench uses to provide snoop response to the RN agent present in the System agent.
  • Execution phase: main_phase
  • Sequencer: RN agent snoop sequencer
  • The basis for setting up the snoop response based on snoop request type is as per ARM-IHI0050A 5.0: 4.7.5 Table 4-11
  • Following are the attributes of the snoop resonse that are set accordingly, based on the Snp Request type: ARM-IHI0050A 5.0: 4.7.5 Table 4-11

snp_rsp_datatransfer Data includes
0 no
1 yes

resp_pass_dirty PD
0 no
1 yes

snp_rsp_isshared final_state
0 I
1 anything other than I

Wherever there are more than one possible values for setting of these response attributes, the response attribute values are set randomly.

 --
CHI_SNP_BASE
* Base sequences for CHI Snoop transaction response sequences. Base sequences have infrastructure, configurable aspects, utilities that are required for the extended snoop transaction response sequences. In general, users are not expected to use these base sequences directly.
 -- svt_chi_snoop_transaction_base_sequence svt_chi_snoop_transaction_base_sequence: This is the base class for svt_chi_snoop_transaction sequences. All other svt_chi_snoop_transaction sequences are extended from this sequence.

The base sequence takes care of managing objections if extended classes or sequence clients set the manage_objection bit to 1.

 --
CHI_RN_NULL
* Null sequence for RN transaction, that does not generate any transactions
 -- svt_chi_rn_transaction_null_sequence svt_chi_rn_transaction_null_sequence

This class creates a null sequence which can be associated with a sequencer but generates no traffic.

 --
default -- svt_chi_ic_sn_random_response_sequence Description-Unavailable --
default -- chi_rn_barrier_directed_sequence Abstract: chi_rn_barrier_directed_sequence is used by test to provide initiator scenario information to the RN agent present in the System Env. This class defines a sequence in which a CHI WRITE followed by a CHI READ sequence is generated by assigning values to the transactions rather than randomization, and then transmitted using `uvm_send.

Execution phase: main_phase Sequencer: Master agent sequencer

 sequence_length
Parameter that controls the number of transactions that will be generated

txn_id
Transaction txn_id

xact_type
Description-Unavailable
default -- chi_rn_directed_noncoherent_xact_sequence Abstract: chi_rn_directed_noncoherent_xact_sequence defines a sequence through which non coherent transactions can be sent. Execution phase: main_phase Sequencer: Master agent sequencer sequence_length
Parameter that controls the number of transactions that will be generated

addr
Transaction address

txn_id
Transaction txn_id

xact_type
Description-Unavailable
mem_type
Description-Unavailable
is_cacheable
Description-Unavailable
requires_go_before_barrier
Description-Unavailable
is_barrier_associated
Description-Unavailable
seq_order_type
Description-Unavailable
seq_req_order_stream_id
Description-Unavailable
default -- chi_rn_noncoherent_transaction_base_sequence Abstract: chi_rn_noncoherent_transaction_base_sequence defines a sequence through which non coherent transactions can be sent. Execution phase: main_phase Sequencer: Master agent sequencer seq_req_order_stream_id
Description-Unavailable
default -- svt_chi_sn_transaction_base_sequence Description-Unavailable --
default -- svt_chi_system_coherent_virtual_sequence This sequence sends coherent transactions from multiple RN and provides mechanism to control following parameters.
  • transactions are sent from each RN only which are applicable to those RNs
  • specific transactions can be controlled seperately for each RN by setting corresponding weights
  • transaction can either be sent with random address or sequential address
  • transactions from different RNs can be set to send with overlapped addresses or completely seperate non-overlapped addresses. These are achieved by setting "addr_mode" along with "rn_start_addr[]" and "rn_end_addr[]" address array.
  • it allows user to send transactions in blocking or sequential manner
  • user can specify number of RN from which transactions will be sent as well as
  • specific RN indexes from which transactions will be sent
  • sequence takes care of cacheline initiallization in order to send transactions from correct initial state without getting dropped by RN driver layer
  • sequence provides necessary constraints to randomize above parameters
  • it also allows user to override sequence members

  • address ranges for each RN are specified through combination of "rn_start_addr" and "rn_end_addr"
  • index of rn_start_addr or rn_end_addr for a specific RN is determined by the position of that RN in the rn_index_list_for_sending_transaction[] array. Ex: rn_index_list_for_sending_transaction = {1, 3} and rn_start_addr = {32'h1000, 32'h2000} This means RN-1 and RN-3 will be used to send transactions to interconnect and RN-1 will have start address of its accessible address region as 32'h1000 and RN-3 as 32'h2000

  • even though sequence can be randomized to automatically create mutually exclusive or overlapped address regions for different RNs either random or sequential, user can also specifically set such address regions by means of configuration override
  • Failure severity of is_supported functionality of the sequence can be controlled by the attribute is_supported_failure_severity.
  • In case of addr_mode set to SEQUENTIAL_NONOVERLAPPED_ADDRESS or SEQUENTIAL_OVERLAPPED_ADDRESS, rn_end_addr is not required to be programmed as rn_end_addr will be calculated based on the rn_start_addr and the sequece_length. Even if rn_end_addr is programmed it will be overriden with the value calculated based on the rn_start_addr and the sequece_length.
  • Mix of coherent and non-coherent transactions within an RN is not allowed as there can be a possibility of mismatch attributes to the same address resulting into software error sceanrio.
  • When addr_mode is set to RANDOM_OVERLAPPED_ADDRESS or SEQUENTIAL_OVERLAPPED_ADDRESS, no 2 RN's should have transaction weights as one RN enabled with non-coherent transactions and the other with coherent transactions as ther can be mismatched memory attributes to the same address resulting into software error scenario.
  • Transaction weights for each RN should be configured through config_db setting. If not the default weights will be set wherein all the coherent transaction weights will be enabled.
  • For cache initialization, single attribute 'initialize_cachelines' which is applicable for all RN's can be programmed or 'rn_initialize_cachelines' attribute can be programmed per RN basis. When both are programmed, rn_initialize_cachelines will take the precedence.
  • For CMO transactions and atomic transactions from a particular node, the memory attributes (Cacheable, Device, EWA) and Snp_attr will be configured same as that of other coherent transactions if atleast one coherent transaction weights is programmed for that node. This behavior can be controlled through the attribute use_coherent_xacts_mem_attr_snp_attr_for_cmo_atomics per RN basis.
  • Currently this sequence doesn't factor in security bits for address calculation. i.e, tagged address

NOTE: sequence is currently supported in UVM or OVM methodology

 addr_mode
determines addresses for each transaction generated by this sequence. indicates whether random address will be chosen or if sequential addresses will be used for successive transactions.

send_blocking_transactions
determines if transactions are sent by this sequence sequentially as blocking transaction or as non-blocking outstanding transactions
num_rn_to_send_transaction
Indicates number of RNs to be used by this sequence for sending transactions
rn_index_list_for_sending_transaction
Holds RN indexes or port-id(s) to which this sequence will send transactions Total size of this list must be same as num_rn_to_send_transaction
rn_start_addr
holds start address of accessible address ranges of each RN

rn_end_addr
holds end address of accessible address ranges of each RN

default -- svt_chi_system_multi_node_random_virtual_sequence This sequence initiates Readshared transactions from multiple RN-F nodes. --
default -- svt_chi_system_single_node_cleansharedpersistsep_virtual_sequence This sequence initiates CleanSharedPersistSep transaction from the RN node specified with node_index, which can be a random node or a specific node configured by the user. Before sending each CleanSharedPersistSep transaction, cachelines of peer node are initialized to random, valid states. --
default -- svt_chi_system_single_node_stashoncesepshared_virtual_sequence This sequence initiates StashOnceSepShared transaction from the RN node specified with node_index, which can be a random node or a specific node configured by the user. --
default -- svt_chi_system_single_node_stashoncesepunique_virtual_sequence This sequence initiates StashOnceSepUnique transaction from the RN node specified with node_index, which can be a random node or a specific node configured by the user. --


13 August 2024, Copyright © 2024 Synopsys, Inc.