D:/WorkDir/SugoiProjects/SugoiTracer/include/SugoiTracer/function.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_FUNCTION_H
#define _SG_TRC_FUNCTION_H

#include "SugoiTracer\config.h"

#ifdef __cplusplus
        #include "SugoiTracer\timer.h"
        //#include "SugoiTracer\function.h"
        #include "SugoiTracer\class.h"
        #include "SugoiTracer\appli.h"
        #include <Time.h>
        #include <sys/timeb.h> 
        #include <SugoiTools\cl_base_obj.h>
        #include <SugoiTools\cl_xml_mngr.h>


#if SG_TLS_MEMORY_MANAGER
        #include "SugoiTools\debug_new.h"
#endif 

namespace SG_TRC{
/* \class CL_FUNCT_TRC
*\brief This class is used to store all the records corresponding to one function and all its set of paremeters.
*\todo Add an example
*/
template <typename TracerType = SG_TRC_Default_Trc_Type> 
        class CL_FUNCT_TRC
                :public CL_XML_OBJ,
                public CL_BASE_OBJ<std::string>
{
public:
//Type definitions =================================
/*#if _SG_TLS_SMARTPTR
        typedef typename SGE::CSmartPtr<CL_FUNCT_TRC<TracerType> >                      TplSmartP;
        typedef typename SGE::CSmartPtr<CL_CLASS_TRACER<TracerType> >           TplClassP;
#else
        typedef CL_FUNCT_TRC<TracerType> *                      TplSmartP;
        typedef CL_CLASS_TRACER<TracerType> *           TplClassP;
#endif*/
        typedef CL_FUNCT_TRC<TracerType>                *TplFctHdle;
        typedef CL_CLASS_TRACER<TracerType>             *TplClassHdle;
        typedef CL_FUNCT_TRC<TracerType>                *TplFctObj;
        typedef CL_CLASS_TRACER<TracerType>             *TplClassObj;
//==================================================
                
private:
        bool                    TracingEnable;                  
        bool                    Modified;                               
        TracerType              *TotalTime;
        TracerType              *MinTime;
        TracerType              *MaxTime;
        TplClassHdle    ParentClass;                    
        int                             MaxRecords;                             
        

public:
        int TotalRecords;
        bool                    UseMinMaxTot;
        CL_XML_MNGR<CL_TRACER_RECORD<TracerType> , std::string>         *TracerRecorded;        
        std::vector<CL_TRACER<TracerType>*>             TracerToProccess;       

/*
        void EnableMinMaxTot(bool _val)
        {
                UseMinMaxTot = _val;
        }

        bool GetMinMaxTotUse()
        {
                return UseMinMaxTot;
        }
*/
public:
        CL_FUNCT_TRC(std::string _Name)
                :CL_XML_OBJ("Function"),
                CL_BASE_OBJ<std::string>(_Name),
                ParentClass(NULL),
                Modified(true), //so it will be processed the first time
                TracingEnable(true),//enable tracing
                MinTime(new TracerType()),
                MaxTime(new TracerType()),
                TotalTime(new TracerType()),
                UseMinMaxTot(true),//??? see how to optimise this...???
                TracerRecorded(new CL_XML_MNGR<CL_TRACER_RECORD<TracerType>, std::string>(NULL, "RecordList","Records", XML_TAG_VAL_ID)),
                MaxRecords(-1)
        {
                Clear();
        }

        ~CL_FUNCT_TRC()
        {
                //?? why it does not work? 
                delete(TracerRecorded);
                delete MinTime;
                delete MaxTime;
                delete TotalTime;
        }                                                                       
        
        void Clear()
        {
                MaxTime->Clear();
                TotalTime->Clear();
                TotalRecords =0;        
                MinTime->SetToMax();
                TracerRecorded->DeleteAllLocal();

                //delete all the data from the vector...
                TracerToProccess.clear();//cause we use a smart pointer, unreferences objects will be destroyed automatically
                //---------------------------------------
        }
                                                                                
        void SetParrentClass(TplClassHdle _ParentClass)   
                {ParentClass =_ParentClass;}

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

        void AddTracerToProccess(CL_TRACER<TracerType> *_NewTracer)
        {
                SG_Assert(_NewTracer, "CL_FUNCT_TRC<TracerType>::AddTracerToProccess() : Empty Tracer.");
                TracerToProccess.push_back(_NewTracer);
                Modified = true;
        }

        //return number of tracer processed     
        int Process()
        {
                int i=0;
                std::vector <CL_TRACER<TracerType>* >::iterator iTracer = TracerToProccess.begin();
/*              
                SG_NOTICE_LOG("\nProcessing function");
                SG_NOTICE_LOG(this->GetID());
                SG_NOTICE_LOG("====================================\n");
                SG_NOTICE_LOG("=> Records to process : ");
                int Size = TracerToProccess.size();
                SG_NOTICE_LOG(IntToString(Size));
*/              
                while(iTracer != TracerToProccess.end())
                        //; iTracer != TracerToProccess.end( ) ; iTracer++ )
                {
                        if (!(*iTracer)->GetReady())
                                break;//the function is still benchmarking...

                        AddTracerProccessed(*iTracer); 
                        //SG_NOTICE_LOG("\n");
                        //SG_NOTICE_LOG(IntToString(i));
                        //delete(*iTracer);
                        TracerToProccess.erase(iTracer);
                        i++;
                        iTracer = TracerToProccess.begin();
                }
                TracerToProccess.clear();
                
                return i;
        }
        //int GetAllRecordNumbers();                    //!< Not used qnymore...remove it ????????????

        const TracerType & GetMin(){return *MinTime;}
        const TracerType & GetMax(){return *MaxTime;}
        const TracerType & GetTotal(){return *TotalTime;}
        bool IsModified() {return Modified;}
        
private:                
        CL_TRACER_RECORD<TracerType> *
                AddTracerProccessed(CL_TRACER<TracerType>* _NewTracer)
                {
                        SG_Assert(_NewTracer, "CL_FUNCT_TRC<TracerType>::AddTracerProccessed() : Empty Tracer.");

                        //create a unique srting with _tracer parameters
                        std::string ParamUniqName;
                        if (_NewTracer->GetParams())
                                ParamUniqName = _NewTracer->GetParams()->Params;
                        else
                                ParamUniqName = "empty";
                        
                        //look into the TracerRecorded List to find the correct function with the right parameters
                        //SGE::CSmartPtr<CL_TRACER_RECORD<TracerType> > CurTracer = TracerRecorded->Get(ParamUniqName);
                        CL_XML_MNGR<CL_TRACER_RECORD<TracerType> , std::string>::TplHdle CurTracer = TracerRecorded->Get(ParamUniqName);
                        
                        if (!CurTracer)
                        {//not valide, we create it...
                                CurTracer = TracerRecorded->Add(ParamUniqName);
                                CurTracer->SetParentFunction(this);
                                CurTracer->SetParams(_NewTracer->GetParams());
                                if (MaxRecords!=-1)
                                        CurTracer->SetMaxRecords(MaxRecords);
                        }
                /*      else
                                //here can can delete the params object, cause we have already one recorded
                                delete(_NewTracer->Params);
                */
                        CurTracer->AddTracer(_NewTracer);
                        return CurTracer;
                }
        
#if _SG_TLS_XML
public:
        _SG_TLS_INLINE 
                TiXmlElement* 
                XMLLoad(TiXmlElement* _XML_ROOT)
                {
                        SG_Assert(_XML_ROOT, "No XML root");
                        Process();

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

                        //load all the records
                        TracerRecorded->XMLLoad(_XML_ROOT);

                        //affect the function
                        CL_XML_MNGR<CL_TRACER_RECORD<TracerType> , std::string>::iterator itRecord;
                        for(itRecord = TracerRecorded->GetFirstIter();  itRecord != TracerRecorded->GetLastIter(); itRecord++)
                        {
                                (*itRecord).second->SetParentFunction(this);
                                if (MaxRecords!=-1)
                                        (*itRecord).second->SetMaxRecords(MaxRecords);

                        }

                        return _XML_ROOT;
                }

        _SG_TLS_INLINE 
                TiXmlElement* 
                XMLSave(TiXmlElement* _XML_ROOT)
                {
                        SG_Assert(_XML_ROOT, "No XML root");

                        Process();

                        if (UseMinMaxTot)
                        {
                                //TotalTime, min and maxtime
                                TotalTime->XMLSave(_XML_ROOT, "TotalTime");
                                MinTime->XMLSave(_XML_ROOT, "MinTime");
                                MaxTime->XMLSave(_XML_ROOT, "MaxTime");
                        }
                        
                        XMLWriteVal(_XML_ROOT, "TotalRecords", TotalRecords);
                        if (MaxRecords!=-1)
                                XMLWriteVal(_XML_ROOT, "MaxRecords", MaxRecords);

                        //..
                        _SG_DEBUG_XML(cout << "Function : " << GetIDStr() << " => record nbr : " << TracerRecorded->GetCount() << endl);
                        _SG_DEBUG_XML(cout << "Record to process : " << TracerToProccess.size() << endl);

                        TracerRecorded->XMLSave(_XML_ROOT);


                        //why this,,..>????
                        if (TracerRecorded->GetCount() == 1)
                        {
                                if (TracerRecorded->GetFirstIter()->second->GetParams() == NULL)
                                        return _XML_ROOT;
                                else if  (TracerRecorded->GetFirstIter()->second->GetParams()->Params == "EMPTY")
                                        return _XML_ROOT;
                        }
        
                        return _XML_ROOT;
                }
#endif

#if _SG_TRC_SVG
        bool SaveToSVGFile()
        {

#ifdef _CVG_SVG_CREATE_FILES
        if (CurFct)
        { 
                string Svg;
                string Filename;
                char TempBuff[256];
                CurFct->Sort();
                vector <CL_FCT_SUB_ARGS*> Records;      
                CL_FCT_SUB_ARGS * ActiveRec=NULL;
                CL_TimerVal * CurTime =NULL;
                CL_TimerVal Average;
                long int maxvalue;
                int NParamsEqual=1;
                int NbParamsFirst=true;
                int pst[12];
                struct Pts {
                           unsigned int ImgSize[2];
                           unsigned long int time;
                }ChartPts[128];
                string ActiveParams="";
                string Params="";

 
                for (unsigned int i=0; i<CurFct->Records.size(); i+=NParamsEqual)
                {
                //if (ActiveParams!=CurFct->Records[i]->Params)ActiveParams = CurFct->Records[i]->Params;
                
                            
                        if (NParamsEqual==1)
                        {
                                ActiveRec = CurFct->Records[i];
                                for (unsigned int j=i+1; j<CurFct->Records.size(); j++)
                                        if (ActiveRec->Params == CurFct->Records[j]->Params)
                                           NParamsEqual++;
                                NbParamsFirst=true;
                        }
                        
                        for (unsigned int t=i; t<i+NParamsEqual; t++)
                        {  
                                ActiveRec = CurFct->Records[t];
                                //printf("\n%s - %s - %s %d",CurFct->FCT_NAME.data(),  ActiveRec->Params.data(), ActiveRec->Type.data(), ActiveRec->SizeIn[0]);
                                Average = ActiveRec->TotalTime;
                                Average/= ActiveRec->NbrOfTime;
                                ChartPts[t-i].time = Average.GetValue();
                        }
         
        
                        Filename = _CVG_SVG_EXPORT_PATH;
                        Filename += "\\"+CurFct->FCT_NAME+"_"+ActiveRec->Params+".svg";
                        
                        OpenFile((char *)Filename.data());
                        if (!File) return -1;
                        //this->Sort();
                        
                        Svg = "<svg width='550' height='425'>\n";
                        
                        Svg+="<line x1='49' x2='480' y1='350' y2='350'  style='stroke-width:3 ; fill:none; stroke:black'/>\n";
                        Svg+="<line x1='470' x2='480' y1='347' y2='350'  style='stroke-width:3 ; fill:none; stroke:black'/>\n";
                        Svg+="<line x1='470' x2='480' y1='353' y2='350'  style='stroke-width:3 ; fill:none; stroke:black'/>\n";
                        fwrite( Svg.data(), strlen(Svg.data())*sizeof(unsigned char),1,File);
                        
                        for(unsigned int j=0,ps=400;j<6;j++)
                        {
                                sprintf(TempBuff, "<line x1='%d' x2='%d' y1='347' y2='350'  style='stroke-width:2 ; fill:none; stroke:black'/>\n",50+ps,50+ps); 
                                fwrite( TempBuff, strlen(TempBuff)*sizeof(unsigned char),1,File);
                                ps/=4;
                        }
                        
                        Svg="<line x1='50' x2='47' y1='25' y2='35'  style='stroke-width:3 ; fill:none; stroke:black'/>\n";
                        Svg+="<line x1='50' x2='53' y1='25' y2='35'  style='stroke-width:3 ; fill:none; stroke:black'/>\n";
                        Svg+="<line x1='50' x2='50' y1='351' y2='25'  style='stroke-width:3 ; fill:none; stroke:black'/>\n";
                        fwrite( Svg.data(), strlen(Svg.data())*sizeof(unsigned char),1,File);
   
                        for(unsigned int j=0;j<5;j++)
                        {
                                sprintf(TempBuff, "<line x1='50' x2='53' y1='%d' y2='%d'  style='stroke-width:2 ; fill:none; stroke:black'/>\n",50+60*j,50+60*j); 
                                fwrite( TempBuff, strlen(TempBuff)*sizeof(unsigned char),1,File);
                        }

                        Svg="<g style='font-size:16;fill:black'>\n";
                        Svg+="<text x='20'  y='25'>Time(ms)</text>\n"; 
                        Svg+="<text x='460' y='365'>Size(pixels)</text>\n"; 
                        Svg+="</g>\n";
                        fwrite( Svg.data(), strlen(Svg.data())*sizeof(unsigned char),1,File);
                        
                        Svg="<g style='font-size:13'>\n";
                        Svg+="<text x='20' y='355'>0</text>\n";
                        Svg+="<g transform='rotate(90)'>\n";
                        fwrite( Svg.data(), strlen(Svg.data())*sizeof(unsigned char),1,File); 
   
                        for(unsigned int j=0,pp=2048,ps=400;j<4;j++)
                        {
                                sprintf(TempBuff, "<text x='355' y='%d'>%d*%d</text>\n",(-1)*(ps+46),pp,pp); 
                                fwrite( TempBuff, strlen(TempBuff)*sizeof(unsigned char),1,File);
                                pp/=2;
                                ps/=4;
                        }
                        Svg="</g>\n";
                        Svg+="</g>\n";
                        fwrite( Svg.data(), strlen(Svg.data())*sizeof(unsigned char),1,File);
                        
                        maxvalue=0;
                        for (unsigned int j=0;j<NParamsEqual;j++)
                                if (ChartPts[j].time>maxvalue) 
                                   maxvalue=ChartPts[j].time;
                        
                        
                        if (maxvalue<=2500) maxvalue=2500;
                        else if (maxvalue<=5000) maxvalue=5000;
                        else if (maxvalue<=10000) maxvalue=10000;
                        else if (maxvalue<=20000) maxvalue=20000;
                        else if (maxvalue<=30000) maxvalue=30000;
                        else if (maxvalue<=40000) maxvalue=40000;
                        else if (maxvalue<=50000) maxvalue=50000;
                        else if (maxvalue<=60000) maxvalue=60000;
                        else if (maxvalue<=70000) maxvalue=70000;
                        else if (maxvalue<=80000) maxvalue=80000;
                        else if (maxvalue<=90000) maxvalue=90000;
                        else if (maxvalue<=100000) maxvalue=100000;
                        else if (maxvalue<=110000) maxvalue=110000;
                        else if (maxvalue<=120000) maxvalue=120000;
                        else if (maxvalue<=130000) maxvalue=130000;
                        else if (maxvalue<=140000) maxvalue=140000;
                        else if (maxvalue<=150000) maxvalue=150000;
                        else if (maxvalue<=160000) maxvalue=160000;
                        else if (maxvalue<=170000) maxvalue=170000;
                        else if (maxvalue<=180000) maxvalue=180000;
                        else if (maxvalue<=190000) maxvalue=190000;
                        else if (maxvalue<=200000) maxvalue=200000;
                        
                        for (unsigned int j=0;j<NParamsEqual;j++)        
                                pst[j]=350-300*ChartPts[j].time/maxvalue;       
                        
                        sprintf(TempBuff, "<text x='225'  y='25' style='font-family:Verdana; font-size:20; fill:black'>%s</text>\n",CurFct->FCT_NAME.data());
                        fwrite( TempBuff, strlen(TempBuff)*sizeof(unsigned char),1,File);
                        sprintf(TempBuff, "<text x='225'  y='45' style='font-family:Verdana; font-size:13; fill:black'>%s</text>\n",ActiveRec->Params.data());
                        fwrite( TempBuff, strlen(TempBuff)*sizeof(unsigned char),1,File);
                        
                        Svg="<g style='stroke:black; fill:black' >\n";
                        fwrite( Svg.data(), strlen(Svg.data())*sizeof(unsigned char),1,File);
                        
                        for (unsigned int j=0,ps=400;j<6;j++)
                        { 
                                sprintf(TempBuff, "<circle cx='%d'  cy='%d' r='3'  />\n",ps+50,pst[2*j]);
                                fwrite( TempBuff, strlen(TempBuff)*sizeof(unsigned char),1,File);
                                sprintf(TempBuff, "<circle cx='%d'  cy='%d' r='3'  />\n",ps+50,pst[2*j+1]);
                                fwrite( TempBuff, strlen(TempBuff)*sizeof(unsigned char),1,File);
                                ps/=4;
                        }
                        Svg="</g>\n";
                        fwrite( Svg.data(), strlen(Svg.data())*sizeof(unsigned char),1,File);

                        Svg="<g style='font-size:10; fill:black' >\n";
                        fwrite( Svg.data(), strlen(Svg.data())*sizeof(unsigned char),1,File);
                        for (unsigned int j=0,ps=400;j<3;j++)
                        { 
                                sprintf(TempBuff, "<text x='%d'  y='%d'>(%dus)</text>\n",ps+55,pst[2*j]+10,ChartPts[2*j].time);
                                fwrite( TempBuff, strlen(TempBuff)*sizeof(unsigned char),1,File);
                                sprintf(TempBuff, "<text x='%d'  y='%d'>(%dus)</text>\n",ps+55,pst[2*j+1]+10,ChartPts[2*j+1].time);
                                fwrite( TempBuff, strlen(TempBuff)*sizeof(unsigned char),1,File);
                                ps/=4;
                        }  
                        Svg="</g>\n";
                        fwrite( Svg.data(), strlen(Svg.data())*sizeof(unsigned char),1,File);  
  
                        sprintf(TempBuff, "<polyline points='51,%d,52,%d,56,%d,75,%d,150,%d,450,%d' style='stroke-width:3 ; fill:none; stroke:orange'/>\n",pst[10],pst[8],pst[6],pst[4],pst[2],pst[0]);
                        fwrite( TempBuff, strlen(TempBuff)*sizeof(unsigned char),1,File);
                        sprintf(TempBuff, "<polyline points='51,%d,52,%d,56,%d,75,%d,150,%d,450,%d' style='stroke-width:3 ; fill:none; stroke:blue'/>\n",pst[11],pst[9],pst[7],pst[5],pst[3],pst[1]);
                        fwrite( TempBuff, strlen(TempBuff)*sizeof(unsigned char),1,File);
                        
                        sprintf(TempBuff, "<text x='460'  y='%d' style='font-family:Verdana; font-size:15; fill:orange'>OpenCV</text>\n",pst[0]); 
                        fwrite( TempBuff, strlen(TempBuff)*sizeof(unsigned char),1,File);
                        sprintf(TempBuff, "<text x='460'  y='%d' style='font-family:Verdana; font-size:15; fill:blue'>GPUCV</text>\n",pst[1]); 
                        fwrite( TempBuff, strlen(TempBuff)*sizeof(unsigned char),1,File);
    
                        Svg="<g style='font-size:13'>\n"; 
                        fwrite( Svg.data(), strlen(Svg.data())*sizeof(unsigned char),1,File); 
                        if (maxvalue>3000)  
                        {
                                for (unsigned int j=1,yy=295; j<6;j++)
                                {
                                        sprintf(TempBuff, "<text x='20' y='%d'>%d</text>\n",yy,j*maxvalue/5000); 
                                        fwrite( TempBuff, strlen(TempBuff)*sizeof(unsigned char),1,File);
                                        yy-=60;
                                }
                        }
                        else 
                        {
                                for (unsigned int j=1,yy=295; j<6;j++)
                                {
                                        float m=maxvalue;
                                        sprintf(TempBuff, "<text x='20' y='%d'>%.1f</text>\n",yy,j*m/5000); 
                                        fwrite( TempBuff, strlen(TempBuff)*sizeof(unsigned char),1,File);
                                        yy-=60;
                                }
                        } 
  
                        Svg="</g>\n";    
                        Svg+="<!-- Your SVG elements -->\n";
                        Svg+="</svg>\n";
                        fwrite( Svg.data(), strlen(Svg.data())*sizeof(unsigned char),1,File);
                        
                        CloseFile();
                }//end for
        }//end  if (CurFct)
return 1;
#else
        printf("\n_CVG_SVG_CREATE_FILES flag is not defined in definitions.h, SVG files not created...");
        return 0;
#endif

}//end  this function
#endif//_SG_TRC_SVG
};
//================================================================

};//namespace SG_TRC
#endif //__cplusplus

#if SG_TLS_MEMORY_MANAGER
        #include "SugoiTools\debug_new_off.h"
#endif 

#endif//_SG_TRC_FUNCTION_H

---