Subversion Repositories hssdrc

//

// Project      : High-Speed SDRAM Controller with adaptive bank management and command pipeline

//

// Project Nick : HSSDRC

//

// Version      : 1.0-beta

//

// Revision     : $Revision: 1.1 $

//

// Date         : $Date: 2008-03-06 13:54:00 $

//

// Workfile     : hssrdc_bandwidth_monitor_class.sv

//

// Description  : bandwidth monitor measurement class

//

// HSSDRC is licensed under MIT License

//

// Copyright (c) 2007-2008, Denis V.Shekhalev (des00@opencores.org)

//

// Permission  is hereby granted, free of charge, to any person obtaining a copy of

// this  software  and  associated documentation files (the "Software"), to deal in

// the  Software  without  restriction,  including without limitation the rights to

// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of

// the  Software, and to permit persons to whom the Software is furnished to do so,

// subject to the following conditions:

//

// The  above  copyright notice and this permission notice shall be included in all

// copies or substantial portions of the Software.

//

// THE  SOFTWARE  IS  PROVIDED  "AS  IS",  WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS

// FOR  A  PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR

// COPYRIGHT  HOLDERS  BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER

// IN  AN  ACTION  OF  CONTRACT,  TORT  OR  OTHERWISE,  ARISING  FROM, OUT OF OR IN

// CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

//

`include "hssdrc_define.vh"

`include "hssdrc_timing.vh"

`include "hssdrc_tb_sys_if.vh"

`include "sdram_transaction_class.sv"

`include "hssrdc_driver_cbs_class.sv"

`ifndef __HSSDRC_BANDWIDTH_MONITOR_CLASS__

  `define __HSSDRC_BANDWIDTH_MONITOR_CLASS__

  class hssdrc_bandwidth_monitor_class extends hssrdc_driver_cbs_class;

    virtual hssdrc_tb_sys_if sys_if;

    // bandwidth measurement FSM

    enum {idle, wait_start, work} state = idle;

    // timestamps

    realtime end_time;

    realtime start_time;

    // word transfer counters

    int unsigned wr_word_num;

    int unsigned rd_word_num;

    // bandwidth measurement itself

    real write_bandwidth ;

    real read_bandwidth  ;

    real bandwidth       ;

    real write_bandwidth_percent  ;

    real read_bandwidth_percent   ;

    real bandwidth_percent        ;

    // semaphore to controll access to variables

    semaphore sem;

    // bandwidth measurement parameters

    real mbps_mfactor;

    real max_bandwidth;

    //  tb syncronization

    int measured_tr_num = 0;

    event done;

    function new (virtual hssdrc_tb_sys_if sys_if, ref event done);

      sem = new (1);

      this.sys_if = sys_if;

      this.done   = done;

    endfunction

    //

    // function to start measurement process

    //

    task start();

      sem.get (1) ;

      // set begin

      state = wait_start;

      // clear all counters

      end_time    = 0ns;

      start_time  = 0ns;

      wr_word_num = 0;

      rd_word_num = 0;

      measured_tr_num = 0;

      sem.put (1) ;

    endtask

    //

    // function to stop measurement process

    //

    task stop();

     sem.get (1);

     state = idle;

     count_bandwidth();

     sem.put (1);

    endtask

    //

    // callback for command part of hssdrc_driver_class

    //

    task post_Command (input realtime t);

    endtask

    //

    // callback for write part of hssdrc_driver_class

    //

    task post_WriteData (input realtime t, sdram_transaction_class tr);

      int burst;

    begin

      burst = tr.burst + 1;

      sem.get (1);

      if (state == wait_start) begin

        start_time  = t;

        state       = work;

      end

      else if (state == work) begin

        wr_word_num += burst;

        end_time    = t;

      end

      measured_tr_num++;

      -> done;

      sem.put (1);

    end

    endtask

    //

    // callback for read part of hssdrc_driver_class

    //

    task post_ReadData ( input realtime t, sdram_transaction_class tr);

      int burst;

    begin

      burst = tr.burst + 1;

      sem.get (1);

      if (state == wait_start) begin

        start_time  = t;

        state       = work;

      end

      else if (state == work) begin

        rd_word_num += burst;

        end_time    = t;

      end

      measured_tr_num++;

      -> done;

      sem.put (1);

    end

    endtask

    //

    // measurement count function bwth = mbps_mfactor*num/(end_time - start_time);

    //

    function void count_bandwidth();

      realtime delta;

      int unsigned wrrd_word_num;

    begin

      delta = (end_time - start_time);

      wrrd_word_num = wr_word_num + rd_word_num;

      write_bandwidth =   (wr_word_num/delta)*mbps_mfactor;

      read_bandwidth  =   (rd_word_num/delta)*mbps_mfactor;

      bandwidth       = (wrrd_word_num/delta)*mbps_mfactor;

      write_bandwidth_percent = write_bandwidth*100.0/max_bandwidth ;

      read_bandwidth_percent  = read_bandwidth *100.0/max_bandwidth ;

      bandwidth_percent       = bandwidth      *100.0/max_bandwidth ;

    end

    endfunction

    //

    // task to get multiplicatin factor for counters

    //

    task count_mbps_mfactor (int bytes_in_kilobytes) ;

      realtime delta;

      realtime scale;

    begin

      // define current timeunit value

      delta = $realtime;

      #1;

      delta = $realtime - delta;

      // define time scale factor

      scale = 1s/delta;

      // kilobytes

      mbps_mfactor = real'(scale)/(bytes_in_kilobytes);

      // megabytes

      mbps_mfactor = mbps_mfactor/(bytes_in_kilobytes);

      mbps_mfactor = mbps_mfactor*pDatamBits;

      // define max bandwwidth : 1 world per cycle period

      @(sys_if.cb);

      delta = $realtime;

      @(sys_if.cb);

      delta = $realtime - delta;

      max_bandwidth = (1/delta)*mbps_mfactor;

    end

    endtask

  endclass

`endif