RubySlicc_Util.hh

Go to the documentation of this file.

/*
 * Copyright (c) 2020-2021,2023 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.
 *
 * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood
 * Copyright (c) 2013 Advanced Micro Devices, Inc.
 * 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;
 * 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.
 */
 
/*
 * These are the functions that exported to slicc from ruby.
 */
 
#ifndef __MEM_RUBY_SLICC_INTERFACE_RUBYSLICC_UTIL_HH__
#define __MEM_RUBY_SLICC_INTERFACE_RUBYSLICC_UTIL_HH__
 
#include <cassert>
#include <climits>
 
#include "debug/RubyProtocol.hh"
#include "debug/RubySlicc.hh"
#include "mem/packet.hh"
#include "mem/ruby/common/Address.hh"
#include "mem/ruby/common/BoolVec.hh"
#include "mem/ruby/common/DataBlock.hh"
#include "mem/ruby/common/TypeDefines.hh"
#include "mem/ruby/common/WriteMask.hh"
#include "mem/ruby/protocol/RubyRequestType.hh"
 
namespace gem5
{
 
namespace ruby
{
 
inline Cycles zero_time() { return Cycles(0); }
 
inline Cycles intToCycles(int c) { return Cycles(c); }
 
inline Tick intToTick(int c) { return c; }
 
inline NodeID
intToID(int nodenum)
{
    NodeID id = nodenum;
    return id;
}
intToID(int nodenum) {…}
 
inline int
IDToInt(NodeID id)
{
    int nodenum = id;
    return nodenum;
}
IDToInt(NodeID id) {…}
 
inline int
addressToInt(Addr addr)
{
    assert(!(addr & 0xffffffff00000000));
    return addr;
}
addressToInt(Addr addr) {…}
 
inline Addr
intToAddress(int addr)
{
    assert(!(addr & 0xffffffff00000000));
    return addr;
}
intToAddress(int addr) {…}
 
inline int
mod(int val, int mod)
{
    return val % mod;
}
mod(int val, int mod) {…}
 
inline int max_tokens()
{
  return 1024;
}
inline int max_tokens() {…}
 
inline bool
isWriteRequest(RubyRequestType type)
{
    if ((type == RubyRequestType_ST) ||
        (type == RubyRequestType_ATOMIC) ||
        (type == RubyRequestType_RMW_Read) ||
        (type == RubyRequestType_RMW_Write) ||
        (type == RubyRequestType_Store_Conditional) ||
        (type == RubyRequestType_Locked_RMW_Read) ||
        (type == RubyRequestType_Locked_RMW_Write) ||
        (type == RubyRequestType_FLUSH)) {
            return true;
    } else {
            return false;
    }
}
isWriteRequest(RubyRequestType type) {…}
 
inline bool
isDataReadRequest(RubyRequestType type)
{
    if ((type == RubyRequestType_LD) ||
        (type == RubyRequestType_Load_Linked)) {
            return true;
    } else {
            return false;
    }
}
isDataReadRequest(RubyRequestType type) {…}
 
inline bool
isReadRequest(RubyRequestType type)
{
    if (isDataReadRequest(type) ||
        (type == RubyRequestType_IFETCH)) {
            return true;
    } else {
            return false;
    }
}
isReadRequest(RubyRequestType type) {…}
 
inline bool
isHtmCmdRequest(RubyRequestType type)
{
    if ((type == RubyRequestType_HTM_Start)  ||
        (type == RubyRequestType_HTM_Commit) ||
        (type == RubyRequestType_HTM_Cancel) ||
        (type == RubyRequestType_HTM_Abort)) {
            return true;
    } else {
            return false;
    }
}
isHtmCmdRequest(RubyRequestType type) {…}
 
inline bool
isTlbiCmdRequest(RubyRequestType type)
{
    if ((type == RubyRequestType_TLBI)  ||
        (type == RubyRequestType_TLBI_SYNC) ||
        (type == RubyRequestType_TLBI_EXT_SYNC) ||
        (type == RubyRequestType_TLBI_EXT_SYNC_COMP)) {
            return true;
    } else {
            return false;
    }
}
isTlbiCmdRequest(RubyRequestType type) {…}
 
inline RubyRequestType
htmCmdToRubyRequestType(const Packet *pkt)
{
    if (pkt->req->isHTMStart()) {
        return RubyRequestType_HTM_Start;
    } else if (pkt->req->isHTMCommit()) {
        return RubyRequestType_HTM_Commit;
    } else if (pkt->req->isHTMCancel()) {
        return RubyRequestType_HTM_Cancel;
    } else if (pkt->req->isHTMAbort()) {
        return RubyRequestType_HTM_Abort;
    }
    else {
        panic("invalid ruby packet type\n");
    }
}
htmCmdToRubyRequestType(const Packet *pkt) {…}
 
inline RubyRequestType
tlbiCmdToRubyRequestType(const Packet *pkt)
{
    if (pkt->req->isTlbi()) {
        return RubyRequestType_TLBI;
    } else if (pkt->req->isTlbiSync()) {
        return RubyRequestType_TLBI_SYNC;
    } else if (pkt->req->isTlbiExtSync()) {
        return RubyRequestType_TLBI_EXT_SYNC;
    } else if (pkt->req->isTlbiExtSyncComp()) {
        return RubyRequestType_TLBI_EXT_SYNC_COMP;
    } else {
        panic("invalid ruby packet type\n");
    }
}
tlbiCmdToRubyRequestType(const Packet *pkt) {…}
 
inline int
addressOffset(Addr addr, Addr base)
{
    assert(addr >= base);
    Addr offset = addr - base;
    // sanity checks if fits in an int
    assert(offset < INT_MAX);
    return offset;
}
addressOffset(Addr addr, Addr base) {…}
 
inline bool
testAndRead(Addr addr, DataBlock& blk, Packet *pkt)
{
    int block_size_bits = floorLog2(blk.getBlockSize());
    Addr pktLineAddr = makeLineAddress(pkt->getAddr(), block_size_bits);
    Addr lineAddr = makeLineAddress(addr, block_size_bits);
 
    if (pktLineAddr == lineAddr) {
        uint8_t *data = pkt->getPtr<uint8_t>();
        unsigned int size_in_bytes = pkt->getSize();
        unsigned startByte = pkt->getAddr() - lineAddr;
 
        for (unsigned i = 0; i < size_in_bytes; ++i) {
            data[i] = blk.getByte(i + startByte);
        }
        return true;
    }
    return false;
}
testAndRead(Addr addr, DataBlock& blk, Packet *pkt) {…}
 
inline bool
testAndReadMask(Addr addr, DataBlock& blk, WriteMask& mask, Packet *pkt)
{
    assert(blk.getBlockSize() == mask.getBlockSize());
    int block_size_bits = floorLog2(blk.getBlockSize());
    Addr pktLineAddr = makeLineAddress(pkt->getAddr(), block_size_bits);
    Addr lineAddr = makeLineAddress(addr, block_size_bits);
 
    if (pktLineAddr == lineAddr) {
        uint8_t *data = pkt->getPtr<uint8_t>();
        unsigned int size_in_bytes = pkt->getSize();
        unsigned startByte = pkt->getAddr() - lineAddr;
        bool was_read = false;
 
        for (unsigned i = 0; i < size_in_bytes; ++i) {
            if (mask.test(i + startByte)) {
                was_read = true;
                data[i] = blk.getByte(i + startByte);
            }
        }
        return was_read;
    }
    return false;
}
testAndReadMask(Addr addr, DataBlock& blk, WriteMask& mask, Packet *pkt) {…}
 
inline bool
testAndWrite(Addr addr, DataBlock& blk, Packet *pkt)
{
    int block_size_bits = floorLog2(blk.getBlockSize());
    Addr pktLineAddr = makeLineAddress(pkt->getAddr(), block_size_bits);
    Addr lineAddr = makeLineAddress(addr, block_size_bits);
 
    if (pktLineAddr == lineAddr) {
        const uint8_t *data = pkt->getConstPtr<uint8_t>();
        unsigned int size_in_bytes = pkt->getSize();
        unsigned startByte = pkt->getAddr() - lineAddr;
 
        for (unsigned i = 0; i < size_in_bytes; ++i) {
            blk.setByte(i + startByte, data[i]);
        }
        return true;
    }
    return false;
}
testAndWrite(Addr addr, DataBlock& blk, Packet *pkt) {…}
 
inline int
countBoolVec(BoolVec bVec)
{
    int count = 0;
    for (const bool e: bVec) {
        if (e) {
            count++;
        }
    }
    return count;
}
countBoolVec(BoolVec bVec) {…}
 
inline RequestorID
getRequestorID(RequestPtr req)
{
    return req->requestorId();
}
getRequestorID(RequestPtr req) {…}
 
} // namespace ruby
} // namespace gem5
 
#endif //__MEM_RUBY_SLICC_INTERFACE_RUBYSLICC_UTIL_HH__