mem_checker.hh

Go to the documentation of this file.

/*
 * Copyright (c) 2014 ARM Limited
 * All rights reserved.
 *
 * The license below extends only to copyright in the software and shall
 * not be construed as granting a license to any other intellectual
 * property including but not limited to intellectual property relating
 * to a hardware implementation of the functionality of the software
 * licensed hereunder.  You may use the software subject to the license
 * terms below provided that you ensure that this notice is replicated
 * unmodified and in its entirety in all distributions of the software,
 * modified or unmodified, in source code or in binary form.
 *
 * 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;
 * neither the name of the copyright holders nor the names of its
 * contributors may be used to endorse or promote products derived from
 * this software without specific prior written permission.
 *
 * 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 __MEM_MEM_CHECKER_HH__
#define __MEM_MEM_CHECKER_HH__
 
#include <list>
#include <map>
#include <string>
#include <unordered_map>
#include <vector>
 
#include "base/logging.hh"
#include "base/trace.hh"
#include "base/types.hh"
#include "debug/MemChecker.hh"
#include "params/MemChecker.hh"
#include "sim/core.hh"
#include "sim/sim_object.hh"
 
class MemChecker : public SimObject
{
  public:
    typedef uint64_t Serial;
 
    static const Serial  SERIAL_INITIAL = 0; 
 
    static const Tick    TICK_INITIAL   = 0;
 
    static const Tick    TICK_FUTURE  = MaxTick;
 
    static const uint8_t DATA_INITIAL   = 0x00;
 
    class Transaction
    {
      public:
 
        Transaction(Serial _serial,
                    Tick _start, Tick _complete,
                    uint8_t _data = DATA_INITIAL)
            : serial(_serial),
              start(_start), complete(_complete),
              data(_data)
        {}
 
      public:
        Serial serial; 
        Tick start;    
        Tick complete; 
 
        uint8_t data;
 
        bool operator<(const Transaction& rhs) const
        { return serial < rhs.serial; }
    };
 
    class WriteCluster
    {
      public:
        WriteCluster()
            : start(TICK_FUTURE), complete(TICK_FUTURE),
              completeMax(TICK_INITIAL), numIncomplete(0)
        {}
 
        void startWrite(Serial serial, Tick _start, uint8_t data);
 
        void completeWrite(Serial serial, Tick _complete);
 
        void abortWrite(Serial serial);
 
        bool isComplete() const { return complete != TICK_FUTURE; }
 
      public:
        Tick start;     
        Tick complete;  
 
        std::unordered_map<Serial, Transaction> writes;
 
      private:
        Tick completeMax;
        size_t numIncomplete;
    };
 
    typedef std::list<Transaction> TransactionList;
    typedef std::list<WriteCluster> WriteClusterList;
 
    class ByteTracker : public Named
    {
      public:
 
        ByteTracker(Addr addr = 0, const MemChecker *parent = NULL)
            : Named((parent != NULL ? parent->name() : "") +
                     csprintf(".ByteTracker@%#llx", addr))
        {
            // The initial transaction has start == complete == TICK_INITIAL,
            // indicating that there has been no real write to this location;
            // therefore, upon checking, we do not expect any particular value.
            readObservations.emplace_back(
                    Transaction(SERIAL_INITIAL, TICK_INITIAL, TICK_INITIAL,
                                DATA_INITIAL));
        }
 
        void startRead(Serial serial, Tick start);
 
        bool inExpectedData(Tick start, Tick complete, uint8_t data);
 
        bool completeRead(Serial serial, Tick complete, uint8_t data);
 
        void startWrite(Serial serial, Tick start, uint8_t data);
 
        void completeWrite(Serial serial, Tick complete);
 
        void abortWrite(Serial serial);
 
        const std::vector<uint8_t>& lastExpectedData() const
        { return _lastExpectedData; }
 
      private:
 
        WriteCluster* getIncompleteWriteCluster();
 
        template <class TList>
        typename TList::iterator lastCompletedTransaction(TList *l, Tick before)
        {
            assert(!l->empty());
 
            // Scanning backwards increases the chances of getting a match
            // quicker.
            auto it = l->end();
 
            for (--it; it != l->begin() && it->complete >= before; --it);
 
            return it;
        }
 
        void pruneTransactions();
 
      private:
 
        std::map<Serial, Transaction> outstandingReads;
 
        TransactionList readObservations;
 
        WriteClusterList writeClusters;
 
        std::vector<uint8_t> _lastExpectedData;
    };
 
  public:
 
    MemChecker(const MemCheckerParams *p)
        : SimObject(p),
          nextSerial(SERIAL_INITIAL)
    {}
 
    virtual ~MemChecker() {}
 
    Serial startRead(Tick start, Addr addr, size_t size);
 
    Serial startWrite(Tick start, Addr addr, size_t size, const uint8_t *data);
 
    bool completeRead(Serial serial, Tick complete,
                      Addr addr, size_t size, uint8_t *data);
 
    void completeWrite(Serial serial, Tick complete, Addr addr, size_t size);
 
    void abortWrite(Serial serial, Addr addr, size_t size);
 
    void reset()
    { byte_trackers.clear(); }
 
    void reset(Addr addr, size_t size);
 
    const std::string& getErrorMessage() const { return errorMessage; }
 
  private:
    ByteTracker* getByteTracker(Addr addr)
    {
        auto it = byte_trackers.find(addr);
        if (it == byte_trackers.end()) {
            it = byte_trackers.insert(
                std::make_pair(addr, ByteTracker(addr, this))).first;
        }
        return &it->second;
    };
 
  private:
    std::string errorMessage;
 
    Serial nextSerial;
 
    std::unordered_map<Addr, ByteTracker> byte_trackers;
};
 
inline MemChecker::Serial
MemChecker::startRead(Tick start, Addr addr, size_t size)
{
    DPRINTF(MemChecker,
            "starting read: serial = %d, start = %d, addr = %#llx, "
            "size = %d\n", nextSerial, start, addr , size);
 
    for (size_t i = 0; i < size; ++i) {
        getByteTracker(addr + i)->startRead(nextSerial, start);
    }
 
    return nextSerial++;
}
 
inline MemChecker::Serial
MemChecker::startWrite(Tick start, Addr addr, size_t size, const uint8_t *data)
{
    DPRINTF(MemChecker,
            "starting write: serial = %d, start = %d, addr = %#llx, "
            "size = %d\n", nextSerial, start, addr, size);
 
    for (size_t i = 0; i < size; ++i) {
        getByteTracker(addr + i)->startWrite(nextSerial, start, data[i]);
    }
 
    return nextSerial++;
}
 
inline void
MemChecker::completeWrite(MemChecker::Serial serial, Tick complete,
                          Addr addr, size_t size)
{
    DPRINTF(MemChecker,
            "completing write: serial = %d, complete = %d, "
            "addr = %#llx, size = %d\n", serial, complete, addr, size);
 
    for (size_t i = 0; i < size; ++i) {
        getByteTracker(addr + i)->completeWrite(serial, complete);
    }
}
 
inline void
MemChecker::abortWrite(MemChecker::Serial serial, Addr addr, size_t size)
{
    DPRINTF(MemChecker,
            "aborting write: serial = %d, addr = %#llx, size = %d\n",
            serial, addr, size);
 
    for (size_t i = 0; i < size; ++i) {
        getByteTracker(addr + i)->abortWrite(serial);
    }
}
 
#endif // __MEM_MEM_CHECKER_HH__