ODManager Class Reference

A singleton that manages currently running Tasks on an arbitrary number of threads. More...

#include <ODManager.h>

Collaboration diagram for ODManager:

Classes
class	ODManagerHelperThread
class	Pauser

Public Member Functions
void	DemandTrackUpdate (WaveTrack *track, double seconds)
	changes the tasks associated with this Waveform to process the task from a different point in the track More...
void	DecrementCurrentThreads ()
	Reduces the count of current threads running. Meant to be called when ODTaskThreads end in their own threads. Thread-safe. More...
void	AddNewTask (std::unique_ptr< ODTask > &&mtask, bool lockMutex=true)
	Adds a wavetrack, creates a queue member. More...
void	SignalTaskQueueLoop ()
	Wakes the queue loop up by signalling its condition variable. More...
void	MakeWaveTrackIndependent (const std::shared_ptr< WaveTrack > &track)
	if it shares a queue/task, creates a NEW queue/task for the track, and removes it from any previously existing tasks. More...
bool	MakeWaveTrackDependent (const std::shared_ptr< WaveTrack > &dependentTrack, WaveTrack *masterTrack)
void	ReplaceWaveTrack (Track *oldTrack, const std::shared_ptr< Track > &newTrack)
	replace the wavetrack whose wavecache the gui watches for updates More...
void	AddTask (ODTask *task)
	Adds a task to the running queue. Thread-safe. More...
void	RemoveTaskIfInQueue (ODTask *task)
	removes a task from the active task queue More...
void	FillTipForWaveTrack (const WaveTrack *t, TranslatableString &tip)
	fills in the status bar message for a given track More...
float	GetOverallPercentComplete ()
	Gets the total percent complete for all tasks combined. More...
int	GetTotalNumTasks ()
	Get Total Number of Tasks. More...

Static Public Member Functions
static ODManager *	InstanceFirstTime ()
	Gets the singleton instance. More...
static ODManager *	InstanceNormal ()
	Gets the singleton instance. More...
static void	Quit ()
	Kills the ODMananger Thread. More...
static void	MarkLoadedODFlag ()
	sets a flag that is set if we have loaded some OD blockfiles from PCM. More...
static void	UnmarkLoadedODFlag ()
	resets a flag that is set if we have loaded some OD blockfiles from PCM. More...
static bool	HasLoadedODFlag ()
	returns a flag that is set if we have loaded some OD blockfiles from PCM. More...
static bool	IsInstanceCreated ()
	returns whether or not the singleton instance was created yet More...

Static Public Attributes
static ODManager *(*	Instance )() = &(ODManager::InstanceFirstTime)

Protected Member Functions
	ODManager ()
	~ODManager ()
void	Init ()
	Launches a thread for the manager and starts accepting Tasks. More...
void	Start ()
	Start the main loop for the manager. More...
void	UpdateQueues ()
	Remove references in our array to Tasks that have been completed/Schedule NEW ones. More...

Protected Attributes
std::vector< std::unique_ptr< ODWaveTrackTaskQueue > >	mQueues
ODLock	mQueuesMutex
std::vector< ODTask * >	mTasks
ODLock	mTasksMutex
volatile bool	mPause
ODLock	mPauseLock
volatile int	mNeedsDraw
volatile int	mCurrentThreads
	Number of threads currently running. Accessed thru multiple threads. More...
ODLock	mCurrentThreadsMutex
int	mMaxThreads
	Maximum number of threads allowed out. More...
volatile bool	mTerminate
ODLock	mTerminateMutex
volatile bool	mTerminated
ODLock	mTerminatedMutex
ODLock	mQueueNotEmptyCondLock
std::unique_ptr< ODCondition >	mQueueNotEmptyCond

Static Protected Attributes
static std::unique_ptr< ODManager >	pMan {}

Detailed Description

A singleton that manages currently running Tasks on an arbitrary number of threads.

Definition at line 45 of file ODManager.h.

Constructor & Destructor Documentation

ODManager()

ODManager::ODManager ( )

protected

Definition at line 155 of file ODManager.cpp.

{
   mTerminate = false;
   mTerminated = false;
   mPause = gPause;
 
   //must set up the queue condition
   mQueueNotEmptyCond = std::make_unique<ODCondition>(&mQueueNotEmptyCondLock);
}

References gPause, mPause, mQueueNotEmptyCond, mQueueNotEmptyCondLock, mTerminate, and mTerminated.

Referenced by InstanceFirstTime().

Here is the caller graph for this function:

~ODManager()

ODManager::~ODManager ( )

protected

Definition at line 166 of file ODManager.cpp.

{
   mTerminateMutex.Lock();
   mTerminate = true;
   mTerminateMutex.Unlock();
 
   //This while loop waits for ODTasks to finish and the DELETE removes all tasks from the Queue.
   //This function is called from the main audacity event thread, so there should not be more requests for pMan
   mTerminatedMutex.Lock();
   while (!mTerminated)
   {
      mTerminatedMutex.Unlock();
      wxThread::Sleep(200);
 
      //signal the queue not empty condition since the ODMan thread will wait on the queue condition
      mQueueNotEmptyCondLock.Lock();
      mQueueNotEmptyCond->Signal();
      mQueueNotEmptyCondLock.Unlock();
 
      mTerminatedMutex.Lock();
   }
   mTerminatedMutex.Unlock();
 
   //get rid of all the queues.  The queues get rid of the tasks, so we don't worry about them.
   //nothing else should be running on OD related threads at this point, so we don't lock.
   mQueues.clear();
}

References mQueueNotEmptyCond, mQueueNotEmptyCondLock, mQueues, mTerminate, mTerminated, mTerminatedMutex, and mTerminateMutex.

Member Function Documentation

AddNewTask()

void ODManager::AddNewTask	(	std::unique_ptr< ODTask > &&	mtask,
		bool	lockMutex = true
	)

Adds a wavetrack, creates a queue member.

Adds a NEW task to the queue. Creates a queue if the tracks associated with the task is not in the list

Parameters

task	the task to add
lockMutex	locks the mutexes if true (default). This function is used within other ODManager calls, which many need to set this to false.

Definition at line 245 of file ODManager.cpp.

{
   auto task = mtask.get();
   ODWaveTrackTaskQueue* queue = NULL;
 
   if(lockMutex)
      mQueuesMutex.Lock();
   for(unsigned int i=0;i<mQueues.size();i++)
   {
      //search for a task containing the lead track.  wavetrack removal is threadsafe and bound to the mQueuesMutex
      //note that GetWaveTrack is not threadsafe, but we are assuming task is not running on a different thread yet.
      if(mQueues[i]->ContainsWaveTrack(task->GetWaveTrack(0).get()))
         queue = mQueues[i].get();
   }
 
   if(queue)
   {
      //Add it to the existing queue but keep the lock since this reference can be deleted.
      queue->AddTask(std::move(mtask));
      if(lockMutex)
         mQueuesMutex.Unlock();
   }
   else
   {
      //Make a NEW one, add it to the local track queue, and to the immediate running task list,
      //since this task is definitely at the head
      auto newqueue = std::make_unique<ODWaveTrackTaskQueue>();
      newqueue->AddTask(std::move(mtask));
      mQueues.push_back(std::move(newqueue));
      if(lockMutex)
         mQueuesMutex.Unlock();
 
      AddTask(task);
   }
}

References AddTask(), ODWaveTrackTaskQueue::AddTask(), ODTask::GetWaveTrack(), mQueues, and mQueuesMutex.

Referenced by ODWaveTrackTaskQueue::MakeWaveTrackIndependent().

Here is the call graph for this function:

Here is the caller graph for this function:

AddTask()

void ODManager::AddTask

(

ODTask *

task

)

Adds a task to the running queue. Thread-safe.

Adds a task to running queue. Thread-safe.

Definition at line 195 of file ODManager.cpp.

{
   mTasksMutex.Lock();
   mTasks.push_back(task);
   mTasksMutex.Unlock();
   //signal the queue not empty condition.
   bool paused;
 
   mPauseLock.Lock();
   paused=mPause;
   mPauseLock.Unlock();
 
   //don't signal if we are paused since if we wake up the loop it will start processing other tasks while paused
   if(!paused)
      mQueueNotEmptyCond->Signal();
}

References mPause, mPauseLock, mQueueNotEmptyCond, mTasks, and mTasksMutex.

Referenced by AddNewTask(), ODTask::DoSome(), and UpdateQueues().

Here is the caller graph for this function:

DecrementCurrentThreads()

void ODManager::DecrementCurrentThreads

(

)

Reduces the count of current threads running. Meant to be called when ODTaskThreads end in their own threads. Thread-safe.

Definition at line 334 of file ODManager.cpp.

{
   mCurrentThreadsMutex.Lock();
   mCurrentThreads--;
   mCurrentThreadsMutex.Unlock();
}

References mCurrentThreads, and mCurrentThreadsMutex.

Referenced by ODTaskThread::Entry().

Here is the caller graph for this function:

DemandTrackUpdate()

void ODManager::DemandTrackUpdate	(	WaveTrack *	track,
		double	seconds
	)

changes the tasks associated with this Waveform to process the task from a different point in the track

changes the tasks associated with this Waveform to process the task from a different point in the track

Parameters

track	the track to update
seconds	the point in the track from which the tasks associated with track should begin processing from.

Definition at line 554 of file ODManager.cpp.

{
   mQueuesMutex.Lock();
   for(unsigned int i=0;i<mQueues.size();i++)
   {
      mQueues[i]->DemandTrackUpdate(track,seconds);
   }
   mQueuesMutex.Unlock();
}

References mQueues, and mQueuesMutex.

FillTipForWaveTrack()

void ODManager::FillTipForWaveTrack	(	const WaveTrack *	t,
		TranslatableString &	tip
	)

fills in the status bar message for a given track

Definition at line 618 of file ODManager.cpp.

{
   mQueuesMutex.Lock();
   for(unsigned int i=0;i<mQueues.size();i++)
   {
      mQueues[i]->FillTipForWaveTrack(t, tip);
   }
   mQueuesMutex.Unlock();
}

References mQueues, and mQueuesMutex.

GetOverallPercentComplete()

float ODManager::GetOverallPercentComplete

(

)

Gets the total percent complete for all tasks combined.

Definition at line 629 of file ODManager.cpp.

{
   float total=0.0;
   mQueuesMutex.Lock();
   for(unsigned int i=0;i<mQueues.size();i++)
   {
      total+=mQueues[i]->GetFrontTask()->PercentComplete();
   }
   mQueuesMutex.Unlock();
 
   //avoid div by zero and be thread smart.
   int totalTasks = GetTotalNumTasks();
   return (float) total/(totalTasks>0?totalTasks:1);
}

References GetTotalNumTasks(), mQueues, and mQueuesMutex.

Here is the call graph for this function:

GetTotalNumTasks()

int ODManager::GetTotalNumTasks

(

)

Get Total Number of Tasks.

Definition at line 645 of file ODManager.cpp.

{
   int ret=0;
   mQueuesMutex.Lock();
   for(unsigned int i=0;i<mQueues.size();i++)
   {
      ret+=mQueues[i]->GetNumTasks();
   }
   mQueuesMutex.Unlock();
   return ret;
}

References mQueues, and mQueuesMutex.

Referenced by GetOverallPercentComplete().

Here is the caller graph for this function:

HasLoadedODFlag()

bool ODManager::HasLoadedODFlag ( )

static

returns a flag that is set if we have loaded some OD blockfiles from PCM.

Definition at line 612 of file ODManager.cpp.

{
   return sHasLoadedOD;
}

References sHasLoadedOD.

Init()

void ODManager::Init ( )

protected

Launches a thread for the manager and starts accepting Tasks.

Definition at line 315 of file ODManager.cpp.

{
   mCurrentThreads = 0;
   mMaxThreads = 5;
 
   //   wxLogDebug(wxT("Initializing ODManager...Creating manager thread"));
   // This is a detached thread, so it deletes itself when it finishes
   // ... except on Mac where we don't use wxThread for reasons unexplained
   ODManagerHelperThread* startThread = safenew ODManagerHelperThread;
 
//   startThread->SetPriority(0);//default of 50.
   startThread->Create();
//   wxPrintf("starting thread from init\n");
   startThread->Run();
 
//   wxPrintf("started thread from init\n");
   //destruction of thread is taken care of by thread library
}

References mCurrentThreads, mMaxThreads, and safenew.

InstanceFirstTime()

ODManager * ODManager::InstanceFirstTime ( )

static

Gets the singleton instance.

Definition at line 282 of file ODManager.cpp.

{
   gODInitedMutex.Lock();
   if(!pMan)
   {
      pMan.reset(safenew ODManager());
      pMan->Init();
      gManagerCreated = true;
   }
   gODInitedMutex.Unlock();
 
   //change the accessor function to use the quicker method.
   Instance = &(ODManager::InstanceNormal);
 
   return pMan.get();
}

References gManagerCreated, gODInitedMutex, Instance, InstanceNormal(), ODManager(), pMan, and safenew.

Here is the call graph for this function:

InstanceNormal()

ODManager * ODManager::InstanceNormal ( )

static

Gets the singleton instance.

Definition at line 300 of file ODManager.cpp.

{
   return pMan.get();
}

References pMan.

Referenced by InstanceFirstTime().

Here is the caller graph for this function:

IsInstanceCreated()

bool ODManager::IsInstanceCreated ( )

static

returns whether or not the singleton instance was created yet

Definition at line 305 of file ODManager.cpp.

{
   bool ret;
   gODInitedMutex.Lock();
   ret= gManagerCreated;
   gODInitedMutex.Unlock();
   return ret;
}

References gManagerCreated, and gODInitedMutex.

Referenced by ODManager::Pauser::Pause(), and Quit().

Here is the caller graph for this function:

MakeWaveTrackDependent()

bool ODManager::MakeWaveTrackDependent	(	const std::shared_ptr< WaveTrack > &	dependentTrack,
		WaveTrack *	masterTrack
	)

attach the track in question to another, already existing track's queues and tasks. Remove the task/tracks. Returns success if it was possible.. Some ODTask conditions make it impossible until the Tasks finish.

attach the track in question to another, already existing track's queues and tasks. Remove the task/tracks. only works if both tracks exist. Sets needODUpdate flag for the task. This is complicated and will probably need better design in the future.

Returns

returns success. Some ODTask conditions require that the tasks finish before merging. e.g. they have different effects being processed at the same time.

Definition at line 505 of file ODManager.cpp.

{
   //First, check to see if the task lists are mergeable.  If so, we can simply add this track to the other task and queue,
   //then DELETE this one.
   ODWaveTrackTaskQueue* masterQueue=NULL;
   ODWaveTrackTaskQueue* dependentQueue=NULL;
   unsigned int dependentIndex = 0;
   bool canMerge = false;
 
   mQueuesMutex.Lock();
   for(unsigned int i=0;i<mQueues.size();i++)
   {
      if(mQueues[i]->ContainsWaveTrack(masterTrack))
      {
         masterQueue = mQueues[i].get();
      }
      else if(mQueues[i]->ContainsWaveTrack(dependentTrack.get()))
      {
         dependentQueue = mQueues[i].get();
         dependentIndex = i;
      }
 
   }
   if(masterQueue&&dependentQueue)
      canMerge=masterQueue->CanMergeWith(dependentQueue);
 
   //otherwise we need to let dependentTrack's queue live on.  We'll have to wait till the conflicting tasks are done.
   if(!canMerge)
   {
      mQueuesMutex.Unlock();
      return false;
   }
   //then we add dependentTrack to the masterTrack's queue - this will allow future ODScheduling to affect them together.
   //this sets the NeedODUpdateFlag since we don't want the head task to finish without haven't dealt with the dependent
   masterQueue->MergeWaveTrack(dependentTrack);
 
   //finally remove the dependent track
   mQueues.erase(mQueues.begin()+dependentIndex);
   mQueuesMutex.Unlock();
   return true;
}

References ODWaveTrackTaskQueue::CanMergeWith(), ODWaveTrackTaskQueue::MergeWaveTrack(), mQueues, and mQueuesMutex.

Here is the call graph for this function:

MakeWaveTrackIndependent()

void ODManager::MakeWaveTrackIndependent

(

const std::shared_ptr< WaveTrack > &

track

)

if it shares a queue/task, creates a NEW queue/task for the track, and removes it from any previously existing tasks.

Definition at line 481 of file ODManager.cpp.

{
   ODWaveTrackTaskQueue* owner=NULL;
   mQueuesMutex.Lock();
   for(unsigned int i=0;i<mQueues.size();i++)
   {
      if(mQueues[i]->ContainsWaveTrack(track.get()))
      {
         owner = mQueues[i].get();
         break;
      }
   }
   if(owner)
      owner->MakeWaveTrackIndependent(track);
 
   mQueuesMutex.Unlock();
}

References ODWaveTrackTaskQueue::MakeWaveTrackIndependent(), mQueues, and mQueuesMutex.

Here is the call graph for this function:

MarkLoadedODFlag()

void ODManager::MarkLoadedODFlag ( )

static

sets a flag that is set if we have loaded some OD blockfiles from PCM.

Definition at line 598 of file ODManager.cpp.

{
   sHasLoadedOD = true;
}

References sHasLoadedOD.

Quit()

void ODManager::Quit ( )

static

Kills the ODMananger Thread.

Definition at line 460 of file ODManager.cpp.

{
   if(IsInstanceCreated())
   {
      pMan.reset();
   }
}

References IsInstanceCreated(), and pMan.

Here is the call graph for this function:

RemoveTaskIfInQueue()

void ODManager::RemoveTaskIfInQueue

(

ODTask *

task

)

removes a task from the active task queue

Definition at line 225 of file ODManager.cpp.

{
   mTasksMutex.Lock();
   //linear search okay for now, (probably only 1-5 tasks exist at a time.)
   for(unsigned int i=0;i<mTasks.size();i++)
   {
      if(mTasks[i]==task)
      {
         mTasks.erase(mTasks.begin()+i);
         break;
      }
   }
   mTasksMutex.Unlock();
 
}

References mTasks, and mTasksMutex.

Referenced by ODWaveTrackTaskQueue::~ODWaveTrackTaskQueue().

Here is the caller graph for this function:

ReplaceWaveTrack()

void ODManager::ReplaceWaveTrack	(	Track *	oldTrack,
		const std::shared_ptr< Track > &	newTrack
	)

replace the wavetrack whose wavecache the gui watches for updates

if oldTrack is being watched, replace the wavetrack whose wavecache the gui watches for updates

Definition at line 469 of file ODManager.cpp.

{
   mQueuesMutex.Lock();
   for(unsigned int i=0;i<mQueues.size();i++)
   {
      mQueues[i]->ReplaceWaveTrack( oldTrack, newTrack );
   }
   mQueuesMutex.Unlock();
}

References mQueues, and mQueuesMutex.

SignalTaskQueueLoop()

void ODManager::SignalTaskQueueLoop

(

)

Wakes the queue loop up by signalling its condition variable.

Definition at line 212 of file ODManager.cpp.

{
   bool paused;
 
   mPauseLock.Lock();
   paused=mPause;
   mPauseLock.Unlock();
   //don't signal if we are paused
   if(!paused)
      mQueueNotEmptyCond->Signal();
}

References mPause, mPauseLock, and mQueueNotEmptyCond.

Start()

void ODManager::Start ( )

protected

Start the main loop for the manager.

Main loop for managing threads and tasks.

Definition at line 342 of file ODManager.cpp.

{
   bool tasksInArray;
   bool paused;
   int  numQueues=0;
 
   mNeedsDraw=0;
 
   //wxLog calls not threadsafe.  are printfs?  thread-messy for sure, but safe?
//   wxPrintf("ODManager thread strating \n");
   //TODO: Figure out why this has no effect at all.
   //wxThread::This()->SetPriority(30);
   mTerminateMutex.Lock();
   while(!mTerminate)
   {
      mTerminateMutex.Unlock();
//    wxPrintf("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 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 condition 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 );
         wxTheApp->AddPendingEvent(event);
      }
      mTerminateMutex.Lock();
   }
   mTerminateMutex.Unlock();
 
   mTerminatedMutex.Lock();
   mTerminated=true;
   mTerminatedMutex.Unlock();
 
   //wxLogDebug Not thread safe.
   //wxPrintf("ODManager thread terminating\n");
}

References mCurrentThreads, mCurrentThreadsMutex, mMaxThreads, mNeedsDraw, mPause, mPauseLock, mQueueNotEmptyCond, mQueueNotEmptyCondLock, mQueues, mQueuesMutex, mTasks, mTasksMutex, mTerminate, mTerminated, mTerminatedMutex, mTerminateMutex, safenew, and UpdateQueues().

Referenced by ODManager::ODManagerHelperThread::Entry().

Here is the call graph for this function:

Here is the caller graph for this function:

UnmarkLoadedODFlag()

void ODManager::UnmarkLoadedODFlag ( )

static

resets a flag that is set if we have loaded some OD blockfiles from PCM.

Definition at line 605 of file ODManager.cpp.

{
   sHasLoadedOD = false;
}

References sHasLoadedOD.

UpdateQueues()

void ODManager::UpdateQueues ( )

protected

Remove references in our array to Tasks that have been completed/Schedule NEW ones.

remove tasks from ODWaveTrackTaskQueues that have been done. Schedules NEW ones if they exist Also remove queues that have become empty.

Definition at line 566 of file ODManager.cpp.

{
   mQueuesMutex.Lock();
   for(unsigned int i=0;i<mQueues.size();i++)
   {
      if(mQueues[i]->IsFrontTaskComplete())
      {
         //this should DELETE and remove the front task instance.
         mQueues[i]->RemoveFrontTask();
         //schedule next.
         if(!mQueues[i]->IsEmpty())
         {
            //we need to release the lock on the queue vector before using the task vector's lock or we deadlock
            //so get a temp.
            ODWaveTrackTaskQueue* queue = mQueues[i].get();
 
            AddTask(queue->GetFrontTask());
         }
      }
 
      //if the queue is empty DELETE it.
      if(mQueues[i]->IsEmpty())
      {
         mQueues.erase(mQueues.begin()+i);
         i--;
      }
   }
   mQueuesMutex.Unlock();
}

References AddTask(), ODWaveTrackTaskQueue::GetFrontTask(), mQueues, and mQueuesMutex.

Referenced by Start().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

Instance

pfodman ODManager::Instance = &(ODManager::InstanceFirstTime)

static

Gets the singleton instance - this is a function pointer that points to one of the below two instance calls. Note that it is not a member function pointer since it is a static function. the function pointer swapping is valid as long as the initial calls only happen from the main thread.

Definition at line 51 of file ODManager.h.

Referenced by ODTask::DoSome(), ODManager::ODManagerHelperThread::Entry(), ODTaskThread::Entry(), InstanceFirstTime(), ODWaveTrackTaskQueue::MakeWaveTrackIndependent(), and ODWaveTrackTaskQueue::~ODWaveTrackTaskQueue().

mCurrentThreads

volatile int ODManager::mCurrentThreads

protected

Number of threads currently running. Accessed thru multiple threads.

Definition at line 162 of file ODManager.h.

Referenced by DecrementCurrentThreads(), Init(), and Start().

mCurrentThreadsMutex

ODLock ODManager::mCurrentThreadsMutex

protected

Definition at line 164 of file ODManager.h.

Referenced by DecrementCurrentThreads(), and Start().

mMaxThreads

int ODManager::mMaxThreads

protected

Maximum number of threads allowed out.

Definition at line 167 of file ODManager.h.

Referenced by Init(), and Start().

mNeedsDraw

volatile int ODManager::mNeedsDraw

protected

Definition at line 159 of file ODManager.h.

Referenced by Start().

mPause

volatile bool ODManager::mPause

protected

Definition at line 156 of file ODManager.h.

Referenced by AddTask(), ODManager(), SignalTaskQueueLoop(), and Start().

mPauseLock

ODLock ODManager::mPauseLock

protected

Definition at line 157 of file ODManager.h.

Referenced by AddTask(), SignalTaskQueueLoop(), and Start().

mQueueNotEmptyCond

std::unique_ptr<ODCondition> ODManager::mQueueNotEmptyCond

protected

Definition at line 177 of file ODManager.h.

Referenced by AddTask(), ODManager(), SignalTaskQueueLoop(), Start(), and ~ODManager().

mQueueNotEmptyCondLock

ODLock ODManager::mQueueNotEmptyCondLock

protected

Definition at line 176 of file ODManager.h.

Referenced by ODManager(), Start(), and ~ODManager().

mQueues

std::vector<std::unique_ptr<ODWaveTrackTaskQueue> > ODManager::mQueues

protected

Definition at line 147 of file ODManager.h.

Referenced by AddNewTask(), DemandTrackUpdate(), FillTipForWaveTrack(), GetOverallPercentComplete(), GetTotalNumTasks(), MakeWaveTrackDependent(), MakeWaveTrackIndependent(), ReplaceWaveTrack(), Start(), UpdateQueues(), and ~ODManager().

mQueuesMutex

ODLock ODManager::mQueuesMutex

protected

Definition at line 148 of file ODManager.h.

Referenced by AddNewTask(), DemandTrackUpdate(), FillTipForWaveTrack(), GetOverallPercentComplete(), GetTotalNumTasks(), MakeWaveTrackDependent(), MakeWaveTrackIndependent(), ReplaceWaveTrack(), Start(), and UpdateQueues().

mTasks

std::vector<ODTask*> ODManager::mTasks

protected

Definition at line 151 of file ODManager.h.

Referenced by AddTask(), RemoveTaskIfInQueue(), and Start().

mTasksMutex

ODLock ODManager::mTasksMutex

protected

Definition at line 153 of file ODManager.h.

Referenced by AddTask(), RemoveTaskIfInQueue(), and Start().

mTerminate

volatile bool ODManager::mTerminate

protected

Definition at line 169 of file ODManager.h.

Referenced by ODManager(), Start(), and ~ODManager().

mTerminated

volatile bool ODManager::mTerminated

protected

Definition at line 172 of file ODManager.h.

Referenced by ODManager(), Start(), and ~ODManager().

mTerminatedMutex

ODLock ODManager::mTerminatedMutex

protected

Definition at line 173 of file ODManager.h.

Referenced by Start(), and ~ODManager().

mTerminateMutex

ODLock ODManager::mTerminateMutex

protected

Definition at line 170 of file ODManager.h.

Referenced by Start(), and ~ODManager().

pMan

std::unique_ptr< ODManager > ODManager::pMan {}

staticprotected

Definition at line 144 of file ODManager.h.

Referenced by InstanceFirstTime(), InstanceNormal(), ODManager::Pauser::Pause(), and Quit().

---

The documentation for this class was generated from the following files:

• ODManager.h
• ODManager.cpp