00001 // 00002 // Copyright (c) 2005-2008 Kenichi Watanabe. 00003 // Copyright (c) 2005-2008 Yasuhiro Watari. 00004 // Copyright (c) 2005-2008 Hironori Ichibayashi. 00005 // Copyright (c) 2008-2009 Kazuo Horio. 00006 // Copyright (c) 2009-2013 Naruki Kurata. 00007 // Copyright (c) 2005-2013 Ryota Shioya. 00008 // Copyright (c) 2005-2013 Masahiro Goshima. 00009 // 00010 // This software is provided 'as-is', without any express or implied 00011 // warranty. In no event will the authors be held liable for any damages 00012 // arising from the use of this software. 00013 // 00014 // Permission is granted to anyone to use this software for any purpose, 00015 // including commercial applications, and to alter it and redistribute it 00016 // freely, subject to the following restrictions: 00017 // 00018 // 1. The origin of this software must not be misrepresented; you must not 00019 // claim that you wrote the original software. If you use this software 00020 // in a product, an acknowledgment in the product documentation would be 00021 // appreciated but is not required. 00022 // 00023 // 2. Altered source versions must be plainly marked as such, and must not be 00024 // misrepresented as being the original software. 00025 // 00026 // 3. This notice may not be removed or altered from any source 00027 // distribution. 00028 // 00029 // 00030 00031 00032 #include <pch.h> 00033 00034 #include "Sim/Pipeline/Scheduler/FinishEvent.h" 00035 00036 #include "Utility/RuntimeError.h" 00037 #include "Sim/Dumper/Dumper.h" 00038 #include "Interface/Addr.h" 00039 00040 #include "Sim/Op/Op.h" 00041 #include "Sim/Thread/Thread.h" 00042 #include "Sim/Core/Core.h" 00043 #include "Sim/InorderList/InorderList.h" 00044 #include "Sim/Memory/MemOrderManager/MemOrderManager.h" 00045 #include "Sim/Predictor/LatPred/LatPred.h" 00046 #include "Sim/Pipeline/Scheduler/Scheduler.h" 00047 #include "Sim/Pipeline/Fetcher/Fetcher.h" 00048 00049 #include "Sim/Foundation/Hook/Hook.h" 00050 #include "Sim/Foundation/Hook/HookUtil.h" 00051 00052 00053 00054 using namespace Onikiri; 00055 00056 namespace Onikiri 00057 { 00058 HookPoint<OpFinishEvent,OpFinishEvent::FinishHookParam> OpFinishEvent::s_finishHook; 00059 }; 00060 00061 00062 OpFinishEvent::OpFinishEvent( OpIterator op ) : 00063 m_op( op ) 00064 { 00065 SetPriority( RP_EXECUTION_FINISH ); 00066 } 00067 00068 void OpFinishEvent::Update() 00069 { 00070 OpIterator op = m_op; 00071 ASSERT( 00072 op->GetStatus() == OpStatus::OS_EXECUTING, 00073 "Op:%s", 00074 op->ToString().c_str() 00075 ); 00076 00077 FinishHookParam param; 00078 param.flushed = false; 00079 00080 HOOK_SECTION_OP_PARAM( s_finishHook, op, param ) 00081 { 00082 Core* core = op->GetCore(); 00083 Thread* thread = op->GetThread(); 00084 Scheduler* scheduler = m_op->GetScheduler(); 00085 00086 // 00087 // Notify the finish of execution to each module. 00088 // 00089 00090 // Write back results to physical registers and update status. 00091 op->ExecutionEnd(); 00092 00093 // Each 'Finished' method may flush an op itself, 00094 // so need to check whether an op is alive or not. 00095 00096 // Update a latency predictor. 00097 if( op.IsAlive() ){ 00098 core->GetLatPred()->Finished( op ); 00099 } 00100 00101 // To a fetcher. 00102 // In Fetcher::Finished(), Check branch miss prediction and 00103 // recover if it is necessary. 00104 if( op.IsAlive() ){ 00105 core->GetFetcher()->Finished( op ); 00106 } 00107 00108 // To a memory order manager. 00109 // In MemOrderManager::Finished(), check access order violation 00110 // and recover if violation occurs. 00111 if( op.IsAlive() ){ 00112 thread->GetMemOrderManager()->Finished( op ); 00113 } 00114 00115 // To a scheduler. 00116 if( op.IsAlive() ){ 00117 scheduler->Finished( op ); 00118 } 00119 00120 if( !op.IsAlive() ){ 00121 param.flushed = true; 00122 } 00123 00124 // Value prediction is not implemented yet. 00125 //if( ValuePredictionMiss(m_op) ) { 00126 // return m_op->GetThread()->RecoverValPredMiss(m_op, DataPredType::VALUE); 00127 //} 00128 } 00129 00130 } 00131