Skip to content

Commit

Permalink
Merge pull request #232 from ketoo/blueprint
Browse files Browse the repository at this point in the history 
Blueprint
  • Loading branch information
@ketoo
ketoo committed Apr 2, 2020
2 parents 8610d3e + 7deae50 commit b80e7fa
Show file tree
Hide file tree
Showing 10 changed files with 106 additions and 280 deletions.
1 change: 1 addition & 0 deletions CMakeLists.txt
View file
Original file line number Diff line number Diff line change
Expand Up @@ -116,4 +116,5 @@ else()
add_subdirectory(Dependencies)
add_subdirectory(NFComm)
add_subdirectory(NFServer)
add_subdirectory(Tutorial)
endif()
292 changes: 65 additions & 227 deletions NFComm/NFKernelPlugin/NFScheduleModule.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -25,27 +25,17 @@

#include "NFScheduleModule.h"

void NFScheduleElement::DoHeartBeatEvent()
void NFScheduleElement::DoHeartBeatEvent(NFINT64 nowTime)
{
if (self.IsNull())
{
MODULE_SCHEDULE_FUNCTOR_PTR cb;
bool bRet = this->mxModuleFunctor.First(cb);
while (bRet)
{
cb.get()->operator()(mstrScheduleName, mfIntervalTime, mnRemainCount);
bRet = this->mxModuleFunctor.Next(cb);
}
}
else
mnRemainCount--;
mnTriggerTime = nowTime + (NFINT64)(mfIntervalTime * 1000);

OBJECT_SCHEDULE_FUNCTOR_PTR cb;
bool bRet = this->mxObjectFunctor.First(cb);
while (bRet)
{
OBJECT_SCHEDULE_FUNCTOR_PTR cb;
bool bRet = this->mxObjectFunctor.First(cb);
while (bRet)
{
cb.get()->operator()(self, mstrScheduleName, mfIntervalTime, mnRemainCount);
bRet = this->mxObjectFunctor.Next(cb);
}
cb.get()->operator()(self, mstrScheduleName, mfIntervalTime, mnRemainCount);
bRet = this->mxObjectFunctor.Next(cb);
}
}

Expand All @@ -65,280 +55,128 @@ bool NFScheduleModule::Init()
m_pKernelModule = pPluginManager->FindModule<NFIKernelModule>();

m_pKernelModule->RegisterCommonClassEvent(this, &NFScheduleModule::OnClassCommonEvent);

return true;
}

bool NFScheduleModule::Execute()
{
/*
we would optimize this function by saving a schedule element list by time sorting, then
we can pick the toppest schedule element to check the time to save the costs of CPU.
*/

NFPerformance performanceObject;
NFINT64 nNow = NFGetTimeMS();

//execute all tasks
NF_SHARE_PTR<NFMapEx <std::string, NFScheduleElement >> xObjectSchedule = mObjectScheduleMap.First();
while (xObjectSchedule)
{
std::string str;
NF_SHARE_PTR<NFScheduleElement> pSchedule = xObjectSchedule->First();
while (pSchedule)
{
if (nNow > pSchedule->mnNextTriggerTime)
{
if (pSchedule->mnRemainCount > 0 || pSchedule->mbForever == true)
{
if (!pSchedule->mbForever)
{
pSchedule->mnRemainCount--;
}

pSchedule->DoHeartBeatEvent();

if (pSchedule->mnRemainCount <= 0 && pSchedule->mbForever == false)
{
mObjectRemoveList.push_back(pSchedule);
}
else
{
NFINT64 nNextCostTime = NFINT64(pSchedule->mfIntervalTime * 1000);
pSchedule->mnNextTriggerTime = nNow + nNextCostTime;
}
}
}

pSchedule = xObjectSchedule->Next();
}
NFINT64 nowTime = NFGetTimeMS();

xObjectSchedule = mObjectScheduleMap.Next();
}
std::list<TickElement> elements;

//remove schedule
for (auto it = mObjectRemoveList.begin(); it != mObjectRemoveList.end(); ++it)
for (auto it = mScheduleMap.begin(); it != mScheduleMap.end();)
{
NF_SHARE_PTR<NFScheduleElement> scheduleElement = *it;
if (scheduleElement)
if (nowTime >= it->triggerTime)
{
NFGUID self = scheduleElement->self;
const std::string& scheduleName = scheduleElement->mstrScheduleName;
//std::cout << nowTime << it->scheduleName << ">>>>>" << it->triggerTime << std::endl;

auto findIter = mObjectScheduleMap.GetElement(self);
if (NULL != findIter)
auto objectMap = mObjectScheduleMap.GetElement(it->self);
if (objectMap)
{
findIter->RemoveElement(scheduleName);
if (findIter->Count() <= 0)
auto scheduleElement = objectMap->GetElement(it->scheduleName);
if (scheduleElement)
{
mObjectScheduleMap.RemoveElement(self);
}
}
}
}

mObjectRemoveList.clear();

//add schedule
for (std::list<NFScheduleElement>::iterator iter = mObjectAddList.begin(); iter != mObjectAddList.end(); ++iter)
{
NF_SHARE_PTR< NFMapEx <std::string, NFScheduleElement >> xObjectScheduleMap = mObjectScheduleMap.GetElement(iter->self);
if (NULL == xObjectScheduleMap)
{
xObjectScheduleMap = NF_SHARE_PTR< NFMapEx <std::string, NFScheduleElement >>(NF_NEW NFMapEx <std::string, NFScheduleElement >());
mObjectScheduleMap.AddElement(iter->self, xObjectScheduleMap);
}

NF_SHARE_PTR<NFScheduleElement> xScheduleElement = xObjectScheduleMap->GetElement(iter->mstrScheduleName);
if (NULL == xScheduleElement)
{
xScheduleElement = NF_SHARE_PTR<NFScheduleElement>(NF_NEW NFScheduleElement());
*xScheduleElement = *iter;

xObjectScheduleMap->AddElement(iter->mstrScheduleName, xScheduleElement);
}
}

mObjectAddList.clear();

if (performanceObject.CheckTimePoint(5))
{
std::ostringstream os;
os << "---------------object schedule performance problem ";
os << performanceObject.TimeScope();
os << "---------- ";
//m_pLogModule->LogWarning(NFGUID(), os, __FUNCTION__, __LINE__);
}

////////////////////////////////////////////
//execute all tasks

NFPerformance performanceModule;
scheduleElement->DoHeartBeatEvent(nowTime);

NF_SHARE_PTR< NFScheduleElement > xModuleSchedule = mModuleScheduleMap.First();
while (xModuleSchedule)
{
NFINT64 nNow = NFGetTimeMS();
if (nNow > xModuleSchedule->mnNextTriggerTime)
{
if (xModuleSchedule->mnRemainCount > 0 || xModuleSchedule->mbForever == true)
{
if (!xModuleSchedule->mbForever)
{
xModuleSchedule->mnRemainCount--;
}

xModuleSchedule->DoHeartBeatEvent();
if (scheduleElement->mnRemainCount != 0)
{
TickElement element;
element.scheduleName = scheduleElement->mstrScheduleName;
element.triggerTime = scheduleElement->mnTriggerTime;
element.self = scheduleElement->self;

if (xModuleSchedule->mnRemainCount <= 0 && xModuleSchedule->mbForever == false)
{
mModuleRemoveList.push_back(xModuleSchedule->mstrScheduleName);
}
else
{
NFINT64 nNextCostTime = NFINT64(xModuleSchedule->mfIntervalTime * 1000);
xModuleSchedule->mnNextTriggerTime = nNow + nNextCostTime;
elements.push_back(element);
}
}
}
}

xModuleSchedule = mModuleScheduleMap.Next();
}

//remove schedule
for (std::list<std::string>::iterator it = mModuleRemoveList.begin(); it != mModuleRemoveList.end(); ++it)
{
const std::string& strSheduleName = *it;;
auto findIter = mModuleScheduleMap.GetElement(strSheduleName);
if (NULL != findIter)
it = mScheduleMap.erase(it);
}
else
{
mModuleScheduleMap.RemoveElement(strSheduleName);
break;
}
}

mModuleRemoveList.clear();

//add schedule
for (std::list<NFScheduleElement>::iterator iter = mModuleAddList.begin(); iter != mModuleAddList.end(); ++iter)
for (auto& item : elements)
{
NF_SHARE_PTR< NFScheduleElement > xModuleScheduleMap = mModuleScheduleMap.GetElement(iter->mstrScheduleName);
if (NULL == xModuleScheduleMap)
{
xModuleScheduleMap = NF_SHARE_PTR< NFScheduleElement >(NF_NEW NFScheduleElement());
mModuleScheduleMap.AddElement(iter->mstrScheduleName, xModuleScheduleMap);
}

*xModuleScheduleMap = *iter;
mScheduleMap.insert(item);
}

mModuleAddList.clear();

if (performanceModule.CheckTimePoint(5))
if (performanceObject.CheckTimePoint(1))
{
std::ostringstream os;
os << "---------------module schedule performance problem ";
os << performanceModule.TimeScope();
os << performanceObject.TimeScope();
os << "---------- ";
//m_pLogModule->LogWarning(NFGUID(), os, __FUNCTION__, __LINE__);
m_pLogModule->LogWarning(NFGUID(), os, __FUNCTION__, __LINE__);
}

return true;
}

bool NFScheduleModule::AddSchedule(const std::string & strScheduleName, const MODULE_SCHEDULE_FUNCTOR_PTR & cb, const float fTime, const int nCount)
bool NFScheduleModule::AddSchedule(const NFGUID self, const std::string& strScheduleName, const OBJECT_SCHEDULE_FUNCTOR_PTR& cb, const float fTime, const int nCount)
{
NFScheduleElement xSchedule;
xSchedule.mstrScheduleName = strScheduleName;
xSchedule.mfIntervalTime = fTime;
xSchedule.mnNextTriggerTime = NFGetTimeMS() + (NFINT64)(fTime * 1000);
xSchedule.mnStartTime = NFGetTimeMS();
xSchedule.mnRemainCount = nCount;
xSchedule.mnAllCount = nCount;
xSchedule.self = NFGUID();
if (nCount < 0)
auto objectMap = mObjectScheduleMap.GetElement(self);
if (!objectMap)
{
xSchedule.mbForever = true;
objectMap = NF_SHARE_PTR< NFMapEx <std::string, NFScheduleElement >>(NF_NEW NFMapEx <std::string, NFScheduleElement >());
mObjectScheduleMap.AddElement(self, objectMap);
}

xSchedule.mxModuleFunctor.Add(cb);

mModuleAddList.push_back(xSchedule);

return true;
}
auto scheduleObject = objectMap->GetElement(strScheduleName);
if (!scheduleObject)
{
scheduleObject = NF_SHARE_PTR<NFScheduleElement>(NF_NEW NFScheduleElement());
scheduleObject->mstrScheduleName = strScheduleName;
scheduleObject->mfIntervalTime = fTime;
scheduleObject->mnTriggerTime = NFGetTimeMS() + (NFINT64)(fTime * 1000);
scheduleObject->mnRemainCount = nCount;
scheduleObject->self = self;

bool NFScheduleModule::AddSchedule(const std::string & strScheduleName, const MODULE_SCHEDULE_FUNCTOR_PTR & cb, const int nCount, const NFDateTime & date)
{
return false;
}

bool NFScheduleModule::RemoveSchedule(const std::string & strScheduleName)
{
mModuleRemoveList.push_back(strScheduleName);
scheduleObject->mxObjectFunctor.Add(cb);

return true;
}
objectMap->AddElement(strScheduleName, scheduleObject);

bool NFScheduleModule::ExistSchedule(const std::string & strScheduleName)
{
return mModuleScheduleMap.ExistElement(strScheduleName);
}
TickElement tickElement;
tickElement.scheduleName = scheduleObject->mstrScheduleName;
tickElement.triggerTime = scheduleObject->mnTriggerTime;
tickElement.self = scheduleObject->self;

bool NFScheduleModule::AddSchedule(const NFGUID self, const std::string& strScheduleName, const OBJECT_SCHEDULE_FUNCTOR_PTR& cb, const float fTime, const int nCount)
{
NFScheduleElement xSchedule;
xSchedule.mstrScheduleName = strScheduleName;
xSchedule.mfIntervalTime = fTime;
xSchedule.mnNextTriggerTime = NFGetTimeMS() + (NFINT64)(fTime * 1000);
xSchedule.mnStartTime = NFGetTimeMS();
xSchedule.mnRemainCount = nCount;
xSchedule.mnAllCount = nCount;
xSchedule.self = self;
if (nCount < 0)
{
xSchedule.mbForever = true;
mScheduleMap.insert(tickElement);
}

xSchedule.mxObjectFunctor.Add(cb);

mObjectAddList.push_back(xSchedule);

return true;
}

bool NFScheduleModule::AddSchedule(const NFGUID self, const std::string & strScheduleName, const OBJECT_SCHEDULE_FUNCTOR_PTR & cb, const int nCount, const NFDateTime & date)
{
//we would store this kind of schedule in database
return false;
}

bool NFScheduleModule::RemoveSchedule(const NFGUID self)
{
//is there will be deleted when using?
return mObjectScheduleMap.RemoveElement(self);
}

bool NFScheduleModule::RemoveSchedule(const NFGUID self, const std::string& strScheduleName)
{
NF_SHARE_PTR<NFScheduleElement> pScheduleElement = GetSchedule(self, strScheduleName);
if (pScheduleElement)
auto objectMap = mObjectScheduleMap.GetElement(self);
if (objectMap)
{
mObjectRemoveList.push_back(pScheduleElement);

return true;
return objectMap->RemoveElement(strScheduleName);
}

return false;
}

bool NFScheduleModule::ExistSchedule(const NFGUID self, const std::string& strScheduleName)
{
NF_SHARE_PTR< NFMapEx <std::string, NFScheduleElement >> xObjectScheduleMap = mObjectScheduleMap.GetElement(self);
if (NULL == xObjectScheduleMap)
auto objectScheduleMap = mObjectScheduleMap.GetElement(self);
if (NULL == objectScheduleMap)
{
return false;
}

return xObjectScheduleMap->ExistElement(strScheduleName);
return objectScheduleMap->ExistElement(strScheduleName);
}

NF_SHARE_PTR<NFScheduleElement> NFScheduleModule::GetSchedule(const NFGUID self, const std::string & strScheduleName)
Expand All @@ -361,4 +199,4 @@ int NFScheduleModule::OnClassCommonEvent(const NFGUID & self, const std::string
}

return 0;
}
}
Loading

0 comments on commit b80e7fa

Please sign in to comment.