VIP Smartsearch

`define SVT_CHI_DAT_FLIT_LSB_TRACETAG

(SVT_CHI_DAT_FLIT_LSB_DATAID+SVT_CHI_DATA_ID_WIDTH)

`define SVT_CHI_DAT_FLIT_LSB_TXNID

(SVT_CHI_DAT_FLIT_LSB_SRCID+SVT_CHI_SRC_ID_WIDTH)

`define SVT_CHI_DAT_FLIT_MAX_BE_WIDTH

(SVT_CHI_DAT_FLIT_MAX_DATA_WIDTH/8)

This defines the width of the BYTE ENABLE field width of the TXDATFLIT and RXDATFLIT signals. It is also used by svt_chi_flit :: byte_enable attribute.

`define SVT_CHI_DAT_FLIT_MAX_DATA_WIDTH

128

This defines the width of the DATA field width of the TXDATFLIT and RXDATFLIT and also affects the BE field. It is also used by svt_chi_flit :: data attribute.

`define SVT_CHI_DAT_FLIT_MAX_DATACHECK_WIDTH

(SVT_CHI_DAT_FLIT_MAX_DATA_WIDTH/8)

`define SVT_CHI_DAT_FLIT_MAX_POISON_WIDTH

(SVT_CHI_DAT_FLIT_MAX_DATA_WIDTH/64)

`define SVT_CHI_DAT_FLIT_MAX_RSVDC_WIDTH

This defines the width of RSVDC field width of the TXDATFLIT and RXDATFLIT

`define SVT_CHI_DAT_RSVDC_WIDTH

((SVT_CHI_DAT_FLIT_MAX_RSVDC_WIDTH ==0 )?1:SVT_CHI_DAT_FLIT_MAX_RSVDC_WIDTH)

Width of DAT RSVDC field

`define SVT_CHI_DAT_USER_EXTN_MAX_WIDTH

`define SVT_CHI_DAT_VC_FLIT_OP_COMPDATA

SVT_CHI_DAT_VC_FLIT_OP_WIDTH'h4

`define SVT_CHI_DAT_VC_FLIT_OP_COPYBACKWRDATA

SVT_CHI_DAT_VC_FLIT_OP_WIDTH'h2

`define SVT_CHI_DAT_VC_FLIT_OP_DATASEPRESP

SVT_CHI_DAT_VC_FLIT_OP_WIDTH'hB

`define SVT_CHI_DAT_VC_FLIT_OP_DATLINKFLIT

SVT_CHI_DAT_VC_FLIT_OP_WIDTH'h0

Opcodes used for Data VC FLIT

`define SVT_CHI_DAT_VC_FLIT_OP_NCBWRDATACOMPACK

SVT_CHI_DAT_VC_FLIT_OP_WIDTH'hC

`define SVT_CHI_DAT_VC_FLIT_OP_NONCOPYBACKWRDATA

SVT_CHI_DAT_VC_FLIT_OP_WIDTH'h3

`define SVT_CHI_DAT_VC_FLIT_OP_SNPRESPDATA

SVT_CHI_DAT_VC_FLIT_OP_WIDTH'h1

`define SVT_CHI_DAT_VC_FLIT_OP_SNPRESPDATAFWDED

SVT_CHI_DAT_VC_FLIT_OP_WIDTH'h6

`define SVT_CHI_DAT_VC_FLIT_OP_SNPRESPDATAPTL

SVT_CHI_DAT_VC_FLIT_OP_WIDTH'h5

`define SVT_CHI_DAT_VC_FLIT_OP_WIDTH

`define SVT_CHI_DAT_VC_FLIT_OP_WRITEDATACANCEL

SVT_CHI_DAT_VC_FLIT_OP_WIDTH'h7

`define SVT_CHI_DATA_ID_WIDTH

Width of Data ID field

`define SVT_CHI_DATA_PULL_WIDTH

`define SVT_CHI_DATA_SIZE_16BYTE

SVT_CHI_SIZE_WIDTH'b100

`define SVT_CHI_DATA_SIZE_1BYTE

SVT_CHI_SIZE_WIDTH'b000

Defines for different data sizes in bytes, also used by data_size_enum

`define SVT_CHI_DATA_SIZE_2BYTE

SVT_CHI_SIZE_WIDTH'b001

`define SVT_CHI_DATA_SIZE_32BYTE

SVT_CHI_SIZE_WIDTH'b101

`define SVT_CHI_DATA_SIZE_4BYTE

SVT_CHI_SIZE_WIDTH'b010

`define SVT_CHI_DATA_SIZE_64BYTE

SVT_CHI_SIZE_WIDTH'b110

`define SVT_CHI_DATA_SIZE_8BYTE

SVT_CHI_SIZE_WIDTH'b011

`define SVT_CHI_DATA_SOURCE_WIDTH

`define SVT_CHI_DATACHECK_INTERNAL_WIDTH_ENABLE

Width of Datacheck field-- applicable for CHI Issue B

`define SVT_CHI_DBID_WIDTH

Width of DBID field

`define SVT_CHI_DEBUG_PORT_WIDTH

`define SVT_CHI_DEF_CFG_NUM_CHANNELS

Default num channels configuration macro set to 1. Applicable for all channels.

`define SVT_CHI_DEF_MAX_CHANNELS

Default value for max num channels macro.

`define SVT_CHI_DEF_MAX_NUM_OUTSTANDING_DVM_SNOOP_XACT

-1

defines maximum number of outstanding non-dvm snoop transactions

`define SVT_CHI_DEF_MAX_NUM_OUTSTANDING_NON_DVM_SNOOP_XACT

-1

defines maximum number of outstanding non-dvm snoop transactions

`define SVT_CHI_DEF_MAX_NUM_OUTSTANDING_SNOOP_XACT

Default maximum number of outstanding transactions

`define SVT_CHI_DEF_MAX_NUM_OUTSTANDING_XACT

Default maximum number of outstanding transactions

`define SVT_CHI_DEFAULT_ADV_CURR_LCRD_HIGH_RANGE_START_VAL

((((SVT_CHI_MAX_FLIT_BUFFER_SIZE)*2)/3)+1)

Start value of high range for l-credit value

`define SVT_CHI_DEFAULT_ADV_CURR_LCRD_MED_RANGE_START_VAL

((SVT_CHI_MAX_FLIT_BUFFER_SIZE/3)+1)

Start value of medium range for l-credit value

`define SVT_CHI_DOMAIN_TYPE_INNERSNOOPABLE

`define SVT_CHI_DOMAIN_TYPE_NONSNOOPABLE

Defines used by system_domain_type_enum

`define SVT_CHI_DOMAIN_TYPE_OUTERSNOOPABLE

`define SVT_CHI_DOMAIN_TYPE_SNOOPABLE

`define SVT_CHI_DONOTDATAPULL_WIDTH

`define SVT_CHI_DONOTGOTOSD_WIDTH

`define SVT_CHI_DVM_MSG_TYPE_BITVEC_SLICE

13:11

`define SVT_CHI_DVM_MSG_TYPE_SYNC

SVT_CHI_DVM_MSG_TYPE_WIDTH'b100

`define SVT_CHI_DVM_MSG_TYPE_WIDTH

DVM Message type related defines

`define SVT_CHI_DVM_PART_NUM_BIT

`define SVT_CHI_DVM_VA_VALID_BIT

`define SVT_CHI_DVMOP_TLBI_FOLLOWED_BY_CMO_FOLLOWED_BY_DVMOP_SYNC_PATTERN_SEQ

10_7

`define SVT_CHI_DVMOP_TLBI_FOLLOWED_BY_CMO_FOLLOWED_BY_DVMOP_TLBI_FOLLOWED_BY_DVMOP_SYNC_PATTERN_SEQ

10_8

`define SVT_CHI_DVMOP_TLBI_FOLLOWED_BY_DVMOP_SYNC_DIFF_LPID

10_10

`define SVT_CHI_DVMOP_TLBI_FOLLOWED_BY_DVMOP_SYNC_FOLLOWED_BY_DVMOP_SYNC_PFOLLOWED_BY_DVMOP_TLBI_ATTERN_SEQ

10_5

`define SVT_CHI_DVMOP_TLBI_FOLLOWED_BY_DVMOP_SYNC_PATTERN_SEQ

10_1

`define SVT_CHI_DVMOP_TLBI_FOLLOWED_BY_DVMOP_SYNC_SAME_LPID

10_9

`define SVT_CHI_DVMOP_TLBI_FOLLOWED_BY_DVMOP_TLBI_FOLLOWED_BY_DVMOP_SYNC_PATTERN_SEQ

10_2

`define SVT_CHI_DVMOP_TLBI_FOLLOWED_BY_RETRY_DVMOP_TLBI_FOLLOWED_BY_DVMOP_SYNC_FOLLOWED_BY_RETRY_DVMOP_SYNC_PATTERN_SEQ

10_3

`define SVT_CHI_DVMOP_TLBI_OUTSTANDING_FOLLOWED_BY_DVMOP_SYNC_FOLLOWED_BY_RETRY_DVMOP_SYNC_PATTERN_SEQ

10_13

`define SVT_CHI_DVMOP_TLBI_OUTSTANDING_FOLLOWED_BY_DVMOP_SYNC_WITH_DIFF_LPID_FOLLOWED_BY_RETRY_DVMOP_SYNC_PATTERN_SEQ

10_15

`define SVT_CHI_DVMOP_TLBI_OUTSTANDING_FOLLOWED_BY_DVMOP_SYNC_WITH_SAME_LPID_FOLLOWED_BY_RETRY_DVMOP_SYNC_PATTERN_SEQ

10_14

`define SVT_CHI_DVMOP_TLBI_OUTSTANDING_FOLLOWED_BY_DVMOP_TLBI_FOLLOWED_BY_RETRY_DVMOP_TLBI_PATTERN_SEQ

10_16

`define SVT_CHI_DVMOP_TLBI_OUTSTANDING_FOLLOWED_BY_DVMOP_TLBI_WITH_DIFF_LPID_FOLLOWED_BY_RETRY_DVMOP_TLBI_PATTERN_SEQ

10_18

`define SVT_CHI_DVMOP_TLBI_OUTSTANDING_FOLLOWED_BY_DVMOP_TLBI_WITH_SAME_LPID_FOLLOWED_BY_RETRY_DVMOP_TLBI_PATTERN_SEQ

10_17

`define SVT_CHI_DVMOP_TYPE_BRANCH_PREDICTOR_INVALIDATE

3'b001

`define SVT_CHI_DVMOP_TYPE_PHY_INS_CACHE_INVALIDATE

3'b010

`define SVT_CHI_DVMOP_TYPE_SYNC

3'b100

`define SVT_CHI_DVMOP_TYPE_TLB_INVALIDATE

3'b000

DVM Operation type related defines

`define SVT_CHI_DVMOP_TYPE_VIRTUAL_INS_CACHE_INVALIDATE

3'b011

`define SVT_CHI_E_SPEC_BEHAVIOR

`define SVT_CHI_ENABLE_COHERENT_XACT

`define SVT_CHI_ENABLE_DCT

Define for controlling default value for enabling DCT

`define SVT_CHI_ENABLE_DMT

Define for controlling default value for enabling DMT

`define SVT_CHI_ENABLE_DWT

Define for controlling default value for enabling DWT

`define SVT_CHI_ENABLE_MEMORY_TAGGING

Define for controlling default value for enabling Memory Tagging

`define SVT_CHI_ENABLE_ORD_STASH_DATA_PULL

Define for controlling default value for enabling Ordered Stash Data Pull

`define SVT_CHI_ENABLE_SEP_RD_DATA_SEP_RSP

Define for controlling default value for enabling Seperate Read Data and Home Response

`define SVT_CHI_ENABLE_STASH

Define for controlling default value for enabling Stash

`define SVT_CHI_ENABLE_STASH_DATA_PULL

Define for controlling default value for enabling Stash Data Pull

`define SVT_CHI_EP_ORDERED_RD_FOLLOWED_BY_EP_ORDERED_RD_PATTERN_SEQ

3_3

`define SVT_CHI_EP_ORDERED_RD_FOLLOWED_BY_EP_ORDERED_RD_W_DIFF_ADDR_PATTERN_SEQ

3_3_2

`define SVT_CHI_EP_ORDERED_RD_FOLLOWED_BY_EP_ORDERED_RD_W_SAME_ADDR_PATTERN_SEQ

3_3_1

`define SVT_CHI_EP_ORDERED_RD_FOLLOWED_BY_EP_ORDERED_WR_PATTERN_SEQ

4_3

`define SVT_CHI_EP_ORDERED_RD_FOLLOWED_BY_EP_ORDERED_WR_W_DIFF_ADDR_PATTERN_SEQ

4_3_2

`define SVT_CHI_EP_ORDERED_RD_FOLLOWED_BY_EP_ORDERED_WR_W_SAME_ADDR_PATTERN_SEQ

4_3_1

`define SVT_CHI_EP_ORDERED_RD_FOLLOWED_BY_REQ_ORDERED_RD_PATTERN_SEQ

3_4

`define SVT_CHI_EP_ORDERED_RD_FOLLOWED_BY_REQ_ORDERED_RD_W_DIFF_ADDR_PATTERN_SEQ

3_4_2

`define SVT_CHI_EP_ORDERED_RD_FOLLOWED_BY_REQ_ORDERED_RD_W_SAME_ADDR_PATTERN_SEQ

3_4_1

`define SVT_CHI_EP_ORDERED_RD_FOLLOWED_BY_REQ_ORDERED_WR_PATTERN_SEQ

4_4

`define SVT_CHI_EP_ORDERED_RD_FOLLOWED_BY_REQ_ORDERED_WR_W_DIFF_ADDR_PATTERN_SEQ

4_4_2

`define SVT_CHI_EP_ORDERED_RD_FOLLOWED_BY_REQ_ORDERED_WR_W_SAME_ADDR_PATTERN_SEQ

4_4_1

`define SVT_CHI_EP_ORDERED_WR_FOLLOWED_BY_EP_ORDERED_RD_PATTERN_SEQ

1_3

`define SVT_CHI_EP_ORDERED_WR_FOLLOWED_BY_EP_ORDERED_RD_W_DIFF_ADDR_PATTERN_SEQ

1_3_2

`define SVT_CHI_EP_ORDERED_WR_FOLLOWED_BY_EP_ORDERED_RD_W_SAME_ADDR_PATTERN_SEQ

1_3_1

`define SVT_CHI_EP_ORDERED_WR_FOLLOWED_BY_EP_ORDERED_WR_PATTERN_SEQ

2_3

`define SVT_CHI_EP_ORDERED_WR_FOLLOWED_BY_EP_ORDERED_WR_W_DIFF_ADDR_PATTERN_SEQ

2_3_2

`define SVT_CHI_EP_ORDERED_WR_FOLLOWED_BY_EP_ORDERED_WR_W_SAME_ADDR_PATTERN_SEQ

2_3_1

`define SVT_CHI_EP_ORDERED_WR_FOLLOWED_BY_REQ_ORDERED_RD_PATTERN_SEQ

1_4

`define SVT_CHI_EP_ORDERED_WR_FOLLOWED_BY_REQ_ORDERED_RD_W_DIFF_ADDR_PATTERN_SEQ

1_4_2

`define SVT_CHI_EP_ORDERED_WR_FOLLOWED_BY_REQ_ORDERED_RD_W_SAME_ADDR_PATTERN_SEQ

1_4_1

`define SVT_CHI_EP_ORDERED_WR_FOLLOWED_BY_REQ_ORDERED_WR_PATTERN_SEQ

2_4

`define SVT_CHI_EP_ORDERED_WR_FOLLOWED_BY_REQ_ORDERED_WR_W_DIFF_ADDR_PATTERN_SEQ

2_4_2

`define SVT_CHI_EP_ORDERED_WR_FOLLOWED_BY_REQ_ORDERED_WR_W_SAME_ADDR_PATTERN_SEQ

2_4_1

`define SVT_CHI_ERROR_CTRL_REG_WIDTH

Define the width of enum bits *

`define SVT_CHI_EXCL_MON_FAILURE_COND_DEFAULT_VALUE_XACT_DROPPED

Defines CHI exclusive transaction drop condition*

`define SVT_CHI_EXCL_MON_INVALID

Defines CHI exclusive monitor status*

`define SVT_CHI_EXCL_MON_INVALID_MAX_EXCL_ACCESS_XACT_DROPPED

`define SVT_CHI_EXCL_MON_RESET

`define SVT_CHI_EXCL_MON_RESET_ACCESS_FAIL_XACT_DROPPED

`define SVT_CHI_EXCL_MON_RESET_SNOOP_INVALIDATION_XACT_DROPPED

`define SVT_CHI_EXCL_MON_RESET_STORE_WITHOUT_LOAD_XACT_DROPPED

`define SVT_CHI_EXCL_MON_SET

`define SVT_CHI_EXCL_MON_SET_ACCESS_FAIL_XACT_DROPPED

`define SVT_CHI_EXCL_MON_SET_ACCESS_PASS_XACT_DROPPED

`define SVT_CHI_EXCL_MONITOR_DEFAULT

Defines CHI exclusive monitor status, used by subsequent excluisve store to determine on whether to bypass excluisve_store_response_check

`define SVT_CHI_EXCL_MONITOR_NO_ENTRY

`define SVT_CHI_EXCL_MONITOR_RESET

`define SVT_CHI_EXCL_MONITOR_SET

`define SVT_CHI_EXCL_SNPME_CAH_WIDTH

`define SVT_CHI_EXCL_WIDTH

`define SVT_CHI_EXCLUDE_UNSTARTED_XACT

`define SVT_CHI_EXCLUSIVE_ACCESSES_SEQUENCE_PAIR_INTERLEAVED_BY_ANOTHER_EXCL_STORE_FROM_DIFF_LPID_PATTERN_SEQ

11_1_2

`define SVT_CHI_EXCLUSIVE_ACCESSES_SEQUENCE_PAIR_INTERLEAVED_BY_ANOTHER_EXCL_STORE_PATTERN_SEQ

11_1_1

`define SVT_CHI_EXCLUSIVE_ACCESSES_SEQUENCE_PAIR_PATTERN_SEQ

11_0_1

`define SVT_CHI_EXCLUSIVE_ACCESSES_SEQUENCE_PAIR_WITH_DIFF_MEMORY_ATTRIBUTE_PATTERN_SEQ

11_0_2

`define SVT_CHI_EXCLUSIVE_ACCESSES_SEQUENCE_PAIR_WITH_DIFF_SNOOP_ATTRIBUTE_PATTERN_SEQ

11_0_4

`define SVT_CHI_EXCLUSIVE_ACCESSES_SEQUENCE_PAIR_WITH_SAME_MEMORY_ATTRIBUTE_PATTERN_SEQ

11_0_3

`define SVT_CHI_EXPCOMPACK_WIDTH

`define SVT_CHI_F_PRINT_XACT_FIELD ( xact, field )

`ifdef SVT_CHI_ISSUE_F_ENABLE
$sformatf("%0s = %0d",
SVT_DATA_UTIL_ARG_TO_STRING(field),xact.field)
`else
" "
`endif

`define SVT_CHI_F_PRINT_XACT_NSE ( xact )

`ifdef SVT_CHI_ISSUE_F_ENABLE
$sformatf(" NSE('b%0b)",
xact.non_secure_ext)
`else
" "
`endif

`define SVT_CHI_FLIT_CAUSAL_PRINT_PREFIX ( flit )

((flit == null) ? "CAUSAL XACT {SYS_ID(-1) OBJ_NUM(-1) NODE_ID(-1) TYPE(null) TXN_ID(0) ADDR(0) END_TIME(0)}":flit.causal_xact_psdisplay_concise())

`define SVT_CHI_FLIT_DATA_WIDTH_128BIT

128

Different Flit data widths

`define SVT_CHI_FLIT_DATA_WIDTH_256BIT

256

`define SVT_CHI_FLIT_DATA_WIDTH_512BIT

512

`define SVT_CHI_FLIT_EXCEPTION_LIST_MAX_NUM_EXCEPTIONS

This value is used by the svt_chi_flit_exception_list constructor to define the initial value for svt_exception_list :: max_num_exceptions. This field is used by the exception list to define the maximum number of exceptions which can be generated for a single transaction. The user testbench can override this constant value to define a different maximum value for use by all svt_chi_flit_exception_list instances or can change the value of the svt_exception_list :: max_num_exceptions field directly to define a different maximum value for use by that svt_chi_flit_exception_list instance.

`define SVT_CHI_FLIT_PRINT_PREFIX ( flit )

((flit == null) ? "FLIT {SYS_ID(-1) OBJ_NUM(-1) NODE_ID(-1) TYPE(null) TXN_ID(0) ADDR(0) END_TIME(0)}":flit.psdisplay_concise())

`define SVT_CHI_FLIT_RSVDC_WIDTH_0BIT

Different rsvdc widths

`define SVT_CHI_FLIT_RSVDC_WIDTH_12BIT

`define SVT_CHI_FLIT_RSVDC_WIDTH_16BIT

`define SVT_CHI_FLIT_RSVDC_WIDTH_24BIT

`define SVT_CHI_FLIT_RSVDC_WIDTH_32BIT

`define SVT_CHI_FLIT_RSVDC_WIDTH_4BIT

`define SVT_CHI_FLIT_RSVDC_WIDTH_8BIT

`define SVT_CHI_FORWARD_NID_PBHA_WIDTH

Width of Forward NID or {(NID_WIDTH-4)'b0,PBHA[3:0]} field. Used for packing the data flit.

`define SVT_CHI_FORWARD_NID_WIDTH

Width of Forward NID field. Used for attributes declaration in data classes.

`define SVT_CHI_FORWARD_TXN_ID_WIDTH

Width of Forward Transaction ID field

`define SVT_CHI_FWD_STATE_WIDTH

`define SVT_CHI_GET_XACT_END_TIME ( xact )

`ifdef SVT_VMM_TECHNOLOGY
xact.notify.timestamp(vmm_data::ENDED)
`else
xact.get_end_realtime()
`endif

`define SVT_CHI_GET_XACT_START_TIME ( xact )

`ifdef SVT_VMM_TECHNOLOGY
xact.notify.timestamp(vmm_data::STARTED)
`else
xact.get_begin_realtime()
`endif

`define SVT_CHI_HN

`define SVT_CHI_HN_ALWAYS_FORWARD_AS_READ_AND_WRITE

Atomic xact propagation to slave policy

`define SVT_CHI_HN_ALWAYS_FORWARD_ATOMICS

`define SVT_CHI_HN_FORWARD_AS_ATOMICS_OR_AS_READ_AND_WRITE

`define SVT_CHI_HN_NODE_IDX_WIDTH

`define SVT_CHI_HN_STATUS_DEFAULT_ADDRESS_BASED_FLUSH_POLICY

CLEANINVALID_ABF

Define for controlling the default value of svt_chi_hn_status :: address_based_flush_policy

`define SVT_CHI_HOME_NID_PBHA_WIDTH

Width of Home NID or {(NID_WIDTH-4)'b0,PBHA[3:0]} field. Used for packing the data flit.

`define SVT_CHI_HOME_NID_WIDTH

(33+(SVT_CHI_DAT_VC_FLIT_OP_WIDTH)+(3*SVT_CHI_MAX_NODE_ID_WIDTH)+SVT_CHI_DAT_FLIT_MAX_RSVDC_WIDTH+SVT_CHI_DAT_FLIT_MAX_BE_WIDTH+SVT_CHI_DAT_FLIT_MAX_DATA_WIDTH +(SVT_CHI_DATACHECK_INTERNAL_WIDTH_ENABLE * SVT_CHI_DAT_FLIT_MAX_DATACHECK_WIDTH)+(SVT_CHI_POISON_INTERNAL_WIDTH_ENABLE * SVT_CHI_DAT_FLIT_MAX_POISON_WIDTH)+SVT_CHI_DAT_USER_EXTN_MAX_WIDTH)

Width of Home NID field. Used for attributes declaration in data classes.

`define SVT_CHI_HYBRID_DATA_FORMAT

`define SVT_CHI_IC_CFG_DEFAULT_CHI_SPEC_REVISION

ISSUE_A

`define SVT_CHI_IC_RN_LINK_CB_EXEC_COMMON_POST_TX_DAT_CB_NAME

post_tx_dat_seq_item_get

`define SVT_CHI_IC_RN_LINK_CB_EXEC_COMMON_POST_TX_RSP_CB_NAME

post_tx_rsp_seq_item_get

`define SVT_CHI_IC_RN_TRANSACTION_SV

`define SVT_CHI_IC_SN_TRANSACTION_SV

`define SVT_CHI_INACTIVE_HIGH_VAL

`define SVT_CHI_INACTIVE_LOW_VAL

Inactive value defines

`define SVT_CHI_INACTIVE_PREV_VAL

`define SVT_CHI_INACTIVE_RAND_VAL

`define SVT_CHI_INACTIVE_X_VAL

`define SVT_CHI_INACTIVE_Z_VAL

`define SVT_CHI_INT_TYPE_WIDTH

Width of an integer type variable in bits

`define SVT_CHI_INTERFACE_HN_F

`define SVT_CHI_INTERFACE_HN_I

`define SVT_CHI_INTERFACE_IC_SN_F

`define SVT_CHI_INTERFACE_IC_SN_I

`define SVT_CHI_INTERFACE_RN_D

`define SVT_CHI_INTERFACE_RN_F

Interface types

`define SVT_CHI_INTERFACE_RN_I

`define SVT_CHI_INTERFACE_SN_F

`define SVT_CHI_INTERFACE_SN_I

`define SVT_CHI_INTERNAL_SPEC_ISSUE_MACROS_DEFINED

`define SVT_CHI_IS_XACT_BARRIER ( xact )

(
(xact.xact_type == svt_chi_transaction::EOBARRIER) ||
(xact.xact_type == svt_chi_transaction::ECBARRIER)
)

`define SVT_CHI_IS_XACT_CMO ( xact )

(
  (xact.xact_type == svt_chi_transaction::CLEANSHARED) ||
  `ifdef SVT_CHI_ISSUE_B_ENABLE
  (xact.xact_type == svt_chi_transaction::CLEANSHAREDPERSIST) ||
  `endif
  `ifdef SVT_CHI_ISSUE_D_ENABLE
  (xact.xact_type == svt_chi_transaction::CLEANSHAREDPERSISTSEP) ||
  `endif
  `ifdef SVT_CHI_ISSUE_F_ENABLE
  (xact.xact_type == svt_chi_transaction::CLEANINVALIDPOPA) ||
  `endif
  (xact.xact_type == svt_chi_transaction::CLEANINVALID) ||
  (xact.xact_type == svt_chi_transaction::MAKEINVALID)
)

`define SVT_CHI_IS_XACT_COPYBACK ( xact )

(
  (xact.xact_type == svt_chi_transaction::WRITEBACKFULL) ||
  (xact.xact_type == svt_chi_transaction::WRITEBACKPTL) ||
  (xact.xact_type == svt_chi_transaction::WRITECLEANFULL) ||
  (xact.xact_type == svt_chi_transaction::WRITECLEANPTL) ||
  (xact.xact_type == svt_chi_transaction::WRITEEVICTFULL) ||
  `ifdef SVT_CHI_ISSUE_E_ENABLE
  (xact.xact_type == svt_chi_transaction::WRITEEVICTOREVICT) ||
  (xact.xact_type == svt_chi_transaction::WRITEBACKFULL_CLEANSHARED) ||
  (xact.xact_type == svt_chi_transaction::WRITEBACKFULL_CLEANSHAREDPERSISTSEP) ||
  (xact.xact_type == svt_chi_transaction::WRITEBACKFULL_CLEANINVALID) ||
  (xact.xact_type == svt_chi_transaction::WRITECLEANFULL_CLEANSHARED) ||
  (xact.xact_type == svt_chi_transaction::WRITECLEANFULL_CLEANSHAREDPERSISTSEP) ||
  `endif
  `ifdef SVT_CHI_ISSUE_F_ENABLE
  (xact.xact_type == svt_chi_transaction::WRITEBACKFULL_CLEANINVALIDPOPA) ||
  `endif
  (xact.xact_type == svt_chi_transaction::EVICT)
)

`define SVT_CHI_IS_XACT_DVMOP ( xact )

(
(xact.xact_type == svt_chi_transaction::DVMOP)
)

`define SVT_CHI_IS_XACT_PCRDRETURN ( xact )

(
(xact.xact_type == svt_chi_transaction::PCRDRETURN)
)

`define SVT_CHI_IS_XACT_PREFETCHTGT ( xact )

(
(xact.xact_type == svt_chi_transaction::PREFETCHTGT)
)

`define SVT_CHI_IS_XACT_READ ( xact )

(
  (xact.xact_type == svt_chi_transaction::READNOSNP) ||
  (xact.xact_type == svt_chi_transaction::READONCE) ||
  (xact.xact_type == svt_chi_transaction::READSHARED) ||
  (xact.xact_type == svt_chi_transaction::READCLEAN) ||
  `ifdef SVT_CHI_ISSUE_C_ENABLE
  (xact.xact_type == svt_chi_transaction::READNOSNPSEP) ||
  `endif
  `ifdef SVT_CHI_ISSUE_E_ENABLE
  (xact.xact_type == svt_chi_transaction::READPREFERUNIQUE) ||
  (xact.xact_type == svt_chi_transaction::MAKEREADUNIQUE) ||
  (xact.xact_type == svt_chi_transaction::STASHONCESEPSHARED) ||
  (xact.xact_type == svt_chi_transaction::STASHONCESEPUNIQUE) ||
  `endif
  `ifdef SVT_CHI_ISSUE_B_ENABLE
  (xact.xact_type == svt_chi_transaction::READNOTSHAREDDIRTY) ||
  (xact.xact_type == svt_chi_transaction::READONCECLEANINVALID) ||
  (xact.xact_type == svt_chi_transaction::READONCEMAKEINVALID) ||
  (xact.xact_type == svt_chi_transaction::STASHONCESHARED) ||
  (xact.xact_type == svt_chi_transaction::STASHONCEUNIQUE) ||
  `endif
  (xact.xact_type == svt_chi_transaction::READUNIQUE) ||
  (xact.xact_type == svt_chi_transaction::CLEANUNIQUE) ||
  (xact.xact_type == svt_chi_transaction::MAKEUNIQUE)
)

`define SVT_CHI_IS_XACT_WRITE ( xact )

(
  (xact.xact_type == svt_chi_transaction::WRITENOSNPFULL) ||
  (xact.xact_type == svt_chi_transaction::WRITENOSNPPTL) ||
  (xact.xact_type == svt_chi_transaction::WRITEUNIQUEFULL) ||
  `ifdef SVT_CHI_ISSUE_B_ENABLE
  (xact.xact_type == svt_chi_transaction::WRITEUNIQUEFULLSTASH) ||
  (xact.xact_type == svt_chi_transaction::WRITEUNIQUEPTLSTASH) ||
  (xact.xact_type == svt_chi_transaction::ATOMICSTORE_ADD) ||
  (xact.xact_type == svt_chi_transaction::ATOMICSTORE_CLR) ||
  (xact.xact_type == svt_chi_transaction::ATOMICSTORE_EOR) ||
  (xact.xact_type == svt_chi_transaction::ATOMICSTORE_SET) ||
  (xact.xact_type == svt_chi_transaction::ATOMICSTORE_SMAX) ||
  (xact.xact_type == svt_chi_transaction::ATOMICSTORE_SMIN) ||
  (xact.xact_type == svt_chi_transaction::ATOMICSTORE_UMAX) ||
  (xact.xact_type == svt_chi_transaction::ATOMICSTORE_UMIN) ||
  (xact.xact_type == svt_chi_transaction::ATOMICLOAD_ADD) ||
  (xact.xact_type == svt_chi_transaction::ATOMICLOAD_CLR) ||
  (xact.xact_type == svt_chi_transaction::ATOMICLOAD_EOR) ||
  (xact.xact_type == svt_chi_transaction::ATOMICLOAD_SET) ||
  (xact.xact_type == svt_chi_transaction::ATOMICLOAD_SMAX) ||
  (xact.xact_type == svt_chi_transaction::ATOMICLOAD_SMIN) ||
  (xact.xact_type == svt_chi_transaction::ATOMICLOAD_UMAX) ||
  (xact.xact_type == svt_chi_transaction::ATOMICLOAD_UMIN) ||
  (xact.xact_type == svt_chi_transaction::ATOMICSWAP) ||
  (xact.xact_type == svt_chi_transaction::ATOMICCOMPARE) ||
  `endif
  `ifdef SVT_CHI_ISSUE_E_ENABLE
  (xact.xact_type == svt_chi_transaction::WRITEUNIQUEZERO) ||
  (xact.xact_type == svt_chi_transaction::WRITENOSNPZERO) ||
  (xact.xact_type == svt_chi_transaction::WRITENOSNPFULL_CLEANSHARED) ||
  (xact.xact_type == svt_chi_transaction::WRITENOSNPFULL_CLEANINVALID) ||
  (xact.xact_type == svt_chi_transaction::WRITENOSNPPTL_CLEANSHARED) ||
  (xact.xact_type == svt_chi_transaction::WRITENOSNPPTL_CLEANINVALID) ||
  (xact.xact_type == svt_chi_transaction::WRITEUNIQUEFULL_CLEANSHARED) ||
  (xact.xact_type == svt_chi_transaction::WRITEUNIQUEPTL_CLEANSHARED) ||
  (xact.xact_type == svt_chi_transaction::WRITEUNIQUEPTL_CLEANSHAREDPERSISTSEP) ||
  (xact.xact_type == svt_chi_transaction::WRITEUNIQUEFULL_CLEANSHAREDPERSISTSEP) ||
  (xact.xact_type == svt_chi_transaction::WRITENOSNPFULL_CLEANSHAREDPERSISTSEP) ||
  (xact.xact_type == svt_chi_transaction::WRITENOSNPPTL_CLEANSHAREDPERSISTSEP) ||
  `endif
  `ifdef SVT_CHI_ISSUE_F_ENABLE
  (xact.xact_type == svt_chi_transaction::WRITENOSNPDEF) ||
  (xact.xact_type == svt_chi_transaction::WRITENOSNPPTL_CLEANINVALIDPOPA) ||
  (xact.xact_type == svt_chi_transaction::WRITENOSNPFULL_CLEANINVALIDPOPA) ||
  `endif
  (xact.xact_type == svt_chi_transaction::WRITEUNIQUEPTL)
)

`define SVT_CHI_ISSUE_A_ENABLE

`define SVT_CHI_ISSUE_A_TO_ISSUE_C_ONLY_FEATURES_ENABLE

`define SVT_CHI_ISSUE_B_ENABLE

`define SVT_CHI_ISSUE_B_ISSUE_C_ONLY_FEATURES_ENABLE

`define SVT_CHI_ISSUE_C_ONLY_FEATURES_ENABLE

`define SVT_CHI_ISSUE_E_INTERNAL_ENABLE

`define SVT_CHI_ISSUE_F_INTERNAL_ENABLE

`define SVT_CHI_ISSUE_G_INTERNAL_ENABLE

`define SVT_CHI_LIKELYSHARED_WIDTH

`define SVT_CHI_LIMITED_VALIDATION_FEATURE_MSG_COV

Related covergroups are early adopter (EA) features. Coverage closure for these covergroups is not yet achieved within Synopsys internal setup. Users need to exclude any bins that are not valid/not applicable/not possible to hit at their end.

Used for documentation and messaging, for limited validated covergroups

`define SVT_CHI_LINK_ACTIVITY_MAX_DELAY_COUNT

Genaralized maximum delay count applicable for link activity

`define SVT_CHI_LINK_LAYER

`define SVT_CHI_LOAD_FOLLOWED_BY_STORE_FOLLOWED_BY_STORE_PATTERN_SEQ

11_1_0

`define SVT_CHI_LOAD_FOLLOWED_BY_STORE_PATTERN_SEQ

11_0_0

`define SVT_CHI_LOG_BASE_2_CACHE_LINE_SIZE

log_base_2 of cache line size (64) in CHI

`define SVT_CHI_LOG_BASE_2_CACHE_LINE_SIZE

`define SVT_CHI_LPID_WIDTH

Width of LPID field of a Message Request

`define SVT_CHI_MAX_ADDR_WIDTH

Width of Addr field of a Message Request For CHI Issue-B: this is redefinable For CHI Issue-A: this is fixed to 44

`define SVT_CHI_MAX_ATOMIC_BE_WIDTH

Width of atomic operation byte enable field

`define SVT_CHI_MAX_ATOMIC_DATA_WIDTH

128

Width of atomic operation data field

`define SVT_CHI_MAX_ATOMIC_DATACHECK_WIDTH

`define SVT_CHI_MAX_ATOMIC_LD_ST_BE_WIDTH

`define SVT_CHI_MAX_ATOMIC_LD_ST_DATA_WIDTH

`define SVT_CHI_MAX_ATOMIC_LD_ST_DATACHECK_WIDTH

`define SVT_CHI_MAX_ATOMIC_LD_ST_POISON_WIDTH

`define SVT_CHI_MAX_ATOMIC_POISON_WIDTH

`define SVT_CHI_MAX_BE_WIDTH

Width of transaction byte enable field

`define SVT_CHI_MAX_COMPDATATOCOMPACKFLIT_DELAY

Maximum value for read_xacts_compdata_to_compack_delay_count

`define SVT_CHI_MAX_COMPTODBID_DELAY

Maximum value for comp_to_dbid_flit_delay

`define SVT_CHI_MAX_DAT_FLIT_REORDERING_DEPTH

256

Maximum value for DAT flit reordering depth

`define SVT_CHI_MAX_DAT_FLIT_TO_LCRD_DELAY

Max value of received DAT flit to LCRD delay

`define SVT_CHI_MAX_DAT_FLIT_WIDTH

`define SVT_CHI_MAX_DATA_WIDTH

512

Width of transaction data field

`define SVT_CHI_MAX_DATACHECK_WIDTH

(SVT_CHI_MAX_DATA_WIDTH/8)

Width of transaction DataCheck field

`define SVT_CHI_MAX_DBIDTOCOMP_DELAY

Maximum value for dbid_to_comp_flit_delay

`define SVT_CHI_MAX_DBIDTODATAFLIT_DELAY

Maximum value for write_xacts_dbid_to_writedata_delay_count

`define SVT_CHI_MAX_FLIT_BUFFER_SIZE

Max flit buffer size for RX*** VC

`define SVT_CHI_MAX_INTER_XACT_OPTIMIZATIONS_RSP_DAT_DELAY

`define SVT_CHI_MAX_LPID_WIDTH

SVT_CHI_LPID_WIDTH

Define Max LPID width used for monitoring exclusive accesses by exclusive monitor *

`define SVT_CHI_MAX_MIN_CYCLES_IN_DEACTIVE

100

Max value for the min_cycles_in_deactive property in the Link Service descriptor

`define SVT_CHI_MAX_NODE_ID_WIDTH

`define SVT_CHI_MAX_NUM_CACHE_LINES

1024

Maximum number of cache lines

`define SVT_CHI_MAX_NUM_CLOCK_CYCLES_SPECULATIVE_SACTIVE_SIGNAL_ASSERTED

MAX_NUM_CLOCK_CYCLES_SPECULATIVE_SACTIVE_SIGNAL_ASSERTED

`define SVT_CHI_MAX_NUM_END_OF_XACT_TXSACTIVE_EXTENDED_ASSERTION_CYCLES

MAX_NUM_END_OF_XACT_TXSACTIVE_EXTENDED_ASSERTION_CYCLES

`define SVT_CHI_MAX_NUM_EXCLUSIVE_ACCESS

Maximum number of active exclusive accesses at a given node*

`define SVT_CHI_MAX_NUM_HNS

Maximum number of HNs

`define SVT_CHI_MAX_NUM_INTERCONNECTS

`define SVT_CHI_MAX_NUM_LCREDITS_XMITTED_IN_DEACTIVATE_STATE

Maximum number of L-Credits to be transmitted in Deactivate state.

`define SVT_CHI_MAX_NUM_OUTSTANDING_SNOOP_XACT

256

Maximum number of outstanding snoop transactions

`define SVT_CHI_MAX_NUM_OUTSTANDING_XACT

256

Maximum number of outstanding transactions

`define SVT_CHI_MAX_NUM_REQ_ORDER_STREAMS

Max value for the Number of Request Order Streams. This corresponds to CHI node configuration attribute num_req_order_streams.

`define SVT_CHI_MAX_NUM_RNS

`define SVT_CHI_MAX_NUM_SNS

`define SVT_CHI_MAX_NUM_SPECULATIVE_TXSACTIVE_ASSERTION_CYCLES

MAX_NUM_SPECULATIVE_TXSACTIVE_ASSERTION_CYCLES

`define SVT_CHI_MAX_NUM_SPECULATIVE_TXSACTIVE_DEASSERTION_CYCLES

MAX_NUM_SPECULATIVE_TXSACTIVE_DEASSERTION_CYCLES

`define SVT_CHI_MAX_NUM_SYSTEMS

`define SVT_CHI_MAX_PA_WIDTH

SVT_CHI_MAX_ADDR_WIDTH

`define SVT_CHI_MAX_PCREDITGRANTTORETRYACK_DELAY

Maximum value for pcreditgrant_to_retryack_flit_delay

`define SVT_CHI_MAX_PERMITTED_TXN_ID_WIDTH

SVT_CHI_RN_MAX_RXRSP_CHANNELS

`define SVT_CHI_MAX_POISON_WIDTH

(SVT_CHI_MAX_DATA_WIDTH/64)

Macros defining width of Poison field at transaction level

`define SVT_CHI_MAX_QOS_VALUE

(1<<SVT_CHI_QOS_WIDTH)

Maximum value of QoS field

`define SVT_CHI_MAX_RD_INTERLEAVE_DEPTH

256

`define SVT_CHI_MAX_READ_DATA_INTERLEAVE_SIZE

Defines used for read data interleaving in CHI ICN full slave

`define SVT_CHI_MAX_READ_FIFO_DRAIN_RATE

`define SVT_CHI_MAX_READ_FIFO_FULL_LEVEL

8192

`define SVT_CHI_MAX_REQ_CHANNELS

(SVT_CHI_RN_MAX_TXREQ_CHANNELS >= SVT_CHI_SN_MAX_RXREQ_CHANNELS ? SVT_CHI_RN_MAX_TXREQ_CHANNELS : SVT_CHI_SN_MAX_RXREQ_CHANNELS)

Maximum of RN & SN max REQ channel macros

`define SVT_CHI_MAX_REQ_FLIT_TO_LCRD_DELAY

Max value of received REQ flit to LCRD delay

`define SVT_CHI_MAX_REQ_FLIT_WIDTH

(52+(3*SVT_CHI_MAX_NODE_ID_WIDTH)+SVT_CHI_REQ_ADDR_WIDTH+SVT_CHI_REQ_FLIT_MAX_RSVDC_WIDTH+SVT_CHI_REQ_USER_EXTN_MAX_WIDTH)

`define SVT_CHI_MAX_REQTOCOMP_DELAY

Maximum value for req_to_comp_flit_delay

`define SVT_CHI_MAX_REQTOCOMPDATA_DELAY

Maximum value for req_to_compdata_flit_delay

`define SVT_CHI_MAX_REQTOCOMPDBID_DELAY

Maximum value for req_to_compdbid_flit_delay

`define SVT_CHI_MAX_REQTODBID_DELAY

Maximum value for req_to_dbid_flit_delay

`define SVT_CHI_MAX_REQTOPCREDITGRANT_DELAY

Maximum value for req_to_pcrdgrant_flit_delay

`define SVT_CHI_MAX_REQTORETRYACK_DELAY

Maximum value for req_to_retryack_flit_delay

`define SVT_CHI_MAX_RETRYACKTOPCREDITGRANT_DELAY

Maximum value for retryack_to_pcreditgrant_flit_delay

`define SVT_CHI_MAX_RSP_FLIT_REORDERING_DEPTH

256

Maximum value for RSP flit reordering depth

`define SVT_CHI_MAX_RSP_FLIT_TO_LCRD_DELAY

Max value of received RSP flit to LCRD delay

`define SVT_CHI_MAX_RSP_FLIT_WIDTH

(37+(2*SVT_CHI_MAX_NODE_ID_WIDTH)+SVT_CHI_RSP_USER_EXTN_MAX_WIDTH)

`define SVT_CHI_MAX_RXDAT_CHANNELS

(SVT_CHI_RN_MAX_RXDAT_CHANNELS >= SVT_CHI_SN_MAX_RXDAT_CHANNELS ? SVT_CHI_RN_MAX_RXDAT_CHANNELS : SVT_CHI_SN_MAX_RXDAT_CHANNELS)

Maximum of RN & SN max RXDAT channel macros

`define SVT_CHI_MAX_RXDATLCRDV_DELAY

Maximum value for RXDATLCRDV_DELAY

`define SVT_CHI_MAX_RXRSP_CHANNELS

Maximum of RN RXRSP channel macros

`define SVT_CHI_MAX_RXRSPLCRDV_DELAY

Maximum value for RXRSPLCRDV_DELAY

`define SVT_CHI_MAX_RXSNP_CHANNELS

SVT_CHI_RN_MAX_RXSNP_CHANNELS

Maximum of RN RXSNP channel macros

`define SVT_CHI_MAX_RXSNPLCRDV_DELAY

Maximum value for RXSNPLCRDV_DELAY

`define SVT_CHI_MAX_SNP_FLIT_TO_LCRD_DELAY

Max value of received SNP flit to LCRD delay

`define SVT_CHI_MAX_SNP_FLIT_WIDTH

(29+(2*SVT_CHI_MAX_NODE_ID_WIDTH)+SVT_CHI_SNP_ADDR_WIDTH+SVT_CHI_SNP_USER_EXTN_MAX_WIDTH)

`define SVT_CHI_MAX_SNPSTASHUNIQUE_XACT_TO_SNPRESP_DELAY

Maximum value for snpstashunique_xact_to_snpresp_delay

`define SVT_CHI_MAX_SNPUNIQUE_SNPCLEANINVALID_SNPMAKEINVALID_XACT_TO_SNPRESP_DELAY

Maximum value for snpunique_snpcleaninvalid_snpmakeinvalid_xact_to_snpresp_delay

`define SVT_CHI_MAX_SNPUNIQUE_SNPCLEANINVALID_XACT_TO_SNPRESPDATA_DELAY

Maximum value for snpunique_snpcleaninvalid_xact_to_snprespdata_delay

`define SVT_CHI_MAX_TAGGED_ADDR_WIDTH

(SVT_CHI_MAX_ADDR_WIDTH + SVT_CHI_TAG_ADDR_WIDTH)

`define SVT_CHI_MAX_TX_DATAPULL_COMPACK_FLITPEND_DELAY

Maximum value for TX_DATAPULL_COMPACK_FLITPEND_DELAY

`define SVT_CHI_MAX_TX_DATAPULL_COMPACK_FLITV_DELAY

Maximum value for TX_DATAPULL_COMPACK_FLITV_DELAY

`define SVT_CHI_MAX_TX_FLIT_DELAY

Max value for the flit delay. Must not conflict with `SVT_CHI_MAX_TX***FLITPEND_DELAY

`define SVT_CHI_MAX_TX_FLITPEND_FLITV_DELAY

Max value for the flitpend->flitv delay. Must not conflict with `SVT_CHI_MAX_TX***FLITV_DELAY

`define SVT_CHI_MAX_TXDAT_CHANNELS

(SVT_CHI_RN_MAX_TXDAT_CHANNELS >= SVT_CHI_SN_MAX_TXDAT_CHANNELS ? SVT_CHI_RN_MAX_TXDAT_CHANNELS : SVT_CHI_SN_MAX_TXDAT_CHANNELS)

Maximum of RN & SN max TXDAT channel macros

`define SVT_CHI_MAX_TXDATFLITPEND_DELAY

Maximum value for TXDATFLITPEND_DELAY

`define SVT_CHI_MAX_TXDATFLITV_DELAY

Maximum value for TXDATFLITV_DELAY

`define SVT_CHI_MAX_TXN_ID_WIDTH

`define SVT_CHI_MAX_TXREQFLITPEND_DELAY

Maximum value for TXREQFLITPEND_DELAY

`define SVT_CHI_MAX_TXREQFLITV_DELAY

Maximum value for TXREQFLITV_DELAY

`define SVT_CHI_MAX_TXRSP_CHANNELS

(SVT_CHI_RN_MAX_TXRSP_CHANNELS >= SVT_CHI_SN_MAX_TXRSP_CHANNELS ? SVT_CHI_RN_MAX_TXRSP_CHANNELS : SVT_CHI_SN_MAX_TXRSP_CHANNELS)

Maximum of RN & SN max TXRSP channel macros

`define SVT_CHI_MAX_TXRSPFLITPEND_DELAY

Maximum value for TXRSPFLITPEND_DELAY

`define SVT_CHI_MAX_TXRSPFLITV_DELAY

Maximum value for TXRSPFLITV_DELAY

`define SVT_CHI_MAX_TXSNPFLITV_DELAY

Maximum value for TXSNPFLITV_DELAY

`define SVT_CHI_MAX_VA_WIDTH

((SVT_CHI_MAX_ADDR_WIDTH == 44)?49:((SVT_CHI_MAX_ADDR_WIDTH == 45)?51:53))

`define SVT_CHI_MAX_VAL_FOR_LINK_ACTIVATION_TIMEOUT

200

Max value for the TX Link Activation Timeout

`define SVT_CHI_MAX_VAL_FOR_LINK_DEACTIVATION_TIME

200

Max value for the counter for Link Deactivation

`define SVT_CHI_MAX_VAL_FOR_LINK_DEACTIVATION_TIMEOUT

200

Max value for the TX Link Deactivation Timeout

`define SVT_CHI_MAX_VAL_RX_VC_CREDIT_TRANSMISSION_TIMEOUT

300

Max value for the RX VC credit transmission timeeout

`define SVT_CHI_MAX_WR_INTERLEAVE_DEPTH

256

`define SVT_CHI_MAX_WRITE_DATA_INTERLEAVE_SIZE

Defines used for Write data interleaving in CHI RN-F Node

`define SVT_CHI_MAX_WRITE_FIFO_FILL_RATE

`define SVT_CHI_MAX_WRITE_FIFO_FULL_LEVEL

8192

`define SVT_CHI_MAX_XACT_DAT_VC_ACCESS_FAIL_MAX_COUNT

100

Maximum value for XACT DAT VC access fail count. This should be >= 20 and >= 1.

`define SVT_CHI_MAX_XACT_RSP_VC_ACCESS_FAIL_MAX_COUNT

100

Maximum value for XACT RSP VC access fail count. This should be >= 20 and >= 1.

`define SVT_CHI_MEM_ATTR_WIDTH

Width of Mem Attr field

`define svt_chi_mem_debug ( id, msg )

if (chi_mem_reporter == null)
  svt_debug(id, msg);
else
`ifdef uvm_info_context
   do
     uvm_info_context(id, msg, UVM_HIGH, chi_mem_reporter)
   while (0)
`else
   do
     if (chi_mem_reporter.uvm_report_enabled(UVM_HIGH,UVM_INFO,id))
       chi_mem_reporter.uvm_report_info(id, msg, UVM_HIGH);
   while (0)
`endif

`define svt_chi_mem_error ( id, msg )

if (chi_mem_reporter == null)
  svt_error(id, msg);
else
`ifdef uvm_error_context
   do
     uvm_error_context(id, msg, chi_mem_reporter)
   while (0)
`else
   do
     if (chi_mem_reporter.uvm_report_enabled(UVM_NONE,UVM_ERROR,id))
       chi_mem_reporter.uvm_report_error(id, msg);
   while (0)
`endif

This is an SVT memory class customized for CHI.

`define svt_chi_mem_note ( id, msg )

if (chi_mem_reporter == null)
  svt_note(id, msg);
else
`ifdef uvm_info_context
   do
     uvm_info_context(id, msg, UVM_LOW, chi_mem_reporter)
   while (0)
`else
   do
     if (chi_mem_reporter.uvm_report_enabled(UVM_LOW,UVM_INFO,id))
       chi_mem_reporter.uvm_report_info(id, msg, UVM_LOW);
   while (0)
`endif

`define SVT_CHI_MEM_TYPE_DEVICE

`define SVT_CHI_MEM_TYPE_NORMAL

Defines for Memory types, also used by mem_attr_mem_type_enum

`define svt_chi_mem_verbose ( id, msg )

if (chi_mem_reporter == null)
  svt_verbose(id, msg);
else
`ifdef uvm_info_context
   do
     uvm_info_context(id, msg, UVM_FULL, chi_mem_reporter)
   while (0)
`else
   do
     if (chi_mem_reporter.uvm_report_enabled(UVM_FULL,UVM_INFO,id))
       chi_mem_reporter.uvm_report_info(id, msg, UVM_FULL);
   while (0)
`endif

`define svt_chi_mem_warning ( id, msg )

if (chi_mem_reporter == null)
  svt_warning(id, msg);
else
`ifdef uvm_warning_context
   do
     uvm_warning_context(id, msg, chi_mem_reporter)
   while(0)
`else
   do
     if (chi_mem_reporter.uvm_report_enabled(UVM_NONE,UVM_WARNING,id))
       chi_mem_reporter.uvm_report_warning(id, msg);
   while (0)
`endif

`define SVT_CHI_MEMORY_RESPONSE_GEN_SOURCE

`define SVT_CHI_MID_COMPDATATOCOMPACKFLIT_DELAY

Macro to control number of bins for read_xacts_compdata_to_compack_delay_count

`define SVT_CHI_MID_DBIDTODATAFLIT_DELAY

Macro to control number of bins for write_xacts_dbid_to_writedata_delay_count

`define SVT_CHI_MID_SNPSTASHUNIQUE_XACT_TO_SNPRESP_DELAY

Macro to control number of bins for snpstashunique_xact_to_snpresp_delay

`define SVT_CHI_MID_SNPUNIQUE_SNPCLEANINVALID_SNPMAKEINVALID_XACT_TO_SNPRESP_DELAY

Macro to control number of bins for snpunique_snpcleaninvalid_snpmakeinvalid_xact_to_snpresp_delay

`define SVT_CHI_MID_SNPUNIQUE_SNPCLEANINVALID_XACT_TO_SNPRESPDATA_DELAY

Macro to control number of bins for snpunique_snpcleaninvalid_xact_to_snprespdata_delay

`define SVT_CHI_MIN_COMPDATATOCOMPACKFLIT_DELAY

Minimum value for read_xacts_compdata_to_compack_delay_count

`define SVT_CHI_MIN_COMPTODBID_DELAY

Minimum value for comp_to_dbid_flit_delay

`define SVT_CHI_MIN_DAT_FLIT_TO_LCRD_DELAY

Min value of received DAT flit to LCRD delay

`define SVT_CHI_MIN_DBIDTOCOMP_DELAY

Minimum value for dbid_to_comp_flit_delay

`define SVT_CHI_MIN_DBIDTODATAFLIT_DELAY

Minimum value for write_xacts_dbid_to_writedata_delay_count

`define SVT_CHI_MIN_INTER_XACT_OPTIMIZATIONS_RSP_DAT_DELAY

`define SVT_CHI_MIN_NUM_END_OF_XACT_TXSACTIVE_EXTENDED_ASSERTION_CYCLES

MIN_NUM_END_OF_XACT_TXSACTIVE_EXTENDED_ASSERTION_CYCLES

`define SVT_CHI_MIN_NUM_SPECULATIVE_TXSACTIVE_ASSERTION_CYCLES

MIN_NUM_SPECULATIVE_TXSACTIVE_ASSERTION_CYCLES

`define SVT_CHI_MIN_NUM_SPECULATIVE_TXSACTIVE_DEASSERTION_CYCLES

MIN_NUM_SPECULATIVE_TXSACTIVE_DEASSERTION_CYCLES

`define SVT_CHI_MIN_PCREDITGRANTTORETRYACK_DELAY

Minimum value for pcreditgrant_to_retryack_flit_delay

`define SVT_CHI_MIN_REQ_FLIT_TO_LCRD_DELAY

Min value of received REQ flit to LCRD delay

`define SVT_CHI_MIN_REQTOCOMP_DELAY

Minimum value for req_to_comp_flit_delay

`define SVT_CHI_MIN_REQTOCOMPDATA_DELAY

Minimum value for req_to_compdata_flit_delay

`define SVT_CHI_MIN_REQTOCOMPDBID_DELAY

Minimum value for req_to_compdbid_flit_delay

`define SVT_CHI_MIN_REQTODBID_DELAY

Minimum value for req_to_dbid_flit_delay

`define SVT_CHI_MIN_REQTOPCREDITGRANT_DELAY

Minimum value for req_to_pcrdgrant_flit_delay

`define SVT_CHI_MIN_REQTORETRYACK_DELAY

Minimum value for req_to_retryack_flit_delay

`define SVT_CHI_MIN_RETRYACKTOPCREDITGRANT_DELAY

Minimum value for retryack_to_pcreditgrant_flit_delay

`define SVT_CHI_MIN_RSP_FLIT_TO_LCRD_DELAY

Min value of received RSP flit to LCRD delay

`define SVT_CHI_MIN_RXDATLCRDV_DELAY

Mininum value for RXDATLCRDV_DELAY

`define SVT_CHI_MIN_RXRSPLCRDV_DELAY

Mininum value for RXRSPLCRDV_DELAY

`define SVT_CHI_MIN_RXSNPLCRDV_DELAY

Mininum value for RXSNPLCRDV_DELAY

`define SVT_CHI_MIN_SNP_FLIT_TO_LCRD_DELAY

Min value of received SNP flit to LCRD delay

`define SVT_CHI_MIN_SNPSTASHUNIQUE_XACT_TO_SNPRESP_DELAY

Minimum value for snpstashunique_xact_to_snpresp_delay

`define SVT_CHI_MIN_SNPUNIQUE_SNPCLEANINVALID_SNPMAKEINVALID_XACT_TO_SNPRESP_DELAY

Minimum value for snpunique_snpcleaninvalid_snpmakeinvalid_xact_to_snpresp_delay

`define SVT_CHI_MIN_SNPUNIQUE_SNPCLEANINVALID_XACT_TO_SNPRESPDATA_DELAY

Minimum value for snpunique_snpcleaninvalid_xact_to_snprespdata_delay

`define SVT_CHI_MIN_TX_DATAPULL_COMPACK_FLITPEND_DELAY

Mininum value for TX_DATAPULL_COMPACK_FLITPEND_DELAY

`define SVT_CHI_MIN_TX_DATAPULL_COMPACK_FLITV_DELAY

Mininum value for TX_DATAPULL_COMPACK_FLITV_DELAY

`define SVT_CHI_MIN_TXDATFLITPEND_DELAY

Mininum value for TXDATFLITPEND_DELAY

`define SVT_CHI_MIN_TXDATFLITV_DELAY

Mininum value for TXDATFLITV_DELAY

`define SVT_CHI_MIN_TXREQFLITPEND_DELAY

Mininum value for TXREQFLITPEND_DELAY

`define SVT_CHI_MIN_TXREQFLITV_DELAY

Mininum value for TXREQFLITV_DELAY

`define SVT_CHI_MIN_TXRSPFLITPEND_DELAY

Mininum value for TXRSPFLITPEND_DELAY

`define SVT_CHI_MIN_TXRSPFLITV_DELAY

Mininum value for TXRSPFLITV_DELAY

`define SVT_CHI_MIN_TXSNPFLITV_DELAY

Mininum value for TXSNPFLITV_DELAY

`define SVT_CHI_MONITOR_IF_HOLD_TIME

0.1

`define SVT_CHI_MONITOR_IF_SETUP_TIME

0.1

`define SVT_CHI_MS_SCENARIO_GEN_SOURCE

`define SVT_CHI_NEW_LINK_ERR_CHECK_STATS ( stats_name, stats_description, reference, sub_group_name )

stats_name = new("",SVT_DATA_UTIL_ARG_TO_STRING(stats_name),
                 group_name,sub_group_name,
                 {stats_description},
                 {reference},svt_err_check_stats::ERROR,0,1
       `ifdef SVT_AMBA_ERR_CHECK_STATS_USED
        ,generic_prefix_str,
                   `SVT_AMBA_ERR_CHECK_STATS_SUFFIX_STR(stats_name)
       `endif
                 );
register_check(stats_name);
`ifndef SVT_VMM_TECHNOLOGY
`ifndef SVT_AMBA_EXCLUDE_CHI_NODE_LL_CHECK_COVERAGE
SVT_ERR_CHECK_STATS_COV_PREFIX_EXTENDED_CLASS_OVERRIDE(svt_chi_link,stats_name)
`endif
`endif
stats_name.set_default_pass_effect(svt_err_check_stats::EXPECTED);
`ifndef SVT_AMBA_EXCLUDE_CHI_NODE_LL_CHECK_COVERAGE
if ((node_cfg.ll_protocol_checks_coverage_enable == 1) && (enable_pc_cov ==1))
stats_name.add_cov(.enable_pass_cov(1),.enable_fail_cov(0));
`endif

`define SVT_CHI_NEW_LINK_WARN_CHECK_STATS ( stats_name, stats_description, reference, sub_group_name )

stats_name = new("",SVT_DATA_UTIL_ARG_TO_STRING(stats_name),
                 group_name,sub_group_name,
                 {stats_description},
                 {reference},svt_err_check_stats::WARNING,0,1
       `ifdef SVT_AMBA_ERR_CHECK_STATS_USED
        ,generic_prefix_str,
                   `SVT_AMBA_ERR_CHECK_STATS_SUFFIX_STR(stats_name)
       `endif
                 );
register_check(stats_name);
`ifndef SVT_VMM_TECHNOLOGY
`ifndef SVT_AMBA_EXCLUDE_CHI_NODE_LL_CHECK_COVERAGE
SVT_ERR_CHECK_STATS_COV_PREFIX_EXTENDED_CLASS_OVERRIDE(svt_chi_link,stats_name)
`endif
`endif
stats_name.set_default_pass_effect(svt_err_check_stats::EXPECTED);
`ifndef SVT_AMBA_EXCLUDE_CHI_NODE_LL_CHECK_COVERAGE
if ((node_cfg.ll_protocol_checks_coverage_enable == 1) && (enable_pc_cov ==1))
stats_name.add_cov(.enable_pass_cov(1),.enable_fail_cov(0));
`endif

`define SVT_CHI_NEW_PROT_ERR_CHECK_STATS ( stats_name, stats_description, reference, sub_group_name )

stats_name = new("",SVT_DATA_UTIL_ARG_TO_STRING(stats_name),
                 group_name,sub_group_name,
                 {stats_description},
                 {reference},svt_err_check_stats::ERROR,0,1
       `ifdef SVT_AMBA_ERR_CHECK_STATS_USED
        ,generic_prefix_str,
                   `SVT_AMBA_ERR_CHECK_STATS_SUFFIX_STR(stats_name)
       `endif
                 );
register_check(stats_name);
`ifndef SVT_VMM_TECHNOLOGY
`ifndef SVT_AMBA_EXCLUDE_CHI_NODE_PL_CHECK_COVERAGE
SVT_ERR_CHECK_STATS_COV_PREFIX_EXTENDED_CLASS_OVERRIDE(svt_chi_prot,stats_name)
`endif
`endif
stats_name.set_default_pass_effect(svt_err_check_stats::EXPECTED);
`ifndef SVT_AMBA_EXCLUDE_CHI_NODE_PL_CHECK_COVERAGE
if ((node_cfg.pl_protocol_checks_coverage_enable == 1) && (enable_pc_cov ==1))
stats_name.add_cov(.enable_pass_cov(1),.enable_fail_cov(0));
`endif

`define SVT_CHI_NEW_PROT_WARN_CHECK_STATS ( stats_name, stats_description, reference, sub_group_name )

stats_name = new("",SVT_DATA_UTIL_ARG_TO_STRING(stats_name),
                 group_name,sub_group_name,
                 {stats_description},
                 {reference},svt_err_check_stats::WARNING,0,1
       `ifdef SVT_AMBA_ERR_CHECK_STATS_USED
        ,generic_prefix_str,
                   `SVT_AMBA_ERR_CHECK_STATS_SUFFIX_STR(stats_name)
       `endif
                 );
register_check(stats_name);
`ifndef SVT_VMM_TECHNOLOGY
`ifndef SVT_AMBA_EXCLUDE_CHI_NODE_PL_CHECK_COVERAGE
SVT_ERR_CHECK_STATS_COV_PREFIX_EXTENDED_CLASS_OVERRIDE(svt_chi_prot,stats_name)
`endif
`endif
stats_name.set_default_pass_effect(svt_err_check_stats::EXPECTED);
`ifndef SVT_AMBA_EXCLUDE_CHI_NODE_PL_CHECK_COVERAGE
if ((node_cfg.pl_protocol_checks_coverage_enable == 1) && (enable_pc_cov ==1))
stats_name.add_cov(.enable_pass_cov(1),.enable_fail_cov(0));
`endif

`define SVT_CHI_NO_ORDERING_RD_AFTER_EP_ORDER_RD_FOLLOWED_BY_EP_ORDER_RD_TRANSACTION_W_DIFF_DIFF_ADDR_PATTERN_SEQ

6_2_16

`define SVT_CHI_NO_ORDERING_RD_AFTER_EP_ORDER_RD_FOLLOWED_BY_EP_ORDER_RD_TRANSACTION_W_SAME_ADDR_PATTERN_SEQ

6_1_16

`define SVT_CHI_NO_ORDERING_RD_AFTER_EP_ORDER_RD_FOLLOWED_BY_EP_ORDER_WR_TRANSACTION_W_DIFF_DIFF_ADDR_PATTERN_SEQ

6_2_14

`define SVT_CHI_NO_ORDERING_RD_AFTER_EP_ORDER_RD_FOLLOWED_BY_EP_ORDER_WR_TRANSACTION_W_SAME_ADDR_PATTERN_SEQ

6_1_14

`define SVT_CHI_NO_ORDERING_RD_AFTER_EP_ORDER_RD_FOLLOWED_BY_REQ_ORDER_RD_TRANSACTION_W_DIFF_DIFF_ADDR_PATTERN_SEQ

6_2_15

`define SVT_CHI_NO_ORDERING_RD_AFTER_EP_ORDER_RD_FOLLOWED_BY_REQ_ORDER_RD_TRANSACTION_W_SAME_ADDR_PATTERN_SEQ

6_1_15

`define SVT_CHI_NO_ORDERING_RD_AFTER_EP_ORDER_RD_FOLLOWED_BY_REQ_ORDER_WR_TRANSACTION_W_DIFF_DIFF_ADDR_PATTERN_SEQ

6_2_13

`define SVT_CHI_NO_ORDERING_RD_AFTER_EP_ORDER_RD_FOLLOWED_BY_REQ_ORDER_WR_TRANSACTION_W_SAME_ADDR_PATTERN_SEQ

6_1_13

`define SVT_CHI_NO_ORDERING_RD_AFTER_EP_ORDER_WR_FOLLOWED_BY_EP_ORDER_RD_TRANSACTION_W_DIFF_DIFF_ADDR_PATTERN_SEQ

6_2_12

`define SVT_CHI_NO_ORDERING_RD_AFTER_EP_ORDER_WR_FOLLOWED_BY_EP_ORDER_RD_TRANSACTION_W_SAME_ADDR_PATTERN_SEQ

6_1_12

`define SVT_CHI_NO_ORDERING_RD_AFTER_EP_ORDER_WR_FOLLOWED_BY_EP_ORDER_WR_TRANSACTION_W_DIFF_DIFF_ADDR_PATTERN_SEQ

6_2_10

`define SVT_CHI_NO_ORDERING_RD_AFTER_EP_ORDER_WR_FOLLOWED_BY_EP_ORDER_WR_TRANSACTION_W_SAME_ADDR_PATTERN_SEQ

6_1_10

`define SVT_CHI_NO_ORDERING_RD_AFTER_EP_ORDER_WR_FOLLOWED_BY_REQ_ORDER_RD_TRANSACTION_W_DIFF_DIFF_ADDR_PATTERN_SEQ

6_2_11

`define SVT_CHI_NO_ORDERING_RD_AFTER_EP_ORDER_WR_FOLLOWED_BY_REQ_ORDER_RD_TRANSACTION_W_SAME_ADDR_PATTERN_SEQ

6_1_11

`define SVT_CHI_NO_ORDERING_RD_AFTER_EP_ORDER_WR_FOLLOWED_BY_REQ_ORDER_WR_TRANSACTION_W_DIFF_DIFF_ADDR_PATTERN_SEQ

6_2_9

`define SVT_CHI_NO_ORDERING_RD_AFTER_EP_ORDER_WR_FOLLOWED_BY_REQ_ORDER_WR_TRANSACTION_W_SAME_ADDR_PATTERN_SEQ

6_1_9

`define SVT_CHI_NO_ORDERING_RD_AFTER_REQ_ORDER_RD_FOLLOWED_BY_EP_ORDER_RD_TRANSACTION_W_DIFF_DIFF_ADDR_PATTERN_SEQ

6_2_8

`define SVT_CHI_NO_ORDERING_RD_AFTER_REQ_ORDER_RD_FOLLOWED_BY_EP_ORDER_RD_TRANSACTION_W_SAME_ADDR_PATTERN_SEQ

6_1_8

`define SVT_CHI_NO_ORDERING_RD_AFTER_REQ_ORDER_RD_FOLLOWED_BY_EP_ORDER_WR_TRANSACTION_W_DIFF_DIFF_ADDR_PATTERN_SEQ

6_2_6

`define SVT_CHI_NO_ORDERING_RD_AFTER_REQ_ORDER_RD_FOLLOWED_BY_EP_ORDER_WR_TRANSACTION_W_SAME_ADDR_PATTERN_SEQ

6_1_6

`define SVT_CHI_NO_ORDERING_RD_AFTER_REQ_ORDER_RD_FOLLOWED_BY_REQ_ORDER_RD_TRANSACTION_W_DIFF_DIFF_ADDR_PATTERN_SEQ

6_2_7

`define SVT_CHI_NO_ORDERING_RD_AFTER_REQ_ORDER_RD_FOLLOWED_BY_REQ_ORDER_RD_TRANSACTION_W_SAME_ADDR_PATTERN_SEQ

6_1_7

`define SVT_CHI_NO_ORDERING_RD_AFTER_REQ_ORDER_RD_FOLLOWED_BY_REQ_ORDER_WR_TRANSACTION_W_DIFF_DIFF_ADDR_PATTERN_SEQ

6_2_5

`define SVT_CHI_NO_ORDERING_RD_AFTER_REQ_ORDER_RD_FOLLOWED_BY_REQ_ORDER_WR_TRANSACTION_W_SAME_ADDR_PATTERN_SEQ

6_1_5

`define SVT_CHI_NO_ORDERING_RD_AFTER_REQ_ORDER_WR_FOLLOWED_BY_EP_ORDER_RD_TRANSACTION_W_DIFF_DIFF_ADDR_PATTERN_SEQ

6_2_4

`define SVT_CHI_NO_ORDERING_RD_AFTER_REQ_ORDER_WR_FOLLOWED_BY_EP_ORDER_RD_TRANSACTION_W_SAME_ADDR_PATTERN_SEQ

6_1_4

`define SVT_CHI_NO_ORDERING_RD_AFTER_REQ_ORDER_WR_FOLLOWED_BY_EP_ORDER_WR_TRANSACTION_W_DIFF_DIFF_ADDR_PATTERN_SEQ

6_2_2

`define SVT_CHI_NO_ORDERING_RD_AFTER_REQ_ORDER_WR_FOLLOWED_BY_EP_ORDER_WR_TRANSACTION_W_SAME_ADDR_PATTERN_SEQ

6_1_2

`define SVT_CHI_NO_ORDERING_RD_AFTER_REQ_ORDER_WR_FOLLOWED_BY_REQ_ORDER_RD_TRANSACTION_W_DIFF_DIFF_ADDR_PATTERN_SEQ

6_2_3

`define SVT_CHI_NO_ORDERING_RD_AFTER_REQ_ORDER_WR_FOLLOWED_BY_REQ_ORDER_RD_TRANSACTION_W_SAME_ADDR_PATTERN_SEQ

6_1_3

`define SVT_CHI_NO_ORDERING_RD_AFTER_REQ_ORDER_WR_FOLLOWED_BY_REQ_ORDER_WR_TRANSACTION_W_DIFF_DIFF_ADDR_PATTERN_SEQ

6_2_1

`define SVT_CHI_NO_ORDERING_RD_AFTER_REQ_ORDER_WR_FOLLOWED_BY_REQ_ORDER_WR_TRANSACTION_W_SAME_ADDR_PATTERN_SEQ

6_1_1

`define SVT_CHI_NO_ORDERING_RD_AFTER_TWO_NON_NO_ORDERING_TRANSACTION_PATTERN_SEQ

6_0

`define SVT_CHI_NO_ORDERING_RD_AFTER_TWO_NON_NO_ORDERING_TRANSACTION_W_DIFF_DIFF_ADDR_PATTERN_SEQ

6_2

`define SVT_CHI_NO_ORDERING_RD_AFTER_TWO_NON_NO_ORDERING_TRANSACTION_W_SAME_ADDR_PATTERN_SEQ

6_1

`define SVT_CHI_NO_ORDERING_REQUIRED

SVT_CHI_ORDER_WIDTH'b00

Defines for different order types, also used by order_type_enum

`define SVT_CHI_NO_SOURCE

`define SVT_CHI_NODE_CFG_DEFAULT_ASYNC_INPUT_BANNED_OUTPUT_RACE_LINK_ACTIVE_STATES_TIMEOUT

Default value of CHI Node Configuration attribute async_input_banned_output_race_link_active_states_timeout

`define SVT_CHI_NODE_CFG_DEFAULT_CHI_SPEC_REVISION

ISSUE_A

Default value of CHI Extensions enable attribute

`define SVT_CHI_NODE_CFG_DEFAULT_ENABLE_MPAM

Default value of node configuration attribute enable_mpam

`define SVT_CHI_NODE_CFG_DEFAULT_IF_PARITY

UNSUPPORTED

Default value of node configuration attribute interface_parity_check_type

`define SVT_CHI_NODE_CFG_DEFAULT_IS_LINK_ACTIVE_STATE_MACHINE_IN_ASYNC_INPUT_RACE_STATE_EXPECTED

Default value of CHI Node Configuration attribute is_link_active_state_machine_in_async_input_race_state_expected

`define SVT_CHI_NODE_CFG_DEFAULT_IS_LINK_ACTIVE_STATE_MACHINE_IN_BANNED_OUTPUT_RACE_STATE_EXPECTED

Default value of CHI Node Configuration attribute is_link_active_state_machine_in_banned_output_race_state_expected

`define SVT_CHI_NODE_CFG_DEFAULT_MPAM_PARTID_PMG_TYPE

CHI_MPAM_9_1

Default value of node configuration attribute mpam_partid_pmg_type

`define SVT_CHI_NODE_CFG_DEFAULT_NDERR_RESP_POLICY

CHI_E_SPEC_BEHAVIOR

Default_value of node configuration attribute nderr_resp_policy.

`define SVT_CHI_NODE_CFG_DEFAULT_RESET_TYPE

EXCLUDE_UNSTARTED_XACT

Default value of node configuration attribute reset_type.

`define SVT_CHI_NODE_CFG_DEFAULT_STOP_SNP_LCRD_XMISSION_WHEN_TXLA_NOT_IN_RUN_STATE

Default value of CHI Node Configuration attribute stop_snp_lcrd_xmission_when_txla_not_in_run_state

`define SVT_CHI_NODE_CFG_PARTIAL_CACHE_STATES_ENABLE

Default value of node configuration attribute partial_cache_line_states_enable.

`define SVT_CHI_NODE_COV_NUM_BYTE_ENABLE_BINS

Used to define the number of bins for byte_enable values in node level covergroup trans_cross_chi_rn_writeuniqueptl_byte_enable.

`define SVT_CHI_NODE_ID_WIDTH

SVT_CHI_MAX_NODE_ID_WIDTH

Width of Node ID fields

`define SVT_CHI_NODE_INFO_PRINT_PREFIX ( cfg )

$sformatf("{SYS_ID(%0d) NODE_ID(%0d)} ",
(((cfg !=null) && (cfg.sys_cfg != null))?cfg.sys_cfg.system_id:-1),
((cfg != null)?cfg.node_id:-1))

`define SVT_CHI_NON_COHERENT_EXCLUSIVE_ACCESS_CONDITION ( xact )

((xact.xact_type == svt_chi_transaction::WRITENOSNPPTL ||
      xact.xact_type == svt_chi_transaction::WRITENOSNPFULL ||
       xact.xact_type == svt_chi_transaction::READNOSNP )
    )

`define SVT_CHI_NON_CONTIGUOUS_4_TIMES_EP_ORDER_TYPE_PATTERN_SEQ

5_2_4_2

`define SVT_CHI_NON_CONTIGUOUS_4_TIMES_ORDER_TYPE_PATTERN_SEQ

5_2_4

`define SVT_CHI_NON_CONTIGUOUS_4_TIMES_REQ_ORDER_TYPE_PATTERN_SEQ

5_2_4_1

`define SVT_CHI_NON_CONTIGUOUS_8_TIMES_EP_ORDER_TYPE_PATTERN_SEQ

5_2_8_2

`define SVT_CHI_NON_CONTIGUOUS_8_TIMES_ORDER_TYPE_PATTERN_SEQ

5_2_8

`define SVT_CHI_NON_CONTIGUOUS_8_TIMES_REQ_ORDER_TYPE_PATTERN_SEQ

5_2_8_1

`define SVT_CHI_NORMAL_CMO_XACT ( xact )

(
  (xact.xact_type == svt_chi_transaction::CLEANINVALID) ||
  (xact.xact_type == svt_chi_transaction::MAKEINVALID) ||
  (xact.xact_type == svt_chi_transaction::CLEANSHARED)
)

`define SVT_CHI_NS_WIDTH

`define SVT_CHI_NUM_P_CRD_TYPES

`define SVT_CHI_ORDER_WIDTH

Width of order field

`define SVT_CHI_OUTSTANDING_DVMOP_TLBI_FOLLOWED_BY_DVMOP_SYNC_DIFF_LPID

10_12

`define SVT_CHI_OUTSTANDING_DVMOP_TLBI_FOLLOWED_BY_DVMOP_SYNC_SAME_LPID

10_11

`define SVT_CHI_P_CRD_TYPE0

SVT_CHI_P_CRD_TYPE_WIDTH'd0

Defines for different P Credit types, also used by p_crd_type_enum

`define SVT_CHI_P_CRD_TYPE1

SVT_CHI_P_CRD_TYPE_WIDTH'd1

`define SVT_CHI_P_CRD_TYPE10

SVT_CHI_P_CRD_TYPE_WIDTH'd10

`define SVT_CHI_P_CRD_TYPE11

SVT_CHI_P_CRD_TYPE_WIDTH'd11

`define SVT_CHI_P_CRD_TYPE12

SVT_CHI_P_CRD_TYPE_WIDTH'd12

`define SVT_CHI_P_CRD_TYPE13

SVT_CHI_P_CRD_TYPE_WIDTH'd13

`define SVT_CHI_P_CRD_TYPE14

SVT_CHI_P_CRD_TYPE_WIDTH'd14

`define SVT_CHI_P_CRD_TYPE15

SVT_CHI_P_CRD_TYPE_WIDTH'd15

`define SVT_CHI_P_CRD_TYPE2

SVT_CHI_P_CRD_TYPE_WIDTH'd2

`define SVT_CHI_P_CRD_TYPE3

SVT_CHI_P_CRD_TYPE_WIDTH'd3

`define SVT_CHI_P_CRD_TYPE4

SVT_CHI_P_CRD_TYPE_WIDTH'd4

`define SVT_CHI_P_CRD_TYPE5

SVT_CHI_P_CRD_TYPE_WIDTH'd5

`define SVT_CHI_P_CRD_TYPE6

SVT_CHI_P_CRD_TYPE_WIDTH'd6

`define SVT_CHI_P_CRD_TYPE7

SVT_CHI_P_CRD_TYPE_WIDTH'd7

`define SVT_CHI_P_CRD_TYPE8

SVT_CHI_P_CRD_TYPE_WIDTH'd8

`define SVT_CHI_P_CRD_TYPE9

SVT_CHI_P_CRD_TYPE_WIDTH'd9

`define SVT_CHI_P_CRD_TYPE_WIDTH

Width of P Credit type field

`define SVT_CHI_PCRDRETURN_TYPE_SEMANTIC

`define SVT_CHI_PERSIST_CMO_XACT ( xact )

(
  `ifdef SVT_CHI_ISSUE_B_ENABLE
  (xact.xact_type == svt_chi_transaction::CLEANSHAREDPERSIST)
  `endif
  `ifdef SVT_CHI_ISSUE_D_ENABLE
  || (xact.xact_type == svt_chi_transaction::CLEANSHAREDPERSISTSEP )
  `endif
)

`define SVT_CHI_POISON_INTERNAL_WIDTH_ENABLE

Width of Posion field-- applicable for CHI Issue B

`define SVT_CHI_PREFETCHTGT_TYPE_SEMANTIC

`define SVT_CHI_PREV_RXDATFLITV_VALID_REF

`define SVT_CHI_PREV_TXDATFLITV_VALID_REF

`define SVT_CHI_PREV_TXREQFLITPEND_VALID_REF

Defines used by delay reference events

`define SVT_CHI_PRINT_PREFIX ( xact )

$sformatf("{%0s%0sSYS_ID('d%0d) %0sOBJ_NUM('d%0d) NODE_ID('d%0d) %0sTYPE(%0s)%0s TXN_ID('h%0h) QOS('h%0h) ADDR('h%0x)%0s%0s SIZE(%0s)%0s %0sNS(%0b) RETRY_ALLOWED(%0b)%0s%0s%0s%0s%0s%0s%0s%0s%0s%0s%0s ALLOCATE(%0b) SNPATTR('b%0b%0b)%0s%0s%0s%0s%0s%0s%0s%0s%0s%0s%0s%0s%0s%0s%0s%0s%0s%0s%0s%0s%0s%0s%0s} ",
          (((xact != null) && (xact.object_context != ""))?$sformatf("%0s: ", xact.object_context):""),
          (((xact != null) && (xact.object_info != ""))?$sformatf("OBJ_INFO(%0s) ", xact.object_info):""),
          ((xact != null && xact.cfg!= null && xact.cfg.sys_cfg != null)?xact.cfg.sys_cfg.system_id:-1),
          ((xact != null && xact.cfg!= null)?((xact.cfg.port_interleaving_enable==0)?"":($sformatf("INTRVED_GRP_OBJ_NUM('d%0d) ",xact.interleaved_group_object_num))):""),
          ((xact != null)?xact.object_num:-1),
          ((xact != null && xact.cfg!= null)?xact.cfg.node_id:-1),
          ((xact != null)?xact.source_target_info:""),
          ((xact != null)?xact.xact_type.name:"null"),
          ((xact != null)?((xact.xact_type==svt_chi_transaction::DVMOP)?(xact.is_dvm_msg_type_sync()?" DVM_TYPE(SYNC)":" DVM_TYPE(NON-SYNC)"):""):""),
          ((xact != null)?xact.txn_id:0),
          ((xact != null)?xact.qos:0),
          ((xact != null)?xact.addr:0),
          `ifdef SVT_CHI_ISSUE_F_ENABLE
          ((xact != null)?((xact.cfg != null && xact.cfg.pbha_support == svt_chi_node_configuration::CHI_PBHA_SUPPORT_TRUE)?($sformatf(" PBHA('h%0h) PBHA_POLICY(%0s)", xact.pbha, xact.pbha_policy.name())):""):""),
          `else
          "",
          `endif
          `ifdef SVT_CHI_ISSUE_G_ENABLE
          ((xact != null)?((xact.cfg != null && xact.cfg.mec_support == svt_chi_node_configuration::CHI_MEC_TRUE)?($sformatf(" MECID('h%0h) MECID_POLICY(%0s)", xact.mecid, xact.mecid_policy.name())):""):""),
          `else
          "",
          `endif
          ((xact != null)?xact.data_size.name:"null"),
          `ifdef SVT_CHI_ISSUE_F_ENABLE
          ((xact != null)?((xact.cfg != null && xact.cfg.cah_support == svt_chi_node_configuration::CHI_CAH_SUPPORT_TRUE && (xact.is_cah_applicable_xact() == 1 || xact.get_semantic()==SVT_CHI_READ_TYPE_SEMANTIC))?($sformatf(" CAH('b%0b)", xact.cah)):""):""),
          `else
          "",
          `endif
          `ifdef SVT_CHI_ISSUE_F_ENABLE
          ((xact != null)?($sformatf("NSE(%0b) ", xact.non_secure_ext)):""),
          `else
          "",
          `endif
          ((xact != null)?xact.is_non_secure_access:0),
          ((xact != null)?xact.is_dyn_p_crd:0),
          `ifdef SVT_CHI_ISSUE_B_ENABLE
          ((xact != null)?(xact.get_poison_str()):""),
          ((xact != null)?({" DATACHECK(",$sformatf("'h%0h", xact.datacheck),")"}):""),
          ((xact != null)?(
                           ((
                            xact.xact_type == svt_chi_transaction::WRITEUNIQUEFULLSTASH || xact.xact_type == svt_chi_transaction::WRITEUNIQUEPTLSTASH
                            || xact.xact_type == svt_chi_transaction::STASHONCESHARED || xact.xact_type == svt_chi_transaction::STASHONCEUNIQUE
                            `ifdef SVT_CHI_ISSUE_E_ENABLE
                            || xact.xact_type == svt_chi_transaction::STASHONCESEPSHARED || xact.xact_type == svt_chi_transaction::STASHONCESEPUNIQUE
                            `endif
                           )
                          )? {$sformatf(" STASH_NID_VALID(%0b) STASH_NID('h%0h) STASH_LPID_VALID(%0b) STASH_LPID('h%0h)", xact.stash_nid_valid, xact.stash_nid, xact.stash_lpid_valid, xact.stash_lpid)}:"")
                          :""),
          `else
            "",
            "",
            "",
          `endif
          ((xact != null)?{" COMPACK(",$sformatf("%0b", xact.exp_comp_ack),")"}:""),
          ((xact != null && xact.cfg!= null)?(((xact.xact_type==svt_chi_transaction::READCLEAN)||(xact.xact_type==svt_chi_transaction::READNOSNP)||
                            (xact.xact_type==svt_chi_transaction::READSHARED)||(xact.xact_type==svt_chi_transaction::CLEANUNIQUE)||
                            (xact.xact_type==svt_chi_transaction::WRITENOSNPFULL)||(xact.xact_type==svt_chi_transaction::WRITENOSNPPTL)
                            `ifdef SVT_CHI_ISSUE_B_ENABLE
                            ||
                            ((xact.cfg.chi_spec_revision>=svt_chi_node_configuration::ISSUE_B)?(xact.xact_type==svt_chi_transaction::READNOTSHAREDDIRTY):"")
                            `endif
                            `ifdef SVT_CHI_ISSUE_E_ENABLE
                            ||
                            ((xact.cfg.chi_spec_revision>=svt_chi_node_configuration::ISSUE_E)?(xact.xact_type==svt_chi_transaction::READPREFERUNIQUE):"")
                            ||
                            ((xact.cfg.chi_spec_revision>=svt_chi_node_configuration::ISSUE_E)?(xact.xact_type==svt_chi_transaction::MAKEREADUNIQUE):"")
                            `endif
                           )?{" IS_EXCLUSIVE(",$sformatf("%0b", xact.is_exclusive),")"}:""):""),
          ((xact != null && xact.cfg!= null)?(((((xact.xact_type==svt_chi_transaction::READCLEAN)||(xact.xact_type==svt_chi_transaction::READNOSNP)||
                             (xact.xact_type==svt_chi_transaction::READSHARED)||(xact.xact_type==svt_chi_transaction::CLEANUNIQUE)||
                             (xact.xact_type==svt_chi_transaction::WRITENOSNPFULL)||(xact.xact_type==svt_chi_transaction::WRITENOSNPPTL)
                            `ifdef SVT_CHI_ISSUE_B_ENABLE
                            ||
                            ((xact.cfg.chi_spec_revision>=svt_chi_node_configuration::ISSUE_B)?(xact.xact_type==svt_chi_transaction::READNOTSHAREDDIRTY):"")
                            `endif
                            `ifdef SVT_CHI_ISSUE_E_ENABLE
                            ||
                            ((xact.cfg.chi_spec_revision>=svt_chi_node_configuration::ISSUE_E)?(xact.xact_type==svt_chi_transaction::READPREFERUNIQUE):"")
                            ||
                            ((xact.cfg.chi_spec_revision>=svt_chi_node_configuration::ISSUE_E)?(xact.xact_type==svt_chi_transaction::MAKEREADUNIQUE):"")
                            `endif
                            ) &&
                            (xact.is_exclusive==1)) || xact.xact_type == svt_chi_transaction::DVMOP)?{" LPID(",$sformatf("'h%0h", xact.lpid),")"}:""):""),
          ((xact != null && xact.cfg!= null)?((((xact.xact_type==svt_chi_transaction::READCLEAN)||(xact.xact_type==svt_chi_transaction::READNOSNP)||
                             (xact.xact_type==svt_chi_transaction::READSHARED)||(xact.xact_type==svt_chi_transaction::CLEANUNIQUE)||
                             (xact.xact_type==svt_chi_transaction::WRITENOSNPFULL)||(xact.xact_type==svt_chi_transaction::WRITENOSNPPTL)
                            `ifdef SVT_CHI_ISSUE_B_ENABLE
                            ||
                            ((xact.cfg.chi_spec_revision>=svt_chi_node_configuration::ISSUE_B)?(xact.xact_type==svt_chi_transaction::READNOTSHAREDDIRTY):"")
                            `endif
                            `ifdef SVT_CHI_ISSUE_E_ENABLE
                            ||
                            ((xact.cfg.chi_spec_revision>=svt_chi_node_configuration::ISSUE_E)?(xact.xact_type==svt_chi_transaction::READPREFERUNIQUE):"")
                            ||
                            ((xact.cfg.chi_spec_revision>=svt_chi_node_configuration::ISSUE_E)?(xact.xact_type==svt_chi_transaction::MAKEREADUNIQUE):"")
                            `endif
                            ) &&
                            (xact.is_exclusive==1))?{" EXCL_ACCESS_STATUS(",$sformatf("%0s", xact.excl_access_status.name()),")"}:""):""),
          ((xact != null && xact.cfg!= null)?((((xact.xact_type==svt_chi_transaction::READCLEAN)||(xact.xact_type==svt_chi_transaction::READNOSNP)||
                             (xact.xact_type==svt_chi_transaction::READSHARED)||(xact.xact_type==svt_chi_transaction::CLEANUNIQUE)||
                             (xact.xact_type==svt_chi_transaction::WRITENOSNPFULL)||(xact.xact_type==svt_chi_transaction::WRITENOSNPPTL)
                            `ifdef SVT_CHI_ISSUE_B_ENABLE
                            ||
                            ((xact.cfg.chi_spec_revision>=svt_chi_node_configuration::ISSUE_B)?(xact.xact_type==svt_chi_transaction::READNOTSHAREDDIRTY):"")
                            `endif
                            `ifdef SVT_CHI_ISSUE_E_ENABLE
                            ||
                            ((xact.cfg.chi_spec_revision>=svt_chi_node_configuration::ISSUE_E)?(xact.xact_type==svt_chi_transaction::READPREFERUNIQUE):"")
                            ||
                            ((xact.cfg.chi_spec_revision>=svt_chi_node_configuration::ISSUE_E)?(xact.xact_type==svt_chi_transaction::MAKEREADUNIQUE):"")
                            `endif
                            ) &&
                            (xact.is_exclusive==1))?{" EXCL_MON_STATUS(",$sformatf("%0s", xact.excl_mon_status.name()),")"}:""):""),
          ((xact != null && xact.cfg!= null)?((((xact.xact_type==svt_chi_transaction::READCLEAN)||(xact.xact_type==svt_chi_transaction::READNOSNP)||
                             (xact.xact_type==svt_chi_transaction::READSHARED)||(xact.xact_type==svt_chi_transaction::CLEANUNIQUE)||
                             (xact.xact_type==svt_chi_transaction::WRITENOSNPFULL)||(xact.xact_type==svt_chi_transaction::WRITENOSNPPTL)
                            `ifdef SVT_CHI_ISSUE_B_ENABLE
                            ||
                            ((xact.cfg.chi_spec_revision>=svt_chi_node_configuration::ISSUE_B)?(xact.xact_type==svt_chi_transaction::READNOTSHAREDDIRTY):"")
                            `endif
                            `ifdef SVT_CHI_ISSUE_E_ENABLE
                            ||
                            ((xact.cfg.chi_spec_revision>=svt_chi_node_configuration::ISSUE_E)?(xact.xact_type==svt_chi_transaction::READPREFERUNIQUE):"")
                            ||
                            ((xact.cfg.chi_spec_revision>=svt_chi_node_configuration::ISSUE_E)?(xact.xact_type==svt_chi_transaction::MAKEREADUNIQUE):"")
                            `endif
                            ) &&
                            (xact.is_exclusive==1) && (xact.excl_access_status != svt_chi_transaction::EXCL_ACCESS_INITIAL))?{" EXCL_XACT_DROP_COND(",$sformatf("%0s", xact.excl_xact_drop_cond.name()),")"}:""):""),
                            `ifdef SVT_CHI_ISSUE_C_ENABLE
          ((xact != null)?(((xact.xact_type==svt_chi_transaction::READONCE)||(xact.xact_type==svt_chi_transaction::READONCECLEANINVALID)||(xact.xact_type==svt_chi_transaction::READONCEMAKEINVALID)||(xact.xact_type==svt_chi_transaction::READNOSNPSEP)||(xact.xact_type==svt_chi_transaction::READNOSNP)||(xact.xact_type==svt_chi_transaction::WRITENOSNPFULL)||(xact.xact_type==svt_chi_transaction::WRITENOSNPPTL)||(xact.xact_type==svt_chi_transaction::WRITEUNIQUEFULL)||(xact.xact_type==svt_chi_transaction::WRITEUNIQUEPTL)||(xact.is_atomicop_xact() == 1))?{" ORDER(",xact.order_type.name(),")"}:""):""),
                            `elsif SVT_CHI_ISSUE_B_ENABLE
          ((xact != null)?(((xact.xact_type==svt_chi_transaction::READONCE)||(xact.xact_type==svt_chi_transaction::READONCECLEANINVALID)||(xact.xact_type==svt_chi_transaction::READONCEMAKEINVALID)||(xact.xact_type==svt_chi_transaction::READNOSNP)||(xact.xact_type==svt_chi_transaction::WRITENOSNPFULL)||(xact.xact_type==svt_chi_transaction::WRITENOSNPPTL)||(xact.xact_type==svt_chi_transaction::WRITEUNIQUEFULL)||(xact.xact_type==svt_chi_transaction::WRITEUNIQUEPTL)||(xact.is_atomicop_xact() == 1))?{" ORDER(",xact.order_type.name(),")"}:""):""),
                            `else
          ((xact != null)?(((xact.xact_type==svt_chi_transaction::READONCE)||(xact.xact_type==svt_chi_transaction::READNOSNP)||(xact.xact_type==svt_chi_transaction::WRITENOSNPFULL)||(xact.xact_type==svt_chi_transaction::WRITENOSNPPTL)||(xact.xact_type==svt_chi_transaction::WRITEUNIQUEFULL)||(xact.xact_type==svt_chi_transaction::WRITEUNIQUEPTL))?{" ORDER(",xact.order_type.name(),")"}:""):""),
                            `endif
                            `ifdef SVT_CHI_ISSUE_F_ENABLE
          ((xact != null)?(((xact.xact_type==svt_chi_transaction::WRITENOSNPFULL_CLEANINVALIDPOPA) || (xact.xact_type==svt_chi_transaction::WRITENOSNPPTL_CLEANINVALIDPOPA) || (xact.xact_type==svt_chi_transaction::WRITEUNIQUEZERO) || (xact.xact_type==svt_chi_transaction::WRITENOSNPZERO) || (xact.xact_type==svt_chi_transaction::WRITENOSNPFULL_CLEANSHARED) || (xact.xact_type==svt_chi_transaction::WRITENOSNPFULL_CLEANINVALID) || (xact.xact_type==svt_chi_transaction::WRITENOSNPPTL_CLEANINVALID) || (xact.xact_type==svt_chi_transaction::WRITENOSNPPTL_CLEANINVALID) || (xact.xact_type==svt_chi_transaction::WRITEUNIQUEFULL_CLEANSHARED) || (xact.xact_type==svt_chi_transaction::WRITEUNIQUEPTL_CLEANSHARED))?{" ORDER(",xact.order_type.name(),")"}:""):""),
                            `elsif SVT_CHI_ISSUE_E_ENABLE
          ((xact != null)?(((xact.xact_type==svt_chi_transaction::WRITEUNIQUEZERO) || (xact.xact_type==svt_chi_transaction::WRITENOSNPZERO) || (xact.xact_type==svt_chi_transaction::WRITENOSNPFULL_CLEANSHARED) || (xact.xact_type==svt_chi_transaction::WRITENOSNPFULL_CLEANINVALID) || (xact.xact_type==svt_chi_transaction::WRITENOSNPPTL_CLEANSHARED) || (xact.xact_type==svt_chi_transaction::WRITENOSNPPTL_CLEANINVALID) || (xact.xact_type==svt_chi_transaction::WRITEUNIQUEFULL_CLEANSHARED) || (xact.xact_type==svt_chi_transaction::WRITEUNIQUEPTL_CLEANSHARED))?{" ORDER(",xact.order_type.name(),")"}:""):""),
                            `else
                              "",
                            `endif
          ((xact != null)?xact.mem_attr_allocate_hint:0),
          ((xact != null && xact.cfg.chi_spec_revision < svt_chi_node_configuration::ISSUE_B)?xact.snp_attr_snp_domain_type:0),
          ((xact != null)?xact.snp_attr_is_snoopable:0),
          `ifdef SVT_CHI_ISSUE_F_ENABLE
          ((xact != null)?(((xact.xact_type==svt_chi_transaction::READNOSNP)||(xact.xact_type==svt_chi_transaction::CLEANSHARED)||(xact.xact_type==svt_chi_transaction::CLEANINVALIDPOPA)||(xact.xact_type==svt_chi_transaction::CLEANINVALID)||(xact.xact_type==svt_chi_transaction::MAKEINVALID)||(xact.xact_type==svt_chi_transaction::WRITENOSNPFULL)||(xact.xact_type==svt_chi_transaction::WRITENOSNPPTL))?{" CACHEABLE(",$sformatf("%0b", xact.mem_attr_is_cacheable),")"}:""):""),
          `else
          ((xact != null)?(((xact.xact_type==svt_chi_transaction::READNOSNP)||(xact.xact_type==svt_chi_transaction::CLEANSHARED)||(xact.xact_type==svt_chi_transaction::CLEANINVALID)||(xact.xact_type==svt_chi_transaction::MAKEINVALID)||(xact.xact_type==svt_chi_transaction::WRITENOSNPFULL)||(xact.xact_type==svt_chi_transaction::WRITENOSNPPTL))?{" CACHEABLE(",$sformatf("%0b", xact.mem_attr_is_cacheable),")"}:""):""),
          `endif
          ((xact != null)?(((xact.xact_type==svt_chi_transaction::READNOSNP)||(xact.xact_type==svt_chi_transaction::WRITENOSNPFULL)||(xact.xact_type==svt_chi_transaction::WRITENOSNPPTL))?{" MEM_TYPE(",xact.mem_attr_mem_type.name,")"}:""):""),
          ((xact != null)?(((xact.xact_type==svt_chi_transaction::READNOSNP)||(xact.xact_type==svt_chi_transaction::WRITENOSNPFULL)||(xact.xact_type==svt_chi_transaction::WRITENOSNPPTL))?{" EWA(",$sformatf("%0b", xact.mem_attr_is_early_wr_ack_allowed),")"}:""):""),
          `ifdef SVT_CHI_ISSUE_E_ENABLE
          ((xact != null)?((xact.is_combined_writenosnpfull_cmo_xact() || xact.is_combined_writenosnpptl_cmo_xact())?($sformatf(" CACHEABLE$%0b$ MEM_TYPE$%0s$ EWA$%0b$", xact.mem_attr_is_cacheable, xact.mem_attr_mem_type, xact.mem_attr_is_early_wr_ack_allowed)):""):""),
          `else
            "",
          `endif
          `ifdef SVT_CHI_ISSUE_E_ENABLE
          ((xact != null)?(((xact.xact_type==svt_chi_transaction::WRITENOSNPFULL_CLEANSHAREDPERSISTSEP) || (xact.xact_type==svt_chi_transaction::WRITENOSNPPTL_CLEANSHAREDPERSISTSEP) || (xact.xact_type==svt_chi_transaction::WRITEUNIQUEFULL_CLEANSHAREDPERSISTSEP) || (xact.xact_type==svt_chi_transaction::WRITEUNIQUEPTL_CLEANSHAREDPERSISTSEP) || (xact.xact_type==svt_chi_transaction::WRITEBACKFULL_CLEANSHAREDPERSISTSEP) || (xact.xact_type==svt_chi_transaction::WRITECLEANFULL_CLEANSHAREDPERSISTSEP))?($sformatf(" PGROUP_ID$'h%0h$ DEEP$%0b$", xact.pgroup_id, xact.deep)):""):""),
          `else
            "",
          `endif
          `ifdef SVT_CHI_ISSUE_B_ENABLE
            `ifdef SVT_CHI_ISSUE_F_ENABLE
            ((xact != null)?((xact.is_atomicop_xact()==0)?(((xact.xact_type == svt_chi_transaction::CLEANSHARED)||(xact.xact_type == svt_chi_transaction::CLEANSHAREDPERSIST)||(xact.xact_type == svt_chi_transaction::CLEANINVALIDPOPA)||(xact.xact_type == svt_chi_transaction::CLEANINVALID)||(xact.xact_type == svt_chi_transaction::MAKEINVALID))?$sformatf(" MEM_TYPE$%0s$", xact.mem_attr_mem_type.name()):""):($sformatf(" CACHEABLE$%0b$ MEM_TYPE$%0s$ EWA $%0b$ ENDIAN$%0b$ SNOOPME$%0b$",xact.mem_attr_is_cacheable, xact.mem_attr_mem_type.name(), xact.mem_attr_is_early_wr_ack_allowed, xact.endian,xact.snoopme))):""),
            `else
            ((xact != null)?((xact.is_atomicop_xact()==0)?(((xact.xact_type == svt_chi_transaction::CLEANSHARED)||(xact.xact_type == svt_chi_transaction::CLEANSHAREDPERSIST)||(xact.xact_type == svt_chi_transaction::CLEANINVALID)||(xact.xact_type == svt_chi_transaction::MAKEINVALID))?$sformatf(" MEM_TYPE$%0s$", xact.mem_attr_mem_type.name()):""):($sformatf(" CACHEABLE$%0b$ MEM_TYPE$%0s$ EWA $%0b$ ENDIAN$%0b$ SNOOPME$%0b$",xact.mem_attr_is_cacheable, xact.mem_attr_mem_type.name(), xact.mem_attr_is_early_wr_ack_allowed, xact.endian,xact.snoopme))):""),
            `endif
            `ifdef SVT_CHI_ISSUE_D_ENABLE
            ((xact != null)?(xact.xact_type == svt_chi_transaction::CLEANSHAREDPERSISTSEP) ? ($sformatf(" PGROUP_ID$'h%0h$ MEM_TYPE$%0s$ is_comp_received$%0b$ is_persist_received$%0b$ is_comppersist_received$%0b$",xact.pgroup_id, xact.mem_attr_mem_type.name(),xact.is_comp_received, xact.is_persist_received, xact.is_comppersist_received)):(""):""),
            `else
              "",
            `endif
          `else
            "",
            "",
          `endif
          `ifdef SVT_CHI_ISSUE_E_ENABLE
          ((xact != null)?((xact.cfg.dvm_version_support >= svt_chi_node_configuration::DVM_v8_4 && xact.xact_type==svt_chi_transaction::DVMOP && xact.addr[13:11] == 3'b000)?($sformatf(" IS_TLBI_INVALIDATE_BY_VA_OR_IPA(%0b)", xact.addr[4])):""):""),
          `else
            "",
          `endif
          `ifdef SVT_CHI_ISSUE_E_ENABLE
          ((xact != null)?(((xact.cfg.chi_node_type == svt_chi_node_configuration::SN || xact.cfg.allow_dmt_from_rn_when_hn_is_absent || xact.cfg.allow_dwt_from_rn_when_hn_is_absent) && (xact.get_semantic()==SVT_CHI_READ_TYPE_SEMANTIC || xact.get_semantic()==SVT_CHI_WRITE_TYPE_SEMANTIC))?($sformatf(" RETURN_NID('h%0h)", xact.return_nid)):""):""),
          `elsif SVT_CHI_ISSUE_B_ENABLE
          ((xact != null)?(((xact.cfg.chi_node_type == svt_chi_node_configuration::SN || xact.cfg.allow_dmt_from_rn_when_hn_is_absent) && (xact.get_semantic()==SVT_CHI_READ_TYPE_SEMANTIC))?($sformatf(" RETURN_NID('h%0h)", xact.return_nid)):""):""),
          `else
            "",
          `endif
          `ifdef SVT_CHI_ISSUE_E_ENABLE
          ((xact != null)?(((xact.cfg.chi_node_type == svt_chi_node_configuration::SN || xact.cfg.allow_dmt_from_rn_when_hn_is_absent || xact.cfg.allow_dwt_from_rn_when_hn_is_absent) && (xact.get_semantic()==SVT_CHI_READ_TYPE_SEMANTIC || xact.get_semantic()==SVT_CHI_WRITE_TYPE_SEMANTIC))?($sformatf(" RETURN_TXNID('d%0h)", xact.return_txn_id)):""):""),
          `elsif SVT_CHI_ISSUE_B_ENABLE
          ((xact != null)?(((xact.cfg.chi_node_type == svt_chi_node_configuration::SN || xact.cfg.allow_dmt_from_rn_when_hn_is_absent) && (xact.get_semantic()==SVT_CHI_READ_TYPE_SEMANTIC))?($sformatf(" RETURN_TXNID('d%0h)", xact.return_txn_id)):""):""),
          `else
            "",
          `endif
          `ifdef SVT_CHI_ISSUE_E_ENABLE
          ((xact != null)?((xact.cfg.dvm_version_support >= svt_chi_node_configuration::DVM_v8_4 && xact.xact_type==svt_chi_transaction::DVMOP && xact.addr[13:11] == 3'b000 && xact.addr[4] == 1)?($sformatf(" IS_RANGE_BASED_TLBI(%0b)", xact.dvm_range)):""):""),
          `else
            "",
          `endif
          `ifdef SVT_CHI_ISSUE_E_ENABLE
          ((xact != null)?((xact.xact_type == svt_chi_transaction::WRITEEVICTOREVICT)?($sformatf(" IS_LIKELY_SHARED$%0b$ IS_COMP_RECEIVED$%0b$ IS_DBID_RECEIVED$%0b$ ",xact.is_likely_shared, xact.is_comp_received, xact.is_dbid_received)):""):""),
          ((xact != null)?($sformatf(" REQUEST_TAGOP$%0s$", xact.req_tag_op.name())):""),
          `ifdef SVT_CHI_ISSUE_F_ENABLE
          ((xact != null)?(((xact.xact_type == svt_chi_transaction::WRITENOSNPFULL_CLEANINVALIDPOPA) || (xact.xact_type == svt_chi_transaction::WRITENOSNPPTL_CLEANINVALIDPOPA) || (xact.xact_type == svt_chi_transaction::WRITENOSNPFULL) || (xact.xact_type == svt_chi_transaction::WRITENOSNPFULL_CLEANSHARED) || (xact.xact_type == svt_chi_transaction::WRITENOSNPFULL_CLEANINVALID) || (xact.xact_type == svt_chi_transaction::WRITENOSNPFULL_CLEANSHAREDPERSISTSEP) || (xact.xact_type == svt_chi_transaction::WRITENOSNPPTL) || (xact.xact_type == svt_chi_transaction::WRITENOSNPPTL_CLEANSHARED) || (xact.xact_type == svt_chi_transaction::WRITENOSNPPTL_CLEANINVALID) || (xact.xact_type == svt_chi_transaction::WRITENOSNPPTL_CLEANSHAREDPERSISTSEP) || (xact.xact_type == svt_chi_transaction::WRITEUNIQUEFULL) || (xact.xact_type == svt_chi_transaction::WRITEUNIQUEFULL_CLEANSHARED) || (xact.xact_type == svt_chi_transaction::WRITEUNIQUEFULL_CLEANSHAREDPERSISTSEP) || (xact.xact_type == svt_chi_transaction::WRITEUNIQUEPTL) || (xact.xact_type == svt_chi_transaction::WRITEUNIQUEPTL_CLEANSHARED) || (xact.xact_type == svt_chi_transaction::WRITEUNIQUEPTL_CLEANSHAREDPERSISTSEP) || (xact.xact_type == svt_chi_transaction::WRITEUNIQUEFULLSTASH) || (xact.xact_type == svt_chi_transaction::WRITEUNIQUEPTLSTASH))?($sformatf(" DO_DWT$%0b$", xact.do_dwt)):""):""),
          `else
          ((xact != null)?(((xact.xact_type == svt_chi_transaction::WRITENOSNPFULL) || (xact.xact_type == svt_chi_transaction::WRITENOSNPFULL_CLEANSHARED) || (xact.xact_type == svt_chi_transaction::WRITENOSNPFULL_CLEANINVALID) || (xact.xact_type == svt_chi_transaction::WRITENOSNPFULL_CLEANSHAREDPERSISTSEP) || (xact.xact_type == svt_chi_transaction::WRITENOSNPPTL) || (xact.xact_type == svt_chi_transaction::WRITENOSNPPTL_CLEANSHARED) || (xact.xact_type == svt_chi_transaction::WRITENOSNPPTL_CLEANINVALID) || (xact.xact_type == svt_chi_transaction::WRITENOSNPPTL_CLEANSHAREDPERSISTSEP) || (xact.xact_type == svt_chi_transaction::WRITEUNIQUEFULL) || (xact.xact_type == svt_chi_transaction::WRITEUNIQUEFULL_CLEANSHARED) || (xact.xact_type == svt_chi_transaction::WRITEUNIQUEFULL_CLEANSHAREDPERSISTSEP) || (xact.xact_type == svt_chi_transaction::WRITEUNIQUEPTL) || (xact.xact_type == svt_chi_transaction::WRITEUNIQUEPTL_CLEANSHARED) || (xact.xact_type == svt_chi_transaction::WRITEUNIQUEPTL_CLEANSHAREDPERSISTSEP) || (xact.xact_type == svt_chi_transaction::WRITEUNIQUEFULLSTASH) || (xact.xact_type == svt_chi_transaction::WRITEUNIQUEPTLSTASH))?($sformatf(" DO_DWT$%0b$", xact.do_dwt)):""):""),
          `endif
          ((xact != null && (xact.is_atomicop_xact() == 0) && xact.data_status != svt_chi_transaction::INITIAL)?($sformatf(" DATA_TAGOP$%0s$", xact.data_tag_op.name())):""),
          ((xact != null && (xact.xact_type == svt_chi_transaction::MAKEREADUNIQUE) && xact.is_comp_received && xact.data_status == svt_chi_transaction::INITIAL)?($sformatf(" RSP_TAGOP$%0s$", xact.rsp_tag_op.name())):""),
          ((xact != null && (xact.is_atomicop_xact() == 1) && xact.atomic_write_data_status != svt_chi_transaction::INITIAL)?($sformatf(" ATOMIC_WRITE_DATA_TAGOP$%0s$", xact.atomic_write_data_tag_op.name())):""),
          ((xact != null && (xact.is_atomicop_xact() == 1) && xact.atomic_returned_initial_data_status != svt_chi_transaction::INITIAL)?($sformatf(" ATOMIC_READ_DATA_TAGOP$%0s$", xact.atomic_read_data_tag_op.name())):""),
          `else
            "",
            "",
            "",
            "",
            "",
            "",
            "",
          `endif
          `ifdef SVT_CHI_ISSUE_F_ENABLE
            (((xact!=null) && xact.xact_type == svt_chi_transaction::WRITENOSNPDEF && xact.req_status == svt_chi_transaction::ACCEPT)? $sformatf(" RESPONSE(%0s)", xact.deferreable_write_resp.name()): ""),
          `else
            "",
          `endif
          `ifdef SVT_CHI_ISSUE_D_ENABLE
            (((xact!=null) && (xact.cfg!=null) && (xact.cfg.enable_mpam))? $sformatf(" MPAM_PERFMONGROUP('h%0h) MPAM_PARTID('h%0h) MPAM_NS('h%0h)", xact.mpam_perfmongroup, xact.mpam_partid, xact.mpam_ns): ""),
          `else
            "",
          `endif
          ((xact != null)?((xact.get_begin_time()==-1)?"":($sformatf(" START_TIME(%0t)",xact.get_begin_realtime()))):""),
          ((xact != null)?((xact.get_end_time()==-1)?"":($sformatf(" END_TIME(%0t)",xact.get_end_realtime()))):""),
          ((xact != null)?((xact.get_req_accept_realtime()==-1)?"":($sformatf(" REQ_ACCEPT_TIME(%0t)",xact.get_req_accept_realtime()))):""))

`define SVT_CHI_PRINT_PREFIX1 ( xact )

SVT_CHI_PRINT_PREFIX(xact)

`define SVT_CHI_PROT_SVC_PRINT_PREFIX ( xact )

xact.psdisplay_concise()

`define SVT_CHI_PROTOCOL_LAYER

Used to define the layer

`define SVT_CHI_QOS_WIDTH

Width of QoS field

`define SVT_CHI_READ_FOLLOWED_BY_READ_PATTERN_SEQ

3_0

`define SVT_CHI_READ_FOLLOWED_BY_WRITE_PATTERN_SEQ

4_0

`define SVT_CHI_READ_TYPE_SEMANTIC

Used to define the kind of semantics used for a transation type

`define SVT_CHI_REASONABLE_FLIT_BUFFER_SIZE

Default flit buffer size for RX*** VC

`define SVT_CHI_REASONABLE_XACT_DAT_VC_ACCESS_FAIL_MAX_COUNT

Reasonable value for XACT DAT VC access fail count. This should be >=1 and <= 100

`define SVT_CHI_REASONABLE_XACT_RSP_VC_ACCESS_FAIL_MAX_COUNT

Reasonable value for XACT RSP VC access fail count. This should be >=1 and <= 100

`define SVT_CHI_REORDERING_PRIORITIZED

`define SVT_CHI_REORDERING_RANDOM

`define SVT_CHI_REORDERING_ROUND_ROBIN

`define SVT_CHI_REPLICATED_CHANNELS_INTERNAL_ENABLE

`define SVT_CHI_REQ_ADDR_WIDTH

SVT_CHI_MAX_ADDR_WIDTH

`define SVT_CHI_REQ_EP_ORDERING_REQUIRED

SVT_CHI_ORDER_WIDTH'b11

`define SVT_CHI_REQ_FLIT

Defines FLIT types, also used by flit_type_enum

`define SVT_CHI_REQ_FLIT_LSB_ADDRESS

(SVT_CHI_REQ_FLIT_LSB_SIZE+SVT_CHI_SIZE_WIDTH)

`define SVT_CHI_REQ_FLIT_LSB_ALLOWRETRY

(SVT_CHI_REQ_FLIT_LSB_LIKELYSHARED+SVT_CHI_LIKELYSHARED_WIDTH)

`define SVT_CHI_REQ_FLIT_LSB_EXCL_SNPME_CAH

(SVT_CHI_REQ_FLIT_LSB_LPID_PGROUPID_TAGGROUPID_STASHGROUPID+SVT_CHI_LPID_WIDTH)

`define SVT_CHI_REQ_FLIT_LSB_EXPCOMPACK

(SVT_CHI_REQ_FLIT_LSB_EXCL_SNPME_CAH+SVT_CHI_EXCL_SNPME_CAH_WIDTH)

`define SVT_CHI_REQ_FLIT_LSB_LIKELYSHARED

(SVT_CHI_REQ_FLIT_LSB_NS+SVT_CHI_NS_WIDTH)

`define SVT_CHI_REQ_FLIT_LSB_LPID_PGROUPID_TAGGROUPID_STASHGROUPID

(SVT_CHI_REQ_FLIT_LSB_SNPATTR_DODWT+SVT_CHI_SNP_ATTR_WIDTH)

`define SVT_CHI_REQ_FLIT_LSB_MEMATTR

(SVT_CHI_REQ_FLIT_LSB_PCRDTYPE+SVT_CHI_P_CRD_TYPE_WIDTH)

`define SVT_CHI_REQ_FLIT_LSB_NS

(SVT_CHI_REQ_FLIT_LSB_ADDRESS+SVT_CHI_MAX_ADDR_WIDTH)

`define SVT_CHI_REQ_FLIT_LSB_OPCODE

(SVT_CHI_REQ_FLIT_LSB_RETURNTXNID_STASHLPID+SVT_CHI_RETURN_TXN_ID_WIDTH)

`define SVT_CHI_REQ_FLIT_LSB_ORDER

(SVT_CHI_REQ_FLIT_LSB_ALLOWRETRY+SVT_CHI_ALLOWRETRY_WIDTH)

`define SVT_CHI_REQ_FLIT_LSB_PCRDTYPE

(SVT_CHI_REQ_FLIT_LSB_ORDER+SVT_CHI_ORDER_WIDTH)

`define SVT_CHI_REQ_FLIT_LSB_QOS

`define SVT_CHI_REQ_FLIT_LSB_RETURNNID_STASHNID

(SVT_CHI_REQ_FLIT_LSB_TXNID+SVT_CHI_TXN_ID_WIDTH)

`define SVT_CHI_REQ_FLIT_LSB_RETURNTXNID_STASHLPID

(SVT_CHI_REQ_FLIT_LSB_STASHNIDVALID_ENDIAN_DEEP_PREFETCHTGTHINT+SVT_CHI_STASHNIDVALID_WIDTH)

`define SVT_CHI_REQ_FLIT_LSB_RSVDC

(SVT_CHI_REQ_FLIT_LSB_TRACETAG+SVT_CHI_TRACE_TAG_WIDTH)

`define SVT_CHI_REQ_FLIT_LSB_SIZE

(SVT_CHI_REQ_FLIT_LSB_OPCODE+SVT_CHI_REQ_VC_FLIT_OP_WIDTH)

`define SVT_CHI_REQ_FLIT_LSB_SNPATTR_DODWT

(SVT_CHI_REQ_FLIT_LSB_MEMATTR+SVT_CHI_MEM_ATTR_WIDTH)

`define SVT_CHI_REQ_FLIT_LSB_SRCID

(SVT_CHI_REQ_FLIT_LSB_TGTID+SVT_CHI_TGT_ID_WIDTH)

`define SVT_CHI_REQ_FLIT_LSB_STASHLPID_VALID

(SVT_CHI_REQ_FLIT_LSB_STASHNIDVALID_ENDIAN_DEEP_PREFETCHTGTHINT+SVT_CHI_STASHNIDVALID_WIDTH+SVT_CHI_STASH_LPID_WIDTH)

`define SVT_CHI_REQ_FLIT_LSB_STASHNIDVALID_ENDIAN_DEEP_PREFETCHTGTHINT

(SVT_CHI_REQ_FLIT_LSB_RETURNNID_STASHNID+SVT_CHI_RETURN_NID_WIDTH)

`define SVT_CHI_REQ_FLIT_LSB_TGTID

(SVT_CHI_REQ_FLIT_LSB_EXPCOMPACK+SVT_CHI_EXPCOMPACK_WIDTH)

`define SVT_CHI_REQ_FLIT_LSB_TRACETAG

`define SVT_CHI_REQ_FLIT_LSB_TXNID

(SVT_CHI_REQ_FLIT_LSB_SRCID+SVT_CHI_SRC_ID_WIDTH)

`define SVT_CHI_REQ_FLIT_MAX_RSVDC_WIDTH

This defines the width of RSVDC field width of the TXREQFLIT and RXREQFLIT

`define SVT_CHI_REQ_ORDERED_RD_FOLLOWED_BY_EP_ORDERED_RD_PATTERN_SEQ

3_2

`define SVT_CHI_REQ_ORDERED_RD_FOLLOWED_BY_EP_ORDERED_RD_W_DIFF_ADDR_PATTERN_SEQ

3_2_2

`define SVT_CHI_REQ_ORDERED_RD_FOLLOWED_BY_EP_ORDERED_RD_W_SAME_ADDR_PATTERN_SEQ

3_2_1

`define SVT_CHI_REQ_ORDERED_RD_FOLLOWED_BY_EP_ORDERED_WR_PATTERN_SEQ

4_2

`define SVT_CHI_REQ_ORDERED_RD_FOLLOWED_BY_EP_ORDERED_WR_W_DIFF_ADDR_PATTERN_SEQ

4_2_2

`define SVT_CHI_REQ_ORDERED_RD_FOLLOWED_BY_EP_ORDERED_WR_W_SAME_ADDR_PATTERN_SEQ

4_2_1

`define SVT_CHI_REQ_ORDERED_RD_FOLLOWED_BY_REQ_ORDERED_RD_PATTERN_SEQ

3_1

`define SVT_CHI_REQ_ORDERED_RD_FOLLOWED_BY_REQ_ORDERED_RD_W_DIFF_ADDR_PATTERN_SEQ

3_1_2

`define SVT_CHI_REQ_ORDERED_RD_FOLLOWED_BY_REQ_ORDERED_RD_W_SAME_ADDR_PATTERN_SEQ

3_1_1

`define SVT_CHI_REQ_ORDERED_RD_FOLLOWED_BY_REQ_ORDERED_WR_PATTERN_SEQ

4_1

`define SVT_CHI_REQ_ORDERED_RD_FOLLOWED_BY_REQ_ORDERED_WR_W_DIFF_ADDR_PATTERN_SEQ

4_1_2

`define SVT_CHI_REQ_ORDERED_RD_FOLLOWED_BY_REQ_ORDERED_WR_W_SAME_ADDR_PATTERN_SEQ

4_1_1

`define SVT_CHI_REQ_ORDERED_WR_FOLLOWED_BY_EP_ORDERED_RD_PATTERN_SEQ

1_2

`define SVT_CHI_REQ_ORDERED_WR_FOLLOWED_BY_EP_ORDERED_RD_W_DIFF_ADDR_PATTERN_SEQ

1_2_2

`define SVT_CHI_REQ_ORDERED_WR_FOLLOWED_BY_EP_ORDERED_RD_W_SAME_ADDR_PATTERN_SEQ

1_2_1

`define SVT_CHI_REQ_ORDERED_WR_FOLLOWED_BY_EP_ORDERED_WR_PATTERN_SEQ

2_2

`define SVT_CHI_REQ_ORDERED_WR_FOLLOWED_BY_EP_ORDERED_WR_W_DIFF_ADDR_PATTERN_SEQ

2_2_2

`define SVT_CHI_REQ_ORDERED_WR_FOLLOWED_BY_EP_ORDERED_WR_W_SAME_ADDR_PATTERN_SEQ

2_2_1

`define SVT_CHI_REQ_ORDERED_WR_FOLLOWED_BY_REQ_ORDERED_RD_PATTERN_SEQ

1_1

`define SVT_CHI_REQ_ORDERED_WR_FOLLOWED_BY_REQ_ORDERED_RD_W_DIFF_ADDR_PATTERN_SEQ

1_1_2

`define SVT_CHI_REQ_ORDERED_WR_FOLLOWED_BY_REQ_ORDERED_RD_W_SAME_ADDR_PATTERN_SEQ

1_1_1

`define SVT_CHI_REQ_ORDERED_WR_FOLLOWED_BY_REQ_ORDERED_WR_PATTERN_SEQ

2_1

`define SVT_CHI_REQ_ORDERED_WR_FOLLOWED_BY_REQ_ORDERED_WR_W_DIFF_ADDR_PATTERN_SEQ

2_1_2

`define SVT_CHI_REQ_ORDERED_WR_FOLLOWED_BY_REQ_ORDERED_WR_W_SAME_ADDR_PATTERN_SEQ

2_1_1

`define SVT_CHI_REQ_ORDERING_REQUIRED

SVT_CHI_ORDER_WIDTH'b10

`define SVT_CHI_REQ_PACK_UNPACK_WIDTH

(169+SVT_CHI_REQ_USER_EXTN_MAX_WIDTH)

`define SVT_CHI_REQ_RESERVED_STASHLPID_WIDTH

(SVT_CHI_RETURN_TXN_ID_WIDTH-(SVT_CHI_STASH_LPID_WIDTH+SVT_CHI_STASHLPIDVALID_WIDTH))

Width of Reserved bits in STASHLPID fields of REQ flit-- applicable for CHI Issue B or later

`define SVT_CHI_REQ_RSVDC_WIDTH

((SVT_CHI_REQ_FLIT_MAX_RSVDC_WIDTH ==0 )?1:SVT_CHI_REQ_FLIT_MAX_RSVDC_WIDTH)

Width of REQ RSVDC field

`define SVT_CHI_REQ_USER_EXTN_MAX_WIDTH

`define SVT_CHI_REQ_VC_FLIT_OP_ATOMICCOMPARE

SVT_CHI_REQ_VC_FLIT_OP_WIDTH'h39

`define SVT_CHI_REQ_VC_FLIT_OP_ATOMICLOAD_ADD

SVT_CHI_REQ_VC_FLIT_OP_WIDTH'h30

`define SVT_CHI_REQ_VC_FLIT_OP_ATOMICLOAD_CLR

SVT_CHI_REQ_VC_FLIT_OP_WIDTH'h31

`define SVT_CHI_REQ_VC_FLIT_OP_ATOMICLOAD_EOR

SVT_CHI_REQ_VC_FLIT_OP_WIDTH'h32

`define SVT_CHI_REQ_VC_FLIT_OP_ATOMICLOAD_SET

SVT_CHI_REQ_VC_FLIT_OP_WIDTH'h33

`define SVT_CHI_REQ_VC_FLIT_OP_ATOMICLOAD_SMAX

SVT_CHI_REQ_VC_FLIT_OP_WIDTH'h34

`define SVT_CHI_REQ_VC_FLIT_OP_ATOMICLOAD_SMIN

SVT_CHI_REQ_VC_FLIT_OP_WIDTH'h35

`define SVT_CHI_REQ_VC_FLIT_OP_ATOMICLOAD_UMAX

SVT_CHI_REQ_VC_FLIT_OP_WIDTH'h36

`define SVT_CHI_REQ_VC_FLIT_OP_ATOMICLOAD_UMIN

SVT_CHI_REQ_VC_FLIT_OP_WIDTH'h37

`define SVT_CHI_REQ_VC_FLIT_OP_ATOMICSTORE_ADD

SVT_CHI_REQ_VC_FLIT_OP_WIDTH'h28

`define SVT_CHI_REQ_VC_FLIT_OP_ATOMICSTORE_CLR

SVT_CHI_REQ_VC_FLIT_OP_WIDTH'h29

`define SVT_CHI_REQ_VC_FLIT_OP_ATOMICSTORE_EOR

SVT_CHI_REQ_VC_FLIT_OP_WIDTH'h2A

`define SVT_CHI_REQ_VC_FLIT_OP_ATOMICSTORE_SET

SVT_CHI_REQ_VC_FLIT_OP_WIDTH'h2B

`define SVT_CHI_REQ_VC_FLIT_OP_ATOMICSTORE_SMAX

SVT_CHI_REQ_VC_FLIT_OP_WIDTH'h2C

`define SVT_CHI_REQ_VC_FLIT_OP_ATOMICSTORE_SMIN

SVT_CHI_REQ_VC_FLIT_OP_WIDTH'h2D

`define SVT_CHI_REQ_VC_FLIT_OP_ATOMICSTORE_UMAX

SVT_CHI_REQ_VC_FLIT_OP_WIDTH'h2E

`define SVT_CHI_REQ_VC_FLIT_OP_ATOMICSTORE_UMIN

SVT_CHI_REQ_VC_FLIT_OP_WIDTH'h2F

`define SVT_CHI_REQ_VC_FLIT_OP_ATOMICSWAP

SVT_CHI_REQ_VC_FLIT_OP_WIDTH'h38

`define SVT_CHI_REQ_VC_FLIT_OP_CLEANINVALID

SVT_CHI_REQ_VC_FLIT_OP_WIDTH'h09

`define SVT_CHI_REQ_VC_FLIT_OP_CLEANSHARED

SVT_CHI_REQ_VC_FLIT_OP_WIDTH'h08

`define SVT_CHI_REQ_VC_FLIT_OP_CLEANSHAREDPERSIST

SVT_CHI_REQ_VC_FLIT_OP_WIDTH'h27

`define SVT_CHI_REQ_VC_FLIT_OP_CLEANUNIQUE

SVT_CHI_REQ_VC_FLIT_OP_WIDTH'h0B

`define SVT_CHI_REQ_VC_FLIT_OP_DVMOP

SVT_CHI_REQ_VC_FLIT_OP_WIDTH'h14

`define SVT_CHI_REQ_VC_FLIT_OP_ECBARRIER

SVT_CHI_REQ_VC_FLIT_OP_WIDTH'h0F

`define SVT_CHI_REQ_VC_FLIT_OP_EOBARRIER

SVT_CHI_REQ_VC_FLIT_OP_WIDTH'h0E

`define SVT_CHI_REQ_VC_FLIT_OP_EVICT

SVT_CHI_REQ_VC_FLIT_OP_WIDTH'h0D

`define SVT_CHI_REQ_VC_FLIT_OP_MAKEINVALID

SVT_CHI_REQ_VC_FLIT_OP_WIDTH'h0A

`define SVT_CHI_REQ_VC_FLIT_OP_MAKEUNIQUE

SVT_CHI_REQ_VC_FLIT_OP_WIDTH'h0C

`define SVT_CHI_REQ_VC_FLIT_OP_PCRDRETURN

SVT_CHI_REQ_VC_FLIT_OP_WIDTH'h05

`define SVT_CHI_REQ_VC_FLIT_OP_PREFETCHTGT

SVT_CHI_REQ_VC_FLIT_OP_WIDTH'h3A

`define SVT_CHI_REQ_VC_FLIT_OP_READCLEAN

SVT_CHI_REQ_VC_FLIT_OP_WIDTH'h02

`define SVT_CHI_REQ_VC_FLIT_OP_READNOSNP

SVT_CHI_REQ_VC_FLIT_OP_WIDTH'h04

`define SVT_CHI_REQ_VC_FLIT_OP_READNOSNPSEP

SVT_CHI_REQ_VC_FLIT_OP_WIDTH'h11

`define SVT_CHI_REQ_VC_FLIT_OP_READNOTSHAREDDIRTY

SVT_CHI_REQ_VC_FLIT_OP_WIDTH'h26

`define SVT_CHI_REQ_VC_FLIT_OP_READONCE

SVT_CHI_REQ_VC_FLIT_OP_WIDTH'h03

`define SVT_CHI_REQ_VC_FLIT_OP_READONCECLEANINVALID

SVT_CHI_REQ_VC_FLIT_OP_WIDTH'h24

`define SVT_CHI_REQ_VC_FLIT_OP_READONCEMAKEINVALID

SVT_CHI_REQ_VC_FLIT_OP_WIDTH'h25

`define SVT_CHI_REQ_VC_FLIT_OP_READSHARED

SVT_CHI_REQ_VC_FLIT_OP_WIDTH'h01

`define SVT_CHI_REQ_VC_FLIT_OP_READSPEC

SVT_CHI_REQ_VC_FLIT_OP_WIDTH'h06

`define SVT_CHI_REQ_VC_FLIT_OP_READUNIQUE

SVT_CHI_REQ_VC_FLIT_OP_WIDTH'h07

`define SVT_CHI_REQ_VC_FLIT_OP_REQLINKFLIT

SVT_CHI_REQ_VC_FLIT_OP_WIDTH'h0

Width macros of Opcode fields for different FLIT types are defined in svt_chi_port_defines.svi file. Opcodes used for Request VC FLIT, Request message types.

`define SVT_CHI_REQ_VC_FLIT_OP_STASHONCESHARED

SVT_CHI_REQ_VC_FLIT_OP_WIDTH'h22

`define SVT_CHI_REQ_VC_FLIT_OP_STASHONCEUNIQUE

SVT_CHI_REQ_VC_FLIT_OP_WIDTH'h23

`define SVT_CHI_REQ_VC_FLIT_OP_WIDTH

Widths of Opcode fields for different FLIT types -- Defined in svt_chi_port_defines.svi file

`define SVT_CHI_REQ_VC_FLIT_OP_WRITEBACKFULL

SVT_CHI_REQ_VC_FLIT_OP_WIDTH'h1B

`define SVT_CHI_REQ_VC_FLIT_OP_WRITEBACKPTL

SVT_CHI_REQ_VC_FLIT_OP_WIDTH'h1A

`define SVT_CHI_REQ_VC_FLIT_OP_WRITECLEANFULL

SVT_CHI_REQ_VC_FLIT_OP_WIDTH'h17

`define SVT_CHI_REQ_VC_FLIT_OP_WRITECLEANPTL

SVT_CHI_REQ_VC_FLIT_OP_WIDTH'h16

`define SVT_CHI_REQ_VC_FLIT_OP_WRITEEVICTFULL

SVT_CHI_REQ_VC_FLIT_OP_WIDTH'h15

`define SVT_CHI_REQ_VC_FLIT_OP_WRITENOSNPFULL

SVT_CHI_REQ_VC_FLIT_OP_WIDTH'h1D

`define SVT_CHI_REQ_VC_FLIT_OP_WRITENOSNPPTL

SVT_CHI_REQ_VC_FLIT_OP_WIDTH'h1C

`define SVT_CHI_REQ_VC_FLIT_OP_WRITEUNIQUEFULL

SVT_CHI_REQ_VC_FLIT_OP_WIDTH'h19

`define SVT_CHI_REQ_VC_FLIT_OP_WRITEUNIQUEFULLSTASH

SVT_CHI_REQ_VC_FLIT_OP_WIDTH'h20

`define SVT_CHI_REQ_VC_FLIT_OP_WRITEUNIQUEPTL

SVT_CHI_REQ_VC_FLIT_OP_WIDTH'h18

`define SVT_CHI_REQ_VC_FLIT_OP_WRITEUNIQUEPTLSTASH

SVT_CHI_REQ_VC_FLIT_OP_WIDTH'h21

`define SVT_CHI_REQFLITV_FOR_PCREDITGRANT_VALID_REF

`define SVT_CHI_REQFLITV_FOR_RETRYACK_VALID_REF

`define SVT_CHI_REQUEST_ACCEPTED

SVT_CHI_ORDER_WIDTH'b01

`define SVT_CHI_RESET_ALL_XACT

`define SVT_CHI_RESP_ERR_STATUS_DATA_ERROR

SVT_CHI_RESP_ERR_STATUS_WIDTH'b10

`define SVT_CHI_RESP_ERR_STATUS_EXCLUSIVE_OKAY

SVT_CHI_RESP_ERR_STATUS_WIDTH'b01

`define SVT_CHI_RESP_ERR_STATUS_NON_DATA_ERROR

SVT_CHI_RESP_ERR_STATUS_WIDTH'b11

`define SVT_CHI_RESP_ERR_STATUS_NORMAL_OKAY

SVT_CHI_RESP_ERR_STATUS_WIDTH'b00

Defines for response error types, also used by resp_err_type_enum

`define SVT_CHI_RESP_ERR_STATUS_WIDTH

Width of ResErr field

`define SVT_CHI_RESP_WIDTH

Width of Response field

`define SVT_CHI_RETRY_TRANS_AFTER_TWO_NORMAL_TRANSACTIONS_OF_SAME_TXNID_PATTERN_SEQ

8_2_0

`define SVT_CHI_RETRY_TRANS_BETWEEN_TWO_NORMAL_TRANSACTIONS_OF_SAME_TXNID_PATTERN_SEQ

8_1_0

`define SVT_CHI_RETRY_TRANS_W_DIFF_TXNID_AFTER_TWO_NORMAL_TRANSACTIONS_OF_SAME_TXNID_PATTERN_SEQ

8_2_2

`define SVT_CHI_RETRY_TRANS_W_DIFF_TXNID_BETWEEN_TWO_NORMAL_TRANSACTIONS_OF_SAME_TXNID_PATTERN_SEQ

8_1_2

`define SVT_CHI_RETRY_TRANS_W_SAME_TXNID_AFTER_TWO_NORMAL_TRANSACTIONS_OF_SAME_TXNID_PATTERN_SEQ

8_2_1

`define SVT_CHI_RETRY_TRANS_W_SAME_TXNID_BETWEEN_TWO_NORMAL_TRANSACTIONS_OF_SAME_TXNID_PATTERN_SEQ

8_1_1

`define SVT_CHI_RETTOSRC_WIDTH

`define SVT_CHI_RETURN_NID_WIDTH

Width of Return NID field

`define SVT_CHI_RETURN_TXN_ID_WIDTH

Width of Return Transaction ID field

`define SVT_CHI_RN

Node types

`define SVT_CHI_RN_CLK

clk

`define SVT_CHI_RN_IF_HOLD_TIME

0.1

`define SVT_CHI_RN_IF_SETUP_TIME

0.1

`define SVT_CHI_RN_MAX_RXDAT_CHANNELS

Maximum number of RXDAT channels allowed at RN

`define SVT_CHI_RN_MAX_RXRSP_CHANNELS

Maximum number of RXRSP channels allowed at RN

`define SVT_CHI_RN_MAX_RXSNP_CHANNELS

Maximum number of RXSNP channels allowed at RN

`define SVT_CHI_RN_MAX_TXDAT_CHANNELS

Maximum number of TXDAT channels allowed at RN

`define SVT_CHI_RN_MAX_TXREQ_CHANNELS

Maximum number of TXREQ channels allowed at RN

`define SVT_CHI_RN_MAX_TXRSP_CHANNELS

(SVT_CHI_RSP_FLIT_LSB_FWDSTATE_DATAPULL+SVT_CHI_FWD_STATE_WIDTH)

Maximum number of TXRSP channels allowed at RN

`define SVT_CHI_RN_RESETN

resetn

`define SVT_CHI_RN_TRANSACTION_EXCEPTION_LIST_MAX_NUM_EXCEPTIONS

This value is used by the svt_chi_rn_transaction_exception_list constructor to define the initial value for svt_exception_list :: max_num_exceptions. This field is used by the exception list to define the maximum number of exceptions which can be generated for a single transaction. The user testbench can override this constant value to define a different maximum value for use by all svt_chi_rn_transaction_exception_list instances or can change the value of the svt_exception_list :: max_num_exceptions field directly to define a different maximum value for use by that svt_chi_rn_transaction_exception_list instance.

`define SVT_CHI_RSP_FLIT

`define SVT_CHI_RSP_FLIT_LSB_DBID_PGROUPID

`define SVT_CHI_RSP_FLIT_LSB_FWDSTATE_DATAPULL

(SVT_CHI_RSP_FLIT_LSB_RESP+SVT_CHI_RESP_WIDTH)

`define SVT_CHI_RSP_FLIT_LSB_OPCODE

(SVT_CHI_RSP_FLIT_LSB_TXNID+SVT_CHI_TXN_ID_WIDTH)

`define SVT_CHI_RSP_FLIT_LSB_PCRDTYPE

(SVT_CHI_RSP_FLIT_LSB_DBID_PGROUPID+SVT_CHI_DBID_WIDTH)

`define SVT_CHI_RSP_FLIT_LSB_QOS

`define SVT_CHI_RSP_FLIT_LSB_RESP

(SVT_CHI_RSP_FLIT_LSB_RESPERR+SVT_CHI_RESP_ERR_STATUS_WIDTH)

`define SVT_CHI_RSP_FLIT_LSB_RESPERR

(SVT_CHI_RSP_FLIT_LSB_OPCODE+SVT_CHI_RSP_VC_FLIT_OP_WIDTH)

`define SVT_CHI_RSP_FLIT_LSB_SRCID

(SVT_CHI_RSP_FLIT_LSB_TGTID+SVT_CHI_TGT_ID_WIDTH)

`define SVT_CHI_RSP_FLIT_LSB_TGTID

`define SVT_CHI_RSP_FLIT_LSB_TRACETAG

(SVT_CHI_RSP_FLIT_LSB_PCRDTYPE+SVT_CHI_P_CRD_TYPE_WIDTH)

`define SVT_CHI_RSP_FLIT_LSB_TXNID

(SVT_CHI_RSP_FLIT_LSB_SRCID+SVT_CHI_SRC_ID_WIDTH)

`define SVT_CHI_RSP_PACK_UNPACK_WIDTH

(59+SVT_CHI_RSP_USER_EXTN_MAX_WIDTH)

`define SVT_CHI_RSP_USER_EXTN_MAX_WIDTH

`define SVT_CHI_RSP_VC_FLIT_OP_COMP

SVT_CHI_RSP_VC_FLIT_OP_WIDTH'h4

`define SVT_CHI_RSP_VC_FLIT_OP_COMPACK

SVT_CHI_RSP_VC_FLIT_OP_WIDTH'h2

`define SVT_CHI_RSP_VC_FLIT_OP_COMPDBIDRESP

SVT_CHI_RSP_VC_FLIT_OP_WIDTH'h5

`define SVT_CHI_RSP_VC_FLIT_OP_DBIDRESP

SVT_CHI_RSP_VC_FLIT_OP_WIDTH'h6

`define SVT_CHI_RSP_VC_FLIT_OP_PCRDGRANT

SVT_CHI_RSP_VC_FLIT_OP_WIDTH'h7

`define SVT_CHI_RSP_VC_FLIT_OP_READRECEIPT

SVT_CHI_RSP_VC_FLIT_OP_WIDTH'h8

`define SVT_CHI_RSP_VC_FLIT_OP_RESPSEPDATA

SVT_CHI_RSP_VC_FLIT_OP_WIDTH'hB

`define SVT_CHI_RSP_VC_FLIT_OP_RETRYACK

SVT_CHI_RSP_VC_FLIT_OP_WIDTH'h3

`define SVT_CHI_RSP_VC_FLIT_OP_RSPLINKFLIT

SVT_CHI_RSP_VC_FLIT_OP_WIDTH'h0

Opcodes used for Response VC FLIT

`define SVT_CHI_RSP_VC_FLIT_OP_SNPRESP

SVT_CHI_RSP_VC_FLIT_OP_WIDTH'h1

`define SVT_CHI_RSP_VC_FLIT_OP_SNPRESPFWDED

SVT_CHI_RSP_VC_FLIT_OP_WIDTH'h9

`define SVT_CHI_RSP_VC_FLIT_OP_WIDTH

`define SVT_CHI_RSPFLITV_FOR_PCREDITGRANT_TO_RETRYACK_VALID_REF

`define SVT_CHI_RSPFLITV_FOR_RETRYACK_TO_PCREDITGRANT_VALID_REF

`define SVT_CHI_RXLA_ACK_ASSERTION_MAX_DELAY

250

Max delay value for the assertion of RXLINKACTIVEACk

`define SVT_CHI_RXLA_ACK_ASSERTION_MIN_DELAY

Min delay value for the assertion of RXLINKACTIVEACk

`define SVT_CHI_RXLA_ACK_DEASSERTION_MAX_DELAY

250

Max delay value for the deassertion of RXLINKACTIVEACk

`define SVT_CHI_RXLA_ACK_DEASSERTION_MIN_DELAY

Min delay value for the deassertion of RXLINKACTIVEACk

`define SVT_CHI_RXLA_ACTIVATE_STATE

`define SVT_CHI_RXLA_DEACTIVATE_STATE

`define SVT_CHI_RXLA_RUN_STATE

`define SVT_CHI_RXLA_STOP_STATE

Used to indicate the status of the RX LINKACTIVE Interface state machine.

`define SVT_CHI_RXRSPFLITV_VALID_REF

`define SVT_CHI_RXSNPFLITV_VALID_REF

`define SVT_CHI_SCENARIO_GEN_SOURCE

`define SVT_CHI_SIMPLE_RESPONSE_GEN_SOURCE

`define SVT_CHI_SIZE_WIDTH

Width of Size field

`define SVT_CHI_SN

`define SVT_CHI_SN_CLK

clk

`define SVT_CHI_SN_IF_HOLD_TIME

0.1

`define SVT_CHI_SN_IF_SETUP_TIME

0.1

`define SVT_CHI_SN_MAX_RXDAT_CHANNELS

Maximum number of RXDAT channels allowed at SN

`define SVT_CHI_SN_MAX_RXREQ_CHANNELS

Maximum number of RXREQ channels allowed at SN

`define SVT_CHI_SN_MAX_TXDAT_CHANNELS

Maximum number of TXDAT channels allowed at SN

`define SVT_CHI_SN_MAX_TXRSP_CHANNELS

(SVT_CHI_SNP_FLIT_LSB_OPCODE+SVT_CHI_SNP_VC_FLIT_OP_WIDTH)

Maximum number of TXRSP channels allowed at SN

`define SVT_CHI_SN_RESETN

resetn

`define SVT_CHI_SN_TRANSACTION_EXCEPTION_LIST_MAX_NUM_EXCEPTIONS

This value is used by the svt_chi_sn_transaction_exception_list constructor to define the initial value for svt_exception_list :: max_num_exceptions. This field is used by the exception list to define the maximum number of exceptions which can be generated for a single transaction. The user testbench can override this constant value to define a different maximum value for use by all svt_chi_sn_transaction_exception_list instances or can change the value of the svt_exception_list :: max_num_exceptions field directly to define a different maximum value for use by that svt_chi_sn_transaction_exception_list instance.

`define SVT_CHI_SNOOP_INIT_STATE_ISUNIQUE ( xact )

xact.current_state == svt_chi_snoop_transaction::UC ||
    xact.current_state == svt_chi_snoop_transaction::UD ||
    xact.current_state == svt_chi_snoop_transaction::UDP ||
    xact.current_state == svt_chi_snoop_transaction::UCE

`define SVT_CHI_SNOOP_PRINT_PREFIX ( xact )

SVT_CHI_SNP_PRINT_PREFIX(xact)

`define SVT_CHI_SNOOP_RESP_ISSHARED ( xact )

xact.final_state == svt_chi_snoop_transaction::SC ||
xact.final_state == svt_chi_snoop_transaction::SD

`define SVT_CHI_SNOOP_RESP_ISUNIQUE ( xact )

xact.final_state == svt_chi_snoop_transaction::UC ||
xact.final_state == svt_chi_snoop_transaction::UD

`define SVT_CHI_SNOOP_TRANSACTION_EXCEPTION_LIST_MAX_NUM_EXCEPTIONS

This value is used by the svt_chi_snoop_transaction_exception_list constructor to define the initial value for svt_exception_list :: max_num_exceptions. This field is used by the exception list to define the maximum number of exceptions which can be generated for a single transaction. The user testbench can override this constant value to define a different maximum value for use by all svt_chi_snoop_transaction_exception_list instances or can change the value of the svt_exception_list :: max_num_exceptions field directly to define a different maximum value for use by that svt_chi_snoop_transaction_exception_list instance.

`define SVT_CHI_SNOOPABLE_WRITEBACK_NO_ALLOCATE_LIKELYSHARED_NO_ORDER_RD_FOLLOWED_BY_RD_W_SAME_CACHELINE_ADDR_PATTERN_SEQ

3_5_3

`define SVT_CHI_SNOOPABLE_WRITEBACK_NO_ALLOCATE_LIKELYSHARED_NO_ORDER_RD_FOLLOWED_BY_WR_W_SAME_CACHELINE_ADDR_PATTERN_SEQ

4_5_3

`define SVT_CHI_SNOOPABLE_WRITEBACK_NO_ALLOCATE_LIKELYSHARED_NO_ORDER_WR_FOLLOWED_BY_RD_W_SAME_CACHELINE_ADDR_PATTERN_SEQ

1_5_3

`define SVT_CHI_SNOOPABLE_WRITEBACK_NO_ALLOCATE_LIKELYSHARED_NO_ORDER_WR_FOLLOWED_BY_WR_W_SAME_CACHELINE_ADDR_PATTERN_SEQ

2_6_3

`define SVT_CHI_SNOOPABLE_WRITEBACK_NO_ALLOCATE_LIKELYSHARED_ORDER_RD_FOLLOWED_BY_WR_W_SAME_CACHELINE_ADDR_PATTERN_SEQ

4_5_4

`define SVT_CHI_SNOOPABLE_WRITEBACK_NO_ALLOCATE_LIKELYSHARED_ORDER_WR_FOLLOWED_BY_RD_W_SAME_CACHELINE_ADDR_PATTERN_SEQ

1_5_4

`define SVT_CHI_SNOOPABLE_WRITEBACK_NO_ALLOCATE_LIKELYSHARED_ORDER_WR_FOLLOWED_BY_WR_W_SAME_CACHELINE_ADDR_PATTERN_SEQ

2_6_4

`define SVT_CHI_SNOOPABLE_WRITEBACK_NO_ALLOCATE_NO_LIKELYSHARED_NO_ORDER_RD_FOLLOWED_BY_RD_W_SAME_CACHELINE_ADDR_PATTERN_SEQ

3_5_1

`define SVT_CHI_SNOOPABLE_WRITEBACK_NO_ALLOCATE_NO_LIKELYSHARED_NO_ORDER_RD_FOLLOWED_BY_WR_W_SAME_CACHELINE_ADDR_PATTERN_SEQ

4_5_1

`define SVT_CHI_SNOOPABLE_WRITEBACK_NO_ALLOCATE_NO_LIKELYSHARED_NO_ORDER_WR_FOLLOWED_BY_RD_W_SAME_CACHELINE_ADDR_PATTERN_SEQ

1_5_1

`define SVT_CHI_SNOOPABLE_WRITEBACK_NO_ALLOCATE_NO_LIKELYSHARED_NO_ORDER_WR_FOLLOWED_BY_WR_W_SAME_CACHELINE_ADDR_PATTERN_SEQ

2_6_1

`define SVT_CHI_SNOOPABLE_WRITEBACK_NO_ALLOCATE_NO_LIKELYSHARED_ORDER_RD_FOLLOWED_BY_RD_W_SAME_CACHELINE_ADDR_PATTERN_SEQ

3_5_2

`define SVT_CHI_SNOOPABLE_WRITEBACK_NO_ALLOCATE_NO_LIKELYSHARED_ORDER_RD_FOLLOWED_BY_WR_W_SAME_CACHELINE_ADDR_PATTERN_SEQ

4_5_2

`define SVT_CHI_SNOOPABLE_WRITEBACK_NO_ALLOCATE_NO_LIKELYSHARED_ORDER_WR_FOLLOWED_BY_RD_W_SAME_CACHELINE_ADDR_PATTERN_SEQ

1_5_2

`define SVT_CHI_SNOOPABLE_WRITEBACK_NO_ALLOCATE_NO_LIKELYSHARED_ORDER_WR_FOLLOWED_BY_WR_W_SAME_CACHELINE_ADDR_PATTERN_SEQ

2_6_2

`define SVT_CHI_SNOOPABLE_WRITEBACK_NO_ALLOCATE_RD_FOLLOWED_BY_RD_W_SAME_CACHELINE_ADDR_PATTERN_SEQ

3_5

`define SVT_CHI_SNOOPABLE_WRITEBACK_NO_ALLOCATE_RD_FOLLOWED_BY_WR_W_SAME_CACHELINE_ADDR_PATTERN_SEQ

4_5

`define SVT_CHI_SNOOPABLE_WRITEBACK_NO_ALLOCATE_WR_FOLLOWED_BY_RD_W_SAME_CACHELINE_ADDR_PATTERN_SEQ

1_5

`define SVT_CHI_SNOOPABLE_WRITEBACK_NO_ALLOCATE_WR_FOLLOWED_BY_WR_W_SAME_CACHELINE_ADDR_PATTERN_SEQ

2_6

`define SVT_CHI_SNP_ADDR_WIDTH

((SVT_CHI_REQ_ADDR_WIDTH)-3)

Width of Addr field of a Snoop Message Request

`define SVT_CHI_SNP_ATTR_WIDTH

Width of Snp Attr field

`define SVT_CHI_SNP_DOMAIN_INNER

Defines for Snoop domain, also used by snoop_domain_type_enum

`define SVT_CHI_SNP_DOMAIN_OUTER

`define SVT_CHI_SNP_ERR_EXCL_SEQ_FAIL

SVT_CHI_ERROR_CTRL_REG_WIDTH'h1

`define SVT_CHI_SNP_FLIT

`define SVT_CHI_SNP_FLIT_LSB_ADDR

`define SVT_CHI_SNP_FLIT_LSB_DONOTGOTOSD

(SVT_CHI_SNP_FLIT_LSB_NS+SVT_CHI_NS_WIDTH)

`define SVT_CHI_SNP_FLIT_LSB_FWDNID_PBHA

(SVT_CHI_SNP_FLIT_LSB_TXNID+SVT_CHI_TXN_ID_WIDTH)

`define SVT_CHI_SNP_FLIT_LSB_FWDTXNID

(SVT_CHI_SNP_FLIT_LSB_FWDNID_PBHA+SVT_CHI_FORWARD_NID_PBHA_WIDTH)

`define SVT_CHI_SNP_FLIT_LSB_NS

(SVT_CHI_SNP_FLIT_LSB_ADDR+SVT_CHI_SNP_ADDR_WIDTH)

`define SVT_CHI_SNP_FLIT_LSB_OPCODE

(SVT_CHI_SNP_FLIT_LSB_FWDTXNID+SVT_CHI_FORWARD_TXN_ID_WIDTH)

`define SVT_CHI_SNP_FLIT_LSB_QOS

`define SVT_CHI_SNP_FLIT_LSB_RETTOSRC

(SVT_CHI_SNP_FLIT_LSB_DONOTGOTOSD+SVT_CHI_DONOTGOTOSD_WIDTH)

`define SVT_CHI_SNP_FLIT_LSB_SRCID

(SVT_CHI_SNP_FLIT_LSB_FWDNID_PBHA+SVT_CHI_FORWARD_NID_PBHA_WIDTH+SVT_CHI_STASH_LPID_WIDTH)

`define SVT_CHI_SNP_FLIT_LSB_STASHLPID_VALID

`define SVT_CHI_SNP_FLIT_LSB_TRACETAG

(SVT_CHI_SNP_FLIT_LSB_RETTOSRC+SVT_CHI_RETTOSRC_WIDTH)

`define SVT_CHI_SNP_FLIT_LSB_TXNID

(SVT_CHI_SNP_FLIT_LSB_SRCID+SVT_CHI_SRC_ID_WIDTH)

`define SVT_CHI_SNP_PACK_UNPACK_WIDTH

(100+SVT_CHI_SNP_USER_EXTN_MAX_WIDTH)

`define SVT_CHI_SNP_PRINT_PREFIX ( xact )

$sformatf("{%0s%0sSYS_ID('d%0d) OBJ_NUM('d%0d) NODE_ID('d%0d) %0sTYPE(%0s)%0s TXN_ID('h%0h) QOS('h%0h)%0s ADDR('h%0x)%0s%0s %0sNS(%0b)POISON('h%0h) DATACHECK(%0h)%0s%0s%0s%0s%0s%0s%0s%0s%0s%0s%0s%0s%0s} ",
          (((xact != null) && (xact.object_context != ""))?$sformatf("%0s: ", xact.object_context):""),
          (((xact != null) && (xact.object_info != ""))?$sformatf("OBJ_INFO(%0s) ", xact.object_info):""),
          ((xact != null && xact.cfg!= null && xact.cfg.sys_cfg != null)?xact.cfg.sys_cfg.system_id:-1),
          ((xact != null)?xact.object_num:-1),
          ((xact != null && xact.cfg!= null)?xact.cfg.node_id:-1),
          ((xact != null)?xact.source_target_info:""),
          ((xact != null)?xact.snp_req_msg_type.name:"null"),
          ((xact != null)?((xact.snp_req_msg_type==svt_chi_snoop_transaction::SNPDVMOP)?(xact.is_dvm_msg_type_sync()?" DVM_TYPE(SYNC)":" DVM_TYPE(NON-SYNC)"):""):""),
          ((xact != null)?xact.txn_id:0),
          ((xact != null)?xact.qos:0),
          `ifdef SVT_CHI_ISSUE_F_ENABLE
          ((xact != null)?((xact.cfg != null && xact.cfg.cah_support == svt_chi_node_configuration::CHI_CAH_SUPPORT_TRUE)?($sformatf(" CAH('b%0b)", xact.cah)):""):""),
          `else
          "",
          `endif
          ((xact != null)?xact.addr:0),
          `ifdef SVT_CHI_ISSUE_F_ENABLE
          ((xact != null)?((xact.cfg != null && xact.cfg.pbha_support == svt_chi_node_configuration::CHI_PBHA_SUPPORT_TRUE)?($sformatf(" PBHA('h%0h)", xact.pbha)):""):""),
          `else
          "",
          `endif
          `ifdef SVT_CHI_ISSUE_G_ENABLE
          ((xact != null)?((xact.cfg != null && xact.cfg.mec_support == svt_chi_node_configuration::CHI_MEC_TRUE)?($sformatf(" MECID('h%0h)", xact.mecid)):""):""),
          `else
          "",
          `endif
          `ifdef SVT_CHI_ISSUE_F_ENABLE
          ((xact != null)?$sformatf("NSE(%0b) ", xact.non_secure_ext):""),
          `else
          "",
          `endif
          ((xact != null)?xact.is_non_secure_access:0),
          ((xact != null)?xact.poison:0),
          ((xact != null)?xact.datacheck:0),
          ((xact != null && xact.cfg!= null)?((xact.cfg.chi_spec_revision>=svt_chi_node_configuration::ISSUE_B)?($sformatf(" DONOTGOTOSD('b%0b) RET_TO_SRC('b%0b)",xact.do_not_go_to_sd, xact.ret_to_src)):""):""),
          ((xact != null && xact.cfg!= null)?((xact.cfg.chi_spec_revision>=svt_chi_node_configuration::ISSUE_B && xact.is_forward_type_snoop())?($sformatf(" FWD_NID('h%0h) FWD_TXN_ID('d%0h)",xact.fwd_nid, xact.fwd_txn_id)):""):""),
          ((xact != null && xact.cfg!= null)?((xact.cfg.chi_spec_revision>=svt_chi_node_configuration::ISSUE_B && xact.is_cache_stash_snoop())?($sformatf(" DO_NOT_DATA_PULL('b%0b) DATA_PULL('b%0b) STASH_LPID_VALID(%0b) STASH_LPID('h%0h)",xact.do_not_data_pull, xact.data_pull, xact.stash_lpid_valid, xact.stash_lpid)):""):""),
          ((xact != null && xact.cfg!= null)?((xact.cfg.chi_spec_revision>=svt_chi_node_configuration::ISSUE_B && xact.is_cache_stash_snoop() && (xact.data_pull == 1 && (xact.get_end_time()!=-1)))?($sformatf(" DATA_PULL_TXN_ID('h%0h) DATA_PULL_DBID('h%0h) DATA_PULL_FINAL_STATE(%0s)",xact.data_pull_txn_id, xact.data_pull_dbid, xact.data_pull_resp_final_state.name())):""):""),
          ((xact != null && xact.cfg!= null)?((xact.cfg.chi_spec_revision>=svt_chi_node_configuration::ISSUE_B && xact.get_end_time()!=-1)?($sformatf(" DATASOURCE('h%0h)",xact.data_source)):""):""),
          `ifdef SVT_CHI_ISSUE_E_ENABLE
          ((xact != null)?((xact.cfg.dvm_version_support >= svt_chi_node_configuration::DVM_v8_4 && xact.snp_req_msg_type==svt_chi_transaction::SNPDVMOP && xact.snp_dvm_op_p1_payload[13:11] == 3'b000)?($sformatf(" IS_TLBI_INVALIDATE_BY_VA_OR_IPA(%0b)", xact.snp_dvm_op_p1_payload[4])):""):""),
          `else
            "",
          `endif
          `ifdef SVT_CHI_ISSUE_E_ENABLE
          ((xact != null)?((xact.cfg.dvm_version_support >= svt_chi_node_configuration::DVM_v8_4 && xact.snp_req_msg_type==svt_chi_snoop_transaction::SNPDVMOP && xact.snp_dvm_op_p1_payload[13:11] == 3'b000 && xact.snp_dvm_op_p1_payload[4] == 1)?($sformatf(" IS_RANGE_BASED_TLBI(%0b)", xact.dvm_range)):""):""),
          ((xact != null && xact.data_status != svt_chi_snoop_transaction::INITIAL)?($sformatf(" DATA_TAGOP$%0s$", xact.data_tag_op)):""),
          ((xact != null && xact.is_forward_type_snoop() && xact.fwded_read_data_status != svt_chi_snoop_transaction::INITIAL)?($sformatf(" FWDED_TAGOP$%0s$", xact.fwded_tag_op)):""),
          `else
            "",
            "",
            "",
          `endif
          `ifdef SVT_CHI_ISSUE_D_ENABLE
            (((xact!=null) && (xact.cfg!=null) && (xact.cfg.enable_mpam) && xact.is_cache_stash_snoop())? $sformatf(" MPAM_PERFMONGROUP('h%0h) MPAM_PARTID('h%0h) MPAM_NS('h%0h)", xact.mpam_perfmongroup, xact.mpam_partid, xact.mpam_ns): ""),
          `else
            "",
          `endif
          ((xact != null)?((xact.get_begin_time()==-1)?"":($sformatf(" START_TIME(%0t)",xact.get_begin_realtime()))):""),
          ((xact != null)?((xact.get_end_time()==-1)?"":($sformatf(" END_TIME(%0t)",xact.get_end_realtime()))):""),
          (((xact != null) && (xact.cfg != null) && (xact.cfg.is_user_extension_enabled(svt_chi_node_configuration::USER_EXTN_SNP_USER)))?$sformatf(" USER_EXTN_SNP_USER('h%0h)",xact.user_extn_snp_user):""))

`define SVT_CHI_SNP_REQ_MSG_TYPE_SNPCLEAN

SVT_CHI_SNP_VC_FLIT_OP_SNPCLEAN

`define SVT_CHI_SNP_REQ_MSG_TYPE_SNPCLEANFWD

SVT_CHI_SNP_VC_FLIT_OP_SNPCLEANFWD

`define SVT_CHI_SNP_REQ_MSG_TYPE_SNPCLEANINVALID

SVT_CHI_SNP_VC_FLIT_OP_SNPCLEANINVALID

`define SVT_CHI_SNP_REQ_MSG_TYPE_SNPCLEANSHARED

SVT_CHI_SNP_VC_FLIT_OP_SNPCLEANSHARED

`define SVT_CHI_SNP_REQ_MSG_TYPE_SNPDVMOP

SVT_CHI_SNP_VC_FLIT_OP_SNPDVMOP

`define SVT_CHI_SNP_REQ_MSG_TYPE_SNPLINKFLIT

SVT_CHI_SNP_VC_FLIT_OP_SNPLINKFLIT

AMBA CHI SNOOP REQ_MSG TYPE: Used to define type for snoop request messages: Aliased to Snoop VC FLIT Opcodes

`define SVT_CHI_SNP_REQ_MSG_TYPE_SNPMAKEINVALID

SVT_CHI_SNP_VC_FLIT_OP_SNPMAKEINVALID

`define SVT_CHI_SNP_REQ_MSG_TYPE_SNPMAKEINVALIDSTASH

SVT_CHI_SNP_VC_FLIT_OP_SNPMAKEINVALIDSTASH

`define SVT_CHI_SNP_REQ_MSG_TYPE_SNPNOTSHAREDDIRTY

SVT_CHI_SNP_VC_FLIT_OP_SNPNOTSHAREDDIRTY

`define SVT_CHI_SNP_REQ_MSG_TYPE_SNPNOTSHAREDDIRTYFWD

SVT_CHI_SNP_VC_FLIT_OP_SNPNOTSHAREDDIRTYFWD

`define SVT_CHI_SNP_REQ_MSG_TYPE_SNPONCE

SVT_CHI_SNP_VC_FLIT_OP_SNPONCE

`define SVT_CHI_SNP_REQ_MSG_TYPE_SNPONCEFWD

SVT_CHI_SNP_VC_FLIT_OP_SNPONCEFWD

`define SVT_CHI_SNP_REQ_MSG_TYPE_SNPSHARED

SVT_CHI_SNP_VC_FLIT_OP_SNPSHARED

`define SVT_CHI_SNP_REQ_MSG_TYPE_SNPSHAREDFWD

SVT_CHI_SNP_VC_FLIT_OP_SNPSHAREDFWD

`define SVT_CHI_SNP_REQ_MSG_TYPE_SNPSTASHSHARED

SVT_CHI_SNP_VC_FLIT_OP_SNPSTASHSHARED

`define SVT_CHI_SNP_REQ_MSG_TYPE_SNPSTASHUNIQUE

SVT_CHI_SNP_VC_FLIT_OP_SNPSTASHUNIQUE

`define SVT_CHI_SNP_REQ_MSG_TYPE_SNPUNIQUE

SVT_CHI_SNP_VC_FLIT_OP_SNPUNIQUE

`define SVT_CHI_SNP_REQ_MSG_TYPE_SNPUNIQUEFWD

SVT_CHI_SNP_VC_FLIT_OP_SNPUNIQUEFWD

`define SVT_CHI_SNP_REQ_MSG_TYPE_SNPUNIQUESTASH

SVT_CHI_SNP_VC_FLIT_OP_SNPUNIQUESTASH

`define SVT_CHI_SNP_RESERVED_STASHLPID_WIDTH

(SVT_CHI_FORWARD_TXN_ID_WIDTH-(SVT_CHI_STASH_LPID_WIDTH+SVT_CHI_STASHLPIDVALID_WIDTH))

Width of Reserved bits in STASHLPID fields of SNP flit-- applicable for CHI Issue B or later

`define SVT_CHI_SNP_USER_EXTN_MAX_WIDTH

(`SVT_CHI_USER_EXTN_MAX_SNP_USER_WIDTH*SVT_CHI_USER_EXTN_SNP_USER_WIDTH_INTERNAL_ENABLE)

`define SVT_CHI_SNP_VC_FLIT_OP_SNPCLEAN

SVT_CHI_SNP_VC_FLIT_OP_WIDTH'h2

`define SVT_CHI_SNP_VC_FLIT_OP_SNPCLEANFWD

SVT_CHI_SNP_VC_FLIT_OP_WIDTH'h12

`define SVT_CHI_SNP_VC_FLIT_OP_SNPCLEANINVALID

SVT_CHI_SNP_VC_FLIT_OP_WIDTH'h9

`define SVT_CHI_SNP_VC_FLIT_OP_SNPCLEANSHARED

SVT_CHI_SNP_VC_FLIT_OP_WIDTH'h8

`define SVT_CHI_SNP_VC_FLIT_OP_SNPDVMOP

SVT_CHI_SNP_VC_FLIT_OP_WIDTH'hD

`define SVT_CHI_SNP_VC_FLIT_OP_SNPLINKFLIT

SVT_CHI_SNP_VC_FLIT_OP_WIDTH'h0

Opcodes used for Snoop VC FLIT, Snoop Request message types

`define SVT_CHI_SNP_VC_FLIT_OP_SNPMAKEINVALID

SVT_CHI_SNP_VC_FLIT_OP_WIDTH'hA

`define SVT_CHI_SNP_VC_FLIT_OP_SNPMAKEINVALIDSTASH

SVT_CHI_SNP_VC_FLIT_OP_WIDTH'h6

`define SVT_CHI_SNP_VC_FLIT_OP_SNPNOTSHAREDDIRTY

SVT_CHI_SNP_VC_FLIT_OP_WIDTH'h4

`define SVT_CHI_SNP_VC_FLIT_OP_SNPNOTSHAREDDIRTYFWD

SVT_CHI_SNP_VC_FLIT_OP_WIDTH'h14

`define SVT_CHI_SNP_VC_FLIT_OP_SNPONCE

SVT_CHI_SNP_VC_FLIT_OP_WIDTH'h3

`define SVT_CHI_SNP_VC_FLIT_OP_SNPONCEFWD

SVT_CHI_SNP_VC_FLIT_OP_WIDTH'h13

`define SVT_CHI_SNP_VC_FLIT_OP_SNPSHARED

SVT_CHI_SNP_VC_FLIT_OP_WIDTH'h1

`define SVT_CHI_SNP_VC_FLIT_OP_SNPSHAREDFWD

SVT_CHI_SNP_VC_FLIT_OP_WIDTH'h11

`define SVT_CHI_SNP_VC_FLIT_OP_SNPSTASHSHARED

SVT_CHI_SNP_VC_FLIT_OP_WIDTH'hC

`define SVT_CHI_SNP_VC_FLIT_OP_SNPSTASHUNIQUE

SVT_CHI_SNP_VC_FLIT_OP_WIDTH'hB

`define SVT_CHI_SNP_VC_FLIT_OP_SNPUNIQUE

SVT_CHI_SNP_VC_FLIT_OP_WIDTH'h7

`define SVT_CHI_SNP_VC_FLIT_OP_SNPUNIQUEFWD

SVT_CHI_SNP_VC_FLIT_OP_WIDTH'h17

`define SVT_CHI_SNP_VC_FLIT_OP_SNPUNIQUESTASH

SVT_CHI_SNP_VC_FLIT_OP_WIDTH'h5

`define SVT_CHI_SNP_VC_FLIT_OP_WIDTH

`define SVT_CHI_SNPRESP2SNPRESP_DELAY_COV_MAX_VALUE

Macro to control the max value of clk delay for SNPRESP to SNPRESP assertion related link cg

`define SVT_CHI_SNPRESP2SNPRESP_DELAY_COV_MID_BIN_VAL_RANGE

Macro to control the number of bins for SNPRESP to SNPRESP assertion related link cg

`define SVT_CHI_SNPRESP2SNPRESP_DELAY_COV_MIN_VALUE

Macro to control the min value of clk delay for SNPRESP to SNPRESP assertion related link cg

`define SVT_CHI_SPEC_PERMITTED_MAX_DBID_VALUE_FOR_ISSUE_D

1023

Spec permitted maximum DBID value for ISSUE_D

`define SVT_CHI_SPEC_PERMITTED_MAX_DBID_VALUE_FOR_ISSUE_E

4095

Spec permitted maximum DBID value for ISSUE_E

`define SVT_CHI_SPEC_PERMITTED_MAX_DBID_VALUE_UPTO_ISSUE_C

255

Spec permitted maximum DBID value upto ISSUE_C

`define SVT_CHI_SPEC_PERMITTED_MAX_NUM_OUTSTANDING_SNP_XACT_FOR_ISSUE_D

1024

Spec permitted maximum number of outstanding snoop transactions for ISSUE_D

`define SVT_CHI_SPEC_PERMITTED_MAX_NUM_OUTSTANDING_SNP_XACT_UPTO_ISSUE_C

256

Spec permitted maximum number of outstanding snoop transactions upto ISSUE_C

`define SVT_CHI_SPEC_PERMITTED_MAX_NUM_OUTSTANDING_XACT_FOR_ISSUE_D

1024

Spec permitted maximum number of outstanding transactions for ISSUE_D

`define SVT_CHI_SPEC_PERMITTED_MAX_NUM_OUTSTANDING_XACT_UPTO_ISSUE_C

256

Spec permitted maximum number of outstanding transactions upto ISSUE_C

`define SVT_CHI_SPEC_PERMITTED_MAX_TXNID_VALUE_FOR_ISSUE_D

1023

Spec permitted maximum TxnID value for ISSUE_D

`define SVT_CHI_SPEC_PERMITTED_MAX_TXNID_VALUE_FOR_ISSUE_E

4095

Spec permitted maximum TxnID value for ISSUE_E

`define SVT_CHI_SPEC_PERMITTED_MAX_TXNID_VALUE_UPTO_ISSUE_C

255

Spec permitted maximum TxnID value upto ISSUE_C

`define SVT_CHI_SPEC_REV_ISSUE_A

Spec revisions

`define SVT_CHI_SPEC_REV_ISSUE_B

`define SVT_CHI_SPEC_REV_ISSUE_C

`define SVT_CHI_SPEC_REV_ISSUE_D

`define SVT_CHI_SPEC_REV_ISSUE_E

`define SVT_CHI_SPEC_REV_ISSUE_F

`define SVT_CHI_SPEC_REV_ISSUE_G

`define SVT_CHI_SRC_ID_WIDTH

Width of Source ID field

`define SVT_CHI_STANDARD_DATA_FORMAT

Data formats

`define SVT_CHI_STASH_LPID_WIDTH

Width of Stash related fields

`define SVT_CHI_STASH_NID_WIDTH

Width of Stash NID field

`define SVT_CHI_STASHLPIDVALID_WIDTH

`define SVT_CHI_STASHNIDVALID_WIDTH

`define SVT_CHI_STREAMING_ORDERED_WRITENOSNP_TRANSACTIONS

2_7_1

`define SVT_CHI_STREAMING_ORDERED_WRITEUNIQUE_TRANSACTIONS

2_7_0

`define SVT_CHI_SUPER_MAX_DAT_FLIT_WIDTH

(750+SVT_CHI_DAT_USER_EXTN_MAX_WIDTH)

`define SVT_CHI_SYS_CFG_ABF_ENABLE

Define for controlling the default value of svt_chi_system_configuration :: abf_enable

`define SVT_CHI_SYS_COV_NUM_BYTE_ENABLE_BINS

Used to define the number of bins for byte_enable values in system level covergroup trans_cross_chi_writeuniqueptl_byte_enable_snoop_filter_access.

`define SVT_CHI_SYSCOACK_ASSERTION_MAX_DELAY

100

Max delay value of SYSCOACK signal to get asserted

`define SVT_CHI_SYSCOACK_DEASSERTION_MAX_DELAY

100

Max delay value of SYSCOACK signal to get deasserted

`define SVT_CHI_SYSCOREQ_ASSERTION_MAX_DELAY

100

Max delay value of SYSCOREQ signal to get asserted

`define SVT_CHI_SYSCOREQ_DEASSERTION_MAX_DELAY

100

Max delay value of SYSCOREQ signal to get deasserted

`define SVT_CHI_SYSTEM_MONITOR_DEF_COV_UTIL_ASSOCIATED_NONSTASH_SNOOP_XACT_TYPE ( weight_val )

associated_nonstash_snoop_xact_type : coverpoint sys_xact.associated_nonstash_snoop_xact_type {
   bins no_snoop_xact_present = {svt_chi_snoop_transaction::SNPSHARED};
   bins snpunique = {svt_chi_snoop_transaction::SNPUNIQUE};
   bins snpmakeinvalid = {svt_chi_snoop_transaction::SNPMAKEINVALID};
   option.weight = weight_val;
   type_option.weight = weight_val;
}

associated_nonstash_snoop_xact_type : Captures associated non-stash type snoop transaction types

`define SVT_CHI_SYSTEM_MONITOR_DEF_COV_UTIL_COHERENT_ATOMIC_XACT_DETAILED_BINS

bins atomicstore_add_xact = {svt_chi_transaction::ATOMICSTORE_ADD};
      bins atomicstore_clr_xact = {svt_chi_transaction::ATOMICSTORE_CLR};
      bins atomicstore_eor_xact = {svt_chi_transaction::ATOMICSTORE_EOR};
      bins atomicstore_set_xact = {svt_chi_transaction::ATOMICSTORE_SET};
      bins atomicstore_smax_xact = {svt_chi_transaction::ATOMICSTORE_SMAX};
      bins atomicstore_smin_xact = {svt_chi_transaction::ATOMICSTORE_SMIN};
      bins atomicstore_umax_xact = {svt_chi_transaction::ATOMICSTORE_UMAX};
      bins atomicstore_umin_xact = {svt_chi_transaction::ATOMICSTORE_UMIN};
      bins atomicload_add_xact = {svt_chi_transaction::ATOMICLOAD_ADD};
      bins atomicload_clr_xact = {svt_chi_transaction::ATOMICLOAD_CLR};
      bins atomicload_eor_xact = {svt_chi_transaction::ATOMICLOAD_EOR};
      bins atomicload_set_xact = {svt_chi_transaction::ATOMICLOAD_SET};
      bins atomicload_smax_xact = {svt_chi_transaction::ATOMICLOAD_SMAX};
      bins atomicload_smin_xact = {svt_chi_transaction::ATOMICLOAD_SMIN};
      bins atomicload_umax_xact = {svt_chi_transaction::ATOMICLOAD_UMAX};
      bins atomicload_umin_xact = {svt_chi_transaction::ATOMICLOAD_UMIN};
      bins atomicswap_xact = {svt_chi_transaction::ATOMICSWAP};
      bins atomiccompare_xact = {svt_chi_transaction::ATOMICCOMPARE};

Bins for coherent atomic xact type on RN-F/RN-I/RN-D ports

`define SVT_CHI_SYSTEM_MONITOR_DEF_COV_UTIL_COHERENT_ATOMIC_XACT_ON_RN_F_PORT1 ( weight_val )

coherent_atomic_xact_on_rn_f_port1: coverpoint coherent_atomic_xact_on_rn_f_port1 {
      SVT_CHI_SYSTEM_MONITOR_DEF_COV_UTIL_COHERENT_ATOMIC_XACT_DETAILED_BINS
      option.weight = weight_val;
      type_option.weight = weight_val;
    }

coherent_atomic_xact_on_rn_f_port1 : Captures opcodes for coherent atomic transaction type from RN-F port1

`define SVT_CHI_SYSTEM_MONITOR_DEF_COV_UTIL_COHERENT_ATOMIC_XACT_ON_RN_F_PORT2 ( weight_val )

coherent_atomic_xact_on_rn_f_port2: coverpoint coherent_atomic_xact_on_rn_f_port2 {
      SVT_CHI_SYSTEM_MONITOR_DEF_COV_UTIL_COHERENT_ATOMIC_XACT_DETAILED_BINS
      option.weight = weight_val;
      type_option.weight = weight_val;
    }

coherent_atomic_xact_on_rn_f_port2 : Captures opcodes for coherent atomic transaction type from RN-F port2

`define SVT_CHI_SYSTEM_MONITOR_DEF_COV_UTIL_COHERENT_ATOMIC_XACT_ON_RN_F_PORTS ( weight_val )

coherent_atomic_xact_on_rn_f_ports: coverpoint coherent_atomic_xact_on_rn_f_ports {
      SVT_CHI_SYSTEM_MONITOR_DEF_COV_UTIL_COHERENT_ATOMIC_XACT_DETAILED_BINS
      option.weight = weight_val;
      type_option.weight = weight_val;
    }

coherent_atomic_xact_on_rn_f_ports : Captures opcodes for coherent atomic transaction type from RN-F ports

`define SVT_CHI_SYSTEM_MONITOR_DEF_COV_UTIL_COHERENT_ATOMIC_XACT_ON_RN_I_PORTS ( weight_val )

coherent_atomic_xact_on_rn_i_ports: coverpoint coherent_atomic_xact_on_rn_i_ports {
      SVT_CHI_SYSTEM_MONITOR_DEF_COV_UTIL_COHERENT_ATOMIC_XACT_DETAILED_BINS
      option.weight = weight_val;
      type_option.weight = weight_val;
    }

coherent_atomic_xact_on_rn_i_ports : Captures opcodes for coherent atomic transaction type from RN-I ports

`define SVT_CHI_SYSTEM_MONITOR_DEF_COV_UTIL_COHERENT_NON_ATOMIC_XACT_ON_RN_F_PORT1 ( weight_val )

coherent_non_atomic_xact_on_rn_f_port1: coverpoint coherent_non_atomic_xact_on_rn_f_port1 {
      SVT_CHI_SYSTEM_MONITOR_DEF_COV_UTIL_COHERENT_NON_ATOMIC_XACT_ON_RN_F_PORTS_DETAILED_BINS
      option.weight = weight_val;
      type_option.weight = weight_val;
    }

coherent_non_atomic_xact_on_rn_f_port1 : Captures opcodes for coherent non-atomic transaction type from RN-F port1

`define SVT_CHI_SYSTEM_MONITOR_DEF_COV_UTIL_COHERENT_NON_ATOMIC_XACT_ON_RN_F_PORT2 ( weight_val )

coherent_non_atomic_xact_on_rn_f_port2: coverpoint coherent_non_atomic_xact_on_rn_f_port2 {
      SVT_CHI_SYSTEM_MONITOR_DEF_COV_UTIL_COHERENT_NON_ATOMIC_XACT_ON_RN_F_PORTS_DETAILED_BINS
      option.weight = weight_val;
      type_option.weight = weight_val;
    }

coherent_non_atomic_xact_on_rn_f_port2 : Captures opcodes for coherent non-atomic transaction type from RN-F port2

`define SVT_CHI_SYSTEM_MONITOR_DEF_COV_UTIL_COHERENT_NON_ATOMIC_XACT_ON_RN_F_PORTS ( weight_val )

coherent_non_atomic_xact_on_rn_f_ports: coverpoint coherent_non_atomic_xact_on_rn_f_ports {
      SVT_CHI_SYSTEM_MONITOR_DEF_COV_UTIL_COHERENT_NON_ATOMIC_XACT_ON_RN_F_PORTS_DETAILED_BINS
      option.weight = weight_val;
      type_option.weight = weight_val;
    }

coherent_non_atomic_xact_on_rn_f_ports : Captures opcodes for coherent non-atomic transaction type from RN-F ports

`define SVT_CHI_SYSTEM_MONITOR_DEF_COV_UTIL_COHERENT_NON_ATOMIC_XACT_ON_RN_F_PORTS_DETAILED_BINS

Bins for coherent non-atomic xact type on RN-F ports

`define SVT_CHI_SYSTEM_MONITOR_DEF_COV_UTIL_COHERENT_XACT_ON_RN_F_PORT1 ( weight_val )

coherent_xact_on_rn_f_port1: coverpoint coherent_xact_on_rn_f_port1 {
      SVT_CHI_SYSTEM_MONITOR_DEF_COV_UTIL_COHERENT_XACT_ON_RN_F_PORTS_DETAILED_BINS
      option.weight = weight_val;
      type_option.weight = weight_val;
    }

coherent_xact_on_rn_f_port1 : Captures opcodes for coherent transaction type from RN-F port1

`define SVT_CHI_SYSTEM_MONITOR_DEF_COV_UTIL_COHERENT_XACT_ON_RN_F_PORT2 ( weight_val )

coherent_xact_on_rn_f_port2: coverpoint coherent_xact_on_rn_f_port2 {
      SVT_CHI_SYSTEM_MONITOR_DEF_COV_UTIL_COHERENT_XACT_ON_RN_F_PORTS_DETAILED_BINS
      option.weight = weight_val;
      type_option.weight = weight_val;
    }

coherent_xact_on_rn_f_port2 : Captures opcodes for coherent transaction type from RN-F port2

`define SVT_CHI_SYSTEM_MONITOR_DEF_COV_UTIL_COHERENT_XACT_ON_RN_F_PORTS ( weight_val )

coherent_xact_on_rn_f_ports: coverpoint coherent_xact_on_rn_f_ports {
      SVT_CHI_SYSTEM_MONITOR_DEF_COV_UTIL_COHERENT_XACT_ON_RN_F_PORTS_DETAILED_BINS
      option.weight = weight_val;
      type_option.weight = weight_val;
    }

coherent_xact_on_rn_f_ports : Captures opcodes for coherent transaction type from RN-F ports

`define SVT_CHI_SYSTEM_MONITOR_DEF_COV_UTIL_COHERENT_XACT_ON_RN_F_PORTS_DETAILED_BINS

bins readonce_xact = {svt_chi_transaction::READONCE} ;
      bins readclean_xact = {svt_chi_transaction::READCLEAN};
      bins readshared_xact = {svt_chi_transaction::READSHARED};
      bins readunique_xact = {svt_chi_transaction::READUNIQUE};
      bins cleanunique_xact = {svt_chi_transaction::CLEANUNIQUE};
      bins makeunique_xact = {svt_chi_transaction::MAKEUNIQUE};
      bins evict_xact = {svt_chi_transaction::EVICT};
      bins cleanshared_xact = {svt_chi_transaction::CLEANSHARED};
      bins cleaninvalid_xact = {svt_chi_transaction::CLEANINVALID};
      bins makeinvalid_xact = {svt_chi_transaction::MAKEINVALID};
      bins writeuniquefull_xact = {svt_chi_transaction::WRITEUNIQUEFULL};
      bins writeuniqueptl_xact = {svt_chi_transaction::WRITEUNIQUEPTL};
      bins writebackfull_xact = {svt_chi_transaction::WRITEBACKFULL};
      bins writebackptl_xact = {svt_chi_transaction::WRITEBACKPTL};
      bins writeevictfull_xact = {svt_chi_transaction::WRITEEVICTFULL};
      bins writecleanfull_xact = {svt_chi_transaction::WRITECLEANFULL};
    `ifdef SVT_CHI_ISSUE_B_ENABLE
      bins readoncecleaninvalid_xact = {svt_chi_transaction::READONCECLEANINVALID};
      bins readoncemakeinvalid_xact = {svt_chi_transaction::READONCEMAKEINVALID};
      bins readnotshareddirty_xact = {svt_chi_transaction::READNOTSHAREDDIRTY};
      bins cleansharedpersist_xact = {svt_chi_transaction::CLEANSHAREDPERSIST};
      bins atomicstore_add_xact = {svt_chi_transaction::ATOMICSTORE_ADD};
      bins atomicstore_clr_xact = {svt_chi_transaction::ATOMICSTORE_CLR};
      bins atomicstore_eor_xact = {svt_chi_transaction::ATOMICSTORE_EOR};
      bins atomicstore_set_xact = {svt_chi_transaction::ATOMICSTORE_SET};
      bins atomicstore_smax_xact = {svt_chi_transaction::ATOMICSTORE_SMAX};
      bins atomicstore_smin_xact = {svt_chi_transaction::ATOMICSTORE_SMIN};
      bins atomicstore_umax_xact = {svt_chi_transaction::ATOMICSTORE_UMAX};
      bins atomicstore_umin_xact = {svt_chi_transaction::ATOMICSTORE_UMIN};
      bins atomicload_add_xact = {svt_chi_transaction::ATOMICLOAD_ADD};
      bins atomicload_clr_xact = {svt_chi_transaction::ATOMICLOAD_CLR};
      bins atomicload_eor_xact = {svt_chi_transaction::ATOMICLOAD_EOR};
      bins atomicload_set_xact = {svt_chi_transaction::ATOMICLOAD_SET};
      bins atomicload_smax_xact = {svt_chi_transaction::ATOMICLOAD_SMAX};
      bins atomicload_smin_xact = {svt_chi_transaction::ATOMICLOAD_SMIN};
      bins atomicload_umax_xact = {svt_chi_transaction::ATOMICLOAD_UMAX};
      bins atomicload_umin_xact = {svt_chi_transaction::ATOMICLOAD_UMIN};
      bins atomicswap_xact = {svt_chi_transaction::ATOMICSWAP};
      bins atomiccompare_xact = {svt_chi_transaction::ATOMICCOMPARE};
      bins prefetchtgt_xact = {svt_chi_transaction::PREFETCHTGT};
    `endif

Bins for coherent xact type on RN-F ports

`define SVT_CHI_SYSTEM_MONITOR_DEF_COV_UTIL_COHERENT_XACT_ON_RN_I_PORTS ( weight_val )

coherent_xact_on_rn_i_ports : coverpoint coherent_xact_on_rn_i_ports {
      bins readonce_xact = {svt_chi_transaction::READONCE} ;
      bins cleanshared_xact = {svt_chi_transaction::CLEANSHARED};
      bins cleaninvalid_xact = {svt_chi_transaction::CLEANINVALID};
      bins makeinvalid_xact = {svt_chi_transaction::MAKEINVALID};
      bins writeuniquefull_xact = {svt_chi_transaction::WRITEUNIQUEFULL};
      bins writeuniqueptl_xact = {svt_chi_transaction::WRITEUNIQUEPTL};
      option.weight = weight_val;
      type_option.weight = weight_val;
    }

coherent_xact_on_rn_i_ports : Captures coherent transaction types from RN-I/RN-D ports

`define SVT_CHI_SYSTEM_MONITOR_DEF_COV_UTIL_COHERENT_XACT_TYPE ( weight_val )

coherent_xact_type: coverpoint sys_xact.rn_xact.xact_type {
      SVT_CHI_SYSTEM_MONITOR_DEF_COV_UTIL_COHERENT_XACT_ON_RN_F_PORTS_DETAILED_BINS
      option.weight = weight_val;
      type_option.weight = weight_val;
    }

coherent_xact_type : Captures opcodes for coherent transaction type

`define SVT_CHI_SYSTEM_MONITOR_DEF_COV_UTIL_FINAL_CACHE_LINE_STATE ( weight_val )

final_cache_line_state : coverpoint sys_xact.rn_xact.final_cacheline_state {
   bins final_state_invalid = {svt_chi_snoop_transaction::I};
   bins final_state_sharedclean = {svt_chi_snoop_transaction::SC};
   bins final_state_shareddirty = {svt_chi_snoop_transaction::SD};
   bins final_state_uniqueclean = {svt_chi_snoop_transaction::UC};
   bins final_state_uniquedirty = {svt_chi_snoop_transaction::UD};
   option.weight = weight_val ;
   type_option.weight = weight_val;
}

final_cache_line_state : Captures final cache line state of RN transaction

`define SVT_CHI_SYSTEM_MONITOR_DEF_COV_UTIL_HOME_NODE_IDX ( weight_val )

home_node_idx : coverpoint hn_node_idx iff(target_id_flag){
     bins hn_idx[] = {[0:(const_sys_cfg_num_hn-1)]};
     option.weight = weight_val;
     type_option.weight = weight_val;
   }

home_node_idx : Captures values of HN indices

`define SVT_CHI_SYSTEM_MONITOR_DEF_COV_UTIL_NON_COHERENT_XACT_ON_RN_F_PORT1 ( weight_val )

non_coherent_xact_on_rn_f_port1: coverpoint non_coherent_xact_on_rn_f_port1 {
      SVT_CHI_SYSTEM_MONITOR_DEF_COV_UTIL_NON_COHERENT_XACT_ON_RN_F_PORTS_DETAILED_BINS
      option.weight = weight_val;
      type_option.weight = weight_val;
    }

non_coherent_xact_on_rn_f_port1 : Captures non-coherent transaction types from RN-F port1

`define SVT_CHI_SYSTEM_MONITOR_DEF_COV_UTIL_NON_COHERENT_XACT_ON_RN_F_PORT2 ( weight_val )

non_coherent_xact_on_rn_f_port2: coverpoint non_coherent_xact_on_rn_f_port2 {
      SVT_CHI_SYSTEM_MONITOR_DEF_COV_UTIL_NON_COHERENT_XACT_ON_RN_F_PORTS_DETAILED_BINS
      option.weight = weight_val;
      type_option.weight = weight_val;
    }

non_coherent_xact_on_rn_f_port2 : Captures non-coherent transaction types from RN-F port2

`define SVT_CHI_SYSTEM_MONITOR_DEF_COV_UTIL_NON_COHERENT_XACT_ON_RN_F_PORTS ( weight_val )

non_coherent_xact_on_rn_f_ports: coverpoint non_coherent_xact_on_rn_f_ports {
      SVT_CHI_SYSTEM_MONITOR_DEF_COV_UTIL_NON_COHERENT_XACT_ON_RN_F_PORTS_DETAILED_BINS
      option.weight = weight_val;
      type_option.weight = weight_val;
    }

non_coherent_xact_on_rn_f_ports : Captures non-coherent transaction types from RN-F ports

`define SVT_CHI_SYSTEM_MONITOR_DEF_COV_UTIL_NON_COHERENT_XACT_ON_RN_F_PORTS_DETAILED_BINS

bins readnosnp_xact = {svt_chi_transaction::READNOSNP};
bins writenosnpfull_xact = {svt_chi_transaction::WRITENOSNPFULL};
bins writenosnpptl_xact = {svt_chi_transaction::WRITENOSNPPTL};

Bins for non-coherent xact type on RN-F ports

`define SVT_CHI_SYSTEM_MONITOR_DEF_COV_UTIL_NON_COHERENT_XACT_ON_RN_I_PORTS ( weight_val )

non_coherent_xact_on_rn_i_ports : coverpoint non_coherent_xact_on_rn_i_ports{
      bins readnosnp_xact = {svt_chi_transaction::READNOSNP};
      bins writenosnp_xact = {svt_chi_transaction::WRITENOSNPPTL, svt_chi_transaction::WRITENOSNPFULL};
      option.weight = weight_val;
      type_option.weight = weight_val;
    }

non_coherent_xact_on_rn_i_ports : Captures non-coherent transaction types from RN-I/RN-D ports

`define SVT_CHI_SYSTEM_MONITOR_DEF_COV_UTIL_NONSTASH_SNOOP_RESP_HAS_DATA_XFER ( weight_val )

nonstash_snoop_resp_has_data_xfer: coverpoint sys_xact.nonstash_snoop_resp_has_data_xfer {
   bins nonstash_snoop_resp_has_no_data_xfer = {0};
   bins nonstash_snoop_resp_has_data_xfer = {1};
   option.weight = weight_val ;
   type_option.weight = weight_val;
}

nonstash_snoop_resp_has_data_xfer : Captures whether non-stash snoop response has data transfer or not

`define SVT_CHI_SYSTEM_MONITOR_DEF_COV_UTIL_NONSTASH_SNP_RESP_PD ( weight_val )

nonstash_snp_resp_pd: coverpoint sys_xact.nonstash_snoop_resp_PD {
   bins nonstash_snoop_resp_has_no_PD = {0};
   bins nonstash_snoop_resp_has_PD = {1};
   option.weight = weight_val ;
   type_option.weight = weight_val;
}

nonstash_snp_resp_pd : Captures whether non-stash snoop response has PassDirty asserted or not

`define SVT_CHI_SYSTEM_MONITOR_DEF_COV_UTIL_NONSTASHTYPE_ASSOCIATED_SNP_PRESENT ( weight_val )

nonstashtype_associated_snp_present: coverpoint sys_xact.nonstashtype_associated_snp_present {
   bins nonstashtype_associated_snp_is_not_present = {0};
   bins nonstashtype_associated_snp_present = {1};
   option.weight = weight_val ;
   type_option.weight = weight_val;
}

nonstashtype_associated_snp_present : Captures whether non-stash type associated snoop present or not

`define SVT_CHI_SYSTEM_MONITOR_DEF_COV_UTIL_RN_COHERENT_EXCLUSIVE_READ_XACT_RESPONSE ( weight_val )

rn_coherent_exclusive_read_xact_response : coverpoint sys_xact_read_resp_err {
    bins normal_okay_resp_err = {svt_chi_transaction::NORMAL_OKAY};
    bins excl_okay_resp_err = {svt_chi_transaction::EXCLUSIVE_OKAY};
    bins data_error_resp_err = {svt_chi_transaction::DATA_ERROR};
    bins non_data_error_resp_err = {svt_chi_transaction::NON_DATA_ERROR};
    type_option.weight = weight_val;
    option.weight = weight_val;
  }

rn_coherent_exclusive_read_xact_response : This coverpoint captures RN coherent exclusive transactions response type

`define SVT_CHI_SYSTEM_MONITOR_DEF_COV_UTIL_RN_COHERENT_EXCLUSIVE_WRITE_XACT_RESPONSE ( weight_val )

rn_coherent_exclusive_write_xact_response : coverpoint sys_xact.rn_xact.response_resp_err_status {
    bins normal_okay_resp_err = {svt_chi_transaction::NORMAL_OKAY};
    bins excl_okay_resp_err = {svt_chi_transaction::EXCLUSIVE_OKAY};
    bins data_error_resp_err = {svt_chi_transaction::DATA_ERROR};
    bins non_data_error_resp_err = {svt_chi_transaction::NON_DATA_ERROR};
    type_option.weight = weight_val;
    option.weight = weight_val;
  }

rn_coherent_exclusive_write_xact_response : This coverpoint captures RN coherent exclusive transactions response type

`define SVT_CHI_SYSTEM_MONITOR_DEF_COV_UTIL_RN_COHERENT_EXCLUSIVE_WRITE_XACT_TYPE ( weight_val )

rn_coherent_exclusive_write_xact_type : coverpoint sys_xact.rn_xact.xact_type {
    bins cleanunique = {svt_chi_transaction::CLEANUNIQUE};
    type_option.weight = weight_val;
    option.weight = weight_val;
  }

rn_coherent_exclusive_write_xact_type : This coverpoint captures RN coherent exclusive transactions

`define SVT_CHI_SYSTEM_MONITOR_DEF_COV_UTIL_RN_EXCL_READ_XACT_ASSOC_SNP_XACT_TYPE ( weight_val )

rn_excl_read_xact_assoc_snp_xact_type : coverpoint sys_xact_snp_xact_type {
    bins snpshared = {svt_chi_snoop_transaction::SNPSHARED};
    type_option.weight = weight_val;
    option.weight = weight_val;
  }

rn_excl_read_xact_assoc_snp_xact_type : This coverpoint captures snoop transaction associated for an RN coherent exclusive read transaction

`define SVT_CHI_SYSTEM_MONITOR_DEF_COV_UTIL_RN_EXCL_WRITE_XACT_ASSOC_SNP_XACT_TYPE ( weight_val )

rn_excl_write_xact_assoc_snp_xact_type : coverpoint sys_xact_snp_xact_type {
    bins snpcleaninvalid = {svt_chi_snoop_transaction::SNPCLEANINVALID};
    type_option.weight = weight_val;
    option.weight = weight_val;
  }

rn_excl_write_xact_assoc_snp_xact_type : This coverpoint captures snoop transaction associated for an RN coherent exclusive write transaction

`define SVT_CHI_SYSTEM_MONITOR_DEF_COV_UTIL_RN_F_COHERENT_EXCLUSIVE_READ_XACT_TYPE ( weight_val )

rn_f_coherent_exclusive_read_xact_type : coverpoint sys_xact.rn_xact.xact_type {
    bins readclean = {svt_chi_transaction::READCLEAN};
    bins readshared = {svt_chi_transaction::READSHARED};
    bins readnotshareddirty = {svt_chi_transaction::READNOTSHAREDDIRTY};
    type_option.weight = weight_val;
    option.weight = weight_val;
  }

rn_f_coherent_exclusive_read_xact_type : This coverpoint captures RN-F coherent exclusive read transactions

`define SVT_CHI_SYSTEM_MONITOR_DEF_COV_UTIL_RN_F_PORT1_COHERENT_EXCLUSIVE_READ_XACT_RESPONSE ( weight_val )

rn_f_port1_coherent_exclusive_read_xact_response : coverpoint sys_xact_rn_f_port1_read_resp_err {
    bins rn_f_port1_resp_err_normal_okay = {svt_chi_transaction::NORMAL_OKAY};
    bins rn_f_port1_resp_err_excl_okay = {svt_chi_transaction::EXCLUSIVE_OKAY};
    bins rn_f_port1_resp_err_data_error = {svt_chi_transaction::DATA_ERROR};
    bins rn_f_port1_resp_err_non_data_error = {svt_chi_transaction::NON_DATA_ERROR};
    type_option.weight = weight_val;
    option.weight = weight_val;
  }

rn_f_port1_coherent_exclusive_read_xact_response : This coverpoint captures RN-F coherent exclusive read transactions response type

`define SVT_CHI_SYSTEM_MONITOR_DEF_COV_UTIL_RN_F_PORT1_COHERENT_EXCLUSIVE_READ_XACT_TYPE ( weight_val )

rn_f_port1_coherent_exclusive_read_xact_type : coverpoint cov_rn_f_port1_coherent_exclusive_read_xact_type {
    bins rn_f_port1_readclean = {svt_chi_transaction::READCLEAN};
    bins rn_f_port1_readshared = {svt_chi_transaction::READSHARED};
    bins rn_f_port1_readnotshareddirty = {svt_chi_transaction::READNOTSHAREDDIRTY};
    type_option.weight = weight_val;
    option.weight = weight_val;
  }

rn_f_port1_coherent_exclusive_read_xact_type : This coverpoint captures RN-F coherent exclusive read transactions

`define SVT_CHI_SYSTEM_MONITOR_DEF_COV_UTIL_RN_F_PORT1_COHERENT_EXCLUSIVE_WRITE_XACT_RESPONSE ( weight_val )

rn_f_port1_coherent_exclusive_write_xact_response : coverpoint sys_xact_rn_f_port1_write_resp_err {
    bins rn_f_port1_resp_err_normal_okay = {svt_chi_transaction::NORMAL_OKAY};
    bins rn_f_port1_resp_err_excl_okay = {svt_chi_transaction::EXCLUSIVE_OKAY};
    bins rn_f_port1_resp_err_data_error = {svt_chi_transaction::DATA_ERROR};
    bins rn_f_port1_resp_err_non_data_error = {svt_chi_transaction::NON_DATA_ERROR};
    type_option.weight = weight_val;
    option.weight = weight_val;
  }

rn_f_port1_coherent_exclusive_write_xact_response : This coverpoint captures RN-F coherent exclusive write transactions response type

`define SVT_CHI_SYSTEM_MONITOR_DEF_COV_UTIL_RN_F_PORT1_COHERENT_EXCLUSIVE_WRITE_XACT_TYPE ( weight_val )

rn_f_port1_coherent_exclusive_write_xact_type : coverpoint cov_rn_f_port1_coherent_exclusive_write_xact_type {
    bins rn_f_port1_cleanunique = {svt_chi_transaction::CLEANUNIQUE};
    type_option.weight = weight_val;
    option.weight = weight_val;
  }

rn_f_port1_coherent_exclusive_write_xact_type : This coverpoint captures RN-F coherent exclusive write transactions

`define SVT_CHI_SYSTEM_MONITOR_DEF_COV_UTIL_RN_F_PORT2_COHERENT_EXCLUSIVE_READ_XACT_RESPONSE ( weight_val )

rn_f_port2_coherent_exclusive_read_xact_response : coverpoint sys_xact_rn_f_port2_read_resp_err {
    bins rn_f_port2_resp_err_normal_okay = {svt_chi_transaction::NORMAL_OKAY};
    bins rn_f_port2_resp_err_excl_okay = {svt_chi_transaction::EXCLUSIVE_OKAY};
    bins rn_f_port2_resp_err_data_error = {svt_chi_transaction::DATA_ERROR};
    bins rn_f_port2_resp_err_non_data_error = {svt_chi_transaction::NON_DATA_ERROR};
    type_option.weight = weight_val;
    option.weight = weight_val;
  }

rn_f_port2_coherent_exclusive_read_xact_response : This coverpoint captures RN-F coherent exclusive read transactions response type

`define SVT_CHI_SYSTEM_MONITOR_DEF_COV_UTIL_RN_F_PORT2_COHERENT_EXCLUSIVE_READ_XACT_TYPE ( weight_val )

rn_f_port2_coherent_exclusive_read_xact_type : coverpoint cov_rn_f_port2_coherent_exclusive_read_xact_type {
    bins rn_f_port2_readclean = {svt_chi_transaction::READCLEAN};
    bins rn_f_port2_readshared = {svt_chi_transaction::READSHARED};
    bins rn_f_port2_readnotshareddirty = {svt_chi_transaction::READNOTSHAREDDIRTY};
    type_option.weight = weight_val;
    option.weight = weight_val;
  }

rn_f_port2_coherent_exclusive_read_xact_type : This coverpoint captures RN-F coherent exclusive read transactions

`define SVT_CHI_SYSTEM_MONITOR_DEF_COV_UTIL_RN_F_PORT2_COHERENT_EXCLUSIVE_WRITE_XACT_RESPONSE ( weight_val )

rn_f_port2_coherent_exclusive_write_xact_response : coverpoint sys_xact_rn_f_port2_write_resp_err {
    bins rn_f_port2_resp_err_normal_okay = {svt_chi_transaction::NORMAL_OKAY};
    bins rn_f_port2_resp_err_excl_okay = {svt_chi_transaction::EXCLUSIVE_OKAY};
    bins rn_f_port2_resp_err_data_error = {svt_chi_transaction::DATA_ERROR};
    bins rn_f_port2_resp_err_non_data_error = {svt_chi_transaction::NON_DATA_ERROR};
    type_option.weight = weight_val;
    option.weight = weight_val;
  }

rn_f_port2_coherent_exclusive_write_xact_response : This coverpoint captures RN-F coherent exclusive write transactions response type

`define SVT_CHI_SYSTEM_MONITOR_DEF_COV_UTIL_RN_F_PORT2_COHERENT_EXCLUSIVE_WRITE_XACT_TYPE ( weight_val )

rn_f_port2_coherent_exclusive_write_xact_type : coverpoint cov_rn_f_port2_coherent_exclusive_write_xact_type {
    bins rn_f_port2_cleanunique = {svt_chi_transaction::CLEANUNIQUE};
    type_option.weight = weight_val;
    option.weight = weight_val;
  }

rn_f_port2_coherent_exclusive_write_xact_type : This coverpoint captures RN-F coherent exclusive write transactions

`define SVT_CHI_SYSTEM_MONITOR_DEF_COV_UTIL_RN_I_COHERENT_EXCLUSIVE_READ_XACT_TYPE ( weight_val )

rn_i_coherent_exclusive_read_xact_type : coverpoint sys_xact.rn_xact.xact_type {
    bins readonce = {svt_chi_transaction::READONCE};
    bins readoncecleaninvalid = {svt_chi_transaction::READONCECLEANINVALID};
    bins readoncemakeinvalid = {svt_chi_transaction::READONCEMAKEINVALID};
    type_option.weight = weight_val;
    option.weight = weight_val;
  }

rn_i_coherent_exclusive_read_xact_type : This coverpoint captures RN-I coherent exclusive read transactions

`define SVT_CHI_SYSTEM_MONITOR_DEF_COV_UTIL_RN_I_PORT1_COHERENT_EXCLUSIVE_READ_XACT_RESPONSE ( weight_val )

rn_i_port1_coherent_exclusive_read_xact_response : coverpoint sys_xact_rn_i_port1_read_resp_err {
    bins rn_i_port1_resp_err_normal_okay = {svt_chi_transaction::NORMAL_OKAY};
    bins rn_i_port1_resp_err_excl_okay = {svt_chi_transaction::EXCLUSIVE_OKAY};
    bins rn_i_port1_resp_err_data_error = {svt_chi_transaction::DATA_ERROR};
    bins rn_i_port1_resp_err_non_data_error = {svt_chi_transaction::NON_DATA_ERROR};
    type_option.weight = weight_val;
    option.weight = weight_val;
  }

rn_i_port1_coherent_exclusive_read_xact_response : This coverpoint captures RN-I/RN-D coherent exclusive read transactions response type

`define SVT_CHI_SYSTEM_MONITOR_DEF_COV_UTIL_RN_I_PORT1_COHERENT_EXCLUSIVE_READ_XACT_TYPE ( weight_val )

rn_i_port1_coherent_exclusive_read_xact_type : coverpoint cov_rn_i_port1_coherent_exclusive_read_xact_type {
    bins rn_i_port1_readonce = {svt_chi_transaction::READONCE};
    bins rn_i_port1_readoncecleaninvalid = {svt_chi_transaction::READONCECLEANINVALID};
    bins rn_i_port1_readoncemakeinvalid = {svt_chi_transaction::READONCEMAKEINVALID};
    type_option.weight = weight_val;
    option.weight = weight_val;
  }

rn_i_port1_coherent_exclusive_read_xact_type : This coverpoint captures RN-I/RN-D coherent exclusive read transactions

`define SVT_CHI_SYSTEM_MONITOR_DEF_COV_UTIL_RN_I_PORT1_COHERENT_EXCLUSIVE_WRITE_XACT_RESPONSE ( weight_val )

rn_i_port1_coherent_exclusive_write_xact_response : coverpoint sys_xact_rn_i_port1_write_resp_err {
    bins rn_i_port1_resp_err_normal_okay = {svt_chi_transaction::NORMAL_OKAY};
    bins rn_i_port1_resp_err_excl_okay = {svt_chi_transaction::EXCLUSIVE_OKAY};
    bins rn_i_port1_resp_err_data_error = {svt_chi_transaction::DATA_ERROR};
    bins rn_i_port1_resp_err_non_data_error = {svt_chi_transaction::NON_DATA_ERROR};
    type_option.weight = weight_val;
    option.weight = weight_val;
  }

rn_i_port1_coherent_exclusive_write_xact_response : This coverpoint captures RN-I/RN-D coherent exclusive write transactions response type

`define SVT_CHI_SYSTEM_MONITOR_DEF_COV_UTIL_RN_I_PORT1_COHERENT_EXCLUSIVE_WRITE_XACT_TYPE ( weight_val )

rn_i_port1_coherent_exclusive_write_xact_type : coverpoint cov_rn_i_port1_coherent_exclusive_write_xact_type {
    bins rn_i_port1_cleanunique = {svt_chi_transaction::CLEANUNIQUE};
    type_option.weight = weight_val;
    option.weight = weight_val;
  }

rn_i_port1_coherent_exclusive_write_xact_type : This coverpoint captures RN-I/RN-D coherent exclusive write transactions

`define SVT_CHI_SYSTEM_MONITOR_DEF_COV_UTIL_RN_XACT_BYTE_ENABLE_VAL ( weight_val )

rn_xact_byte_enable_val : coverpoint sys_xact.rn_xact.byte_enable {
    bins byte_enable_val[SVT_CHI_SYS_COV_NUM_BYTE_ENABLE_BINS] = {[SVT_CHI_MAX_BE_WIDTH'h0:SVT_CHI_MAX_BE_WIDTH'hFFFF_FFFF_FFFF_FFFF]};
    type_option.weight = weight_val;
    option.weight = weight_val;
  }

rn_xact_byte_enable_val : This coverpoint captures byte_enable value of RN transaction

`define SVT_CHI_SYSTEM_MONITOR_DEF_COV_UTIL_SNOOP_FILTER_ACCESS_STATUS ( weight_val )

snoop_filter_access_status : coverpoint sys_xact.snoop_filter_access_status {
    bins snoop_filter_hit = {svt_chi_system_transaction::SF_HIT};
    bins snoop_filter_miss = {svt_chi_system_transaction::SF_MISS};
    type_option.weight = weight_val;
    option.weight = weight_val;
  }

snoop_filter_access_status : This coverpoint captures snoop filter HIT/MISS condition

`define SVT_CHI_SYSTEM_MONITOR_DEF_COV_UTIL_SNP_ASSOCIATE ( weight_val )

snp_associate: coverpoint sys_xact.are_associate_snoops_present{
   bins associated_snoop[] = {[0:1]};
   option.weight = weight_val ;
   type_option.weight = weight_val;
}

snp_associate : Captures whether there is any associated snoop present or not

`define SVT_CHI_SYSTEM_MONITOR_DEF_COV_UTIL_SNP_DATA_XFER ( weight_val )

snp_data_xfer: coverpoint sys_xact.snoop_resp_has_data_xfer {
   bins snoop_data_transfer[] = {[0:1]};
   option.weight = weight_val ;
   type_option.weight = weight_val;
}

snp_data_xfer : Captures whether snoop response has data transfer or not

`define SVT_CHI_SYSTEM_MONITOR_DEF_COV_UTIL_SNP_PTL_DATA_XFER ( weight_val )

snp_ptl_data_xfer: coverpoint sys_xact.snoop_resp_has_partial_data {
   bins snoop_ptl_data_transfer[] = {[0:1]};
   option.weight = weight_val ;
   type_option.weight = weight_val;
}

snp_ptl_data_xfer : Captures whether snoop response has partial data transfer or not

`define SVT_CHI_SYSTEM_MONITOR_DEF_COV_UTIL_SNP_RESP_PD ( weight_val )

snp_resp_pd: coverpoint sys_xact.snoop_resp_PD {
   bins snoop_rsp_pd[] = {[0:1]};
   option.weight = weight_val ;
   type_option.weight = weight_val;
}

snp_resp_pd : Captures whether snoop response has PassDirty asserted or not

`define SVT_CHI_SYSTEM_MONITOR_DEF_COV_UTIL_SNP_RSP_FINAL_CACHE_LINE_STATE ( weight_val )

snp_rsp_final_cache_line_state : coverpoint sys_xact.snoop_resp_final_state {
   bins final_state_invalid = {svt_chi_snoop_transaction::I};
   bins final_state_sharedclean = {svt_chi_snoop_transaction::SC};
   bins final_state_shareddirty = {svt_chi_snoop_transaction::SD};
   bins final_state_uniqueclean = {svt_chi_snoop_transaction::UC};
   bins final_state_uniquedirty = {svt_chi_snoop_transaction::UD};
   option.weight = weight_val ;
   type_option.weight = weight_val;
}

snp_rsp_final_cache_line_state : Captures final cache line state of snoop response

`define SVT_CHI_SYSTEM_MONITOR_DEF_COV_UTIL_SNP_XACT_TYPE ( weight_val )

snp_xact_type : coverpoint sys_xact.associated_snoop_xacts_type {
   bins snponce = {svt_chi_snoop_transaction::SNPONCE};
   bins snpclean = {svt_chi_snoop_transaction::SNPCLEAN};
   bins snpshared = {svt_chi_snoop_transaction::SNPSHARED};
   bins snpunique = {svt_chi_snoop_transaction::SNPUNIQUE};
   bins snpcleanshared = {svt_chi_snoop_transaction::SNPCLEANSHARED};
   bins snpcleaninvalid = {svt_chi_snoop_transaction::SNPCLEANINVALID};
   bins snpmakeinvalid = {svt_chi_snoop_transaction::SNPMAKEINVALID};
`ifdef SVT_CHI_ISSUE_B_ENABLE
   bins snpnotshareddirty = {svt_chi_snoop_transaction::SNPNOTSHAREDDIRTY};
`endif
   option.weight = weight_val;
   type_option.weight = weight_val;
  }

snp_xact_type : Captures Snoop transaction type, upto CHI Issue D

`define SVT_CHI_SYSTEM_MONITOR_DEF_COV_UTIL_STASH_LPID_VALID ( weight_val )

stash_lpid_valid: coverpoint sys_xact.rn_xact.stash_lpid_valid {
   bins stash_lpid_defined = {1};
   bins stash_lpid_notdefined = {0};
   option.weight = weight_val ;
   type_option.weight = weight_val;
}

stash_lpid_valid : Captures StashLPID value

`define SVT_CHI_SYSTEM_MONITOR_DEF_COV_UTIL_STASH_NID_VALID ( weight_val )

stash_nid_valid: coverpoint sys_xact.rn_xact.stash_nid_valid {
   bins stash_nid_defined = {1};
   bins stash_nid_notdefined = {0};
   option.weight = weight_val ;
   type_option.weight = weight_val;
}

stash_nid_valid : Captures StashNID Value

`define SVT_CHI_SYSTEM_MONITOR_DEF_COV_UTIL_STASH_OPCODE ( weight_val )

stash_opcode : coverpoint sys_xact.rn_xact.xact_type {
   bins stashonceunique = {svt_chi_transaction::STASHONCEUNIQUE};
   bins stashonceshared = {svt_chi_transaction::STASHONCESHARED};
   type_option.weight = weight_val;
   option.weight = weight_val;
}

stash_opcode : Captures StashOnce* opcodes

`define SVT_CHI_SYSTEM_MONITOR_DEF_COV_UTIL_STASH_SNOOP_RESP_HAS_DATA_XFER ( weight_val )

stash_snoop_resp_has_data_xfer: coverpoint sys_xact.stash_snoop_resp_has_data_xfer {
   bins stash_snoop_resp_has_no_data_xfer = {0};
   bins stash_snoop_resp_has_data_xfer = {1};
   option.weight = weight_val ;
   type_option.weight = weight_val;
}

stash_snoop_resp_has_data_xfer : Captures whether stash snoop response has data transfer or not

`define SVT_CHI_SYSTEM_MONITOR_DEF_COV_UTIL_STASH_SNP_RESP_PD ( weight_val )

stash_snp_resp_pd: coverpoint sys_xact.stash_snoop_resp_PD {
   bins stash_snoop_resp_has_no_PD = {0};
   bins stash_snoop_resp_has_PD = {1};
   option.weight = weight_val ;
   type_option.weight = weight_val;
}

stash_snp_resp_pd : Captures whether stash snoop response has PassDirty asserted or not

`define SVT_CHI_SYSTEM_MONITOR_DEF_COV_UTIL_STASH_SNP_XACT_DONOTDATAPULL ( weight_val )

stash_snp_xact_donotdatapull : coverpoint sys_xact.stash_snpreq_donotdatapull {
   bins donotdatapull_zero = {1'b0};
   bins donotdatapull_is_asserted = {1'b1};
   option.weight = weight_val;
   type_option.weight = weight_val;
}

stash_snp_xact_donotdatapull : Captures whether stash snoop transaction has donotdatapull asserted or not

`define SVT_CHI_SYSTEM_MONITOR_DEF_COV_UTIL_STASH_SNP_XACT_TYPE ( weight_val )

stash_snp_xact_type : coverpoint sys_xact.associated_stashsnoop_xacts_type {
   bins no_stash_snoop_xact_present = {svt_chi_snoop_transaction::SNPSHARED};
   bins snpmakeinvalidstash = {svt_chi_snoop_transaction::SNPMAKEINVALIDSTASH};
   bins snpuniquestash = {svt_chi_snoop_transaction::SNPUNIQUESTASH};
   bins snpstashunique = {svt_chi_snoop_transaction::SNPSTASHUNIQUE};
   bins snpstashshared = {svt_chi_snoop_transaction::SNPSTASHSHARED};
   option.weight = weight_val;
   type_option.weight = weight_val;
}

stash_snp_xact_type : Captures stash snoop transaction types

`define SVT_CHI_SYSTEM_MONITOR_DEF_COV_UTIL_STASH_SNPRESP_DATAPULL ( weight_val )

stash_snpresp_datapull : coverpoint sys_xact.stash_snpresp_datapull_read_resp {
   bins datapull_is_zero = {3'b0};
   bins datapull_is_asserted = {3'b001};
   option.weight = weight_val;
   type_option.weight = weight_val;
}

stash_snpresp_datapull : Captures whether stasth snoop response has datapull asserted or not

`define SVT_CHI_SYSTEM_MONITOR_DEF_COV_UTIL_STASH_SNPRESP_DATAPULL_READ_DATARESP_FINAL_STATE ( weight_val )

stash_snpresp_datapull_read_dataresp_final_state : coverpoint sys_xact.stash_snpresp_datapull_read_dataresp_final_state {
   bins stash_datapull_respdata_invalid = {svt_chi_snoop_transaction::I};
   bins stash_datapull_respdata_sharedclean = {svt_chi_snoop_transaction::SC};
   bins stash_datapull_respdata_shareddirty = {svt_chi_snoop_transaction::SD};
   bins stash_datapull_respdata_uniqueclean = {svt_chi_snoop_transaction::UC};
   bins stash_datapull_respdata_uniquedirty = {svt_chi_snoop_transaction::UD};
   option.weight = weight_val ;
   type_option.weight = weight_val;
}

stash_snpresp_datapull_read_dataresp_final_state : Captures final state of Read Data response, corresponding to Stash Snoop resposne with DataPull asserted

`define SVT_CHI_SYSTEM_MONITOR_DEF_COV_UTIL_STASH_SNPRESP_DATAPULL_READ_DATARESP_IS_DMT_USED ( weight_val )

stash_snpresp_datapull_read_dataresp_is_dmt_used : coverpoint sys_xact.stash_snpresp_datapull_read_dataresp_is_dmt_used {
   bins datapull_resp_either_is_dmt_not_used_or_not_applicable = {0};
   bins datapull_resp_is_dmt_used_asserted = {1};
   option.weight = weight_val;
   type_option.weight = weight_val;
}

stash_snpresp_datapull_read_dataresp_is_dmt_used : Captures whether DMT is used for read data response, when stash snoop response has datapull asserted

`define SVT_CHI_SYSTEM_MONITOR_DEF_COV_UTIL_STASH_SNPRESP_DATAPULL_READ_DATARESP_IS_RESPSEPDATA_DATASEPRESP_FLOW_USED ( weight_val )

stash_snpresp_datapull_read_dataresp_is_respsepdata_datasepresp_flow_used : coverpoint sys_xact.stash_snpresp_datapull_read_dataresp_is_respsepdata_datasepresp_flow_used {
  bins datapull_resp_is_respsepdata_datasepresp_flow_is_either_not_used_or_not_applicable = {0};
  bins datapull_resp_is_respsepdata_datasepresp_flow_used = {1};
  option.weight = weight_val;
  type_option.weight = weight_val;
  }

stash_snpresp_datapull_read_dataresp_is_respsepdata_datasepresp_flow_used : Captures whether seperate response and data flow is used or not for read data, when stash snoop resposne has datapull asserted

`define SVT_CHI_SYSTEM_MONITOR_DEF_COV_UTIL_STASH_SNPRESP_DATAPULL_READ_DATARESP_PASSDIRTY ( weight_val )

stash_snpresp_datapull_read_dataresp_passdirty : coverpoint sys_xact.stash_snpresp_datapull_read_dataresp_passdirty {
   bins datapull_resp_passdirty_is_either_zero_or_not_applicable = {0};
   bins datapull_resp_passdirty_asserted = {1};
   option.weight = weight_val;
   type_option.weight = weight_val;
}

stash_snpresp_datapull_read_dataresp_passdirty : Captures whether PassDirty is asserted or not for read data response, when stash snoop response has datapull asserted

`define SVT_CHI_SYSTEM_MONITOR_DEF_COV_UTIL_STASHONCESHARED_OPCODE ( weight_val )

stashonceshared_opcode : coverpoint sys_xact.rn_xact.xact_type {
    bins stashonceshared = {svt_chi_transaction::STASHONCESHARED};
    type_option.weight = weight_val;
    option.weight = weight_val;
  }

stashonceshared_opcode : Captures StashOnceShared opcode

`define SVT_CHI_SYSTEM_MONITOR_DEF_COV_UTIL_STASHONCEUNIQUE_OPCODE ( weight_val )

stashonceunique_opcode : coverpoint sys_xact.rn_xact.xact_type {
    bins stashonceunique = {svt_chi_transaction::STASHONCEUNIQUE};
    type_option.weight = weight_val;
    option.weight = weight_val;
  }

stashonceunique_opcode : Captures StashOnceUnique opcode

`define SVT_CHI_SYSTEM_MONITOR_DEF_COV_UTIL_STASHTYPE_ASSOCIATED_SNP_PRESENT ( weight_val )

stashtype_associated_snp_present: coverpoint sys_xact.are_associate_stashsnoops_present {
   bins stashtype_associated_snp_is_not_present = {0};
   bins stashtype_associated_snp_present = {1};
   option.weight = weight_val ;
   type_option.weight = weight_val;
}

stashtype_associated_snp_present : Captures whether stash type associated snoop is present or not

`define SVT_CHI_SYSTEM_MONITOR_DEF_COV_UTIL_SYS_XACT_SNP_DONOTGOTOSD ( weight_val )

sys_xact_snp_donotgotosd : coverpoint sys_xact_snp_donotgotosd {
    bins snp_donotgotosd_1 = {1};
    bins snp_donotgotosd_0 = {0};
    type_option.weight = weight_val;
    option.weight = weight_val;
  }

sys_xact_snp_donotgotosd : This coverpoint captures the DoNotGoToSD attribute of the snoop transaction

`define SVT_CHI_SYSTEM_MONITOR_DEF_COV_UTIL_SYS_XACT_SNP_RETTOSRC ( weight_val )

sys_xact_snp_rettosrc : coverpoint sys_xact_snp_rettosrc {
    bins snp_rettosrc_1 = {1};
    bins snp_rettosrc_0 = {0};
    type_option.weight = weight_val;
    option.weight = weight_val;
  }

sys_xact_snp_rettosrc : This coverpoint captures the rettosrc attribute of the snoop transaction

`define SVT_CHI_SYSTEM_MONITOR_DEF_COV_UTIL_SYS_XACT_SNP_RSP_DATATRANSFER ( weight_val )

sys_xact_snp_rsp_datatransfer : coverpoint sys_xact_snp_rsp_datatransfer {
    bins snp_rsp_datatransfer = {1};
    bins snp_rsp = {0};
    type_option.weight = weight_val;
    option.weight = weight_val;
  }

sys_xact_snp_rsp_datatransfer : This coverpoint captures the snp_rsp_datatransfer attribute of the snoop transaction

`define SVT_CHI_SYSTEM_MONITOR_DEF_COV_UTIL_WRITEDATACANCEL_OPCODE ( weight_val )

writedatacancel_opcode : coverpoint sys_xact.rn_xact.is_writedatacancel_used_for_write_xact {
    bins write_datacancel_used = {1};
    bins ncbwrdata_used = {0};
    type_option.weight = weight_val;
    option.weight = weight_val;
  }

writedatacancel_opcode : Captures

`define SVT_CHI_SYSTEM_MONITOR_DEF_COV_UTIL_WRITEUNIQUEPTL_OPCODE ( weight_val )

writeuniqueptl_opcode : coverpoint sys_xact.rn_xact.xact_type {
    bins writeuniqueptl = {svt_chi_transaction::WRITEUNIQUEPTL};
    type_option.weight = weight_val;
    option.weight = weight_val;
  }

writeuniqueptl_opcode : Captures WriteUniquePtl opcode

`define SVT_CHI_SYSTEM_MONITOR_DEF_COV_UTIL_WRITEUNIQUEPTLSTASH_OPCODE ( weight_val )

writeuniqueptlstash_opcode : coverpoint sys_xact.rn_xact.xact_type {
    bins writeuniqueptlstash = {svt_chi_transaction::WRITEUNIQUEPTLSTASH};
    type_option.weight = weight_val;
    option.weight = weight_val;
  }

writeuniqueptlstash_opcode : Captures WriteUniquePtlStash opcode

`define SVT_CHI_SYSTEM_MONITOR_DEF_COV_UTIL_WRITEUNIQUESTASH_OPCODE ( weight_val )

writeuniquestash_opcode : coverpoint sys_xact.rn_xact.xact_type {
    bins writeuniqueptlstash = {svt_chi_transaction::WRITEUNIQUEPTLSTASH};
    bins writeuniquefullstash = {svt_chi_transaction::WRITEUNIQUEFULLSTASH};
    type_option.weight = weight_val;
    option.weight = weight_val;
  }

writeuniquestash_opcode : Captures WriteUnique*Stash opcodes

`define SVT_CHI_SYSTEM_TRANSACTION_SV

`define SVT_CHI_TAG_ADDR_WIDTH

`define SVT_CHI_TGT_ID_WIDTH

Width of Target ID field

`define SVT_CHI_THREE_READ_REQUEST_EP_ORDERING_TRANSACTION_PATTERN_SEQ

7_0_2

`define SVT_CHI_THREE_READ_REQUEST_ORDERING_TRANSACTION_PATTERN_SEQ

7_0

`define SVT_CHI_THREE_READ_REQUEST_REQ_ORDERING_TRANSACTION_PATTERN_SEQ

7_0_1

`define SVT_CHI_TLBI_FOLLOWED_BY_CANCEL_TLBI_FOLLOWED_BY_NON_DVMOP_OF_SAME_TXNID_FOLLOWED_BY_SYNC_FOLLOWED_BY_CANCEL_SYNC_FOLLOWED_BY_SYNC_OF_SAME_TXNID_PATTERN_SEQ

10_6

`define SVT_CHI_TLBI_FOLLOWED_BY_CANCEL_TLBI_FOLLOWED_BY_TLBI_OF_SAME_TXNID_FOLLOWED_BY_SYNC_FOLLOWED_BY_CANCEL_SYNC_FOLLOWED_BY_SYNC_OF_SAME_TXNID_PATTERN_SEQ

10_4

`define SVT_CHI_TRACE_TAG_WIDTH

`define SVT_CHI_TRANSACTION_EXCEPTION_LIST_MAX_NUM_EXCEPTIONS

This value is used by the svt_chi_transaction_exception_list constructor to define the initial value for svt_exception_list :: max_num_exceptions. This field is used by the exception list to define the maximum number of exceptions which can be generated for a single transaction. The user testbench can override this constant value to define a different maximum value for use by all svt_chi_transaction_exception_list instances or can change the value of the svt_exception_list :: max_num_exceptions field directly to define a different maximum value for use by that svt_chi_transaction_exception_list instance.

`define SVT_CHI_TRANSACTION_INTERLEAVE_RANDOM_BLOCK

`define SVT_CHI_TRANSACTION_IS_RESP_OK ( xact )

(
  (
    (xact.get_semantic() == SVT_CHI_WRITE_TYPE_SEMANTIC) &&
    (xact.req_status == svt_chi_transaction::ACCEPT ) &&
    (((xact.cfg.exclusive_access_enable == 1) && (xact.is_exclusive) &&
     (xact.get_resperr_status(svt_chi_transaction::EXCLUSIVE_OKAY,0))) ||
     (((!xact.cfg.exclusive_access_enable) || !(xact.is_exclusive)) &&
     xact.get_resperr_status(svt_chi_transaction::NORMAL_OKAY,0)))
  ) ||
  (
    (xact.get_semantic() == SVT_CHI_READ_TYPE_SEMANTIC) &&
    (xact.req_status == svt_chi_transaction::ACCEPT ) &&
    ((
      (xact.cfg.exclusive_access_enable == 1) && (xact.is_exclusive) &&
      (
       (xact.get_resperr_status(svt_chi_transaction::EXCLUSIVE_OKAY,0))
       `ifdef SVT_CHI_ISSUE_E_ENABLE
       ||((xact.xact_type == svt_chi_transaction::READPREFERUNIQUE || xact.xact_type == svt_chi_transaction::MAKEREADUNIQUE) && (xact.get_resperr_status(svt_chi_transaction::NORMAL_OKAY,0)))
       `endif
      )
     ) ||
     (((!xact.cfg.exclusive_access_enable) || !(xact.is_exclusive)) &&
     xact.get_resperr_status(svt_chi_transaction::NORMAL_OKAY,0)))
  )
)

`define SVT_CHI_TXDATFLITPEND_VALID_REF

`define SVT_CHI_TXLA_ACTIVATE_STATE

`define SVT_CHI_TXLA_DEACTIVATE_STATE

`define SVT_CHI_TXLA_REQ_ASSERTION_MAX_DELAY

250

Max delay value for the assertion of TXLINKACTIVEREQ

`define SVT_CHI_TXLA_REQ_ASSERTION_MIN_DELAY

Min delay value for the assertion of TXLINKACTIVEREQ

`define SVT_CHI_TXLA_REQ_DEASSERTION_MAX_DELAY

250

Max delay value for the deassertion of TXLINKACTIVEREQ

`define SVT_CHI_TXLA_REQ_DEASSERTION_MIN_DELAY

Min delay value for the deassertion of TXLINKACTIVEREQ

`define SVT_CHI_TXLA_RUN_STATE

`define SVT_CHI_TXLA_STOP_STATE

Used to indicate the status of the TX LINKACTIVE Interface state machine.

`define SVT_CHI_TXN_ID_WIDTH