diff --git a/panda/src/event/asyncTask.I b/panda/src/event/asyncTask.I index 70a505c3d0..53bdafe9fe 100644 --- a/panda/src/event/asyncTask.I +++ b/panda/src/event/asyncTask.I @@ -95,25 +95,6 @@ get_delay() const { return _delay; } -//////////////////////////////////////////////////////////////////// -// Function: AsyncTask::get_wake_time -// Access: Published -// Description: If this task has been added to an AsyncTaskManager -// with a delay in effect, this returns the time at -// which the task is expected to awaken. It has no -// meaning if the task has not yet been added to a -// queue, or if there was no delay in effect at the time -// the task was added. -// -// It is only valid to call this if the task's status is -// S_sleeping. -//////////////////////////////////////////////////////////////////// -INLINE double AsyncTask:: -get_wake_time() const { - nassertr(_state == S_sleeping, 0.0); - return _wake_time; -} - //////////////////////////////////////////////////////////////////// // Function: AsyncTask::get_start_time // Access: Published diff --git a/panda/src/event/asyncTask.cxx b/panda/src/event/asyncTask.cxx index bc2c730fab..e5c97805fb 100644 --- a/panda/src/event/asyncTask.cxx +++ b/panda/src/event/asyncTask.cxx @@ -87,6 +87,33 @@ remove() { } } +//////////////////////////////////////////////////////////////////// +// Function: AsyncTask::get_wake_time +// Access: Published +// Description: If this task has been added to an AsyncTaskManager +// with a delay in effect, this returns the time at +// which the task is expected to awaken. It has no +// meaning if the task has not yet been added to a +// queue, or if there was no delay in effect at the time +// the task was added. +// +// If the task's status is not S_sleeping, this returns +// 0.0. +//////////////////////////////////////////////////////////////////// +double AsyncTask:: +get_wake_time() const { + if (_manager != (AsyncTaskManager *)NULL) { + MutexHolder holder(_manager->_lock); + if (_state == S_sleeping) { + return _wake_time; + } + } + + // If it's not on any manager, or it's not sleeping, the wake time + // is 0.0. + return 0.0; +} + //////////////////////////////////////////////////////////////////// // Function: AsyncTask::get_elapsed_time // Access: Published diff --git a/panda/src/event/asyncTask.h b/panda/src/event/asyncTask.h index f39e7e0ef1..4c310e3c6f 100644 --- a/panda/src/event/asyncTask.h +++ b/panda/src/event/asyncTask.h @@ -77,7 +77,7 @@ PUBLISHED: INLINE void clear_delay(); INLINE bool has_delay() const; INLINE double get_delay() const; - INLINE double get_wake_time() const; + double get_wake_time() const; INLINE double get_start_time() const; double get_elapsed_time() const; diff --git a/panda/src/event/asyncTaskChain.I b/panda/src/event/asyncTaskChain.I index a612e3fab2..ca1b2c7350 100644 --- a/panda/src/event/asyncTaskChain.I +++ b/panda/src/event/asyncTaskChain.I @@ -25,3 +25,29 @@ INLINE bool AsyncTaskChain:: is_started() const { return (_state == S_started); } + +//////////////////////////////////////////////////////////////////// +// Function: AsyncTaskChain::do_get_next_wake_time +// Access: Protected +// Description: Returns the time at which the next sleeping thread +// will awaken, or -1 if there are no sleeping threads. +// Assumes the lock is already held. +//////////////////////////////////////////////////////////////////// +INLINE double AsyncTaskChain:: +do_get_next_wake_time() const { + if (!_sleeping.empty()) { + return _sleeping.front()->_wake_time; + } + return -1.0; +} + +//////////////////////////////////////////////////////////////////// +// Function: AsyncTaskChain::get_wake_time +// Access: Protected, Static +// Description: Returns the time at which the indicated thread +// will awaken. Assumes the lock is already held. +//////////////////////////////////////////////////////////////////// +INLINE double AsyncTaskChain:: +get_wake_time(AsyncTask *task) { + return task->_wake_time; +} diff --git a/panda/src/event/asyncTaskChain.cxx b/panda/src/event/asyncTaskChain.cxx index 34f0a7b5db..7be77ecd88 100644 --- a/panda/src/event/asyncTaskChain.cxx +++ b/panda/src/event/asyncTaskChain.cxx @@ -765,7 +765,7 @@ service_one_task(AsyncTaskChain::AsyncTaskChainThread *thread) { if (task_cat.is_spam()) { task_cat.spam() << "Sleeping " << *task << ", wake time at " - << task->get_wake_time() - now << "\n"; + << task->_wake_time - now << "\n"; } _cvar.notify_all(); } @@ -927,12 +927,12 @@ finish_sort_group() { // Check for any sleeping tasks that need to be woken. double now = _manager->_clock->get_frame_time(); - while (!_sleeping.empty() && _sleeping.front()->get_wake_time() <= now) { + while (!_sleeping.empty() && _sleeping.front()->_wake_time <= now) { PT(AsyncTask) task = _sleeping.front(); if (task_cat.is_spam()) { task_cat.spam() << "Waking " << *task << ", wake time at " - << task->get_wake_time() - now << "\n"; + << task->_wake_time - now << "\n"; } pop_heap(_sleeping.begin(), _sleeping.end(), AsyncTaskSortWakeTime()); _sleeping.pop_back(); @@ -948,7 +948,7 @@ finish_sort_group() { } else { task_cat.spam() << "Next sleeper: " << *_sleeping.front() << ", wake time at " - << _sleeping.front()->get_wake_time() - now << "\n"; + << _sleeping.front()->_wake_time - now << "\n"; } } @@ -1281,20 +1281,6 @@ cleanup_pickup_mode() { } } -//////////////////////////////////////////////////////////////////// -// Function: AsyncTaskChain::do_get_next_wake_time -// Access: Protected -// Description: -//////////////////////////////////////////////////////////////////// -double AsyncTaskChain:: -do_get_next_wake_time() const { - if (!_sleeping.empty()) { - PT(AsyncTask) task = _sleeping.front(); - return task->_wake_time; - } - return -1.0; -} - //////////////////////////////////////////////////////////////////// // Function: AsyncTaskChain::do_output // Access: Protected @@ -1519,7 +1505,7 @@ thread_main() { PStatTimer timer(_wait_pcollector); _chain->_cvar.wait(); } else { - double wake_time = _chain->_sleeping.front()->get_wake_time(); + double wake_time = _chain->do_get_next_wake_time(); double now = _chain->_manager->_clock->get_frame_time(); double timeout = max(wake_time - now, 0.0); PStatTimer timer(_wait_pcollector); diff --git a/panda/src/event/asyncTaskChain.h b/panda/src/event/asyncTaskChain.h index 97c17a615a..50d84e0862 100644 --- a/panda/src/event/asyncTaskChain.h +++ b/panda/src/event/asyncTaskChain.h @@ -117,7 +117,8 @@ protected: AsyncTaskCollection do_get_sleeping_tasks() const; void do_poll(); void cleanup_pickup_mode(); - double do_get_next_wake_time() const; + INLINE double do_get_next_wake_time() const; + static INLINE double get_wake_time(AsyncTask *task); void do_output(ostream &out) const; void do_write(ostream &out, int indent_level) const; @@ -136,7 +137,7 @@ protected: class AsyncTaskSortWakeTime { public: bool operator () (AsyncTask *a, AsyncTask *b) const { - return a->get_wake_time() > b->get_wake_time(); + return AsyncTaskChain::get_wake_time(a) > AsyncTaskChain::get_wake_time(b); } }; @@ -209,6 +210,7 @@ private: friend class AsyncTaskChainThread; friend class AsyncTask; friend class AsyncTaskManager; + friend class AsyncTaskSortWakeTime; }; INLINE ostream &operator << (ostream &out, const AsyncTaskChain &chain) { diff --git a/panda/src/event/asyncTaskCollection.cxx b/panda/src/event/asyncTaskCollection.cxx index 03523d07a6..7f03158e71 100644 --- a/panda/src/event/asyncTaskCollection.cxx +++ b/panda/src/event/asyncTaskCollection.cxx @@ -234,6 +234,28 @@ get_task(int index) const { return _tasks[index]; } +//////////////////////////////////////////////////////////////////// +// Function: AsyncTaskCollection::remove_task +// Access: Published +// Description: Removes the nth AsyncTask from the collection. +//////////////////////////////////////////////////////////////////// +void AsyncTaskCollection:: +remove_task(int index) { + // If the pointer to our internal array is shared by any other + // AsyncTaskCollections, we have to copy the array now so we won't + // inadvertently modify any of our brethren AsyncTaskCollection + // objects. + + if (_tasks.get_ref_count() > 1) { + AsyncTasks old_tasks = _tasks; + _tasks = AsyncTasks::empty_array(0); + _tasks.v() = old_tasks.v(); + } + + nassertv(index >= 0 && index < (int)_tasks.size()); + _tasks.erase(_tasks.begin() + index); +} + //////////////////////////////////////////////////////////////////// // Function: AsyncTaskCollection::operator [] // Access: Published diff --git a/panda/src/event/asyncTaskCollection.h b/panda/src/event/asyncTaskCollection.h index c3f08bc7c4..fd9221d265 100644 --- a/panda/src/event/asyncTaskCollection.h +++ b/panda/src/event/asyncTaskCollection.h @@ -46,6 +46,7 @@ PUBLISHED: int get_num_tasks() const; AsyncTask *get_task(int index) const; + void remove_task(int index); AsyncTask *operator [] (int index) const; void output(ostream &out) const; diff --git a/panda/src/event/pythonTask.cxx b/panda/src/event/pythonTask.cxx index dd9b27f3fd..bf35ce4f27 100644 --- a/panda/src/event/pythonTask.cxx +++ b/panda/src/event/pythonTask.cxx @@ -305,9 +305,6 @@ __getattr__(const string &attr_name) const { } else if (attr_name == "name") { return PyString_FromString(get_name().c_str()); } else if (attr_name == "wakeTime") { - if (get_state() != S_sleeping) { - Py_RETURN_NONE; - } return PyFloat_FromDouble(get_wake_time()); } else if (attr_name == "delayTime") { if (!has_delay()) { diff --git a/panda/src/pipeline/conditionVarDebug.cxx b/panda/src/pipeline/conditionVarDebug.cxx index a83e2dd828..158ec60547 100755 --- a/panda/src/pipeline/conditionVarDebug.cxx +++ b/panda/src/pipeline/conditionVarDebug.cxx @@ -74,11 +74,11 @@ void ConditionVarDebug:: wait() { _mutex._global_lock->acquire(); - Thread *this_thread = Thread::get_current_thread(); + Thread *current_thread = Thread::get_current_thread(); if (!_mutex.do_debug_is_locked()) { ostringstream ostr; - ostr << *this_thread << " attempted to wait on " + ostr << *current_thread << " attempted to wait on " << *this << " without holding " << _mutex; nassert_raise(ostr.str()); _mutex._global_lock->release(); @@ -87,25 +87,25 @@ wait() { if (thread_cat->is_spam()) { thread_cat.spam() - << *this_thread << " waiting on " << *this << "\n"; + << *current_thread << " waiting on " << *this << "\n"; } - nassertd(this_thread->_waiting_on_cvar == NULL && - this_thread->_waiting_on_cvar_full == NULL) { + nassertd(current_thread->_waiting_on_cvar == NULL && + current_thread->_waiting_on_cvar_full == NULL) { } - this_thread->_waiting_on_cvar = this; + current_thread->_waiting_on_cvar = this; _mutex.do_release(); _impl.wait(); // temporarily releases _global_lock - _mutex.do_lock(); + _mutex.do_acquire(current_thread); - nassertd(this_thread->_waiting_on_cvar == this) { + nassertd(current_thread->_waiting_on_cvar == this) { } - this_thread->_waiting_on_cvar = NULL; + current_thread->_waiting_on_cvar = NULL; if (thread_cat.is_spam()) { thread_cat.spam() - << *this_thread << " awake on " << *this << "\n"; + << *current_thread << " awake on " << *this << "\n"; } _mutex._global_lock->release(); @@ -115,7 +115,7 @@ wait() { // Function: ConditionVarDebug::wait // Access: Published // Description: Waits on the condition, with a timeout. The function -// will return when the condition variable is signaled, +// will return when the condition variable is notified, // or the timeout occurs. There is no way to directly // tell which happened, and it is possible that neither // in fact happened (spurious wakeups are possible). @@ -126,11 +126,11 @@ void ConditionVarDebug:: wait(double timeout) { _mutex._global_lock->acquire(); - Thread *this_thread = Thread::get_current_thread(); + Thread *current_thread = Thread::get_current_thread(); if (!_mutex.do_debug_is_locked()) { ostringstream ostr; - ostr << *this_thread << " attempted to wait on " + ostr << *current_thread << " attempted to wait on " << *this << " without holding " << _mutex; nassert_raise(ostr.str()); _mutex._global_lock->release(); @@ -139,33 +139,33 @@ wait(double timeout) { if (thread_cat.is_spam()) { thread_cat.spam() - << *this_thread << " waiting on " << *this + << *current_thread << " waiting on " << *this << ", with timeout " << timeout << "\n"; } - nassertd(this_thread->_waiting_on_cvar == NULL && - this_thread->_waiting_on_cvar_full == NULL) { + nassertd(current_thread->_waiting_on_cvar == NULL && + current_thread->_waiting_on_cvar_full == NULL) { } - this_thread->_waiting_on_cvar = this; + current_thread->_waiting_on_cvar = this; _mutex.do_release(); _impl.wait(timeout); // temporarily releases _global_lock - _mutex.do_lock(); + _mutex.do_acquire(current_thread); - nassertd(this_thread->_waiting_on_cvar == this) { + nassertd(current_thread->_waiting_on_cvar == this) { } - this_thread->_waiting_on_cvar = NULL; + current_thread->_waiting_on_cvar = NULL; if (thread_cat.is_spam()) { thread_cat.spam() - << *this_thread << " awake on " << *this << "\n"; + << *current_thread << " awake on " << *this << "\n"; } _mutex._global_lock->release(); } //////////////////////////////////////////////////////////////////// -// Function: ConditionVarDebug::signal +// Function: ConditionVarDebug::notify // Access: Published // Description: Informs one of the other threads who are currently // blocked on wait() that the relevant condition has @@ -179,17 +179,17 @@ wait(double timeout) { // will not release the mutex. // // If no threads are waiting, this is a no-op: the -// signal is lost. +// notify event is lost. //////////////////////////////////////////////////////////////////// void ConditionVarDebug:: notify() { _mutex._global_lock->acquire(); - Thread *this_thread = Thread::get_current_thread(); + Thread *current_thread = Thread::get_current_thread(); if (!_mutex.do_debug_is_locked()) { ostringstream ostr; - ostr << *this_thread << " attempted to signal " + ostr << *current_thread << " attempted to notify " << *this << " without holding " << _mutex; nassert_raise(ostr.str()); _mutex._global_lock->release(); @@ -198,7 +198,7 @@ notify() { if (thread_cat->is_spam()) { thread_cat.spam() - << *this_thread << " signalling " << *this << "\n"; + << *current_thread << " notifying " << *this << "\n"; } _impl.notify(); diff --git a/panda/src/pipeline/conditionVarDirect.I b/panda/src/pipeline/conditionVarDirect.I index cc2d14de27..9634ff6118 100755 --- a/panda/src/pipeline/conditionVarDirect.I +++ b/panda/src/pipeline/conditionVarDirect.I @@ -108,7 +108,7 @@ wait() { // Function: ConditionVarDirect::wait // Access: Published // Description: Waits on the condition, with a timeout. The function -// will return when the condition variable is signaled, +// will return when the condition variable is notified, // or the timeout occurs. There is no way to directly // tell which happened, and it is possible that neither // in fact happened (spurious wakeups are possible). @@ -122,7 +122,7 @@ wait(double timeout) { } //////////////////////////////////////////////////////////////////// -// Function: ConditionVarDirect::signal +// Function: ConditionVarDirect::notify // Access: Public // Description: Informs one of the other threads who are currently // blocked on wait() that the relevant condition has @@ -136,7 +136,7 @@ wait(double timeout) { // will not release the mutex. // // If no threads are waiting, this is a no-op: the -// signal is lost. +// notify event is lost. //////////////////////////////////////////////////////////////////// INLINE void ConditionVarDirect:: notify() { diff --git a/panda/src/pipeline/conditionVarFullDebug.cxx b/panda/src/pipeline/conditionVarFullDebug.cxx index 32fa5e661c..e848b3c0d8 100644 --- a/panda/src/pipeline/conditionVarFullDebug.cxx +++ b/panda/src/pipeline/conditionVarFullDebug.cxx @@ -74,11 +74,11 @@ void ConditionVarFullDebug:: wait() { _mutex._global_lock->acquire(); - Thread *this_thread = Thread::get_current_thread(); + Thread *current_thread = Thread::get_current_thread(); if (!_mutex.do_debug_is_locked()) { ostringstream ostr; - ostr << *this_thread << " attempted to wait on " + ostr << *current_thread << " attempted to wait on " << *this << " without holding " << _mutex; nassert_raise(ostr.str()); _mutex._global_lock->release(); @@ -87,25 +87,25 @@ wait() { if (thread_cat->is_spam()) { thread_cat.spam() - << *this_thread << " waiting on " << *this << "\n"; + << *current_thread << " waiting on " << *this << "\n"; } - nassertd(this_thread->_waiting_on_cvar == NULL && - this_thread->_waiting_on_cvar_full == NULL) { + nassertd(current_thread->_waiting_on_cvar == NULL && + current_thread->_waiting_on_cvar_full == NULL) { } - this_thread->_waiting_on_cvar_full = this; + current_thread->_waiting_on_cvar_full = this; _mutex.do_release(); _impl.wait(); // temporarily releases _global_lock - _mutex.do_lock(); + _mutex.do_acquire(current_thread); - nassertd(this_thread->_waiting_on_cvar_full == this) { + nassertd(current_thread->_waiting_on_cvar_full == this) { } - this_thread->_waiting_on_cvar_full = NULL; + current_thread->_waiting_on_cvar_full = NULL; if (thread_cat.is_spam()) { thread_cat.spam() - << *this_thread << " awake on " << *this << "\n"; + << *current_thread << " awake on " << *this << "\n"; } _mutex._global_lock->release(); @@ -115,7 +115,7 @@ wait() { // Function: ConditionVarFullDebug::wait // Access: Published // Description: Waits on the condition, with a timeout. The function -// will return when the condition variable is signaled, +// will return when the condition variable is notified, // or the timeout occurs. There is no way to directly // tell which happened, and it is possible that neither // in fact happened (spurious wakeups are possible). @@ -126,11 +126,11 @@ void ConditionVarFullDebug:: wait(double timeout) { _mutex._global_lock->acquire(); - Thread *this_thread = Thread::get_current_thread(); + Thread *current_thread = Thread::get_current_thread(); if (!_mutex.do_debug_is_locked()) { ostringstream ostr; - ostr << *this_thread << " attempted to wait on " + ostr << *current_thread << " attempted to wait on " << *this << " without holding " << _mutex; nassert_raise(ostr.str()); _mutex._global_lock->release(); @@ -139,33 +139,33 @@ wait(double timeout) { if (thread_cat.is_spam()) { thread_cat.spam() - << *this_thread << " waiting on " << *this + << *current_thread << " waiting on " << *this << ", with timeout " << timeout << "\n"; } - nassertd(this_thread->_waiting_on_cvar == NULL && - this_thread->_waiting_on_cvar_full == NULL) { + nassertd(current_thread->_waiting_on_cvar == NULL && + current_thread->_waiting_on_cvar_full == NULL) { } - this_thread->_waiting_on_cvar_full = this; + current_thread->_waiting_on_cvar_full = this; _mutex.do_release(); _impl.wait(timeout); // temporarily releases _global_lock - _mutex.do_lock(); + _mutex.do_acquire(current_thread); - nassertd(this_thread->_waiting_on_cvar_full == this) { + nassertd(current_thread->_waiting_on_cvar_full == this) { } - this_thread->_waiting_on_cvar_full = NULL; + current_thread->_waiting_on_cvar_full = NULL; if (thread_cat.is_spam()) { thread_cat.spam() - << *this_thread << " awake on " << *this << "\n"; + << *current_thread << " awake on " << *this << "\n"; } _mutex._global_lock->release(); } //////////////////////////////////////////////////////////////////// -// Function: ConditionVarFullDebug::signal +// Function: ConditionVarFullDebug::notify // Access: Published // Description: Informs one of the other threads who are currently // blocked on wait() that the relevant condition has @@ -179,17 +179,17 @@ wait(double timeout) { // will not release the mutex. // // If no threads are waiting, this is a no-op: the -// signal is lost. +// notify event is lost. //////////////////////////////////////////////////////////////////// void ConditionVarFullDebug:: notify() { _mutex._global_lock->acquire(); - Thread *this_thread = Thread::get_current_thread(); + Thread *current_thread = Thread::get_current_thread(); if (!_mutex.do_debug_is_locked()) { ostringstream ostr; - ostr << *this_thread << " attempted to signal " + ostr << *current_thread << " attempted to notify " << *this << " without holding " << _mutex; nassert_raise(ostr.str()); _mutex._global_lock->release(); @@ -198,7 +198,7 @@ notify() { if (thread_cat->is_spam()) { thread_cat.spam() - << *this_thread << " signalling " << *this << "\n"; + << *current_thread << " notifying " << *this << "\n"; } _impl.notify(); @@ -206,7 +206,7 @@ notify() { } //////////////////////////////////////////////////////////////////// -// Function: ConditionVarFullDebug::signal +// Function: ConditionVarFullDebug::notify // Access: Published // Description: Informs all of the other threads who are currently // blocked on wait() that the relevant condition has @@ -217,17 +217,17 @@ notify() { // will not release the mutex. // // If no threads are waiting, this is a no-op: the -// signal is lost. +// notify event is lost. //////////////////////////////////////////////////////////////////// void ConditionVarFullDebug:: notify_all() { _mutex._global_lock->acquire(); - Thread *this_thread = Thread::get_current_thread(); + Thread *current_thread = Thread::get_current_thread(); if (!_mutex.do_debug_is_locked()) { ostringstream ostr; - ostr << *this_thread << " attempted to signal " + ostr << *current_thread << " attempted to notify " << *this << " without holding " << _mutex; nassert_raise(ostr.str()); _mutex._global_lock->release(); @@ -236,7 +236,7 @@ notify_all() { if (thread_cat->is_spam()) { thread_cat.spam() - << *this_thread << " signalling all " << *this << "\n"; + << *current_thread << " notifying all " << *this << "\n"; } _impl.notify_all(); diff --git a/panda/src/pipeline/conditionVarFullDirect.I b/panda/src/pipeline/conditionVarFullDirect.I index 908e6e8f54..1f05a475a8 100644 --- a/panda/src/pipeline/conditionVarFullDirect.I +++ b/panda/src/pipeline/conditionVarFullDirect.I @@ -108,7 +108,7 @@ wait() { // Function: ConditionVarFullDirect::wait // Access: Published // Description: Waits on the condition, with a timeout. The function -// will return when the condition variable is signaled, +// will return when the condition variable is notified, // or the timeout occurs. There is no way to directly // tell which happened, and it is possible that neither // in fact happened (spurious wakeups are possible). @@ -122,7 +122,7 @@ wait(double timeout) { } //////////////////////////////////////////////////////////////////// -// Function: ConditionVarFullDirect::signal +// Function: ConditionVarFullDirect::notify // Access: Published // Description: Informs one of the other threads who are currently // blocked on wait() that the relevant condition has @@ -136,7 +136,7 @@ wait(double timeout) { // will not release the mutex. // // If no threads are waiting, this is a no-op: the -// signal is lost. +// notify is lost. //////////////////////////////////////////////////////////////////// INLINE void ConditionVarFullDirect:: notify() { @@ -145,7 +145,7 @@ notify() { } //////////////////////////////////////////////////////////////////// -// Function: ConditionVarFullDirect::signal_all +// Function: ConditionVarFullDirect::notify_all // Access: Published // Description: Informs all of the other threads who are currently // blocked on wait() that the relevant condition has @@ -156,7 +156,7 @@ notify() { // will not release the mutex. // // If no threads are waiting, this is a no-op: the -// signal is lost. +// notify event is lost. //////////////////////////////////////////////////////////////////// INLINE void ConditionVarFullDirect:: notify_all() { diff --git a/panda/src/pipeline/mutexDebug.I b/panda/src/pipeline/mutexDebug.I index 69c8c2b4d8..ab2a7e25ca 100755 --- a/panda/src/pipeline/mutexDebug.I +++ b/panda/src/pipeline/mutexDebug.I @@ -48,14 +48,13 @@ operator = (const MutexDebug ©) { // // Also see MutexHolder. //////////////////////////////////////////////////////////////////// -INLINE bool MutexDebug:: +INLINE void MutexDebug:: acquire(Thread *current_thread) const { TAU_PROFILE("void MutexDebug::acquire(Thread *)", " ", TAU_USER); nassertv(current_thread == Thread::get_current_thread()); _global_lock->acquire(); - ((MutexDebug *)this)->do_acquire(); - _global_lock->release(current_thread); - return true; + ((MutexDebug *)this)->do_acquire(current_thread); + _global_lock->release(); } //////////////////////////////////////////////////////////////////// @@ -68,7 +67,7 @@ acquire(Thread *current_thread) const { INLINE bool MutexDebug:: try_acquire(Thread *current_thread) const { TAU_PROFILE("void MutexDebug::acquire(Thread *)", " ", TAU_USER); - nassertv(current_thread == Thread::get_current_thread()); + nassertr(current_thread == Thread::get_current_thread(), false); _global_lock->acquire(); bool acquired = ((MutexDebug *)this)->do_try_acquire(current_thread); _global_lock->release(); diff --git a/panda/src/pipeline/mutexDebug.cxx b/panda/src/pipeline/mutexDebug.cxx index 6e29e8cc5e..10efafbb01 100755 --- a/panda/src/pipeline/mutexDebug.cxx +++ b/panda/src/pipeline/mutexDebug.cxx @@ -219,7 +219,7 @@ do_try_acquire(Thread *current_thread) { pipeline_cat.error() << "Configure name-deleted-mutexes 1 to see the mutex name.\n"; } - return; + return false; } bool acquired = true; @@ -227,12 +227,12 @@ do_try_acquire(Thread *current_thread) { // The mutex is not already locked by anyone. Lock it. _locking_thread = current_thread; ++_lock_count; - nassertv(_lock_count == 1); + nassertr(_lock_count == 1, false); } else if (_locking_thread == current_thread) { // The mutex is already locked by this thread. Increment the lock // count. - nassertv(_lock_count > 0); + nassertr(_lock_count > 0, false); if (!_allow_recursion) { ostringstream ostr; ostr << *current_thread << " attempted to double-lock non-reentrant " diff --git a/panda/src/pipeline/semaphore.cxx b/panda/src/pipeline/semaphore.cxx index 9646fd2b0a..6e8c7fb830 100644 --- a/panda/src/pipeline/semaphore.cxx +++ b/panda/src/pipeline/semaphore.cxx @@ -19,7 +19,7 @@ // Access: Published // Description: //////////////////////////////////////////////////////////////////// -INLINE void Semaphore:: +void Semaphore:: output(ostream &out) const { MutexHolder holder(_lock); out << "Semaphore, count = " << _count; diff --git a/panda/src/pipeline/threadSimpleImpl.cxx b/panda/src/pipeline/threadSimpleImpl.cxx index 803a5845b0..db79d83a7a 100644 --- a/panda/src/pipeline/threadSimpleImpl.cxx +++ b/panda/src/pipeline/threadSimpleImpl.cxx @@ -151,8 +151,10 @@ join() { nassertv(_joinable); if (_status == S_running) { ThreadSimpleImpl *thread = _manager->get_current_thread(); - _joining_threads.push_back(thread); - _manager->next_context(); + if (thread != this) { + _joining_threads.push_back(thread); + _manager->next_context(); + } } }