void ReliabilitySystem::Update(float deltaTime) {
FunctionLock lock(thisLock);
acks.clear();
AdvanceQueueTime(deltaTime);
UpdateQueues();
UpdateStats();
#ifdef NET_UNIT_TEST
Validate();
#endif
}
///Main loop for managing threads and tasks.
void ODManager::Start()
{
ODTask* task;
ODTaskThread* thread;
bool tasksInArray;
//wxLog calls not threadsafe. are printfs? thread-messy for sure, but safe?
printf("ODManager thread strating \n");
//TODO: Figure out why this has no effect at all.
//wxThread::This()->SetPriority(30);
mTerminateMutex.Lock();
while(!mTerminate)
{
mTerminateMutex.Unlock();
//we should look at our WaveTrack queues to see if we can process a new task to the running queue.
UpdateQueues();
//start some threads if necessary
mTasksMutex.Lock();
tasksInArray = mTasks.size()>0;
mTasksMutex.Unlock();
mCurrentThreadsMutex.Lock();
while( tasksInArray&& mCurrentThreads < mMaxThreads)
{
mCurrentThreads++;
mCurrentThreadsMutex.Unlock();
//remove the head
mTasksMutex.Lock();
task = mTasks[0];
//the thread will add it back to the array if the job is not yet done at the end of the thread's run.
mTasks.erase(mTasks.begin());
mTasksMutex.Unlock();
//detach a new thread.
thread = new ODTaskThread(task);
// thread->SetPriority(10);//default is 50.
thread->Create();
thread->Run();
mTasksMutex.Lock();
tasksInArray = mTasks.size()>0;
mTasksMutex.Unlock();
mCurrentThreadsMutex.Lock();
}
mCurrentThreadsMutex.Unlock();
wxThread::Sleep(200);
//wxSleep can't be called from non-main thread.
// ::wxMilliSleep(250);
mTerminateMutex.Lock();
//if there is some ODTask running, then there will be something in the queue. If so then redraw to show progress
mQueuesMutex.Lock();
mNeedsDraw += mQueues.size()>0?1:0;
mQueuesMutex.Unlock();
//
// //TODO:this is a little excessive, in the future only redraw some, and if possible only the Tracks on the trackpanel..
if(mNeedsDraw > 18)
{
mNeedsDraw=0;
wxCommandEvent event( wxEVT_ODTASK_UPDATE );
AudacityProject::AllProjectsDeleteLock();
AudacityProject* proj = GetActiveProject();
if(proj)
proj->AddPendingEvent( event );
AudacityProject::AllProjectsDeleteUnlock();
}
}
mTerminateMutex.Unlock();
//wxLogDebug Not thread safe.
//printf("ODManager thread terminating\n");
}
///Main loop for managing threads and tasks.
void ODManager::Start()
{
bool tasksInArray;
bool paused;
int numQueues=0;
mNeedsDraw=0;
//wxLog calls not threadsafe. are printfs? thread-messy for sure, but safe?
// printf("ODManager thread strating \n");
//TODO: Figure out why this has no effect at all.
//wxThread::This()->SetPriority(30);
mTerminateMutex.Lock();
while(!mTerminate)
{
mTerminateMutex.Unlock();
// printf("ODManager thread running \n");
//we should look at our WaveTrack queues to see if we can process a NEW task to the running queue.
UpdateQueues();
//start some threads if necessary
mTasksMutex.Lock();
tasksInArray = mTasks.size()>0;
mTasksMutex.Unlock();
mPauseLock.Lock();
paused=mPause;
mPauseLock.Unlock();
mCurrentThreadsMutex.Lock();
// keep adding tasks if there is work to do, up to the limit.
while(!paused && tasksInArray && (mCurrentThreads < mMaxThreads))
{
mCurrentThreads++;
mCurrentThreadsMutex.Unlock();
mTasksMutex.Lock();
//detach a NEW thread.
// This is a detached thread, so it deletes itself when it finishes
// ... except on Mac where we we don't use wxThread for reasons unexplained
auto thread = safenew ODTaskThread(mTasks[0]);//task);
//thread->SetPriority(10);//default is 50.
thread->Create();
thread->Run();
mTasks.erase(mTasks.begin());
tasksInArray = mTasks.size()>0;
mTasksMutex.Unlock();
mCurrentThreadsMutex.Lock();
}
mCurrentThreadsMutex.Unlock();
//use a conditon variable to block here instead of a sleep.
// JKC: If there are no tasks ready to run, or we're paused then
// we wait for there to be tasks in the queue.
{
ODLocker locker{ &mQueueNotEmptyCondLock };
if( (!tasksInArray) || paused)
mQueueNotEmptyCond->Wait();
}
//if there is some ODTask running, then there will be something in the queue. If so then redraw to show progress
mQueuesMutex.Lock();
mNeedsDraw += mQueues.size()>0?1:0;
numQueues=mQueues.size();
mQueuesMutex.Unlock();
//redraw the current project only (ODTasks will send a redraw on complete even if the projects are in the background)
//we don't want to redraw at a faster rate when we have more queues because
//this means the CPU is already taxed. This if statement normalizes the rate
if((mNeedsDraw>numQueues) && numQueues)
{
mNeedsDraw=0;
wxCommandEvent event( EVT_ODTASK_UPDATE );
ODLocker locker{ &AudacityProject::AllProjectDeleteMutex() };
AudacityProject* proj = GetActiveProject();
if(proj)
proj->GetEventHandler()->AddPendingEvent(event);
}
mTerminateMutex.Lock();
}
mTerminateMutex.Unlock();
mTerminatedMutex.Lock();
mTerminated=true;
mTerminatedMutex.Unlock();
//wxLogDebug Not thread safe.
//printf("ODManager thread terminating\n");
}