bullet3/examples/Utils/b3Quickprof.h

/*
Copyright (c) 2003-2013 Erwin Coumans  http://bulletphysics.org

This software is provided 'as-is', without any express or implied warranty.
In no event will the authors be held liable for any damages arising from the use of this software.
Permission is granted to anyone to use this software for any purpose, 
including commercial applications, and to alter it and redistribute it freely, 
subject to the following restrictions:

1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
*/

/***************************************************************************************************
**
** Real-Time Hierarchical Profiling for Game Programming Gems 3
**
** by Greg Hjelstrom & Byon Garrabrant
**
***************************************************************************************************/

// Credits: The Clock class was inspired by the Timer classes in
// Ogre (www.ogre3d.org).

#ifndef B3_QUICK_PROF_H
#define B3_QUICK_PROF_H

//To disable built-in profiling, please comment out next line
//#define B3_NO_PROFILE 1
#ifndef B3_NO_PROFILE
#include <stdio.h>  //@todo remove this, backwards compatibility
#include "Bullet3Common/b3Scalar.h"
#include "Bullet3Common/b3AlignedAllocator.h"
#include <new>

#include "b3Clock.h"

///A node in the Profile Hierarchy Tree
class b3ProfileNode
{
public:
	b3ProfileNode(const char* name, b3ProfileNode* parent);
	~b3ProfileNode(void);

	b3ProfileNode* Get_Sub_Node(const char* name);

	b3ProfileNode* Get_Parent(void) { return Parent; }
	b3ProfileNode* Get_Sibling(void) { return Sibling; }
	b3ProfileNode* Get_Child(void) { return Child; }

	void CleanupMemory();
	void Reset(void);
	void Call(void);
	bool Return(void);

	const char* Get_Name(void) { return Name; }
	int Get_Total_Calls(void) { return TotalCalls; }
	float Get_Total_Time(void) { return TotalTime; }
	void* GetUserPointer() const { return m_userPtr; }
	void SetUserPointer(void* ptr) { m_userPtr = ptr; }

protected:
	const char* Name;
	int TotalCalls;
	float TotalTime;
	unsigned long int StartTime;
	int RecursionCounter;

	b3ProfileNode* Parent;
	b3ProfileNode* Child;
	b3ProfileNode* Sibling;
	void* m_userPtr;
};

///An iterator to navigate through the tree
class b3ProfileIterator
{
public:
	// Access all the children of the current parent
	void First(void);
	void Next(void);
	bool Is_Done(void);
	bool Is_Root(void) { return (CurrentParent->Get_Parent() == 0); }

	void Enter_Child(int index);     // Make the given child the new parent
	void Enter_Largest_Child(void);  // Make the largest child the new parent
	void Enter_Parent(void);         // Make the current parent's parent the new parent

	// Access the current child
	const char* Get_Current_Name(void) { return CurrentChild->Get_Name(); }
	int Get_Current_Total_Calls(void) { return CurrentChild->Get_Total_Calls(); }
	float Get_Current_Total_Time(void) { return CurrentChild->Get_Total_Time(); }

	void* Get_Current_UserPointer(void) { return CurrentChild->GetUserPointer(); }
	void Set_Current_UserPointer(void* ptr) { CurrentChild->SetUserPointer(ptr); }
	// Access the current parent
	const char* Get_Current_Parent_Name(void) { return CurrentParent->Get_Name(); }
	int Get_Current_Parent_Total_Calls(void) { return CurrentParent->Get_Total_Calls(); }
	float Get_Current_Parent_Total_Time(void) { return CurrentParent->Get_Total_Time(); }

protected:
	b3ProfileNode* CurrentParent;
	b3ProfileNode* CurrentChild;

	b3ProfileIterator(b3ProfileNode* start);
	friend class b3ProfileManager;
};

///The Manager for the Profile system
class b3ProfileManager
{
public:
	static void Start_Profile(const char* name);
	static void Stop_Profile(void);

	static void CleanupMemory(void)
	{
		Root.CleanupMemory();
	}

	static void Reset(void);
	static void Increment_Frame_Counter(void);
	static int Get_Frame_Count_Since_Reset(void) { return FrameCounter; }
	static float Get_Time_Since_Reset(void);

	static b3ProfileIterator* Get_Iterator(void)
	{
		return new b3ProfileIterator(&Root);
	}
	static void Release_Iterator(b3ProfileIterator* iterator) { delete (iterator); }

	static void dumpRecursive(b3ProfileIterator* profileIterator, int spacing);
	static void dumpAll();

	static void dumpRecursive(FILE* f, b3ProfileIterator* profileIterator, int spacing);
	static void dumpAll(FILE* f);

private:
	static b3ProfileNode Root;
	static b3ProfileNode* CurrentNode;
	static int FrameCounter;
	static unsigned long int ResetTime;
};

#else

#endif  //#ifndef B3_NO_PROFILE

#endif  //B3_QUICK_PROF_H