Buffer.h

 #ifndef __NOXIMBUFFER_H__
 #define __NOXIMBUFFER_H__

 #include <cassert>
 #include <queue>
 #include "DataStructs.h"
 using namespace std;

class Buffer {

.................

};

#endif

public:

     Buffer(); //构造函数

     virtual ~ Buffer() {//虚析构函数解决因delete基类指针导致的资源泄漏
     } 

 Buffer::Buffer()
 {
   SetMaxBufferSize(GlobalParams::buffer_depth);
   max_occupancy = ;
   hold_time = 0.0;
   last_event = 0.0;
   hold_time_sum = 0.0;
   previous_occupancy = ;
   mean_occupancy = 0.0;
   true_buffer = true;
   full_cycles_counter = ;
   last_front_flit_seq = NOT_VALID;
   deadlock_detected = false;
 }

Buffer()

     void SetMaxBufferSize(const unsigned int bms);    // Set buffer max size (in flits)

     unsigned int GetMaxBufferSize() const;    // Get max buffer size

     unsigned int getCurrentFreeSlots() const;    // free buffer slots

     bool IsFull() const;    // Returns true if buffer is full

     bool IsEmpty() const;    // Returns true if buffer is empty

     virtual void Drop(const Flit & flit) const;    // Called by Push() when buffer is full

     virtual void Empty() const;    // Called by Pop() when buffer is empty

     void Push(const Flit & flit);    // Push a flit. Calls Drop method if buffer is full

     Flit Pop();        // Pop a flit

     Flit Front() const;    // Return a copy of the first flit in the buffer

     unsigned int Size() const;

     void ShowStats(std::ostream & out);

     void Disable();

     void Print();

     bool deadlockFree();
     void deadlockCheck();

     void setLabel(string);
     string getLabel() const;

 void Buffer::SetMaxBufferSize(const unsigned int bms)
 {
   assert(bms > );

   max_buffer_size = bms;
 }

SetMaxBufferSize(const unsigned int bms)

 unsigned int Buffer::GetMaxBufferSize() const
 {
   return max_buffer_size;
 }

GetMaxBufferSize() const

 unsigned int Buffer::getCurrentFreeSlots() const
 {
   return (GetMaxBufferSize() - Size());
 }

getCurrentFreeSlots() const

 unsigned int Buffer::Size() const
 {
   return buffer.size();
 }

Size() const

 bool Buffer::IsFull() const
 {
   return buffer.size() == max_buffer_size;
 }

 bool Buffer::IsEmpty() const
 {
   return buffer.size() == ;
 }

 void Buffer::Drop(const Flit & flit) const
 {
   assert(false);
 }

 void Buffer::Empty() const
 {
   assert(false);
 }

 void Buffer::Push(const Flit & flit)
 {
     SaveOccupancyAndTime();

     if (IsFull())
         Drop(flit);
     else
         buffer.push(flit);

     UpdateMeanOccupancy();

     if (max_occupancy < buffer.size())
         max_occupancy = buffer.size();
 }

Push(const Flit & flit)

 Flit Buffer::Pop()
 {
   Flit f;

   SaveOccupancyAndTime();

   if (IsEmpty())
     Empty();
   else {
     f = buffer.front();
     buffer.pop();
   }

   UpdateMeanOccupancy();

   return f;
 }

Pop()

 Flit Buffer::Front() const
 {
   Flit f;

   if (IsEmpty())
     Empty();
   else
     f = buffer.front();

   return f;
 }

Front() const

 void Buffer::SaveOccupancyAndTime()
 {
   previous_occupancy = buffer.size();
   hold_time = (sc_time_stamp().to_double() / GlobalParams::clock_period_ps) - last_event;
   last_event = sc_time_stamp().to_double() / GlobalParams::clock_period_ps;
 }

SaveOccupancyAndTime()

 void Buffer::UpdateMeanOccupancy()
 {
   double current_time = sc_time_stamp().to_double() / GlobalParams::clock_period_ps;
   if (current_time - GlobalParams::reset_time < GlobalParams::stats_warm_up_time)
     return;

   mean_occupancy = mean_occupancy * (hold_time_sum/(hold_time_sum+hold_time)) + (1.0/(hold_time_sum+hold_time)) * hold_time * buffer.size();
   hold_time_sum += hold_time;
 }

UpdateMeanOccupancy()

 void Buffer::ShowStats(std::ostream & out)
 {
   if (true_buffer)
     out << "\t" << mean_occupancy << "\t" << max_occupancy;
   else
     out << "\t\t";
 }

ShowStats(std::ostream & out)

 void Buffer::setLabel(string l)
 {
     //cout << "\n BUFFER LABEL: " << l << endl;
     label = l;
 }

 string Buffer::getLabel() const
 {
     return label;
 }

 void Buffer::Print()
 {
     queue<Flit> m = buffer;

     string bstr = "";

     char  t[] = "HBT";

     cout << label << " | ";
     while (!(m.empty()))
     {
         Flit f = m.front();
         m.pop();
         cout << bstr << t[f.flit_type] << f.sequence_no <<  "(" << f.dst_id << ") | ";
     }
     cout << endl;
 }

 void Buffer::deadlockCheck()
 {
     // TOOD: add as parameter
     int check_threshold = ;

     if (IsEmpty()) return;

     Flit f = buffer.front();
     int seq = f.sequence_no;

     if (last_front_flit_seq == seq)
     {
         full_cycles_counter++;
     }
     else
     {
         if (deadlock_detected)
         {
             cout << " WRONG DEADLOCK detection, please increase the check_threshold " << endl;
             assert(false);
         }
         last_front_flit_seq = seq;
         full_cycles_counter=;
     }

     if (full_cycles_counter>check_threshold && !deadlock_detected)
     {
         double current_time = sc_time_stamp().to_double() / GlobalParams::clock_period_ps;
         cout << "WARNING: DEADLOCK DETECTED at cycle " << current_time << " in buffer:  " << getLabel() << endl;
         deadlock_detected = true;
     }
 }

deadlockCheck()

 bool Buffer::deadlockFree()
 {
     if (IsEmpty()) return true;

     Flit f = buffer.front();

     int seq = f.sequence_no;

     if (last_front_flit_seq==seq)
     {
         full_cycles_counter++;
     }
     else
     {
         last_front_flit_seq = seq;
         full_cycles_counter=;
     }
     if (full_cycles_counter>)
     {
         return false;
     }
     return true;
 }

deadlockFree()

 void Buffer::Disable()
 {
   true_buffer = false;
 }

private:

     bool true_buffer;
     bool deadlock_detected;

     int full_cycles_counter;
     int last_front_flit_seq;

     string label;

     unsigned int max_buffer_size;

     queue < Flit > buffer;

     unsigned int max_occupancy;
     double hold_time, last_event, hold_time_sum;
     double mean_occupancy;
     int    previous_occupancy;

     void SaveOccupancyAndTime();
     void UpdateMeanOccupancy();