/*
* Copyright (c) 1999-2008 Mark D. Hill and David A. Wood
* 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.
*/
/*
* $Id$
*
*/
/*------------------------------------------------------------------------*/
/* Includes */
/*------------------------------------------------------------------------*/
#include "OpalInterface.hh"
#include "interface.hh"
#include "System.hh"
#include "SubBlock.hh"
#include "mf_api.hh"
#include "Chip.hh"
#include "RubyConfig.hh"
//#include "XactIsolationChecker.hh" //gem5:Arka for decomissioning ruby/log_tm
// #include "TransactionInterfaceManager.hh"
//#include "TransactionVersionManager.hh" //gem5:Arka for decomissioning ruby/log_tm
#include "Sequencer.hh"
/*------------------------------------------------------------------------*/
/* Forward declarations */
/*------------------------------------------------------------------------*/
static CacheRequestType get_request_type( OpalMemop_t opaltype );
static OpalMemop_t get_opal_request_type( CacheRequestType type );
/// The static opalinterface instance
OpalInterface *OpalInterface::inst = NULL;
/*------------------------------------------------------------------------*/
/* Constructor(s) / destructor */
/*------------------------------------------------------------------------*/
//**************************************************************************
OpalInterface::OpalInterface(System* sys_ptr) {
clearStats();
ASSERT( inst == NULL );
inst = this;
m_opal_intf = NULL;
}
/*------------------------------------------------------------------------*/
/* Public methods */
/*------------------------------------------------------------------------*/
//**************************************************************************
void OpalInterface::printConfig(ostream& out) const {
out << "Opal_ruby_multiplier: " << OPAL_RUBY_MULTIPLIER << endl;
out << endl;
}
void OpalInterface::printStats(ostream& out) const {
out << endl;
out << "Opal Interface Stats" << endl;
out << "----------------------" << endl;
out << endl;
}
//**************************************************************************
void OpalInterface::clearStats() {
}
//**************************************************************************
integer_t OpalInterface::getInstructionCount(int procID) const {
return ((*m_opal_intf->getInstructionCount)(procID));
}
//*************************************************************************
uint64 OpalInterface::getOpalTime(int procID) const {
return ((*m_opal_intf->getOpalTime)(procID));
}
/************ For WATTCH power stats ************************************/
//*************************************************************************
void OpalInterface::incrementL2Access(int procID) const{
((*m_opal_intf->incrementL2Access)(procID));
}
//*************************************************************************
void OpalInterface::incrementPrefetcherAccess(int procID, int num_prefetches, int isinstr) const{
((*m_opal_intf->incrementPrefetcherAccess)(procID, num_prefetches, isinstr));
}
/******************** END WATTCH power stats ****************************/
// Notifies Opal of an L2 miss
//*************************************************************************
void OpalInterface::notifyL2Miss(int procID, physical_address_t physicalAddr, OpalMemop_t type, int tagexists) const{
((*m_opal_intf->notifyL2Miss)(procID, physicalAddr, type, tagexists));
}
/******************************************************************
* void hitCallback(int cpuNumber)
* Called by Sequencer. Calls opal.
******************************************************************/
//**************************************************************************
void OpalInterface::hitCallback(NodeID proc, SubBlock& data, CacheRequestType type, int thread) {
// notify opal that the transaction has completed
(*m_opal_intf->hitCallback)( proc, data.getAddress().getAddress(), get_opal_request_type(type), thread );
}
//**************************************************************************
// Useful functions if Ruby needs to read/write physical memory when running with Opal
integer_t OpalInterface::readPhysicalMemory(int procID,
physical_address_t address,
int len ){
return SIMICS_read_physical_memory(procID, address, len);
}
//**************************************************************************
void OpalInterface::writePhysicalMemory( int procID,
physical_address_t address,
integer_t value,
int len ){
SIMICS_write_physical_memory(procID, address, value, len);
}
//***************************************************************
// notifies Opal to print debug info
void OpalInterface::printDebug(){
(*m_opal_intf->printDebug)();
}
//***************************************************************
/******************************************************************
* Called by opal's memory operations (memop.C)
* May call Sequencer.
******************************************************************/
//****************************************************************************
int OpalInterface::getNumberOutstanding( int cpuNumber ){
Sequencer* targetSequencer_ptr = g_system_ptr->getChip(cpuNumber/RubyConfig::numberOfProcsPerChip())->getSequencer(cpuNumber%RubyConfig::numberOfProcsPerChip());
return targetSequencer_ptr->getNumberOutstanding();
}
//****************************************************************************
int OpalInterface::getNumberOutstandingDemand( int cpuNumber ){
Sequencer* targetSequencer_ptr = g_system_ptr->getChip(cpuNumber/RubyConfig::numberOfProcsPerChip())->getSequencer(cpuNumber%RubyConfig::numberOfProcsPerChip());
return targetSequencer_ptr->getNumberOutstandingDemand();
}
//****************************************************************************
int OpalInterface::getNumberOutstandingPrefetch( int cpuNumber ){
Sequencer* targetSequencer_ptr = g_system_ptr->getChip(cpuNumber/RubyConfig::numberOfProcsPerChip())->getSequencer(cpuNumber%RubyConfig::numberOfProcsPerChip());
return targetSequencer_ptr->getNumberOutstandingPrefetch();
}
//**************************************************************************
int OpalInterface::isReady( int cpuNumber, la_t logicalAddr, pa_t physicalAddr, OpalMemop_t typeOfRequest, int thread ) {
// Send request to sequencer
Sequencer* targetSequencer_ptr = g_system_ptr->getChip(cpuNumber/RubyConfig::numberOfProcsPerChip())->getSequencer(cpuNumber%RubyConfig::numberOfProcsPerChip());
// FIXME - some of these fields have bogus values sinced isReady()
// doesn't need them. However, it would be cleaner if all of these
// fields were exact.
return (targetSequencer_ptr->isReady(CacheMsg(Address( physicalAddr ),
Address( physicalAddr ),
get_request_type(typeOfRequest),
Address(0),
AccessModeType_UserMode, // User/supervisor mode
0, // Size in bytes of request
PrefetchBit_No, // Not a prefetch
0, // Version number
Address(logicalAddr), // Virtual Address
thread, // SMT thread
0, // TM specific - timestamp of memory request
false // TM specific - whether request is part of escape action
)
));
}
// FIXME: duplicated code should be avoided
//**************************************************************************
void OpalInterface::makeRequest(int cpuNumber, la_t logicalAddr, pa_t physicalAddr,
int requestSize, OpalMemop_t typeOfRequest,
la_t virtualPC, int isPriv, int thread) {
// Issue the request to the sequencer.
// set access type (user/supervisor)
AccessModeType access_mode;
if (isPriv) {
access_mode = AccessModeType_SupervisorMode;
} else {
access_mode = AccessModeType_UserMode;
}
// Send request to sequencer
Sequencer* targetSequencer_ptr = g_system_ptr->getChip(cpuNumber/RubyConfig::numberOfProcsPerChip())->getSequencer(cpuNumber%RubyConfig::numberOfProcsPerChip());
targetSequencer_ptr->makeRequest(CacheMsg(Address( physicalAddr ),
Address( physicalAddr ),
get_request_type(typeOfRequest),
Address(virtualPC),
access_mode, // User/supervisor mode
requestSize, // Size in bytes of request
PrefetchBit_No, // Not a prefetch
0, // Version number
Address(logicalAddr), // Virtual Address
thread, // SMT thread
0, // TM specific - timestamp of memory request
false // TM specific - whether request is part of escape action
)
);
}
//**************************************************************************
void OpalInterface::makePrefetch(int cpuNumber, la_t logicalAddr, pa_t physicalAddr,
int requestSize, OpalMemop_t typeOfRequest,
la_t virtualPC, int isPriv, int thread) {
DEBUG_MSG(SEQUENCER_COMP,MedPrio,"Making prefetch request");
// Issue the request to the sequencer.
// set access type (user/supervisor)
AccessModeType access_mode;
if (isPriv) {
access_mode = AccessModeType_SupervisorMode;
} else {
access_mode = AccessModeType_UserMode;
}
// make the prefetch
Sequencer* targetSequencer_ptr = g_system_ptr->getChip(cpuNumber/RubyConfig::numberOfProcsPerChip())->getSequencer(cpuNumber%RubyConfig::numberOfProcsPerChip());
targetSequencer_ptr->makeRequest(CacheMsg(Address( physicalAddr ),
Address( physicalAddr ),
get_request_type(typeOfRequest),
Address(virtualPC),
access_mode,
requestSize,
PrefetchBit_Yes, // True means this is a prefetch
0, // Version number
Address(logicalAddr), // Virtual Address
thread, // SMT thread
0, // TM specific - timestamp of memory request
false // TM specific - whether request is part of escape action
)
);
return;
}
//**************************************************************************
int OpalInterface::staleDataRequest( int cpuNumber, pa_t physicalAddr,
int requestSize, int8 *buffer ) {
// Find sequencer
Sequencer* targetSequencer_ptr = g_system_ptr->getChip(cpuNumber/RubyConfig::numberOfProcsPerChip())->getSequencer(cpuNumber%RubyConfig::numberOfProcsPerChip());
assert(targetSequencer_ptr != NULL);
// query the cache for stale data values (if any)
bool hit = false;
//hit = targetSequencer_ptr->staleDataAccess( Address(physicalAddr),
// requestSize, buffer );
return hit;
}
//**************************************************************************
void OpalInterface::notify( int status ) {
if (OpalInterface::inst == NULL) {
if (status == 1) {
// notify system that opal is now loaded
g_system_ptr->opalLoadNotify();
} else {
return;
}
}
// opal interface must be allocated now
ASSERT( OpalInterface::inst != NULL );
if ( status == 0 ) {
} else if ( status == 1 ) {
// install notification: query opal for its interface
OpalInterface::inst->queryOpalInterface();
if ( OpalInterface::inst->m_opal_intf != NULL ) {
cout << "OpalInterface: installation successful." << endl;
// test: (*(OpalInterface::inst->m_opal_intf->hitCallback))( 0, 0xFFULL );
}
} else if ( status == 2 ) {
// unload notification
// NOTE: this is not tested, as we can't unload ruby or opal right now.
OpalInterface::inst->removeOpalInterface();
}
}
// advance ruby time
//**************************************************************************
int OpalInterface::s_advance_counter = 0;
void OpalInterface::advanceTime( void ) {
s_advance_counter++;
if (s_advance_counter == OPAL_RUBY_MULTIPLIER) {
Time time = g_eventQueue_ptr->getTime() + 1;
DEBUG_EXPR(NODE_COMP, HighPrio, time);
g_eventQueue_ptr->triggerEvents(time);
s_advance_counter = 0;
}
}
// return ruby's time
//**************************************************************************
unsigned long long OpalInterface::getTime( void ) {
return (g_eventQueue_ptr->getTime());
}
// print's Ruby outstanding request table
void OpalInterface::printProgress(int cpuNumber){
Sequencer* targetSequencer_ptr = g_system_ptr->getChip(cpuNumber/RubyConfig::numberOfProcsPerChip())->getSequencer(cpuNumber%RubyConfig::numberOfProcsPerChip());
assert(targetSequencer_ptr != NULL);
targetSequencer_ptr->printProgress(cout);
}
// Non-method helper function
//**************************************************************************
static CacheRequestType get_request_type( OpalMemop_t opaltype ) {
CacheRequestType type;
if (opaltype == OPAL_LOAD) {
type = CacheRequestType_LD;
} else if (opaltype == OPAL_STORE){
type = CacheRequestType_ST;
} else if (opaltype == OPAL_IFETCH){
type = CacheRequestType_IFETCH;
} else if (opaltype == OPAL_ATOMIC){
type = CacheRequestType_ATOMIC;
} else {
ERROR_MSG("Error: Strange memory transaction type: not a LD or a ST");
}
return type;
}
//**************************************************************************
static OpalMemop_t get_opal_request_type( CacheRequestType type ) {
OpalMemop_t opal_type;
if(type == CacheRequestType_LD){
opal_type = OPAL_LOAD;
}
else if( type == CacheRequestType_ST){
opal_type = OPAL_STORE;
}
else if( type == CacheRequestType_IFETCH){
opal_type = OPAL_IFETCH;
}
else if( type == CacheRequestType_ATOMIC){
opal_type = OPAL_ATOMIC;
}
else{
ERROR_MSG("Error: Strange memory transaction type: not a LD or a ST");
}
//cout << "get_opal_request_type() CacheRequestType[ " << type << " ] opal_type[ " << opal_type << " ] " << endl;
return opal_type;
}
//**************************************************************************
void OpalInterface::removeOpalInterface( void ) {
cout << "ruby: opal uninstalled. reinstalling timing model." << endl;
SIMICS_install_timing_model();
}
//**************************************************************************
bool OpalInterface::isOpalLoaded( void ) {
if (!g_SIMICS) {
return false;
} else {
mf_opal_api_t *opal_interface = SIMICS_get_opal_interface();
if ( opal_interface == NULL ) {
return false;
} else {
return true;
}
}
}
//**************************************************************************
void OpalInterface::queryOpalInterface( void ) {
m_opal_intf = SIMICS_get_opal_interface();
if ( m_opal_intf == NULL ) {
WARN_MSG("error: OpalInterface: opal does not implement mf-opal-api interface.\n");
} else {
// opal is loaded -- remove the timing_model interface
cout << "Ruby: ruby-opal link established. removing timing_model." << endl;
SIMICS_remove_timing_model();
if (m_opal_intf->notifyCallback != NULL) {
cout << "opalinterface: doing notify callback\n";
(*m_opal_intf->notifyCallback)( 1 );
} else {
// 2/27/2005, removed spurious error message (MRM)
// cout << "error: opalinterface: mf-opal-api has NULL notify callback.\n";
}
}
}
// install the opal interface to simics
//**************************************************************************
void OpalInterface::installInterface( mf_ruby_api_t *api ) {
// install ruby interface
api->isReady = &OpalInterface::isReady;
api->makeRequest = &OpalInterface::makeRequest;
api->makePrefetch = &OpalInterface::makePrefetch;
api->advanceTime = &OpalInterface::advanceTime;
api->getTime = &OpalInterface::getTime;
api->staleDataRequest = &OpalInterface::staleDataRequest;
api->notifyCallback = &OpalInterface::notify;
api->getNumberOutstanding = &OpalInterface::getNumberOutstanding;
api->getNumberOutstandingDemand = &OpalInterface::getNumberOutstandingDemand;
api->getNumberOutstandingPrefetch = &OpalInterface::getNumberOutstandingPrefetch;
api->printProgress = &OpalInterface::printProgress;
}