From 0ea5fc66924303d1bf73ba283a383e2aadee02f2 Mon Sep 17 00:00:00 2001 From: neodarz Date: Sat, 11 Aug 2018 20:21:34 +0200 Subject: Initial commit --- docs/doxygen/nel/a02216.html | 1033 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 1033 insertions(+) create mode 100644 docs/doxygen/nel/a02216.html (limited to 'docs/doxygen/nel/a02216.html') diff --git a/docs/doxygen/nel/a02216.html b/docs/doxygen/nel/a02216.html new file mode 100644 index 00000000..cdd5c821 --- /dev/null +++ b/docs/doxygen/nel/a02216.html @@ -0,0 +1,1033 @@ + + +NeL: NLMISC::CTaskManager class Reference + + + +

NLMISC::CTaskManager Class Reference

#include <task_manager.h> +

Inheritance diagram for NLMISC::CTaskManager: +

+ + + + +

Detailed Description

+CTaskManager is a class that manage a list of Task with one Thread

Author:: Alain Saffray
+Nevrax France

Date:: 2000

+ +

+Definition at line 55 of file task_manager.h. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Public Member Functions
void addTask (IRunnable *, float priority=0)
Add a task to TaskManager and its priority.

CTaskManager ()
Constructor.

bool deleteTask (IRunnable *r)
Delete a task, only if task is not running, return true if found and deleted.

void dump (std::vector< std::string > &result)
Dump task list.

virtual void getName (std::string &result) const
uint getNumWaitingTasks ()
Get number of waiting task.

bool isTaskRunning () const
Is there a current task ?

bool isThreadRunning () const
return false if exit() is required. task added with addTask() should test this flag.

void registerTaskPriorityCallback (IChangeTaskPriority *callback)
Register task priority callback.

void run (void)
Manage TaskQueue.

void sleepTask (void)
Sleep a Task.

uint taskListSize (void)
Task list size.

~CTaskManager ()
Destructeur.

Protected Member Functions
void waitCurrentTaskToComplete ()

Protected Attributes
CSynchronized< std::list<
+ std::string > > _DoneTaskQueue
CSynchronized< std::string > _RunningTask
queue of tasks, using list container instead of queue for DeleteTask methode

CSynchronized< std::list<
+ CWaitingTask > > _TaskQueue
IThread * _Thread
thread pointer

volatile bool _ThreadRunning
flag indicate thread loop, if false cause thread exit

Private Member Functions
void changeTaskPriority ()
Register task priority callback.

Private Attributes
IChangeTaskPriority * _ChangePriorityCallback
The callback.

volatile bool _IsTaskRunning
+

Constructor & Destructor Documentation

+ + + + +
+ + + + + + + + + +
NLMISC::CTaskManager::CTaskManager ( )
+
+ + + + + +
+ + + +
+Constructor. +
+ +
+Definition at line 39 of file task_manager.cpp. +
+References _ChangePriorityCallback, _IsTaskRunning, _RunningTask, _Thread, _ThreadRunning, and NLMISC::IThread::start(). +
+
00039 : _RunningTask (""), _TaskQueue (""), _DoneTaskQueue ("") +00040 { +00041 _IsTaskRunning = false; +00042 _ThreadRunning = true; +00043 CSynchronized<string>::CAccessor currentTask(&_RunningTask); +00044 currentTask.value () = ""; +00045 _Thread = IThread::create(this); +00046 _Thread->start(); +00047 _ChangePriorityCallback = NULL; +00048 } +

+

+ + + + +
+ + + + + + + + + +
NLMISC::CTaskManager::~CTaskManager ( )
+
+ + + + + +
+ + + +
+Destructeur. +
+ +
+Definition at line 53 of file task_manager.cpp. +
+References _ThreadRunning, and NLMISC::nlSleep(). +
+
00054 { +00055 _ThreadRunning = false; +00056 while(!_ThreadRunning) +00057 nlSleep(10); +00058 } +

+

Member Function Documentation

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
void NLMISC::CTaskManager::addTask ( IRunnable * ,
float priority = 0
)
+
+ + + + + +
+ + + +
+Add a task to TaskManager and its priority. +
+ +
+Definition at line 126 of file task_manager.cpp. +
+References _TaskQueue, and r. +
+Referenced by NLMISC::CAsyncFileManager::addLoadTask(), NL3D::CZoneManager::checkZonesAround(), NLMISC::CAsyncFileManager::loadFile(), NLMISC::CAsyncFileManager::loadFiles(), and NLMISC::CAsyncFileManager::signal(). +
+
00127 { +00128 CSynchronized<std::list<CWaitingTask> >::CAccessor acces(&_TaskQueue); +00129 acces.value().push_back(CWaitingTask(r, priority)); +00130 } +

+

+ + + + +
+ + + + + + + + + +
void NLMISC::CTaskManager::changeTaskPriority ( ) [private]
+
+ + + + + +
+ + + +
+Register task priority callback. +
+ +
+Definition at line 216 of file task_manager.cpp. +
+References _ChangePriorityCallback, _TaskQueue, and NLMISC::CTaskManager::IChangeTaskPriority::getTaskPriority(). +
+Referenced by run(). +
+
00217 { +00218 if (_ChangePriorityCallback) +00219 { +00220 CSynchronized<list<CWaitingTask> >::CAccessor acces(&_TaskQueue); +00221 list<CWaitingTask> &taskList = acces.value(); +00222 +00223 list<CWaitingTask>::iterator ite = taskList.begin(); +00224 while(ite != taskList.end()) +00225 { +00226 // Get the new priority +00227 ite->Priority = _ChangePriorityCallback->getTaskPriority(*(ite->Task)); +00228 +00229 // Next task +00230 ite++; +00231 } +00232 } +00233 } +

+

+ + + + +
+ + + + + + + + + + +
bool NLMISC::CTaskManager::deleteTask ( IRunnable * r )
+
+ + + + + +
+ + + +
+Delete a task, only if task is not running, return true if found and deleted. +
+ +
+Definition at line 133 of file task_manager.cpp. +
+References _TaskQueue, and r. +
+
00134 { +00135 CSynchronized<list<CWaitingTask> >::CAccessor acces(&_TaskQueue); +00136 for(list<CWaitingTask>::iterator it = acces.value().begin(); it != acces.value().end(); it++) +00137 { +00138 if(it->Task == r) +00139 { +00140 acces.value().erase(it); +00141 return true; +00142 } +00143 } +00144 return false; +00145 } +

+

+ + + + +
+ + + + + + + + + + +
void NLMISC::CTaskManager::dump ( std::vector< std::string > & result )
+
+ + + + + +
+ + + +
+Dump task list. +
+ +
+Definition at line 163 of file task_manager.cpp. +
+References _DoneTaskQueue, _RunningTask, _TaskQueue, and NLMISC::toString(). +
+
00164 { +00165 CSynchronized<string>::CAccessor accesCurrent(&_RunningTask); +00166 CSynchronized<list<CWaitingTask> >::CAccessor acces(&_TaskQueue); +00167 CSynchronized<list<string> >::CAccessor accesDone(&_DoneTaskQueue); +00168 +00169 const list<CWaitingTask> &taskList = acces.value(); +00170 const list<string> &taskDone = accesDone.value(); +00171 const string &taskCurrent = accesCurrent.value(); +00172 +00173 // Resize the destination array +00174 result.clear (); +00175 result.reserve (taskList.size () + taskDone.size () + 1); +00176 +00177 // Add the waiting strings +00178 list<string>::const_reverse_iterator iteDone = taskDone.rbegin (); +00179 while (iteDone != taskDone.rend ()) +00180 { +00181 result.push_back ("Done : " + *iteDone); +00182 +00183 // Next task +00184 iteDone++; +00185 } +00186 +00187 // Add the current string +00188 if (!taskCurrent.empty()) +00189 { +00190 result.push_back ("Current : " + taskCurrent); +00191 } +00192 +00193 // Add the waiting strings +00194 list<CWaitingTask>::const_iterator ite = taskList.begin (); +00195 while (ite != taskList.end ()) +00196 { +00197 string name; +00198 ite->Task->getName (name); +00199 result.push_back ("Waiting : " + name + " " + toString(ite->Priority)); +00200 +00201 // Next task +00202 ite++; +00203 } +00204 } +

+

+ + + + +
+ + + + + + + + + + +
virtual void NLMISC::IRunnable::getName ( std::string & result ) const [inline, virtual, inherited]
+
+ + + + + +
+ + + +
+ +
+Reimplemented in NL3D::CAsyncFileManager3D::CMeshLoad, NL3D::CAsyncFileManager3D::CIGLoad, NL3D::CAsyncFileManager3D::CIGLoadUser, NL3D::CAsyncFileManager3D::CTextureLoad, NL3D::CZoneLoadingTask, NLPACS::CGlobalRetriever::CLrLoader, NLMISC::CAsyncFileManager::CFileLoad, NLMISC::CAsyncFileManager::CMultipleFileLoad, and NLMISC::CAsyncFileManager::CSignal. +
+Definition at line 74 of file thread.h. +
+Referenced by run(). +
+
00075 { +00076 result = "NoName"; +00077 } +

+

+ + + + +
+ + + + + + + + + +
uint NLMISC::CTaskManager::getNumWaitingTasks ( )
+
+ + + + + +
+ + + +
+Get number of waiting task. +
+ +
+Definition at line 208 of file task_manager.cpp. +
+References _TaskQueue, and uint. +
+
00209 { +00210 CSynchronized<list<CWaitingTask> >::CAccessor acces(&_TaskQueue); +00211 return acces.value().size(); +00212 } +

+

+ + + + +
+ + + + + + + + + +
bool NLMISC::CTaskManager::isTaskRunning ( ) const [inline]
+
+ + + + + +
+ + + +
+Is there a current task ? +
+ +
+Definition at line 90 of file task_manager.h. +
+References _IsTaskRunning. +
+
00090 {return _IsTaskRunning;} +

+

+ + + + +
+ + + + + + + + + +
bool NLMISC::CTaskManager::isThreadRunning ( ) const [inline]
+
+ + + + + +
+ + + +
+return false if exit() is required. task added with addTask() should test this flag. +
+ +
+Definition at line 81 of file task_manager.h. +
+References _ThreadRunning. +
+
00081 {return _ThreadRunning;} +

+

+ + + + +
+ + + + + + + + + + +
void NLMISC::CTaskManager::registerTaskPriorityCallback ( IChangeTaskPriority * callback )
+
+ + + + + +
+ + + +
+Register task priority callback. +
+ +
+Definition at line 237 of file task_manager.cpp. +
+References _ChangePriorityCallback. +
+
00238 { +00239 _ChangePriorityCallback = callback; +00240 } +

+

+ + + + +
+ + + + + + + + + + +
void NLMISC::CTaskManager::run ( void ) [virtual]
+
+ + + + + +
+ + + +
+Manage TaskQueue. +
+ +
+Implements NLMISC::IRunnable. +
+Definition at line 61 of file task_manager.cpp. +
+References _DoneTaskQueue, _IsTaskRunning, _RunningTask, _TaskQueue, _ThreadRunning, changeTaskPriority(), NLMISC::IRunnable::getName(), NLMISC_DONE_TASK_SIZE, NLMISC::IRunnable::run(), sleepTask(), and NLMISC::toString(). +
+
00062 { +00063 IRunnable *runnableTask; +00064 float priorityTask; +00065 while(_ThreadRunning) +00066 { +00067 { +00068 CSynchronized<list<CWaitingTask> >::CAccessor acces(&_TaskQueue); +00069 if(acces.value().empty()) +00070 { +00071 runnableTask = NULL; +00072 } +00073 else +00074 { +00075 // Update task priorities +00076 changeTaskPriority (); +00077 +00078 // Get the best task +00079 list<CWaitingTask> &taskList = acces.value(); +00080 list<CWaitingTask>::iterator ite = taskList.begin(); +00081 list<CWaitingTask>::iterator bestIte = ite; +00082 while (ite != taskList.end()) +00083 { +00084 if (ite->Priority < bestIte->Priority) +00085 bestIte = ite; +00086 +00087 // Next task; +00088 ite++; +00089 } +00090 +00091 _IsTaskRunning = true; +00092 runnableTask = bestIte->Task; +00093 priorityTask = bestIte->Priority; +00094 taskList.erase (bestIte); +00095 } +00096 } +00097 if(runnableTask) +00098 { +00099 { +00100 CSynchronized<string>::CAccessor currentTask(&_RunningTask); +00101 string temp; +00102 runnableTask->getName(temp); +00103 currentTask.value () = temp + " " + toString (priorityTask); +00104 } +00105 runnableTask->run(); +00106 { +00107 CSynchronized<string>::CAccessor currentTask(&_RunningTask); +00108 CSynchronized<list<string> >::CAccessor doneTask(&_DoneTaskQueue); +00109 doneTask.value().push_front (currentTask.value ()); +00110 currentTask.value () = ""; +00111 if (doneTask.value().size () > NLMISC_DONE_TASK_SIZE) +00112 doneTask.value().resize (NLMISC_DONE_TASK_SIZE); +00113 } +00114 +00115 _IsTaskRunning = false; +00116 } +00117 else +00118 { +00119 sleepTask(); +00120 } +00121 } +00122 _ThreadRunning = true; +00123 } +

+

+ + + + +
+ + + + + + + + + + +
void NLMISC::CTaskManager::sleepTask ( void ) [inline]
+
+ + + + + +
+ + + +
+Sleep a Task. +
+ +
+Definition at line 75 of file task_manager.h. +
+References NLMISC::nlSleep(). +
+Referenced by run(), and waitCurrentTaskToComplete(). +
+
00075 { nlSleep(10); } +

+

+ + + + +
+ + + + + + + + + + +
uint NLMISC::CTaskManager::taskListSize ( void )
+
+ + + + + +
+ + + +
+Task list size. +
+ +
+Definition at line 148 of file task_manager.cpp. +
+References _TaskQueue, and uint. +
+
00149 { +00150 CSynchronized<list<CWaitingTask> >::CAccessor acces(&_TaskQueue); +00151 return acces.value().size(); +00152 } +

+

+ + + + +
+ + + + + + + + + +
void NLMISC::CTaskManager::waitCurrentTaskToComplete ( ) [protected]
+
+ + + + + +
+ + + +
+If any, wait the current running task to complete this function MUST be called in a 'accessor to the _TaskQueue' statement because a mutex is required eg: { CSynchronized<list<IRunnable *> >::CAccessor acces(&_TaskQueue); waitCurrentTaskToComplete(); } +
+Definition at line 155 of file task_manager.cpp. +
+References _IsTaskRunning, and sleepTask(). +
+Referenced by NLMISC::CAsyncFileManager::cancelLoadTask(). +
+
00156 { +00157 while (_IsTaskRunning) +00158 sleepTask(); +00159 } +

+

Field Documentation

+ + + + +
+ + +
IChangeTaskPriority* NLMISC::CTaskManager::_ChangePriorityCallback [private] +
+
+ + + + + +
+ + + +
+The callback. +
+ +
+Definition at line 108 of file task_manager.h. +
+Referenced by changeTaskPriority(), CTaskManager(), and registerTaskPriorityCallback().
+

+ + + + +
+ + +
CSynchronized<std::list<std::string> > NLMISC::CTaskManager::_DoneTaskQueue [protected] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 148 of file task_manager.h. +
+Referenced by dump(), and run().
+

+ + + + +
+ + +
volatile bool NLMISC::CTaskManager::_IsTaskRunning [private] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 158 of file task_manager.h. +
+Referenced by CTaskManager(), isTaskRunning(), run(), and waitCurrentTaskToComplete().
+

+ + + + +
+ + +
CSynchronized<std::string> NLMISC::CTaskManager::_RunningTask [protected] +
+
+ + + + + +
+ + + +
+queue of tasks, using list container instead of queue for DeleteTask methode +
+ +
+Definition at line 146 of file task_manager.h. +
+Referenced by CTaskManager(), dump(), and run().
+

+ + + + +
+ + +
CSynchronized<std::list<CWaitingTask> > NLMISC::CTaskManager::_TaskQueue [protected] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 147 of file task_manager.h. +
+Referenced by addTask(), changeTaskPriority(), deleteTask(), dump(), getNumWaitingTasks(), run(), and taskListSize().
+

+ + + + +
+ + +
IThread* NLMISC::CTaskManager::_Thread [protected] +
+
+ + + + + +
+ + + +
+thread pointer +
+ +
+Definition at line 151 of file task_manager.h. +
+Referenced by CTaskManager().
+

+ + + + +
+ + +
volatile bool NLMISC::CTaskManager::_ThreadRunning [protected] +
+
+ + + + + +
+ + + +
+flag indicate thread loop, if false cause thread exit +
+ +
+Definition at line 154 of file task_manager.h. +
+Referenced by CTaskManager(), isThreadRunning(), run(), and ~CTaskManager().
+

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

Generated on Tue Mar 16 13:37:19 2004 for NeL by + +

+1.3.6

+ + -- cgit v1.2.1


Public Member Functions
void	addTask (IRunnable *, float priority=0)
	Add a task to TaskManager and its priority.
	CTaskManager ()
	Constructor.
bool	deleteTask (IRunnable *r)
	Delete a task, only if task is not running, return true if found and deleted.
void	dump (std::vector< std::string > &result)
	Dump task list.
virtual void	getName (std::string &result) const
uint	getNumWaitingTasks ()
	Get number of waiting task.
bool	isTaskRunning () const
	Is there a current task ?
bool	isThreadRunning () const
	return false if exit() is required. task added with addTask() should test this flag.
void	registerTaskPriorityCallback (IChangeTaskPriority *callback)
	Register task priority callback.
void	run (void)
	Manage TaskQueue.
void	sleepTask (void)
	Sleep a Task.
uint	taskListSize (void)
	Task list size.
	~CTaskManager ()
	Destructeur.
Protected Member Functions
void	waitCurrentTaskToComplete ()
Protected Attributes
CSynchronized< std::list< + std::string > >	_DoneTaskQueue
CSynchronized< std::string >	_RunningTask
	queue of tasks, using list container instead of queue for DeleteTask methode
CSynchronized< std::list< + CWaitingTask > >	_TaskQueue
IThread *	_Thread
	thread pointer
volatile bool	_ThreadRunning
	flag indicate thread loop, if false cause thread exit
Private Member Functions
void	changeTaskPriority ()
	Register task priority callback.
Private Attributes
IChangeTaskPriority *	_ChangePriorityCallback
	The callback.
volatile bool	_IsTaskRunning