Subversion Repositories uart2bus_testbench

//
//------------------------------------------------------------------------------
//   Copyright 2007-2010 Mentor Graphics Corporation
//   Copyright 2007-2011 Cadence Design Systems, Inc.
//   Copyright 2010 Synopsys, Inc.
//   Copyright 2014 NVIDIA Corportation
//   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
//
//       http://www.apache.org/licenses/LICENSE-2.0
//
//   Unless required by applicable law or agreed to in
//   writing, software distributed under the License is
//   distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
//   CONDITIONS OF ANY KIND, either express or implied.  See
//   the License for the specific language governing
//   permissions and limitations under the License.
//------------------------------------------------------------------------------

//------------------------------------------------------------------------------
//
// CLASS: uvm_event_base
//
// The uvm_event_base class is an abstract wrapper class around the SystemVerilog event
// construct.  It provides some additional services such as setting callbacks
// and maintaining the number of waiters.
//
//------------------------------------------------------------------------------

virtual class uvm_event_base extends uvm_object;
        const static string type_name = "uvm_event_base";
        protected event      m_event;
        protected int        num_waiters;
        protected bit        on;
        protected time       trigger_time=0;
        protected uvm_event_callback  callbacks[$];

        // Function: new
        //
        // Creates a new event object.

        function new (string name="");
                super.new(name);
        endfunction  

        //---------//
        // waiting //
        //---------//

        // Task: wait_on
        //
        // Waits for the event to be activated for the first time.
        //
        // If the event has already been triggered, this task returns immediately.
        // If ~delta~ is set, the caller will be forced to wait a single delta #0
        // before returning. This prevents the caller from returning before
        // previously waiting processes have had a chance to resume.
        //
        // Once an event has been triggered, it will be remain "on" until the event
        // is <reset>.

        virtual task wait_on (bit delta = 0);
                if (on) begin
                        if (delta)
                                #0;
                        return;
                end
                num_waiters++;
                @on;
        endtask


        // Task: wait_off
        //
        // If the event has already triggered and is "on", this task waits for the
        // event to be turned "off" via a call to <reset>.
        //
        // If the event has not already been triggered, this task returns immediately.
        // If ~delta~ is set, the caller will be forced to wait a single delta #0
        // before returning. This prevents the caller from returning before
        // previously waiting processes have had a chance to resume.

        virtual task wait_off (bit delta = 0);
                if (!on) begin
                        if (delta)
                                #0;
                        return;
                end
                num_waiters++;
                @on;
        endtask


        // Task: wait_trigger
        //
        // Waits for the event to be triggered. 
        //
        // If one process calls wait_trigger in the same delta as another process
        // calls <uvm_event#(T)::trigger>, a race condition occurs. If the call to wait occurs
        // before the trigger, this method will return in this delta. If the wait
        // occurs after the trigger, this method will not return until the next
        // trigger, which may never occur and thus cause deadlock.

        virtual task wait_trigger ();
                num_waiters++;
                @m_event;
        endtask


        // Task: wait_ptrigger
        //
        // Waits for a persistent trigger of the event. Unlike <wait_trigger>, this
        // views the trigger as persistent within a given time-slice and thus avoids
        // certain race conditions. If this method is called after the trigger but
        // within the same time-slice, the caller returns immediately.

        virtual task wait_ptrigger ();
                if (m_event.triggered)
                        return;
                num_waiters++;
                @m_event;
        endtask


        // Function: get_trigger_time
        //
        // Gets the time that this event was last triggered. If the event has not been
        // triggered, or the event has been reset, then the trigger time will be 0.

        virtual function time get_trigger_time ();
                return trigger_time;
        endfunction


        //-------//
        // state //
        //-------//

        // Function: is_on
        //
        // Indicates whether the event has been triggered since it was last reset. 
        //
        // A return of 1 indicates that the event has triggered.

        virtual function bit is_on ();
                return (on == 1);
        endfunction


        // Function: is_off
        //
        // Indicates whether the event has been triggered or been reset.
        //
        // A return of 1 indicates that the event has not been triggered.

        virtual function bit is_off ();
                return (on == 0);
        endfunction


        // Function: reset
        //
        // Resets the event to its off state. If ~wakeup~ is set, then all processes
        // currently waiting for the event are activated before the reset.
        //
        // No callbacks are called during a reset.

        virtual function void reset (bit wakeup = 0);
                event e;
                if (wakeup)
                        ->m_event;
                m_event = e;
                num_waiters = 0;
                on = 0;
                trigger_time = 0;
        endfunction



        //--------------//
        // waiters list //
        //--------------//

        // Function: cancel
        //
        // Decrements the number of waiters on the event. 
        //
        // This is used if a process that is waiting on an event is disabled or
        // activated by some other means.

        virtual function void cancel ();
                if (num_waiters > 0)
                        num_waiters--;
        endfunction


        // Function: get_num_waiters
        //
        // Returns the number of processes waiting on the event.

        virtual function int get_num_waiters ();
                return num_waiters;
        endfunction


        virtual function string get_type_name();
                return type_name;
        endfunction


        virtual function void do_print (uvm_printer printer);
                printer.print_field_int("num_waiters", num_waiters, $bits(num_waiters), UVM_DEC, ".", "int");
                printer.print_field_int("on", on, $bits(on), UVM_BIN, ".", "bit");
                printer.print_time("trigger_time", trigger_time);
                printer.m_scope.down("callbacks");
                foreach(callbacks[e]) begin
                        printer.print_object($sformatf("[%0d]",e), callbacks[e], "[");
                end
                printer.m_scope.up();
        endfunction


        virtual function void do_copy (uvm_object rhs);
                uvm_event_base e;
                super.do_copy(rhs);
                if(!$cast(e, rhs) || (e==null)) return;

                m_event = e.m_event;
                num_waiters = e.num_waiters;
                on = e.on;
                trigger_time = e.trigger_time;
                callbacks.delete();
                callbacks = e.callbacks;   

        endfunction

endclass


//------------------------------------------------------------------------------
//
// CLASS: uvm_event#(T)
//
// The uvm_event class is an extension of the abstract uvm_event_base class.  
// 
// The optional parameter ~T~ allows the user to define a data type which
// can be passed during an event trigger.
//------------------------------------------------------------------------------

class uvm_event#(type T=uvm_object) extends uvm_event_base;

        const static string type_name = "uvm_event";

        local T trigger_data;

        // Function: new
        //
        // Creates a new event object.

        function new (string name="");
                super.new(name);
        endfunction  


        // Task: wait_trigger_data
        //
        // This method calls <uvm_event_base::wait_trigger> followed by <get_trigger_data>.

        virtual task wait_trigger_data (output T data);
                wait_trigger();
                data = get_trigger_data();
        endtask


        // Task: wait_ptrigger_data
        //
        // This method calls <uvm_event_base::wait_ptrigger> followed by <get_trigger_data>.

        virtual task wait_ptrigger_data (output T data);
                wait_ptrigger();
                data = get_trigger_data();
        endtask


        //------------//
        // triggering //
        //------------//

        // Function: trigger
        //
        // Triggers the event, resuming all waiting processes.
        //
        // An optional ~data~ argument can be supplied with the enable to provide
        // trigger-specific information.

        virtual function void trigger (T data=null);
                int skip;
                skip=0;
                if (callbacks.size()) begin
                        for (int i=0;i<callbacks.size();i++) begin
                                uvm_event_callback#(T) tmp=callbacks[i];
                                skip = skip + tmp.pre_trigger(this,data);
                        end
                end
                if (skip==0) begin
                        ->m_event;
                        if (callbacks.size()) begin
                                for (int i=0;i<callbacks.size();i++) begin
                                        uvm_event_callback#(T) tmp=callbacks[i];
                                        tmp.post_trigger(this,data);
                                end
                        end
                        num_waiters = 0;
                        on = 1;
                        trigger_time = $realtime;
                        trigger_data = data;
                end
        endfunction


        // Function: get_trigger_data
        //
        // Gets the data, if any, provided by the last call to <trigger>.

        virtual function T get_trigger_data ();
                return trigger_data;
        endfunction

        virtual function string get_type_name();
                return type_name;
        endfunction
        
                //-----------//
        // callbacks //
        //-----------//

        // Function: add_callback
        //
        // Registers a callback object, ~cb~, with this event. The callback object
        // may include pre_trigger and post_trigger functionality. If ~append~ is set
        // to 1, the default, ~cb~ is added to the back of the callback list. Otherwise,
        // ~cb~ is placed at the front of the callback list.

        virtual function void add_callback (uvm_event_callback#(T) cb, bit append=1);
                for (int i=0;i<callbacks.size();i++) begin
                        if (cb == callbacks[i]) begin
                                uvm_report_warning("CBRGED","add_callback: Callback already registered. Ignoring.", UVM_NONE);
                                return;
                        end
                end
                if (append)
                        callbacks.push_back(cb);
                else
                        callbacks.push_front(cb);
        endfunction


        // Function: delete_callback
        //
        // Unregisters the given callback, ~cb~, from this event. 

        virtual function void delete_callback (uvm_event_callback#(T) cb);
                for (int i=0;i<callbacks.size();i++) begin
                        if (cb == callbacks[i]) begin
                                callbacks.delete(i);
                                return;
                        end
                end
                uvm_report_warning("CBNTFD", "delete_callback: Callback not found. Ignoring delete request.", UVM_NONE);
        endfunction

        virtual function void do_print (uvm_printer printer);
                super.do_print(printer);
                printer.print_object("trigger_data", trigger_data);
        endfunction
        
        virtual function void do_copy (uvm_object rhs);
                uvm_event#(T) e;
                super.do_copy(rhs);
                if(!$cast(e, rhs) || (e==null)) return;
                trigger_data = e.trigger_data;
        endfunction // do_copy

        virtual function uvm_object create(string name=""); 
                uvm_event#(T) v;
                v=new(name);
                return v;
        endfunction

endclass