src/mem/cache/mshr_queue.hh

   1 /*
   2  * Copyright (c) 2003-2005 The Regents of The University of Michigan
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions are
   7  * met: redistributions of source code must retain the above copyright
   8  * notice, this list of conditions and the following disclaimer;
   9  * redistributions in binary form must reproduce the above copyright
  10  * notice, this list of conditions and the following disclaimer in the
  11  * documentation and/or other materials provided with the distribution;
  12  * neither the name of the copyright holders nor the names of its
  13  * contributors may be used to endorse or promote products derived from
  14  * this software without specific prior written permission.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  17  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  18  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  19  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  20  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  21  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  22  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  23  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  26  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27  *
  28  * Authors: Erik Hallnor
  29  */
  30
  31 /** @file
  32  * Declaration of a structure to manage MSHRs.
  33  */
  34
  35 #ifndef __MEM__CACHE__MISS__MSHR_QUEUE_HH__
  36 #define __MEM__CACHE__MISS__MSHR_QUEUE_HH__
  37
  38 #include <vector>
  39
  40 #include "mem/packet.hh"
  41 #include "mem/cache/mshr.hh"
  42
  43 /**
  44  * A Class for maintaining a list of pending and allocated memory requests.
  45  */
  46 class MSHRQueue
  47 {
  48   private:
  49     /** Local label (for functional print requests) */
  50     const std::string label;
  51
  52     /**  MSHR storage. */
  53     MSHR *registers;
  54     /** Holds pointers to all allocated entries. */
  55     MSHR::List allocatedList;
  56     /** Holds pointers to entries that haven't been sent to the bus. */
  57     MSHR::List readyList;
  58     /** Holds non allocated entries. */
  59     MSHR::List freeList;
  60
  61     // Parameters
  62     /**
  63      * The total number of entries in this queue. This number is set as the
  64      * number of entries requested plus (numReserve - 1). This allows for
  65      * the same number of effective entries while still maintaining the reserve.
  66      */
  67     const int numEntries;
  68
  69     /**
  70      * The number of entries to hold in reserve. This is needed because copy
  71      * operations can allocate upto 4 entries at one time.
  72      */
  73     const int numReserve;
  74
  75     MSHR::Iterator addToReadyList(MSHR *mshr);
  76
  77
  78   public:
  79     /** The number of allocated entries. */
  80     int allocated;
  81     /** The number of entries that have been forwarded to the bus. */
  82     int inServiceEntries;
  83     /** The index of this queue within the cache (MSHR queue vs. write
  84      * buffer). */
  85     const int index;
  86
  87     /**
  88      * Create a queue with a given number of entries.
  89      * @param num_entrys The number of entries in this queue.
  90      * @param reserve The minimum number of entries needed to satisfy
  91      * any access.
  92      */
  93     MSHRQueue(const std::string &_label, int num_entries, int reserve,
  94               int index);
  95
  96     /** Destructor */
  97     ~MSHRQueue();
  98
  99     /**
 100      * Find the first MSHR that matches the provided address.
 101      * @param addr The address to find.
 102      * @return Pointer to the matching MSHR, null if not found.
 103      */
 104     MSHR *findMatch(Addr addr) const;
 105
 106     /**
 107      * Find and return all the matching entries in the provided vector.
 108      * @param addr The address to find.
 109      * @param matches The vector to return pointers to the matching entries.
 110      * @return True if any matches are found, false otherwise.
 111      * @todo Typedef the vector??
 112      */
 113     bool findMatches(Addr addr, std::vector<MSHR*>& matches) const;
 114
 115     /**
 116      * Find any pending requests that overlap the given request.
 117      * @param pkt The request to find.
 118      * @return A pointer to the earliest matching MSHR.
 119      */
 120     MSHR *findPending(Addr addr, int size) const;
 121
 122     bool checkFunctional(PacketPtr pkt, Addr blk_addr);
 123
 124     /**
 125      * Allocates a new MSHR for the request and size. This places the request
 126      * as the first target in the MSHR.
 127      * @param pkt The request to handle.
 128      * @param size The number in bytes to fetch from memory.
 129      * @return The a pointer to the MSHR allocated.
 130      *
 131      * @pre There are free entries.
 132      */
 133     MSHR *allocate(Addr addr, int size, PacketPtr &pkt,
 134                    Tick when, Counter order);
 135
 136     /**
 137      * Removes the given MSHR from the queue. This places the MSHR on the
 138      * free list.
 139      * @param mshr
 140      */
 141     void deallocate(MSHR *mshr);
 142
 143     /**
 144      * Remove a MSHR from the queue. Returns an iterator into the
 145      * allocatedList for faster squash implementation.
 146      * @param mshr The MSHR to remove.
 147      * @return An iterator to the next entry in the allocatedList.
 148      */
 149     MSHR::Iterator deallocateOne(MSHR *mshr);
 150
 151     /**
 152      * Moves the MSHR to the front of the pending list if it is not
 153      * in service.
 154      * @param mshr The entry to move.
 155      */
 156     void moveToFront(MSHR *mshr);
 157
 158     /**
 159      * Mark the given MSHR as in service. This removes the MSHR from the
 160      * readyList. Deallocates the MSHR if it does not expect a response.
 161      * @param mshr The MSHR to mark in service.
 162      */
 163     void markInService(MSHR *mshr, PacketPtr pkt);
 164
 165     /**
 166      * Mark an in service entry as pending, used to resend a request.
 167      * @param mshr The MSHR to resend.
 168      */
 169     void markPending(MSHR *mshr);
 170
 171     /**
 172      * Squash outstanding requests with the given thread number. If a request
 173      * is in service, just squashes the targets.
 174      * @param threadNum The thread to squash.
 175      */
 176     void squash(int threadNum);
 177
 178     /**
 179      * Returns true if the pending list is not empty.
 180      * @return True if there are outstanding requests.
 181      */
 182     bool havePending() const
 183     {
 184         return !readyList.empty();
 185     }
 186
 187     /**
 188      * Returns true if there are no free entries.
 189      * @return True if this queue is full.
 190      */
 191     bool isFull() const
 192     {
 193         return (allocated > numEntries - numReserve);
 194     }
 195
 196     /**
 197      * Returns the MSHR at the head of the readyList.
 198      * @return The next request to service.
 199      */
 200     MSHR *getNextMSHR() const
 201     {
 202         if (readyList.empty() || readyList.front()->readyTime > curTick) {
 203             return NULL;
 204         }
 205         return readyList.front();
 206     }
 207
 208     Tick nextMSHRReadyTime() const
 209     {
 210         return readyList.empty() ? MaxTick : readyList.front()->readyTime;
 211     }
 212 };
 213
 214 #endif //__MEM__CACHE__MISS__MSHR_QUEUE_HH__