bool Event::trigger_locked(T cur,F Release)
{
if( !flag )
{
TaskBase *task=list.get();
if( task )
{
event(task,EventEvent_task::ToTask);
Log("#; is triggered by #; to #;",name,GetTaskName(cur),task->getName());
Release(task,Release_Ok);
}
else
{
flag=true;
event(EventEvent::Trigger);
Log("#; is triggered by #;",name,GetTaskName(cur));
}
return true;
}
return false;
}
///Do a modular part of the task. For example, if the task is to load the entire file, load one BlockFile.
///Relies on DoSomeInternal(), which is the subclasses must implement.
///@param amountWork the percent amount of the total job to do. 1.0 represents the entire job. the default of 0.0
/// will do the smallest unit of work possible
void ODTask::DoSome(float amountWork)
{
mBlockUntilTerminateMutex.Lock();
printf("%s %i subtask starting on new thread with priority\n", GetTaskName(),GetTaskNumber());
mDoingTask=mTaskStarted=true;
float workUntil = amountWork+PercentComplete();
if(workUntil<PercentComplete())
workUntil = PercentComplete();
//check periodically to see if we should exit.
mTerminateMutex.Lock();
if(mTerminate)
{
mBlockUntilTerminateMutex.Unlock();
mTerminateMutex.Unlock();
return;
}
mTerminateMutex.Unlock();
Update();
//Do Some of the task.
mTerminateMutex.Lock();
while(PercentComplete() < workUntil && PercentComplete() < 1.0 && !mTerminate)
{
wxThread::This()->Yield();
//release within the loop so we can cut the number of iterations short
mTerminateMutex.Unlock();
//TODO: check to see if ondemand has been called
if(false)
ODUpdate();
DoSomeInternal();
//But add the mutex lock back before we check the value again.
mTerminateMutex.Lock();
}
mTerminateMutex.Unlock();
mDoingTask=false;
mTerminateMutex.Lock();
//if it is not done, put it back onto the ODManager queue.
if(!IsComplete() && !mTerminate)
{
ODManager::Instance()->AddTask(this);
printf("%s %i is %f done\n", GetTaskName(),GetTaskNumber(),PercentComplete());
}
else
{
printf("%s %i complete\n", GetTaskName(),GetTaskNumber());
}
mTerminateMutex.Unlock();
mBlockUntilTerminateMutex.Unlock();
}
FText UAblSetCollisionChannelResponseTask::GetDescriptiveTaskName() const
{
const FText FormatText = LOCTEXT("AblSetCollisionChannelResponseTaskFormat", "{0}: {1}->{2}");
FString CollisionChannelName = m_SetAllChannelsToResponse ? TEXT("All") : FAbleLogHelper::GetCollisionChannelEnumAsString(m_Channel);
FString ResponseName = FAbleLogHelper::GetCollisionResponseEnumAsString(m_Response);
return FText::FormatOrdered(FormatText, GetTaskName(), FText::FromString(CollisionChannelName), FText::FromString(ResponseName));
}
INLINE STRPTR Executable(struct Task *task)
{
STRPTR ename = NULL;
GLOBAL struct DosLibrary * DOSBase;
// ENTER();
DBG_ASSERT(G->mTask == FindTask(NULL));
DBG_ASSERT(IsTaskRunning(task)==TRUE);
if((ename = Malloc(1025)))
{
struct Process * pr = ((struct Process *)task);
STRPTR tn = GetTaskName(task, NULL);
if(task->tc_Node.ln_Type != NT_TASK && pr->pr_HomeDir)
{
NameFromLock( pr->pr_HomeDir, ename, 1024);
}
if(tn != NULL)
{
AddPart( ename, FilePart(tn), 1024);
Free(tn);
}
}
// DBG_STRING(ename);
// RETURN(ename);
return(ename);
}
//--------------------------------------------------------------------------//
// CRUTask::Dump()
//
// Called by CRUDependenceGraph::Dump()
//
// Prints the "standard" task's dump
//--------------------------------------------------------------------------//
// LCOV_EXCL_START :dpm
void CRUTask::Dump(CDSString &to)
{
char idStr[10];
sprintf(idStr,"%d",GetId());
to += "\nTASK ID = " + CDSString(idStr);
to += "\n\t" + GetTaskName() + "\n";
if (0 == pSuccList_->GetCount())
{
to += "\tNo tasks depend on me.\n";
}
else
{
to += "\tTasks that depend on me:\n";
DSListPosition pos = pSuccList_->GetHeadPosition();
while (NULL != pos)
{
CRUTask *pTask = pSuccList_->GetNext(pos);
sprintf(idStr,"%d",pTask->GetId());
to += "\t\tTask id = " + CDSString(idStr) + "\n";
}
}
}
void AntiSem::add_locked(T cur,ulen dcount)
{
event(AntiSemEvent::Add);
Log("#; (#;) += #; by #;",name,count,dcount,GetTaskName(cur));
add_count(dcount);
}
void AntiSem::wait()
{
Dev::IntLock lock;
if( count<=level )
{
event(Task::GetCurrent(),AntiSemEvent_task::Pass);
Log("#; don't block #;",name,GetTaskName(CurTaskContext));
}
else
{
event(Task::GetCurrent(),AntiSemEvent_task::Wait);
Log("#; block #;",name,GetTaskName(CurTaskContext));
Task::Internal::BlockTask_task(list);
}
}
bool AntiSem::wait_locked(MSec timeout)
{
if( count<=level )
{
event(Task::GetCurrent(),AntiSemEvent_task::Pass);
Log("#; don't block #;",name,GetTaskName(CurTaskContext));
return true;
}
else
{
event(Task::GetCurrent(),AntiSemEvent_task::Wait);
Log("#; block #; timed = #;",name,GetTaskName(CurTaskContext),timeout);
return Task::Internal::BlockTask_task(list,timeout)==Release_Ok;
}
}
FText UAblSetShaderParameterTask::GetDescriptiveTaskName() const
{
const FText FormatText = LOCTEXT("AblPlaySetShaderParameterTaskFormat", "{0}: {1}");
FString ParameterName = TEXT("<none>");
if (!m_ParameterName.IsNone())
{
ParameterName = m_ParameterName.ToString();
}
return FText::FormatOrdered(FormatText, GetTaskName(), FText::FromString(ParameterName));
}
void MultiSemBase::give_locked(T cur,F Release,ulen index)
{
if( TaskBase *task=list.get() )
{
base=nextIndex(base);
event(task,MultiSemEvent_task::ToTask,index);
Log("#;:#; is given by #; to #;",name,index,GetTaskName(cur),task->getName());
Release(task,Release_Custom+index);
}
else
{
event(MultiSemEvent::Give,index);
Log("#;:#; is given by #;",name,index,GetTaskName(cur));
putIndex(index);
}
}
ulen MultiSemBase::take()
{
Dev::IntLock lock;
if( ulen index=try_take_locked() ) return index;
event(Task::GetCurrent(),MultiSemEvent_task::Block);
Log("#; is blocked on #;",GetTaskName(CurTaskContext),name);
return Task::Internal::BlockTask_task(list)-Release_Custom;
}
bool Event::wait_locked(MSec timeout)
{
if( flag )
{
flag=false;
event(Task::GetCurrent(),EventEvent_task::Consume);
Log("#; is consumed by #;",name,GetTaskName(CurTaskContext));
return true;
}
else
{
event(Task::GetCurrent(),EventEvent_task::Block);
Log("#; is blocked on #; timed = #;",GetTaskName(CurTaskContext),name,timeout);
return Task::Internal::BlockTask_task(list,timeout)==Release_Ok;
}
}
ulen MultiSemBase::take_locked(MSec timeout)
{
if( ulen index=try_take_locked() ) return index;
event(Task::GetCurrent(),MultiSemEvent_task::Block);
Log("#; is blocked on #; timed = #;",GetTaskName(CurTaskContext),name,timeout);
if( ReleaseCode code=Task::Internal::BlockTask_task(list,timeout) ) return code-Release_Custom;
return 0;
}
void Event::wait()
{
Dev::IntLock lock;
if( flag )
{
flag=false;
event(Task::GetCurrent(),EventEvent_task::Consume);
Log("#; is consumed by #;",name,GetTaskName(CurTaskContext));
}
else
{
event(Task::GetCurrent(),EventEvent_task::Block);
Log("#; is blocked on #;",GetTaskName(CurTaskContext),name);
Task::Internal::BlockTask_task(list);
}
}
//--------------------------------------------------------------------------//
// LCOV_EXCL_START :dpm
void CRUTask::DumpGraphNode(CDSString &to)
{
char fromChr[10];
sprintf(fromChr,"%d",GetId());
CDSString nodeId(fromChr);
to += "\t\t" + nodeId;
to += " [style=filled,";
to += "label= \"" + nodeId + "." + GetTaskName() + "\"";
to += ",color=";
switch (GetType())
{
case REFRESH:
{
to += "red";
break;
}
case TABLE_SYNC:
{
to += "lightgrey";
break;
}
case DUP_ELIM:
{
to += "violet";
break;
}
case LOG_CLEANUP:
{
to += "yellowgreen";
break;
}
case RC_RELEASE:
{
to += "pink";
break;
}
case EMP_CHECK:
{
to += "gold";
break;
}
case LOCK_EQUIV_SET:
{
to += "yellow";
break;
}
default:
RUASSERT(FALSE);
}
to += "];\n";
}
// report on times
void MPMTask::WriteProfileResults(int nsteps,double timePerStep,double eTimePerStep)
{
cout << "Task #" << taskNumber << ": "<< GetTaskName();
#ifdef _OPENMP
// CPU time per step (not allows good number)
double taskPerStep = 1000.*totalTaskTime/(double)nsteps;
cout << ": " << taskPerStep << " CPU_ms/step (" << 100.*taskPerStep/timePerStep << "%), ";
#endif
// elapsed time per step
double eTaskPerStep = 1000.*totalTaskETime/(double)nsteps;
cout << eTaskPerStep << " ms/step (" << 100.*eTaskPerStep/eTimePerStep << "%, "
<< totalTaskTime/totalTaskETime << ")";
cout << endl;
}
void AntiSem::sub_locked(T cur,F Release,ulen dcount)
{
Log("#; (#;) -= #; by #;",name,count,dcount,GetTaskName(cur));
sub_count(dcount);
if( count<=level )
{
event(AntiSemEvent::Release);
Release(list,Release_Ok,name);
}
else
{
event(AntiSemEvent::Sub);
}
}
bool AntiSem::try_wait()
{
Dev::IntLock lock;
if( count<=level )
{
event(Task::GetCurrent(),AntiSemEvent_task::Pass);
Log("#; don't block #;",name,GetTaskName(CurTaskContext));
return true;
}
else
{
return false;
}
}
bool Event::try_wait()
{
Dev::IntLock lock;
if( flag )
{
flag=false;
event(Task::GetCurrent(),EventEvent_task::Consume);
Log("#; is consumed by #;",name,GetTaskName(CurTaskContext));
return true;
}
else
{
return false;
}
}
const char * CIVTask::GetName()
{
#ifdef EXT_LOG
CLogFile::Printf(__FUNCSIG__);
#endif
// Get the task type
int iType = GetType();
// Get the task name
const char * szName = GetTaskName(iType);
// Undocumented task detection
if(String(szName) == "Unknown Task" && taskMap[iType] == false)
{
CLogFile::Printf("Got task with unknown name (VFTable: 0x%x, Type: %d (0x%x))", m_pTask->m_VFTable, iType, iType);
taskMap[iType] = true;
}
return szName;
}
ulen MultiSemBase::try_take_locked()
{
ulen index=base;
for(ulen cnt=counts.len; cnt ;cnt--,index=nextIndex(index))
{
if( counts[index] )
{
counts[index]--;
base=nextIndex(base);
index++;
event(Task::GetCurrent(),MultiSemEvent_task::Take,index);
Log("#;:#; is taken by #;",name,index,GetTaskName(CurTaskContext));
return index;
}
}
return 0;
}
// for debugging
void MPMTask::WriteLogFile(void)
{ // task number
char logLine[200];
sprintf(logLine," Task #%d: %s",taskNumber,GetTaskName());
archiver->WriteLogFile(logLine,NULL);
}
const char * CIVTask::GetName()
{
return GetTaskName(GetType());
}
FText UAblRayCastQueryTask::GetDescriptiveTaskName() const
{
const FText FormatText = LOCTEXT("AblRayCastQueryFormat", "{0}: {1}");
FString ShapeDescription = FString::Printf(TEXT("%.1fm"), m_Length * 0.01f);
return FText::FormatOrdered(FormatText, GetTaskName(), FText::FromString(ShapeDescription));
}
