D:/WorkDir/SugoiProjects/SugoiTracer/include/SugoiTracer/appli.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_APPLI_H
#define _SG_TRC_APPLI_H

#include "SugoiTracer\config.h"

#ifdef __cplusplus
        #include "SugoiTracer\timer.h"
        #include "SugoiTracer\base.h"
        #include "SugoiTracer\function.h"
        #include "SugoiTracer\class.h"
        #include <SugoiTools\cl_xml_mngr.h>
        #include <iostream>
        #include <map>          //to create map for C wrapping

namespace SG_TRC{

//EXPIMP_TEMPLATE template class DECLSPECIFIER std::vector<TTCL_FCT_TRACER *>;//see http://support.microsoft.com/kb/168958/en-us

template <typename TracerType=SG_TRC_Default_Trc_Type>
        class  TTCL_APPLI_TRACER: 
                public SGE::CL_XML_OBJ
{
public:
        typedef typename CL_FUNCT_TRC<TracerType>                       *       TplFctHdle;
        typedef typename CL_FUNCT_TRC<TracerType>                               TplFctObj;
        typedef typename CL_CLASS_TRACER<TracerType>            *       TplClassHdle;   
        typedef typename CL_CLASS_TRACER<TracerType>                    TplClassObj;

                
protected:
        bool TracingEnable;
        

public:
        SGE::CL_XML_MNGR<TplClassObj,   std::string >   * ClassManager;         
        SGE::CL_XML_MNGR<TplFctObj,             std::string >   * FunctionsManager;     
        //used for wrapping with C      ===========================
        std::map<int, CL_TEMP_TRACER<TracerType> *>             *MapTempTracer;
        std::map<int, TplFctHdle>                                               *MapFunction;
        int             MapFunctionLastID;
        int             MapTracerLastID;
        //===================================================

        TTCL_APPLI_TRACER():
                CL_XML_OBJ("benchmark"),
                TracingEnable(true)
                {
                        ClassManager            = new CL_XML_MNGR<TplClassObj   ,std::string>   (NULL,"ClassManager",           "class",        "name");
                        FunctionsManager        = new CL_XML_MNGR<TplFctObj             ,std::string>   (NULL,"FunctionManager",        "function", "name");

                        if(!MainAppliTracer)
                                MainAppliTracer = this;

                //used to enable wrappping with C library and programs
                        MapTempTracer   = new std::map<int, CL_TEMP_TRACER<TracerType> *>       ();
                        MapFunction             = new std::map<int, TplFctHdle>         ();
                        MapFunctionLastID       = 0;
                        MapTracerLastID         = 0;
                        //====================================================
                }


        ~TTCL_APPLI_TRACER(void)
        {
                delete (ClassManager);
                delete(FunctionsManager);

                //used to enable wrappping with C library and programs
                //???delete all temptracer recorded before...????
                //      delete(MapTempTracer);
                //      delete(MapFunction);
                //====================================================
        }

        void 
                Process()
        {
                cout << "Process() class\n";
                CL_XML_MNGR<TplClassObj >::iterator iClass;
                /*if (ClassManager->GetCount())
                        for (iClass = ClassManager->GetFirstIter(); iClass != ClassManager->GetLastIter(); iClass++)
                                (*iClass).second->Process();
*/
                cout <<"Process() function(s)\n";
                CL_XML_MNGR<TplFctObj>::iterator iFunct;
/*              if (FunctionsManager->GetCount())       
                        for (iFunct = FunctionsManager->GetFirstIter(); iFunct != FunctionsManager->GetLastIter(); iFunct++)
                                (*iFunct).second->Process();
*/
        }

        void 
                ClearAll()
        {       
                //clear all class
                CL_XML_MNGR<CL_CLASS_TRACER<TracerType> >::iterator iClass;
                for (iClass = ClassManager->GetFirstIter(); iClass != ClassManager->GetLastIter(); iClass++)
                        (*iClass).second->Clear();

                //clear all function
                CL_XML_MNGR<CL_FUNCT_TRC<TracerType> >::iterator iFunct;
                for (iFunct = FunctionsManager->GetFirstIter(); iFunct != FunctionsManager->GetLastIter(); iFunct++)
                        (*iFunct).second->Clear();
        }


        TplFctHdle
                AddFunct(std::string _FunctName)
        {
                return (TplFctHdle) (FunctionsManager->Add(_FunctName));
        }


        TplFctHdle
                AddFunct(std::string _FunctName, TplFctHdle _NewFct)
        {
                TplFctHdle TempFunct = (TplFctHdle)FunctionsManager->Get(_FunctName);

                if (TempFunct)
                        return TempFunct;

                //else we add it
                FunctionsManager->AddObj(_NewFct);
                return _NewFct;
        }

        static TTCL_APPLI_TRACER<TracerType> * MainAppliTracer;

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

                ClearAll();//we clear all previous records
                //Get Date
                //_XML_ROOT->SetAttribute("date",       "today");
                
                //Get Application version
                //_XML_ROOT->SetAttribute("app_version", "V0.001");     //save name
                
        #ifdef GPUCV_USE
                //load system, GPU/CPU and os version
                //_XML_ROOT
        #endif


                //list of class benched
                ClassManager->XMLLoad(_XML_ROOT);
                SG_NOTICE_LOG_C("\nClass loaded : %d\n");//,ClassManager->GetCount());

                //list of function benched
                FunctionsManager->XMLLoad(_XML_ROOT);
                SG_NOTICE_LOG_C("Function loaded : %d\n");//,FunctionsManager->GetCount());

                return _XML_ROOT;
        }

        _SG_TLS_INLINE 
                TiXmlElement* 
                        XMLSave(TiXmlElement* _XML_ROOT)
        {
                SG_Assert(_XML_ROOT, "No XML root");
                
                SG_NOTICE_LOG("XMLSave()...Start saving XML values to file\n");


                Process();
                //set Applitracer Attribute
                //date
                XMLWriteVal(_XML_ROOT, "date",  __DATE__);
                XMLWriteVal(_XML_ROOT, "time", __TIME__);
                
                //application version
                XMLWriteVal(_XML_ROOT, "app_version", "V0.001");        //save name
                
        #ifdef GPUCV_USE
                //system, save GPU/CPU and os version
        #endif
                
                //list of class benched
                SG_NOTICE_LOG_C("\nClass to save : %d\n");//,ClassManager->GetCount());
                if (ClassManager->GetCount())
                        ClassManager->XMLSave(_XML_ROOT);
                else
                        SG_NOTICE_LOG("\nNo Class record to save.");

                //list of function benched
                SG_NOTICE_LOG_C("Function to save : %d\n");//,FunctionsManager->GetCount());
                if (FunctionsManager->GetCount())
                        FunctionsManager->XMLSave(_XML_ROOT);
                else
                        SG_NOTICE_LOG("\nNo Function record to save.");

                return _XML_ROOT;
        }

#endif


int GenerateSvgFiles()
{
#if _SG_TRC_SVG
                SG_NOTICE_LOG("\nGenerating SVG files...");
       
                //clear all class
                CL_XML_MNGR<CL_CLASS_TRACER<TracerType> >::iterator iClass;
                //for (iClass = ClassManager->GetFirstIter(); iClass != ClassManager->GetLastIter(); iClass++)
                //      (*iClass).second->SaveToSVGFile();

                //clear all function
                CL_XML_MNGR<CL_FUNCT_TRC<TracerType> >::iterator iFunct;
                for (iFunct = FunctionsManager->GetFirstIter(); iFunct != FunctionsManager->GetLastIter(); iFunct++)
                        (*iFunct).second->SaveToSVGFile();
        
                printf("Done!");

        #ifdef _CVG_SVG_CONVERT_TO_PNG
                printf("\nGenerating PNG files...");
                //"/k java.exe -jar D:\\batik-1.6\\batik-rasterizer.jar -m image/png SVG\\*.svg "
                string Command = "/k java.exe -jar ";
                Command += _CVG_SVG_BATIK_RASTERIZER_PATH;
                Command += " -m image/png ";
                Command += _CVG_SVG_EXPORT_PATH;
                Command += "\\*.svg";
                ShellExecute(0,0,"cmd.exe",Command.data(),0,SW_HIDE);  
                printf("Done!");
        #endif
        return 1;
#else
                printf("\n_CVG_SVG_CREATE_FILES flag is not defined in definitions.h, SVG files not created...");
                return 0;
#endif
}


};


template <typename TracerType> 
        TTCL_APPLI_TRACER<TracerType>* 
                TTCL_APPLI_TRACER<TracerType>::MainAppliTracer = NULL;


template <typename TracerType>
TTCL_APPLI_TRACER<TracerType> * CreateMainTracer()
{       
        if (!TTCL_APPLI_TRACER<TracerType>::MainAppliTracer)
                TTCL_APPLI_TRACER<TracerType>::MainAppliTracer  = new TTCL_APPLI_TRACER<TracerType>();
        return TTCL_APPLI_TRACER<TracerType>::MainAppliTracer;
}

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

_SG_TRC_DLL_EXPORT int StartRecording(int _FctNumber, CL_TRACE_BASE_PARAMS * _Params);//used for C wrapping


#ifdef __cplusplus
extern "C"
{
#endif //__cplusplus

//===============================================================
//here is definition of C function we could use for tracking....
//see http://jeg.developpez.com/cours/cpp_to_c/
//and http://www.cprogramming.com/tutorial/stl/stlmap.html
//===============================================================
//static SG_TRC_FUNCT_BY_TIME = TTCL_APPLI_TRACER<CL_TimerVal>::MainAppliTracer->AddFunct("arDetectMarker");
//      SG_TRC_TEMP_TRACER_BY_TIME (ThisFct, TParams);

//todo
//TParams->AddInt("C", marker_num);
//CL_TRACE_BASE_PARAMS * TParams = new CL_TRACE_BASE_PARAMS("ART",std::string("_2.71"));
_SG_TRC_DLL_EXPORT bool XMLSaveBench(const char *Filename);
_SG_TRC_DLL_EXPORT bool XMLLoadBench(const char *Filename);
_SG_TRC_DLL_EXPORT int StartRecordingInt(const int _FctNumber, const char * ParamsName, const int * _intArray, const int _nbr);
_SG_TRC_DLL_EXPORT int StartRecordingChar(const int _FctNumber, const char * ParamsName, const char *_Value);
_SG_TRC_DLL_EXPORT int CreateFunction(const char * _fctName);
_SG_TRC_DLL_EXPORT int StartRecording(const int _FctNumber);
_SG_TRC_DLL_EXPORT void StopRecording(const int _TracerNumber);
_SG_TRC_DLL_EXPORT bool AddParamInt(const int _TracerNumber, const char * _Name, const int  _Value);
_SG_TRC_DLL_EXPORT bool AddParamChar(const int _TracerNumber, const char * _Name, const char * _Value);
//C functions---------------------------------------------------
#ifdef __cplusplus
}//to export this few functions to 'C'
#endif

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

};//namespace SG_TRC
#endif
#endif //_SG_TRC_APPLI_H

---