D:/WorkDir/SugoiProjects/SugoiTracer/include/SugoiTracer/base.h

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
*/

#ifndef _SG_TRC_BASE_H
#define _SG_TRC_BASE_H

#include "SugoiTracer\config.h"
#include "SugoiTracer\timer.h"
#include <SugoiTools\cl_xml_mngr.h>
#include "SugoiTracer\function.h"
#include "SugoiTools\cl_pos.h"//used to include opengl
//#include "SugoiTracer\class.h"
#include <iostream>
//#include <map>                //to create map for C wrapping

#ifdef __cplusplus
namespace SG_TRC{


        
//================================================================
//================================================================
//================================================================


class _SG_TRC_DLL_EXPORT 
        CL_TRACE_BASE_PARAMS
                :public  SGE::CL_XML_OBJ
{
public:
        CL_TRACE_BASE_PARAMS();
        CL_TRACE_BASE_PARAMS(std::string _paramName, std::string &_ParamStr);                   
        //CL_TRACE_BASE_PARAMS(float *_ParamFlt, int _number);  //!< Constructor with array of float.
        CL_TRACE_BASE_PARAMS(std::string _paramName,int *_ParamInt, int _number);               
        ~CL_TRACE_BASE_PARAMS();                                                                
        std::string Params;                                                                             

        void AddInt(std::string _paramName, const int * _IntArray, int _nbr =1, int _stringSize=3);
        void AddChar(std::string _paramName, const char * _CharArray);
        void ParseParams(int _ParamID, std::string & _DestStrArr);
        bool SplitParam(const std::string &_src, std::string &_name, std::string &_val);
#if _SG_TLS_XML
public:
        _SG_TLS_INLINE TiXmlElement* XMLLoad(TiXmlElement* _XML_ROOT);
        _SG_TLS_INLINE TiXmlElement* XMLSave(TiXmlElement* _XML_ROOT);
#endif
};

//================================================================
//================================================================
//================================================================



template <typename TracerType =SG_TRC_Default_Trc_Type>
        class CL_TEMP_TRACER
{       
private :
                bool m_openGL;                  
                bool m_debug;           
public:
        

        CL_TEMP_TRACER(CL_FUNCT_TRC<TracerType> *_FctTraced, CL_TRACE_BASE_PARAMS * _Params)
                :m_openGL(false),
                m_debug(false)
        {
                SG_Assert(_FctTraced, "CL_TEMP_TRACER(), empty function!");

                //create a CL_TRACER
                Tracer = new CL_TRACER<TracerType>(_FctTraced, _Params);
                
                //send it to the CL_FUNCT_TRC
                _FctTraced->TracerToProccess.push_back(Tracer);

                //StartTracing
                Tracer->StartRecording();
        }

        ~CL_TEMP_TRACER()
        {//stop tracing
                if(m_openGL)
                {
                        glFlush();glFinish();
                }
                Tracer->StopRecording();
                if (m_debug)
                {
                        std::cout << Tracer->GetFctTraced()->GetIDStr() << "("
                                <<Tracer->GetParams()->Params <<") : " 
                                <<Tracer->GetResult()->GetStr() << std::endl;
                }

        }

        CL_TRACER<TracerType>* GetTracer()
        {
                SG_Assert(Tracer, "CL_TEMP_TRACER::GetTracer(), empty Tracer!");//.IsValide()
                return Tracer;
        }

        void SetOpenGLTracer(bool _val)
        {
                m_openGL = _val;
        }

        void SetDebug(bool _val)
        {
                m_debug = _val;
        }


private:
        CL_TRACER<TracerType>* Tracer;
};

//================================================================
//================================================================
//================================================================

template <typename TracerType=SG_TRC_Default_Trc_Type>
        class CL_VIRTUAL_TRACER
{
public:


        CL_VIRTUAL_TRACER(CL_FUNCT_TRC<TracerType> * _FctTraced, CL_TRACE_BASE_PARAMS * _Params)
                :FctTraced(_FctTraced),
                Params(_Params),
                Ready(true),
                Val(new TracerType())
        {
                SG_Assert(_FctTraced, "CL_VIRTUAL_TRACER(), empty function!");
        }

        ~CL_VIRTUAL_TRACER()
        {}

        

        virtual 
                TracerType* GetResult()
                {return Val;};

        void SetReady(bool _b){Ready = _b;};
        bool GetReady(){return Ready;};
        CL_FUNCT_TRC<TracerType> *GetFctTraced()
        {       return FctTraced;       }
        CL_TRACE_BASE_PARAMS*           GetParams(){return Params;};

protected:
        TracerType*     Val;
        bool    Ready;
        CL_TRACE_BASE_PARAMS*           Params;
        CL_FUNCT_TRC<TracerType> *      FctTraced;
};

//================================================================
//================================================================
//================================================================

template <typename TracerType=SG_TRC_Default_Trc_Type> 
        class CL_TRACER : 
                public CL_VIRTUAL_TRACER<TracerType>
{
public:
        //definitions
        typedef  CL_TRACER<TracerType> *        CL_TRACER_HDLE;
        typedef  CL_TRACER<TracerType>          CL_TRACER_NEW;
//end definitions...

        CL_TRACER(CL_FUNCT_TRC<TracerType> * _FctTraced, CL_TRACE_BASE_PARAMS * _Params)
                : CL_VIRTUAL_TRACER<TracerType>(_FctTraced, _Params)
                //CL_VIRTUAL_TRACER<TracerType>::Ready(false)
                {
                        SetReady(false);
                }

        ~CL_TRACER(){};

        void StartRecording()
        {
                SetReady(false);
                Val->Run();
        }

        void StopRecording()
        {
                Val->Run();//run the second time....
                SetReady (true);
        }
//      TracerType * GetResult(){return Val;};
};

//================================================================
//================================================================
//================================================================
template <typename TracerType=SG_TRC_Default_Trc_Type>
        class CL_TRACER_RECORD: 
                public SGE::CL_BASE_OBJ<std::string>,
                        public SGE::CL_XML_OBJ
{
private :
                bool                    UseMinMaxTot;
public:
        CL_TRACER_RECORD(std::string _Name, CL_TRACE_BASE_PARAMS*_Params = NULL):
                SGE::CL_BASE_OBJ<std::string>(_Name),
                SGE::CL_XML_OBJ("record"),
                Params(_Params),
                ParentFunction(NULL),
                TotalRecords(0),
                MinTime(new TracerType(10000000)),
                MaxTime(new TracerType()),
                TotalTime(new TracerType()),
                UseMinMaxTot(true),//optimise the use of it...??????
                MaxRecords(_SG_TRC_MAX_NBR_TIMES)
        {
        }
        
        ~CL_TRACER_RECORD()
        {
                delete MinTime;
                delete MaxTime;
                delete TotalTime;
        }
/*
        void EnableMinMaxTot(bool _val)
        {
                UseMinMaxTot = _val;
        }
*/
        void SetParentFunction(CL_FUNCT_TRC<TracerType>* _ParentFunction)
        {
                ParentFunction = _ParentFunction;
                if (ParentFunction)
                        UseMinMaxTot = _ParentFunction->UseMinMaxTot;
        }
                

        std::vector<TracerType*> TimeRecorded;                                                  
        TracerType *TotalTime;                                                                                  
        TracerType *MinTime;                                                                                            
        TracerType *MaxTime;                                                                                            

        _SG_TLS_INLINE
        void 
        AddTracer(CL_TRACER<TracerType>*_newTracer)
        {
                TracerType *TracerTime = _newTracer->GetResult();

                if (TimeRecorded.size() >= MaxRecords)
                {//we remove the first element
                        TimeRecorded.erase(TimeRecorded.begin());
                }

                //Then we add at the end, FIFO
                TimeRecorded.push_back(TracerTime);
                
                RecordStats(TracerTime);
        }

        _SG_TLS_INLINE
        void 
        RecordStats(TracerType *_TracerTime)
        {
                if (ParentFunction)
                {
                        if (ParentFunction->UseMinMaxTot)
                        {
                                *TotalTime += (*_TracerTime);
                                //check for min and max..?
                                if((*_TracerTime) < *MinTime)
                                        *MinTime = (*_TracerTime);
                                if ((*_TracerTime) > *MaxTime)
                                        *MaxTime = (*_TracerTime);
                                //========================
                        }
                }
                else
                {
                        //check for min and max..?
                        if((*_TracerTime) < *MinTime)
                                *MinTime = (*_TracerTime);
                        if ((*_TracerTime) > *MaxTime)
                                *MaxTime = (*_TracerTime);
                        //========================
                }
                TotalRecords++;

        /*      if (ParentFunction)
                {
                        if((*_TracerTime) < *ParentFunction->MinTime)
                                *ParentFunction->MinTime = (*_TracerTime);
                        if ((*_TracerTime) > *ParentFunction->MaxTime)
                                *ParentFunction->MaxTime = (*_TracerTime);
                        //++ total records
                        ParentFunction->TotalRecords++;
                        *ParentFunction->TotalTime += (*TracerTime);
                        if (ParentFunction->ParentClass)
                                *ParentFunction->ParentClass->TotalTime += (*TracerTime);
                }*/
        }

                                                                                                
        _SG_TLS_INLINE
                void 
                        SetParams(CL_TRACE_BASE_PARAMS*_Params)
                        {Params = _Params;}

        _SG_TLS_INLINE
                CL_TRACE_BASE_PARAMS* 
                        GetParams()
                        {return Params;}

        _SG_TLS_INLINE
                void 
                        SetMaxRecords(unsigned int _size)
                        {MaxRecords= _size;}


                        unsigned int GetTotalRecords() {return TotalRecords;}
                        unsigned int GetMaxRecords() {return MaxRecords;}

private:
        unsigned int TotalRecords;              
        unsigned int MaxRecords;
        CL_TRACE_BASE_PARAMS*Params;
        CL_FUNCT_TRC<TracerType> *ParentFunction;                                                                               

        
#if _SG_TLS_XML
public:
        _SG_TLS_INLINE TiXmlElement* XMLLoad(TiXmlElement* _XML_ROOT)
        {
                SG_Assert(_XML_ROOT, "No XML root");

                if (UseMinMaxTot)
                {
                        //TotalTime, min and maxtime
                        TotalTime->XMLLoad(_XML_ROOT, "TotalTime");
                        MinTime->XMLLoad(_XML_ROOT, "MinTime");
                        MaxTime->XMLLoad(_XML_ROOT, "MaxTime");
                        //===========================
                }
                //get nbre of records
                XMLReadVal(_XML_ROOT,"TotalRecords", TotalRecords);
                XMLReadVal(_XML_ROOT,"MaxRecords", MaxRecords);

                //Load params
#if 0
                if (_XML_ROOT->Attribute("params"))
                {
                        Params = new CL_TRACE_BASE_PARAMS("", std::string (""));
                        if (!Params->XMLLoad(_XML_ROOT))
                                delete Params;//no XML tag for params
                }
#else
                //if (_XML_ROOT->Attribute("params"))
                {
                        Params = new CL_TRACE_BASE_PARAMS("", std::string (""));
                        //if (!Params->XMLLoad(_XML_ROOT))
                        //      delete Params;//no XML tag for params
                        Params->Params = GetID();
                }

#endif
                //load all the records...???

                //if (!UseMinMaxTot)
                //load all if we find them
                        XMLLoadVector<TracerType>(_XML_ROOT, TimeRecorded, "ValVector", "Val");         
                
                //..
                /*if (!UseMinMaxTot)
                        TcerRecorded->XMLLoad("functlist", _XML_ROOT);
                */
                return _XML_ROOT;
        }
        
        _SG_TLS_INLINE TiXmlElement* XMLSave(TiXmlElement* _XML_ROOT)
        {
                SG_Assert(_XML_ROOT, "No XML root");

        //      Process();
                if (ParentFunction)
                {//we synchronize the record with the function it belongs to
                        UseMinMaxTot  = ParentFunction->UseMinMaxTot;
                        /*if (ParentFunction->UseMinMaxTot==false)
                                cout << "Parent function UseminMaxTot is false" << endl;
                        else
                                cout << "Parent function UseminMaxTot is true" << endl;
                        */
                }

                //save params
                if (Params)
                        Params->XMLSave(_XML_ROOT);

                if(UseMinMaxTot)
                {
                        //TotalTime, min and maxtime
                        TotalTime->XMLSave(_XML_ROOT, "TotalTime");
                        MinTime->XMLSave(_XML_ROOT, "MinTime");
                        MaxTime->XMLSave(_XML_ROOT, "MaxTime");
                }
                else
                {//load all
                        XMLSaveVector<TracerType>(_XML_ROOT, TimeRecorded, "ValVector", "Val");         
                }

                //set nbre of records
                XMLWriteVal(_XML_ROOT,"TotalRecords", TotalRecords);
                if (MaxRecords!= _SG_TRC_MAX_NBR_TIMES)
                        XMLWriteVal(_XML_ROOT,"MaxRecords", MaxRecords);

                
                
                //..
        /*      if(!UseMinMaxTot)
                        TracerRecorded->XMLSave("functlist", _XML_ROOT, true);
        */
                return _XML_ROOT;
        }
#endif
};

};//namespace SG_TRC
#endif//CPP
#endif //_SG_TRC_BASE_H

---