root/branches/atorf/personal playground/NXCProfiler/Profiler01.nxc @ 850

//#!C
/*
%
% Core of the NXC-Profiler!
% Declares various functions and macros to be included to NXC programs in order
% to get "live" runtime performance analysis.
%
%   see http://forums.nxtasy.org/index.php?showtopic=4496
%
%
% Signature
%   Author: Linus Atorf (see AUTHORS)
%   Date: 2009/12/07
%   Version: 0.1
%   License: GPLv3
%
%
% ***********************************************************************************************
% *  This file is part of the RWTH - Mindstorms NXT Toolbox.                                    *
% *                                                                                             *
% *  The RWTH - Mindstorms NXT Toolbox 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.        *
% *                                                                                             *
% *  The RWTH - Mindstorms NXT Toolbox 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 the           *
% *  RWTH - Mindstorms NXT Toolbox. If not, see <http://www.gnu.org/licenses/>.                 *
% ***********************************************************************************************
*/

//useful macros:
//#if __FIRMWARE_VERSION > 107
//#ifdef __ENHANCED_FIRMWARE
//__LINE__


// include-guard
#ifndef __PROFILER01_NXC__
#define __PROFILER01_NXC__



//TEST: just a personal check to see if this compiles
//#define __LOCAL_COMPILE_FAKE_TEST
//#define PROFILER_ENABLE
//#define PROFILER_MAXSECTIONS 20
//#define PROFILER_RESULTSFILE "test.prf"


//check if we do actually want to profile?
#ifndef PROFILER_ENABLE

    // these defines ensure that all "calls" to the profiler-functions
    // are ignored and a commentsign (//) is included, so that
    // PROFILER_BEGINSECTION(1);   becomes   //(1);   which is harmless
    #define PROFILER_START /##/
    #define PROFILER_BEGINSECTION /##/
    #define PROFILER_ENDSECTION /##/
    #define PROFILER_STOP /##/

#else // --- profiling enabled! -------------------------------

    // check if user has set all options properly
    #ifndef PROFILER_MAXSECTIONS
        #error "PROFILER_MAXSECTIONS is undefined. Use  #define PROFILER_MAXSECTIONS <number>  to set the number of profile sections you're using!"
    #endif

    #ifndef PROFILER_RESULTSFILE
        #error "PROFILER_RESULTSFILE is undefined. Use  #define PROFILER_RESULTSFILE ``sample.prf``  (with normal double-quotes) if your program is called ``sample.nxc``"
    #endif


    // global variables, these determine the memory usage!
    long __PROFILER_GlobalStartTick;
    long __PROFILER_ExecutionCount[PROFILER_MAXSECTIONS];
    long __PROFILER_ElapsedTicks[PROFILER_MAXSECTIONS];
    long __PROFILER_LastTick[PROFILER_MAXSECTIONS];
    long __PROFILER_ExecutionsSameMs[PROFILER_MAXSECTIONS];


    // init the whole profiling process!
    inline void PROFILER_START() {
        // not much to do, remember when we start.
        DeleteFile(PROFILER_RESULTSFILE);
        __PROFILER_GlobalStartTick = CurrentTick();
    }//end void


    // at the begin of every code section to be profiled, we have:
    inline void PROFILER_BEGINSECTION(const int &no) {
        // just remember timestamp
        __PROFILER_LastTick[no] = CurrentTick();
    }//end void
    
    
    // at the end of every code section to be profiled, collect results:
    inline void PROFILER_ENDSECTION(const int &no) {
        // expensive function :-(
        
        // count the times this section has been executed
        __PROFILER_ExecutionCount[no] =  __PROFILER_ExecutionCount[no] + 1;
        
        // record elapsed time (if possible)
        if (CurrentTick() != __PROFILER_LastTick[no]) {
            // count the number of times where no tick has happened
            __PROFILER_ExecutionsSameMs[no] = __PROFILER_ExecutionsSameMs[no] + 1;
        } else {
            // add up the ticked milliseconds -- not the best way?
            __PROFILER_ElapsedTicks[no] = __PROFILER_ElapsedTicks[no] + (CurrentTick() - __PROFILER_LastTick[no]);
        }//end if
    }//end void
    
    
    // at the very end of each profiler session, calc results and store to file
    inline void PROFILER_STOP() {
    
        // first calc total runtimes
        long TotalRunTime    = CurrentTick() - FirstTick();
        long ProfiledRunTime = CurrentTick() - __PROFILER_GlobalStartTick;

        // calc max. filesize required...
        long fileSize = 0;
        fileSize = fileSize + 3 + 1 + 2;  // Firmware Version + Enhanced flag
        fileSize = fileSize + 4 + 2;      // TotalRunTime
        fileSize = fileSize + 4 + 2;      // ProfiledRunTime
        fileSize = fileSize + 4 + 2;      // PROFILER_MAXSECTIONS
        fileSize = PROFILER_MAXSECTIONS * (3 * 4 + 2); // profiler results + linebreak
        
        // needed to make everything clean etc.
        string tmpStr1 = "";
        string tmpStr2 = "";
        string tmpStr3 = "";
        string tmpStr4 = "";
        long   tmpLong = 0;
        
        // prepare file...
        long bytesWritten = 0;
        byte fid = 0;
        CreateFile(PROFILER_RESULTSFILE, fileSize, fid);

        // start writing to file, line by line
        // firmware version
        tmpStr1 = NumToStr(__FIRMWARE_VERSION);
        tmpStr2 = SubStr(tmpStr1, 0, 3);        // truncate to 3 chars if needed
        #ifdef __ENHANCED_FIRMWARE
            tmpStr1 = StrCat(tmpStr2, "1");     // enhanced
        #else
            tmpStr1 = StrCat(tmpStr2, "0");     // standard
        #endif
        WriteLnString(fid, tmpStr1, bytesWritten);
        
        // total run time
        tmpStr1 = Flatten(TotalRunTime);
        WriteLnString(fid, tmpStr1, bytesWritten);

        // profiled run time
        tmpStr1 = Flatten(ProfiledRunTime);
        WriteLnString(fid, tmpStr1, bytesWritten);
        
        // PROFILER_MAXSECTIONS
        tmpLong = PROFILER_MAXSECTIONS;
        tmpStr1 = Flatten(tmpLong);
        WriteLnString(fid, tmpStr1, bytesWritten);
        
        // now for every profile-section 1 line
        for(int i = 0; i < PROFILER_MAXSECTIONS; i++) {
        
            // execution count, times no tick happened, elapsed ticks/ms
            tmpStr1 = Flatten(__PROFILER_ExecutionCount[i]);
            tmpStr2 = Flatten(__PROFILER_ExecutionsSameMs[i]);
            tmpStr3 = Flatten(__PROFILER_ElapsedTicks[i]);
            tmpStr4 = StrCat(tmpStr1, tmpStr2, tmpStr3);
            
            WriteLnString(fid, tmpStr4, bytesWritten);
        }//end for

        CloseFile(fid);

    }//end void


#endif






// include empty main-task so we can check if this whole file compiles
#ifdef __LOCAL_COMPILE_FAKE_TEST
    task main(){

    }//end task
#endif



#endif