2009-05-11 19:38:43 +02:00
|
|
|
/*
|
2012-07-12 15:39:18 +02:00
|
|
|
* Copyright (c) 1999-2012 Mark D. Hill and David A. Wood
|
|
|
|
* Copyright (c) 2011 Advanced Micro Devices, Inc.
|
2009-05-11 19:38:43 +02:00
|
|
|
* 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.
|
|
|
|
*/
|
|
|
|
|
2012-10-16 00:51:57 +02:00
|
|
|
// Declarations of external types that are common to all protocols
|
2009-05-11 19:38:43 +02:00
|
|
|
external_type(int, primitive="yes", default="0");
|
|
|
|
external_type(bool, primitive="yes", default="false");
|
2010-04-02 20:20:32 +02:00
|
|
|
external_type(std::string, primitive="yes");
|
2012-12-11 17:05:55 +01:00
|
|
|
external_type(uint32_t, primitive="yes");
|
2009-05-11 19:38:43 +02:00
|
|
|
external_type(uint64, primitive="yes");
|
2012-10-16 00:51:57 +02:00
|
|
|
external_type(PacketPtr, primitive="yes");
|
|
|
|
external_type(Packet, primitive="yes");
|
2009-05-11 19:38:43 +02:00
|
|
|
external_type(Address);
|
2013-02-11 04:43:10 +01:00
|
|
|
external_type(Cycles, primitive="yes", default="Cycles(0)");
|
2012-10-16 00:51:57 +02:00
|
|
|
|
2011-03-18 20:12:04 +01:00
|
|
|
structure(DataBlock, external = "yes", desc="..."){
|
2009-08-04 19:52:52 +02:00
|
|
|
void clear();
|
|
|
|
void copyPartial(DataBlock, int, int);
|
|
|
|
}
|
2009-05-11 19:38:43 +02:00
|
|
|
|
2012-10-16 00:51:57 +02:00
|
|
|
bool testAndRead(Address addr, DataBlock datablk, Packet *pkt);
|
|
|
|
bool testAndWrite(Address addr, DataBlock datablk, Packet *pkt);
|
2009-05-11 19:38:43 +02:00
|
|
|
|
|
|
|
// AccessPermission
|
2011-02-24 01:41:58 +01:00
|
|
|
// The following five states define the access permission of all memory blocks.
|
|
|
|
// These permissions have multiple uses. They coordinate locking and
|
|
|
|
// synchronization primitives, as well as enable functional accesses.
|
|
|
|
// One should not need to add any additional permission values and it is very
|
|
|
|
// risky to do so.
|
2009-05-11 19:38:43 +02:00
|
|
|
enumeration(AccessPermission, desc="...", default="AccessPermission_NotPresent") {
|
2011-02-24 01:41:58 +01:00
|
|
|
// Valid data
|
|
|
|
Read_Only, desc="block is Read Only (modulo functional writes)";
|
|
|
|
Read_Write, desc="block is Read/Write";
|
|
|
|
|
2011-07-01 02:49:26 +02:00
|
|
|
// Possibly Invalid data
|
|
|
|
// The maybe stale permission indicates that accordingly to the protocol,
|
|
|
|
// there is no guarantee the block contains valid data. However, functional
|
|
|
|
// writes should update the block because a dataless PUT request may
|
|
|
|
// revalidate the block's data.
|
|
|
|
Maybe_Stale, desc="block can be stale or revalidated by a dataless PUT";
|
2011-09-01 20:41:44 +02:00
|
|
|
// In Broadcast/Snoop protocols, memory has no idea if it is exclusive owner
|
|
|
|
// or not of a block, making it hard to make the logic of having only one
|
|
|
|
// read_write block in the system impossible. This is to allow the memory to
|
|
|
|
// say, "I have the block" and for the RubyPort logic to know that this is a
|
|
|
|
// last-resort block if there are no writable copies in the caching hierarchy.
|
|
|
|
// This is not supposed to be used in directory or token protocols where
|
|
|
|
// memory/NB has an idea of what is going on in the whole system.
|
|
|
|
Backing_Store, desc="for memory in Broadcast/Snoop protocols";
|
2011-07-01 02:49:26 +02:00
|
|
|
|
2011-02-24 01:41:58 +01:00
|
|
|
// Invalid data
|
|
|
|
Invalid, desc="block is in an Invalid base state";
|
|
|
|
NotPresent, desc="block is NotPresent";
|
|
|
|
Busy, desc="block is in a transient state, currently invalid";
|
2009-05-11 19:38:43 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
// TesterStatus
|
|
|
|
enumeration(TesterStatus, desc="...") {
|
|
|
|
Idle, desc="Idle";
|
|
|
|
Action_Pending, desc="Action Pending";
|
|
|
|
Ready, desc="Ready";
|
|
|
|
Check_Pending, desc="Check Pending";
|
|
|
|
}
|
|
|
|
|
2010-08-20 20:46:13 +02:00
|
|
|
// InvalidateGeneratorStatus
|
|
|
|
enumeration(InvalidateGeneratorStatus, desc="...") {
|
|
|
|
Load_Waiting, desc="Load waiting to be issued";
|
|
|
|
Load_Pending, desc="Load issued";
|
|
|
|
Inv_Waiting, desc="Store (invalidate) waiting to be issued";
|
|
|
|
Inv_Pending, desc="Store (invalidate) issued";
|
2009-05-11 19:38:43 +02:00
|
|
|
}
|
|
|
|
|
2010-08-20 20:46:13 +02:00
|
|
|
// SeriesRequestGeneratorStatus
|
|
|
|
enumeration(SeriesRequestGeneratorStatus, desc="...") {
|
2009-05-11 19:38:43 +02:00
|
|
|
Thinking, desc="Doing work before next action";
|
2010-08-20 20:46:13 +02:00
|
|
|
Request_Pending, desc="Request pending";
|
2009-05-11 19:38:43 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
// LockStatus
|
|
|
|
enumeration(LockStatus, desc="...") {
|
|
|
|
Unlocked, desc="Lock is not held";
|
|
|
|
Locked, desc="Lock is held";
|
|
|
|
}
|
|
|
|
|
|
|
|
// SequencerStatus
|
|
|
|
enumeration(SequencerStatus, desc="...") {
|
|
|
|
Idle, desc="Idle";
|
|
|
|
Pending, desc="Pending";
|
|
|
|
}
|
|
|
|
|
|
|
|
enumeration(TransitionResult, desc="...") {
|
|
|
|
Valid, desc="Valid transition";
|
|
|
|
ResourceStall, desc="Stalled due to insufficient resources";
|
|
|
|
ProtocolStall, desc="Protocol specified stall";
|
|
|
|
}
|
|
|
|
|
2011-03-20 00:34:59 +01:00
|
|
|
// RubyRequestType
|
|
|
|
enumeration(RubyRequestType, desc="...", default="RubyRequestType_NULL") {
|
|
|
|
LD, desc="Load";
|
|
|
|
ST, desc="Store";
|
|
|
|
ATOMIC, desc="Atomic Load/Store";
|
|
|
|
IFETCH, desc="Instruction fetch";
|
|
|
|
IO, desc="I/O";
|
|
|
|
REPLACEMENT, desc="Replacement";
|
|
|
|
Load_Linked, desc="";
|
|
|
|
Store_Conditional, desc="";
|
|
|
|
RMW_Read, desc="";
|
|
|
|
RMW_Write, desc="";
|
|
|
|
Locked_RMW_Read, desc="";
|
|
|
|
Locked_RMW_Write, desc="";
|
|
|
|
COMMIT, desc="Commit version";
|
|
|
|
NULL, desc="Invalid request type";
|
2011-03-28 17:49:45 +02:00
|
|
|
FLUSH, desc="Flush request type";
|
2009-08-04 19:52:52 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
enumeration(SequencerRequestType, desc="...", default="SequencerRequestType_NULL") {
|
2012-07-11 07:51:54 +02:00
|
|
|
Default, desc="Replace this with access_types passed to the DMA Ruby object";
|
2009-08-04 19:52:52 +02:00
|
|
|
LD, desc="Load";
|
|
|
|
ST, desc="Store";
|
2009-05-11 19:38:43 +02:00
|
|
|
NULL, desc="Invalid request type";
|
|
|
|
}
|
|
|
|
|
2012-07-11 07:51:54 +02:00
|
|
|
enumeration(CacheRequestType, desc="...", default="CacheRequestType_NULL") {
|
|
|
|
DataArrayRead, desc="Read access to the cache's data array";
|
|
|
|
DataArrayWrite, desc="Write access to the cache's data array";
|
|
|
|
TagArrayRead, desc="Read access to the cache's tag array";
|
|
|
|
TagArrayWrite, desc="Write access to the cache's tag array";
|
|
|
|
}
|
|
|
|
|
2012-07-11 07:51:54 +02:00
|
|
|
enumeration(CacheResourceType, desc="...", default="CacheResourceType_NULL") {
|
|
|
|
DataArray, desc="Access to the cache's data array";
|
|
|
|
TagArray, desc="Access to the cache's tag array";
|
|
|
|
}
|
|
|
|
|
2012-07-11 07:51:54 +02:00
|
|
|
enumeration(DirectoryRequestType, desc="...", default="DirectoryRequestType_NULL") {
|
|
|
|
Default, desc="Replace this with access_types passed to the Directory Ruby object";
|
|
|
|
}
|
|
|
|
|
|
|
|
enumeration(DMASequencerRequestType, desc="...", default="DMASequencerRequestType_NULL") {
|
|
|
|
Default, desc="Replace this with access_types passed to the DMA Ruby object";
|
|
|
|
}
|
|
|
|
|
|
|
|
enumeration(MemoryControlRequestType, desc="...", default="MemoryControlRequestType_NULL") {
|
|
|
|
Default, desc="Replace this with access_types passed to the DMA Ruby object";
|
|
|
|
}
|
|
|
|
|
2009-05-11 19:38:43 +02:00
|
|
|
enumeration(GenericMachineType, desc="...", default="GenericMachineType_NULL") {
|
|
|
|
L1Cache, desc="L1 Cache Mach";
|
|
|
|
L2Cache, desc="L2 Cache Mach";
|
|
|
|
L3Cache, desc="L3 Cache Mach";
|
|
|
|
Directory, desc="Directory Mach";
|
2011-07-07 03:45:15 +02:00
|
|
|
DMA, desc="DMA Mach";
|
2009-05-11 19:38:43 +02:00
|
|
|
Collector, desc="Collector Mach";
|
|
|
|
L1Cache_wCC, desc="L1 Cache Mach with Cache Coherence (used for miss latency profile)";
|
|
|
|
L2Cache_wCC, desc="L1 Cache Mach with Cache Coherence (used for miss latency profile)";
|
|
|
|
NULL, desc="null mach type";
|
|
|
|
}
|
|
|
|
|
|
|
|
// MessageSizeType
|
|
|
|
enumeration(MessageSizeType, default="MessageSizeType_Undefined", desc="...") {
|
|
|
|
Undefined, desc="Undefined";
|
|
|
|
Control, desc="Control Message";
|
|
|
|
Data, desc="Data Message";
|
|
|
|
Request_Control, desc="Request";
|
|
|
|
Reissue_Control, desc="Reissued request";
|
|
|
|
Response_Data, desc="data response";
|
|
|
|
ResponseL2hit_Data, desc="data response";
|
|
|
|
ResponseLocal_Data, desc="data response";
|
|
|
|
Response_Control, desc="non-data response";
|
|
|
|
Writeback_Data, desc="Writeback data";
|
|
|
|
Writeback_Control, desc="Writeback control";
|
2010-08-20 20:46:12 +02:00
|
|
|
Broadcast_Control, desc="Broadcast control";
|
2011-02-07 07:14:18 +01:00
|
|
|
Multicast_Control, desc="Multicast control";
|
2009-05-11 19:38:43 +02:00
|
|
|
Forwarded_Control, desc="Forwarded control";
|
|
|
|
Invalidate_Control, desc="Invalidate control";
|
|
|
|
Unblock_Control, desc="Unblock control";
|
|
|
|
Persistent_Control, desc="Persistent request activation messages";
|
|
|
|
Completion_Control, desc="Completion messages";
|
|
|
|
}
|
|
|
|
|
|
|
|
// AccessType
|
|
|
|
enumeration(AccessType, desc="...") {
|
|
|
|
Read, desc="Reading from cache";
|
|
|
|
Write, desc="Writing to cache";
|
|
|
|
}
|
|
|
|
|
2011-03-20 00:34:37 +01:00
|
|
|
// RubyAccessMode
|
|
|
|
enumeration(RubyAccessMode, default="RubyAccessMode_User", desc="...") {
|
|
|
|
Supervisor, desc="Supervisor mode";
|
|
|
|
User, desc="User mode";
|
|
|
|
Device, desc="Device mode";
|
2009-05-11 19:38:43 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
enumeration(PrefetchBit, default="PrefetchBit_No", desc="...") {
|
|
|
|
No, desc="No, not a prefetch";
|
|
|
|
Yes, desc="Yes, a prefetch";
|
|
|
|
L1_HW, desc="This is a L1 hardware prefetch";
|
|
|
|
L2_HW, desc="This is a L2 hardware prefetch";
|
|
|
|
}
|
|
|
|
|
2009-08-04 19:52:52 +02:00
|
|
|
// CacheMsg
|
|
|
|
structure(SequencerMsg, desc="...", interface="Message") {
|
|
|
|
Address LineAddress, desc="Line address for this request";
|
|
|
|
Address PhysicalAddress, desc="Physical address for this request";
|
|
|
|
SequencerRequestType Type, desc="Type of request (LD, ST, etc)";
|
|
|
|
Address ProgramCounter, desc="Program counter of the instruction that caused the miss";
|
2011-03-20 00:34:37 +01:00
|
|
|
RubyAccessMode AccessMode, desc="user/supervisor access type";
|
2009-08-04 19:52:52 +02:00
|
|
|
DataBlock DataBlk, desc="Data";
|
|
|
|
int Len, desc="size in bytes of access";
|
|
|
|
PrefetchBit Prefetch, desc="Is this a prefetch request";
|
2012-10-16 00:51:57 +02:00
|
|
|
|
|
|
|
bool functionalRead(Packet *pkt) {
|
|
|
|
return testAndRead(PhysicalAddress, DataBlk, pkt);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool functionalWrite(Packet *pkt) {
|
|
|
|
return testAndWrite(PhysicalAddress, DataBlk, pkt);
|
|
|
|
}
|
2009-08-04 19:52:52 +02:00
|
|
|
}
|
|
|
|
|
2009-05-11 19:38:43 +02:00
|
|
|
// MaskPredictorType
|
|
|
|
enumeration(MaskPredictorType, "MaskPredictorType_Undefined", desc="...") {
|
|
|
|
Undefined, desc="Undefined";
|
|
|
|
AlwaysUnicast, desc="AlwaysUnicast";
|
|
|
|
TokenD, desc="TokenD";
|
|
|
|
AlwaysBroadcast, desc="AlwaysBroadcast";
|
|
|
|
TokenB, desc="TokenB";
|
|
|
|
TokenNull, desc="TokenNull";
|
|
|
|
Random, desc="Random";
|
|
|
|
Pairwise, desc="Pairwise";
|
|
|
|
Owner, desc="Owner";
|
|
|
|
BroadcastIfShared, desc="Broadcast-If-Shared";
|
|
|
|
BroadcastCounter, desc="Broadcast Counter";
|
|
|
|
Group, desc="Group";
|
|
|
|
Counter, desc="Counter";
|
|
|
|
StickySpatial, desc="StickySpatial";
|
|
|
|
OwnerBroadcast, desc="Owner/Broadcast Hybrid";
|
|
|
|
OwnerGroup, desc="Owner/Group Hybrid";
|
|
|
|
OwnerBroadcastMod, desc="Owner/Broadcast Hybrid-Mod";
|
|
|
|
OwnerGroupMod, desc="Owner/Group Hybrid-Mod";
|
|
|
|
LastNMasks, desc="Last N Masks";
|
|
|
|
BandwidthAdaptive, desc="Bandwidth Adaptive";
|
|
|
|
}
|
|
|
|
|
|
|
|
// MaskPredictorIndex
|
|
|
|
enumeration(MaskPredictorIndex, "MaskPredictorIndex_Undefined", desc="...") {
|
|
|
|
Undefined, desc="Undefined";
|
|
|
|
DataBlock, desc="Data Block";
|
|
|
|
PC, desc="Program Counter";
|
|
|
|
}
|
|
|
|
|
|
|
|
// MaskPredictorTraining
|
|
|
|
enumeration(MaskPredictorTraining, "MaskPredictorTraining_Undefined", desc="...") {
|
|
|
|
Undefined, desc="Undefined";
|
|
|
|
None, desc="None";
|
|
|
|
Implicit, desc="Implicit";
|
|
|
|
Explicit, desc="Explicit";
|
|
|
|
Both, desc="Both";
|
|
|
|
}
|
|
|
|
|
2010-01-30 05:29:33 +01:00
|
|
|
// Request Status
|
|
|
|
enumeration(RequestStatus, desc="...", default="RequestStatus_NULL") {
|
|
|
|
Ready, desc="The sequencer is ready and the request does not alias";
|
|
|
|
Issued, desc="The sequencer successfully issued the request";
|
|
|
|
BufferFull, desc="Can not issue because the sequencer is full";
|
|
|
|
Aliased, desc="This request aliased with a currently outstanding request";
|
|
|
|
NULL, desc="";
|
|
|
|
}
|
2011-04-29 02:18:14 +02:00
|
|
|
|
|
|
|
// LinkDirection
|
|
|
|
enumeration(LinkDirection, desc="...") {
|
|
|
|
In, desc="Inward link direction";
|
|
|
|
Out, desc="Outward link direction";
|
|
|
|
}
|