Index
$#! · 0-9 · A · B · C · D · E · F · G · H · I · J · K · L · M · N · O · P · Q · R · S · T · U · V · W · X · Y · Z

$#! |
| `ovm_build avt_vmm_ovm_env
0-9 |
| 0 Release Notes-OVM/ VMM Interop Kit v1
| 1 Changes for OVM Interoperability VMM 1
A |
| Adapter Types
| Adapters
| analysis_export Global avt_analysis_channel avt_analysis2notify
| analysis_port Global avt_analysis_channel avt_notify2analysis
| ap
| apb_rw converter classes
| apb_rw_convert_ovm2vmm
| apb_rw_convert_vmm2ovm
| apb_scoreboard
| auto_blocking_master avt_channel2tlm
| auto_put avt_channel2tlm
| auto_stop_request avt_ovm_vmm_env_base
| auto_transport avt_channel2tlm
| avt_analaysis_channel adapter
| avt_analysis_channel
| avt_analysis_channel example
| avt_analysis2notify
| avt_analysis2notify adapter
| avt_analysis2notify example
| avt_channel2tlm
| avt_channel2tlm adapter
| avt_channel2tlm example
| avt_channel2tlm seq_item example
| avt_converter#(IN,OUT)
| avt_notify2analysis
| avt_notify2analysis adapter
| avt_notify2analysis example
| avt_ovm_vmm_env
| avt_ovm_vmm_env_base
| avt_ovm_vmm_env_named
| avt_tlm2channel
| avt_tlm2channel adapter
| avt_tlm2channel example 01_adapters/ 02_tlm2channel.sv 01_adapters/ 17_tlm2channel_passive_producer.sv
| avt_tlm2channel seq_item example
| avt_vmm_ovm_env
B |
| blocking transport tlm to channel
| blocking_get_peek_port avt_tlm2channel
| blocking_get_port
| blocking_master_port avt_channel2tlm
| blocking_put_port avt_channel2tlm avt_tlm2channel
| blocking_slave_port avt_tlm2channel
| blocking_transport_export avt_tlm2channel
| blocking_transport_port avt_channel2tlm
| blockling_put_export
| build Global avt_channel2tlm avt_ovm_vmm_env_base avt_tlm2channel
C |
| can_get avt_channel2tlm avt_tlm2channel
| can_peek avt_channel2tlm avt_tlm2channel
| can_put avt_channel2tlm avt_tlm2channel
| chan avt_analysis_channel
| Common type parameters
| convert Global avt_converter#(IN,OUT)
D |
| Documentation
E |
| end_of_elaboration avt_channel2tlm avt_tlm2channel
| Examples OVERVIEW.txt RELEASE_NOTES.txt
F |
| flush apb_scoreboard
G |
| get avt_channel2tlm avt_tlm2channel
| get_next_item avt_channel2tlm
| get_peek_export avt_channel2tlm
| get_requests avt_tlm2channel
| get_type_name avt_channel2tlm avt_tlm2channel
H |
| has_do_available avt_channel2tlm
I |
| IN avt_converter#(IN,OUT)
| in_chan
| INCOMING
| indicated Global avt_notify2analysis
| insert_vmm_phases avt_ovm_vmm_env_base
| Integrated Phase Control-OVM-on-top
| Integrated Phase Control-VMM-on-top
| Interop Library Setup
| IP Integration
| item_done avt_channel2tlm
L |
| License
M |
| Macros avt_vmm_ovm_env
| main
| master_export avt_tlm2channel
| max_pending_requests avt_channel2tlm
| Methods apb_scoreboard avt_analysis_channel avt_analysis2notify avt_channel2tlm avt_converter#(IN,OUT)avt_notify2analysis avt_ovm_vmm_env avt_ovm_vmm_env_base avt_ovm_vmm_env_named avt_tlm2channel avt_vmm_ovm_env
| Mixed Hierarchy
N |
| Navigating the Documentation
| new Global src/ ovm_producers.sv src/ vmm_consumers.sv apb_scoreboard avt_analysis_channel avt_analysis2notify avt_channel2tlm avt_notify2analysis avt_ovm_vmm_env avt_ovm_vmm_env_base avt_ovm_vmm_env_named avt_tlm2channel avt_vmm_ovm_env
| notify avt_analysis2notify avt_notify2analysis
O |
| ok_to_stop avt_ovm_vmm_env_base
| out
| OUT avt_converter#(IN,OUT)
| OVM Consumers
| OVM on top
| OVM Producers
| OVM Sequences
| OVM-VMM Interoperability Kit
| ovm_apb_rw
| ovm_apb_rw_sequence
| ovm_apb_rw_sequence_grab
| ovm_blocking_transport_producer
| ovm_build avt_vmm_ovm_env
| ovm_consumer
| ovm_driver_req
| ovm_driver_rsp
| ovm_passive_producer
| ovm_producer
| ovm_publish
| ovm_report avt_vmm_ovm_env
| ovm_subscribe
P |
| Parameters avt_converter#(IN,OUT)
| peek avt_channel2tlm avt_tlm2channel
| Ports avt_analysis_channel avt_analysis2notify avt_channel2tlm avt_notify2analysis avt_tlm2channel
| put Global avt_channel2tlm avt_tlm2channel
| put_export avt_channel2tlm avt_tlm2channel
| put_response avt_channel2tlm
| put_responses avt_tlm2channel
R |
| RECEIVED avt_analysis2notify avt_notify2analysis
| report apb_scoreboard avt_vmm_ovm_env
| req_chan Global avt_channel2tlm avt_tlm2channel
| request_ap avt_channel2tlm avt_tlm2channel
| reset_dut avt_vmm_ovm_env
| response_ap avt_channel2tlm avt_tlm2channel
| response_export avt_channel2tlm
| rsp_chan avt_channel2tlm avt_tlm2channel
| rsp_is_req avt_channel2tlm
| run Global src/ ovm_consumers.sv src/ ovm_producers.sv apb_scoreboard avt_analysis_channel avt_channel2tlm avt_ovm_vmm_env_base avt_tlm2channel
S |
| sbd_chan
| seq_item_export avt_channel2tlm
| seq_item_port Global avt_tlm2channel
| slave_export avt_channel2tlm
| Step 1-Simple block-level,mixed environment
| Step 2-Define an OVM IP block
| Step 3-Define a VMM IP block-Part A
| Step 3-Define a VMM IP block-Part B
| Step 4-VMM top-level
| Step 5-OVM sub-component level
| Step 6-OVM top-level
| Step 7-Module
| stop avt_ovm_vmm_env_base avt_vmm_ovm_env
T |
| The Basics
| transport avt_tlm2channel
| try_get avt_channel2tlm avt_tlm2channel
| try_next_item avt_channel2tlm
| try_peek avt_channel2tlm avt_tlm2channel
| try_put avt_channel2tlm avt_tlm2channel
V |
| Variables avt_analysis_channel avt_analysis2notify avt_channel2tlm avt_notify2analysis avt_ovm_vmm_env_base avt_tlm2channel
| VMM Consumers
| VMM on top
| VMM Producers
| vmm_cfg_dut avt_ovm_vmm_env_base
| vmm_consumer
| vmm_gen_cfg avt_ovm_vmm_env_base
| vmm_notifier
| vmm_notifier_consumer
| vmm_pipelined_consumer
| vmm_producer_1chan
| vmm_producer_2chan
| vmm_report avt_ovm_vmm_env_base
| vmm_reset_dut avt_ovm_vmm_env_base
| vmm_watcher
W |
| wait_for_ended avt_tlm2channel
| wait_for_req_ended avt_tlm2channel
| wait_for_sequences avt_channel2tlm
| Windows Users
| write avt_analysis_channel avt_analysis2notify avt_channel2tlm

Overrides the avt_vmm_ovm_env’s ovm_build method such that the call to advance OVM phasing up to end_of_elaboration is performed only once in the most derived env-subtype of a a potentially deep vmm_env-inheritance hierarchy.
Questa and IUS users who wish to use this interoperability kit must download and install the VMM 1.1.1 kit from OVM World.
Define adapter specialization typedefs for the apb_rw transactions type.
The adapters in this kit enable independently developed OVM and VMM components to communicate without modification.
Transactions are received via this inherited analysis export.
The adapter may receive OVM transactions via this analysis export.
The adapter receives OVM transactions via this analysis export.
The put method will also write the transaction to this port for coverage, scoreboarding or other analysis.
VMM transactions received from the channel are converted to OVM transactions and broadcast out this analysis port.
The adapter writes converted VMM data supplied by a vmm_notify event notification to this analysis_port.
Processed requests are published to this port.
This file defines the following converter classes
Convert OVM apb transactions to VMM apb transactions.
Convert VMM apb transactions to OVM apb transactions.
This OVM component accepts OVM transactions from its analysis export and VMM transactions from a vmm_channel passed in as a constructor argument.

> virtual task auto_blocking_master()

Used by this adapter to send transactions to passive OVM consumers.

> virtual task auto_put()

Used by this adapter to send transactions to passive OVM consumers.

> bit auto_stop_request = 0

When set, this bit enables calling an OVM stop_request after the VMM env’s wait_for_end task returns, thus ending OVM’s run phase coincident with VMM’s wait_for_end.

> virtual task auto_transport()

Used by this adapter to send transactions to passive OVM consumers.
A avt_analysis_channel isi used to connect an OVM component with an analysis port or export to any VMM component that uses a vmm_channel to communicate.

> class avt_analysis_channel #( | type | OVM | = | int,
> |  | VMM | = | int,
> |  | OVM2VMM | = | avt_converter #(OVM,VMM),
> |  | VMM2OVM | = | avt_converter #(VMM,OVM) | ) extends ovm_component

The avt_analysis_channel is used to connect any OVM component with an analysis port or export to any VMM component via a vmm_channel.
This example shows how to use the vmm_analysis_adapter to connect VMM xactors to OVM components with analysis ports and exports.

> class avt_analysis2notify #( | type | OVM | = | int,
> |  | VMM | = | int,
> |  | OVM2VMM | = | int | ) extends ovm_component

The avt_analysis2notify adapter receives OVM data from its analysis_export, converts it to VMM, then indicates the configured event notification, passing the converted data as vmm_data-based status.
An avt_analysis2notify is used to connect an OVM component broadcasting transactions via an analysis port to any VMM component receiving transaction via a vmm_nofity event notification.
This example shows how to use the avt_analysis2notify adapter to connect an OVM publisher to a VMM xactor that receives data via vmm_notify event notifications.

> class avt_channel2tlm #(
> | type | VMM_REQ | = | int,
> |  | OVM_REQ | = | int,
> |  | VMM2OVM_REQ | = | int,
> |  | OVM_RSP | = | OVM_REQ,
> |  | VMM_RSP | = | VMM_REQ,
> |  | OVM2VMM_RSP | = | avt_converter #(OVM_RSP,VMM_RSP),
> |  | OVM_MATCH_REQ_RSP | = | avt_match_ovm_id
> ) extends ovm_component

Use this class to connect a VMM producer to an OVM consumer.
A avt_channel2tlm adapter is used to connect any VMM producer using a vmm_channel to any OVM consumer using TLM ports or exports.
This example uses an avt_channel2tlm to connect an VMM producer (generator) to an OVM consumer.
This example uses the avt_channel2tlm adapter to connect an VMM producer to an OVM sequence item driver.

> class avt_converter #( | type | IN | = | int,
> |  | OUT | = | int | )

This converter is a non-functional placeholder used as a default parameter value for any adapters’ unused converters.

> class avt_notify2analysis #( | type | VMM | = | int,
> |  | OVM | = | int,
> |  | VMM2OVM | = | int | ) extends ovm_component

The avt_notify2analysis adapter receives VMM data supplied by a vmm_notify event notification, converts it to OVM, then broadcasts it to all components connected to its analysis_port
A avt_notify2analysis is used to connect a VMM component supplying transactions via vmm_nofity event notification to an OVM component with an analysis export.
This example shows how to use the avt_notify2analysis adapter to connect a VMM xactor that passes transactions via event notifications to an OVM analysis subscriber.

> class avt_ovm_vmm_env #( | type | ENV | = | vmm_env | ) extends avt_ovm_vmm_env_base

Use this class to wrap (contain) an existing VMM env whose constructor does not have a name argument.

> class avt_ovm_vmm_env_base extends ovm_component

The avt_ovm_vmm_env_base class is used to “wrap” an existing vmm_env subtype so that it may be reused as an ordinary OVM component in an OVM-on-top environment.

> class avt_ovm_vmm_env_named #( | type | ENV | = | vmm_env | ) extends avt_ovm_vmm_env_base

Use this class to wrap (contain) an existing VMM env whose constructor must have a name argument.

> class avt_tlm2channel #( | type | OVM_REQ | = | int,
> |  | VMM_REQ | = | int,
> |  | OVM2VMM_REQ | = | int,
> |  | VMM_RSP | = | VMM_REQ,
> |  | OVM_RSP | = | OVM_REQ,
> |  | VMM2OVM_RSP | = | avt_converter #(VMM_RSP,OVM_RSP) | ) extends ovm_component

Use this class to connect an OVM sequencer to a VMM driver via vmm_channel.
A avt_tlm2channel adapter is used to connect any OVM producer using TLM ports or exports to any VMM consumer using a vmm_channel.
This example uses an avt_tlm2channel adapter to connect an OVM producer (generator) to a VMM consumer (driver).
This example uses the avt_tlm2channel adapter to connect an OVM sequencer to a VMM driver type.

> class avt_vmm_ovm_env extends `AVT_VMM_OVM_ENV_BASE

This class is used to automatically integrate OVM phasing with VMM phasing in a VMM-on-top environment.
This example uses an vmm_channel_adapter to connect an OVM producer (generator) to a VMM consumer (driver).
This unidirectional port is used to retrieve responses from a passive OVM producer with a blocking get_peek export.
When connected, a consumer process will continually get from the port and call put with the received transaction.
For driving a passive OVM consumers via blocking master interface
For sending requests to passive OVM consumers via blocking put
This port is used to deliver responses to an OVM producer that expects responses from a blocking put interface.
This bidirectional port is used to request transactions from and deliver responses to a passive OVM producer utilizing a blocking slave interface.
This bidirectional export is used to receive requests from and deliver responses to an OVM producer that utilizes a blocking transport interface.
For atomic execution with passive OVM consumers via blocking transport
Transactions put to this export will be forwarded to the put method, where the received transaction is executed.

> virtual function void build()

Grabs any config settings for the number of transactions to generate and the particular extension of the transaction type to generate.

> virtual function void build()

Called as part of a predefined test flow, this function will retrieve the configuration setting for the rsp_is_req that this component’s req_chan variable has been configured with a non-null

> virtual function void build()

Calls the underlying VMM env’s build phase.

> virtual function void build()

Called as part of a predefined test flow, this function will retrieve the configuration setting for the wait_for_req_ended flag.

> virtual function bit can_get()

Returns 1 if a transactions is available to get, 0 otherwise.

> virtual function bit can_get()

Returns 1 if a response is available to get, 0 otherwise.

> virtual function bit can_peek()

Returns 1 if a transaction is available in the req_chan, 0 otherwise.

> virtual function bit can_peek()

Returns 1 if a transaction is available in the rsp_chan, 0 otherwise.

> virtual function bit can_put ()

Always returns 1 (true) because responses are sneaked into the channel.

> virtual function bit can_put ()

Returns 1 if the req_chan can accept a new request.

> vmm_channel_typed #( | VMM | ) chan

The vmm_channel instance being adapted; if not supplied in its new constructor, the adapter will create one.
Each adapter possesses a common set of type parameters that allow them to be used for any transaction type.

> static function vmm_apb_rw convert( | ovm_apb_rw | from, |  |
> | vmm_apb_rw | to | = | null | )

Converts an OVM apb transaction to a VMM apb transaction, including the transaction/data and sequence/scenario ids.

> static function OUT convert( | IN | in, |  |
> | OUT | to | = | null | )

Normally implemented to convert IN transactions to OUT transactions, the convert function in this class does nothing.
All documentation files for this interoperability kit is found in HTML format at $INTEROP_HOME/docs/html/index.html.

> virtual function void end_of_elaboration()

Called as part of a predefined test flow, this function will check that this component’s req_chan variable has been configured with a non-null instance of a vmm_channel #(VMM).

> virtual function void end_of_elaboration()

Called as part of a predefined test flow, this function will check that this component’s req_chan variable has been configured with a non-null instance of a vmm_channel #(VMM).
This section describes how to run the examples included in this kit.

> virtual function void flush()

This method resets the match and mismatch counts and flushes the internal transaction buffers.

> virtual task get( | output | OVM_REQ | o_req | )

Gets and converts a request from the req_chan vmm_channel.

> virtual task get( | output | OVM_RSP | o_rsp | )

Gets a response from the rsp_chan, converts, and returns in the o_rsp output argument.

> virtual task get_next_item( | output | OVM_REQ | t | )

Peeks and converts a request from the req_chan vmm_channel.
For OVM consumers getting requests via peek/get

> virtual task get_requests()

This task continually gets request transactions from the connected sequencer, converts them to an equivalent VMM transaction, and puts to the underlying req_chan vmm_channel.

> virtual function string get_type_name()

Returns the type name, i.e.

> virtual function string get_type_name()

Returns the type name, i.e.

> virtual function bit has_do_available()

Named for its association with OVM sequencer operation, this function will return 1 if there is a transaction available to get from the vmm_channel, req_chan.
The input type to convert from.

> vmm_channel_typed #( | T | ) in_chan

The vmm_channel from which new transasctions are obtained.

> int INCOMING

The notification id upon which this component will wait for a transaction.

> virtual function void indicated( | vmm_data | status | )

When the INCOMING notification is indicated, the incoming transaction is passed to this function for processing.

> virtual function void indicated( | vmm_data | status | )

Called back when the RECEIVED notification in the notify object is indicated, this method converts the VMM data given in the status argument to its OVM counterpart, then send it out the analysis_port to any connected subscribers.

> local static function bit insert_vmm_phases()

A static function that registers the vmm_gen_cfg phase callback with the OVM.
This class is used to wrap a VMM env for use as an ovm_component in an OVM environment.
This class is used to ensure OVM components (i.e.
The OVM-VMM interop kit consists of a set of Adapters and supporting Examples.
This example shows how to integrate an OVM agent IP in both a VMM-based (“VMM on top”) and OVM-based (“OVM on top”) environment.

> virtual function void item_done( | OVM_RSP | o_rsp | = | null | )

A non-blocking function indicating an OVM driver is done with the transaction retrieved with a get_next_item or get.
Copyright 2008-2009 Mentor Graphics Corporation All Rights Reserved Worldwide

> virtual protected task main()

A process that continually peeks transactions from in_chan, prints it, waits a bit, then pops it off the channel to unblock the producer.
This bidirectional export is used to receive requests from and deliver responses to an OVM producer that utilizes a blocking or non-blocking master interface.
Specifies the maximum number of requests that can be outstanding.
This example demonstrates how testbench environments can evolve to become mixed component hierarchies, where OVM instantiates VMM that instantiates OVM and so on.
The documentation is densely hyperlinked throughout for convenient navigation to related topics and more detailed descriptions of a particular class method or variable.

> function new ( | string | name,
> | ovm_component | parent | )

Creates a new instance of ovm_producer.

> function new( |  | string | name | = | "apb_scoreboard",
> |  | ovm_component | parent | = | null,
> | vmm_channel_typed | #(vmm_apb_rw) | vmm_fifo | = | null,
> |  | bit | always_pull | = | 0 | )

Creates a new instance of the apb_scoreboard.

> function new ( |  | string | name, |  |
> |  | ovm_component | parent | = | null,
> | vmm_channel_typed | #(VMM) | chan | = | null | )

Creates a new avt_analysis_channel with the given name and optional parent; the optional chan argument provides the handle to the vmm_channel being adapted.
Creates a new analysis-to-notify adapter with the given name and optional parent; the notify and notification_id together specify the notification event that this adapter will indicate upon receipt of a transaction on its analysis_export.

> function new ( |  | string | name | = | "avt_channel2tlm",
> |  | ovm_component | parent | = | null,
> | vmm_channel_typed | #(VMM_REQ) | req_chan | = | null,
> | vmm_channel_typed | #(VMM_RSP) | rsp_chan | = | null,
> |  | bit | rsp_is_req | = | 1,
> | int | unsigned | max_pending_req | = | 100 | )

Creates an instance of a avt_channel2tlm adaptor, with four optional arguments.

> function new ( | string | name, |  |
> | ovm_component | parent | = | null,
> | vmm_notify | notify | = | null,
> | int | notification_id | = | -1 | )

Creates a new notify-to-analysis adapter with the given name and optional parent; the notify and notification_id together specify the notification instance that this adapter will be sensitive to.

> function new ( | string | name, |  |
> | ovm_component | parent | = | null,
> | ENV | env | = | null | )

Creates a VMM env container component with the given name and parent.

> function new ( | string | name, |  |
> | ovm_component | parent | = | null,
> | vmm_env | env | = | null | )

Creates the vmm_env proxy class with the given name, parent, and optional vmm_env handle.

> function new ( | string | name, |  |
> | ovm_component | parent | = | null,
> | ENV | env | = | null | )

Creates a VMM env container component with the given name and parent.

> function new ( |  | string | name | = | "avt_tlm2channel",
> |  | ovm_component | parent | = | null,
> | vmm_channel_typed | #(VMM_REQ) | req_chan | = | null,
> | vmm_channel_typed | #(VMM_RSP) | rsp_chan | = | null,
> |  | bit | wait_for_req_ended | = | 0 | )

Creates a new avt_tlm2channel adapter given four optional arguments.

> function new( | string | name | = | "Verif Env" `VMM_ENV_BASE_NEW_EXTERN_ARGS | )

Creates a new instance of an avt_vmm_ovm_env.

> vmm_notify notify

The notify object that this adapter uses to indicate the RECEIVED event notification.

> vmm_notify notify

The notify object that this adapter uses to register a callback on the RECEIVED event notification.

> bit ok_to_stop = 0

When ok_to_stop is clear (default), the avt_ovm_vmm_env’s stop task will wait for the VMM env’s wait_for_end task to return before continuing.
This component uses this analysis port to publish transactions.
The output type to convert to.
This file defines the following OVM consumer components.
This example demonstrates a simple OVM-on-top environment, where OVM controls the phasing of OVM and any integrated VMM envs.
This file defines the following OVM producer components.
This file defines the following sequences.
This kit contains an OVM/VMM interoperability library that meets and exceeds the requirements recently approved by the Accellera VIP-TSC.

> class ovm_apb_rw extends ovm_sequence_item

This class defines the OVM equivalent of the apb_rw VMM transaction type.
This simple APB transaction sequence generates num_trans sequence items (transactions).
Defines a contrived sequence that exercises the grab and ungrab feature.

> virtual function void ovm_build()

Calls into the OVM’s phasing mechanism to complete OVM’s build, connect, and any other user-defined phases up to end_of_elaboration.
A generic OVM driver/consumer component that can get transactions from a blocking get port or receive transactions via is blocking put export.
This consumer’s run task will continually retrieve and execute transaction items from this port in one of two ways, chosen randomly ofr -- either using get_next_item/item_done or peek/get.
This consumer’s run task will continually retrieve, execute, and send back a response in one of three ways, chosen randomly-- either using peek/get, get/delay/put, or get_next_item/item_done.
Generic generator, inheriting from ovm_random_stimulus #(T), that produces transactions of the parameterized type, T, and puts them out the inherited blocking put port.
Uses an ovm_analysis_port to broadcast transactions to all its subscribers.

> virtual task ovm_report()

Calls into the OVM’s phasing mechanism to complete OVM’s extract, check, and report phases.
This consumer receives transactions via the ovm_analysis_export inherited from its ovm_subscriber base class.

> virtual task peek( | output | OVM_REQ | o_req | )

Peeks (does not consume) and converts a request from the req_chan vmm_channel.

> virtual task peek( | output | OVM_RSP | o_rsp | )

Peeks (does not consume) and converts a response from the rsp_chan.

> task put ( | T | tr | )

Called via the blocking_put_port or run process, this process “executes” the transaction by printing a message and waiting a bit of time.

> virtual task put ( | OVM_RSP | o_rsp | )

Converts and sneaks a response to the rsp_chan vmm_channel, if defined.

> virtual task put ( | OVM_REQ | o_req | )

Converts an OVM request to a VMM request and puts it into the req_chan vmm_channel.
For OVM consumers returning responses via blocking put
This export is used to receive transactions from an OVM producer that utilizes a blocking or non-blocking put interface.

> virtual function void put_response ( | OVM_RSP | o_rsp | )

A non-blocking version of put, this function converts and sneaks the given response into the rsp_chan vmm_channel.

> virtual task put_responses()

This task handles getting responses from the rsp_chan vmm_channel and putting them to the appropriate OVM response port.

> int RECEIVED

The notification id that this adapter indicates upon receipt of OVM data from its analysis_export.

> int RECEIVED

The notification id that, when indicated, will provide data to a callback registered by this adapter.

> virtual function void report()

Reports the number of matches and mismatches seen.

> virtual task report()

Calls into the OVM’s phasing mechanism to execute user-defined OVM phases inserted after report_ph, if any.

> vmm_channel_typed #( | T | ) req_chan, rsp_chan

The vmm_channel from which new transasctions are obtained.

> vmm_channel_typed #( | VMM_REQ | ) req_chan

Handle to the request vmm_channel #(VMM) instance being adapted.

> vmm_channel_typed #( | VMM_REQ | ) req_chan

Handle to the request vmm_channel #(VMM) instance being adapted.
All requests are broadcast out this analysis port after successful extraction from the request vmm_channel.
All transaction requests received from any of the interface ports and exports in this adapter are broadcast out this analysis port to any OVM subscribers.

> virtual task reset_dut()

Syncs the start of VMM reset_dut with the start of OVM run phase, then forks OVM run phase to run in parallel with reset_dut, config_dut, start, and wait_for_end.
All responses sent to the response channel are broadcast out this analysis port.
All transaction responses received from any of the interface ports and exports in this adapter are broadcast out this analysis port to any OVM subscribers.
For OVM consumers returning responses via analysis write

> vmm_channel_typed #( | VMM_RSP | ) rsp_chan

Handle to the response vmm_channel #(VMM) instance being adapted.

> vmm_channel_typed #( | VMM_RSP | ) rsp_chan

Handle to the response vmm_channel #(VMM) instance being adapted.

> protected bit rsp_is_req = 1

Indicates whether a response is the same object as the request with the status and/or read data filled in.

> task run()

If the blocking_get_port is connected, a the run task will continually get from the port and put the transaction for immediate execution.

> virtual task run()

Continually fetches OVM-VMM transaction pairs and compares them.

> virtual task run()

If the analysis_port is connected, the run task will continually get VMM transactions from the vmm_channel and end the converted transactions out the analysis_port.

> virtual task run()

Called as part of a predefined test flow, the run task forks a process for getting requests from the request channel and sending them to the OVM consumer connection via the blocking put port.

> virtual task run()

Calls the underlying VMM env’s reset_dut, cfg_dut, start, and wait_for_end phases, returning when the env’s end-of-test condition has been reached.

> virtual task run()

Called as part of a predefined test flow, the run task forks a process for getting requests from the seq_item_port and sending them to the req_chan vmm_channel.

> vmm_channel_typed #( | T | ) sbd_chan

A channel into which the received data is sneaked and from which the main method gets the data, so that the tee() call in the scoreboard will also see it.
Used by OVM driver consumers using the sequencer interface to process transactions.
Transactions are fetched from this port.
This bidirectional port is used to connect to an ovm_sequencer or any other component providing an ovm_seq_item_export.
For sending requests to passive OVM consumers via blocking put
We start with a simple mixed, block-level testbench that connects a VMM generator to on OVM driver via the avt_channel2tlm adapter.
At some point, we may decide to encapsulate the block-level testbench in an OVM IP block for reuse at the system level.
First encapsulate all OVM children with an OVM component wrapper that can make all port connections at the appropriate time.
Then, define the VMM IP block, which instantiates the OVM wrapper and other VMM components.
Let us now consider a vmm_env that contains our vmm_ip block and, optionally, other instances of OVM IP and VMM IP.
We can easily encapsulate our tb_env above for reuse as an ovm_component by extending a avt_ovm_vmm_env specialization, avt_ovm_vmm_env #(tb_env).
Let us now consider an ovm_env that contains our ovm_subcomp block and, optionally, other instances of OVM IP and VMM IP.
Although we can continue the sandwiching of OVM and VMM components indefinitely, we stop at this point by instantiating the ovm_env as a top-level component.

> virtual task stop( | string | ph_name | )

If the run phase is being stopped, this task waits for the underlying env’s wait_for_end phase to return, then calls the VMM env’s stop and cleanup tasks.

> virtual task stop()

Requests the OVM run phase to stop if it is still running, then waits for the OVM run phase to finish.

> task transport ( |  | OVM_REQ | o_req,
> | output | OVM_RSP | o_rsp | )

Blocking transport is used to atomically execute the geiven request transaction, req, and return the response in rsp.

> virtual function bit try_get( | output | OVM_REQ | o_req | )

If a transactions is available to get, returns the transaction in the o_req output argument, else returns 0.

> virtual function bit try_get( | output | OVM_RSP | o_rsp | )

If a response is available in the rsp_chan, gets and returns the response in the o_rsp output argument and returns 1.

> virtual task try_next_item ( | output | OVM_REQ | t | )

Waits a number of delta cycles waiting for a request transaction to arrive in the req_chan vmm_channel.

> virtual function bit try_peek( | output | OVM_REQ | o_req | )

If a request is available to peek from the req_chan, this function peeks (does not consume) the transaction from the channel, converts, and returns via the o_req output argument.

> virtual function bit try_peek( | output | OVM_RSP | o_rsp | )

If a response is available to peek from the rsp_chan, this function peeks (does not consume) the transaction from the channel, converts, and returns via the o_req output argument.

> virtual function bit try_put ( | OVM_RSP | o_rsp | )

Sneak the given response to the response channel, or copy the response to the corresponding request if rsp_is_req is set.

> virtual function bit try_put ( | OVM_REQ | o_req | )

If the req_chan can accept new requests, converts o_req to its VMM equivalent, injects it into the channel, and returns 1.
This file defines the following VMM consumer components.
This example demonstrates a VMM-on-top environment, where the vmm_env controls test flow phasing.
This file defines the following VMM consumer components.

> virtual task vmm_cfg_dut()

Calls the underlying VMM env’s cfg_dut phase, provided this phase was enabled in the new constructor.
A simple VMM consumer xactor that gets transactions from a channel and “executes” them by printing them and delaying a bit.

> virtual function void vmm_gen_cfg()

Calls the underlying VMM env’s gen_cfg phase.
VMM Producer that conveys transactions as status in a notify indication.
A VMM producer using a single request channel to put transactions and expects responses to be annotated in the original request.
A VMM producer using request and response channels.

> virtual task vmm_report()

Calls the underlying VMM env’s report method, then stops the reportvmm phase.

> virtual task vmm_reset_dut()

Calls the underlying VMM env’s reset_dut phase, provided this phase was enabled in the new constructor.
Receives data via notification status

> virtual task wait_for_ended( | VMM_REQ | v_req | )

Used to support VMM non-blocking completion models that indicate and return response status via each transaction’s ENDED notification.

> protected bit wait_for_req_ended = 0

When the VMM consumer does not use a separate response channel, this bit specifies whether the response, which is annotated into the original request, is available after a get from the request channel (wait_for_req_ended=0) or after the original request’s ENDED status is indicated (wait_for_req_ended=1).

> virtual task wait_for_sequences()

Used in the try_next_item method, this method waits a variable number of #0 delays.
Windows users running on cygwin must take care to specify paths in env variables to work around the different filepath formats used between Windows OS and cygwin.

> function void write( | OVM | ovm_t | )

The write method, called via the analysis_export, converts an incoming OVM transaction to its VMM counterpart, then sneaks the converted transaction to the vmm_channel.

> virtual function void write( | OVM | t | )

The write method, called via the analysis_export, converts an incoming OVM transaction to its VMM counterpart, then indicates the configured RECEIVE notification, passing the converted data as status.

> virtual function void write( | OVM_RSP | o_rsp | )

Used by active OVM consumers to send back responses.