GeneralsZeroHour/GeneralsMD/Code/Libraries/Source/WWVegas/WWDebug/wwprofile.cpp

/*
**	Command & Conquer Generals Zero Hour(tm)
**	Copyright 2025 Electronic Arts Inc.
**
**	This program is free software: you can redistribute it and/or modify
**	it under the terms of the GNU General Public License as published by
**	the Free Software Foundation, either version 3 of the License, or
**	(at your option) any later version.
**
**	This program is distributed in the hope that it will be useful,
**	but WITHOUT ANY WARRANTY; without even the implied warranty of
**	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
**	GNU General Public License for more details.
**
**	You should have received a copy of the GNU General Public License
**	along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

/***********************************************************************************************
 ***              C O N F I D E N T I A L  ---  W E S T W O O D  S T U D I O S               ***
 ***********************************************************************************************
 *                                                                                             *
 *                 Project Name : WWDebug                                                      *
 *                                                                                             *
 *                     $Archive:: /Commando/Code/wwdebug/wwprofile.cpp                        $*
 *                                                                                             *
 *                      $Author:: Jani_p                                                      $*
 *                                                                                             *
 *                     $Modtime:: 4/01/02 10:30a                                              $*
 *                                                                                             *
 *                    $Revision:: 20                                                          $*
 *                                                                                             *
 *---------------------------------------------------------------------------------------------*
 *   WWProfile_Get_Ticks -- Retrieves the cpu performance counter                              *
 *   WWProfileHierachyNodeClass::WWProfileHierachyNodeClass -- Constructor                     *
 *   WWProfileHierachyNodeClass::~WWProfileHierachyNodeClass -- Destructor                     *
 *   WWProfileHierachyNodeClass::Get_Sub_Node -- Searches for a child node by name (pointer)   *
 *   WWProfileHierachyNodeClass::Reset -- Reset all profiling data in the tree                 *
 *   WWProfileHierachyNodeClass::Call -- Start timing                                          *
 *   WWProfileHierachyNodeClass::Return -- Stop timing, record results                         *
 *   WWProfileManager::Start_Profile -- Begin a named profile                                  *
 *   WWProfileManager::Stop_Profile -- Stop timing and record the results.                     *
 *   WWProfileManager::Reset -- Reset the contents of the profiling system                     *
 *   WWProfileManager::Increment_Frame_Counter -- Increment the frame counter                  *
 *   WWProfileManager::Get_Time_Since_Reset -- returns the elapsed time since last reset       *
 *   WWProfileManager::Get_Iterator -- Creates an iterator for the profile tree                *
 *   WWProfileManager::Release_Iterator -- Return an iterator for the profile tree             *
 *   WWProfileManager::Get_In_Order_Iterator -- Creates an "in-order" iterator for the profile *
 *   WWProfileManager::Release_In_Order_Iterator -- Return an "in-order" iterator              *
 * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */

#include "always.h"
#include "wwprofile.h"
#include "fastallocator.h"
#include "wwdebug.h"
#include <windows.h>
//#include "systimer.h"
#include "systimer.h"
#include "rawfile.h"
#include "ffactory.h"
#include "simplevec.h"
#include "cpudetect.h"
#include "hashtemplate.h"
#include <stdio.h>

static SimpleDynVecClass<WWProfileHierachyNodeClass*> ProfileCollectVector;
static double TotalFrameTimes;
static bool ProfileCollecting;

static HashTemplateClass<StringClass, unsigned> ProfileStringHash;
static unsigned ProfileStringCount;

unsigned WWProfile_Get_System_Time()
{
	return TIMEGETTIME();
}

WWINLINE double WWProfile_Get_Inv_Processor_Ticks_Per_Second(void) 
{
#ifdef WIN32
	return CPUDetectClass::Get_Inv_Processor_Ticks_Per_Second();
#elif defined (_UNIX)
	return 0.001;
#endif
}

/***********************************************************************************************
 * WWProfile_Get_Ticks -- Retrieves the cpu performance counter                                *
 *                                                                                             *
 * INPUT:                                                                                      *
 *                                                                                             *
 * OUTPUT:                                                                                     *
 *                                                                                             *
 * WARNINGS:                                                                                   *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   9/24/2000  gth : Created.                                                                 *
 *=============================================================================================*/
inline void WWProfile_Get_Ticks(_int64 * ticks)
{
#ifdef _UNIX
       *ticks = TIMEGETTIME();
#else
	__asm
	{
		push edx;
		push ecx;
		push eax;
		mov ecx,ticks;
		_emit 0Fh
		_emit 31h
		mov [ecx],eax;
		mov [ecx+4],edx;
		pop eax;
		pop ecx;
		pop edx;
	}
#endif
}


/***********************************************************************************************
 * WWProfileHierachyNodeClass::WWProfileHierachyNodeClass -- Constructor                       *
 *                                                                                             *
 *                                                                                             *
 * INPUT:                                                                                      *
 * name - pointer to a static string which is the name of this profile node                    *
 * parent - parent pointer                                                                     *
 *                                                                                             *
 * OUTPUT:                                                                                     *
 *                                                                                             *
 * WARNINGS:                                                                                   *
 * The name is assumed to be a static pointer, only the pointer is stored and compared for     *
 * efficiency reasons.                                                                         *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   9/24/2000  gth : Created.                                                                 *
 *=============================================================================================*/
WWProfileHierachyNodeClass::WWProfileHierachyNodeClass( const char * name, WWProfileHierachyNodeClass * parent ) :
	Name( name ),
	TotalCalls( 0 ),
	TotalTime( 0 ),
	StartTime( 0 ),
	RecursionCounter( 0 ),
	Parent( parent ),
	Child( NULL ),
	Sibling( NULL )
{
	Reset();

	if (!ProfileStringHash.Get(name, ProfileStringID)) {
		ProfileStringID=ProfileStringCount++;
		ProfileStringHash.Insert(name,ProfileStringID);
	}
}

WWProfileHierachyNodeClass::WWProfileHierachyNodeClass( unsigned id, WWProfileHierachyNodeClass * parent ) :
	Name( NULL ),
	TotalCalls( 0 ),
	TotalTime( 0 ),
	StartTime( 0 ),
	RecursionCounter( 0 ),
	Parent( parent ),
	Child( NULL ),
	Sibling( NULL ),
	ProfileStringID(id)
{
	Reset();
}


/***********************************************************************************************
 * WWProfileHierachyNodeClass::~WWProfileHierachyNodeClass -- Destructor                       *
 *                                                                                             *
 * INPUT:                                                                                      *
 *                                                                                             *
 * OUTPUT:                                                                                     *
 *                                                                                             *
 * WARNINGS:                                                                                   *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   9/24/2000  gth : Created.                                                                 *
 *=============================================================================================*/
WWProfileHierachyNodeClass::~WWProfileHierachyNodeClass( void )
{
	delete Child;
	delete Sibling;
}


WWProfileHierachyNodeClass* WWProfileHierachyNodeClass::Clone_Hierarchy(WWProfileHierachyNodeClass* parent)
{
	WWProfileHierachyNodeClass* node=new WWProfileHierachyNodeClass(Name,parent);
	node->TotalCalls=TotalCalls;
	node->TotalTime=TotalTime;
	node->StartTime=StartTime;
	node->RecursionCounter=RecursionCounter;
	
	if (Child) {
		node->Child=Child->Clone_Hierarchy(this);
	}
	if (Sibling) {
		node->Sibling=Sibling->Clone_Hierarchy(parent);
	}

	return node;
}

void WWProfileHierachyNodeClass::Write_To_File(FileClass* file,int recursion)
{
	if (TotalTime!=0.0f) {
		int i;
		StringClass string;
		StringClass work;
		for (i=0;i<recursion;++i) { string+="\t"; }
		work.Format("%s\t%d\t%f\r\n",Name,TotalCalls,TotalTime*1000.0f);
		string+=work;
		file->Write(string.Peek_Buffer(),string.Get_Length());
	}
	if (Child) {
		Child->Write_To_File(file,recursion+1);
	}
	if (Sibling) {
		Sibling->Write_To_File(file,recursion);
	}
}

void WWProfileHierachyNodeClass::Add_To_String_Compact(StringClass& string,int recursion)
{
	if (TotalTime!=0.0f) {
		StringClass work;
		work.Format("%d %d %2.2f;",ProfileStringID,TotalCalls,TotalTime*1000.0f);
		string+=work;
	}
	if (Child) {
		StringClass work;
		Child->Add_To_String_Compact(work,recursion+1);
		if (work.Get_Length()!=0) {
			string+="{";
			string+=work;
			string+="}";
		}
	}
	if (Sibling) {
		Sibling->Add_To_String_Compact(string,recursion);
	}
}

/***********************************************************************************************
 * WWProfileHierachyNodeClass::Get_Sub_Node -- Searches for a child node by name (pointer)     *
 *                                                                                             *
 * INPUT:                                                                                      *
 * name - static string pointer to the name of the node we are searching for                   *
 *                                                                                             *
 * OUTPUT:                                                                                     *
 *                                                                                             *
 * WARNINGS:                                                                                   *
 * All profile names are assumed to be static strings so this function uses pointer compares   *
 * to find the named node.                                                                     *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   9/24/2000  gth : Created.                                                                 *
 *=============================================================================================*/
WWProfileHierachyNodeClass * WWProfileHierachyNodeClass::Get_Sub_Node( const char * name )
{
	// Try to find this sub node
	WWProfileHierachyNodeClass * child = Child;
	while ( child ) {
		if ( child->Name == name ) {
			return child;
		}
		child = child->Sibling;
	}

	// We didn't find it, so add it
	WWProfileHierachyNodeClass * node = W3DNEW WWProfileHierachyNodeClass( name, this );
	node->Sibling = Child;
	Child = node;
	return node;
}


/***********************************************************************************************
 * WWProfileHierachyNodeClass::Reset -- Reset all profiling data in the tree                   *
 *                                                                                             *
 * INPUT:                                                                                      *
 *                                                                                             *
 * OUTPUT:                                                                                     *
 *                                                                                             *
 * WARNINGS:                                                                                   *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   9/24/2000  gth : Created.                                                                 *
 *=============================================================================================*/
void	WWProfileHierachyNodeClass::Reset( void )
{
	TotalCalls = 0;
	TotalTime = 0.0f;

	if ( Child ) {
		Child->Reset();
	}
	if ( Sibling ) {
		Sibling->Reset();
	}
}


/***********************************************************************************************
 * WWProfileHierachyNodeClass::Call -- Start timing                                            *
 *                                                                                             *
 * INPUT:                                                                                      *
 *                                                                                             *
 * OUTPUT:                                                                                     *
 *                                                                                             *
 * WARNINGS:                                                                                   *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   9/24/2000  gth : Created.                                                                 *
 *=============================================================================================*/
void	WWProfileHierachyNodeClass::Call( void )
{
	TotalCalls++;
	if (RecursionCounter++ == 0) {
		WWProfile_Get_Ticks(&StartTime);
	}
}


/***********************************************************************************************
 * WWProfileHierachyNodeClass::Return -- Stop timing, record results                           *
 *                                                                                             *
 * INPUT:                                                                                      *
 *                                                                                             *
 * OUTPUT:                                                                                     *
 *                                                                                             *
 * WARNINGS:                                                                                   *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   9/24/2000  gth : Created.                                                                 *
 *=============================================================================================*/
bool	WWProfileHierachyNodeClass::Return( void )
{
	if (--RecursionCounter == 0) {
		if ( TotalCalls != 0 ) {
			__int64 time;
			WWProfile_Get_Ticks(&time);
			time-=StartTime;

			TotalTime += float(double(time)*WWProfile_Get_Inv_Processor_Ticks_Per_Second());
		}
	}
	return RecursionCounter == 0;
}


/***************************************************************************************************
**
** WWProfileManager Implementation
**
***************************************************************************************************/
bool									WWProfileManager::IsProfileEnabled=false;
WWProfileHierachyNodeClass		WWProfileManager::Root( "Root", NULL );
WWProfileHierachyNodeClass	*	WWProfileManager::CurrentNode = &WWProfileManager::Root;
WWProfileHierachyNodeClass	*	WWProfileManager::CurrentRootNode = &WWProfileManager::Root;
int									WWProfileManager::FrameCounter = 0;
__int64								WWProfileManager::ResetTime = 0;

static unsigned int				ThreadID = static_cast<unsigned int>(-1);


/***********************************************************************************************
 * WWProfileManager::Start_Profile -- Begin a named profile                                    *
 *                                                                                             *
 * Steps one level deeper into the tree, if a child already exists with the specified name     *
 * then it accumulates the profiling; otherwise a new child node is added to the profile tree. *
 *                                                                                             *
 * INPUT:                                                                                      *
 * name - name of this profiling record                                                        *
 *                                                                                             *
 * OUTPUT:                                                                                     *
 *                                                                                             *
 * WARNINGS:                                                                                   *
 * The string used is assumed to be a static string; pointer compares are used throughout      *
 * the profiling code for efficiency.                                                          *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   9/24/2000  gth : Created.                                                                 *
 *=============================================================================================*/
void	WWProfileManager::Start_Profile( const char * name )
{
	if (::GetCurrentThreadId() != ThreadID) {
		return;
	}

//	int current_thread = ::GetCurrentThreadId();
	if (name != CurrentNode->Get_Name()) {
		CurrentNode = CurrentNode->Get_Sub_Node( name );
	}

	CurrentNode->Call();
}

void	WWProfileManager::Start_Root_Profile( const char * name )
{
	if (::GetCurrentThreadId() != ThreadID) {
		return;
	}

	if (name != CurrentRootNode->Get_Name()) {
		CurrentRootNode = CurrentRootNode->Get_Sub_Node( name );
	}

	CurrentRootNode->Call();
}


/***********************************************************************************************
 * WWProfileManager::Stop_Profile -- Stop timing and record the results.                       *
 *                                                                                             *
 * INPUT:                                                                                      *
 *                                                                                             *
 * OUTPUT:                                                                                     *
 *                                                                                             *
 * WARNINGS:                                                                                   *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   9/24/2000  gth : Created.                                                                 *
 *=============================================================================================*/
void	WWProfileManager::Stop_Profile( void )
{
	if (::GetCurrentThreadId() != ThreadID) {
		return;
	}

	// Return will indicate whether we should back up to our parent (we may
	// be profiling a recursive function)
	if (CurrentNode->Return()) {
		CurrentNode = CurrentNode->Get_Parent();
	}
}

void	WWProfileManager::Stop_Root_Profile( void )
{
	if (::GetCurrentThreadId() != ThreadID) {
		return;
	}

	// Return will indicate whether we should back up to our parent (we may
	// be profiling a recursive function)
	if (CurrentRootNode->Return()) {
		CurrentRootNode = CurrentRootNode->Get_Parent();
	}
}


/***********************************************************************************************
 * WWProfileManager::Reset -- Reset the contents of the profiling system                       *
 *                                                                                             *
 *    This resets everything except for the tree structure.  All of the timing data is reset.  *
 *                                                                                             *
 *                                                                                             *
 * INPUT:                                                                                      *
 *                                                                                             *
 * OUTPUT:                                                                                     *
 *                                                                                             *
 * WARNINGS:                                                                                   *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   9/24/2000  gth : Created.                                                                 *
 *=============================================================================================*/
void	WWProfileManager::Reset( void )
{
	ThreadID = ::GetCurrentThreadId();

	Root.Reset();
	FrameCounter = 0;
	WWProfile_Get_Ticks(&ResetTime);
}


/***********************************************************************************************
 * WWProfileManager::Increment_Frame_Counter -- Increment the frame counter                    *
 *                                                                                             *
 * INPUT:                                                                                      *
 *                                                                                             *
 * OUTPUT:                                                                                     *
 *                                                                                             *
 * WARNINGS:                                                                                   *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   9/24/2000  gth : Created.                                                                 *
 *=============================================================================================*/
void WWProfileManager::Increment_Frame_Counter( void )
{
	if (ProfileCollecting) {
		float time=Get_Time_Since_Reset();
		TotalFrameTimes+=time;
		WWProfileHierachyNodeClass* new_root=Root.Clone_Hierarchy(NULL);
		new_root->Set_Total_Time(time);
		new_root->Set_Total_Calls(1);
		ProfileCollectVector.Add(new_root);
		Reset();
	}

	FrameCounter++;

}


/***********************************************************************************************
 * WWProfileManager::Get_Time_Since_Reset -- returns the elapsed time since last reset         *
 *                                                                                             *
 * INPUT:                                                                                      *
 *                                                                                             *
 * OUTPUT:                                                                                     *
 *                                                                                             *
 * WARNINGS:                                                                                   *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   9/24/2000  gth : Created.                                                                 *
 *=============================================================================================*/
float WWProfileManager::Get_Time_Since_Reset( void )
{
	__int64 time;
	WWProfile_Get_Ticks(&time);
	time -= ResetTime;

	return float(double(time) * WWProfile_Get_Inv_Processor_Ticks_Per_Second());
}


/***********************************************************************************************
 * WWProfileManager::Get_Iterator -- Creates an iterator for the profile tree                  *
 *                                                                                             *
 * INPUT:                                                                                      *
 *                                                                                             *
 * OUTPUT:                                                                                     *
 *                                                                                             *
 * WARNINGS:                                                                                   *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   9/24/2000  gth : Created.                                                                 *
 *=============================================================================================*/
WWProfileIterator *	WWProfileManager::Get_Iterator( void )
{
	return W3DNEW WWProfileIterator( &Root );
}


/***********************************************************************************************
 * WWProfileManager::Release_Iterator -- Return an iterator for the profile tree               *
 *                                                                                             *
 * INPUT:                                                                                      *
 *                                                                                             *
 * OUTPUT:                                                                                     *
 *                                                                                             *
 * WARNINGS:                                                                                   *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   9/24/2000  gth : Created.                                                                 *
 *=============================================================================================*/
void	WWProfileManager::Release_Iterator( WWProfileIterator * iterator )
{
	delete iterator;
}


void	WWProfileManager::Begin_Collecting()
{
	Reset();
	ProfileCollecting=true;
	TotalFrameTimes=0.0;
}

void	WWProfileManager::End_Collecting(const char* filename)
{
	int i;
	if (filename && ProfileCollectVector.Count()!=0) {
		FileClass * file= _TheWritingFileFactory->Get_File(filename);	
		if (file != NULL) {
			//
			//	Open or create the file
			//
			file->Open (FileClass::WRITE);

			StringClass str;
			float avg_frame_time=TotalFrameTimes/float(ProfileCollectVector.Count());
			str.Format(
				"Total frames: %d, average frame time: %fms\r\n"
				"All frames taking more than twice the average frame time are marked with keyword SPIKE.\r\n\r\n",
				ProfileCollectVector.Count(),avg_frame_time*1000.0f);
			file->Write(str.Peek_Buffer(),str.Get_Length());

			HashTemplateIterator<StringClass,unsigned> ite(ProfileStringHash);
			for (ite.First();!ite.Is_Done();ite.Next()) {
				StringClass name=ite.Peek_Key();
				// Remove spaces, tabs and commas from the name as it would confuse the profile browser
				int i;
				for (i=0;i<name.Get_Length();++i) {
					if (name[i]=='\t') name[i]='-';
					if (name[i]==' ') name[i]='_';
					if (name[i]==',') name[i]='.';
					if (name[i]==';') name[i]=':';
				}
				str.Format("ID: %d %s\r\n",ite.Peek_Value(),name);
				file->Write(str.Peek_Buffer(),str.Get_Length());
			}

			str.Format("\r\n\r\n");
			file->Write(str.Peek_Buffer(),str.Get_Length());

			for (i=0;i<ProfileCollectVector.Count();++i) {
				float frame_time=ProfileCollectVector[i]->Get_Total_Time();
				str.Format("FRAME: %d %2.2f %s ",i,frame_time*1000.0f,frame_time>avg_frame_time*2.0f ? "SPIKE" : "OK");
				ProfileCollectVector[i]->Add_To_String_Compact(str,0);
				str+="\r\n";
				file->Write(str.Peek_Buffer(),str.Get_Length());
			}
		
			//
			//	Close the file
			//
			file->Close ();
			_TheWritingFileFactory->Return_File (file);
		}
	}

	for (i=0;i<ProfileCollectVector.Count();++i) {
		delete ProfileCollectVector[i];
		ProfileCollectVector[i]=0;
	}
	ProfileCollectVector.Delete_All();
	ProfileCollecting=false;
}

static unsigned Read_Line(char* memory,unsigned pos,unsigned maxpos)
{
	while (pos<maxpos) {
		if (memory[pos++]=='\n') {
			return pos;
		}
	}
	return pos;
}

static unsigned Seek_Char(char* memory,unsigned pos,unsigned maxpos,char c)
{
	while (pos<maxpos) {
		if (memory[pos++]==c) {
			return pos;
		}
	}
	return pos;
}

unsigned Read_Int(char* memory,unsigned pos,unsigned maxpos,unsigned& number)
{
	number=0;
	while (pos<maxpos) {
		char c=memory[pos++];
		if (isdigit(c)) {
			number*=10;
			number+=c-'0';
		}
		else break;
	}
	return pos;
}

unsigned Read_String(char* memory,unsigned pos,unsigned maxpos,char* string)
{
	int ccount=0;
	while (pos<maxpos) {
		char c=memory[pos++];
		if (c>' ') {
			string[ccount++]=c;
		}
		else break;
	}
	string[ccount]='\0';
	return pos;
}

unsigned Read_Float(char* memory,unsigned pos,unsigned maxpos,float& fnumber)
{
	unsigned ftint=0;
	float ftfloat=0.0f;
	while (pos<maxpos) {
		char c=memory[pos++];
		if (isdigit(c)) {
			ftint*=10;
			ftint+=c-'0';
		}
		else {
			if (c=='.') {
				float divider=1.0f;
				while (pos<maxpos) {
					char c=memory[pos++];
					if (isdigit(c)) {
						ftfloat*=10.0f;
						ftfloat+=float(c-'0');
						divider*=10.0f;
					}
					else break;
				}
				ftfloat/=divider;
			}
			break;
		}
	}
	ftfloat+=float(ftint);
	fnumber=ftfloat;

	return pos;
}

static unsigned Read_ID(char* memory,unsigned pos,unsigned maxpos,StringClass& string,unsigned& id)
{
	char idstring[256];
	unsigned idnumber=0;
	pos+=4;	// "ID: "

	// Read idnumber
	pos=Read_Int(memory,pos,maxpos,idnumber);
	// Read name
	pos=Read_String(memory,pos,maxpos,idstring);

	string=idstring;
	id=idnumber;

	return Read_Line(memory,pos,maxpos);
}

static unsigned Read_Frame(char* memory,unsigned pos,unsigned maxpos,WWProfileHierachyInfoClass*& root,HashTemplateClass<unsigned, StringClass>& id_hash)
{
	char statusstring[256];
	unsigned framenumber=0;
	float frametime;
	root=NULL;
	WWProfileHierachyInfoClass* parent=NULL;
	WWProfileHierachyInfoClass* latest=NULL;

	pos+=7;	// "FRAME: "

	// Read frame number
	pos=Read_Int(memory,pos,maxpos,framenumber);

	// Read frametime
	pos=Read_Float(memory,pos,maxpos,frametime);

	// Read statusstring
	pos=Read_String(memory,pos,maxpos,statusstring);

	// Done with the header, read the fram data

	unsigned lineend=Read_Line(memory,pos,maxpos);
	while (pos<lineend) {
		// A Digit?
		if (isdigit(memory[pos])) {
			unsigned id;
			unsigned count;
			float time;
			// Read id
			pos=Read_Int(memory,pos,maxpos,id);

			// Read count
			pos=Read_Int(memory,pos,maxpos,count);

			// Read time
			pos=Read_Float(memory,pos,maxpos,time);

			StringClass name="Unknown";
			id_hash.Get(id,name);
			WWProfileHierachyInfoClass* new_node=new WWProfileHierachyInfoClass(name,parent);
			if (parent) {
				new_node->Set_Sibling(parent->Get_Child());
				parent->Set_Child(new_node);
			}
			new_node->Set_Total_Time(time);
			new_node->Set_Total_Calls(count);
			latest=new_node;
			if (root==NULL) root=new_node;
		}
		else if (memory[pos]=='{') {
			parent=latest;
			pos++;
		}
		else if (memory[pos]=='}') {
			if (parent) {
				parent=parent->Get_Parent();
			}
			pos++;
		}
		else {
			pos++;
		}
	}

	return Read_Line(memory,pos,maxpos);
}

void WWProfileManager::Load_Profile_Log(const char* filename, WWProfileHierachyInfoClass**& array, unsigned& count)
{
	array=NULL;
	count=0;

	unsigned i;
	FileClass * file= _TheFileFactory->Get_File(filename);	
	if (file != NULL && file->Is_Available()) {
		HashTemplateClass<StringClass, unsigned> string_hash;
		HashTemplateClass<unsigned, StringClass> id_hash;
		SimpleDynVecClass<WWProfileHierachyInfoClass*> vec;

		//
		//	Open or create the file
		//
		file->Open (FileClass::READ);
		char tmp[256];

		unsigned size=file->Size();
		char* memory=new char[size];
		file->Read(memory,size);
		file->Close();
		unsigned pos=0;

		while (pos<size) {
			Read_String(memory,pos,size,tmp);
			if (tmp[0]=='I' && tmp[1]=='D' && tmp[2]==':') {
				StringClass string;
				unsigned id;
				pos=Read_ID(memory,pos,size,string,id);
				string_hash.Insert(string,id);
				id_hash.Insert(id,string);
			}
			else if (tmp[0]=='F' && tmp[1]=='R' && tmp[2]=='A' && tmp[3]=='M' && tmp[4]=='E' && tmp[5]==':') {
				WWProfileHierachyInfoClass* node=NULL;
				pos=Read_Frame(memory,pos,size,node,id_hash);
				if (node) {
					vec.Add(node);
				}
			}
			else {
				pos=Read_Line(memory,pos,size);
			}
		}
		delete[] memory;

		if (vec.Count()) {
			count=vec.Count();
			array=new WWProfileHierachyInfoClass*[count];
			for (i=0;i<count;++i) {
				array[i]=vec[i];
			}
		}
	}
}


/***********************************************************************************************
 * WWProfileManager::Get_In_Order_Iterator -- Creates an "in-order" iterator for the profile t *
 *                                                                                             *
 * INPUT:                                                                                      *
 *                                                                                             *
 * OUTPUT:                                                                                     *
 *                                                                                             *
 * WARNINGS:                                                                                   *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   9/24/2000  gth : Created.                                                                 *
 *=============================================================================================*/
WWProfileInOrderIterator * WWProfileManager::Get_In_Order_Iterator( void )
{
	return W3DNEW WWProfileInOrderIterator;
}


/***********************************************************************************************
 * WWProfileManager::Release_In_Order_Iterator -- Return an "in-order" iterator                *
 *                                                                                             *
 * INPUT:                                                                                      *
 *                                                                                             *
 * OUTPUT:                                                                                     *
 *                                                                                             *
 * WARNINGS:                                                                                   *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   9/24/2000  gth : Created.                                                                 *
 *=============================================================================================*/
void	WWProfileManager::Release_In_Order_Iterator( WWProfileInOrderIterator * iterator )
{
	delete iterator;
}


/***************************************************************************************************
**
** WWProfileIterator Implementation
**
***************************************************************************************************/
WWProfileIterator::WWProfileIterator( WWProfileHierachyNodeClass * start )
{
	CurrentParent = start;
	CurrentChild = CurrentParent->Get_Child();
}

void	WWProfileIterator::First(void)
{
	CurrentChild = CurrentParent->Get_Child();
}


void	WWProfileIterator::Next(void)
{
	CurrentChild = CurrentChild->Get_Sibling();
}

bool	WWProfileIterator::Is_Done(void)
{
	return CurrentChild == NULL;
}

void	WWProfileIterator::Enter_Child( void )
{
	CurrentParent = CurrentChild;
	CurrentChild = CurrentParent->Get_Child();
}

void	WWProfileIterator::Enter_Child( int index )
{
	CurrentChild = CurrentParent->Get_Child();
	while ( (CurrentChild != NULL) && (index != 0) ) {
		index--;
		CurrentChild = CurrentChild->Get_Sibling();
	}

	if ( CurrentChild != NULL ) {
		CurrentParent = CurrentChild;
		CurrentChild = CurrentParent->Get_Child();
	}
}

void	WWProfileIterator::Enter_Parent( void )
{
	if ( CurrentParent->Get_Parent() != NULL ) {
		CurrentParent = CurrentParent->Get_Parent();
	}
	CurrentChild = CurrentParent->Get_Child();
}

/***************************************************************************************************
**
** WWProfileInOrderIterator Implementation
**
***************************************************************************************************/

WWProfileInOrderIterator::WWProfileInOrderIterator( void )
{
	CurrentNode = &WWProfileManager::Root;
}

void	WWProfileInOrderIterator::First(void)
{
	CurrentNode = &WWProfileManager::Root;
}

void	WWProfileInOrderIterator::Next(void)
{
	if ( CurrentNode->Get_Child() ) {				// If I have a child, go to child
		CurrentNode = CurrentNode->Get_Child();
	} else if ( CurrentNode->Get_Sibling() ) {	// If I have a sibling, go to sibling
		CurrentNode = CurrentNode->Get_Sibling();
	} else {											//	if not, go to my parent's sibling, or his.......
		// Find a parent with a sibling....
		bool done = false;
		while ( CurrentNode != NULL && !done ) {

			// go to my parent
			CurrentNode = CurrentNode->Get_Parent();

			// If I have a sibling, go there
			if ( CurrentNode != NULL && CurrentNode->Get_Sibling() != NULL ) {
				CurrentNode = CurrentNode->Get_Sibling();
				done = true;
			}
		}
	}
}

bool	WWProfileInOrderIterator::Is_Done(void)
{
	return CurrentNode == NULL;
}

/*
**
*/
WWTimeItClass::WWTimeItClass( const char * name )
{
	Name = name;
	WWProfile_Get_Ticks( &Time );
}

WWTimeItClass::~WWTimeItClass( void )
{
	__int64 End;
	WWProfile_Get_Ticks( &End );
	End -= Time;
#ifdef WWDEBUG
	float time = End * WWProfile_Get_Inv_Processor_Ticks_Per_Second();
	WWDEBUG_SAY(( "*** WWTIMEIT *** %s took %1.9f\n", Name, time ));
#endif
}


/*
**
*/
WWMeasureItClass::WWMeasureItClass( float * p_result )
{
	WWASSERT(p_result != NULL);
	PResult = p_result;
	WWProfile_Get_Ticks( &Time );
}

WWMeasureItClass::~WWMeasureItClass( void )
{
	__int64 End;
	WWProfile_Get_Ticks( &End );
	End -= Time;
	WWASSERT(PResult != NULL);
	*PResult = End  * WWProfile_Get_Inv_Processor_Ticks_Per_Second();
}

// ----------------------------------------------------------------------------
//
//
//
// ----------------------------------------------------------------------------

unsigned WWMemoryAndTimeLog::TabCount;

WWMemoryAndTimeLog::WWMemoryAndTimeLog(const char* name)
	:
	Name(name),
	TimeStart(WWProfile_Get_System_Time()),
	AllocCountStart(FastAllocatorGeneral::Get_Allocator()->Get_Total_Allocation_Count()),
	AllocSizeStart(FastAllocatorGeneral::Get_Allocator()->Get_Total_Allocated_Size())
{
	IntermediateTimeStart=TimeStart;
	IntermediateAllocCountStart=AllocCountStart;
	IntermediateAllocSizeStart=AllocSizeStart;
	StringClass tmp(0,true);
	for (unsigned i=0;i<TabCount;++i) tmp+="\t";
	WWRELEASE_SAY(("%s%s {\n",tmp,name));
	TabCount++;
}

WWMemoryAndTimeLog::~WWMemoryAndTimeLog()
{
	if (TabCount>0) TabCount--;
	StringClass tmp(0,true);
	for (unsigned i=0;i<TabCount;++i) tmp+="\t";
	WWRELEASE_SAY(("%s} ",tmp));

	unsigned current_time=WWProfile_Get_System_Time();
	int current_alloc_count=FastAllocatorGeneral::Get_Allocator()->Get_Total_Allocation_Count();
	int current_alloc_size=FastAllocatorGeneral::Get_Allocator()->Get_Total_Allocated_Size();
	WWRELEASE_SAY(("IN TOTAL %s took %d.%3.3d s, did %d memory allocations of %d bytes\n",
		Name,
		(current_time - TimeStart)/1000, (current_time - TimeStart)%1000,
		current_alloc_count - AllocCountStart,
		current_alloc_size - AllocSizeStart));
	WWRELEASE_SAY(("\n"));

}


void WWMemoryAndTimeLog::Log_Intermediate(const char* text)
{
	unsigned current_time=WWProfile_Get_System_Time();
	int current_alloc_count=FastAllocatorGeneral::Get_Allocator()->Get_Total_Allocation_Count();
	int current_alloc_size=FastAllocatorGeneral::Get_Allocator()->Get_Total_Allocated_Size();
	StringClass tmp(0,true);
	for (unsigned i=0;i<TabCount;++i) tmp+="\t";
	WWRELEASE_SAY(("%s%s took %d.%3.3d s, did %d memory allocations of %d bytes\n",
		tmp,
		text,
		(current_time - IntermediateTimeStart)/1000, (current_time - IntermediateTimeStart)%1000,
		current_alloc_count - IntermediateAllocCountStart,
		current_alloc_size - IntermediateAllocSizeStart));
	IntermediateTimeStart=current_time;
	IntermediateAllocCountStart=current_alloc_count;
	IntermediateAllocSizeStart=current_alloc_size;
}

/***********************************************************************************************
 * WWProfileHierachyInfoClass::WWProfileHierachyInfoClass -- Constructor                       *
 *                                                                                             *
 *                                                                                             *
 * INPUT:                                                                                      *
 * name - pointer to a static string which is the name of this profile node                    *
 * parent - parent pointer                                                                     *
 *                                                                                             *
 * OUTPUT:                                                                                     *
 *                                                                                             *
 * WARNINGS:                                                                                   *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *=============================================================================================*/
WWProfileHierachyInfoClass::WWProfileHierachyInfoClass( const char * name, WWProfileHierachyInfoClass * parent ) :
	Name( name ),
	TotalCalls( 0 ),
	TotalTime( 0 ),
	Parent( parent ),
	Child( NULL ),
	Sibling( NULL )
{
}

/***********************************************************************************************
 * WWProfileHierachyNodeClass::~WWProfileHierachyNodeClass -- Destructor                       *
 *                                                                                             *
 * INPUT:                                                                                      *
 *                                                                                             *
 * OUTPUT:                                                                                     *
 *                                                                                             *
 * WARNINGS:                                                                                   *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   9/24/2000  gth : Created.                                                                 *
 *=============================================================================================*/
WWProfileHierachyInfoClass::~WWProfileHierachyInfoClass( void )
{
	delete Child;
	delete Sibling;
}