Intesim2 Integration

Details: See Review 80001 https://gpgpu-sim-code-review.appspot.com/80001/

[git-p4: depot-paths = "//depot/gpgpu_sim_research/fermi/distribution/": change = 16747]

1 files changed, 239 insertions, 0 deletions

diff --git a/src/intersim2/buffer_state.hpp b/src/intersim2/buffer_state.hpp
new file mode 100644
index 0000000..32a7da1
--- /dev/null
+++ b/src/intersim2/buffer_state.hpp
@@ -0,0 +1,239 @@
+// $Id: buffer_state.hpp 5378 2013-01-10 03:40:11Z dub $
+
+/*
+ Copyright (c) 2007-2012, Trustees of The Leland Stanford Junior University
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+
+ Redistributions of source code must retain the above copyright notice, this 
+ list of conditions and the following disclaimer.
+ Redistributions in binary form must reproduce the above copyright notice, this
+ list of conditions and the following disclaimer in the documentation and/or
+ other materials provided with the distribution.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#ifndef _BUFFER_STATE_HPP_
+#define _BUFFER_STATE_HPP_
+
+#include <vector>
+#include <queue>
+
+#include "module.hpp"
+#include "flit.hpp"
+#include "credit.hpp"
+#include "config_utils.hpp"
+
+class BufferState : public Module {
+  
+  class BufferPolicy : public Module {
+  protected:
+    BufferState const * const _buffer_state;
+  public:
+    BufferPolicy(Configuration const & config, BufferState * parent, 
+		 const string & name);
+    virtual void SetMinLatency(int min_latency) {}
+    virtual void TakeBuffer(int vc = 0);
+    virtual void SendingFlit(Flit const * const f);
+    virtual void FreeSlotFor(int vc = 0);
+    virtual bool IsFullFor(int vc = 0) const = 0;
+    virtual int AvailableFor(int vc = 0) const = 0;
+    virtual int LimitFor(int vc = 0) const = 0;
+
+    static BufferPolicy * New(Configuration const & config, 
+			      BufferState * parent, const string & name);
+  };
+  
+  class PrivateBufferPolicy : public BufferPolicy {
+  protected:
+    int _vc_buf_size;
+  public:
+    PrivateBufferPolicy(Configuration const & config, BufferState * parent, 
+			const string & name);
+    virtual void SendingFlit(Flit const * const f);
+    virtual bool IsFullFor(int vc = 0) const;
+    virtual int AvailableFor(int vc = 0) const;
+    virtual int LimitFor(int vc = 0) const;
+  };
+  
+  class SharedBufferPolicy : public BufferPolicy {
+  protected:
+    int _buf_size;
+    vector<int> _private_buf_vc_map;
+    vector<int> _private_buf_size;
+    vector<int> _private_buf_occupancy;
+    int _shared_buf_size;
+    int _shared_buf_occupancy;
+    vector<int> _reserved_slots;
+    void ProcessFreeSlot(int vc = 0);
+  public:
+    SharedBufferPolicy(Configuration const & config, BufferState * parent, 
+		       const string & name);
+    virtual void SendingFlit(Flit const * const f);
+    virtual void FreeSlotFor(int vc = 0);
+    virtual bool IsFullFor(int vc = 0) const;
+    virtual int AvailableFor(int vc = 0) const;
+    virtual int LimitFor(int vc = 0) const;
+  };
+
+  class LimitedSharedBufferPolicy : public SharedBufferPolicy {
+  protected:
+    int _vcs;
+    int _active_vcs;
+    int _max_held_slots;
+  public:
+    LimitedSharedBufferPolicy(Configuration const & config, 
+			      BufferState * parent,
+			      const string & name);
+    virtual void TakeBuffer(int vc = 0);
+    virtual void SendingFlit(Flit const * const f);
+    virtual bool IsFullFor(int vc = 0) const;
+    virtual int AvailableFor(int vc = 0) const;
+    virtual int LimitFor(int vc = 0) const;
+  };
+    
+  class DynamicLimitedSharedBufferPolicy : public LimitedSharedBufferPolicy {
+  public:
+    DynamicLimitedSharedBufferPolicy(Configuration const & config, 
+				     BufferState * parent,
+				     const string & name);
+    virtual void TakeBuffer(int vc = 0);
+    virtual void SendingFlit(Flit const * const f);
+  };
+  
+  class ShiftingDynamicLimitedSharedBufferPolicy : public DynamicLimitedSharedBufferPolicy {
+  public:
+    ShiftingDynamicLimitedSharedBufferPolicy(Configuration const & config, 
+					     BufferState * parent,
+					     const string & name);
+    virtual void TakeBuffer(int vc = 0);
+    virtual void SendingFlit(Flit const * const f);
+  };
+  
+  class FeedbackSharedBufferPolicy : public SharedBufferPolicy {
+  protected:
+    int _ComputeRTT(int vc, int last_rtt) const;
+    int _ComputeLimit(int rtt) const;
+    int _ComputeMaxSlots(int vc) const;
+    int _vcs;
+    vector<int> _occupancy_limit;
+    vector<int> _round_trip_time;
+    vector<queue<int> > _flit_sent_time;
+    int _min_latency;
+    int _total_mapped_size;
+    int _aging_scale;
+    int _offset;
+  public:
+    FeedbackSharedBufferPolicy(Configuration const & config, 
+			       BufferState * parent, const string & name);
+    virtual void SetMinLatency(int min_latency);
+    virtual void SendingFlit(Flit const * const f);
+    virtual void FreeSlotFor(int vc = 0);
+    virtual bool IsFullFor(int vc = 0) const;
+    virtual int AvailableFor(int vc = 0) const;
+    virtual int LimitFor(int vc = 0) const;
+  };
+  
+  class SimpleFeedbackSharedBufferPolicy : public FeedbackSharedBufferPolicy {
+  protected:
+    vector<int> _pending_credits;
+  public:
+    SimpleFeedbackSharedBufferPolicy(Configuration const & config, 
+				     BufferState * parent, const string & name);
+    virtual void SendingFlit(Flit const * const f);
+    virtual void FreeSlotFor(int vc = 0);
+  };
+  
+  bool _wait_for_tail_credit;
+  int  _size;
+  int  _occupancy;
+  vector<int> _vc_occupancy;
+  int  _vcs;
+  
+  BufferPolicy * _buffer_policy;
+  
+  vector<int> _in_use_by;
+  vector<bool> _tail_sent;
+  vector<int> _last_id;
+  vector<int> _last_pid;
+
+#ifdef TRACK_BUFFERS
+  int _classes;
+  vector<queue<int> > _outstanding_classes;
+  vector<int> _class_occupancy;
+#endif
+
+public:
+
+  BufferState( const Configuration& config, 
+	       Module *parent, const string& name );
+
+  ~BufferState();
+
+  inline void SetMinLatency(int min_latency) {
+    _buffer_policy->SetMinLatency(min_latency);
+  }
+
+  void ProcessCredit( Credit const * const c );
+  void SendingFlit( Flit const * const f );
+
+  void TakeBuffer( int vc = 0, int tag = 0 );
+
+  inline bool IsFull() const {
+    assert(_occupancy <= _size);
+    return (_occupancy == _size);
+  }
+  inline bool IsFullFor( int vc = 0 ) const {
+    return _buffer_policy->IsFullFor(vc);
+  }
+  inline int AvailableFor( int vc = 0 ) const {
+    return _buffer_policy->AvailableFor(vc);
+  }
+  inline int LimitFor( int vc = 0 ) const {
+    return _buffer_policy->LimitFor(vc);
+  }
+  inline bool IsEmptyFor(int vc = 0) const {
+    assert((vc >= 0) && (vc < _vcs));
+    return (_vc_occupancy[vc] == 0);
+  }
+  inline bool IsAvailableFor( int vc = 0 ) const {
+    assert( ( vc >= 0 ) && ( vc < _vcs ) );
+    return _in_use_by[vc] < 0;
+  }
+  inline int UsedBy(int vc = 0) const {
+    assert( ( vc >= 0 ) && ( vc < _vcs ) );
+    return _in_use_by[vc];
+  }
+    
+  inline int Occupancy() const {
+    return _occupancy;
+  }
+
+  inline int OccupancyFor( int vc = 0 ) const {
+    assert((vc >= 0) && (vc < _vcs));
+    return _vc_occupancy[vc];
+  }
+  
+#ifdef TRACK_BUFFERS
+  inline int OccupancyForClass(int c) const {
+    assert((c >= 0) && (c < _classes));
+    return _class_occupancy[c];
+  }
+#endif
+
+  void Display( ostream & os = cout ) const;
+};
+
+#endif