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-A SVT UVM Documentation - Sequence Class List

Here are the Sequence classes with brief descriptions:
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.
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. .
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. .
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. .
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. .
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. .
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. .
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. .
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. .
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. .
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. .
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. .
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.
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.
.
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.
.
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.
.
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.
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.
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.
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. .
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. .
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. .
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.
.
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.
.
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.
.
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
.
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
.
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.
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.
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.
.
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.
.
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.
.
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.
.
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.
.
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
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).
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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'.
svt_chi_system_multi_node_random_virtual_sequence This sequence initiates Readshared transactions from multiple RN-F nodes.
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
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.
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
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.
svt_chi_link_service_activate_sequence svt_chi_link_service_active_sequence
svt_chi_link_service_deactivate_sequence svt_chi_link_service_deactivate_sequence
svt_chi_link_service_random_sequence svt_chi_link_service_random_sequence
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.
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
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.
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.
svt_chi_protocol_service_random_sequence svt_chi_protocol_service_random_sequence
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.
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.
svt_chi_ic_sn_random_response_sequence Description-Unavailable
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.
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.
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.
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.
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.
svt_chi_sn_transaction_null_sequence svt_chi_sn_transaction_null_sequence
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.
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.
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.
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.
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.
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:
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

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.
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
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
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.
svt_chi_rn_makeunique_cache_initialization_directed_sequence Abstract: Sends MAKEUNIQUE transactions from an RN Execution phase: main_phase Sequencer: RN agent sequencer
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
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
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
svt_chi_rn_exclusive_access_sequence Abstract: This class defines a sequence for exclusive access support. Execution phase: main_phase Sequencer: RN agent sequencer
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
svt_chi_rn_go_noncoherent_sequence RN transaction non-coherent transaction type sequence that exercises global observability for pre-barrier transactions
svt_chi_rn_ecbarrier_sequence RN transaction ECBARRIER sequence
svt_chi_rn_eobarrier_sequence RN transaction EOBARRIER sequence
svt_chi_rn_transaction_dvm_sync_sequence svt_chi_rn_transaction_dvm_sync_sequence
svt_chi_rn_transaction_dvm_write_semantic_sequence svt_chi_rn_transaction_dvm_write_semantic_sequence
svt_chi_rn_coherent_transaction_base_sequence svt_chi_rn_coherent_transaction_base_sequence
svt_chi_rn_transaction_null_sequence svt_chi_rn_transaction_null_sequence
svt_chi_rn_transaction_xact_type_sequence svt_chi_rn_transaction_xact_type_sequence
svt_chi_rn_transaction_random_sequence svt_chi_rn_transaction_random_sequence
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.
svt_chi_system_rn_coherent_transaction_base_virtual_sequence This is the base sequence for:
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.
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.
svt_chi_sn_transaction_base_sequence Description-Unavailable
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.
13 August 2024, Copyright © 2024 Synopsys, Inc.