D:/WorkDir/SugoiProjects/SugoiTracer/src/appli.cpp

Go to the documentation of this file.

/* LICENSE_BEGIN
SutoiTracer library supply support profiling functions, class, or evet simple 
piece of code. It is part of the SugoiEngine project.
Copyright (C) 2006 Allusse Yannick (yannick dot allusse at laposte dot net)

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 2
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, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
LICENSE_END
*/
#include "SugoiTracer\base.h"

namespace SG_TRC{
using namespace SGE;
//================================================================
//================================================================

CL_TRACE_BASE_PARAMS::CL_TRACE_BASE_PARAMS()
                : SGE::CL_XML_OBJ("params")
{

}

CL_TRACE_BASE_PARAMS::
	CL_TRACE_BASE_PARAMS(std::string _paramName, std::string &_ParamStr)
                : SGE::CL_XML_OBJ("params")
{
        Params = "|";
        Params += _paramName;
        Params += ":";
        Params +=_ParamStr;
        Params += "|";
}

/*
CL_TRACE_BASE_PARAMS::CL_TRACE_BASE_PARAMS(std::string _paramName,float *_ParamFlt, int _number)
{}
*/
CL_TRACE_BASE_PARAMS::CL_TRACE_BASE_PARAMS(std::string _paramName,int *_ParamInt, int _number)
        : SGE::CL_XML_OBJ("params")
{
        AddInt(_paramName, _ParamInt, _number);
}

CL_TRACE_BASE_PARAMS::~CL_TRACE_BASE_PARAMS(){}

void CL_TRACE_BASE_PARAMS::AddInt(std::string _paramName, const int * _IntArray, int _nbr/* =1*/, int _stringSize/*=3*/)
{
        Params += "|";
        Params +=_paramName;
        Params += ":";

        //char buff[16];
        for(int i =0; i < _nbr; i++)
        {
                //Params += IntToString(_IntArray[i],_stringSize);
                Params += ToCharStr(_IntArray[i]);
                if (i< _nbr - 1)
                        Params += "/";
        }
        Params += "|";
}

void CL_TRACE_BASE_PARAMS::AddChar(std::string _paramName, const char * _CharArray)
{
        Params += "|";
        Params +=_paramName;
        Params += ":";
        Params += _CharArray;
        Params += "|";
}

void CL_TRACE_BASE_PARAMS::ParseParams(int _ParamID, std::string & _DestStrArr)
{
        //look into the params and parse it for different parameters
        //_ParamID is the offset of the param we are looking for...
        std::string tempSource;

        size_t Pos = -1;
        size_t Start = 0;
        size_t End = 0;
        tempSource = Params;
        do
        {
                //Find the first '|'
                Start = tempSource.find_first_of('|');
                if (Start==-1)
                        break;
                tempSource = tempSource.substr(Start+1,Params.size());
                //Find the second '|'
                End = tempSource.find_first_of('|');
                _DestStrArr = tempSource.substr(Start,End);
                tempSource = tempSource.substr(End+1,Params.size());
                Pos++;
        }
        while(Pos != _ParamID);
        
        if (Start == -1)
                _DestStrArr = "";
        //else
        //_DestStrArr = Params.substr(Start+1,End-1);
}

bool CL_TRACE_BASE_PARAMS::SplitParam(const std::string &_src, std::string &_name, std::string &_val)
{
        if(_src== "")
                return false;
        int Middle = _src.find_first_of(':');

        if(Middle)
        {
                _name = _src.substr(0,Middle);
                _val = _src.substr(Middle+1, _src.size());
                return true;
        }
        return false;
}


/*
void CL_TRACE_BASE_PARAMS::SetParams(int _ParamID, std::string & _DestStrArr)
{
        //look into the params and parse it for different parameters
        //_ParamID is the offset of the param we are looking for...
        std::string tempSource;

        int Pos = -1;
        int Start = 0;
        int End = 0;
        int ParamsOffset;
        tempSource = Params;
        do
        {
                //Find the first '|'
                Start = tempSource.find_first_of('|');
                if (Start==-1)
                        break;
                tempSource = tempSource.substr(Start+1,Params.size());
                //Find the second '|'
                End = tempSource.find_first_of('|');
                _DestStrArr = tempSource.substr(Start,End);
                tempSource = tempSource.substr(End+1,Params.size());
                ParamsOffset += Start+1;
                Pos++;
        }
        while(Pos != _ParamID);
        
        if (Start == -1)
                _DestStrArr = "";
        //else
        //_DestStrArr = Params.substr(Start+1,End-1);
}
*/

#if _SG_TLS_XML

TiXmlElement* CL_TRACE_BASE_PARAMS::XMLLoad(TiXmlElement* _XML_ROOT)
{
        SG_Assert(_XML_ROOT, "No XML root");
        
        XMLReadVal (_XML_ROOT, "params", Params);//keep it for compatibility
        int NewParamID=0;
        XMLReadVal(_XML_ROOT, "paramNbr", NewParamID);

        std::string ParamTag;
        std::string ParamVal;
        std::string ParamName;
        TiXmlElement* XMLParam = NULL;
        for (int i=0; i< NewParamID; i++)
        {
                ParamTag = "param";
                //ParamTag += IntToString(i+1, 1);
                ParamTag += ToCharStr(i+1);

                XMLParam  = XMLGetElement(_XML_ROOT, ParamTag);
                if (XMLParam)
                {
                        XMLReadVal(XMLParam, "name", ParamName);
                        XMLReadVal(XMLParam, "val", ParamVal);
                        if (ParamVal!="" && ParamName=="")
                        {//retro compatibility
                                Params += ParamVal;
                        }
                        else if (ParamName!="" && ParamVal!="")
                        {
                                AddChar(ParamName, ParamVal.c_str());
                        }
                }
        }

        if (Params.size())
                return _XML_ROOT;
        else
                return NULL;
}



TiXmlElement* CL_TRACE_BASE_PARAMS::XMLSave(TiXmlElement* _XML_ROOT)
{
        SG_Assert(_XML_ROOT, "No XML root");
        std::string NewParam="";
        std::string ParamTag;
        int NewParamID = 0;
        TiXmlElement * XML_NewParam = NULL;
        int Start = 0;
        
#if 0
        do{
                ParseParams(NewParamID, NewParam);
                if (NewParam!="")
                {
                        ParamTag = "param";
                        ParamTag += IntToString(NewParamID+1, 1);
                        //Start = NewParam.find_first_of(':');
                        if (Start!=-1)
                        {
                                XML_NewParam = new TiXmlElement(ParamTag.c_str());
                                XMLWriteVal(XML_NewParam, "val", NewParam);
                                _XML_ROOT->InsertEndChild(*XML_NewParam);
                        }
                }
                NewParamID++;
        }
        while(NewParam!="");
#else
        std::string Name, Val;
        
        do{
                ParseParams(NewParamID, NewParam);
                if (NewParam!="")
                {
                        ParamTag = "param";
                        //ParamTag += IntToString(NewParamID+1, 1);
                        ParamTag += ToCharStr(NewParamID+1);
                        if(!SplitParam(NewParam, Name, Val))
                        {
                                NewParamID++;
                                continue;
                        }
                        //Start = NewParam.find_first_of(':');
                                XML_NewParam = new TiXmlElement(ParamTag.c_str());
                                XMLWriteVal(XML_NewParam, "name", Name);
                                XMLWriteVal(XML_NewParam, "val", Val);                          
                                _XML_ROOT->InsertEndChild(*XML_NewParam);
                }
                NewParamID++;
        }
        while(NewParam!="");
#endif

        XMLWriteVal(_XML_ROOT, "paramNbr", NewParamID);
        
//              XMLWriteVal(_XML_ROOT, "params", Params);
        return _XML_ROOT;
}
#endif//_SG_TLS_XML

#if 1

_SG_TRC_DLL_EXPORT bool XMLSaveBench(const char *Filename)
{
#if _SG_TLS_XML
        TTCL_APPLI_TRACER<CL_TimerVal> * CurApplitrc = TTCL_APPLI_TRACER<CL_TimerVal>::MainAppliTracer;
        if (!CurApplitrc)//create it
        {       
                SG_WARNING_LOG("XMLLoadBench(" << Filename << "), no main TTCL_APPLI_TRACER\n");
                return false;
        }

        if (CurApplitrc->XMLSaveToFile(Filename))
                return true;
        else
                SG_WARNING_LOG("File : " << Filename << " Could not be saved\n");
        return false;
#else
        SG_Assert(0, "_SG_TLS_XML is not defined");
        return false;
#endif
}

_SG_TRC_DLL_EXPORT bool XMLLoadBench(const char *Filename)
{
#if _SG_TLS_XML
        TTCL_APPLI_TRACER<CL_TimerVal> * CurApplitrc = TTCL_APPLI_TRACER<CL_TimerVal>::MainAppliTracer;
        if (!CurApplitrc)//create it
        {
                SG_WARNING_LOG("XMLLoadBench(" << Filename << "), no main TTCL_APPLI_TRACER\n");
                //return false;
                CurApplitrc =  CreateMainTracer<SG_TRC_Default_Trc_Type>();//new TTCL_APPLI_TRACER<SG_TRC_Default_Trc_Type>();
        }

        if (CurApplitrc->XMLLoadFromFile(Filename))
                return true;
        else
                SG_WARNING_LOG("File : " << Filename << " Could not be loaded\n");
        return false;
#else
        SG_Assert(0, "_SG_TLS_XML is not defined");
#endif
}

int CreateFunction(const char * _fctName)
{
        if(!_fctName)
        {
                SG_WARNING_LOG("CreateFunction(): function name is null");
                return -1;
        }
        //SG_NOTICE_LOG("Bench : Creating Function=>" << _fctName);
        //cout << endl;
        TTCL_APPLI_TRACER<CL_TimerVal> * CurApplitrc = TTCL_APPLI_TRACER<CL_TimerVal>::MainAppliTracer;
        if (!CurApplitrc)//create it
                CurApplitrc = CreateMainTracer<CL_TimerVal>();// new TTCL_APPLI_TRACER<CL_TimerVal>();

        SG_Assert(CurApplitrc, "Could not create the main appli tracer!");

        if (!CurApplitrc->MapFunction)
                return 0;

        //debug
        //cout << "FctMngr : Nbr of record : "<< TTCL_APPLI_TRACER<CL_TimerVal>::MainAppliTracer->FunctionsManager->GetCount() << endl;

        TTCL_APPLI_TRACER<CL_TimerVal>::TplFctHdle Fct = TTCL_APPLI_TRACER<CL_TimerVal>::MainAppliTracer->AddFunct(_fctName);

        //look into the map if we find it?
        std::map<int, TTCL_APPLI_TRACER<CL_TimerVal>::TplFctHdle>::iterator itFct;
        for ( itFct = CurApplitrc->MapFunction->begin( ) ; itFct!= CurApplitrc->MapFunction->end( ) ;itFct++ )
        {
                if ((*itFct).second == Fct)
                        return (*itFct).first;
        }

        //not on the map, create a new entry
        CurApplitrc->MapFunction->insert(std::pair<int, TTCL_APPLI_TRACER<CL_TimerVal>::TplFctHdle>(++CurApplitrc->MapFunctionLastID, Fct));
        return CurApplitrc->MapFunctionLastID;

}

//main version of StartRecording
int StartRecording(const int _FctNumber, CL_TRACE_BASE_PARAMS * _Params)
{
        //SG_NOTICE_LOG("Bench : Start recording");
        //cout << endl;
        TTCL_APPLI_TRACER<CL_TimerVal> * CurApplitrc = TTCL_APPLI_TRACER<CL_TimerVal>::MainAppliTracer;
        if (!CurApplitrc) return 0;

        TTCL_APPLI_TRACER<CL_TimerVal>::TplFctHdle CurFct = NULL;
        //find the correct function
        std::map<int, TTCL_APPLI_TRACER<CL_TimerVal>::TplFctHdle>::iterator iFct = CurApplitrc->MapFunction->find(_FctNumber);
                if (iFct != CurApplitrc->MapFunction->end())
            CurFct = (*iFct).second;

        //create a CL_TEMP_TRACER
                CL_TEMP_TRACER<CL_TimerVal> * NewTracer = new CL_TEMP_TRACER<CL_TimerVal>(CurFct, _Params);

        //insert in into the map
                CurApplitrc->MapTempTracer->insert(std::pair<int, CL_TEMP_TRACER<CL_TimerVal> *>(++CurApplitrc->MapTracerLastID, NewTracer));

        //return its number
                return CurApplitrc->MapTracerLastID;

}

//C version of startRecording
int StartRecordingInt(const int _FctNumber, const char * ParamsName, const int * _intArray, const int _nbr)
{
        return StartRecording(_FctNumber, new CL_TRACE_BASE_PARAMS(ParamsName, (int*)_intArray, _nbr));
}

int StartRecordingChar(const int _FctNumber, const char * ParamsName, const char *_Value)
{
        return StartRecording(_FctNumber, new CL_TRACE_BASE_PARAMS(ParamsName, std::string(_Value)));
}

//todo add function for adding values to params....
void StopRecording(const int _TracerNumber)
{
        CL_TimerVal *CurTimer=NULL;
        CL_TimerVal TempTimer;
        TempTimer.Run();

        //SG_NOTICE_LOG("Bench : Stop recording");
//      cout << endl;
        //TempTimer.Print();
        TTCL_APPLI_TRACER<CL_TimerVal> * CurApplitrc = TTCL_APPLI_TRACER<CL_TimerVal>::MainAppliTracer;
        if (!CurApplitrc) return;

        //CL_TEMP_TRACER * CurFct = NULL;
        //find the correct tracer
                std::map<int, CL_TEMP_TRACER<CL_TimerVal>*>::iterator iTrc = CurApplitrc->MapTempTracer->find(_TracerNumber);
                if (iTrc != CurApplitrc->MapTempTracer->end())
                {
                        //(*iTrc).second->GetTracer()->GetResult()->Print();
                        //cout << endl;
                        CurTimer = (*iTrc).second->GetTracer()->GetResult();

                        //do some tricks to get the real time and not the time of the function StopRecording()...
                        if (CurTimer)
                        {
                                //CurTimer->Print();
                                CurTimer->Run(&TempTimer);
                                TempTimer = *CurTimer;
                                //cout << endl;
                                //TempTimer.Print();
                        }
                        //================
                        delete (*iTrc).second;
                        CurApplitrc->MapTempTracer-> erase(_TracerNumber);
                }

        
        if (CurTimer)
        {//finish the tricks
                *CurTimer = TempTimer;
                //cout << endl;
                //CurTimer->Print();
        }

        //XMLSaveBench("ARTtest.xml");
}

bool AddParamInt(const int _TracerNumber, const  char * _Name, const int _Value)
{
        TTCL_APPLI_TRACER<CL_TimerVal> * CurApplitrc = TTCL_APPLI_TRACER<CL_TimerVal>::MainAppliTracer;
        if (!CurApplitrc) return false;

        //find the correct tracer
        std::map<int, CL_TEMP_TRACER<CL_TimerVal>*>::iterator iTrc = CurApplitrc->MapTempTracer->find(_TracerNumber);
        if (iTrc != CurApplitrc->MapTempTracer->end())
        {
                CL_TRACE_BASE_PARAMS * TrcParam = (*iTrc).second->GetTracer()->GetParams();
                if (TrcParam)
                {
                        TrcParam->AddInt(_Name, &_Value);
                }
                else
                {std::cout << "AddParam()=> tracer has no params"<< std::endl;}
        }
        return true;

}
bool AddParamChar(const int _TracerNumber, const char * _Name, const char * _Value)
{
        TTCL_APPLI_TRACER<CL_TimerVal> * CurApplitrc = TTCL_APPLI_TRACER<CL_TimerVal>::MainAppliTracer;
        if (!CurApplitrc) return false;

        //find the correct tracer
        std::map<int, CL_TEMP_TRACER<CL_TimerVal>*>::iterator iTrc = CurApplitrc->MapTempTracer->find(_TracerNumber);
        if (iTrc != CurApplitrc->MapTempTracer->end())
        {
                CL_TRACE_BASE_PARAMS * TrcParam = (*iTrc).second->GetTracer()->GetParams();
                if (TrcParam)
                {
                        TrcParam->AddChar(_Name, _Value);
                }
                else
                {std::cout << "AddParam()=> tracer has no params"<< std::endl;}
        }
        return true;
}


#endif

};//namespace SG_TRC

---