src/common/profiler.cpp

Idź do dokumentacji tego pliku.

/***********************************************************
*PANALIX 0.06, (c) Adrian Panasiuk 2002-4                  *
*adek336[at]o2.pl, panalix.prv.pl                          *
*under GPLv3 license                                       *
*                                                          *
*panalix - small osdev project                             *
************************************************************
*       profiler.cpp, version 1.0                          *
************************************************************
*                                                          *
*The profiler, for debuging's sake- tells the time a       *
*function is ran on average, call count, etc.              *
*                                                          *
*29'08'04- first revision (1.0)                            *
*                                                          *
***********************************************************/

#include "src/common/shared.hpp"
#include "src/common/qsort.hpp"
#include "src/memory/memset.hpp"
#include "src/memory/align.hpp"
#include "src/memory/heap.hpp"
#include "src/common/profiler.hpp"

namespace Debug {
namespace Profiler {

#ifdef PROFILER_ENABLE
uint32 ProfilerCount= 0;
struct profiling_s ProfilerBuf[MAX_PROFILER];

inline uint32 strlen(char *ch)
 {
char *c2=ch;
        while ( *c2 ) c2++;
        return (uint32)(c2-ch);
 }

/*benchmark- so we know how much overhead is added by the profiling macros*/
int voidnull()
 { _Pf("voidnull");
        preturn(42); }

void stats(bool SortBySlowest)
 {_Pf("Profiler::Stats");
        voidnull();
uint32 i;
struct profiling_s *pf,*pBase;
uint32 SavedProfilerCount;
// Are we supposed to sort the list at first? If yes, the slowest functions will be displayed at the end of
// the results.
        SavedProfilerCount= ProfilerCount;
        if (SortBySlowest)
         {
        // copy the buffer temporarily
                pBase= pf=(struct profiling_s*) Memory::Heap::heap0.malloc(SavedProfilerCount*sizeof(struct profiling_s), NO_ALIGN, "ProfilerBuffer", NULL);
                memmove(pBase, ProfilerBuf, SavedProfilerCount*sizeof(struct profiling_s));
        // sort it
                qsort(pBase, SavedProfilerCount, sizeof(struct profiling_s), &ProfilingCompar, NULL);
         } else pf= ProfilerBuf;

        cout(const_cast<char*>("\n>>>>>>>>\n\tDebuf::Profiler::stats()\n"));
        cout(const_cast<char*>("Name\t\t\t   Time\t\t\t\t  Calls\t\t Active\t\tAvrgCallTime\n"));
        for (i=0;i<SavedProfilerCount;i++)
         {
        uint32 n=0;
                if (pf->Name) { n=strlen(pf->Name); cout(pf->Name); }
                        else cout(const_cast<char*>("\t\t"));
                n= MIN(19,n);
                while (19 - (n++)) cout(const_cast<char*>(" "));
                if (pf->Time>>32)
                        coutnum(active_console, (uint32)(pf->Time>>32), 16, 0x10000000, 'A', '-');
                else cout(const_cast<char*>("--------"));
//              cout((uint32)(pf->Time>>32));
                coutnum(active_console, (uint32)pf->Time&0xffffffff, 16, 0x10000000, 'A', '-');
//              cout((uint32)pf->Time&0xffffffff);
                cout(const_cast<char*>("\t  "));
                coutnum(active_console, pf->Calls, 16, 0x10000000, 'A', '-');
//              cout(pf->Calls);
                cout(const_cast<char*>("\t "));
                coutnum(active_console, pf->Active, 16, 0x10000000, 'A', '-');
//              cout(pf->Active);
                cout(const_cast<char*>("\t"));
                if (pf->Calls==0) cout(const_cast<char*>("---------Unkn.--"));
                        else {
                        if ((uint32)((pf->Time/pf->Calls)>>32))
                                coutnum(active_console, (uint32)((pf->Time/pf->Calls)>>32), 16, 0x10000000, 'A', '-');
                        else cout(const_cast<char*>("--------"));
//                      cout((uint32)((pf->Time/pf->Calls)>>32));
                        coutnum(active_console,(uint32)(pf->Time/pf->Calls)&0xffffffff, 16, 0x10000000, 'A', '-'); }
//                      cout((uint32)(pf->Time/pf->Calls)&0xffffffff); }
                cout(const_cast<char*>("\n"));
                pf++;
         }

        if (pBase)
                Memory::Heap::heap0.free(pBase);
        Preturn();
 }

//compare two profiling data structs
int ProfilingCompar(const void *A,const void *B)
 {
struct profiling_s *a=(struct profiling_s*)A ,*b=(struct profiling_s*)B;
uint64 a1, b1;
// zero?
        if (a->Calls == 0) return -1;
        if (b->Calls == 0) return 1;

        a1= a->Time/a->Calls;b1= b->Time/b->Calls;
        if (a1>b1) return 1;
        if (a1==b1) return 0;
        return -1;
 }

#endif  /*PROFILER_ENABLE*/

  };    /*namespace Profiler*/
 };     /*namespace Debug*/

/***********************************************************
*                                                          *
*panalix 0.06 (c) Adrian Panasiuk 2002-4                   *
*adek336[at]o2.pl, panalix.prv.pl                          *
*                                                          *
***********************************************************/

---