vmm_channel.sv

Go to the documentation of this file.

// 
// -------------------------------------------------------------
//    Copyright 2004-2008 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
// 
//        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.
// -------------------------------------------------------------
// 


// ToDo: Fill level based on bytes
   
function vmm_channel::new(string       name,
                          string       inst,
                          int unsigned full,
                          int unsigned empty,
                          bit          fill_as_bytes);
`ifdef VMM_CHANNEL_BASE_NEW_CALL
   super.new(`VMM_CHANNEL_BASE_NEW_CALL);
`endif

   if (this.one_log) begin
      if (this.shared_log == null) begin
         this.shared_log = new("VMM Channel", "[shared]");
      end
      this.log = shared_log;
   end else this.log = new(name, inst);

   this.notify = new(this.log);
   this.notify.configure(FULL,  vmm_notify::ON_OFF);
   this.notify.configure(EMPTY, vmm_notify::ON_OFF);
   this.notify.configure(PUT);
   this.notify.configure(GOT);
   this.notify.configure(PEEKED);
   this.notify.configure(ACTIVATED);
   this.notify.configure(ACT_STARTED);
   this.notify.configure(ACT_COMPLETED);
   this.notify.configure(ACT_REMOVED);
   this.notify.configure(LOCKED);
   this.notify.configure(UNLOCKED);

   if (full <= 0) full = 1;
   if (empty < 0 || empty > full) empty = full;

   this.full = full;
   this.empty = empty;
   this.is_sunk  = 0;

   this.active = null;
   this.active_status = INACTIVE;
   this.tee_on = 0;
   this.downstream = null;
   this.locks  = 2'b00;

   this.full_chan = 0;
   this.notify.indicate(EMPTY);

   this.iterator = 0;

   //
   // Thread to manage connection requests
   //
   fork: connection_requests
      while (1)
      begin : new_while_loop
         vmm_data data = null;

         // Broken connection?
         if (this.downstream != null)
         begin
            if (this.log.start_msg(vmm_log::INTERNAL_TYP, vmm_log::TRACE_SEV))
            begin
               string txt;
               txt = {"Channel connection established: ",
                      this.log.get_name(),
                      "(", this.log.get_instance(), ") -> ",
                      this.downstream.log.get_name(),
                      "(", this.downstream.log.get_instance(), ")"};
       
               this.log.text(txt);
               this.log.end_msg();
            end // if debug level
     
            // Fork the data mover thread
            fork
               while (1)
               begin : inner_while_loop
                  // Simple blocking interface
                  data = null;
                  this.peek(data);
                  this.downstream.put(data);
                  this.get(data);
               end // inner_while_loop
            join_none
         end // if downstream != null
     
         // Wait for new connection requests
         @this.new_connection;
         
         // Stop the data mover thread
         disable fork;
        
         // Remove any datum that was forwarded
         // to the downstream channel but not removed
         // from this channel because of the blocking
         // model. Otherwise, the same datum will be
         // obtained from this channel twice.
         if (data != null) this.get(data);
     end // while (1)
   join_none // connection_requests
endfunction : new


function void vmm_channel::reconfigure(int   full,
                                       int   empty,
                                       logic fill_as_bytes);
   if (full < 0) full = this.full;
   if (full == 0) full = 1;
   if (empty < 0) empty = this.empty;

   if (full < empty)
   begin
      `vmm_error(this.log, "Cannot reconfigure channel with FULL < EMPTY");
      return;
   end

   this.full = full;
   this.empty = empty;

   if (this.level() >= this.full)
   begin 
      this.full_chan = 1;
      this.notify.indicate(FULL);
      this.notify.reset(EMPTY);
   end
   else if (this.level() <= this.empty)
   begin
      this.full_chan = 0;
      -> this.item_taken;
      this.notify.indicate(EMPTY);
      this.notify.reset(FULL);
   end
   else
   begin
      this.full_chan = 0;
      -> this.item_taken;
      this.notify.reset(EMPTY);
      this.notify.reset(FULL);
   end
endfunction: reconfigure


function int unsigned vmm_channel::full_level();
   full_level = this.full;
endfunction: full_level


function int unsigned vmm_channel::empty_level();
   empty_level = this.empty;
endfunction: empty_level


function int unsigned vmm_channel::level();
   level = this.data.size() + ((this.active == null) ? 0 : 1);
endfunction: level


function int unsigned vmm_channel::size();
   size = this.data.size() + ((this.active == null) ? 0 : 1);
endfunction : size


function bit vmm_channel::is_full();
   is_full = full_chan;
endfunction : is_full


function void vmm_channel::flush();
   vmm_data obj;
   if (this.downstream != null)
      this.downstream.flush();

   this.data.delete();
   this.tee_data.delete();
   full_chan = 0;
   this.active = null;
   this.active_status = INACTIVE ;
   -> this.item_taken;
   this.notify.reset(FULL);
   this.notify.indicate(EMPTY);
endfunction: flush


function void vmm_channel::sink();
   this.flush();
   this.is_sunk = 1;
endfunction: sink


function void vmm_channel::flow();
   this.is_sunk = 0;
endfunction: flow


function void vmm_channel::reset();
   this.flush();
endfunction: reset


function void vmm_channel::lock(bit [1:0] who);
   this.locks |= who;
   this.notify.indicate(LOCKED);
endfunction: lock


function void vmm_channel::unlock(bit [1:0] who);
   this.locks &= ~who;
   this.notify.indicate(UNLOCKED);
   // May cause a consumer or producer to unblock
   -> this.item_taken;
   -> this.item_added;
endfunction: unlock


function bit vmm_channel::is_locked(bit [1:0] who);
   is_locked = (this.locks & who) ? 1 : 0;
endfunction: is_locked


function void vmm_channel::display(string prefix);
   $display(this.psdisplay(prefix));
endfunction: display


function string vmm_channel::psdisplay(string prefix);
   $sformat(psdisplay, "%sChannel %s(%s): Level = %0d of %0d (empty=%0d)",
            prefix, this.log.get_name(), this.log.get_instance(),
            this.level(), this.full, this.empty);
   case (this.locks) 
      SOURCE+SINK : psdisplay = {psdisplay, " [src+snk locked]"};
      SOURCE:       psdisplay = {psdisplay, " [src locked]"};
      SINK:         psdisplay = {psdisplay, " [snk locked]"};
   endcase
   if (this.is_sunk) psdisplay = {psdisplay, " (sunk)"};

   foreach(this.data[i]) begin
      $sformat(psdisplay, "%s\n%s", psdisplay, this.data[i].psdisplay(`vmm_sformatf("%s   [%0d] ",
                                                                                    prefix, i)));
   end
endfunction: psdisplay


`ifndef VMM_OV_INTEROP
task vmm_channel::put(vmm_data obj,
                      int offset);
   if (obj == null)
   begin
      `vmm_error(this.log, "Attempted to put null instance into channel");
      return;
   end // if obj == null

   this.block_producer();
   this.sneak(obj, offset);
   this.block_producer();
endtask: put
`endif

function void vmm_channel::sneak(vmm_data obj,
                                 int offset);
   string txt;

   if (obj == null)
   begin
      `vmm_error(this.log, "Attempted to sneak null instance into channel");
      return;
   end // obj == null

   if (this.is_sunk) return;

   if (offset == -1 || (offset == 0 && this.data.size() == 0))
   begin
      this.data.push_back(obj);
   end
   else
   begin
      int idx = this.index(offset);
      if (idx < 0) return;

      this.data.insert(offset, obj);
   end // if offset

   if (this.log.start_msg(vmm_log::INTERNAL_TYP, vmm_log::DEBUG_SEV))
   begin
     $sformat(txt, "New instance added to channel @%0d (level %0d of %0d/%0d)\n%s",
              offset, this.level(), this.full, this.empty,
              obj.psdisplay("    "));
      this.log.text(txt);
      this.log.end_msg();
   end // if dbg

   this.notify.indicate(PUT, obj);

   if (this.level() >= this.full)
   begin
      this.full_chan = 1;
      this.notify.indicate(FULL);
   end

   if (this.level() > this.empty)
   begin
      this.notify.reset(EMPTY);
   end

   -> this.item_added;
endfunction: sneak


function vmm_data vmm_channel::unput(int offset);
   if (this.size() == 0)
   begin
      `vmm_error(this.log, "Cannot unput from an empty channel");
      return null;
   end // if size == 0

   if (offset == -1)
   begin
     unput = this.data.pop_back();
   end
   else
   begin
     int idx = this.index(offset);
     if (idx < 0)
     begin
        unput = null;
     end
     else
     begin
        unput = this.data[idx];
        this.data.delete(idx);
     end
   end // if offset != -1

   if (unput != null) begin
      this.notify.indicate(GOT, unput);
      if (this.log.start_msg(vmm_log::INTERNAL_TYP, vmm_log::DEBUG_SEV))
      begin
         string txt;
         $sformat(txt, "Instance unput from channel @%0d (level %0d of %0d/%0d)\n%s", 
                  offset, this.level(), this.full, this.empty,
                  unput.psdisplay("    "));
         this.log.text(txt);
         this.log.end_msg();
      end // if dbg_lvl
   end

   this.unblock_producer();
endfunction: unput


task vmm_channel::get1(output vmm_data obj,
                       input  int      offset);
   if (offset == 0)
   begin
      obj = this.data.pop_front();
   end
   else
   begin
      int idx = this.index(offset);
      if (idx < 0)
      begin
         obj = null;
      end
      else 
      begin
         obj = this.data[idx];
         this.data.delete(idx);
      end // else if idx < 0
    end // else if offset

   if (obj != null)
   begin
      this.notify.indicate(GOT, obj);
      if (this.log.start_msg(vmm_log::INTERNAL_TYP, vmm_log::DEBUG_SEV))
      begin
         string txt;
         $sformat(txt, "New instance removed from channel @%0d (level %0d of %0d/%0d)\n%s", 
                  offset, this.level(), this.full, this.empty,
                  obj.psdisplay("    "));
         this.log.text(txt);
         this.log.end_msg();
      end // if dbg_lvl

      if (this.tee_on)
      begin
         this.tee_data.push_back(obj);
         -> this.teed;
      end // tee_on

`ifdef VCS
`ifdef VMM_SB_DS_IN_STDLIB
      foreach (this._vmm_sb_ds[i]) begin
         if (this._vmm_sb_ds[i].is_in) begin
            this._vmm_sb_ds[i].sb.insert(obj);
         end

         if (this._vmm_sb_ds[i].is_out) begin
            case (this._vmm_sb_ds[i].order)
              vmm_sb_ds::IN_ORDER:
                this._vmm_sb_ds[i].sb.expect_in_order(obj);

              vmm_sb_ds::WITH_LOSSES: begin
                 vmm_data p;
                 vmm_data losses[];
                 this._vmm_sb_ds[i].sb.expect_with_losses(obj, p, losses);
              end

              vmm_sb_ds::OUT_ORDER:
                this._vmm_sb_ds[i].sb.expect_out_of_order(obj);

            endcase
         end
      end
`endif
`endif
   end // if obj != null
endtask: get1


task vmm_channel::get(output vmm_data obj,
                      input  int      offset);
   this.block_consumer();
   this.get1(obj, offset);
   this.unblock_producer();
endtask: get

task vmm_channel::peek(output vmm_data obj,
                       input  int      offset);
   string txt;
   int    idx;

   this.block_consumer();

   idx = this.index(offset);
   if (idx < 0)
   begin
      obj = null;
   end
   else
   begin
      obj = this.data[idx];
   end

   if (obj != null)
   begin
      this.notify.indicate(PEEKED, obj);
      if (this.log.start_msg(vmm_log::INTERNAL_TYP, vmm_log::DEBUG_SEV))
      begin
         $sformat(txt, "New instance peeked from channel @%0d (level %0d of %0d/%0d)\n%s",
                  offset, this.level(), this.full, this.empty,
                  obj.psdisplay("    "));
         this.log.text(txt);
         this.log.end_msg();
      end // if dbg_lvl
   end // obj != null

   this.unblock_producer();
endtask: peek


task vmm_channel::activate(output vmm_data obj,
                           input  int      offset);
   string txt;

   // Empty the active slot
   if (active != null) 
       this.remove();
 
   while (this.size() == 0) 
      @this.item_added;

   if (offset == 0)
   begin
      obj = this.data.pop_front();
   end
   else
   begin
      int idx = this.index(offset);
      if (idx < 0)
      begin
        obj = null;
      end
      else
      begin
        obj = this.data[idx];
        this.data.delete(idx);
      end
   end // else if offset == 0


   if (obj != null)
   begin
      this.active = obj;
      this.active_status = PENDING ;
      this.notify.indicate(ACTIVATED, obj);
      this.notify.indicate(PEEKED, obj);

      if (this.log.start_msg(vmm_log::INTERNAL_TYP, vmm_log::DEBUG_SEV))
      begin
         $sformat(txt, "New instance activated from channel @%0d (level %0d of %0d/%0d)\n%s",
                  offset, this.level(), this.full, this.empty,
                  obj.psdisplay("    "));
         this.log.text(txt);
         this.log.end_msg();
      end // if dbg_lvl

      if (this.tee_on)
      begin
         this.tee_data.push_back(obj);
         -> this.teed;
      end
   end // if obj != null
endtask: activate


function vmm_data vmm_channel::active_slot();
   active_slot = this.active;
endfunction: active_slot


function vmm_data vmm_channel::start();
   if (this.active == null)
   begin
      `vmm_fatal(this.log, "Cannot start() without prior activate()");
      return null;
   end // if active == null

   if (this.active_status == STARTED)
   begin
      `vmm_warning(this.log, "Active slot already start()'ed");
   end // if STARTED

   this.active_status = STARTED;
   this.notify.indicate(ACT_STARTED, this.active);
   this.active.notify.indicate(vmm_data::STARTED);
   start = this.active;
endfunction: start


function vmm_data vmm_channel::complete(vmm_data status);
   if (this.active == null)
   begin
      `vmm_fatal(this.log, "Cannot complete() without prior activate()");
      return null;
   end
   if (this.active_status != STARTED)
   begin
      `vmm_warning(this.log, "complete() called without start()");
   end

   this.active_status = COMPLETED;
   this.notify.indicate(ACT_COMPLETED, this.active);
   this.active.notify.indicate(vmm_data::ENDED, status);
   complete = this.active;
endfunction: complete


function vmm_data vmm_channel::remove();
   if (this.active == null)
   begin
      `vmm_fatal(this.log, "Cannot remove() without prior activate()");
      return null;
   end

   // OK to remove if not started or completed   
   if (this.active_status == STARTED)
   begin
      `vmm_warning(this.log, "remove() called without complete()");
   end

   this.notify.indicate(ACT_REMOVED, this.active);
   this.notify.indicate(GOT, this.active);
   if (this.active_status != COMPLETED)
   begin
      this.active.notify.indicate(vmm_data::ENDED);
   end
   this.active_status = INACTIVE;
   remove = this.active;
   this.active = null;

   this.unblock_producer();
endfunction: remove


function vmm_channel::active_status_e vmm_channel::status();
   status = this.active_status;
endfunction: status


function bit vmm_channel::tee_mode(bit is_on);
   string txt;
   if (this.log.start_msg(vmm_log::INTERNAL_TYP, vmm_log::TRACE_SEV))
   begin
      $sformat(txt, "tee branch turned %0s", (is_on) ? "ON" : "OFF");
      this.log.text(txt);
      this.log.end_msg();
   end

   tee_mode = this.tee_on;
   this.tee_on = is_on;
endfunction: tee_mode


task vmm_channel::tee(output vmm_data obj);
   string txt;
   while (this.tee_data.size() == 0) 
      @this.teed;

   obj = this.tee_data.pop_front();

   if (this.log.start_msg(vmm_log::INTERNAL_TYP, vmm_log::DEBUG_SEV))
   begin
      $sformat(txt, "New instance teed from channel (level %0d of %0d/%0d)\n%s",
                  this.level(), this.full, this.empty,
                  obj.psdisplay("    "));
      this.log.text(txt);
      this.log.end_msg();
   end
endtask: tee


function void vmm_channel::connect(vmm_channel downstream);
   // Do not disrupt an already-established connection
   if (this.downstream == downstream) return;

   // Indicate a new connection
   this.downstream = downstream;
   -> this.new_connection;
endfunction: connect


function vmm_data vmm_channel::for_each(bit reset);
   if (reset) this.iterator = 0;
   else this.iterator++;

   if (this.iterator >= this.data.size()) for_each = null;
   else for_each = this.data[this.iterator];
endfunction: for_each


function int unsigned vmm_channel::for_each_offset();
   for_each_offset = this.iterator;
endfunction: for_each_offset


function bit vmm_channel::record(string filename);
   if (filename == "")
   begin
      return 1;
   end

   `vmm_warning(this.log, "vmm_channel::record() not implemented yet");
   record = 0;
endfunction: record


task vmm_channel::playback(output bit      success,
                           input  string   filename,
                           input  vmm_data loader,
                           input  bit      metered);
   `vmm_fatal(this.log, "vmm_channel::playback() not implemented yet");
   success = 0;
endtask: playback


function int vmm_channel::index(int offset);
   string txt;
   index = offset;
   if (offset < 0) index += this.data.size() + offset + 1;
   if (index < 0 || index >= this.data.size())
   begin
      if (this.log.start_msg(vmm_log::FAILURE_TYP, vmm_log::FATAL_SEV))
      begin
         $sformat(txt, "Invalid offset %0d specified. Not in {0:%0d}.\n",
                  offset, this.data.size()-1);
         this.log.text(txt);
         this.log.end_msg();
      end
      index = -1;
   end
endfunction: index


`ifndef VMM_OV_INTEROP
task vmm_channel::block_producer();
   while (this.full_chan || this.is_locked(SOURCE)) 
      @this.item_taken;
endtask : block_producer


task vmm_channel::block_consumer();
   while (this.size() == 0 || this.is_locked(SINK)) 
      @this.item_added;
endtask: block_consumer
`endif


task vmm_channel::unblock_producer();
   if (this.level() <= this.empty)
   begin
      this.full_chan = 0;
      this.notify.indicate(EMPTY);
   end

   if (this.level() < this.full)
   begin
      this.notify.reset(FULL);
   end

   -> this.item_taken;
endtask: unblock_producer





`ifdef VCS
`ifdef VMM_SB_DS_IN_STDLIB
function void vmm_channel::register_vmm_sb_ds(vmm_sb_ds             sb,
                                              vmm_sb_ds::kind_e     kind,
                                              vmm_sb_ds::ordering_e order);
   vmm_sb_ds_registration ds;

   foreach (this._vmm_sb_ds[i]) begin
      if (this._vmm_sb_ds[i].sb == sb) begin
         `vmm_warning(this.log, "Data stream scoreboard is already registered");
         return;
      end
   end

   ds = new;
   ds.sb = sb;
   ds.is_in = (kind == vmm_sb_ds::INPUT ||
               kind == vmm_sb_ds::EITHER);
   ds.is_out = (kind == vmm_sb_ds::EXPECT ||
                kind == vmm_sb_ds::EITHER);
   ds.order = order;
   this._vmm_sb_ds.push_back(ds);
endfunction: register_vmm_sb_ds


function void vmm_channel::unregister_vmm_sb_ds(vmm_sb_ds sb);
   foreach (this._vmm_sb_ds[i]) begin
      if (this._vmm_sb_ds[i].sb == sb) begin
         this._vmm_sb_ds.delete(i);
         return;
      end
   end

   `vmm_error(this.log, "Data stream scoreboard is not registered");
endfunction: unregister_vmm_sb_ds
`endif

`endif