mirror/panda3d
1
0
Fork 0
mirror of https://github.com/panda3d/panda3d.git synced 2026-04-21 22:18:25 -05:00
Code Issues Packages Projects Releases Wiki Activity

more and better tau instrumenting

Browse Source
This commit is contained in:
David Rose
2006-04-14 15:45:07 +00:00
parent 452923116d
commit a2dc081676
6 changed files with 30 additions and 12 deletions
Download Patch File Download Diff File Expand all files Collapse all files
dtool/src/dtoolbase/mutexPosixImpl.I
+6 -6
View File
@@ -52,7 +52,7 @@ INLINE MutexPosixImpl::
////////////////////////////////////////////////////////////////////
INLINE void MutexPosixImpl::
lock() {
TAU_PROFILE("MutexPosixImpl::lock", " ", TAU_USER);
TAU_PROFILE("void MutexPosixImpl::lock", " ", TAU_USER);
int result = pthread_mutex_lock(&_lock);
assert(result == 0);
}
@@ -64,7 +64,7 @@ lock() {
////////////////////////////////////////////////////////////////////
INLINE bool MutexPosixImpl::
try_lock() {
TAU_PROFILE("MutexPosixImpl::try_lock", " ", TAU_USER);
TAU_PROFILE("bool MutexPosixImpl::try_lock", " ", TAU_USER);
int result = pthread_mutex_trylock(&_lock);
assert(result == 0 || result == EBUSY);
return (result == 0);
@@ -77,7 +77,7 @@ try_lock() {
////////////////////////////////////////////////////////////////////
INLINE void MutexPosixImpl::
release() {
TAU_PROFILE("MutexPosixImpl::release", " ", TAU_USER);
TAU_PROFILE("void MutexPosixImpl::release", " ", TAU_USER);
int result = pthread_mutex_unlock(&_lock);
assert(result == 0);
}
@@ -117,7 +117,7 @@ INLINE ReMutexPosixImpl::
////////////////////////////////////////////////////////////////////
INLINE void ReMutexPosixImpl::
lock() {
TAU_PROFILE("ReMutexPosixImpl::lock", " ", TAU_USER);
TAU_PROFILE("void ReMutexPosixImpl::lock", " ", TAU_USER);
int result = pthread_mutex_lock(&_lock);
assert(result == 0);
}
@@ -129,7 +129,7 @@ lock() {
////////////////////////////////////////////////////////////////////
INLINE bool ReMutexPosixImpl::
try_lock() {
TAU_PROFILE("ReMutexPosixImpl::try_lock", " ", TAU_USER);
TAU_PROFILE("bool ReMutexPosixImpl::try_lock", " ", TAU_USER);
int result = pthread_mutex_trylock(&_lock);
assert(result == 0 || result == EBUSY);
return (result == 0);
@@ -142,7 +142,7 @@ try_lock() {
////////////////////////////////////////////////////////////////////
INLINE void ReMutexPosixImpl::
release() {
TAU_PROFILE("ReMutexPosixImpl::release", " ", TAU_USER);
TAU_PROFILE("void ReMutexPosixImpl::release", " ", TAU_USER);
int result = pthread_mutex_unlock(&_lock);
assert(result == 0);
}
panda/src/pipeline/mutexDebug.I
+3 -3
View File
@@ -54,7 +54,7 @@ operator = (const MutexDebug &copy) {
////////////////////////////////////////////////////////////////////
INLINE void MutexDebug::
lock() const {
TAU_PROFILE("MutexDebug::lock()", " ", TAU_USER);
TAU_PROFILE("void MutexDebug::lock()", " ", TAU_USER);
_global_mutex.lock();
((MutexDebug *)this)->do_lock();
_global_mutex.release();
@@ -72,7 +72,7 @@ lock() const {
////////////////////////////////////////////////////////////////////
INLINE void MutexDebug::
release() const {
TAU_PROFILE("MutexDebug::release()", " ", TAU_USER);
TAU_PROFILE("void MutexDebug::release()", " ", TAU_USER);
_global_mutex.lock();
((MutexDebug *)this)->do_release();
_global_mutex.release();
@@ -90,7 +90,7 @@ release() const {
////////////////////////////////////////////////////////////////////
INLINE bool MutexDebug::
debug_is_locked() const {
TAU_PROFILE("MutexDebug::debug_is_locked()", " ", TAU_USER);
TAU_PROFILE("bool MutexDebug::debug_is_locked()", " ", TAU_USER);
_global_mutex.lock();
bool is_locked = do_debug_is_locked();
_global_mutex.release();
panda/src/pipeline/mutexDirect.I
+2 -2
View File
@@ -72,7 +72,7 @@ operator = (const MutexDirect &copy) {
////////////////////////////////////////////////////////////////////
INLINE void MutexDirect::
lock() const {
TAU_PROFILE("MutexDirect::lock()", " ", TAU_USER);
TAU_PROFILE("void MutexDirect::lock()", " ", TAU_USER);
((MutexDirect *)this)->_impl.lock();
}
@@ -88,7 +88,7 @@ lock() const {
////////////////////////////////////////////////////////////////////
INLINE void MutexDirect::
release() const {
TAU_PROFILE("MutexDirect::release()", " ", TAU_USER);
TAU_PROFILE("void MutexDirect::release()", " ", TAU_USER);
((MutexDirect *)this)->_impl.release();
}
panda/src/pipeline/pipelineCyclerDummyImpl.I
+16
View File
@@ -81,6 +81,7 @@ INLINE PipelineCyclerDummyImpl::
////////////////////////////////////////////////////////////////////
INLINE void PipelineCyclerDummyImpl::
lock() {
TAU_PROFILE("void PipelineCyclerDummyImpl::lock()", " ", TAU_USER);
nassertv(!_locked);
_locked = true;
}
@@ -93,6 +94,7 @@ lock() {
////////////////////////////////////////////////////////////////////
INLINE void PipelineCyclerDummyImpl::
release() {
TAU_PROFILE("void PipelineCyclerDummyImpl::release()", " ", TAU_USER);
nassertv(_locked);
_locked = false;
}
@@ -110,6 +112,7 @@ release() {
////////////////////////////////////////////////////////////////////
INLINE const CycleData *PipelineCyclerDummyImpl::
read() const {
TAU_PROFILE("const CycleData *PipelineCyclerDummyImpl::read()", " ", TAU_USER);
// This function isn't truly const, but it doesn't change the data
// in any meaningful way, so we pretend it is.
((PipelineCyclerDummyImpl *)this)->_read_count++;
@@ -128,6 +131,7 @@ read() const {
////////////////////////////////////////////////////////////////////
INLINE void PipelineCyclerDummyImpl::
increment_read(const CycleData *pointer) const {
TAU_PROFILE("void PipelineCyclerDummyImpl::increment_read(const CycleData *)", " ", TAU_USER);
// This function isn't truly const, but it doesn't change the data
// in any meaningful way, so we pretend it is.
nassertv(pointer == _data);
@@ -143,6 +147,7 @@ increment_read(const CycleData *pointer) const {
////////////////////////////////////////////////////////////////////
INLINE void PipelineCyclerDummyImpl::
release_read(const CycleData *pointer) const {
TAU_PROFILE("void PipelineCyclerDummyImpl::release_read(const CycleData *)", " ", TAU_USER);
// This function isn't truly const, but it doesn't change the data
// in any meaningful way, so we pretend it is.
nassertv(pointer == _data);
@@ -168,6 +173,7 @@ release_read(const CycleData *pointer) const {
////////////////////////////////////////////////////////////////////
INLINE CycleData *PipelineCyclerDummyImpl::
write() {
TAU_PROFILE("CycleData *PipelineCyclerDummyImpl::write()", " ", TAU_USER);
_write_count++;
// It's an error to grab a write pointer while someone else holds a
@@ -191,6 +197,7 @@ write() {
////////////////////////////////////////////////////////////////////
INLINE CycleData *PipelineCyclerDummyImpl::
elevate_read(const CycleData *pointer) {
TAU_PROFILE("CycleData *PipelineCyclerDummyImpl::elevate_read(const CycleData *)", " ", TAU_USER);
release_read(pointer);
return write();
}
@@ -205,6 +212,7 @@ elevate_read(const CycleData *pointer) {
////////////////////////////////////////////////////////////////////
INLINE CycleData *PipelineCyclerDummyImpl::
elevate_read_upstream(const CycleData *pointer, bool force_to_0) {
TAU_PROFILE("CycleData *PipelineCyclerDummyImpl::elevate_read_upstream(const CycleData *, bool)", " ", TAU_USER);
release_read(pointer);
return write_upstream(force_to_0);
}
@@ -218,6 +226,7 @@ elevate_read_upstream(const CycleData *pointer, bool force_to_0) {
////////////////////////////////////////////////////////////////////
INLINE void PipelineCyclerDummyImpl::
increment_write(CycleData *pointer) const {
TAU_PROFILE("void PipelineCyclerDummyImpl::increment_write(CycleData *)", " ", TAU_USER);
// This function isn't truly const, but it doesn't change the data
// in any meaningful way, so we pretend it is.
nassertv(pointer == _data);
@@ -233,6 +242,7 @@ increment_write(CycleData *pointer) const {
////////////////////////////////////////////////////////////////////
INLINE void PipelineCyclerDummyImpl::
release_write(CycleData *pointer) {
TAU_PROFILE("void PipelineCyclerDummyImpl::release_write(CycleData *)", " ", TAU_USER);
nassertv(pointer == _data);
nassertv(_write_count > 0);
_write_count--;
@@ -261,6 +271,7 @@ get_num_stages() {
////////////////////////////////////////////////////////////////////
INLINE const CycleData *PipelineCyclerDummyImpl::
read_stage(int n) const {
TAU_PROFILE("const CycleData *PipelineCyclerDummyImpl::read_stage(int)", " ", TAU_USER);
// This function isn't truly const, but it doesn't change the data
// in any meaningful way, so we pretend it is.
nassertr(n == 0, NULL);
@@ -279,6 +290,7 @@ read_stage(int n) const {
////////////////////////////////////////////////////////////////////
INLINE void PipelineCyclerDummyImpl::
release_read_stage(int n, const CycleData *pointer) const {
TAU_PROFILE("void PipelineCyclerDummyImpl::release_read_stage(int, const CycleData *)", " ", TAU_USER);
// This function isn't truly const, but it doesn't change the data
// in any meaningful way, so we pretend it is.
nassertv(n == 0);
@@ -318,6 +330,7 @@ release_read_stage(int n, const CycleData *pointer) const {
////////////////////////////////////////////////////////////////////
CycleData *PipelineCyclerDummyImpl::
write_upstream(bool) {
TAU_PROFILE("CycleData *PipelineCyclerDummyImpl::write_upstream(bool)", " ", TAU_USER);
_write_count++;
return _data;
}
@@ -334,6 +347,7 @@ write_upstream(bool) {
////////////////////////////////////////////////////////////////////
INLINE CycleData *PipelineCyclerDummyImpl::
write_stage(int n) {
TAU_PROFILE("CycleData *PipelineCyclerDummyImpl::write_stage(int)", " ", TAU_USER);
nassertr(n == 0, (CycleData *)NULL);
_write_count++;
return _data;
@@ -350,6 +364,7 @@ write_stage(int n) {
////////////////////////////////////////////////////////////////////
INLINE CycleData *PipelineCyclerDummyImpl::
elevate_read_stage(int n, const CycleData *pointer) {
TAU_PROFILE("CycleData *PipelineCyclerDummyImpl::elevate_read_stage(int, CycleData *)", " ", TAU_USER);
nassertr(n == 0, NULL);
release_read(pointer);
return write();
@@ -363,6 +378,7 @@ elevate_read_stage(int n, const CycleData *pointer) {
////////////////////////////////////////////////////////////////////
INLINE void PipelineCyclerDummyImpl::
release_write_stage(int n, CycleData *pointer) {
TAU_PROFILE("void PipelineCyclerDummyImpl::release_write_stage(int, CycleData *)", " ", TAU_USER);
nassertv(n == 0 && pointer == _data);
nassertv(_write_count > 0);
_write_count--;
panda/src/pipeline/pipelineCyclerTrueImpl.I
+1 -1
View File
@@ -55,7 +55,7 @@ release() {
////////////////////////////////////////////////////////////////////
INLINE const CycleData *PipelineCyclerTrueImpl::
read() const {
TAU_PROFILE("const CycleData PipelineCyclerTrueImpl::read()", " ", TAU_USER);
TAU_PROFILE("const CycleData *PipelineCyclerTrueImpl::read()", " ", TAU_USER);
int pipeline_stage = Thread::get_current_pipeline_stage();
nassertr(pipeline_stage >= 0 && pipeline_stage < _num_stages, NULL);
_lock.lock();
panda/src/pipeline/reMutexDirect.I
+2
View File
@@ -84,6 +84,7 @@ operator = (const ReMutexDirect &copy) {
////////////////////////////////////////////////////////////////////
INLINE void ReMutexDirect::
lock() const {
TAU_PROFILE("void ReMutexDirect::lock()", " ", TAU_USER);
#ifdef HAVE_REMUTEXIMPL
((ReMutexDirect *)this)->_impl.lock();
#else
@@ -103,6 +104,7 @@ lock() const {
////////////////////////////////////////////////////////////////////
INLINE void ReMutexDirect::
release() const {
TAU_PROFILE("void ReMutexDirect::release()", " ", TAU_USER);
#ifdef HAVE_REMUTEXIMPL
((ReMutexDirect *)this)->_impl.release();
#else