00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032 #include <pch.h>
00033
00034 #include "Sim/Predictor/DepPred/MemDepPred/ConservativeMemDepPred.h"
00035 #include "Sim/Op/Op.h"
00036 #include "Sim/Core/Core.h"
00037
00038
00039 using namespace std;
00040 using namespace boost;
00041 using namespace Onikiri;
00042
00043 ConservativeMemDepPred::ConservativeMemDepPred() :
00044 m_core(0),
00045 m_checkpointMaster(0),
00046 m_latestStoreDst(),
00047 m_latestMemDst()
00048 {
00049 }
00050
00051 ConservativeMemDepPred::~ConservativeMemDepPred()
00052 {
00053 ReleaseParam();
00054 }
00055
00056 void ConservativeMemDepPred::Initialize(InitPhase phase)
00057 {
00058 if(phase == INIT_POST_CONNECTION){
00059
00060 CheckNodeInitialized( "checkpointMaster", m_checkpointMaster );
00061
00062 m_latestStoreDst.Initialize(
00063 m_checkpointMaster,
00064 CheckpointMaster::SLOT_RENAME
00065 );
00066 m_latestMemDst.Initialize(
00067 m_checkpointMaster,
00068 CheckpointMaster::SLOT_RENAME
00069 );
00070
00071 MemDependencyPtr
00072 tmpStoreDst(
00073 m_memDepPool.construct( m_core->GetNumScheduler() )
00074 );
00075 tmpStoreDst->Set();
00076 m_latestStoreDst.GetCurrent() = tmpStoreDst;
00077
00078 MemDependencyPtr
00079 tmpMemDst(
00080 m_memDepPool.construct( m_core->GetNumScheduler() )
00081 );
00082 tmpMemDst->Set();
00083 m_latestMemDst.GetCurrent() = tmpMemDst;
00084 }
00085 }
00086
00087
00088
00089
00090 void ConservativeMemDepPred::Resolve(OpIterator op)
00091 {
00092
00093 if( !op->GetOpClass().IsMem() ) {
00094 return;
00095 }
00096
00097 if( op->GetOpClass().IsLoad() ) {
00098 if( m_latestStoreDst.GetCurrent() == NULL ) {
00099 return;
00100 }
00101
00102 op->SetSrcMem(0, m_latestStoreDst.GetCurrent());
00103
00104 }else if( op->GetOpClass().IsStore() ) {
00105 if( m_latestMemDst.GetCurrent() == NULL ) {
00106 return;
00107 }
00108
00109 op->SetSrcMem(0, m_latestMemDst.GetCurrent());
00110
00111 }else {
00112 THROW_RUNTIME_ERROR("Unknown Memory Instruction");
00113 }
00114 }
00115
00116
00117 void ConservativeMemDepPred::Allocate(OpIterator op)
00118 {
00119
00120 if( !op->GetOpClass().IsMem() ) {
00121 return;
00122 }
00123
00124
00125 if( op->GetDstMem(0) == NULL ) {
00126 MemDependencyPtr tmpMem(
00127 m_memDepPool.construct(m_core->GetNumScheduler()) );
00128 tmpMem->Clear();
00129 op->SetDstMem(0, tmpMem);
00130 }
00131
00132 *m_latestMemDst = op->GetDstMem(0);
00133 if (op->GetOpClass().IsStore()) {
00134 *m_latestStoreDst = op->GetDstMem(0);
00135 }
00136 }
00137
00138
00139 void ConservativeMemDepPred::Deallocate(OpIterator op)
00140 {
00141 MemDependencyPtr dstMem = op->GetDstMem(0);
00142 if(*m_latestStoreDst == dstMem) {
00143 m_latestStoreDst->reset();
00144 }
00145
00146 if(*m_latestMemDst == dstMem) {
00147 m_latestMemDst->reset();
00148 }
00149 }
00150
00151 void ConservativeMemDepPred::Commit(OpIterator op)
00152 {
00153 if( op->GetOpClass().IsMem() ) {
00154 Deallocate(op);
00155 }
00156 }
00157
00158 void ConservativeMemDepPred::Flush(OpIterator op)
00159 {
00160 if( op->GetStatus() == OpStatus::OS_FETCH ){
00161 return;
00162 }
00163 if( op->GetOpClass().IsMem() ) {
00164 Deallocate(op);
00165 }
00166 }
00167
00168
00169
00170 void ConservativeMemDepPred::OrderConflicted(OpIterator producer, OpIterator consumer)
00171 {
00172 THROW_RUNTIME_ERROR("Access order violation must not occur with Conservative MemDepPred");
00173 }
00174
00175
00176
00177 bool ConservativeMemDepPred::CanAllocate(OpIterator* infoArray, int numOp)
00178 {
00179 return true;
00180 }