| Macros | |
|---|---|
|
`AMIQ_ETH_AARP = 16'h80F3
AppleTalk Address Resolution Protocol (AARP) |
|
|
`AMIQ_ETH_ADDRESS_WIDTH = 48
Width of the "Address" fields |
|
|
`AMIQ_ETH_APPLE_TALK = 16'h809B
AppleTalk (Ethertalk) |
|
|
`AMIQ_ETH_ARP = 16'h0806
Address Resolution Protocol (ARP) |
|
|
`AMIQ_ETH_ARP_HLEN_WIDTH = 8
Hardware length (HLEN) |
|
|
`AMIQ_ETH_ARP_HTYPE_WIDTH = 16
Hardware type (HTYPE) |
|
|
`AMIQ_ETH_ARP_OPER_REPLY = 2
The value of Operation field in ARP packet for Reply |
|
|
`AMIQ_ETH_ARP_OPER_REQUEST = 1
The value of Operation field in ARP packet for Request |
|
|
`AMIQ_ETH_ARP_OPER_WIDTH = 16
Operation |
|
|
`AMIQ_ETH_ARP_PLEN_WIDTH = 8
Protocol length (PLEN) |
|
|
`AMIQ_ETH_ARP_PTYPE_WIDTH = 16
Protocol type (PTYPE) |
|
|
`AMIQ_ETH_ARP_SHA_WIDTH = 48
Sender hardware address (SHA) |
|
|
`AMIQ_ETH_ARP_SPA_WIDTH = 32
Sender protocol address (SPA) |
|
|
`AMIQ_ETH_ARP_THA_WIDTH = 48
Target hardware address (THA) |
|
|
`AMIQ_ETH_ARP_TPA_WIDTH = 32
Target protocol address (TPA) |
|
|
`AMIQ_ETH_ATA_OVER_ETHERNET = 16'h88A2
ATA over Ethernet |
|
|
`AMIQ_ETH_CFM_OAM = 16'h8902
IEEE 802.1ag Connectivity Fault Management (CFM) Protocol / ITU-T Recommendation Y.1731 (OAM) |
|
|
`AMIQ_ETH_COBRANET = 16'h8819
CobraNet |
|
|
`AMIQ_ETH_CRC32_CCITT_SEED = 32'hFFFFFFFF
Seed for computing CRC32 |
|
|
`AMIQ_ETH_DATA_WIDTH = 8
Width of the basic unit in the "Data" field |
|
|
`AMIQ_ETH_DECNET_PHASE_IV = 16'h6003
DECnet Phase IV |
|
|
`AMIQ_ETH_DEFAULT_MIN_FRAME_SIZE = 64
Default minimum frame size |
|
|
`AMIQ_ETH_DEFAULT_SNAP_PACKET_CTL = 8'h03
Default value for CTL field in SNAP packet |
|
|
`AMIQ_ETH_DEFAULT_SNAP_PACKET_DSAP = 8'hAA
Default value for DSAP field in SNAP packet |
|
|
`AMIQ_ETH_DEFAULT_SNAP_PACKET_SSAP = 8'hAA
Default value for SSAP field in SNAP packet |
|
|
`AMIQ_ETH_EAP_OVER_LAN = 16'h888E
EAP over LAN (IEEE 802.1X) |
|
|
`AMIQ_ETH_ETHERCAT = 16'h88A4
EtherCAT Protocol |
|
|
`AMIQ_ETH_ETHERNET_CONFIGURATION_TESTING_DATA_MAX = 1496
Ethernet Configuration Testing packet max data |
|
|
`AMIQ_ETH_ETHERNET_CONFIGURATION_TESTING_DATA_MIN = 42
Ethernet Configuration Testing packet min data |
|
|
`AMIQ_ETH_ETHERNET_CONFIGURATION_TESTING_FORWARD_FUNCTION = 2
Ethernet Configuration Testing packet forward function |
|
|
`AMIQ_ETH_ETHERNET_CONFIGURATION_TESTING_FUNCTION_WIDTH = 16
Ethernet Configuration Testing packet function width |
|
|
`AMIQ_ETH_ETHERNET_CONFIGURATION_TESTING_PROTOCOL = 16'h9000
Ethernet Configuration Testing Protocol |
|
|
`AMIQ_ETH_ETHERNET_CONFIGURATION_TESTING_REPLY_FUNCTION = 1
Ethernet Configuration Testing packet reply function |
|
|
`AMIQ_ETH_ETHERNET_CONFIGURATION_TESTING_SKIPCOUNT_WIDTH = 16
Ethernet Configuration Testing packet skipcount width |
|
|
`AMIQ_ETH_EXTENSION_WIDTH = 1
Width of the basic unit in the "Extensions" field |
|
|
`AMIQ_ETH_FCOE = 16'h8906
Fibre Channel over Ethernet (FCoE) |
|
|
`AMIQ_ETH_FCOE_EOF_WIDTH = 8
FCOE packet width of "EOF" field |
|
|
`AMIQ_ETH_FCOE_EOFa = 8'h50
Numerical value of "EOF" field for literal "EOFa" value |
|
|
`AMIQ_ETH_FCOE_EOFdt = 0x46
Numerical value of "EOF" field for literal "EOFdt" value |
|
|
`AMIQ_ETH_FCOE_EOFdti = 0x4E
Numerical value of "EOF" field for literal "EOFdti" value |
|
|
`AMIQ_ETH_FCOE_EOFn = 8'h41
Numerical value of "EOF" field for literal "EOFn" value |
|
|
`AMIQ_ETH_FCOE_EOFni = 8'h49
Numerical value of "EOF" field for literal "EOFni" value |
|
|
`AMIQ_ETH_FCOE_EOFrt = 0x44
Numerical value of "EOF" field for literal "EOFrt" value |
|
|
`AMIQ_ETH_FCOE_EOFrti = 0x4F
Numerical value of "EOF" field for literal "EOFrti" value |
|
|
`AMIQ_ETH_FCOE_EOFt = 8'h42
Numerical value of "EOF" field for literal "EOFt" value |
|
|
`AMIQ_ETH_FCOE_FC_FRAME_CRC_SIZE_IN_BYTES = 4
FCOE packet CRC size in bytes |
|
|
`AMIQ_ETH_FCOE_FC_FRAME_SIZE_MAX = 2180
FCOE packet maximum value of the "FC Frame Size" field |
|
|
`AMIQ_ETH_FCOE_FC_FRAME_SIZE_MIN = 28
FCOE packet minimum value of the "FC Frame Size" field |
|
|
`AMIQ_ETH_FCOE_INIT = 16'h8914
FCoE Initialization Protocol |
|
|
`AMIQ_ETH_FCOE_RESERVED_AFTER_EOF_SIZE = 24
FCOE packet value of "Reserved Before EOF size" field |
|
|
`AMIQ_ETH_FCOE_RESERVED_BEFORE_SOF_SIZE = 100
FCOE packet value of "Reserved Before SOF size" field |
|
|
`AMIQ_ETH_FCOE_SOF_WIDTH = 8
FCOE packet width of "SOF" field |
|
|
`AMIQ_ETH_FCOE_SOFc4 = 8'h39
Numerical value of "SOF" field for literal "SOFc4" value |
|
|
`AMIQ_ETH_FCOE_SOFf = 8'h28
Numerical value of "SOF" field for literal "SOFf" value |
|
|
`AMIQ_ETH_FCOE_SOFi2 = 8'h2D
Numerical value of "SOF" field for literal "SOFi2" value |
|
|
`AMIQ_ETH_FCOE_SOFi3 = 8'h2E
Numerical value of "SOF" field for literal "SOFi3" value |
|
|
`AMIQ_ETH_FCOE_SOFi4 = 8'h29
Numerical value of "SOF" field for literal "SOFi4" value |
|
|
`AMIQ_ETH_FCOE_SOFn2 = 8'h35
Numerical value of "SOF" field for literal "SOFn2" value |
|
|
`AMIQ_ETH_FCOE_SOFn3 = 8'h36
Numerical value of "SOF" field for literal "SOFn3" value |
|
|
`AMIQ_ETH_FCOE_SOFn4 = 8'h31
Numerical value of "SOF" field for literal "SOFn4" value |
|
|
`AMIQ_ETH_FCOE_VERSION_WIDTH = 4
FCOE packet width of "Version" field |
|
|
`AMIQ_ETH_FCS_WIDTH = 32
Width of the "Frame Check Sequence" field |
|
|
`AMIQ_ETH_FIELD_SEPARATOR = ", "
The field separator when printing a packet |
|
|
`AMIQ_ETH_GROUP_ADDRESS_MASK = 48'hFEFFFFFFFFFF
Ethernet Configuration Testing Source Address Mask used to avoid Source Address to be a group address |
|
|
`AMIQ_ETH_HOMEPLUG = 16'h887B
HomePlug 1.0 MME |
|
|
`AMIQ_ETH_HOMEPLUG_AV_MME = 16'h88E1
HomePlug AV MME |
|
|
`AMIQ_ETH_HSR = 16'h892F
High-availability Seamless Redundancy (HSR) |
|
|
`AMIQ_ETH_HSR_PATH_WIDTH = 4
HSR Standard packet width of the "Path" field |
|
|
`AMIQ_ETH_HSR_STANDARD_LPDU_MAX = 1500
HSR Standard packet maximum value of the "LPDU" field |
|
|
`AMIQ_ETH_HSR_STANDARD_LPDU_MIN = 40
HSR Standard packet minimum value of the "LPDU" field |
|
|
`AMIQ_ETH_HSR_STANDARD_PROTOCOL_WIDTH = 16
HSR Standard packet width of the "Protocol" field |
|
|
`AMIQ_ETH_HSR_STANDARD_SEQ_WIDTH = 16
HSR Standard packet width of the "Seq" field |
|
|
`AMIQ_ETH_HSR_STANDARD_SIZE_WIDTH = 12
HSR Standard packet width of the "Size" field |
|
|
`AMIQ_ETH_IETF_TRILL = 16'h22F3
IETF TRILL Protocol |
|
|
`AMIQ_ETH_IPV4 = 16'h0800
Internet Protocol version 4 (IPv4) |
|
|
`AMIQ_ETH_IPV4_HEADER_CHECKSUM_WIDTH = 16
IPV4 packet Checksum width |
|
|
`AMIQ_ETH_IPV4_HEADER_DESTINATION_IP_ADDRESS_WIDTH = 32
IPV4 packet Destination IP address width |
|
|
`AMIQ_ETH_IPV4_HEADER_DSCP_WIDTH = 6
IPV4 packet DSCP (Differentiated Services Code Point) width |
|
|
`AMIQ_ETH_IPV4_HEADER_ECN_WIDTH = 2
IPV4 packet ECN (Explicit Congestion Notification) width |
|
|
`AMIQ_ETH_IPV4_HEADER_FLAGS_WIDTH = 3
IPV4 packet Flags width |
|
|
`AMIQ_ETH_IPV4_HEADER_FRAGMENT_OFFSET_WIDTH = 13
IPV4 packet Fragment Offset width |
|
|
`AMIQ_ETH_IPV4_HEADER_IDENTIFICATION_WIDTH = 16
IPV4 packet Identification width |
|
|
`AMIQ_ETH_IPV4_HEADER_IHL_WIDTH = 4
IPV4 packet IHL (Internet Header Length) width |
|
|
`AMIQ_ETH_IPV4_HEADER_OPTION_WIDTH = 32
IPV4 packet Option width |
|
|
`AMIQ_ETH_IPV4_HEADER_PROTOCOL_WIDTH = 8
IPV4 packet Protocol width |
|
|
`AMIQ_ETH_IPV4_HEADER_SOURCE_IP_ADDRESS_WIDTH = 32
IPV4 packet Source IP address width |
|
|
`AMIQ_ETH_IPV4_HEADER_TOTAL_LENGTH_WIDTH = 16
IPV4 packet Total Length width |
|
|
`AMIQ_ETH_IPV4_HEADER_TTL_WIDTH = 8
IPV4 packet TTL (Time To Live) width |
|
|
`AMIQ_ETH_IPV4_HEADER_VERSION_VALUE = 4
IPV4 packet version value |
|
|
`AMIQ_ETH_IPV4_HEADER_VERSION_WIDTH = 4
IPV4 packet version width |
|
|
`AMIQ_ETH_IPV4_REQUIRED_REASSEMBLE_LENGTH = 576
The largest datagram that any host is required to be able to reassemble |
|
|
`AMIQ_ETH_IPV6 = 16'h86DD
Internet Protocol Version 6 (IPv6) |
|
|
`AMIQ_ETH_IPX_1 = 16'h8137
IPX 1 |
|
|
`AMIQ_ETH_IPX_2 = 16'h8138
IPX 2 |
|
|
`AMIQ_ETH_JUMBO_CLIENT_DATA_SIZE_WIDTH = 32
Jumbo packet client data size width |
|
|
`AMIQ_ETH_JUMBO_FRAMES = 16'h8870
Jumbo Frames |
|
|
`AMIQ_ETH_LENGTH_TYPE_WIDTH = 16
Width of the "Length/Type" field |
|
|
`AMIQ_ETH_LLDP = 16'h88CC
Link Layer Discovery Protocol (LLDP) |
|
|
`AMIQ_ETH_LLT_FOR_CLUSTER_SERVER = 16'hCAFE
Veritas Low Latency Transport (LLT) for Veritas Cluster Server |
|
|
`AMIQ_ETH_MAC_CONTROL = 16'h8808
Ethernet flow control |
|
|
`AMIQ_ETH_MAC_SECURITY = 16'h88E5
MAC security (IEEE 802.1AE) |
|
|
`AMIQ_ETH_MAGIC_PACKET_SYNCH_STREAM = 48'hFFFFFFFFFFFF
Default magic packet pattern which identifies the target address |
|
|
`AMIQ_ETH_MAGIC_PACKET_SYNCH_STREAM_WIDTH = 48
Width of the magic packet pattern which identifies the target address |
|
|
`AMIQ_ETH_MAGIC_PACKET_TARGET_MAC_REPETITIONS = 6
The number of times the target address is repeated in the magic packet |
|
|
`AMIQ_ETH_MAX_JUMBO_PAYLOAD_SIZE = 9000
Maximum payload length of the Jumbo frame, in bytes |
|
|
`AMIQ_ETH_MEDIA_REDUNDANCY = 16'h88E3
Media Redundancy Protocol (IEC62439-2) |
|
|
`AMIQ_ETH_MINIMUM_HEADER_LENGTH_IN_BITS
Minimum header length in bits of the Ethernet frame |
|
|
`AMIQ_ETH_MINIMUM_HEADER_LENGTH_IN_BYTES
Minimum header length in bytes of the Ethernet frame |
|
|
`AMIQ_ETH_MINIMUM_HEADER_LENGTH_IN_WORDS
Minimum header length in words of the Ethernet frame |
|
|
`AMIQ_ETH_MIN_JUMBO_PAYLOAD_SIZE = 1501
Minimum payload length of the Jumbo frame, in bytes |
|
|
`AMIQ_ETH_MPLS_MULTICAST = 16'h8848
MPLS multicast |
|
|
`AMIQ_ETH_MPLS_UNICAST = 16'h8847
MPLS unicast |
|
|
`AMIQ_ETH_PACKET_ARP_CODE = 32'h0000_0009
The code of the ARP packet used to identify the information in generic payload |
|
|
`AMIQ_ETH_PACKET_ETHERNET_CONFIGURATION_TESTING_CODE = 32'h0000_0006
The code of the ethernet configuration testing packet used to identify the information in generic payload |
|
|
`AMIQ_ETH_PACKET_FCOE_CODE = 32'h0000_000A
The code of the fcoe packet used to identify the information in generic payload |
|
|
`AMIQ_ETH_PACKET_HSR_STANDARD_CODE = 32'h0000_0008
The code of the hsr packet used to identify the information in generic payload |
|
|
`AMIQ_ETH_PACKET_IPV4_CODE = 32'h0000_0007
The code of the IPV4 packet used to identify the information in generic payload |
|
|
`AMIQ_ETH_PACKET_JUMBO_CODE = 32'h0000_0001
The code of the jumbo packet used to identify the information in generic payload |
|
|
`AMIQ_ETH_PACKET_LENGTH_CODE = 32'h0000_0005
The code of the length packet used to identify the information in generic payload |
|
|
`AMIQ_ETH_PACKET_MAGIC_CODE = 32'h0000_0000
The code of the magic packet used to identify the information in generic payload |
|
|
`AMIQ_ETH_PACKET_PAUSE_CODE = 32'h0000_0003
The code of the pause packet used to identify the information in generic payload |
|
|
`AMIQ_ETH_PACKET_PFC_PAUSE_CODE = 32'h0000_0004
The code of the pfc pause packet used to identify the information in generic payload |
|
|
`AMIQ_ETH_PACKET_PTP_CODE = 32'h0000_000C
The code of the PTP packet used to identify the information in generic payload |
|
|
`AMIQ_ETH_PACKET_SNAP_CODE = 32'h0000_0002
The code of the snap packet used to identify the information in generic payload |
|
|
`AMIQ_ETH_PACK_FOR_PCAP(DATA, ARRAY)
|
|
|
`AMIQ_ETH_PAUSE_OPCODE = `AMIQ_ETH_PAUSE_OPCODE_WIDTH'h0001
Ethernet Pause packet opcode |
|
|
`AMIQ_ETH_PAUSE_OPCODE_WIDTH = 16
Ethernet Pause packet width of the "Opcode" field |
|
|
`AMIQ_ETH_PAUSE_PACKET_DESTINATION_ADDRESS = `AMIQ_ETH_ADDRESS_WIDTH'h0180C2000001
Ethernet Pause packet Destination Address |
|
|
`AMIQ_ETH_PAUSE_PARAMETER_MAX = `AMIQ_ETH_PAUSE_PARAMETER_WIDTH'hFFFF
Ethernet Pause packet maximum value of the "Parameter" field |
|
|
`AMIQ_ETH_PAUSE_PARAMETER_MIN = `AMIQ_ETH_PAUSE_PARAMETER_WIDTH'h0000
Ethernet Pause packet minimum value of the "Parameter" field |
|
|
`AMIQ_ETH_PAUSE_PARAMETER_WIDTH = 16
Ethernet Pause packet width of the "Parameter" field |
|
|
`AMIQ_ETH_PAYLOAD_SIZE_MAX = 1500
Ethernet packet maximum payload size |
|
|
`AMIQ_ETH_PAYLOAD_SIZE_MIN = 46
Ethernet packet minimum payload size |
|
|
`AMIQ_ETH_PFC_CLASS_ENABLE_VECTOR_MAX = `AMIQ_ETH_PFC_CLASS_ENABLE_VECTOR_WIDTH'h00FF
Ethernet PFC packet maximum value of the "Class Enable Vector" field |
|
|
`AMIQ_ETH_PFC_CLASS_ENABLE_VECTOR_MIN = `AMIQ_ETH_PFC_CLASS_ENABLE_VECTOR_WIDTH'h0000
Ethernet PFC packet minimum value of the "Class Enable Vector" field |
|
|
`AMIQ_ETH_PFC_CLASS_ENABLE_VECTOR_WIDTH = 16
Ethernet PFC packet width of the "Class Enable Vector" field |
|
|
`AMIQ_ETH_PFC_NUMBER_OF_PARAMETERS = 8
Ethernet PFC packet number of parameters |
|
|
`AMIQ_ETH_PFC_OPCODE = `AMIQ_ETH_PFC_OPCODE_WIDTH'h0101
Ethernet PFC packet opcode |
|
|
`AMIQ_ETH_PFC_OPCODE_WIDTH = 16
Ethernet PFC packet width of the "Opcode" field |
|
|
`AMIQ_ETH_PFC_PACKET_DESTINATION_ADDRESS = `AMIQ_ETH_ADDRESS_WIDTH'h0180C2000001
Ethernet PFC packet Destination Address |
|
|
`AMIQ_ETH_PFC_PARAMETER_MAX = `AMIQ_ETH_PAUSE_PARAMETER_WIDTH'hFFFF
Ethernet PFC packet maximum value of the "Parameter" field |
|
|
`AMIQ_ETH_PFC_PARAMETER_MIN = `AMIQ_ETH_PAUSE_PARAMETER_WIDTH'h0000
Ethernet PFC packet minimum value of the "Parameter" field |
|
|
`AMIQ_ETH_PFC_PARAMETER_WIDTH = 16
Ethernet PFC packet width of the "Parameter" field |
|
|
`AMIQ_ETH_POWERLINK = 16'h88AB
Ethernet Powerlink |
|
|
`AMIQ_ETH_PPPOE_DISCOVERY = 16'h8863
PPPoE Discovery Stage |
|
|
`AMIQ_ETH_PPPOE_SESSION = 16'h8864
PPPoE Session Stage |
|
|
`AMIQ_ETH_PREAMBLE_WIDTH = 56
Width of the Preamble field |
|
|
`AMIQ_ETH_PROFINET = 16'h8892
PROFINET Protocol |
|
|
`AMIQ_ETH_PROVIDER_BRIDGING_SHORT_PATH_BRIDGING = 16'h88A8
Provider Bridging (IEEE 802.1ad) & Shortest Path Bridging IEEE 802.1aq |
|
|
`AMIQ_ETH_PTP = 16'h88F7
Precision Time Protocol (PTP) over Ethernet (IEEE 1588) |
|
|
`AMIQ_ETH_PTP_ANNOUNCEMESSAGE = 11
Numerical value of "Message Type" field for literal "PTP_AnnounceMessage" value |
|
|
`AMIQ_ETH_PTP_ANNOUNCE_MESSAGE_CURRENT_UTC_OFFSET_WIDTH = 16
PTP packet width of the "Current UTC Offset" field from "Announce Message" body |
|
|
`AMIQ_ETH_PTP_ANNOUNCE_MESSAGE_GRANDMASTER_CLOCK_QUALITY_WIDTH = 32
PTP packet width of the "Clock Quality" field from "Announce Message" body |
|
|
`AMIQ_ETH_PTP_ANNOUNCE_MESSAGE_GRANDMASTER_IDENTITY_WIDTH = 64
PTP packet width of the "Grandmaster Identity" field from "Announce Message" body |
|
|
`AMIQ_ETH_PTP_ANNOUNCE_MESSAGE_GRANDMASTER_PRIORITY_1_WIDTH = 8
PTP packet width of the "Priority 1" field from "Announce Message" body |
|
|
`AMIQ_ETH_PTP_ANNOUNCE_MESSAGE_GRANDMASTER_PRIORITY_2_WIDTH = 8
PTP packet width of the "Priority 2" field from "Announce Message" body |
|
|
`AMIQ_ETH_PTP_ANNOUNCE_MESSAGE_RESERVED_WIDTH = 8
PTP packet width of the "Reserved" field from "Announce Message" body |
|
|
`AMIQ_ETH_PTP_ANNOUNCE_MESSAGE_STEPS_REMOVED_WIDTH = 16
PTP packet width of the "Steps Removed" field from "Announce Message" body |
|
|
`AMIQ_ETH_PTP_ANNOUNCE_MESSAGE_TIME_SOURCE_WIDTH = 8
PTP packet width of the "Time Source" field from "Announce Message" body |
|
|
`AMIQ_ETH_PTP_CONTROL_FIELD_WIDTH = 8
PTP packet width of the "Control Field" field |
|
|
`AMIQ_ETH_PTP_CORRECTION_FIELD_WIDTH = 64
PTP packet width of the "Correction Field" field |
|
|
`AMIQ_ETH_PTP_DELAY_REQMESSAGE = 1
Numerical value of "Message Type" field for literal "PTP_Delay_ReqMessage" value |
|
|
`AMIQ_ETH_PTP_DELAY_REQMESSAGE_CTRL = 1
Numerical value of "Control Field" field for literal "PTP_Delay_ReqMessage_ctrl" value |
|
|
`AMIQ_ETH_PTP_DELAY_RESPMESSAGE = 9
Numerical value of "Message Type" field for literal "PTP_Delay_RespMessage" value |
|
|
`AMIQ_ETH_PTP_DELAY_RESPMESSAGE_CTRL = 3
Numerical value of "Control Field" field for literal "PTP_Delay_RespMessage_ctrl" value |
|
|
`AMIQ_ETH_PTP_DOMAIN_NUMBER_WIDTH = 8
PTP packet width of the "Domain Number" field |
|
|
`AMIQ_ETH_PTP_FLAGS_WIDTH = 16
PTP packet width of the "Flags" field |
|
|
`AMIQ_ETH_PTP_FOLLOW_UPMESSAGE = 8
Numerical value of "Message Type" field for literal "PTP_Follow_UpMessage" value |
|
|
`AMIQ_ETH_PTP_FOLLOW_UPMESSAGE_CTRL = 2
Numerical value of "Control Field" field for literal "PTP_Follow_UpMessage_ctrl" value |
|
|
`AMIQ_ETH_PTP_IN_802_1_AS = 1
Numerical value of "Transport Specific" field for literal "PTP_in_802_1_as" value |
|
|
`AMIQ_ETH_PTP_IN_IEEE1588 = 0
Numerical value of "Transport Specific" field for literal "PTP_in_IEEE1588" value |
|
|
`AMIQ_ETH_PTP_LOG_MESSAGE_WIDTH = 8
PTP packet width of the "Log Message" field |
|
|
`AMIQ_ETH_PTP_MANAGEMENTMESSAGE = 13
Numerical value of "Message Type" field for literal "PTP_ManagementMessage" value |
|
|
`AMIQ_ETH_PTP_MANAGEMENTMESSAGE_CTRL = 4
Numerical value of "Control Field" field for literal "PTP_ManagementMessage_ctrl" value |
|
|
`AMIQ_ETH_PTP_MESSAGE_LENGTH_WIDTH = 16
PTP packet width of the "Message Length" field |
|
|
`AMIQ_ETH_PTP_MESSAGE_TYPE_WIDTH = 4
PTP packet width of the "Message Type" field |
|
|
`AMIQ_ETH_PTP_ORIGIN_TIMESTAMP_SIZE = 10
PTP packet size of "Origin Timestamp" field |
|
|
`AMIQ_ETH_PTP_PDELAY_REQMESSAGE = 2
Numerical value of "Message Type" field for literal "PTP_Pdelay_ReqMessage" value |
|
|
`AMIQ_ETH_PTP_PDELAY_RESPMESSAGE = 3
Numerical value of "Message Type" field for literal "PTP_Pdelay_RespMessage" value |
|
|
`AMIQ_ETH_PTP_PDELAY_RESP_FOLLOW_UPMESSAGE = 10
Numerical value of "Message Type" field for literal "PTP_Pdelay_Resp_Follow_UpMessage" value |
|
|
`AMIQ_ETH_PTP_RESERVED_1_WIDTH = 4
PTP packet width of the "Reserved " field |
|
|
`AMIQ_ETH_PTP_RESERVED_2_WIDTH = 8
PTP packet width of the "Reserved" field |
|
|
`AMIQ_ETH_PTP_RESERVED_3_WIDTH = 32
PTP packet width of the "Reserved" field |
|
|
`AMIQ_ETH_PTP_SEQUENCE_ID_WIDTH = 16
PTP packet width of the "Sequence ID" field |
|
|
`AMIQ_ETH_PTP_SIGNALLINGMESSAGE = 12
Numerical value of "Message Type" field for literal "PTP_SignallingMessage" value |
|
|
`AMIQ_ETH_PTP_SOURCE_PORT_IDENTITY_SIZE = 10
PTP packet size of "Source Port Identity" field |
|
|
`AMIQ_ETH_PTP_SYNCMESSAGE = 0
Numerical value of "Message Type" field for literal "PTP_SyncMessage" value |
|
|
`AMIQ_ETH_PTP_SYNCMESSAGE_CTRL = 0
Numerical value of "Control Field" field for literal "PTP_SyncMessage_ctrl" value |
|
|
`AMIQ_ETH_PTP_TRANSPORT_SPECIFIC_WIDTH = 4
PTP packet width of the "Transport Specific" field |
|
|
`AMIQ_ETH_PTP_VERSION_WIDTH = 4
PTP packet width of the "Version" field |
|
|
`AMIQ_ETH_QNX_QNET = 16'h8204
QNX Qnet |
|
|
`AMIQ_ETH_Q_IN_Q = 16'h9100
Q-in-Q |
|
|
`AMIQ_ETH_RARP = 16'h8035
Reverse Address Resolution Protocol |
|
|
`AMIQ_ETH_ROCE = 16'h8915
RDMA over Converged Ethernet (RoCE) |
|
|
`AMIQ_ETH_SCSI_OVER_ETHERNET = 16'h889A
HyperSCSI (SCSI over Ethernet) |
|
|
`AMIQ_ETH_SERCOS_III = 16'h88CD
SERCOS III |
|
|
`AMIQ_ETH_SFD_WIDTH = 8
Width of the "Start Frame Delimiter" field |
|
|
`AMIQ_ETH_SLOW_PROTOCOLS = 16'h8809
Slow Protocols (IEEE 802.3) |
|
|
`AMIQ_ETH_SNAP_PROTOCOL_IDENTIFIER_WIDTH = 40
Width of the "Protocol Identifier" field from SNAP packet |
|
|
`AMIQ_ETH_VLAN_TAGGED_FRAME_SHORT_PATH_BRIDGING = 16'h8100
VLAN-tagged frame (IEEE 802.1Q) & Shortest Path Bridging IEEE 802.1aq |
|
|
`AMIQ_ETH_WAKE_ON_LAN = 16'h0842
Wake-on-LAN |
|
|
`AMIQ_ETH_WIRESHARK_FILE = "wireshark_file"
|
|
|
`M_FIELD_QDA_ENUM(TYPE, T, ARG, FLAG)
|
|
|
`M_UVM_ARRAY_RESIZE(ARG, VAL)
|
|
|
`M_UVM_FIELD_DATA_AA_enum_key(KEY, ARG, FLAG)
|
|
|
`M_UVM_FIELD_DATA_AA_generic(TYPE, KEY, ARG, FLAG)
|
|
|
`M_UVM_FIELD_DATA_AA_int_key(KEY, ARG, FLAG)
M_UVM_FIELD_DATA_AA_int_int |
|
|
`M_UVM_FIELD_DATA_AA_int_string(ARG, FLAG)
|
|
|
`M_UVM_FIELD_DATA_AA_object_int(ARG, FLAG)
|
|
|
`M_UVM_FIELD_DATA_AA_object_string(ARG, FLAG)
|
|
|
`M_UVM_FIELD_DATA_AA_string_string(ARG, FLAG)
|
|
|
`M_UVM_FIELD_QDA_INT(TYPE, ARG, FLAG)
|
|
|
`M_UVM_FIELD_QDA_OBJECT(TYPE, ARG, FLAG)
|
|
|
`M_UVM_FIELD_QDA_STRING(TYPE, ARG, FLAG)
|
|
|
`M_UVM_FIELD_SET_AA_INT_ENUMTYPE(INDEX_TYPE, ARRAY_TYPE, ARRAY, RHS, FLAG)
|
|
|
`M_UVM_FIELD_SET_AA_INT_TYPE(INDEX_TYPE, ARRAY_TYPE, ARRAY, RHS, FLAG)
|
|
|
`M_UVM_FIELD_SET_AA_OBJECT_TYPE(INDEX_TYPE, ARRAY, FLAG)
|
|
|
`M_UVM_FIELD_SET_AA_TYPE(INDEX_TYPE, ARRAY_TYPE, ARRAY, RHS, FLAG)
|
|
|
`M_UVM_QUEUE_RESIZE(ARG, VAL)
|
|
|
`M_UVM_SARRAY_RESIZE(ARG, VAL)
|
|
|
`TLM_IFS_SVH [empty]
|
|
|
`UVMC_MAX_WORDS = (`UVM_PACKER_MAX_BYTES/4)
Number of 32-bits words used to transfer packed object data |
|
|
`UVMC_PKG__SVH [empty]
|
|
|
`UVM_BASE_SVH [empty]
|
|
|
`UVM_BLOCKING_GET_IMP(imp, TYPE, arg)
|
|
|
`UVM_BLOCKING_GET_IMP_SFX(SFX, imp, TYPE, arg)
|
|
|
`UVM_BLOCKING_GET_PEEK_IMP(imp, TYPE, arg)
|
|
|
`UVM_BLOCKING_PEEK_IMP(imp, TYPE, arg)
|
|
|
`UVM_BLOCKING_PEEK_IMP_SFX(SFX, imp, TYPE, arg)
|
|
|
`UVM_BLOCKING_PUT_IMP(imp, TYPE, arg)
TLM imp implementations |
|
|
`UVM_BLOCKING_PUT_IMP_SFX(SFX, imp, TYPE, arg)
These imps are used in uvm_*_port, uvm_*_export and uvm_*_imp, using suffixes |
|
|
`UVM_BLOCKING_TRANSPORT_IMP(imp, REQ, RSP, req_arg, rsp_arg)
|
|
|
`UVM_BLOCKING_TRANSPORT_IMP_SFX(SFX, imp, REQ, RSP, req_arg, rsp_arg)
|
|
|
`UVM_CALLBACK_SVH [empty]
|
|
|
`UVM_CB_MACROS_SVH [empty]
|
|
|
`UVM_CMDLINE_PROCESSOR_SV [empty]
|
|
|
`UVM_DEFAULT_TIMEOUT = 9200s
The default timeout for simulation, if not overridden by <uvm_root::set_timeout> or <+UVM_TIMEOUT> |
|
|
`UVM_DPI_SVH [empty]
|
|
|
`UVM_EXPORT_COMMON(MASK, TYPE_NAME)
|
|
|
`UVM_FIX_REV = d
|
|
|
`UVM_FIX_REV_STR = `"`UVM_FIX_REV`"
Function- uvmc_init Future automate execution of uvmc_init, which must fork this from initial block |
|
|
`UVM_FIX_REV_d [empty]
|
|
|
`UVM_FIX_VERSION_1_1_d [empty]
|
|
|
`UVM_FUNCTION_ERROR = "TLM interface function not implemented"
|
|
|
`UVM_GET_IMP(imp, TYPE, arg)
|
|
|
`UVM_GET_PEEK_IMP(imp, TYPE, arg)
|
|
|
`UVM_HDL_MAX_WIDTH = 1024
|
|
|
`UVM_HDL__SVH [empty]
|
|
|
`UVM_HEARTBEAT_SVH [empty]
|
|
|
`UVM_IMP_COMMON(MASK, TYPE_NAME, IMP)
|
|
|
`UVM_KIT_DATE = 2014-04-03
|
|
|
`UVM_KIT_VERSION = 13.20-s006
|
|
|
`UVM_LINE_WIDTH = 120
|
|
|
`UVM_MACROS_SVH [empty]
|
|
|
`UVM_MAJOR_REV = 1
|
|
|
`UVM_MAJOR_REV_1 [empty]
|
|
|
`UVM_MAJOR_VERSION_1_1 [empty]
|
|
|
`UVM_MAX_STREAMBITS = 4096
|
|
|
`UVM_MEM_MAM__SV [empty]
|
|
|
`UVM_MESSAGE_DEFINES_SVH [empty]
|
|
|
`UVM_MINOR_REV = 1
|
|
|
`UVM_MINOR_REV_1 [empty]
|
|
|
`UVM_MS_IMP_COMMON(MASK, TYPE_NAME)
|
|
|
`UVM_NAME = CDNS-UVM
Version numbers to be used in creating version strings for printing or programmatic tesing against version numbers |
|
|
`UVM_NONBLOCKING_GET_IMP(imp, TYPE, arg)
|
|
|
`UVM_NONBLOCKING_GET_IMP_SFX(SFX, imp, TYPE, arg)
|
|
|
`UVM_NONBLOCKING_GET_PEEK_IMP(imp, TYPE, arg)
|
|
|
`UVM_NONBLOCKING_PEEK_IMP(imp, TYPE, arg)
|
|
|
`UVM_NONBLOCKING_PEEK_IMP_SFX(SFX, imp, TYPE, arg)
|
|
|
`UVM_NONBLOCKING_PUT_IMP(imp, TYPE, arg)
|
|
|
`UVM_NONBLOCKING_PUT_IMP_SFX(SFX, imp, TYPE, arg)
|
|
|
`UVM_NONBLOCKING_TRANSPORT_IMP(imp, REQ, RSP, req_arg, rsp_arg)
|
|
|
`UVM_NONBLOCKING_TRANSPORT_IMP_SFX(SFX, imp, REQ, RSP, req_arg, rsp_arg)
|
|
|
`UVM_NUM_LINES = 120
|
|
|
`UVM_OBJECTION_SVH [empty]
|
|
|
`UVM_OBJECT_DEFINES_SVH [empty]
|
|
|
`UVM_PACKER_MAX_BYTES = UVM_STREAMBITS
|
|
|
`UVM_PACK_MAX_SIZE = `UVM_PACKER_MAX_BYTES
|
|
|
`UVM_PEEK_IMP(imp, TYPE, arg)
|
|
|
`UVM_PHASE_DEFINES_SVH [empty]
|
|
|
`UVM_PH_TRACE(ID, MSG, PH, VERB)
|
|
|
`UVM_PKG_SV [empty]
Copyright 2007-2011 Mentor Graphics Corporation
Copyright 2007-2010 Cadence Design Systems, Inc.
Copyright 2010-2011 Synopsys, Inc.
All Rights Reserved Worldwide
Licensed under the Apache License, Version 2.0 (the
"License"); you may not use this file except in
compliance with the License. You may obtain a copy of
the License at
|
|
|
`UVM_PORT_COMMON(MASK, TYPE_NAME)
|
|
|
`UVM_PRINTER_DEFINES_SVH [empty]
|
|
|
`UVM_PUT_IMP(imp, TYPE, arg)
|
|
|
`UVM_QUEUE_SVH [empty]
|
|
|
`UVM_REGISTRY_SVH [empty]
|
|
|
`UVM_REG_ADDR_WIDTH = 64
Maximum address width in bits Default value is 64. Used to define the <uvm_reg_addr_t> type. |
|
|
`UVM_REG_BYTENABLE_WIDTH = ((`UVM_REG_DATA_WIDTH-1)/8+1)
Maximum number of byte enable bits
Default value is one per byte in |
|
|
`UVM_REG_CVR_WIDTH = 32
Maximum number of bits in a <uvm_reg_cvr_t> coverage model set. Default value is 32. |
|
|
`UVM_REG_DATA_WIDTH = 64
Maximum data width in bits Default value is 64. Used to define the <uvm_reg_data_t> type. |
|
|
`UVM_REG_MODEL__SV [empty]
|
|
|
`UVM_REPORT_CATCHER_SVH [empty]
|
|
|
`UVM_REPORT_CLIENT_SVH [empty]
|
|
|
`UVM_REPORT_HANDLER_SVH [empty]
|
|
|
`UVM_REPORT_SERVER_SVH [empty]
|
|
|
`UVM_RESOURCE_GET_FCNS(base_type)
When specicializing resources the get_by_name and get_by_type functions must be redefined. The reason is that the version of these functions in the base class (uvm_resource#(T)) returns an object of type uvm_resource#(T). In the specializations we must return an object of the type of the specialization. So, we call the base_class implementation of these functions and then downcast to the subtype. This macro is invokved once in each where a resource specialization is a class defined as:class <resource_specialization> extends uvm_resource#(T)where <resource_specialization> is the name of the derived class. The argument to this macro is T, the type of the uvm_resource#(T) specialization. The class in which the macro is defined must supply a typedef of the specialized class of the form:typedef <resource_specialization> this_subtype;where <resource_specialization> is the same as above. The macro generates the get_by_name() and get_by_type() functions for the specialized resource (i.e. resource subtype). |
|
|
`UVM_SEQ_ITEM_FUNCTION_ERROR = "Sequencer interface function not implemented"
|
|
|
`UVM_SEQ_ITEM_GET_MASK = (1<<7)
|
|
|
`UVM_SEQ_ITEM_GET_NEXT_ITEM_MASK = (1<<0)
|
|
|
`UVM_SEQ_ITEM_HAS_DO_AVAILABLE_MASK = (1<<3)
|
|
|
`UVM_SEQ_ITEM_ITEM_DONE_MASK = (1<<2)
|
|
|
`UVM_SEQ_ITEM_PEEK_MASK = (1<<8)
|
|
|
`UVM_SEQ_ITEM_PULL_IMP(imp, REQ, RSP, req_arg, rsp_arg)
imp definitions |
|
|
`UVM_SEQ_ITEM_PULL_MASK
|
|
|
`UVM_SEQ_ITEM_PUSH_MASK = (`UVM_SEQ_ITEM_PUT_MASK)
|
|
|
`UVM_SEQ_ITEM_PUT_MASK = (1<<6)
|
|
|
`UVM_SEQ_ITEM_PUT_RESPONSE_MASK = (1<<5)
|
|
|
`UVM_SEQ_ITEM_TASK_ERROR = "Sequencer interface task not implemented"
|
|
|
`UVM_SEQ_ITEM_TRY_NEXT_ITEM_MASK = (1<<1)
|
|
|
`UVM_SEQ_ITEM_UNI_PULL_MASK
|
|
|
`UVM_SEQ_ITEM_WAIT_FOR_SEQUENCES_MASK = (1<<4)
|
|
|
`UVM_SEQ_PORT(MASK, TYPE_NAME)
|
|
|
`UVM_TASK_ERROR = "TLM interface task not implemented"
|
|
|
`UVM_TLM_ANALYSIS_MASK = (1<<8)
|
|
|
`UVM_TLM_BLOCKING_GET_MASK = (1<<1)
|
|
|
`UVM_TLM_BLOCKING_GET_PEEK_MASK = (`UVM_TLM_BLOCKING_GET_MASK | `UVM_TLM_BLOCKING_PEEK_MASK)
|
|
|
`UVM_TLM_BLOCKING_MASTER_MASK = (`UVM_TLM_BLOCKING_PUT_MASK | `UVM_TLM_BLOCKING_GET_MASK | `UVM_TLM_BLOCKING_PEEK_MASK | `UVM_TLM_MASTER_BIT_MASK)
|
|
|
`UVM_TLM_BLOCKING_PEEK_MASK = (1<<2)
|
|
|
`UVM_TLM_BLOCKING_PUT_MASK = (1<<0)
Primitive interfaces |
|
|
`UVM_TLM_BLOCKING_SLAVE_MASK = (`UVM_TLM_BLOCKING_PUT_MASK | `UVM_TLM_BLOCKING_GET_MASK | `UVM_TLM_BLOCKING_PEEK_MASK | `UVM_TLM_SLAVE_BIT_MASK)
|
|
|
`UVM_TLM_BLOCKING_TRANSPORT_MASK = (1<<3)
|
|
|
`UVM_TLM_B_MASK = (1<<2)
Define blocking mask onehot assignment = 'b100 |
|
|
`UVM_TLM_B_TRANSPORT_IMP(imp, T, t, delay)
The macro wraps the function b_transport() Execute a blocking transaction. Once this method returns, the transaction is assumed to have been executed. Whether that execution is succesful or not must be indicated by the transaction itself. The callee may modify or update the transaction object, subject to any constraints imposed by the transaction class. The initiator may re-use a transaction object from one call to the next and across calls to b_transport(). The call to b_transport shall mark the first timing point of the transaction. The return from b_transport() shall mark the final timing point of the transaction. The timing annotation argument allows the timing points to be offset from the simulation times at which the task call and return are executed. |
|
|
`UVM_TLM_FIFO_FUNCTION_ERROR = "fifo channel function not implemented"
|
|
|
`UVM_TLM_FIFO_TASK_ERROR = "fifo channel task not implemented"
Copyright 2007-2011 Mentor Graphics Corporation
Copyright 2007-2011 Cadence Design Systems, Inc.
Copyright 2010 Synopsys, Inc.
All Rights Reserved Worldwide
Licensed under the Apache License, Version 2.0 (the
"License"); you may not use this file except in
compliance with the License. You may obtain a copy of
the License at
|
|
|
`UVM_TLM_FUNCTION_ERROR = "TLM-2 interface function not implemented"
Defines Not-Yet-Implemented TLM functions |
|
|
`UVM_TLM_GET_MASK = (`UVM_TLM_BLOCKING_GET_MASK | `UVM_TLM_NONBLOCKING_GET_MASK)
|
|
|
`UVM_TLM_GET_PEEK_MASK = (`UVM_TLM_GET_MASK | `UVM_TLM_PEEK_MASK)
|
|
|
`UVM_TLM_GET_TYPE_NAME(NAME)
|
|
|
`UVM_TLM_IMPS_SVH [empty]
|
|
|
`UVM_TLM_MASTER_BIT_MASK = (1<<9)
|
|
|
`UVM_TLM_MASTER_MASK = (`UVM_TLM_BLOCKING_MASTER_MASK | `UVM_TLM_NONBLOCKING_MASTER_MASK)
|
|
|
`UVM_TLM_NB_BW_MASK = (1<<1)
Define Non blocking backward mask onehot assignment = 'b010 |
|
|
`UVM_TLM_NB_FW_MASK = (1<<0)
Define Non blocking Forward mask onehot assignment = 'b001 |
|
|
`UVM_TLM_NB_TRANSPORT_BW_IMP(imp, T, P, t, p, delay)
Implementation of the backward path. The macro wraps the function called nb_transport_bw(). This function MUST be implemented in the INITIATOR component class. Every call to this method may mark a timing point, including the final timing point, in the execution of the transaction. The timing annotation argument allows the timing point to be offset from the simulation times at which the backward path is used. The final timing point of a transaction may be marked by a call to nb_transport_fw() within |
|
|
`UVM_TLM_NB_TRANSPORT_FW_IMP(imp, T, P, t, p, delay)
The macro wraps the forward path call function nb_transport_fw()
The first call to this method for a transaction marks the initial timing point.
Every call to this method may mark a timing point in the execution of the
transaction. The timing annotation argument allows the timing points
to be offset from the simulation times at which the forward path is used.
The final timing point of a transaction may be marked by a call
to nb_transport_bw() within |
|
|
`UVM_TLM_NONBLOCKING_GET_MASK = (1<<5)
|
|
|
`UVM_TLM_NONBLOCKING_GET_PEEK_MASK = (`UVM_TLM_NONBLOCKING_GET_MASK | `UVM_TLM_NONBLOCKING_PEEK_MASK)
|
|
|
`UVM_TLM_NONBLOCKING_MASTER_MASK = (`UVM_TLM_NONBLOCKING_PUT_MASK | `UVM_TLM_NONBLOCKING_GET_MASK | `UVM_TLM_NONBLOCKING_PEEK_MASK | `UVM_TLM_MASTER_BIT_MASK)
|
|
|
`UVM_TLM_NONBLOCKING_PEEK_MASK = (1<<6)
|
|
|
`UVM_TLM_NONBLOCKING_PUT_MASK = (1<<4)
|
|
|
`UVM_TLM_NONBLOCKING_SLAVE_MASK = (`UVM_TLM_NONBLOCKING_PUT_MASK | `UVM_TLM_NONBLOCKING_GET_MASK | `UVM_TLM_NONBLOCKING_PEEK_MASK | `UVM_TLM_SLAVE_BIT_MASK)
|
|
|
`UVM_TLM_NONBLOCKING_TRANSPORT_MASK = (1<<7)
|
|
|
`UVM_TLM_PEEK_MASK = (`UVM_TLM_BLOCKING_PEEK_MASK | `UVM_TLM_NONBLOCKING_PEEK_MASK)
|
|
|
`UVM_TLM_PUT_MASK = (`UVM_TLM_BLOCKING_PUT_MASK | `UVM_TLM_NONBLOCKING_PUT_MASK)
Combination interfaces |
|
|
`UVM_TLM_SLAVE_BIT_MASK = (1<<10)
|
|
|
`UVM_TLM_SLAVE_MASK = (`UVM_TLM_BLOCKING_SLAVE_MASK | `UVM_TLM_NONBLOCKING_SLAVE_MASK)
|
|
|
`UVM_TLM_TASK_ERROR = "TLM-2 interface task not implemented"
Defines Not-Yet-Implemented TLM tasks |
|
|
`UVM_TLM_TRANSPORT_MASK = (`UVM_TLM_BLOCKING_TRANSPORT_MASK | `UVM_TLM_NONBLOCKING_TRANSPORT_MASK)
|
|
|
`UVM_TRANSPORT_IMP(imp, REQ, RSP, req_arg, rsp_arg)
|
|
|
`UVM_VERSION_1_1 [empty]
Whole version identifiers that can be used in `ifdefs and `ifndefs to do conditional compilation |
|
|
`UVM_VERSION_DEFINES_SVH [empty]
|
|
|
`UVM_VERSION_STRING = `"`UVM_NAME-`UVM_MAJOR_REV.`UVM_MINOR_REV`UVM_FIX_REV (`UVM_KIT_VERSION)`"
When there is a FIX_REV, print as "M.mf" When there is NO FIX_REV, print as "M.m". Fix rev kind of string: |
|
|
`UVM_VERSION_SVH [empty]
|
|
|
`__AMIQ_ETH_DEFINES [empty]
Protection against multiple includes |
|
|
`__AMIQ_ETH_ETHERNET_PROTOCOLS [empty]
Protection against multiple includes |
|
|
`__AMIQ_ETH_PACKET [empty]
Protection against multiple includes |
|
|
`__AMIQ_ETH_PACKET_ARP [empty]
Protection against multiple includes |
|
|
`__AMIQ_ETH_PACKET_ETHERNET_CONFIGURATION_TESTING [empty]
Protection against multiple includes |
|
|
`__AMIQ_ETH_PACKET_ETHER_TYPE [empty]
Protection against multiple includes |
|
|
`__AMIQ_ETH_PACKET_FCOE [empty]
Protection against multiple includes |
|
|
`__AMIQ_ETH_PACKET_HSR_BASE [empty]
Protection against multiple includes |
|
|
`__AMIQ_ETH_PACKET_HSR_STANDARD [empty]
Protection against multiple includes |
|
|
`__AMIQ_ETH_PACKET_IPV4 [empty]
Protection against multiple includes |
|
|
`__AMIQ_ETH_PACKET_JUMBO [empty]
Protection against multiple includes |
|
|
`__AMIQ_ETH_PACKET_LENGTH [empty]
Protection against multiple includes |
|
|
`__AMIQ_ETH_PACKET_MAGIC [empty]
Protection against multiple includes |
|
|
`__AMIQ_ETH_PACKET_PAUSE [empty]
Protection against multiple includes |
|
|
`__AMIQ_ETH_PACKET_PFC_PAUSE [empty]
Protection against multiple includes |
|
|
`__AMIQ_ETH_PACKET_PTP [empty]
Protection against multiple includes |
|
|
`__AMIQ_ETH_PACKET_SNAP [empty]
Protection against multiple includes |
|
|
`__AMIQ_ETH_PCAP_UTIL [empty]
Protection against multiple includes |
|
|
`__AMIQ_ETH_PKG [empty]
Protection against multiple includes |
|
|
`__AMIQ_ETH_TYPES [empty]
Protection against multiple includes |
|
|
`__AMIQ_ETH_VE_CONSUMER [empty]
Protection against multiple includes |
|
|
`__AMIQ_ETH_VE_ENV [empty]
Protection against multiple includes |
|
|
`__AMIQ_ETH_VE_PKG [empty]
Protection against multiple includes |
|
|
`__AMIQ_ETH_VE_PRODUCER [empty]
Protection against multiple includes |
|
|
`__AMIQ_ETH_VE_SCOREBOARD [empty]
Protection against multiple includes |
|
|
`__AMIQ_ETH_VE_TEST_ARP_PACKETS [empty]
Protection against multiple includes |
|
|
`__AMIQ_ETH_VE_TEST_BASIC [empty]
Protection against multiple includes |
|
|
`__AMIQ_ETH_VE_TEST_ETHERNET_CONFIGURATION_TESTING [empty]
Protection against multiple includes |
|
|
`__AMIQ_ETH_VE_TEST_FCOE_PACKETS [empty]
Protection against multiple includes |
|
|
`__AMIQ_ETH_VE_TEST_HSR_STANDARD_PACKETS [empty]
Protection against multiple includes |
|
|
`__AMIQ_ETH_VE_TEST_IPV4_PACKETS [empty]
Protection against multiple includes |
|
|
`__AMIQ_ETH_VE_TEST_JUMBO_PACKETS [empty]
Protection against multiple includes |
|
|
`__AMIQ_ETH_VE_TEST_MAGIC_PACKETS [empty]
Protection against multiple includes |
|
|
`__AMIQ_ETH_VE_TEST_PACKETS [empty]
Protection against multiple includes |
|
|
`__AMIQ_ETH_VE_TEST_PAUSE_PACKETS [empty]
Protection against multiple includes |
|
|
`__AMIQ_ETH_VE_TEST_PFC_PAUSE_PACKETS [empty]
Protection against multiple includes |
|
|
`__AMIQ_ETH_VE_TEST_PTP_PACKETS [empty]
Protection against multiple includes |
|
|
`__AMIQ_ETH_VE_TEST_SNAP_PACKETS [empty]
Protection against multiple includes |
|
|
`__AMIQ_ETH_VE_TOP [empty]
|
|
|
`__UVMC_GET_PORT__
Group C2SV_* The C2SV_*_done methods indicate blocking operation completion to SV from SC. |
|
|
`m_uvm_bottomup_phase(PHASE, COMP, PREFIX)
|
|
|
`m_uvm_component_registry_internal(T, S)
This is needed due to an issue in of passing down strings created by args to lower level macros. |
|
|
`m_uvm_component_registry_param(T)
|
|
|
`m_uvm_get_type_name_func(T)
|
|
|
`m_uvm_object_create_func(T)
|
|
|
`m_uvm_object_registry_internal(T, S)
This is needed due to an issue in of passing down strings created by args to lower level macros. |
|
|
`m_uvm_object_registry_param(T)
|
|
|
`m_uvm_record_int(ARG, FLAG)
Purpose provide print functionality for a specific integral field. This macro is available for user access. If used externally, a record_options object must be avaialble and must have the name opt. Postcondition ARG is printed using the format set by the FLAGS. |
|
|
`m_uvm_record_object(ARG, FLAG)
|
|
|
`m_uvm_record_qda_enum(ARG, FLAG, SZ)
|
|
|
`m_uvm_record_qda_int(ARG, FLAG, SZ)
|
|
|
`m_uvm_record_qda_object(ARG, FLAG, SZ)
|
|
|
`m_uvm_record_qda_string(ARG, FLAG, SZ)
|
|
|
`m_uvm_record_string(ARG, STR, FLAG)
|
|
DEPRECATED * Group- Sequence Registration Macros The sequence-specific macros perform the same function as the set of `uvm_object_*_utils macros, except they also set the default sequencer type the sequence will run on. |
|
|
`m_uvm_task_phase(PHASE, COMP, PREFIX)
|
|
|
`m_uvm_topdown_phase(PHASE, COMP, PREFIX)
|
|
|
`uvm_add_to_seq_lib(TYPE, LIBTYPE)
|
|
|
`uvm_analysis_imp_decl(SFX)
`uvm_analysis_imp_decl(SFX)Define the class uvm_analysis_impSFX for providing an analysis implementation. SFX is the suffix for the new class type. The analysis implemenation is the write function. The `uvm_analysis_imp_decl allows for a scoreboard (or other analysis component) to support input from many places. For example:`uvm_analysis_imp_decl(_ingress) `uvm_analysis_imp_decl(_egress) class myscoreboard extends uvm_component; uvm_analysis_imp_ingress#(mydata, myscoreboard) ingress; uvm_analysis_imp_egress#(mydata, myscoreboard) egress; mydata ingress_list[$]; ... function new(string name, uvm_component parent); super.new(name,parent); ingress = new("ingress", this); egress = new("egress", this); endfunction function void write_ingress(mydata t); ingress_list.push_back(t); endfunction function void write_egress(mydata t); find_match_in_ingress_list(t); endfunction function void find_match_in_ingress_list(mydata t); implement scoreboarding for this particular DUT ... endfunction endclass |
|
|
`uvm_blocking_get_imp_decl(SFX)
`uvm_blocking_get_imp_decl(SFX)Define the class uvm_blocking_get_impSFX for providing blocking get implementations. SFX is the suffix for the new class type. |
|
|
`uvm_blocking_get_peek_imp_decl(SFX)
`uvm_blocking_get_peek_imp_decl(SFX)Define the class uvm_blocking_get_peek_impSFX for providing the blocking get_peek implemenation. |
|
|
`uvm_blocking_master_imp_decl(SFX)
`uvm_blocking_master_imp_decl(SFX)Define the class uvm_blocking_master_impSFX for providing the blocking master implemenation. |
|
|
`uvm_blocking_peek_imp_decl(SFX)
`uvm_blocking_peek_imp_decl(SFX)Define the class uvm_blocking_peek_impSFX for providing blocking peek implementations. SFX is the suffix for the new class type. |
|
|
`uvm_blocking_put_imp_decl(SFX)
`uvm_blocking_put_imp_decl(SFX)Define the class uvm_blocking_put_impSFX for providing blocking put implementations. SFX is the suffix for the new class type. |
|
|
`uvm_blocking_slave_imp_decl(SFX)
`uvm_blocking_slave_imp_decl(SFX)Define the class uvm_blocking_slave_impSFX for providing the blocking slave implemenation. |
|
|
`uvm_blocking_transport_imp_decl(SFX)
`uvm_blocking_transport_imp_decl(SFX)Define the class uvm_blocking_transport_impSFX for providing the blocking transport implemenation. |
|
|
`uvm_builtin_bottomup_phase(PHASE)
|
|
|
`uvm_builtin_task_phase(PHASE)
|
|
|
`uvm_builtin_topdown_phase(PHASE)
|
|
|
`uvm_cb_trace(OBJ, CB, OPER)
|
|
|
`uvm_cb_trace_noobj(CB, OPER)
|
|
|
`uvm_component_param_utils(T)
|
|
|
`uvm_component_param_utils_begin(T)
|
|
|
`uvm_component_registry(T, S)
Registers a uvm_component-based class with the factory`uvm_component_registry(T,S)Registers a uvm_component-based class T and lookup string S with the factory. S typically is the name of the class in quotes. The |
|
|
`uvm_component_utils(T)
MACRO `uvm_component_end uvm_component-based class declarations may contain one of the above forms of utility macros. For simple components with no field macros, use`uvm_component_utils(TYPE)For simple components with field macros, use`uvm_component_utils_begin(TYPE) `uvm_field_* macro invocations here `uvm_component_utils_endFor parameterized components with no field macros, use`uvm_component_param_utils(TYPE)For parameterized components with field macros, use`uvm_component_param_utils_begin(TYPE) `uvm_field_* macro invocations here `uvm_component_utils_endSimple (non-parameterized) components must use the uvm_components_utils* versions, which do the following:
|
|
|
`uvm_component_utils_begin(T)
|
|
|
`uvm_component_utils_end
|
|
|
`uvm_create(SEQ_OR_ITEM)
`uvm_create(SEQ_OR_ITEM)This action creates the item or sequence using the factory. It intentionally does zero processing. After this action completes, the user can manually set values, manipulate rand_mode and constraint_mode, etc. |
|
|
`uvm_create_on(SEQ_OR_ITEM, SEQR)
`uvm_create_on(SEQ_OR_ITEM, SEQR)This is the same as |
|
|
`uvm_create_seq(UVM_SEQ, SEQR_CONS_IF)
|
|
|
`uvm_declare_p_sequencer(SEQUENCER)
This macro is used to declare a variable p_sequencer whose type is specified by SEQUENCER.`uvm_declare_p_sequencer(SEQUENCER)The example below shows using the the `uvm_declare_p_sequencer macro along with the uvm_object_utils macros to set up the sequence but not register the sequence in the sequencer's library.class mysequence extends uvm_sequence#(mydata); `uvm_object_utils(mysequence) `uvm_declare_p_sequencer(some_seqr_type) task body; Access some variable in the user's custom sequencer if(p_sequencer.some_variable) begin ... end endtask endclass |
|
DEPRECATED * Group- Sequencer Registration Macros The sequencer-specific macros perform the same function as the set of `uvm_componenent_*utils macros except that they also declare the plumbing necessary for creating the sequencer's sequence library. |
|
|
`uvm_delay(TIME)
|
|
|
`uvm_do(SEQ_OR_ITEM)
`uvm_do(SEQ_OR_ITEM)This macro takes as an argument a uvm_sequence_item variable or object. The argument is created using |
|
|
`uvm_do_callbacks(T, CB, METHOD)
|
|
|
`uvm_do_callbacks_exit_on(T, CB, METHOD, VAL)
|
|
|
`uvm_do_obj_callbacks(T, CB, OBJ, METHOD)
`uvm_do_obj_callbacks(T,CB,OBJ,METHOD)Calls the given METHOD of all callbacks based on type CB registered with the given object, OBJ, which is or is based on type T. This macro is identical to |
|
|
`uvm_do_obj_callbacks_exit_on(T, CB, OBJ, METHOD, VAL)
`uvm_do_obj_callbacks_exit_on(T,CB,OBJ,METHOD,VAL)Calls the given METHOD of all callbacks of type CB registered with the given object OBJ, which must be or be based on type T, and returns upon the first callback that returns the bit value given by VAL. It is exactly the same as the |
|
|
`uvm_do_on(SEQ_OR_ITEM, SEQR)
`uvm_do_on(SEQ_OR_ITEM, SEQR)This is the same as |
|
|
`uvm_do_on_pri(SEQ_OR_ITEM, SEQR, PRIORITY)
`uvm_do_on_pri(SEQ_OR_ITEM, SEQR, PRIORITY)This is the same as |
|
|
`uvm_do_on_pri_with(SEQ_OR_ITEM, SEQR, PRIORITY, CONSTRAINTS)
`uvm_do_on_pri_with(SEQ_OR_ITEM, SEQR, PRIORITY, CONSTRAINTS)This is the same as `uvm_do_pri_with except that it also sets the parent sequence to the sequence in which the macro is invoked, and it sets the sequencer to the specified SEQR argument. |
|
|
`uvm_do_on_with(SEQ_OR_ITEM, SEQR, CONSTRAINTS)
`uvm_do_on_with(SEQ_OR_ITEM, SEQR, CONSTRAINTS)This is the same as |
|
|
`uvm_do_pri(SEQ_OR_ITEM, PRIORITY)
`uvm_do_pri(SEQ_OR_ITEM, PRIORITY)This is the same as `uvm_do except that the sequene item or sequence is executed with the priority specified in the argument |
|
|
`uvm_do_pri_with(SEQ_OR_ITEM, PRIORITY, CONSTRAINTS)
`uvm_do_pri_with(SEQ_OR_ITEM, PRIORITY, CONSTRAINTS)This is the same as `uvm_do_pri except that the given constraint block is applied to the item or sequence in a randomize with statement before execution. |
|
|
`uvm_do_seq(UVM_SEQ, SEQR_CONS_IF)
|
|
|
`uvm_do_seq_with(UVM_SEQ, SEQR_CONS_IF, CONSTRAINTS)
|
|
|
`uvm_do_with(SEQ_OR_ITEM, CONSTRAINTS)
`uvm_do_with(SEQ_OR_ITEM, CONSTRAINTS)This is the same as `uvm_do except that the constraint block in the 2nd argument is applied to the item or sequence in a randomize with statement before execution. |
|
|
`uvm_end_package
|
|
|
`uvm_error(ID, MSG)
`uvm_error(ID,MSG)Calls uvm_report_error with a verbosity of UVM_NONE. The message can not be turned off using the reporter's verbosity setting, but can be turned off by setting the action for the message. ID is given as the message tag and MSG is given as the message text. The file and line are also sent to the uvm_report_error call. |
|
|
`uvm_error_context(ID, MSG, CNTXT)
`uvm_error_context(ID,MSG,CNTXT)Operates identically to `uvm_error but requires that the context, or <uvm_report_object> in which the message is printed be explicitly supplied as a macro argument. |
|
|
`uvm_fatal(ID, MSG)
`uvm_fatal(ID,MSG)Calls uvm_report_fatal with a verbosity of UVM_NONE. The message can not be turned off using the reporter's verbosity setting, but can be turned off by setting the action for the message. ID is given as the message tag and MSG is given as the message text. The file and line are also sent to the uvm_report_fatal call. |
|
|
`uvm_fatal_context(ID, MSG, CNTXT)
`uvm_fatal_context(ID,MSG,CNTXT)Operates identically to `uvm_fatal but requires that the context, or <uvm_report_object>, in which the message is printed be explicitly supplied as a macro argument. |
|
|
`uvm_field_aa_int_byte(ARG, FLAG)
Implements the data operations for an associative array of integral types indexed by the byte data type.`uvm_field_aa_int_byte(ARG,FLAG)ARG is the name of a property that is an associative array of integrals with byte key, and FLAG is a bitwise OR of one or more flag settings as described in <Field Macros> above. |
|
|
`uvm_field_aa_int_byte_unsigned(ARG, FLAG)
Implements the data operations for an associative array of integral types indexed by the byte unsigned data type.`uvm_field_aa_int_byte_unsigned(ARG,FLAG)ARG is the name of a property that is an associative array of integrals with byte unsigned key, and FLAG is a bitwise OR of one or more flag settings as described in <Field Macros> above. |
|
|
`uvm_field_aa_int_enumkey(KEY, ARG, FLAG)
Implements the data operations for an associative array of integral types indexed by any enumeration key data type.`uvm_field_aa_int_longint_unsigned(ARG,FLAG)ARG is the name of a property that is an associative array of integrals with longint unsigned key, and FLAG is a bitwise OR of one or more flag settings as described in <Field Macros> above. |
|
|
`uvm_field_aa_int_int(ARG, FLAG)
Implements the data operations for an associative array of integral types indexed by the int data type.`uvm_field_aa_int_int(ARG,FLAG)ARG is the name of a property that is an associative array of integrals with int key, and FLAG is a bitwise OR of one or more flag settings as described in <Field Macros> above. |
|
|
`uvm_field_aa_int_int_unsigned(ARG, FLAG)
Implements the data operations for an associative array of integral types indexed by the int unsigned data type.`uvm_field_aa_int_int_unsigned(ARG,FLAG)ARG is the name of a property that is an associative array of integrals with int unsigned key, and FLAG is a bitwise OR of one or more flag settings as described in <Field Macros> above. |
|
|
`uvm_field_aa_int_integer(ARG, FLAG)
Implements the data operations for an associative array of integral types indexed by the integer data type.`uvm_field_aa_int_integer(ARG,FLAG)ARG is the name of a property that is an associative array of integrals with integer key, and FLAG is a bitwise OR of one or more flag settings as described in <Field Macros> above. |
|
|
`uvm_field_aa_int_integer_unsigned(ARG, FLAG)
Implements the data operations for an associative array of integral types indexed by the integer unsigned data type.`uvm_field_aa_int_integer_unsigned(ARG,FLAG)ARG is the name of a property that is an associative array of integrals with integer unsigned key, and FLAG is a bitwise OR of one or more flag settings as described in <Field Macros> above. |
|
|
`uvm_field_aa_int_key(KEY, ARG, FLAG)
Implements the data operations for an associative array of integral types indexed by any integral key data type.`uvm_field_aa_int_key(long unsigned,ARG,FLAG)KEY is the data type of the integral key, ARG is the name of a property that is an associative array of integrals, and FLAG is a bitwise OR of one or more flag settings as described in <Field Macros> above. |
|
|
`uvm_field_aa_int_longint(ARG, FLAG)
Implements the data operations for an associative array of integral types indexed by the longint data type.`uvm_field_aa_int_longint(ARG,FLAG)ARG is the name of a property that is an associative array of integrals with longint key, and FLAG is a bitwise OR of one or more flag settings as described in <Field Macros> above. |
|
|
`uvm_field_aa_int_longint_unsigned(ARG, FLAG)
Implements the data operations for an associative array of integral types indexed by the longint unsigned data type.`uvm_field_aa_int_longint_unsigned(ARG,FLAG)ARG is the name of a property that is an associative array of integrals with longint unsigned key, and FLAG is a bitwise OR of one or more flag settings as described in <Field Macros> above. |
|
|
`uvm_field_aa_int_shortint(ARG, FLAG)
Implements the data operations for an associative array of integral types indexed by the shortint data type.`uvm_field_aa_int_shortint(ARG,FLAG)ARG is the name of a property that is an associative array of integrals with shortint key, and FLAG is a bitwise OR of one or more flag settings as described in <Field Macros> above. |
|
|
`uvm_field_aa_int_shortint_unsigned(ARG, FLAG)
Implements the data operations for an associative array of integral types indexed by the shortint unsigned data type.`uvm_field_aa_int_shortint_unsigned(ARG,FLAG)ARG is the name of a property that is an associative array of integrals with shortint unsigned key, and FLAG is a bitwise OR of one or more flag settings as described in <Field Macros> above. |
|
|
`uvm_field_aa_int_string(ARG, FLAG)
Implements the data operations for an associative array of integrals indexed by string.`uvm_field_aa_int_string(ARG,FLAG)ARG is the name of a property that is an associative array of integrals with string key, and FLAG is a bitwise OR of one or more flag settings as described in <Field Macros> above. |
|
|
`uvm_field_aa_object_int(ARG, FLAG)
Implements the data operations for an associative array of <uvm_object>-based objects indexed by the int data type.`uvm_field_aa_object_int(ARG,FLAG)ARG is the name of a property that is an associative array of objects with int key, and FLAG is a bitwise OR of one or more flag settings as described in <Field Macros> above. |
|
|
`uvm_field_aa_object_string(ARG, FLAG)
Implements the data operations for an associative array of <uvm_object>-based objects indexed by string.`uvm_field_aa_object_string(ARG,FLAG)ARG is the name of a property that is an associative array of objects with string key, and FLAG is a bitwise OR of one or more flag settings as described in <Field Macros> above. |
|
|
`uvm_field_aa_string_string(ARG, FLAG)
Implements the data operations for an associative array of strings indexed by string.`uvm_field_aa_string_string(ARG,FLAG)ARG is the name of a property that is an associative array of strings with string key, and FLAG is a bitwise OR of one or more flag settings as described in <Field Macros> above. |
|
|
`uvm_field_array_enum(T, ARG, FLAG)
Implements the data operations for a one-dimensional dynamic array of enums.`uvm_field_array_enum(T,ARG,FLAG)T is a one-dimensional dynamic array of enums type ARG is an instance of that type, and FLAG is a bitwise OR of one or more flag settings as described in <Field Macros> above. |
|
|
`uvm_field_array_int(ARG, FLAG)
Implements the data operations for a one-dimensional dynamic array of integrals.`uvm_field_array_int(ARG,FLAG)ARG is a one-dimensional dynamic array of integrals, and FLAG is a bitwise OR of one or more flag settings as described in <Field Macros> above. |
|
|
`uvm_field_array_object(ARG, FLAG)
Implements the data operations for a one-dimensional dynamic array of <uvm_object>-based objects.`uvm_field_array_object(ARG,FLAG)ARG is a one-dimensional dynamic array of <uvm_object>-based objects, and FLAG is a bitwise OR of one or more flag settings as described in <Field Macros> above. |
|
|
`uvm_field_array_string(ARG, FLAG)
Implements the data operations for a one-dimensional dynamic array of strings.`uvm_field_array_string(ARG,FLAG)ARG is a one-dimensional dynamic array of strings, and FLAG is a bitwise OR of one or more flag settings as described in <Field Macros> above. |
|
|
`uvm_field_enum(T, ARG, FLAG)
Implements the data operations for an enumerated property.`uvm_field_enum(T,ARG,FLAG)T is an enumerated _type_, ARG is an instance of that type, and FLAG is a bitwise OR of one or more flag settings as described in <Field Macros> above. |
|
|
`uvm_field_event(ARG, FLAG)
Implements the data operations for an event property.`uvm_field_event(ARG,FLAG)ARG is an event property of the class, and FLAG is a bitwise OR of one or more flag settings as described in <Field Macros> above. |
|
|
`uvm_field_int(ARG, FLAG)
Implements the data operations for any packed integral property.`uvm_field_int(ARG,FLAG)ARG is an integral property of the class, and FLAG is a bitwise OR of one or more flag settings as described in <Field Macros> above. |
|
|
`uvm_field_object(ARG, FLAG)
Implements the data operations for an <uvm_object>-based property.`uvm_field_object(ARG,FLAG)ARG is an object property of the class, and FLAG is a bitwise OR of one or more flag settings as described in <Field Macros> above. |
|
|
`uvm_field_queue_enum(T, ARG, FLAG)
Implements the data operations for a one-dimensional queue of enums.`uvm_field_queue_enum(T,ARG,FLAG)T is a queue of enums _type_, ARG is an instance of that type, and FLAG is a bitwise OR of one or more flag settings as described in <Field Macros> above. |
|
|
`uvm_field_queue_int(ARG, FLAG)
Implements the data operations for a queue of integrals.`uvm_field_queue_int(ARG,FLAG)ARG is a one-dimensional queue of integrals, and FLAG is a bitwise OR of one or more flag settings as described in <Field Macros> above. |
|
|
`uvm_field_queue_object(ARG, FLAG)
Implements the data operations for a queue of <uvm_object>-based objects.`uvm_field_queue_object(ARG,FLAG)ARG is a one-dimensional queue of <uvm_object>-based objects, and FLAG is a bitwise OR of one or more flag settings as described in <Field Macros> above. |
|
|
`uvm_field_queue_string(ARG, FLAG)
Implements the data operations for a queue of strings.`uvm_field_queue_string(ARG,FLAG)ARG is a one-dimensional queue of strings, and FLAG is a bitwise OR of one or more flag settings as described in <Field Macros> above. |
|
|
`uvm_field_real(ARG, FLAG)
Implements the data operations for any real property.`uvm_field_real(ARG,FLAG)ARG is an real property of the class, and FLAG is a bitwise OR of one or more flag settings as described in <Field Macros> above. |
|
|
`uvm_field_sarray_enum(T, ARG, FLAG)
Implements the data operations for a one-dimensional static array of enums.`uvm_field_sarray_enum(T,ARG,FLAG)T is a one-dimensional dynamic array of enums _type_, ARG is an instance of that type, and FLAG is a bitwise OR of one or more flag settings as described in <Field Macros> above. |
|
|
`uvm_field_sarray_int(ARG, FLAG)
Implements the data operations for a one-dimensional static array of integrals.`uvm_field_sarray_int(ARG,FLAG)ARG is a one-dimensional static array of integrals, and FLAG is a bitwise OR of one or more flag settings as described in <Field Macros> above. |
|
|
`uvm_field_sarray_object(ARG, FLAG)
Implements the data operations for a one-dimensional static array of <uvm_object>-based objects.`uvm_field_sarray_object(ARG,FLAG)ARG is a one-dimensional static array of <uvm_object>-based objects, and FLAG is a bitwise OR of one or more flag settings as described in <Field Macros> above. |
|
|
`uvm_field_sarray_string(ARG, FLAG)
Implements the data operations for a one-dimensional static array of strings.`uvm_field_sarray_string(ARG,FLAG)ARG is a one-dimensional static array of strings, and FLAG is a bitwise OR of one or more flag settings as described in <Field Macros> above. |
|
|
`uvm_field_string(ARG, FLAG)
Implements the data operations for a string property.`uvm_field_string(ARG,FLAG)ARG is a string property of the class, and FLAG is a bitwise OR of one or more flag settings as described in <Field Macros> above. |
|
|
`uvm_field_utils_begin(T)
MACRO `uvm_field_utils_end These macros form a block in which `uvm_field_* macros can be placed. Used as`uvm_field_utils_begin(TYPE) `uvm_field_* macros here `uvm_field_utils_endThese macros do not perform factory registration nor implement the get_type_name and create methods. Use this form when you need custom implementations of these two methods, or when you are setting up field macros for an abstract class (i.e. virtual class). |
|
|
`uvm_field_utils_end
|
|
|
`uvm_file = `__FILE__
|
|
|
`uvm_get_imp_decl(SFX)
`uvm_get_imp_decl(SFX)Define the class uvm_get_impSFX for providing both blocking and non-blocking get implementations. SFX is the suffix for the new class type. |
|
|
`uvm_get_peek_imp_decl(SFX)
`uvm_get_peek_imp_decl(SFX)Define the class uvm_get_peek_impSFX for providing both blocking and non-blocking get_peek implementations. SFX is the suffix for the new class type. |
|
|
`uvm_info(ID, MSG, VERBOSITY)
`uvm_info(ID,MSG,VERBOSITY)Calls uvm_report_info if VERBOSITY is lower than the configured verbosity of the associated reporter. ID is given as the message tag and MSG is given as the message text. The file and line are also sent to the uvm_report_info call. |
|
|
`uvm_info_context(ID, MSG, VERBOSITY, CNTXT)
`uvm_info_context(ID,MSG,VERBOSITY,CNTXT)Operates identically to `uvm_info but requires that the context, or <uvm_report_object>, in which the message is printed be explicitly supplied as a macro argument. |
|
|
`uvm_line = `__LINE__
|
|
|
`uvm_master_imp_decl(SFX)
`uvm_master_imp_decl(SFX)Define the class uvm_master_impSFX for providing both blocking and non-blocking master implementations. SFX is the suffix for the new class type. |
|
|
`uvm_new_func
|
|
|
`uvm_non_blocking_transport_imp_decl(SFX)
|
|
|
`uvm_nonblocking_get_imp_decl(SFX)
`uvm_nonblocking_get_imp_decl(SFX)Define the class uvm_nonblocking_get_impSFX for providing non-blocking get implementations. SFX is the suffix for the new class type. |
|
|
`uvm_nonblocking_get_peek_imp_decl(SFX)
`uvm_nonblocking_get_peek_imp_decl(SFX)Define the class uvm_nonblocking_get_peek_impSFX for providing non-blocking get_peek implemenation. |
|
|
`uvm_nonblocking_master_imp_decl(SFX)
`uvm_nonblocking_master_imp_decl(SFX)Define the class uvm_nonblocking_master_impSFX for providing the non-blocking master implemenation. |
|
|
`uvm_nonblocking_peek_imp_decl(SFX)
`uvm_nonblocking_peek_imp_decl(SFX)Define the class uvm_nonblocking_peek_impSFX for providing non-blocking peek implementations. SFX is the suffix for the new class type. |
|
|
`uvm_nonblocking_put_imp_decl(SFX)
`uvm_nonblocking_put_imp_decl(SFX)Define the class uvm_nonblocking_put_impSFX for providing non-blocking put implementations. SFX is the suffix for the new class type. |
|
|
`uvm_nonblocking_slave_imp_decl(SFX)
`uvm_nonblocking_slave_imp_decl(SFX)Define the class uvm_nonblocking_slave_impSFX for providing the non-blocking slave implemenation. |
|
|
`uvm_nonblocking_transport_imp_decl(SFX)
`uvm_nonblocking_transport_imp_decl(SFX)Define the class uvm_nonblocking_transport_impSFX for providing the non-blocking transport implemenation. |
|
|
`uvm_object_param_utils(T)
|
|
|
`uvm_object_param_utils_begin(T)
|
|
|
`uvm_object_registry(T, S)
Register a uvm_object-based class with the factory`uvm_object_registry(T,S)Registers a uvm_object-based class T and lookup string S with the factory. S typically is the name of the class in quotes. The |
|
|
`uvm_object_utils(T)
<uvm_object>-based class declarations may contain one of the above forms of utility macros. For simple objects with no field macros, use`uvm_object_utils(TYPE)For simple objects with field macros, use`uvm_object_utils_begin(TYPE) `uvm_field_* macro invocations here `uvm_object_utils_endFor parameterized objects with no field macros, use`uvm_object_param_utils(TYPE)For parameterized objects, with field macros, use`uvm_object_param_utils_begin(TYPE) `uvm_field_* macro invocations here `uvm_object_utils_endSimple (non-parameterized) objects use the uvm_object_utils* versions, which do the following:
`uvm_object_utils only in that they do not supply a type name
when registering the object with the factory. As such, name-based lookup with
the factory for parameterized classes is not possible.
The macros with _begin suffixes are the same as the non-suffixed versions
except that they also start a block in which `uvm_field_* macros can be
placed. The block must be terminated by `uvm_object_utils_end.
Objects deriving from uvm_sequence must use the `uvm_sequence_* macros
instead of these macros. See `uvm_sequence_utils for details.
|
|
|
`uvm_object_utils_begin(T)
|
|
|
`uvm_object_utils_end
|
|
|
`uvm_pack_array(VAR)
Pack a dynamic array without having to also specify the bit size of its elements. Array size must be non-zero.`uvm_pack_array(VAR) |
|
|
`uvm_pack_arrayN(VAR, SIZE)
Pack a dynamic array of integrals.`uvm_pack_arrayN(VAR,SIZE) |
|
|
`uvm_pack_enum(VAR)
Pack an enumeration value. Packing does not require its type be specified.`uvm_pack_enum(VAR) |
|
|
`uvm_pack_enumN(VAR, SIZE)
Pack an integral variable.`uvm_pack_enumN(VAR,SIZE) |
|
|
`uvm_pack_int(VAR)
Pack an integral variable without having to also specify the bit size.`uvm_pack_int(VAR) |
|
|
`uvm_pack_intN(VAR, SIZE)
Pack an integral variable.`uvm_pack_intN(VAR,SIZE) |
|
|
`uvm_pack_queue(VAR)
Pack a queue without having to also specify the bit size of its elements. Queue must not be empty.`uvm_pack_queue(VAR) |
|
|
`uvm_pack_queueN(VAR, SIZE)
Pack a queue of integrals.`uvm_pack_queueN(VAR,SIZE) |
|
|
`uvm_pack_real(VAR)
Pack a variable of type real.`uvm_pack_real(VAR) |
|
|
`uvm_pack_sarray(VAR)
Pack a static array without having to also specify the bit size of its elements.`uvm_pack_sarray(VAR) |
|
|
`uvm_pack_sarrayN(VAR, SIZE)
Pack a static array of integrals.`uvm_pack_sarray(VAR,SIZE) |
|
|
`uvm_pack_string(VAR)
Pack a string variable.`uvm_pack_string(VAR) |
|
|
`uvm_package(PKG)
Use `uvm_package to define the SV package and to create a bogus type to help automate triggering the static initializers of the package. Use uvm_end_package to endpackage. |
|
|
`uvm_peek_imp_decl(SFX)
`uvm_peek_imp_decl(SFX)Define the class uvm_peek_impSFX for providing both blocking and non-blocking peek implementations.  SFX is the suffix for the new class type. |
|
|
`uvm_rand_send(SEQ_OR_ITEM)
`uvm_rand_send(SEQ_OR_ITEM)This macro processes the item or sequence that has been already been allocated (possibly with `uvm_create). The processing is done with randomization. Essentially, an `uvm_do without the create. |
|
|
`uvm_rand_send_pri(SEQ_OR_ITEM, PRIORITY)
`uvm_rand_send_pri(SEQ_OR_ITEM, PRIORITY)This is the same as `uvm_rand_send except that the sequene item or sequence is executed with the priority specified in the argument. |
|
|
`uvm_rand_send_pri_with(SEQ_OR_ITEM, PRIORITY, CONSTRAINTS)
`uvm_rand_send_pri_with(SEQ_OR_ITEM, PRIORITY, CONSTRAINTS)This is the same as `uvm_rand_send_pri except that the given constraint block is applied to the item or sequence in a randomize with statement before execution. |
|
|
`uvm_rand_send_with(SEQ_OR_ITEM, CONSTRAINTS)
`uvm_rand_send_with(SEQ_OR_ITEM, CONSTRAINTS)This is the same as `uvm_rand_send except that the given constraint block is applied to the item or sequence in a randomize with statement before execution. |
|
|
`uvm_record_attribute(TR_HANDLE, NAME, VALUE) [empty]
|
|
|
`uvm_record_field(NAME, VALUE)
Macro for recording name-value pairs into a transaction recording database. Requires a valid transaction handle, as provided by the <uvm_transaction::begin_tr> and <uvm_component::begin_tr> methods. |
|
|
`uvm_record_int(NAME, VALUE, SIZE, RADIX)
Use the following if the simulator's recording API can not distinguish types. |
|
|
`uvm_record_real(NAME, VALUE)
|
|
|
`uvm_record_string(NAME, VALUE)
|
|
|
`uvm_record_time(NAME, VALUE)
|
|
|
`uvm_register_cb(T, CB)
`uvm_register_cb(T,CB)Registers the given CB callback type with the given T object type. If a type-callback pair is not registered then a warning is issued if an attempt is made to use the pair (add, delete, etc.). The registration will typically occur in the component that executes the given type of callback. For instance:virtual class mycb extends uvm_callback; virtual function void doit(); endclass class my_comp extends uvm_component; `uvm_register_cb(my_comp,mycb) ... task run_phase(uvm_phase phase); ... `uvm_do_callbacks(my_comp, mycb, doit()) endtask endclass |
|
|
`uvm_send(SEQ_OR_ITEM)
`uvm_send(SEQ_OR_ITEM)This macro processes the item or sequence that has been created using `uvm_create. The processing is done without randomization. Essentially, an `uvm_do without the create or randomization. |
|
|
`uvm_send_pri(SEQ_OR_ITEM, PRIORITY)
`uvm_send_pri(SEQ_OR_ITEM, PRIORITY)This is the same as `uvm_send except that the sequene item or sequence is executed with the priority specified in the argument. |
|
|
`uvm_sequence_library_package(PKG_NAME)
This macro is used to trigger static initializers in packages. `uvm_package creates a bogus type which gets referred to by uvm_sequence_library_package to make a package-based variable of the bogus type. |
|
|
`uvm_sequence_library_utils(TYPE)
`uvm_sequence_library_utils(TYPE)Declares the infrastructure needed to define extensions to the <uvm_sequence_library> class. You define new sequence library subtypes to statically specify sequence membership from within sequence definitions. See also <`uvm_add_to_sequence_library> for more information.typedef simple_seq_lib uvm_sequence_library #(simple_item); class simple_seq_lib_RST extends simple_seq_lib; `uvm_object_utils(simple_seq_lib_RST) `uvm_sequence_library_utils(simple_seq_lib_RST) function new(string name=""); super.new(name); endfunction endclassEach library, itself a sequence, can then be started independently on different sequencers or in different phases of the same sequencer. See <uvm_sequencer_base::start_phase_sequence> for information on starting default sequences. |
|
|
`uvm_sequence_utils(TYPE_NAME, SEQUENCER)
The sequence macros can be used in non-parameterized <uvm_sequence #(REQ,RSP)> extensions to pre-register the sequence with a given <uvm_sequencer #(REQ,RSP)> type. For sequences that do not use any `uvm_field macros`uvm_sequence_utils(TYPE_NAME,SQR_TYPE_NAME)For sequences employing with field macros`uvm_sequence_utils_begin(TYPE_NAME,SQR_TYPE_NAME) `uvm_field_* macro invocations here `uvm_sequence_utils_endThe sequence-specific macros perform the same function as the set of `uvm_object_*_utils macros except that they also register the sequence's type, TYPE_NAME, with the given sequencer type, SQR_TYPE_NAME, and define the p_sequencer variable and m_set_p_sequencer method. Use `uvm_sequence_utils[_begin] for non-parameterized classes and `uvm_sequence_param_utils[_begin] for parameterized classes. |
|
|
`uvm_sequence_utils_begin(TYPE_NAME, SEQUENCER)
|
|
|
`uvm_sequence_utils_end
|
|
|
`uvm_sequencer_param_utils(TYPE_NAME)
|
|
|
`uvm_sequencer_param_utils_begin(TYPE_NAME)
|
|
|
`uvm_sequencer_utils(TYPE_NAME)
|
|
|
`uvm_sequencer_utils_begin(TYPE_NAME)
|
|
|
`uvm_sequencer_utils_end
The sequencer macros are used in uvm_sequencer-based class declarations in one of four ways. For simple sequencers, no field macros `uvm_sequencer_utils(SQR_TYPE_NAME) For simple sequencers, with field macros `uvm_sequencer_utils_begin(SQR_TYPE_NAME) `uvm_field_* macros here `uvm_sequencer_utils_end For parameterized sequencers, no field macros `uvm_sequencer_param_utils(SQR_TYPE_NAME) For parameterized sequencers, with field macros `uvm_sequencer_param_utils_begin(SQR_TYPE_NAME) `uvm_field_* macros here `uvm_sequencer_utils_end The sequencer-specific macros perform the same function as the set of `uvm_componenent_*utils macros except that they also declare the plumbing necessary for creating the sequencer's sequence library. This includes: 1. Declaring the type-based static queue of strings registered on the sequencer type. 2. Declaring the static function to add strings to item #1 above. 3. Declaring the static function to remove strings to item #1 above. 4. Declaring the function to populate the instance specific sequence library for a sequencer. Use `uvm_sequencer_utils[_begin] for non-parameterized classes and `uvm_sequencer_param_utils[_begin] for parameterized classes. |
|
|
`uvm_set_super_type(T, ST)
`uvm_set_super_type(T,ST)Defines the super type of T to be ST. This allows for derived class objects to inherit typewide callbacks that are registered with the base class. The registration will typically occur in the component that executes the given type of callback. For instance:virtual class mycb extend uvm_callback; virtual function void doit(); endclass class my_comp extends uvm_component; `uvm_register_cb(my_comp,mycb) ... task run_phase(uvm_phase phase); ... `uvm_do_callbacks(my_comp, mycb, doit()) endtask endclass class my_derived_comp extends my_comp; `uvm_set_super_type(my_derived_comp,my_comp) ... task run_phase(uvm_phase phase); ... `uvm_do_callbacks(my_comp, mycb, doit()) endtask endclass |
|
|
`uvm_slave_imp_decl(SFX)
`uvm_slave_imp_decl(SFX)Define the class uvm_slave_impSFX for providing both blocking and non-blocking slave implementations. SFX is the suffix for the new class type. |
|
|
`uvm_transport_imp_decl(SFX)
`uvm_transport_imp_decl(SFX)Define the class uvm_transport_impSFX for providing both blocking and non-blocking transport implementations. SFX is the suffix for the new class type. |
|
|
`uvm_typename(X)
|
|
|
`uvm_unpack_array(VAR)
Unpack a dynamic array without having to also specify the bit size of its elements. Array size must be non-zero.`uvm_unpack_array(VAR) |
|
|
`uvm_unpack_arrayN(VAR, SIZE)
Unpack into a dynamic array of integrals.`uvm_unpack_arrayN(VAR,SIZE) |
|
|
`uvm_unpack_enum(VAR, TYPE)
Unpack an enumeration value, which requires its type be specified.`uvm_unpack_enum(VAR,TYPE) |
|
|
`uvm_unpack_enumN(VAR, SIZE, TYPE)
Unpack enum of type TYPE into VAR. `uvm_unpack_enumN(VAR,SIZE,TYPE) |
|
|
`uvm_unpack_int(VAR)
Unpack an integral variable without having to also specify the bit size.`uvm_unpack_int(VAR) |
|
|
`uvm_unpack_intN(VAR, SIZE)
Unpack into an integral variable.`uvm_unpack_intN(VAR,SIZE) |
|
|
`uvm_unpack_queue(VAR)
Unpack a queue without having to also specify the bit size of its elements. Queue must not be empty.`uvm_unpack_queue(VAR) |
|
|
`uvm_unpack_queueN(VAR, SIZE)
Unpack into a queue of integrals.`uvm_unpack_queue(VAR,SIZE) |
|
|
`uvm_unpack_real(VAR)
Unpack a variable of type real.`uvm_unpack_real(VAR) |
|
|
`uvm_unpack_sarray(VAR)
Unpack a static array without having to also specify the bit size of its elements.`uvm_unpack_sarray(VAR) |
|
|
`uvm_unpack_sarrayN(VAR, SIZE)
Unpack a static (fixed) array of integrals.`uvm_unpack_sarrayN(VAR,SIZE) |
|
|
`uvm_unpack_string(VAR)
Pack a string variable.`uvm_unpack_string(VAR) |
|
|
`uvm_update_sequence_lib
This macro populates the instance-specific sequence library for a sequencer. It should be invoked inside the sequencer¿s constructor. |
|
|
`uvm_update_sequence_lib_and_item(USER_ITEM)
This macro populates the instance specific sequence library for a sequencer, and it registers the given USER_ITEM as an instance override for the simple sequence's item variable. The macro should be invoked inside the sequencer's constructor. |
|
|
`uvm_user_bottomup_phase(PHASE, COMP, PREFIX)
|
|
|
`uvm_user_task_phase(PHASE, COMP, PREFIX)
|
|
|
`uvm_user_topdown_phase(PHASE, COMP, PREFIX)
|
|
|
`uvm_warning(ID, MSG)
`uvm_warning(ID,MSG)Calls uvm_report_warning with a verbosity of UVM_NONE. The message can not be turned off using the reporter's verbosity setting, but can be turned off by setting the action for the message. ID is given as the message tag and MSG is given as the message text. The file and line are also sent to the uvm_report_warning call. |
|
|
`uvm_warning_context(ID, MSG, CNTXT)
`uvm_warning_context(ID,MSG,CNTXT)Operates identically to `uvm_warning but requires that the context, or <uvm_report_object>, in which the message is printed be explicitly supplied as a macro argument. |
Generated by cristian.slav on Thu Nov 06 11:19:25 EET 2014 using SpecadorTM Version 3.5.25


Artworks by [[${artistName}]]
[[${artistName}]] does not have any artworks uploaded.
[[${artwork.name}]]
Update
Delete
Details


Mario
Mario is a Navy veteran of the submarine force and has visited many cities around the world. Mario has an Assosciate's of Technical Arts in Marine Systems Technology and a Bachelors of Science degree in Workforce Education and Development. He is currently embarking on a new career in software development. He enjoys travel and visiting other countries and enjoying their culture. If not learning to code or spending time with his family he is learning chords on his guitar or attending rock concerts.
Ryan
Ryan is a veteran and current member of the Washington State National Gaurd. After taking 2 years of college for engineering he joined the Army in 2012. After passing the rigorous selection for Rangers he was assigned to 2nd Ranger Battalion where he deployed 4 times to Afghanistan and jumped out of many airplanes. After getting out of the Army in 2017 he started another rigorous training program at Code Fellows.
John
John was born in a small town in North Dakota where he lived his entire life. Then after receiving a degree in Mechanical Engineering John got a job as an engineer for an oil and gas company and was able to travel and meet people from all around the world, since then he has had the travel bug and there hasn't been a cure. John also likes hiking, camping, coding and long walks on the beach! John moved to Seattle in July to attend Code Fellows.
Han
As a professional developer Han's goal is to contribute to building softwares that improve people's daily and social life. Han is a Honor graduate from the University of California, Merced with a B.S in Chemistry.


Story Synth is a platform for developing, playtesting, and publishing lightweight storytelling games on the web. The mission is to lower the barrier to playtesting games online and encourage a flourishing of new designs.
Check out this video tour of Story Synth to see it in action:
There are a few key features:
Designers can create their game in an Google Spreadsheet and can playtest by pasting the link into Story Synth – no coding knowledge needed.
Story Synth games take place in “Rooms” where content is synchronized for everyone in the same Room. In other words, everybody at the same URL automatically sees the same content.
There are multiple templates for different types of games and, if you’re comfortable coding, you can add your own games
You can see the templates in action (with placeholder content) at storysynth.org.
I’m planning to elaborate on these guides so please reach out with any questions or if anything is unclear.
Available formats and templates
Story Synth currently has five different game formats you can use. Here’s a brief description of each and a link to its template. You can read more about each format on the Formats Page.
Shuffled – a series of ordered prompts followed by shuffled prompts
Timed – each player receives unique prompts at different times based on a shared stopwatch
Secrets – each player receives a secret prompt each round
Monster – a series of ordered promts spread over rounds; some rounds have multiple prompts
Slot Machine – a series of cards with randomized content, drawn from each of several lists


List of most Major Grand Slam Winners
Filter Results using:
name
rank
country
titles
years
Search:
Limit Results To:
2
4
6
8
All
Rank
Name
Country
Years-Active
Titles
Image
{{item.rank}}
{{item.name | uppercase}}
{{item.country}}
{{item.years}}
{{item.titles}}


1 Department of Pathology, The University of Alabama at Birmingham, Birmingham, AL: 2 Centro para el Desarrollo de la Investigación Científica, Asunción, Paraguay
Data analysis was carried out using 3 approaches: descriptive analysis, association analysis, and outcome analysis. Data was analyzed and plots were generated using R version 3.4.0 (2017-04-21) from the R Foundation for Statistical Computing (Vienna, Austria). R packages from the tidyverse were extensively used.
The analysis describes the clinicopathologic, treatment and outcome features corresponding to the 25 patients included in the dataset from TMA 674, and to the 28 patients included in the dataset from TMA 931.
The analysis also descibres the marker features as evaluated in the 148 spots from TMA 674, and the 320 spots from TMA 931, including the extent (i.e., percentage of positive cells), intensity (absent, weak, moderate and strong intensity), and H-score. The H-score was estimated by multipling the extent (0–100%) by the intensity (0 for absent, 1 for weak, 2 for moderate and 3 for strong intensity), ranging from 0 to 300.
We describe marker features using two approaches: first, we describe the marker expression considering all TMA spots; then, we summarized marker expression by cases (i.e., patients), using either the median or the maximum value of the considered feature.
Categorical variables were described using frequency tables and barplots. Numerical variables were described using measurements of central tendency and dispersion, histograms, and density plots.
For association analyses we included only the invasive cases (i.e., cases in which the TMA spot evaluated showed tumor cells). For each TMA, the marker values were compared considering clinical, preoperative, pathologic, treatment, and outcome features. In this context, marker values were considered as the outcome variables and the aforementioned features as the predictor variables. Variables were described using measurements of central tendency and dispersion, boxplots, and density plots.
For each feature (extent, intensity and H-score), either the median or the maximum value was used for the analysis. Thus, the association analysis was carried out by median percentage, maximum percentage, median intensity, maximum intensity, median H-score, and [maximum H-score]((association_h_max.html).
The association was evaluated using either the Mann-Whitney U test for the sum of ranks or the Kruskal-Wallis rank sum test, depending on the features of the predictor variables.
For outcome analyses we included only the invasive cases (i.e., cases in which the TMA spot evaluated showed tumor cells). The outcome analysis included regression modeling and survival analysis. For each feature (extent, intensity and H-score), each case was categorized as showing high or low expression using the median values of the feature grouped in 2 levels, considering the median value of the feature distribution.
Outcome variables included tumor recurrence, tumor progression, overall mortality, and cancer-related mortality.
Odds ratios were estimated using unconditional binary logistic regression. Hazard ratios were estimated using Cox’s proportional hazards regression. Survival curves were built using the Kapplan-Meier estimator and compared using the log-rank test.


◆ createInstance()
Returns the shared instance to the loader (and creates it if it didn't exist yet).
- Returns
- Shared icon loader instance
The caller of this function should call incrementReferenceCount() directly after the first call to this function and call decrementReferenceCount() when it no longer needs the icon loader. The caller can call this function multiple times inbetween the incrementReferenceCount and decrementReferenceCount calls.
◆ getGenericFileIcon()
Returns the generic file/folder icon, which is used until the file-specific icons are finished loading.
- Parameters
-
| file | Information about the file, used to check if a folder or file icon needs to be returned |
- Returns
- File or folder icon
◆ hasGenericIcons()
| virtual bool tgui::FileDialogIconLoader::hasGenericIcons |
( |
| ) |
const |
|
virtual |
Returns whether generic icons (one folder and one file icon) are available.
Returns true when a folder and file icon can be returned
Generic icons can be shows while waiting for the per-file icons to finish loading
◆ requestFileIcons()
| virtual void tgui::FileDialogIconLoader::requestFileIcons |
( |
const std::vector< Filesystem::FileInfo > & |
files | ) |
|
|
virtual |
Starts a thread to load the icons for all given files.
- Parameters
-
| files | List of files for which icons should be loaded |
If the thread was still running then it will be cancelled. Once the thread finished, the update() function will return true and retrieveFileIcons() should be called.
◆ retrieveFileIcons()
| virtual std::vector<Texture> tgui::FileDialogIconLoader::retrieveFileIcons |
( |
| ) |
|
|
virtual |
Access the file icons that where loaded in the thread that was started in requestFileIcons()
- Returns
- Loaded icons for all files passed to requestFileIcons
◆ supportsSystemIcons()
| virtual bool tgui::FileDialogIconLoader::supportsSystemIcons |
( |
| ) |
const |
|
virtual |
Returns whether this icon loader does something or whether its functions are no-ops.
- Returns
- True if the platform supports loading icons
◆ update()
| virtual bool tgui::FileDialogIconLoader::update |
( |
| ) |
|
|
virtual |
Called every frame to check if the background thread has finished.
- Returns
- Whether icons are available and retrieveFileIcons can be called
The documentation for this class was generated from the following file:


Your accounts
Account-ID
Numbers
Account name
Available balance
Booked balance
Currency
Status
Actions


Dashboard
Master
Supplier
Item
Order to Payment
Purchase Order
Good Receipt Note
Purchase Invoice
Scan Purchase Invoice
Remittance
Admin
Entity and Site
User Login
User Group
Supplier Group
Category
Content
Email
Di sini content utama


1pass4all is a bookmarklet to create passwords easily and securely. For more details, please read its introduction here.
Before installation, you probably need customize bookmarklets for better security(esp. cryptographic salt).
Basic usage of 1pass4all can be described by the following two simple scenarios. For more advanced usage, please refer to the usage section of README file.
Have a strong and secret password in mind(called "master password" hereafter), log in some web account and go to password-change page. Fill the new-password field with the master password and then click 1pass4all bookmarklet. A new password will be generated and substitute the master password in-place. If applicable, repeat the action in a confirmed-password field. Save the change and log out.
Back to login page, type a username in the login field and a master password into the password field, then click the 1pass4all bookmarklet. Just as the previous step, the actual password is populated. The only difference is 1pass4all will auto-submit login form this time(provided that auto-login is enabled).
Clicking on the
Warning: button will update bookmarklets of IE version and non-IE version. DIY version can be customized by editing corresponding variables in Makefile. As for mobile version, if you don't want to change the parameters on every refresh page, you have to generate mobile page from Makefile, or manually edit the mobile version's HTML file.You MUST make sure the bookmarklets(or bookmarks in mobile version) installed on different browsers or computers have EXACTLY the same parameters, including password length, password charset, iteration and salt, otherwise they will NOT be compatible. Please keep the master password in mind and the related parameters in a safe place, losing any of them will lock you out of your accounts.
If you don't really trust a website, please stop using bookmarklet there, instead, use mobile version to generate passwords. Disclaimer:
This software is free to use, but AT YOUR OWN RISK.


This table contains the emissions for each region in 2019 [<IP_ADDRESS>] and the population of each region in 2019 [<IP_ADDRESS>]. We use data from 2019 so that we can ignore the effects of the pandemic, which caused an (unfortunately, short-term) reduction in CO2 emissions that was unequal across different regions.
in-context


()
In javascript, the parentheses denote a parameter. In JS we usually find the parentheses after a declared function. In this instance, we can call a function with a different value each time by changing the value in the parentheses when we call the function. This allows us to use the same code for many different tasks. We can also use parentheses to surround a conditional statements. We can also use parentheses to enforce mathematical order of operations eg BEDMAS.
[]
The brackets can mean different things in javascript. The first could be that the values inside of these brackets are an array. The second use could be that the brackets are used to access a property of an object through bracket notation eg object['property'].
{}
Braces can be used to construct an object, or enclose blocks of code.
' ' and " "
The use of single vs double quotes can depend greatly on the situation in which they are used. Some libraries may require a certain type of quote to be used. Whilst the use of both may be necessary in order to make the code readable. The quotes would be used in either case to declare a string or to access a property in an array in bracket notation.


{{'common.case1-desc' | translate}}
Making a donation is a way of reaching out a helping hand. By providing even a small donation, you can be part of an effort to provide medical assistance, supply food and shelter, and help families rebuild their lives and communities
Orphans are at the top of our Association's priorities, as it takes care of normal orphans and handicapped orphans through orphanages , and surrogate mothers take care of them, and an integrated group of supervisors and psychosocial specialists to provide integrated care for children. The association is also very interested in the alternative families project.
We offers is an idea to urge donors to benefit from the rewards of charity with the reception of the holy of year, where the donor can give his donation in ways that benefit the beneficiaries, including support for a patient's eye operation so that he can see again .. or Participation in a prosthetic limb for a poor family head so that she is able to work and take care of her family , or pure water compass to protect an entire family from diseases , heart operation to save a child.
100%
Safe
73 K
feeded childrens
3,012
helped poor families
Isolation hospitals bear a great responsibility in light of the current crisis and face challenges to complete their role in receiving and treating the injured .. and due to the lack of tools, supplies and medical devices in many hospitals, especially in the governorates and regions. This calls for everyone to join together to cover their needs and to cross us from the current crisis to safety.


Online RPS! (totally not gambling)
Username:
Password:
Login
RPS
(Definitely no gambling)
Play RPS!
create
Already registered?
Sign In
login
Not registered?
Create an account
Hey!
Logout
Return to Lobby


{% extends "layout.html" %}
{% block content %}You have marked less than 100 URLs as interesting, we recommend you head over to the Crawl Results page and click more check marks for sites you find interesting
{% else %}You have marked {{ num_yes_interest }} URLs as interesting, this is enough to run scoring and get good results.
{% endif %}You have marked less than 100 URLs as not interesting, we recommend you head over to the Crawl Results page and click more x's for sites you find interesting
{% else %}You have marked {{ num_no_interest }} URLs as not interesting, this is enough to run scoring and get good results.
{% endif %}Note: In order to get scores for new URLs picked up by crawls you need to run a rescore from this page.


Here is the first word of the sample page.
and here is the first paragraph of the sample page.
This is the link to page 2 Bacardi
here is some big text.
here is some medium text.


PMCMRplus: Calculate Pairwise Multiple Comparisons of Mean Rank Sums
Extended
For one-way layout experiments the one-way ANOVA can
be performed as an omnibus test. All-pairs multiple comparisons
tests (Tukey-Kramer test, Scheffe test, LSD-test)
and many-to-one tests (Dunnett test) for normally distributed
residuals and equal within variance are available. Furthermore,
all-pairs tests (Games-Howell test, Tamhane's T2 test,
Dunnett T3 test, Ury-Wiggins-Hochberg test) and many-to-one
(Tamhane-Dunnett Test) for normally distributed residuals
and heterogeneous variances are provided. Van der Waerden's normal
scores test for omnibus, all-pairs and many-to-one tests is
provided for non-normally distributed residuals and homogeneous
variances. The Kruskal-Wallis, BWS and Anderson-Darling
omnibus test and all-pairs tests
(Nemenyi test, Dunn test, Conover test, Dwass-Steele-Critchlow-
Fligner test) as well as many-to-one (Nemenyi test, Dunn test,
U-test) are given for the analysis of variance by ranks.
Non-parametric trend tests (Jonckheere test, Cuzick test,
Johnson-Mehrotra test, Spearman test) are included.
In addition, a Friedman-test for one-way ANOVA with repeated
measures on ranks (CRBD) and Skillings-Mack test for unbalanced
CRBD is provided with consequent all-pairs tests (Nemenyi test,
Siegel test, Miller test, Conover test, Exact test)
and many-to-one tests (Nemenyi test, Demsar test, Exact test).
A trend can be tested with Pages's test. Durbin's test
for a two-way balanced incomplete block design (BIBD) is given
in this package as well as Gore's test for CRBD with multiple
observations per cell is given. Outlier tests, Mandel's k- and
h statistic as well as functions for Type I error and Power
analysis as well as generic summary, print and plot methods
are provided.
| Version: |
1.4.1 |
| Depends: |
R (≥ 3.0.0) |
| Imports: |
mvtnorm (≥ 1.0), multcompView, gmp, Rmpfr, SuppDists, kSamples (≥ 1.2.7), BWStest (≥ 0.2.1), MASS |
| Suggests: |
xtable, graphics, knitr, rmarkdown, car, e1071, multcomp, pwr |
| Published: |
2018-11-12 |
| Author: |
Thorsten Pohlert |
| Maintainer: |
Thorsten Pohlert <thorsten.pohlert at gmx.de> |
| License: |
GPL (≥ 3) |
| NeedsCompilation: |
yes |
| SystemRequirements: |
gmp (>= 4.2.3), mpfr (>= 3.0.0) | file README.md |
| Materials: |
README NEWS |
| CRAN checks: |
PMCMRplus results |
Downloads:
Reverse dependencies:
Linking:
Please use the canonical form
https://CRAN.R-project.org/package=PMCMRplus
to link to this page.