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

svt_chi_transaction Class Reference

Inheritance diagram for class svt_chi_transaction:

List of all members.


Detailed Description

This class contains fields required for CHI RN and SN transaction. This class acts as a base class for RN and SN transaction classes.



Public Member Functions

virtual function vmm_data  allocate ( )
virtual function unsigned int  byte_pack ( ref logic [7:0] bytes[], input int unsigned offset, input int kind )
virtual function unsigned int  byte_unpack ( const ref logic [7:0] bytes[], input int unsigned offset, input int len, input int kind )
virtual function bit  compare ( vmm_data to, output string diff, input int kind )
virtual function vmm_data  copy ( vmm_data to = null )
static function svt_chi_transaction  create_instance ( vmm_object parent, string name, string fname = "", int lineno = 0 )
function real  get_compack_realtime ( )
function dat_msg_type_enum  get_dat_flit_type_for_writes_atomics ( )
function byte_enable_pattern_enum  get_entire_byte_enable_pattern_type ( )
function data_pattern_enum  get_entire_write_data_pattern_type ( )
function bit [SVT_CHI_MAX_TAGGED_ADDR_WIDTH-1:0]  get_max_byte_address ( bit use_tagged_addr = 0 )
function int  get_max_byte_idx ( )
function bit [SVT_CHI_MAX_TAGGED_ADDR_WIDTH-1:0]  get_min_byte_address ( bit use_tagged_addr = 0 )
function int  get_min_byte_idx ( )
function bit  get_ns_from_tagged_addr ( bit [SVT_CHI_MAX_TAGGED_ADDR_WIDTH-1:0] tagged_addr )
function realtime  get_req_accept_realtime ( )
function bit  get_resperr_status ( input svt_chi_common_transaction :: resp_err_status_enum response_type, input bit get_first_match = 1'b1 )
function realtime  get_resp_status_accept_realtime ( )
virtual function string  get_typename ( )
function int  get_valid_byte_count ( )
function bit [(SVT_CHI_XACT_MAX_BE_WIDTH-1):0]  get_valid_wysiwyg_byte_enable ( )
function bit [(SVT_CHI_XACT_MAX_DATA_WIDTH-1):0]  get_valid_wysiwyg_data ( )
function void  get_write_data_and_byte_enable_pattern_type ( )
function xact_category_enum  get_xact_category ( )
function void  get_xacts_to_same_cacheline_started_before_curr_xact ( output svt_chi_transaction xacts_to_same_cache_line[$] )
function bit  is_cbwrite_xact_involves_data ( )
function bit  is_cmo_xact ( )
function bit  is_copyback_write_xact ( )
function bit  is_dvm_sync ( )
function bit  is_final_completing_flit_from_rn ( )
function bit  is_ordered_read_xact ( )
function bit  is_req_order_asserted ( )
virtual function bit  is_valid ( bit silent = 1, int kind = -1 )
static function void  override_with_copy ( string name, svt_chi_transaction factory, vmm_log log, string fname = "", int lineno = 0 )
static function void  override_with_new ( string name, svt_chi_transaction factory, vmm_log log, string fname = "", int lineno = 0 )
function void  pack_byte_enable_to_byte_stream ( input bit [SVT_CHI_XACT_MAX_BE_WIDTH-1:0] byte_enable_to_pack, output bit packed_byte_enable[] )
function void  pack_data_to_byte_stream ( input bit [SVT_CHI_XACT_MAX_DATA_WIDTH-1:0] data_to_pack, output bit [7:0] packed_data[] )
function queue_of_str  print_pending_flits ( svt_chi_common_transaction common_xact )
virtual function string  psdisplay ( string prefix = "" )
function int  reasonable_constraint_mode ( bit on_off )
function void  set_combined_responses_order ( )
function void  set_end_of_transaction ( bit aborted = 0 )
function void  set_req_accept_realtime ( )
function void  set_resp_status_accept_realtime ( )
static function svt_chi_transaction  this_type ( )
function void  unpack_byte_stream_to_byte_enable ( input bit byte_enable_to_unpack[], output bit [SVT_CHI_XACT_MAX_BE_WIDTH-1:0] unpacked_byte_enable )
function void  unpack_byte_stream_to_data ( input bit [7:0] data_to_unpack[], output bit [SVT_CHI_XACT_MAX_DATA_WIDTH-1:0] unpacked_data )
function void  do_all ( vmm_data :: do_what_e do_what, ref logic [7:0] pack[], const ref logic [7:0] unpack[] )
function void  new ( vmm_log log = null )
static function void  Xadd_patternX ( vmm_factory_pattern_info fact )

Public Attributes

rand bit  allocate_in_cache = 1; 
svt_chi_transaction  associated_barrier_xact 
svt_chi_transaction :: auto_generation_category_enum  auto_generation_category 
rand bit [(SVT_CHI_XACT_MAX_BE_WIDTH-1):0]  byte_enable = 0; 
bit  cache_update_complete = 0; 
svt_chi_transaction :: comp_dbid_responses_order_enum  comp_dbid_responses_order 
rand int  comp_to_dbid_flit_delay = SVT_CHI_MIN_COMPTODBID_DELAY
int  current_dat_flit_num = 0; 
rand bit [(SVT_CHI_XACT_MAX_DATA_WIDTH-1):0]  data = 0; 
rand bit [(SVT_CHI_XACT_DAT_RSVDC_WIDTH-1):0]  dat_rsvdc [] 
rand svt_chi_common_transaction :: resp_err_status_enum  data_resp_err_status[] 
rand svt_chi_common_transaction :: dbid_policy_enum  dbid_policy 
rand int  dbid_to_comp_flit_delay = SVT_CHI_MIN_DBIDTOCOMP_DELAY
bit  enable_interleave = 0; 
svt_chi_common_transaction :: excl_access_status_enum  excl_access_status 
svt_chi_common_transaction :: excl_mon_status_enum  excl_mon_status 
bit  excl_store_cache_update = 0; 
svt_chi_common_transaction :: excl_xact_drop_cond_enum  excl_xact_drop_cond 
svt_chi_common_transaction :: cache_state_enum  final_cache_line_state 
rand bit [SVT_CHI_HN_NODE_IDX_WIDTH-1:0]  hn_node_idx = 0; 
svt_chi_common_transaction :: cache_state_enum  initial_cache_line_state 
int  interleaved_group_object_num = -1; 
rand svt_chi_transaction :: interleave_pattern_enum  interleave_pattern 
bit  is_auto_generated = 0; 
bit  is_cached_data = 0; 
bit  is_cacheline_reserved = 1'b0; 
bit  is_cancelled_on_retry = 0; 
bit  is_comp_received = 0; 
bit  is_dbid_received = 0; 
bit  is_p_crd_grant_allocated = 0; 
rand bit  is_p_crd_grant_before_retry_ack = 0; 
bit  is_read_data_unknown = 1'b0; 
rand bit  is_retried_with_original_qos = 1; 
rand bit  is_retried_with_original_rsvdc = 1; 
rand bit  is_retried_with_original_tgt_id = 1; 
rand bit  is_retried_with_original_txn_id = 1; 
bit  is_tgt_id_remapped = 0; 
bit  is_xact_dropped = 0; 
svt_chi_transaction :: link_activation_deactivation_initiator_info_enum  link_deactivation_during_xact_queue[$] 
svt_chi_transaction :: link_activation_deactivation_initiator_info_enum  link_reactivation_during_xact_queue[$] 
int  num_dat_flits = 0; 
bit [(SVT_CHI_TGT_ID_WIDTH-1):0]  original_tgt_id = 0; 
rand int  pcreditgrant_to_retryack_flit_delay = SVT_CHI_MIN_PCREDITGRANTTORETRYACK_DELAY
rand int  random_interleave_array [] 
rand svt_chi_transaction :: reference_event_for_comp_to_dbid_flit_delay_enum  reference_event_for_comp_to_dbid_flit_delay 
rand svt_chi_transaction :: reference_event_for_dbid_to_comp_flit_delay_enum  reference_event_for_dbid_to_comp_flit_delay 
rand svt_chi_transaction :: reference_event_for_pcreditgrant_to_retryack_flit_delay_enum  reference_event_for_pcreditgrant_to_retryack_flit_delay 
rand svt_chi_transaction :: reference_event_for_req_to_comp_flit_delay_enum  reference_event_for_req_to_comp_flit_delay 
rand svt_chi_transaction :: reference_event_for_req_to_compdata_flit_delay_enum  reference_event_for_req_to_compdata_flit_delay 
rand svt_chi_transaction :: reference_event_for_req_to_compdbid_flit_delay_enum  reference_event_for_req_to_compdbid_flit_delay 
rand svt_chi_transaction :: reference_event_for_req_to_dbid_flit_delay_enum  reference_event_for_req_to_dbid_flit_delay 
rand svt_chi_transaction :: reference_event_for_req_to_pcreditgrant_flit_delay_enum  reference_event_for_req_to_pcreditgrant_flit_delay 
rand svt_chi_transaction :: reference_event_for_req_to_retryack_flit_delay_enum  reference_event_for_req_to_retryack_flit_delay 
rand svt_chi_transaction :: reference_event_for_retryack_to_pcreditgrant_flit_delay_enum  reference_event_for_retryack_to_pcreditgrant_flit_delay 
realtime  req_accept_realtime = 0; 
rand int unsigned  req_order_stream_id = 0; 
rand int  req_to_comp_flit_delay = SVT_CHI_MIN_REQTOCOMP_DELAY
rand int  req_to_compdata_flit_delay = SVT_CHI_MIN_REQTOCOMPDATA_DELAY
rand int  req_to_compdbid_flit_delay = SVT_CHI_MIN_REQTOCOMPDBID_DELAY
rand int  req_to_dbid_flit_delay = SVT_CHI_MIN_REQTODBID_DELAY
rand int  req_to_pcreditgrant_flit_delay = SVT_CHI_MIN_REQTOPCREDITGRANT_DELAY
rand int  req_to_retryack_flit_delay = SVT_CHI_MIN_REQTORETRYACK_DELAY
realtime  resp_status_accept_realtime = 0; 
rand svt_chi_common_transaction :: resp_err_status_enum  response_resp_err_status 
rand int  retryack_to_pcreditgrant_flit_delay = SVT_CHI_MIN_RETRYACKTOPCREDITGRANT_DELAY
svt_chi_snoop_transaction  snoop_xacts_started_after_curr_xact_queue [$] 
svt_chi_common_transaction :: chi_suspend_resume_status_enum  suspend_wr_data_status 
svt_chi_common_transaction :: byte_enable_pattern_enum  write_dat_be_pattern[] 
svt_chi_common_transaction :: data_pattern_enum  write_dat_data_pattern[] 
svt_chi_transaction :: xact_flow_category_enum  xact_flow_category_type 
rand svt_chi_common_transaction :: xact_type_enum  xact_type 
svt_chi_transaction  xacts_started_before_curr_xact_queue [$] 

Protected Attributes

static protected svt_chi_transaction  __vmm_rhs 

Member Typedefs

 typedef enum  auto_generation_category_enum 
 typedef enum  comp_dbid_responses_order_enum 
 typedef enum  comp_persist_responses_order_enum 
 typedef enum  comp_stashdone_responses_order_enum 
 typedef enum  interleave_pattern_enum 
 typedef enum  link_activation_deactivation_initiator_info_enum 
 typedef enum  reference_event_for_comp_to_dbid_flit_delay_enum 
 typedef enum  reference_event_for_dbid_to_comp_flit_delay_enum 
 typedef enum  reference_event_for_pcreditgrant_to_retryack_flit_delay_enum 
 typedef enum  reference_event_for_req_to_comp_flit_delay_enum 
 typedef enum  reference_event_for_req_to_compdata_flit_delay_enum 
 typedef enum  reference_event_for_req_to_compdbid_flit_delay_enum 
 typedef enum  reference_event_for_req_to_dbid_flit_delay_enum 
 typedef enum  reference_event_for_req_to_pcreditgrant_flit_delay_enum 
 typedef enum  reference_event_for_req_to_retryack_flit_delay_enum 
 typedef enum  reference_event_for_retryack_to_pcreditgrant_flit_delay_enum 
 typedef enum  xact_category_enum 
 typedef enum  xact_flow_category_enum 
 typedef class  _factory_base 

Constraints

constraint  chi_transaction_valid_ranges  ( )
constraint  reasonable_comp_to_dbid_flit_delay  ( )
constraint  reasonable_dbid_to_comp_flit_delay  ( )
constraint  reasonable_pcreditgrant_to_retryack_flit_delay  ( )
constraint  reasonable_req_to_comp_flit_delay  ( )
constraint  reasonable_req_to_compdata_flit_delay  ( )
constraint  reasonable_req_to_compdbid_flit_delay  ( )
constraint  reasonable_req_to_dbid_flit_delay  ( )
constraint  reasonable_req_to_pcreditgrant_flit_delay  ( )
constraint  reasonable_req_to_retryack_flit_delay  ( )
constraint  reasonable_retryack_to_pcreditgrant_flit_delay  ( )


Member Function Documentation

 virtual function vmm_data
 svt_chi_transaction::allocate

 (   ) 


 Superseded functions 
 vmm_data :: allocate 
 svt_data :: allocate 
 svt_transaction :: allocate 
 svt_chi_common_transaction :: allocate 
 svt_chi_base_transaction :: allocate 
 Superseding functions 
 svt_chi_rn_transaction :: allocate 
 svt_chi_ic_rn_transaction :: allocate 
 svt_chi_sn_transaction :: allocate 
 svt_chi_ic_sn_transaction :: allocate 

 virtual function unsigned int
 svt_chi_transaction::byte_pack

 (  ref logic [7:0] bytes [], input int unsigned offset , input int kind  ) 


 Superseded functions 
 vmm_data :: byte_pack 
 svt_data :: byte_pack 
 svt_transaction :: byte_pack 
 svt_chi_common_transaction :: byte_pack 
 svt_chi_base_transaction :: byte_pack 
 Superseding functions 
 svt_chi_rn_transaction :: byte_pack 
 svt_chi_ic_rn_transaction :: byte_pack 
 svt_chi_sn_transaction :: byte_pack 
 svt_chi_ic_sn_transaction :: byte_pack 

 virtual function unsigned int
 svt_chi_transaction::byte_unpack

 (  const ref logic [7:0] bytes [], input int unsigned offset , input int len , input int kind  ) 


 Superseded functions 
 vmm_data :: byte_unpack 
 svt_data :: byte_unpack 
 svt_transaction :: byte_unpack 
 svt_chi_common_transaction :: byte_unpack 
 svt_chi_base_transaction :: byte_unpack 
 Superseding functions 
 svt_chi_rn_transaction :: byte_unpack 
 svt_chi_ic_rn_transaction :: byte_unpack 
 svt_chi_sn_transaction :: byte_unpack 
 svt_chi_ic_sn_transaction :: byte_unpack 

 virtual function bit
 svt_chi_transaction::compare

 (  vmm_data to , output string diff , input int kind  ) 


 Superseded functions 
 vmm_data :: compare 
 svt_data :: compare 
 svt_transaction :: compare 
 svt_chi_common_transaction :: compare 
 svt_chi_base_transaction :: compare 
 Superseding functions 
 svt_chi_rn_transaction :: compare 
 svt_chi_ic_rn_transaction :: compare 
 svt_chi_sn_transaction :: compare 
 svt_chi_ic_sn_transaction :: compare 

 virtual function vmm_data
 svt_chi_transaction::copy

 (  vmm_data to = null  ) 


 Superseded functions 
 vmm_data :: copy 
 svt_data :: copy 
 svt_transaction :: copy 
 svt_chi_common_transaction :: copy 
 svt_chi_base_transaction :: copy 
 Superseding functions 
 svt_chi_rn_transaction :: copy 
 svt_chi_ic_rn_transaction :: copy 
 svt_chi_sn_transaction :: copy 
 svt_chi_ic_sn_transaction :: copy 

 static function svt_chi_transaction
 svt_chi_transaction::create_instance

 (  vmm_object parent , string name , string fname = "", int lineno = 0  ) 


 Superseded functions 
 svt_chi_common_transaction :: create_instance 
 svt_chi_base_transaction :: create_instance 
 Superseding functions 
 svt_chi_rn_transaction :: create_instance 
 svt_chi_ic_rn_transaction :: create_instance 
 svt_chi_sn_transaction :: create_instance 
 svt_chi_ic_sn_transaction :: create_instance 

  function real
 svt_chi_transaction::get_compack_realtime

 (   ) 


This method returns the time at which the compack flit is completed.

  function dat_msg_type_enum
 svt_chi_transaction::get_dat_flit_type_for_writes_atomics

 (   ) 


Returns the write data type observed for a write/atomic transaction. This function is internal to VIP and used only for coverage collection.

  function byte_enable_pattern_enum
 svt_chi_transaction::get_entire_byte_enable_pattern_type

 (   ) 


Used to get the byte_enable pattern of entire write data

  function data_pattern_enum
 svt_chi_transaction::get_entire_write_data_pattern_type

 (   ) 


Used to get the data pattern of entire write data

  function bit [SVT_CHI_MAX_TAGGED_ADDR_WIDTH-1:0]
 svt_chi_transaction::get_max_byte_address

 (  bit use_tagged_addr = 0  ) 


Returns maximum byte address for the cacheline corresponding to current address

 Superseded functions 
 svt_chi_common_transaction :: get_max_byte_address 

  function int
 svt_chi_transaction::get_max_byte_idx

 (   ) 


Returns maximum byte inded for the cacheline corresponding to current address

  function bit [SVT_CHI_MAX_TAGGED_ADDR_WIDTH-1:0]
 svt_chi_transaction::get_min_byte_address

 (  bit use_tagged_addr = 0  ) 


Returns minimum byte address for the cacheline corresponding to current address

 Superseded functions 
 svt_chi_common_transaction :: get_min_byte_address 

  function int
 svt_chi_transaction::get_min_byte_idx

 (   ) 


Returns minimum byte index for the cacheline corresponding to current address

  function bit
 svt_chi_transaction::get_ns_from_tagged_addr

 (  bit [SVT_CHI_MAX_TAGGED_ADDR_WIDTH-1:0] tagged_addr  ) 


Returns NS bit from the provided CHI tagged address.

  function realtime
 svt_chi_transaction::get_req_accept_realtime

 (   ) 


Accessor method which returns the time at which the req is accepted as a realtime value.

  function bit
 svt_chi_transaction::get_resperr_status

 (  input svt_chi_common_transaction :: resp_err_status_enum response_type , input bit get_first_match = 1'b1  ) 


This method is used to check for a particular response type provided as an argument to this method by traversing the data_resp_err_status array and checking the value in the response_resp_err_status attribute.

response_type - The response type to search.

get_first_match - Flag to indicate whether to get the first match for the response_type or to match the response_type with all the values of data_resp_err_status array and response_resp_err_status attribute. In case this argument is set to 0, the method will return 1 only when the response_type matches with all the values of data_resp_err_status array and response_resp_err_status attribute based on transaction type. Default value is 1 for this argument which allows the method to return after the first matching occurance is found.

Return values - Returns 1 if the particular response type is found else returns 0.

  function realtime
 svt_chi_transaction::get_resp_status_accept_realtime

 (   ) 


Accessor method which returns the time at which CompAck is observed as a realtime value.

 virtual function string
 svt_chi_transaction::get_typename

 (   ) 


 Superseded functions 
 svt_chi_common_transaction :: get_typename 
 svt_chi_base_transaction :: get_typename 
 Superseding functions 
 svt_chi_rn_transaction :: get_typename 
 svt_chi_ic_rn_transaction :: get_typename 
 svt_chi_sn_transaction :: get_typename 
 svt_chi_ic_sn_transaction :: get_typename 

  function int
 svt_chi_transaction::get_valid_byte_count

 (   ) 


Returns number of byte whose byte_enable is '1'

  function bit [(SVT_CHI_XACT_MAX_BE_WIDTH-1):0]
 svt_chi_transaction::get_valid_wysiwyg_byte_enable

 (   ) 


Returns byte_enable of the transaction in wysiwyg format with all the bits corresponding to invalid byte lanes maksed as zeros.

  function bit [(SVT_CHI_XACT_MAX_DATA_WIDTH-1):0]
 svt_chi_transaction::get_valid_wysiwyg_data

 (   ) 


Returns data of the transaction in wysiwyg format with all the bits corresponding to invalid byte lanes maksed as zeros.

  function void
 svt_chi_transaction::get_write_data_and_byte_enable_pattern_type

 (   ) 


Used to get the byte_enable pattern of write data flit

  function xact_category_enum
 svt_chi_transaction::get_xact_category

 (   ) 


Returns category type for the current transaction object

  function void
 svt_chi_transaction::get_xacts_to_same_cacheline_started_before_curr_xact

 (  output svt_chi_transaction xacts_to_same_cache_line [$]  ) 


This API gives out xacts to the same cache line that are started before this transaction.

  function bit
 svt_chi_transaction::is_cbwrite_xact_involves_data

 (   ) 


Indicates if the copyback write transaction involves data response (compdbidresp -> copybackwritedata) or not (comp -> compack).
  • 1 : compdbidresp -> copybackwritedata
  • 0 : comp -> compack
This function is internal to VIP and used only for coverage collection and should be called only after the transaction is complete as it looks at rsp/data status attributes.

  function bit
 svt_chi_transaction::is_cmo_xact

 (   ) 


Determines if this transaction is a CMO transaction.

  function bit
 svt_chi_transaction::is_copyback_write_xact

 (   ) 


Determines if this transaction is a Copyback transaction (includes Combined CBWrite and (P)CMO type transactions).

  function bit
 svt_chi_transaction::is_dvm_sync

 (   ) 


Determines if this transaction is a DVM sync

  function bit
 svt_chi_transaction::is_final_completing_flit_from_rn

 (   ) 


Method which indicates if the completing flit of the transaction is sent or expected to be sent by the RN.

  function bit
 svt_chi_transaction::is_ordered_read_xact

 (   ) 


Determines if the transaction is an ordered read transaction.

  function bit
 svt_chi_transaction::is_req_order_asserted

 (   ) 


Determines if the transaction's attribute for request ordering is asserted.

 virtual function bit
 svt_chi_transaction::is_valid

 (  bit silent = 1, int kind = -1  ) 


 Superseded functions 
 vmm_data :: is_valid 
 svt_data :: is_valid 
 svt_transaction :: is_valid 
 svt_chi_common_transaction :: is_valid 
 svt_chi_base_transaction :: is_valid 
 Superseding functions 
 svt_chi_rn_transaction :: is_valid 
 svt_chi_ic_rn_transaction :: is_valid 
 svt_chi_sn_transaction :: is_valid 
 svt_chi_ic_sn_transaction :: is_valid 

 static function void
 svt_chi_transaction::override_with_copy

 (  string name , svt_chi_transaction factory , vmm_log log , string fname = "", int lineno = 0  ) 

 static function void
 svt_chi_transaction::override_with_new

 (  string name , svt_chi_transaction factory , vmm_log log , string fname = "", int lineno = 0  ) 

  function void
 svt_chi_transaction::pack_byte_enable_to_byte_stream

 (  input bit [SVT_CHI_XACT_MAX_BE_WIDTH-1:0] byte_enable_to_pack , output bit packed_byte_enable []  ) 


Returns the byte_enable in the byte_enable_to_pack[] field as a byte stream based on the address. The assumption is that byte_enable[] field of this class have been passed as arguments to byte_enable_to_pack[] field. The output has byte_enable packed with the first element corresponding to the address aligned to the data_size.

byte_enable_to_pack - byte_enable to be packed

packed_byte_enable - [] Output byte stream with packed byte_enable

  function void
 svt_chi_transaction::pack_data_to_byte_stream

 (  input bit [SVT_CHI_XACT_MAX_DATA_WIDTH-1:0] data_to_pack , output bit [7:0] packed_data []  ) 


Returns the data in the data_to_pack[] field as a byte stream based on the address. The assumption is that data[] field of this class have been passed as arguments to data_to_pack[] field. The output has data packed with the first element corresponding to the address aligned to the data_size.

data_to_pack - Data to be packed

packed_data - [] Output byte stream with packed data

  function queue_of_str
 svt_chi_transaction::print_pending_flits

 (  svt_chi_common_transaction common_xact  ) 


This method is used to printh the information of Pending flits for a transaction at the point of transaction inactivity timeout

 virtual function string
 svt_chi_transaction::psdisplay

 (  string prefix = ""  ) 


 Superseded functions 
 vmm_object :: psdisplay 
 vmm_data :: psdisplay 
 svt_data :: psdisplay 
 svt_transaction :: psdisplay 
 svt_chi_common_transaction :: psdisplay 
 svt_chi_base_transaction :: psdisplay 
 Superseding functions 
 svt_chi_rn_transaction :: psdisplay 
 svt_chi_ic_rn_transaction :: psdisplay 
 svt_chi_sn_transaction :: psdisplay 
 svt_chi_ic_sn_transaction :: psdisplay 

  function int
 svt_chi_transaction::reasonable_constraint_mode

 (  bit on_off  ) 


Method to turn reasonable constraints on/off as a block.

 Superseded functions 
 svt_data :: reasonable_constraint_mode 
 svt_chi_common_transaction :: reasonable_constraint_mode 
 svt_chi_base_transaction :: reasonable_constraint_mode 
 Superseding functions 
 svt_chi_rn_transaction :: reasonable_constraint_mode 
 svt_chi_sn_transaction :: reasonable_constraint_mode 
 svt_chi_ic_sn_transaction :: reasonable_constraint_mode 

  function void
 svt_chi_transaction::set_combined_responses_order

 (   ) 


Sets Combined response attributes:
  • comp_dbid_responses_order
  • comp_persist_responses_order
  • comp_stashdone_responses_order
This function is internal to VIP and used only for coverage collection.

  function void
 svt_chi_transaction::set_end_of_transaction

 (  bit aborted = 0  ) 


Mark end of transaction.

aborted - indicates that, tranaction is aborted. Currently this argument is not used for any functionality.

  function void
 svt_chi_transaction::set_req_accept_realtime

 (   ) 


Method setting the req_accept_time to the current simulation time.

  function void
 svt_chi_transaction::set_resp_status_accept_realtime

 (   ) 


Method setting the resp_status_accept_realtime to the current simulation time.

 static function svt_chi_transaction
 svt_chi_transaction::this_type

 (   ) 


 Superseded functions 
 svt_chi_common_transaction :: this_type 
 svt_chi_base_transaction :: this_type 
 Superseding functions 
 svt_chi_rn_transaction :: this_type 
 svt_chi_ic_rn_transaction :: this_type 
 svt_chi_sn_transaction :: this_type 
 svt_chi_ic_sn_transaction :: this_type 

  function void
 svt_chi_transaction::unpack_byte_stream_to_byte_enable

 (  input bit byte_enable_to_unpack [], output bit [SVT_CHI_XACT_MAX_BE_WIDTH-1:0] unpacked_byte_enable  ) 


Populates the byte_enable in the byte_enable_to_unpack[] field into unpacked_byte_enable based on the address. The first element in the byte_enable_to_unpack must correspond to the address aligned to data_size and subsequent elements must correspond to consecutive address locations. The size of this array must be equal to the number of bytes transferred based on data_size.

byte_enable_to_unpack - byte_enable to be unpacked

unpacked_byte_enable - [] Unpacked byte_enable

  function void
 svt_chi_transaction::unpack_byte_stream_to_data

 (  input bit [7:0] data_to_unpack [], output bit [SVT_CHI_XACT_MAX_DATA_WIDTH-1:0] unpacked_data  ) 


Populates the data in the data_to_unpack[] field into unpacked_data based on the address. The first element in the data_to_unpack must correspond to the address aligned to data_size and subsequent elements must correspond to consecutive address locations. The size of this array must be equal to the number of bytes transferred based on data_size.

data_to_unpack - Data to be unpacked

unpacked_data - [] Unpacked data

  function void
 svt_chi_transaction::do_all

 (  vmm_data :: do_what_e do_what , ref logic [7:0] pack [], const ref logic [7:0] unpack []  ) 


 Superseded functions 
 vmm_data :: do_all 
 svt_data :: do_all 
 svt_transaction :: do_all 
 svt_chi_common_transaction :: do_all 
 svt_chi_base_transaction :: do_all 
 Superseding functions 
 svt_chi_rn_transaction :: do_all 
 svt_chi_ic_rn_transaction :: do_all 
 svt_chi_sn_transaction :: do_all 
 svt_chi_ic_sn_transaction :: do_all 

  function void
 svt_chi_transaction::new

 (  vmm_log log = null  ) 


CONSTRUCTOR: Create a new transaction instance.

log - VMM Log instance used for reporting.


 Superseded functions 
 svt_chi_common_transaction :: new 
 svt_chi_base_transaction :: new 
 Superseding functions 
 svt_chi_rn_transaction :: new 
 svt_chi_ic_rn_transaction :: new 
 svt_chi_sn_transaction :: new 
 svt_chi_ic_sn_transaction :: new 

 static function void
 svt_chi_transaction::Xadd_patternX

 (  vmm_factory_pattern_info fact  ) 


 Superseded functions 
 svt_chi_common_transaction :: Xadd_patternX 
 svt_chi_base_transaction :: Xadd_patternX 
 Superseding functions 
 svt_chi_rn_transaction :: Xadd_patternX 
 svt_chi_ic_rn_transaction :: Xadd_patternX 
 svt_chi_sn_transaction :: Xadd_patternX 
 svt_chi_ic_sn_transaction :: Xadd_patternX 


Member Attribute Documentation

 rand bit  attribute
 svt_chi_transaction::allocate_in_cache = 1


Indicates if the data as given in data field is to be allocated in cache. Currently applicable only for CLEANUNIQUE and MakeReadUnique transaction. . A CLEANUNIQUE transaction is used to write partial data into the cache when the requesting RN already has the cacheline, but the cache line is in a shared state. . If this bit is set, the data as given in data field will be written into cache according to the byte-enables set in the byte_enable field. Also, the cacheline will move to a UD state. In case of CleanUnique, if the cacheline gets deleted by an incoming snoop before this transaction completes, the cacheline moves to a UDP state. In case of MakeReadUnique, if the cacheline gets deleted by an incoming Snoop before the transaction completes, the cacheine will be updated with the transaction data, given by "makereadunique_read_data" and then overriden with the data and byte_enable programmed in the transaction handle. The cacheline will move to UD state. . If this bit is unset, the data given in the data field has no relevance. In case of CLeanUnique, if the cacheline gets deleted by an incoming snoop before this transaction completes, the cacheline moves to a UCE state. In case of MakeReadUnique, if the cacheline gets deleted by an incoming Snoop before the transaction completes, the cacheline moves to the state specified in the read data response.

 svt_chi_transaction  attribute
 svt_chi_transaction::associated_barrier_xact


This member points to a CHI transaction of barrier type (EOBarrier or ECBarrier) associated to this current transaction. When associated_barrier_xact is null, it indicates that this current transaction is not a post-barrier transaction. When associated_barrier_xact is non-null, this current transaction will wait for the response of the barrier transaction associated_barrier_xact, before this transaction can be transmitted.

Please refer to User Guide for more details on usage of this member.

 svt_chi_transaction :: auto_generation_category_enum  attribute
 svt_chi_transaction::auto_generation_category = NOT_AUTO_GENERATED


Indicates the reason for VIP to issue an auto-generated transaction.
Applicable only for Active RN. Applicable only when is_auto_generated bit is set to 1.
When this field is set to:
  • NOT_AUTO_GENERATED: This transaction is not auto generated.
  • CACHE_FULL_AND_ENTRY_IN_CACHE_NEEDED: This transaction is auto-generated when the cache is full and an entry needs to be evicted from the cache.
  • WRITE_TO_MEMEORY_BEFORE_CMO: This transaction is auto-generated when user supplied a cache maintenance transaction and the protocol requires that the cache line is first written into memory before sending the cache maintenance transaction.
  • INVALIDATE_CACHELINE_BEFORE_ATOMIC_WITH_SNOOPME_ZERO: This transaction is auto-generated when user supplied an atomic transaction with snoopme set to zero and the protocol requires that the cache line is first invalidated before sending the atomic transaction.
  • SYSCO_CACHE_CLEANUP: This transaction is auto-generated when Cache copies are invalidated/cleaned up before moving to the Coherency DISCONNECT phase
  • AUTO_READ_AFTER_PARTIAL_WRITE_XACT: This transaction is auto-generated when user supplies a partial write transaction. In this case, the VIP auto-generates a full cacheline read for the partial write transactions.
This is a read-only member and should not be modified by the user.

 rand bit [(SVT_CHI_XACT_MAX_BE_WIDTH-1):0]  attribute
 svt_chi_transaction::byte_enable = 0


This field defines the byte enable.
This field is applicable for write data, DVM payload.
This field is not applicable for Atomic transactions and will be ignored.
It consists of a bit for each data byte in the transaction data, which when set indicates that the corresponding data byte is valid.
For DVM, this field is always right aligned. For other transaction types, the details are described below.
When svt_chi_node_configuration :: wysiwyg_enable is set to 1: The byte_enable corresponds to all 64 bytes irrespective of data size of the transaction.

When svt_chi_node_configuration :: wysiwyg_enable is set to 0: The byte_enable value is right aligned.
  • For Normal type memory transactions, this corresponds to number of bytes as per the data size of the transaction, starting from the address that is aligned to the data size.
  • For Device type memory transactions, this corresponds to the addresses starting from transaction's address, upto next aligned address to the data size.

 bit  attribute
 svt_chi_transaction::cache_update_complete = 0


This is a flag that indicates whether the cache has been updated for the current transaction. Only applicable in case of allocation read and dataless transactions initiated from active RN-F.
This will be set internally and must not be programmed by the user.
Default value is 0.

 svt_chi_transaction :: comp_dbid_responses_order_enum  attribute
 svt_chi_transaction::comp_dbid_responses_order = NOT_SET_COMP_DBIDRESP_ORDER


For a Write transaction when separate comp and dbidresp responses are observed, this attribute indicates the order in which COMP and DBIDRESP are observed.
  • NOT_SET_COMP_DBIDRESP_ORDER: This attribute is not set.
  • COMP_DBIDRESP : First Comp respons is observed, later DBIDResp is observed.
  • DBIDRESP_COMP : First DBIDResp respons is observed, later Comp is observed.
  • COMP_DBIDRESPORD : First Comp respons is observed, later DBIDRespOrd is observed.
  • DBIDRESPORD_COMP : First DBIDRespOrd respons is observed, later Comp is observed.
  • COMBINED_COMPDBIDRESP : Combined CompDBIDResp respons is observed.
Applicable only in Active RN. This is a read-only attribute that is populated internally in the VIP and used for coverage purposes.

 rand int  attribute
 svt_chi_transaction::comp_to_dbid_flit_delay = SVT_CHI_MIN_COMPTODBID_DELAY


Defines the delay in number of cycles between COMP and DBIDResp flit in the case when COMP is sent before DBIDResp. This is only applicable for WriteNoSnp* and WriteUnique* transactions when svt_chi_ic_sn_transaction:: xact_rsp_msg_type is set to RSP_MSG_COMP. The clock cycles are with respect to the TXRSPFLITV signal asserted for COMP Response.

The delay will have no effect in case the number of clock cycles programmed for this delay is already elapsed with respect to the reference event even before this delay is applied.

If this delay is set to a non-zero value, the tx_flit_delay corresponding to DBID RSP Flit is enforced to 0 and tx_flit_delay corresponding to COMP RSP flit is randomized.If the tx_flit_delay corresponding to DBID RSP flit is not enforced to zero, we will not see the actual comp_to_dbid_dlit_delay getting applied.

The reference event for this delay is reference_event_for_comp_to_dbid_flit_delay. Default value is 0. Applicable only for CHI ICN in Full-Slave mode

 int  attribute
 svt_chi_transaction::current_dat_flit_num = 0


This is a counter which is incremented for every DAT flit transmitted for a read transaction. Applicable for CHI ICN Full-Slave mode.

 rand bit [(SVT_CHI_XACT_MAX_DATA_WIDTH-1):0]  attribute
 svt_chi_transaction::data = 0


This field defines the data.
This field is applicable for write data, read data and DVM payload of the transaction.
This field is not applicable for Atomic transactions and will be ignored.
For DVM, this field is always right aligned. For other transaction types, the details are described below.
When svt_chi_node_configuration :: wysiwyg_enable is set to 1: The data corresponds to all 64 bytes irrespective of data size of the transaction.
When svt_chi_node_configuration :: wysiwyg_enable is set to 0: The data value is right aligned.
  • For Normal type memory transactions, this corresponds to number of bytes as per the data size of the transaction, starting from the address that is aligned to the data size.
  • For Device type memory transactions, this corresponds to the addresses starting from transaction's address, upto next aligned address to the data size.

 rand bit [(SVT_CHI_XACT_DAT_RSVDC_WIDTH-1):0]  attribute
 svt_chi_transaction::dat_rsvdc[]


This field defines the Reserved Value defined by the user for each of the Protocol Data VC Flits associated to the current transaction.
The size of this array must be equal to the number of data VC flits associated.
The array indices correspond to the order in which the flits are transmitted/received.
Any value can be driven on this field.

 rand svt_chi_common_transaction :: resp_err_status_enum  attribute
 svt_chi_transaction::data_resp_err_status[]


This field holds the resp_err_status defined by the user for each of the Protocol Data VC Flits associated to the current transaction.
The size of this array must be equal to the number of data VC flits associated.
The array indices correspond to the order in which the flits are transmitted/received.
All valid values for Response Error status (NORMAL_OKAY, EXCLUSIVE_OKAY, DATA_ERROR and NON_DATA_ERROR) can be driven on this field.
In case of WriteEvictorEvict transaction, as the data transfer depends on the response from the completer, this field values are used and populated in DAT flits only when there is write data transfer.

 rand svt_chi_common_transaction :: dbid_policy_enum  attribute
 svt_chi_transaction::dbid_policy = ZEROS


The DBID policy used for DBID field value of certain RSP, DAT flit types of current transaction. Please refer to documentation of the svt_chi_common_transaction :: dbid_policy_enum for more details.

 rand int  attribute
 svt_chi_transaction::dbid_to_comp_flit_delay = SVT_CHI_MIN_DBIDTOCOMP_DELAY


Defines the delay in number of cycles between DBIDResp and COMP flit in the case when DBIDResp is sent before COMP. This is only applicable for WriteNoSnp* and WriteUnique* transactions when svt_chi_ic_sn_transaction:: xact_rsp_msg_type is set to RSP_MSG_DBIDRESP. The clock cycles are with respect to the TXRSPFLITV signal asserted for DBIDRESP response.

The delay will have no effect in case the number of clock cycles programmed for this delay is already elapsed with respect to the reference event even before this delay is applied.

If this delay is set to a non-zero value, the tx_flit_delay corresponding to COMP RSP Flit is enforced to 0 and tx_flit_delay corresponding to DBID RSP flit is randomized.If the tx_flit_delay corresponding to COMP RSP flit is not enforced to zero, we will not see the actual comp_to_dbid_dlit_delay getting applied

The reference event for this delay is reference_event_for_dbid_to_comp_flit_delay. Default value is 0. Applicable only for CHI ICN in Full-Slave mode

 bit  attribute
 svt_chi_transaction::enable_interleave = 0


This variable controls enabling of interleaving for the current transaction. When set to 1, interleaving is enabled for current transaction. Currently, interleaving is not supported for Ordered transactions. Default value is 0

Applicable only for CHI ICN Full-Slave mode.

 svt_chi_common_transaction :: excl_access_status_enum  attribute
 svt_chi_transaction::excl_access_status = EXCL_ACCESS_INITIAL


Represents the status of an exclusive access. Following are the possible status types:
  • EXCL_ACCESS_INITIAL : Initial state of the transaction before it is processed by RN
  • EXCL_ACCESS_PASS : CHI exclusive access is successful
  • EXCL_ACCESS_FAIL : CHI exclusive access is failed

A combination of excl_access_status and excl_mon_status can be used to determine the reason for failure of exclusive store. This attribute is applicable to both exclusive load/read and store/write. excl_access_status is applicable to read/load transactions only if the exclusive load transaction get OK response instead of EXOK response which indicates the exclusive access fail and the sequence must be terminated and respective exclusive monitor needs to be reset. Please refer to the User Guide for more description.

 svt_chi_common_transaction :: excl_mon_status_enum  attribute
 svt_chi_transaction::excl_mon_status = EXCL_MON_INVALID


Represents the status of RN exclusive monitor. Following are the possible status types:
  • EXCL_MON_INVALID : RN exclusive monitor does not monitor the exclusive access on the cache line associated with the transaction
  • EXCL_MON_SET : RN exclusive monitor is set for exclusive access on the cache line associated with the transaction
  • EXCL_MON_RESET : RN exclusive monitor is reset for exclusive access on the cache line associated with the transaction

A combination of excl_access_status and excl_mon_status can be used to determine the reason for failure of exclusive store. This attribute is applicable to both read/load and write/store exclusive transactions. This attribute is programmed to 'EXCL_MON_RESET' on completion of the exclusive transactions. It is programmed to 'EXCL_MON_SET' only if the exclusive load/read is successful else it is marked as 'EXCL_MON_RESET'. Please refer to the User Guide for more description.

 bit  attribute
 svt_chi_transaction::excl_store_cache_update = 0


Flag to indicate update cache for successfull excl store when the transaction is dropped and the cache line is already present in unique state at the RN.

 svt_chi_common_transaction :: excl_xact_drop_cond_enum  attribute
 svt_chi_transaction::excl_xact_drop_cond = EXCL_MON_FAILURE_COND_DEFAULT_VALUE_XACT_DROPPED


This enum represents the value for conditions under which the RN coherent exclusive transactions are dropped. Conditions are based on the values of excl_mon_status and excl_access_status. Combination of these attributes causes the transaction to drop.

Following are the possible status types:

  • EXCL_MON_FAILURE_COND_DEFAULT_VALUE_XACT_DROPPED : Default value.
  • EXCL_MON_RESET_ACCESS_FAIL_XACT_DROPPED : set if the exclusive transaction is dropped as the excl_mon_status is reset and the exclusive_access_status is failed
  • EXCL_MON_SET_ACCESS_FAIL_XACT_DROPPED : set if the exclusive transaction is dropped as the excl_mon_status is set and the exclusive_access_status is failed as unexpected INVALID cache line status encountered
  • EXCL_MON_SET_ACCESS_PASS_XACT_DROPPED : set if the exclusive transaction is dropped as when RN has a cacheline for which CU is generated, excl_mon is set for the same cacheline address and the cacheline state is unique, which means this is a RN speculative transaction to a cacheline present in it's own cache. In such scenario, do a silent write into the cache and drop the transaction. Need not issue this transaction.
  • EXCL_MON_RESET_SNOOP_INVALIDATION_XACT_DROPPED : set to indicate that exclusive sequence needs to restart as the exclusive monitored RN cache has been invalidated by the incoming invalidating snoop request from different lpid or due to the normal coherent store[CU] transactions.
  • EXCL_MON_RESET_STORE_WITHOUT_LOAD_XACT_DROPPED : set if the exclusive transaction is dropped as the excl_mon_status is invalid and exclusive_access_status is failed. This occurs when store without Load/Read is issued by the RN or there was an intervening Store/Write before the current exclusive store/write transaction.
  • EXCL_MON_INVALID_MAX_EXCL_ACCESS_XACT_DROPPED : set if the exclusive transaction is dropped when the maximum number of active exclusive acessses exceeds 4.

 svt_chi_common_transaction :: cache_state_enum  attribute
 svt_chi_transaction::final_cache_line_state = I


This field indicates the final state of the cache line for this transaction.
  • Applicable for RN-F agent in active mode.
  • Used by the functional coverage related to cache states.
  • Updated when the cache line is updated.

 rand bit [SVT_CHI_HN_NODE_IDX_WIDTH-1:0]  attribute
 svt_chi_transaction::hn_node_idx = 0


HN Node Index to which transactions need to be sent to. This variable is not used by the VIP, but can potentially be used by users in sequences.

 svt_chi_common_transaction :: cache_state_enum  attribute
 svt_chi_transaction::initial_cache_line_state = I


This field indicates the initial state of the cache line for this transaction.
  • Applicable for RN-F agent in active mode.
  • Used by the functional coverage related to cache states.
  • Updated when the request flit is created by active RN-F agent.

 int  attribute
 svt_chi_transaction::interleaved_group_object_num = -1


Variable that holds the interleaved_group_object_num of this transaction. VIP assigns a unique number to each transaction it generates from interleaved ports.
Applicable for interleaved ports only. For normal ports it is same as obect_num.

 rand svt_chi_transaction :: interleave_pattern_enum  attribute
 svt_chi_transaction::interleave_pattern = RANDOM_BLOCK


Represents the various interleave pattern for a read transaction. The interleave_pattern gives flexibility to program interleave blocks with different patterns as mentioned below.

A Block is group of DAT flits within a transaction. RANDOM_BLOCK : Drives the blocks programmed in random_interleave_array Applicable only for CHI ICN Full-Slave mode.

 bit  attribute
 svt_chi_transaction::is_auto_generated = 0


Indicates if the transaction is auto generated by the VIP. Transactions are auto-generated when:
  • 1) The cache is full and an entry needs to be evicted from the cache.
  • 2) User supplies a cache maintenance transaction and the protocol requires that the cache line is first written into memory before sending the cache maintenance transaction.
  • 3) User supplies an atomic transaction with snoopme set to zero and the protocol requires that the cache line is first invalidated before sending the atomic transaction.
  • 4) Cache copies are invalidated/cleaned up before moving to the Coherency DISCONNECT phase.
  • 5) User supplies a partial write transaction. In this case, the VIP auto-generates a full cacheline read for the partial write transactions.

This is a read-only member, which VIP uses to indicate whether the transaction is auto generated. It should not be modified by the user.

Applicable for ACTIVE RN only.

 bit  attribute
 svt_chi_transaction::is_cached_data = 0


Indicates if the transaction ended because the requested data was already available in the cache. This bit is set by the master, no action is taken if the user sets this bit. A transaction with this bit set was not sent out on the bus and therefore other components in the testbench will not detect this transaction.

This is a read-only member, which VIP uses to indicate whether the requested data was cached. It should not be modified by the user.

Applicable for ACTIVE RN only.

 bit  attribute
 svt_chi_transaction::is_cacheline_reserved = 1'b0


This bit is set by RN if a cache line is reserved for the transaction. Thie field is used by task which unreserves the cache line at the end of transaction to filtering. This is to ensure only command that reserved cache line should unreserve cache line.

Applicable for ACTIVE RN only

 bit  attribute
 svt_chi_transaction::is_cancelled_on_retry = 0


This field indicates if the request is cancelled after receiving a retry response.

 bit  attribute
 svt_chi_transaction::is_comp_received = 0


Indicates if COMP has been received

 bit  attribute
 svt_chi_transaction::is_dbid_received = 0


Indicates if DBID has been received

 bit  attribute
 svt_chi_transaction::is_p_crd_grant_allocated = 0


For a requester, this field indicates if the PcrdGrant is received.
For a completer, this field indicates if the PcrdGrant is transmitted.

 rand bit  attribute
 svt_chi_transaction::is_p_crd_grant_before_retry_ack = 0


For a requester, this field indicates if the PcrdGrant is received before the RetryAck.
For a completer, this field indicates if the PcrdGrant is sent before the RetryAck.

 bit  attribute
 svt_chi_transaction::is_read_data_unknown = 1'b0


This bit is set by SN if the read is performed to a memory location that was not writtent to earlier. This should not be programmed by user. Applicable for SN only

 rand bit  attribute
 svt_chi_transaction::is_retried_with_original_qos = 1


Indicates if the transaction is retried with original qos of original request or not. In case of active RN, based on this field, RN driver decides to use original qos or any random qos for the retried transaction.

 rand bit  attribute
 svt_chi_transaction::is_retried_with_original_rsvdc = 1


Indicates if the transaction is retried with original req_rsvdc of original request not. In case of active RN, based on this field, RN driver decides to use original req_rsvdc or any random req_rsdvc for the retried transaction. This is applicable only when svt_chi_node_configuration :: chi_spec_revision is not set to ISSUE_A.

 rand bit  attribute
 svt_chi_transaction::is_retried_with_original_tgt_id = 1


Indicates if the transaction is retried with original tgt_id of original request or not. In case of active RN, based on this field, RN driver decides to use original tgt_id or the remapped tgt_id for the retried transaction, when svt_chi_system_configuration :: expect_target_id_remapping_by_interconnect is set to 1.

 rand bit  attribute
 svt_chi_transaction::is_retried_with_original_txn_id = 1


Indicates if the transaction is retried with original txn_id of original request or not. In case of active RN, based on this field, RN driver decides to use original txn_id or any random txn_id for the retried transaction.

 bit  attribute
 svt_chi_transaction::is_tgt_id_remapped = 0


Indicates if the tgt_id is remapped by Interconnect, to a different value other than the tgt_id field sent in the request flit by RN.

 bit  attribute
 svt_chi_transaction::is_xact_dropped = 0


Indicates if a transaction is dropped because the start state of the corresponding cache line is not as expected before transmitting the transaction. The expected start states for each of the transaction types are given in Table 6-1 of the specification.
This will be set automatically by the RN driver based on the initial cache state validity check. If the user wishes to drop transactions based on any additional/custom rules or transaction fields, they can set this attribute to 1 in svt_chi_rn_protocol_callback :: post_initial_cache_state_check that is invoked before the request flit is scheduled for a given transaction. Applicable for ACTIVE RN only.

 svt_chi_transaction :: link_activation_deactivation_initiator_info_enum  attribute
 svt_chi_transaction::link_deactivation_during_xact_queue[$]


For every instance of link deactivation that happens while the transaction is outstanding, indicates if the deactivation was initiated by the local or the remote node.

 svt_chi_transaction :: link_activation_deactivation_initiator_info_enum  attribute
 svt_chi_transaction::link_reactivation_during_xact_queue[$]


For every instance of link reactivation that happens while the transaction is outstanding, indicates if the reactivation was initiated by the local or the remote node.

 int  attribute
 svt_chi_transaction::num_dat_flits = 0


This field indicates the number of data Flits required to transfer the data based on the data width of the interface and the data size attribute of the transaction.
Consider the example that the data size is 64 Byte and data width of the interface is 16 Byte. In this case, the num_dat_flits will be 4.

 bit [(SVT_CHI_TGT_ID_WIDTH-1):0]  attribute
 svt_chi_transaction::original_tgt_id = 0


Captures the value of original_tgt_id, that is tgt_field of the associated request flit.

 rand int  attribute
 svt_chi_transaction::pcreditgrant_to_retryack_flit_delay = SVT_CHI_MIN_PCREDITGRANTTORETRYACK_DELAY


Defines the delay in number of cycles between RetryAck and PcrdGrant RSP flits in the case RetryAck is sent before PcrdGrant(svt_chi_transaction :: is_p_crd_grant_before_retry_ack = 0), when svt_chi_ic_sn_transaction:: xact_rsp_msg_type is set to RSP_MSG_RETRYACK. The clock cycles are with respect to the RSPFLITV signal asserted for RetryAck response.

The delay will have no effect in case the number of clock cycles programmed for this delay is already elapsed with respect to the reference event even before this delay is applied.

If this delay is set to a non-zero value, the tx_flit_delay corresponding to PcrdGrant RSP Flit is enforced to 0. This is reqired to ensure that actual pcreditgrant_to_retryack_flit_delay getting applied. Note that tx_flit_delay corresponding to RetryAck RSP flit is still randomized. The reference event for this delay is reference_event_for_pcreditgrant_to_retryack_flit_delay. Default value is 0. Applicable only for CHI ICN in Full-Slave mode.

 rand int  attribute
 svt_chi_transaction::random_interleave_array[]


When the interleave_pattern is set to RANDOM_BLOCK, the user would program this array with blocks. There are default constraints, which the user can override and set their own block patterns. Applicable only for CHI ICN Full-Slave mode.

 rand svt_chi_transaction :: reference_event_for_comp_to_dbid_flit_delay_enum  attribute
 svt_chi_transaction::reference_event_for_comp_to_dbid_flit_delay = TXRSPFLITV_FOR_COMPTODBID_VALID


Defines a reference event from which the comp_to_dbid_flit_delay should start. Following are the different reference events:

TXRSPFLITV_FOR_COMPTODBID_VALID: Reference event is TXRSPFLITV signal assertion for the current write request.

 rand svt_chi_transaction :: reference_event_for_dbid_to_comp_flit_delay_enum  attribute
 svt_chi_transaction::reference_event_for_dbid_to_comp_flit_delay = TXRSPFLITV_FOR_DBIDTOCOMP_VALID


Defines a reference event from which the dbid_to_comp_flit_delay should start. Following are the different reference events:

TXRSPFLITV_FOR_DBIDTOCOMP_VALID: Reference event is TXRSPFLITV signal assertion for the current write request.

 rand svt_chi_transaction :: reference_event_for_pcreditgrant_to_retryack_flit_delay_enum  attribute
 svt_chi_transaction::reference_event_for_pcreditgrant_to_retryack_flit_delay = RSPFLITV_FOR_PCREDITGRANT_TO_RETRYACK_VALID


Defines a reference event from which the pcreditgrant_to_retryack_flit_delay should start. Following are the different reference events:

RSPFLITV_FOR_PCREDITGRANT_TO_RETRYACK_VALID: Reference event is RSPFLITV signal assertion for the current request.

 rand svt_chi_transaction :: reference_event_for_req_to_comp_flit_delay_enum  attribute
 svt_chi_transaction::reference_event_for_req_to_comp_flit_delay = TXREQFLITV_FOR_COMP_VALID


Defines a reference event from which the req_to_comp_flit_delay should start. Following are the different reference events:

TXREQFLITV_FOR_COMP_VALID: Reference event is TXREQFLITV signal assertion for the current write request.

 rand svt_chi_transaction :: reference_event_for_req_to_compdata_flit_delay_enum  attribute
 svt_chi_transaction::reference_event_for_req_to_compdata_flit_delay = TXREQFLITV_FOR_COMPDATA_VALID


Defines a reference event from which the req_to_compdata_flit_delay should start. Following are the different reference events:

TXREQFLITV_FOR_COMPDATA_VALID: Reference event is TXREQFLITV signal assertion for the current write request.

 rand svt_chi_transaction :: reference_event_for_req_to_compdbid_flit_delay_enum  attribute
 svt_chi_transaction::reference_event_for_req_to_compdbid_flit_delay = TXREQFLITV_FOR_COMPDBID_VALID


Defines a reference event from which the req_to_compdbid_flit_delay should start. Following are the different reference events:

TXREQFLITV_FOR_COMPDBID_VALID: Reference event is TXREQFLITV signal assertion for the current write request.

 rand svt_chi_transaction :: reference_event_for_req_to_dbid_flit_delay_enum  attribute
 svt_chi_transaction::reference_event_for_req_to_dbid_flit_delay = TXREQFLITV_FOR_DBID_VALID


Defines a reference event from which the req_to_dbid_flit_delay should start. Following are the different reference events:

TXREQFLITV_FOR_DBID_VALID: Reference event is TXREQFLITV signal assertion for the current write request.

 rand svt_chi_transaction :: reference_event_for_req_to_pcreditgrant_flit_delay_enum  attribute
 svt_chi_transaction::reference_event_for_req_to_pcreditgrant_flit_delay = REQFLITV_FOR_PCREDITGRANT_VALID


Defines a reference event from which the req_to_pcreditgrant_flit_delay should start. Following are the different reference events:

REQFLITV_FOR_PCREDITGRANT_VALID: Reference event is REQFLITV signal assertion for the current request.

 rand svt_chi_transaction :: reference_event_for_req_to_retryack_flit_delay_enum  attribute
 svt_chi_transaction::reference_event_for_req_to_retryack_flit_delay = REQFLITV_FOR_RETRYACK_VALID


Defines a reference event from which the req_to_retryack_flit_delay should start. Following are the different reference events:

REQFLITV_FOR_RETRYACK_VALID: Reference event is REQFLITV signal assertion for the current request.

 rand svt_chi_transaction :: reference_event_for_retryack_to_pcreditgrant_flit_delay_enum  attribute
 svt_chi_transaction::reference_event_for_retryack_to_pcreditgrant_flit_delay = RSPFLITV_FOR_RETRYACK_TO_PCREDITGRANT_VALID


Defines a reference event from which the retryack_to_pcreditgrant_flit_delay should start. Following are the different reference events:

RSPFLITV_FOR_RETRYACK_TO_PCREDITGRANT_VALID: Reference event is RSPFLITV signal assertion for the current request.

 realtime  attribute
 svt_chi_transaction::req_accept_realtime = 0


Time at which this transaction was accepted by the completer recorded as a realtime value. This represents the timestamp at which a ReadReceipt/Comp/CompData response was seen for the transaction.

 rand int unsigned  attribute
 svt_chi_transaction::req_order_stream_id = 0


This member indicates the ID of the request order stream to which this transaction belongs to. Active RN agent orders the requests within a stream without any ordering dependency to the transaction that belong to other streams.

Applicable to only active RN agent. The value should be inside [0:(svt_chi_node_configuration :: num_req_order_streams-1)]

 rand int  attribute
 svt_chi_transaction::req_to_comp_flit_delay = SVT_CHI_MIN_REQTOCOMP_DELAY


Defines the delay in number of cycles between Write REQ flit and Comp flit. This is applicable for all write, CMO and other control (DVM,Barrier) transactions when svt_chi_ic_sn_transaction:: xact_rsp_msg_type is set to RSP_MSG_COMP. The clock cycles are with respect to the TXREQFLITV signal assertion for the current request.

This delay is applied after the response item is received by the interconnect from the IC SN xact sequencer before dispatching the RSP flit to the link layer. In case the response is suspended, the response item should reach the driver in 0 time, hence the delay is still applied once the response is resumed.

The delay will have no effect in case the number of clock cycles programmed for this delay is already elapsed with respect to the reference event even before this delay is applied.

If this delay is set to a non-zero value, the tx_flit_delay corresponding to COMP RSP Flit is enforced to 0.

The reference event for this delay is reference_event_for_req_to_comp_flit_delay. Default value is 0. Applicable only for CHI ICN in Full-Slave mode.

 rand int  attribute
 svt_chi_transaction::req_to_compdata_flit_delay = SVT_CHI_MIN_REQTOCOMPDATA_DELAY


Defines the delay in number of cycles between Read REQ flit and COMPDATA flit. This is only applicable for ReadNoSnp and ReadOnce transactions when svt_chi_sn_transaction :: xact_rsp_msg_type is set to RSP_MSG_COMPDATA. The clock cycles are with respect to the TXREQFLITV signal assertion for the current request.

This delay is applied after the response item is received by the interconnect from the IC SN xact sequencer before dispatching the DAT flit to the link layer. In case the response is suspended, the response item should reach the driver in 0 time, hence the delay is still applied once the response is resumed.

The delay will have no effect in case the number of clock cycles programmed for this delay is already elapsed with respect to the reference event even before this delay is applied.

If this delay is set to a non-zero value, the tx_flit_delay corresponding to COMPDATA DAT Flit is enforced to 0. The reference event for this delay is reference_event_for_req_to_compdata_flit_delay. Default value is 0. Applicable only for CHI ICN in Full-Slave mode

 rand int  attribute
 svt_chi_transaction::req_to_compdbid_flit_delay = SVT_CHI_MIN_REQTOCOMPDBID_DELAY


Defines the delay in number of cycles between Write REQ flit and COMPDBIDResp flit. This is only applicable for WriteNoSnp* and WriteUnique* transactions when svt_chi_ic_sn_transaction:: xact_rsp_msg_type is set to RSP_MSG_COMPDBIDRESP. The clock cycles are with respect to the TXREQFLITV signal assertion for the current request.

This delay is applied after the response item is received by the interconnect from the IC SN xact sequencer before dispatching the RSP flit to the link layer. In case the response is suspended, the response item should reach the driver in 0 time, hence the delay is still applied once the response is resumed.

The delay will have no effect in case the number of clock cycles programmed for this delay is already elapsed with respect to the reference event even before this delay is applied.

If this delay is set to a non-zero value, the tx_flit_delay corresponding to COMPDBIDRESP RSP Flit is enforced to 0.

The reference event for this delay is reference_event_for_req_to_compdbid_flit_delay. Default value is 0. Applicable only for CHI ICN in Full-Slave mode

 rand int  attribute
 svt_chi_transaction::req_to_dbid_flit_delay = SVT_CHI_MIN_REQTODBID_DELAY


Defines the delay in number of cycles between Write REQ flit and DBIDResp flit. This is only applicable for WriteNoSnp* and WriteUnique* transactions when svt_chi_ic_sn_transaction:: xact_rsp_msg_type is set to RSP_MSG_DBIDRESP. The clock cycles are with respect to the TXREQFLITV signal assertion for the current request.

This delay is applied after the response item is received by the interconnect from the IC SN xact sequencer before dispatching the RSP flit to the link layer. In case the response is suspended, the response item should reach the driver in 0 time, hence the delay is still applied once the response is resumed.

The delay will have no effect in case the number of clock cycles programmed for this delay is already elapsed with respect to the reference event even before this delay is applied.

If this delay is set to a non-zero value, the tx_flit_delay corresponding to DBIDRESP RSP Flit is enforced to 0.

The reference event for this delay is reference_event_for_req_to_dbid_flit_delay. Default value is 0. Applicable only for CHI ICN in Full-Slave mode.

 rand int  attribute
 svt_chi_transaction::req_to_pcreditgrant_flit_delay = SVT_CHI_MIN_REQTOPCREDITGRANT_DELAY


Defines the delay in number of cycles between REQ flit and Pcrdgrant RSP flit, when PcrdGrant is sent ahead of RetryAck (svt_chi_transaction :: is_p_crd_grant_before_retry_ack = 1). This is only applicable for all request transactions that can have PcrdGrant as a valid response, that is, with svt_chi_ic_sn_transaction:: xact_rsp_msg_type is set to RSP_MSG_RETRYACK. The clock cycles are with respect to the REQFLITV signal assertion for the current request.
This delay is applied after the response item is received by the interconnect from the IC SN xact sequencer before dispatching the Pcrdgrant RSP flit to the link layer. In case the response is suspended, the response item should reach the driver in 0 time, hence the delay is still applied once the response is resumed.

The delay will have no effect in case the number of clock cycles programmed for this delay is already elapsed with respect to the reference event even before this delay is applied.

If this delay is set to a non-zero value, the tx_flit_delay corresponding to Pcrdgrant RSP Flit is enforced to 0.

The reference event for this delay is reference_event_for_req_to_pcreditgrant_flit_delay. Default value is 0. Applicable only for CHI ICN in Full-Slave mode.

 rand int  attribute
 svt_chi_transaction::req_to_retryack_flit_delay = SVT_CHI_MIN_REQTORETRYACK_DELAY


Defines the delay in number of cycles between REQ flit and RetryAck RSP flit, when RetryAck is sent ahead of PcrdGrant (svt_chi_transaction :: is_p_crd_grant_before_retry_ack = 0). This is only applicable for all request transactions that can have RetryAck as a valid response, that is, with svt_chi_ic_sn_transaction:: xact_rsp_msg_type is set to RSP_MSG_RETRYACK. The clock cycles are with respect to the REQFLITV signal assertion for the current request.
This delay is applied after the response item is received by the interconnect from the IC SN xact sequencer before dispatching the RetryAck RSP flit to the link layer. In case the response is suspended, the response item should reach the driver in 0 time, hence the delay is still applied once the response is resumed.

The delay will have no effect in case the number of clock cycles programmed for this delay is already elapsed with respect to the reference event even before this delay is applied.

If this delay is set to a non-zero value, the tx_flit_delay corresponding to RetryAck RSP Flit is enforced to 0.

The reference event for this delay is reference_event_for_req_to_retryack_flit_delay. Default value is 0. Applicable only for CHI ICN in Full-Slave mode.

 realtime  attribute
 svt_chi_transaction::resp_status_accept_realtime = 0


Time at which response was sent from the requester to the completer. This represents the timestamp at which a CompAck response was seen for the transaction.

 rand svt_chi_common_transaction :: resp_err_status_enum  attribute
 svt_chi_transaction::response_resp_err_status = NORMAL_OKAY


Indicates the RespErr field of the Response flits associated to this transaction that can have a variable value for RespErr field.
Even though there can be more than one RSP flit associated to a given CHI transaction, as per section “14.4 Error Response Use By Transaction Type” of CHI 4.0 specification, only one of the response flits can have a variable value {Okay/ExOkay, Data Error/Non-Data Error} for this field. Whereas, the remaining response flits need to be transmitted only with a fixed value as described in above mentioned reference.
Consider the following example:
  • In case of WriteNoSnpFull, assume that the Comp and DBIDResp are received separately.
  • The DBIDResp can have only Okay value for RespErr.
  • However, Comp can have any value for RespErr.
  • In this case, the user interface needs to accommodate only for specifying/storing the RespErr that corresponds to Comp.

 rand int  attribute
 svt_chi_transaction::retryack_to_pcreditgrant_flit_delay = SVT_CHI_MIN_RETRYACKTOPCREDITGRANT_DELAY


Defines the delay in number of cycles between RetryAck and PcrdGrant RSP flits in the case RetryAck is sent before PcrdGrant(svt_chi_transaction :: is_p_crd_grant_before_retry_ack = 0), when svt_chi_ic_sn_transaction:: xact_rsp_msg_type is set to RSP_MSG_RETRYACK. The clock cycles are with respect to the RSPFLITV signal asserted for RetryAck response.

The delay will have no effect in case the number of clock cycles programmed for this delay is already elapsed with respect to the reference event even before this delay is applied.

If this delay is set to a non-zero value, the tx_flit_delay corresponding to PcrdGrant RSP Flit is enforced to 0. This is reqired to ensure that actual retryack_to_pcreditgrant_flit_delay getting applied. Note that tx_flit_delay corresponding to RetryAck RSP flit is still randomized. The reference event for this delay is reference_event_for_retryack_to_pcreditgrant_flit_delay. Default value is 0. Applicable only for CHI ICN in Full-Slave mode.

 svt_chi_snoop_transaction  attribute
 svt_chi_transaction::snoop_xacts_started_after_curr_xact_queue[$]


Internal queue of snoop transactions which started after current transaction started

 svt_chi_common_transaction :: chi_suspend_resume_status_enum  attribute
 svt_chi_transaction::suspend_wr_data_status = SUSPEND_RESUME_INITIAL


- This attribute captures the status of the transaction with respect to suspend_wr_data
  • This is a read-only field for testbench, and is updated by VIP components

 svt_chi_common_transaction :: byte_enable_pattern_enum  attribute
 svt_chi_transaction::write_dat_be_pattern[]


Byte Enable pattern for DAT flits of a write transactions.

 svt_chi_common_transaction :: data_pattern_enum  attribute
 svt_chi_transaction::write_dat_data_pattern[]


Data pattern for DAT flits of a write transactions.

 svt_chi_transaction :: xact_flow_category_enum  attribute
 svt_chi_transaction::xact_flow_category_type = DEFAULT_REQ


This property indicates the order in which the flits are seen for the transaction. It is populated at the end of the transaction based on the order in which the associated flits are completed. When the CHI_E replicated channel feature is enabled it is possible that multiple flits are seen on the interface at the same point in time, in such a scenario this field reflect the order in which these flits are stored in the internal queues of the transaction class. This is a read only field and is internally populated by the VIP.

 rand svt_chi_common_transaction :: xact_type_enum  attribute
 svt_chi_transaction::xact_type = READNOSNP


This field defines the Transaction type.

 svt_chi_transaction  attribute
 svt_chi_transaction::xacts_started_before_curr_xact_queue[$]


Internal queue of transactions which started before current transaction started, populated only in case of RN

 static protected svt_chi_transaction  attribute
 svt_chi_transaction::__vmm_rhs


Member Typedef Documentation

 typedef enum  svt_chi_transaction::auto_generation_category_enum

User supplies a partial write transaction. In this case, the VIP auto-generates a full cacheline read for the partial write transactions.

NOT_AUTO_GENERATED(0)
CACHE_FULL_AND_ENTRY_IN_CACHE_NEEDED(1)
WRITEBACK_TO_MEMORY_BEFORE_CMO(2)
AUTO_READ_AFTER_PARTIAL_WRITE_XACT(3)

 typedef enum  svt_chi_transaction::comp_dbid_responses_order_enum

This enum declaration is used to specify the order of COMP and DBIDRESP responses for a Write transaction. Applicable only in Active RN.

NOT_SET_COMP_DBIDRESP_ORDER
COMP_DBIDRESP
DBIDRESP_COMP
COMP_DBIDRESPORD
DBIDRESPORD_COMP
COMBINED_COMPDBIDRESP

 typedef enum  svt_chi_transaction::comp_persist_responses_order_enum

This enum declaration is used to specify the order of COMP and PERSIST responses for a *persistsep transaction. Applicable only in Active RN.

NOT_SET_COMP_PERSIST_ORDER
COMP_PERSIST
PERSIST_COMP
COMBINED_COMPPERSIST

 typedef enum  svt_chi_transaction::comp_stashdone_responses_order_enum

This enum declaration is used to specify the order of COMP and STASHDONE responses for a *stashsep transaction. Applicable only in Active RN.

NOT_SET_COMP_STASHDONE_ORDER
COMP_STASHDONE
STASHDONE_COMP
COMBINED_COMPSTASHDONE

 typedef enum  svt_chi_transaction::interleave_pattern_enum

Enum for interleave block pattern

RANDOM_BLOCK(SVT_CHI_TRANSACTION_INTERLEAVE_RANDOM_BLOCK)

 typedef enum  svt_chi_transaction::link_activation_deactivation_initiator_info_enum
LOCAL
: If link activation/deactivation was initiated by the peer node
REMOTE
: Value that corresponds to non-exclusive transaction type

 Typedefe'd string ==>   string

 typedef enum  svt_chi_transaction::reference_event_for_comp_to_dbid_flit_delay_enum

Enum to represent comp_to_dbid_flit_delay reference event

TXRSPFLITV_FOR_COMPTODBID_VALID(SVT_CHI_TXRSPFLITV_FOR_COMPTODBID_VALID_REF)

 typedef enum  svt_chi_transaction::reference_event_for_dbid_to_comp_flit_delay_enum

Enum to represent dbid_to_comp_flit_delay reference event

TXRSPFLITV_FOR_DBIDTOCOMP_VALID(SVT_CHI_TXRSPFLITV_FOR_DBIDTOCOMP_VALID_REF)

 typedef enum  svt_chi_transaction::reference_event_for_pcreditgrant_to_retryack_flit_delay_enum

Enum to represent pcreditgrant_to_retryack_flit_delay reference event

RSPFLITV_FOR_PCREDITGRANT_TO_RETRYACK_VALID(SVT_CHI_RSPFLITV_FOR_PCREDITGRANT_TO_RETRYACK_VALID_REF)

 typedef enum  svt_chi_transaction::reference_event_for_req_to_comp_flit_delay_enum

Enum to represent req_to_comp_flit_delay reference event

TXREQFLITV_FOR_COMP_VALID(SVT_CHI_TXREQFLITV_FOR_COMP_VALID_REF)

 typedef enum  svt_chi_transaction::reference_event_for_req_to_compdata_flit_delay_enum

Enum to represent req_to_compdata_flit_delay reference event

TXREQFLITV_FOR_COMPDATA_VALID(SVT_CHI_TXREQFLITV_FOR_COMPDATA_VALID_REF)

 typedef enum  svt_chi_transaction::reference_event_for_req_to_compdbid_flit_delay_enum

Enum to represent req_to_compdbid_flit_delay reference event

TXREQFLITV_FOR_COMPDBID_VALID(SVT_CHI_TXREQFLITV_FOR_COMPDBID_VALID_REF)

 typedef enum  svt_chi_transaction::reference_event_for_req_to_dbid_flit_delay_enum

Enum to represent req_to_dbid_flit_delay reference event

TXREQFLITV_FOR_DBID_VALID(SVT_CHI_TXREQFLITV_FOR_DBID_VALID_REF)

 typedef enum  svt_chi_transaction::reference_event_for_req_to_pcreditgrant_flit_delay_enum

Enum to represent req_to_pcreditgrant_flit_delay reference event

REQFLITV_FOR_PCREDITGRANT_VALID(SVT_CHI_REQFLITV_FOR_PCREDITGRANT_VALID_REF)

 typedef enum  svt_chi_transaction::reference_event_for_req_to_retryack_flit_delay_enum

Enum to represent req_to_retryack_flit_delay reference event

REQFLITV_FOR_RETRYACK_VALID(SVT_CHI_REQFLITV_FOR_RETRYACK_VALID_REF)

 typedef enum  svt_chi_transaction::reference_event_for_retryack_to_pcreditgrant_flit_delay_enum

Enum to represent retryack_to_pcreditgrant_flit_delay reference event

RSPFLITV_FOR_RETRYACK_TO_PCREDITGRANT_VALID(SVT_CHI_RSPFLITV_FOR_RETRYACK_TO_PCREDITGRANT_VALID_REF)

 typedef enum  svt_chi_transaction::xact_category_enum

Defines transaction category type

READ
: READNOSNP, READONCE, READCLEAN, READSHARED, READUNIQUE
CMO
: CLEANUNIQUE, MAKEUNIQUE, CLEANINVALID, CLEANSHARED, MAKEINVALID, EVICT
WRITE
: WRITEBACKFULL, WRITEBACKPTL, WRITECLEANFULL, WRITECLEANPTL, WRITEEVICTFULL, WRITEUNIQUEFULL,WRITEUNIQUEPTL, WRITENOSNPFULL, WRITENOSNPPTL
CTRL
: DVMOP, EOBARRIER, ECBARRIER
OTHERS
: PCRDRETURN

 typedef enum  svt_chi_transaction::xact_flow_category_enum

WRITEBACKFULL, WRITEBACKPTL, WRITECLEANFULL, WRITECLEANPTL, WRITEEVICTFULL

DEFAULT_REQ(0)
REQ_DBID_COMP_NCBWRDATA
: WRITEUNIQUEFULL,WRITEUNIQUEPTL,WRITEUNIQUEFULLSTASH,WRITEUNIQUEPTLSTASH, WRITENOSNPFULL, WRITENOSNPPTL, ATOMICSTORE
REQ_COMP_DBID_NCBWRDATA
: WRITEUNIQUEFULL,WRITEUNIQUEPTL,WRITEUNIQUEFULLSTASH,WRITEUNIQUEPTLSTASH, WRITENOSNPFULL, WRITENOSNPPTL, ATOMICSTORE
REQ_DBID_NCBWRDATA_COMP
: WRITEUNIQUEFULL,WRITEUNIQUEPTL,WRITEUNIQUEFULLSTASH,WRITEUNIQUEPTLSTASH, WRITENOSNPFULL, WRITENOSNPPTL, ATOMICSTORE, DVM
REQ_COMPDBIDRESP_NCBWRDATA
: WRITEUNIQUEFULL,WRITEUNIQUEPTL,WRITEUNIQUEFULLSTASH,WRITEUNIQUEPTLSTASH, WRITENOSNPFULL, WRITENOSNPPTL
REQ_DBID_COMP_NCBWRDATA_COMPACK_NCBWRDATA
: WRITEUNIQUEFULL,WRITEUNIQUEPTL,WRITEUNIQUEFULLSTASH,WRITEUNIQUEPTLSTASH, WRITENOSNPFULL, WRITENOSNPPTL, ATOMICSTORE, DVM
REQ_COMP_DBID_NCBWRDATA_COMPACK_NCBWRDATA
: WRITEUNIQUEFULL,WRITEUNIQUEPTL,WRITEUNIQUEFULLSTASH,WRITEUNIQUEPTLSTASH, WRITENOSNPFULL, WRITENOSNPPTL, ATOMICSTORE, DVM
REQ_DBID_NCBWRDATA_COMP_NCBWRDATA_COMPACK
: WRITEUNIQUEFULL,WRITEUNIQUEPTL,WRITEUNIQUEFULLSTASH,WRITEUNIQUEPTLSTASH, WRITENOSNPFULL, WRITENOSNPPTL, ATOMICSTORE, DVM
REQ_DBID_NCBWRDATA_COMP_NCBWRDATA
: WRITEUNIQUEFULL,WRITEUNIQUEPTL,WRITEUNIQUEFULLSTASH,WRITEUNIQUEPTLSTASH, WRITENOSNPFULL, WRITENOSNPPTL, ATOMICSTORE, DVM
REQ_DBID_NCBWRDATA_COMP_NCBWRDATA_COMPACK_NCBWRDATA
: WRITEUNIQUEFULL,WRITEUNIQUEPTL,WRITEUNIQUEFULLSTASH,WRITEUNIQUEPTLSTASH, WRITENOSNPFULL, WRITENOSNPPTL, ATOMICSTORE, DVM
REQ_DBID_NCBWRDATA_COMP_COMPACK_NCBWRDATA
: WRITEUNIQUEFULL,WRITEUNIQUEPTL,WRITEUNIQUEFULLSTASH,WRITEUNIQUEPTLSTASH, WRITENOSNPFULL, WRITENOSNPPTL, ATOMICSTORE, DVM
REQ_COMPDBIDRESP_NCBWRDATA_COMPACK_NCBWRDATA
: WRITEUNIQUEFULL,WRITEUNIQUEPTL,WRITEUNIQUEFULLSTASH,WRITEUNIQUEPTLSTASH, WRITENOSNPFULL, WRITENOSNPPTL, ATOMICSTORE, DVM
REQ_DBID_COMP_NCBWRDATA_COMPACK
: WRITEUNIQUEFULL,WRITEUNIQUEPTL,WRITEUNIQUEFULLSTASH,WRITEUNIQUEPTLSTASH
REQ_COMP_DBID_NCBWRDATA_COMPACK
: WRITEUNIQUEFULL,WRITEUNIQUEPTL,WRITEUNIQUEFULLSTASH,WRITEUNIQUEPTLSTASH
REQ_DBID_NCBWRDATA_COMP_COMPACK
: WRITEUNIQUEFULL,WRITEUNIQUEPTL,WRITEUNIQUEFULLSTASH,WRITEUNIQUEPTLSTASH
REQ_DBID_COMP_COMPACK_NCBWRDATA
: WRITEUNIQUEFULL,WRITEUNIQUEPTL,WRITEUNIQUEFULLSTASH,WRITEUNIQUEPTLSTASH
REQ_COMP_COMPACK_DBID_NCBWRDATA
: WRITEUNIQUEFULL,WRITEUNIQUEPTL,WRITEUNIQUEFULLSTASH,WRITEUNIQUEPTLSTASH
REQ_COMP_DBID_COMPACK_NCBWRDATA
: WRITEUNIQUEFULL,WRITEUNIQUEPTL,WRITEUNIQUEFULLSTASH,WRITEUNIQUEPTLSTASH
REQ_COMPDBIDRESP_NCBWRDATA_COMPACK
: WRITEUNIQUEFULL,WRITEUNIQUEPTL,WRITEUNIQUEFULLSTASH,WRITEUNIQUEPTLSTASH
REQ_COMPDBIDRESP_COMPACK_NCBWRDATA
: WRITEUNIQUEFULL,WRITEUNIQUEPTL,WRITEUNIQUEFULLSTASH,WRITEUNIQUEPTLSTASH
REQ_COMPDBIDRESP_CBWRDATA
REQ_COMPDATA_COMPACK
: READCLEAN, READNOTSHAREDDIRTY, READSHARED, READUNIQUE, READNOSNP, READONCE, ROMI, ROCI
REQ_COMPDATA
: READNOSNP, READONCE, ROMI, ROCI
REQ_READRECEIPT_COMPDATA
: READNOSNP, READONCE, ROMI, ROCI
REQ_COMPDATA_READRECEIPT
: READNOSNP, READONCE, ROMI, ROCI
REQ_READRECEIPT_COMPDATA_COMPACK
: READNOSNP, READONCE, ROMI, ROCI
REQ_COMPDATA_READRECEIPT_COMPACK
: READNOSNP, READONCE, ROMI, ROCI
REQ_COMPDATA_COMPACK_READRECEIPT
: READNOSNP, READONCE, ROMI, ROCI
REQ_COMP
: EVICT, STASHONCEUNIQUE, STASHONCESHARED, CLEANSHARED, CLEANSHAREDPERSIST, CLEANINVALID, MAKEINVALID
REQ_COMP_COMPACK
: CLEANUNIQUE, MAKEUNIQUE
REQ_RETRYACK

 typedef class  svt_chi_transaction::_factory_base
 Typedefe'd string ==>   vmm_class_factory_base#(svt_chi_transaction)


Member Constraint Documentation

  constraint
 svt_chi_transaction::chi_transaction_valid_ranges


Valid ranges constraints insure that the transaction settings are supported by the chi components.

constraint chi_transaction_valid_ranges {
     solve xact_type before txn_id, qos, addr, is_non_secure_access, p_crd_type, data_size, is_likely_shared, is_dyn_p_crd, order_type,
                            mem_attr_is_early_wr_ack_allowed, mem_attr_mem_type, mem_attr_is_cacheable, mem_attr_allocate_hint,
                            snp_attr_is_snoopable, snp_attr_snp_domain_type, lpid, is_exclusive, exp_comp_ack;
     solve data_size before byte_enable;
    req_to_retryack_flit_delay inside {[ 0: 16]};
    req_to_pcreditgrant_flit_delay inside {[ 0: 16]};
    req_to_dbid_flit_delay inside {[ 0: 16]};
    req_to_compdbid_flit_delay inside {[ 0: 16]};
    req_to_comp_flit_delay inside {[ 0: 16]};
    req_to_compdata_flit_delay inside {[ 0: 16]};
    comp_to_dbid_flit_delay inside {[ 0: 16]};
    dbid_to_comp_flit_delay inside {[ 0: 16]};
    retryack_to_pcreditgrant_flit_delay inside {[ 0: 16]};
    pcreditgrant_to_retryack_flit_delay inside {[ 0: 16]};
       }

  constraint
 svt_chi_transaction::reasonable_comp_to_dbid_flit_delay


constraint reasonable_comp_to_dbid_flit_delay {
   comp_to_dbid_flit_delay dist {
       0 := MIN_DELAY_wt,
     [ 0:( 16 >> 2)] :/ SHORT_DELAY_wt,
     [(( 16 >> 2)+1): 16] :/ LONG_DELAY_wt
   };
  }

  constraint
 svt_chi_transaction::reasonable_dbid_to_comp_flit_delay


constraint reasonable_dbid_to_comp_flit_delay {
   dbid_to_comp_flit_delay dist {
       0 := MIN_DELAY_wt,
     [ 0:( 16 >> 2)] :/ SHORT_DELAY_wt,
     [(( 16 >> 2)+1): 16] :/ LONG_DELAY_wt
   };
  }

  constraint
 svt_chi_transaction::reasonable_pcreditgrant_to_retryack_flit_delay


constraint reasonable_pcreditgrant_to_retryack_flit_delay {
   pcreditgrant_to_retryack_flit_delay dist {
       0 := MIN_DELAY_wt,
     [ 0:( 16 >> 2)] :/ SHORT_DELAY_wt,
     [(( 16 >> 2)+1): 16] :/ LONG_DELAY_wt
   };
  }

  constraint
 svt_chi_transaction::reasonable_req_to_comp_flit_delay


constraint reasonable_req_to_comp_flit_delay {
   req_to_comp_flit_delay dist {
       0 := MIN_DELAY_wt,
     [ 0:( 16 >> 2)] :/ SHORT_DELAY_wt,
     [(( 16 >> 2)+1): 16] :/ LONG_DELAY_wt
   };
  }

  constraint
 svt_chi_transaction::reasonable_req_to_compdata_flit_delay


constraint reasonable_req_to_compdata_flit_delay {
   req_to_compdata_flit_delay dist {
       0 := MIN_DELAY_wt,
     [ 0:( 16 >> 2)] :/ SHORT_DELAY_wt,
     [(( 16 >> 2)+1): 16] :/ LONG_DELAY_wt
   };
  }

  constraint
 svt_chi_transaction::reasonable_req_to_compdbid_flit_delay


constraint reasonable_req_to_compdbid_flit_delay {
   req_to_compdbid_flit_delay dist {
       0 := MIN_DELAY_wt,
     [ 0:( 16 >> 2)] :/ SHORT_DELAY_wt,
     [(( 16 >> 2)+1): 16] :/ LONG_DELAY_wt
   };
  }

  constraint
 svt_chi_transaction::reasonable_req_to_dbid_flit_delay


constraint reasonable_req_to_dbid_flit_delay {
   req_to_dbid_flit_delay dist {
       0 := MIN_DELAY_wt,
     [ 0:( 16 >> 2)] :/ SHORT_DELAY_wt,
     [(( 16 >> 2)+1): 16] :/ LONG_DELAY_wt
   };
  }

  constraint
 svt_chi_transaction::reasonable_req_to_pcreditgrant_flit_delay


constraint reasonable_req_to_pcreditgrant_flit_delay {
   req_to_pcreditgrant_flit_delay dist {
       0 := MIN_DELAY_wt,
     [ 0:( 16 >> 2)] :/ SHORT_DELAY_wt,
     [(( 16 >> 2)+1): 16] :/ LONG_DELAY_wt
   };
  }

  constraint
 svt_chi_transaction::reasonable_req_to_retryack_flit_delay


constraint reasonable_req_to_retryack_flit_delay {
   req_to_retryack_flit_delay dist {
       0 := MIN_DELAY_wt,
     [ 0:( 16 >> 2)] :/ SHORT_DELAY_wt,
     [(( 16 >> 2)+1): 16] :/ LONG_DELAY_wt
   };
  }

  constraint
 svt_chi_transaction::reasonable_retryack_to_pcreditgrant_flit_delay


constraint reasonable_retryack_to_pcreditgrant_flit_delay {
   retryack_to_pcreditgrant_flit_delay dist {
       0 := MIN_DELAY_wt,
     [ 0:( 16 >> 2)] :/ SHORT_DELAY_wt,
     [(( 16 >> 2)+1): 16] :/ LONG_DELAY_wt
   };
  }