JCommEngineGroup& JAgentThread::GetCommEngineGroup()
{
JLogAutoPtr clsLogAutoPtr(JSingleton<JLog>::instance(),
JLOG_MOD_THREAD, "JAgentThread::GetCommEngineGroup");
return m_commEngineGroup;
}
JCommEngine* JAgentThread::GetNotifyCommEngine()
{
JLogAutoPtr clsLogAutoPtr(JSingleton<JLog>::instance(),
JLOG_MOD_THREAD, "JAgentThread::GetNotifyCommEngine");
return m_pNotifyCommEngine;
}
JQueue<JEvent>& JAgentThread::GetQueue()
{
JLogAutoPtr clsLogAutoPtr(JSingleton<JLog>::instance(),
JLOG_MOD_THREAD, "JAgentThread::GetQueue");
return m_agtThrdData.hQueue;
}
JUINT32 JModuleThread::EnQueueEvent(JListItem<JEvent>* pItem, JCHAR* pModName)
{
JQueue<JEvent>* pModuleQueue = JNULL;
JLogAutoPtr clsLogAutoPtr(JSingleton<JLog>::instance(),
JLOG_MOD_THREAD, "JModuleThread::EnQueueEvent");
if (!pItem)
{
JSingleton<JLog>::instance2() << set(JLOG_MOD_THREAD, JLOG_ERROR_LEVEL)
<< "JModuleThread::EnQueueEvent input param is NULL\n";
return JFAILURE;
}
pModuleQueue = GetModuleQueue(pModName);
if (pModuleQueue)
{
m_Lock.Acquire();
pModuleQueue->EnQueue(pItem);
m_Lock.Release();
}
else
{
JSingleton<JLog>::instance2() << set(JLOG_MOD_THREAD, JLOG_ERROR_LEVEL)
<< "JModuleThread::EnQueueEvent module queue isn't exist\n";
return JFAILURE;
}
return JSUCCESS;
}
JUINT32 JThreadManager::Run()
{
JUINT32 uiIdx = 0;
JUINT32 uiRet = 0;
JLogAutoPtr clsLogAutoPtr(JSingleton<JLog>::instance(),
JLOG_MOD_THREAD, "JThreadManager::Run");
for (uiIdx=0; uiIdx<m_thrdDataUsed; uiIdx++)
{
if (m_thrdData[uiIdx].pThread &&
!m_thrdData[uiIdx].bRunning &&
(m_thrdData[uiIdx].pThread->GetType() == JTHRD_TYPE_MOD ||
m_thrdData[uiIdx].pThread->GetType() == JTHRD_TYPE_SRV ||
m_thrdData[uiIdx].pThread->GetType() == JTHRD_TYPE_MSG))
{
m_thrdData[uiIdx].pThreadId = CreateThread(JNULL, JNULL,
(LPTHREAD_START_ROUTINE)JThreadProc, m_thrdData[uiIdx].pThread, 0,
(LPDWORD)JNULL);
if (!m_thrdData[uiIdx].pThreadId)
{
JSingleton<JLog>::instance2() << set(JLOG_MOD_THREAD, JLOG_ERROR_LEVEL)
<< "JThreadManager::Run CreateThread return failure\n";
return JFAILURE;
}
m_thrdData[uiIdx].bRunning = JTRUE;
}
}
return JSUCCESS;
}
JEVT_TYPE JEvent::GetEventType()
{
JLogAutoPtr clsLogAutoPtr(JSingleton<JLog>::instance(),
JLOG_MOD_EVENT, "JEvent::GetEventType");
return m_eType;
}
JEventBody* JEvent::GetBody()
{
JLogAutoPtr clsLogAutoPtr(JSingleton<JLog>::instance(),
JLOG_MOD_EVENT, "JEvent::GetBody");
return m_pBody;
}
JString& JEvent::GetToMod()
{
JLogAutoPtr clsLogAutoPtr(JSingleton<JLog>::instance(),
JLOG_MOD_EVENT, "JEvent::GetToMod(");
return m_strToMod;
}
JString& JEvent::GetFromThrd()
{
JLogAutoPtr clsLogAutoPtr(JSingleton<JLog>::instance(),
JLOG_MOD_EVENT, "JEvent::GetFromThrd");
return m_strFromThrd;
}
JUINT32 JAgentThread::Run()
{
JLogAutoPtr clsLogAutoPtr(JSingleton<JLog>::instance(),
JLOG_MOD_THREAD, "JAgentThread::Run");
return JSUCCESS;
}
JModule* GetRegisterModule(JCHAR* pThrdName, JCHAR* pModName)
{
JThread* pThread = JNULL;
JModuleThread* pModuleThread = JNULL;
JModule* pModule = JNULL;
JThreadManager* pThreadManager = JSingleton<JThreadManager>::instance();
JLogAutoPtr clsLogAutoPtr(JSingleton<JLog>::instance(),
JLOG_MOD_THREAD, "GetRegisterModule");
if (!pThrdName || !pModName)
{
return JNULL;
}
pThread = pThreadManager->GetThread(pThrdName);
if (pThread && pThread->GetType() == JTHRD_TYPE_MOD)
{
pModuleThread = dynamic_cast<JModuleThread*>(pThread);
if (pModuleThread)
{
pModule = pModuleThread->GetModule(pModName);
}
}
return pModule;
}
JEventBody* JAgentThread::MakeEventBody(JEVT_TYPE eType, JCHAR* pModName)
{
JEventBody* pEventBody = JNULL;
JLogAutoPtr clsLogAutoPtr(JSingleton<JLog>::instance(),
JLOG_MOD_THREAD, "JAgentThread::MakeEventBody");
return pEventBody;
}
JUINT32 JEvent::SetFromMod(JCHAR* pFromMod)
{
JLogAutoPtr clsLogAutoPtr(JSingleton<JLog>::instance(),
JLOG_MOD_EVENT, "JEvent::SetFromMod");
m_strFromMod = pFromMod;
return JSUCCESS;
}
JUINT32 JEvent::SetBody(JEventBody* pBody)
{
JLogAutoPtr clsLogAutoPtr(JSingleton<JLog>::instance(),
JLOG_MOD_EVENT, "JEvent::SetBody");
m_pBody = pBody;
return JSUCCESS;
}
template<> inline JUINT32 JList<JPER_RECORD>::CopyObject(JList<JPER_RECORD>& rDst,
JList<JPER_RECORD>& rSrc)
{
JPER_RECORD* pDstData = JNULL;
JListItem<JPER_RECORD>* pDstItem = JNULL;
JUINT32 uiLen = 0;
JPER_RECORD* pSrcData = JNULL;
JListItem<JPER_RECORD>* pSrcItem = JNULL;
JListItem<JPER_RECORD>* prevDstItem = JNULL;
rDst.m_pHead = JNULL;
rDst.m_pTail = JNULL;
JLogAutoPtr clsLogAutoPtr(JSingleton<JLog>::instance(),
JLOG_MOD_LIST, "JList::CopyObject");
JListIterator<JPER_RECORD> clsListIter(rSrc);
for (clsListIter.First(); clsListIter.Done(); clsListIter.Next())
{
pSrcItem = clsListIter.Item();
pDstData = JNULL;
pSrcData = pSrcItem->GetData();
uiLen = pSrcItem->GetDataLength();
if (uiLen)
{
//alloc memory for the dst data
pDstData =
reinterpret_cast<JPER_RECORD*>(JSingleton<JStaticMemory>::instance()->Alloc(uiLen+1));
if (pDstData)
{
SafeMemset(reinterpret_cast<JCHAR*>(pDstData), 0, uiLen+1);
SafeMemcpy(reinterpret_cast<JCHAR*>(pDstData),
reinterpret_cast<JCHAR*>(pSrcData), uiLen, uiLen+1);
}
else
{
JSingleton<JLog>::instance2() << set(JLOG_MOD_LIST, JLOG_ERROR_LEVEL)
<< "JList::CopyObject memory alloc failure\n";
return JFAILURE;
}
}
//construct the dst item
pDstItem = new JListItem<JPER_RECORD>(pDstData);
pDstItem->SetDataLength(uiLen);
rDst.InsertItem(pDstItem, prevDstItem);
prevDstItem = pDstItem;
}
return JSUCCESS;
}
JListItem<JEvent>* JAgentThread::DeQueueEvent()
{
JListItem<JEvent>* pListItem = JNULL;
JLogAutoPtr clsLogAutoPtr(JSingleton<JLog>::instance(),
JLOG_MOD_THREAD, "JAgentThread::DeQueueEvent");
m_Lock.Acquire();
pListItem = m_agtThrdData.hQueue.DeQueue();
m_Lock.Release();
return pListItem;
}
DWORD JThreadProc(JThread* pThread)
{
JLogAutoPtr clsLogAutoPtr(JSingleton<JLog>::instance(),
JLOG_MOD_THREAD, "JThreadProc");
if (!pThread)
{
cout << "JThreadProc input param is NULL" << endl;
return JFAILURE;
}
pThread->Run();
return JSUCCESS;
}
JEventBody* JThreadManager::MakeEventBody(JCHAR* pThrdName, JCHAR* pModName, JEVT_TYPE eType)
{
JThread* pThread = JNULL;
JEventBody* pEventBody = JNULL;
JLogAutoPtr clsLogAutoPtr(JSingleton<JLog>::instance(),
JLOG_MOD_THREAD, "JThreadManager::MakeEventBody");
pThread = GetThread(pThrdName);
if (pThread)
{
pEventBody = pThread->MakeEventBody(eType, pModName);
}
return pEventBody;
}
JUINT32 JEvent::SetFromThrd(JCHAR* pFromThrd)
{
JLogAutoPtr clsLogAutoPtr(JSingleton<JLog>::instance(),
JLOG_MOD_EVENT, "JEvent::SetFromThrd");
if (!pFromThrd)
{
JSingleton<JLog>::instance2() << set(JLOG_MOD_EVENT, JLOG_ERROR_LEVEL)
<< "JEvent::SetFromThrd input param is NULL\n";
return JFAILURE;
}
m_strFromThrd = pFromThrd;
return JSUCCESS;
}
JEventBody* JModuleThread::MakeEventBody(JEVT_TYPE eType, JCHAR* pModName)
{
JEventBody* pEventBody = JNULL;
JModule* pModule = JNULL;
JLogAutoPtr clsLogAutoPtr(JSingleton<JLog>::instance(),
JLOG_MOD_THREAD, "JModuleThread::MakeEventBody");
pModule = GetModule(pModName);
if (pModule)
{
pEventBody = pModule->MakeEventBody(static_cast<JUINT32>(eType));
}
return pEventBody;
}
JUINT32 JEvent::SetToProc(JCHAR* pToProc)
{
JLogAutoPtr clsLogAutoPtr(JSingleton<JLog>::instance(),
JLOG_MOD_EVENT, "JEvent::SetToProc");
if (!pToProc)
{
JSingleton<JLog>::instance2() << set(JLOG_MOD_EVENT, JLOG_ERROR_LEVEL)
<< "JEvent::SetToProc input param is NULL\n";
return JFAILURE;
}
m_strToProc = pToProc;
return JSUCCESS;
}
JThread* JThreadManager::GetThread(JCHAR* pThrdName)
{
JUINT32 uiIdx;
JLogAutoPtr clsLogAutoPtr(JSingleton<JLog>::instance(),
JLOG_MOD_THREAD, "JThreadManager::GetThread");
for (uiIdx=0; uiIdx<m_thrdDataUsed; uiIdx++)
{
if (m_thrdData[uiIdx].strThrdName == pThrdName)
{
return m_thrdData[uiIdx].pThread;
}
}
return JNULL;
}
JModule* JModuleThread::GetModule(JCHAR* pModName)
{
JUINT32 uiIdx;
JLogAutoPtr clsLogAutoPtr(JSingleton<JLog>::instance(),
JLOG_MOD_THREAD, "JModuleThread::GetModule");
for (uiIdx=0; uiIdx<m_modDataUsed; uiIdx++)
{
if (m_modData[uiIdx].strModName == pModName)
{
return m_modData[uiIdx].pModule;
}
}
return JNULL;
}
JUINT32 JAgentThread::EnQueueEvent(JListItem<JEvent>* pItem, JCHAR* pModName)
{
JLogAutoPtr clsLogAutoPtr(JSingleton<JLog>::instance(),
JLOG_MOD_THREAD, "JAgentThread::EnQueueEvent");
if (!pItem)
{
JSingleton<JLog>::instance2() << set(JLOG_MOD_THREAD, JLOG_ERROR_LEVEL)
<< "JAgentThread::EnQueueEvent input param is NULL\n";
return JFAILURE;
}
m_Lock.Acquire();
m_agtThrdData.hQueue.EnQueue(pItem);
m_Lock.Release();
return JSUCCESS;
}
JUINT32 JThreadManager::RegisterThread(JTHRD_PUB_DATA thrdPubData)
{
JLogAutoPtr clsLogAutoPtr(JSingleton<JLog>::instance(),
JLOG_MOD_THREAD, "JThreadManager::RegisterModule");
if (m_thrdDataUsed >= JTHREAD_MAX_MODULE)
{
JSingleton<JLog>::instance2() << set(JLOG_MOD_THREAD, JLOG_ERROR_LEVEL)
<< "JThreadManager::RegisterModule: registered module already reach to the max number\n";
return JFAILURE;
}
m_thrdData[m_thrdDataUsed].strThrdName = thrdPubData.strThrdName;
m_thrdData[m_thrdDataUsed].pThread = thrdPubData.pThread;
m_thrdDataUsed++;
return JSUCCESS;
}
JUINT32 JModuleThread::RegisterModule(JMOD_PUB_DATA modPubData)
{
JLogAutoPtr clsLogAutoPtr(JSingleton<JLog>::instance(),
JLOG_MOD_THREAD, "JModuleThread::RegisterModule");
if (m_modDataUsed >= JTHREAD_MAX_MODULE)
{
JSingleton<JLog>::instance2() << set(JLOG_MOD_THREAD, JLOG_ERROR_LEVEL)
<< "JModuleThread::RegisterModule: registered module already reach to the max number\n";
return JFAILURE;
}
m_modData[m_modDataUsed].strModName = modPubData.strModName;
m_modData[m_modDataUsed].eLevel = modPubData.eLevel;
m_modData[m_modDataUsed].pModule = modPubData.pModule;
m_modData[m_modDataUsed].uiRunTime = 0;
m_modDataUsed++;
return JSUCCESS;
}
JUINT32 JThreadManager::EnQueueEvent(JCHAR* pThrdName, JCHAR* pModName, JListItem<JEvent>* pItem)
{
JUINT32 uiRet = JFAILURE;
JThread* pThread = JNULL;
JLogAutoPtr clsLogAutoPtr(JSingleton<JLog>::instance(),
JLOG_MOD_THREAD, "JThreadManager::EnQueueEvent");
if (!pThrdName && !pModName && !pItem)
{
JSingleton<JLog>::instance2() << set(JLOG_MOD_THREAD, JLOG_ERROR_LEVEL)
<< "JThreadManager::EnQueueEvent input param is NULL\n";
return JFAILURE;
}
pThread = GetThread(pThrdName);
if (pThread)
{
uiRet = pThread->EnQueueEvent(pItem, pModName);
}
return uiRet;
}
JUINT32 JModuleThread::GetRunModuleSeq()
{
JUINT32 uiIdx = 0;
JUINT32 uiHighPriMod = m_modDataUsed;
JUINT32 uiMinRunTime = 0xFFFF;
JLogAutoPtr clsLogAutoPtr(JSingleton<JLog>::instance(),
JLOG_MOD_THREAD, "JModuleThread::GetRunModuleSeq");
for (uiIdx=0; uiIdx<m_modDataUsed; uiIdx++)
{
if (!m_modData[uiIdx].hQueue.IsEmpty())
{
if (uiMinRunTime > m_modData[uiIdx].uiRunTime)
{
uiMinRunTime = m_modData[uiIdx].uiRunTime;
uiHighPriMod = uiIdx;
}
}
}
return uiHighPriMod;
}
JUINT32 JModuleThread::IncModuleSeq(const JUINT32 uiModSeq)
{
JUINT32 uiIdx = 0;
JUINT32 uiMinRunTime = m_modData[0].uiRunTime;
JUINT32 uiSwitchValue = 0;
JUINT32 uiMaxValue = 0xFFFF;
JUINT32 uiIncValue = 0;
JLogAutoPtr clsLogAutoPtr(JSingleton<JLog>::instance(),
JLOG_MOD_THREAD, "JModuleThread::IncModuleSeq");
if (uiModSeq < m_modDataUsed)
{
uiIncValue = m_modData[uiModSeq].eLevel;
if ((uiMaxValue-m_modData[uiModSeq].uiRunTime) < uiIncValue)
{
for (uiIdx=1; uiIdx<m_modDataUsed; uiIdx++)
{
if (uiMinRunTime > m_modData[uiIdx].uiRunTime)
{
uiMinRunTime = m_modData[uiIdx].uiRunTime;
}
}
uiSwitchValue = uiMaxValue-uiMinRunTime;
for (uiIdx=0; uiIdx<m_modDataUsed; uiIdx++)
{
m_modData[uiIdx].uiRunTime += uiSwitchValue;
}
}
m_modData[uiModSeq].uiRunTime += m_modData[uiModSeq].eLevel;
}
return JSUCCESS;
}
JQueue<JEvent>* JModuleThread::GetModuleQueue(JCHAR* pModName)
{
JUINT32 uiIdx;
JLogAutoPtr clsLogAutoPtr(JSingleton<JLog>::instance(),
JLOG_MOD_THREAD, "JModuleThread::GetModuleQueue");
if (!pModName)
{
JSingleton<JLog>::instance2() << set(JLOG_MOD_THREAD, JLOG_ERROR_LEVEL)
<< "JModuleThread::GetModuleQueue input param is NULL\n";
return JNULL;
}
for (uiIdx=0; uiIdx<m_modDataUsed; uiIdx++)
{
if (m_modData[uiIdx].strModName == pModName)
{
return &m_modData[uiIdx].hQueue;
}
}
return JNULL;
}
