Changeset 3565 for trunk/kStuff/kProfile/prfreader.cpp.h

Timestamp:

Aug 27, 2007, 6:06:17 AM (18 years ago)

Author:

bird

Message:

Use kStuff.

File:

• trunk/kStuff/kProfile/prfreader.cpp.h (modified) (45 diffs)

trunk/kStuff/kProfile/prfreader.cpp.h

@@ -1 +1 @@
 /* $Id: $ */
 /** @file
- *
- * kProfiler Mark 2 - Reader template.
- *
- * Copyright (c) 2006 knut st. osmundsen <bird-src-spam@anduin.net.de>
- *
- *
- * This file is part of kLIBC.
- *
- * kLIBC 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.
- *
- * kLIBC is distributed in the hope that it will be useful,
+ * kProfiler Mark 2 - Reader Code Template.
+ */
+
+/*
+ * Copyright (c) 2006-2007 knut st. osmundsen <bird-src-spam@anduin.net>
+ *
+ * This file is part of kProfiler.
+ *
+ * kProfiler is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * kProfiler 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 kLIBC; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with kProfiler; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  *
  */
@@ -36 +36 @@
  * @param   pOut        Where to write error messages.
  */
-static bool KPRF_NAME(IsValid)(KPRF_TYPE(PC,HDR) pHdr, uint32_t cb, FILE *pOut)
+static bool KPRF_NAME(IsValid)(KPRF_TYPE(PC,HDR) pHdr, KU32 cb, FILE *pOut)
 {
     KPRF_TYPE(,UPTR) uMaxPtr = ~(KPRF_TYPE(,UPTR))0 - pHdr->uBasePtr;
@@ -43 +43 @@
      * Iterate the module segments.
      */
-    uint32_t off = pHdr->offModSegs;
+    KU32 off = pHdr->offModSegs;
     while (off < pHdr->offModSegs + pHdr->cbModSegs)
     {
         KPRF_TYPE(PC,MODSEG) pCur = KPRF_OFF2PTR(PC,MODSEG, off, pHdr);
-        uint32_t cbCur = KPRF_OFFSETOF(MODSEG, szPath[pCur->cchPath + 1]);
+        KU32 cbCur = KPRF_OFFSETOF(MODSEG, szPath[pCur->cchPath + 1]);
         cbCur = KPRF_ALIGN(cbCur, KPRF_SIZEOF(UPTR));
         if (cbCur + off > pHdr->offModSegs + pHdr->cbModSegs)
@@ -73 +73 @@
      */
     KPRF_TYPE(PC,FUNC) paFuncs = KPRF_OFF2PTR(PC,FUNC, pHdr->offFunctions, pHdr);
-    for (uint32_t i = 0; i < pHdr->cFunctions; i++)
+    for (KU32 i = 0; i < pHdr->cFunctions; i++)
     {
         KPRF_TYPE(PC,FUNC) pCur = &paFuncs[i];
@@ -97 +97 @@
      */
     KPRF_TYPE(PC,THREAD) paThreads = KPRF_OFF2PTR(PC,THREAD, pHdr->offThreads, pHdr);
-    for (uint32_t i = 0; i < pHdr->cThreads; i++)
+    for (KU32 i = 0; i < pHdr->cThreads; i++)
     {
         KPRF_TYPE(PC,THREAD) pCur = &paThreads[i];
@@ -148 +148 @@
             "----------------\n",
             pHdr->offModSegs, pHdr->cbModSegs, pHdr->cbMaxModSegs);
-    uint32_t off = pHdr->offModSegs;
+    KU32 off = pHdr->offModSegs;
     while (off < pHdr->offModSegs + pHdr->cbModSegs)
     {
         KPRF_TYPE(PC,MODSEG) pCur = KPRF_OFF2PTR(PC,MODSEG, off, pHdr);
-        uint32_t cbCur = KPRF_OFFSETOF(MODSEG, szPath[pCur->cchPath + 1]);
+        KU32 cbCur = KPRF_OFFSETOF(MODSEG, szPath[pCur->cchPath + 1]);
         cbCur = KPRF_ALIGN(cbCur, KPRF_SIZEOF(UPTR));
 
@@ -172 +172 @@
             pHdr->offFunctions, pHdr->cFunctions, pHdr->cMaxFunctions);
     KPRF_TYPE(PC,FUNC) paFuncs = KPRF_OFF2PTR(PC,FUNC, pHdr->offFunctions, pHdr);
-    for (uint32_t i = 0; i < pHdr->cFunctions; i++)
+    for (KU32 i = 0; i < pHdr->cFunctions; i++)
     {
         KPRF_TYPE(PC,FUNC) pCur = &paFuncs[i];
@@ -188 +188 @@
 
 #if 1
-            PRTDBGMOD pMod;
-            int rc = RTDbgModuleOpen(pModSeg->szPath, &pMod);
-            if (RT_SUCCESS(rc))
+            PKDBGMOD pMod;
+            int rc = kDbgModuleOpen(&pMod, pModSeg->szPath, NULL /* pLdrMod */);
+            if (!rc)
             {
-                RTDBGSYMBOL Sym;
-                rc = RTDbgModuleQuerySymbol(pMod, pModSeg->iSegment, (RTUINTPTR)(pCur->uEntryPtr - pModSeg->uBasePtr), &Sym);
-                if (RT_SUCCESS(rc))
+                KDBGSYMBOL Sym;
+                rc = kDbgModuleQuerySymbol(pMod, pModSeg->iSegment, pCur->uEntryPtr - pModSeg->uBasePtr, &Sym);
+                if (!rc)
                 {
                     fprintf(pOut, "  %s\n", Sym.szName);
                 }
-                RTDbgModuleClose(pMod);
+                kDbgModuleClose(pMod);
             }
 #endif
@@ -214 +214 @@
             pHdr->offThreads, pHdr->cThreads, pHdr->cMaxThreads, pHdr->cStacks, pHdr->cMaxStacks, pHdr->cMaxStackFrames);
     KPRF_TYPE(PC,THREAD) paThreads = KPRF_OFF2PTR(PC,THREAD, pHdr->offThreads, pHdr);
-    for (uint32_t i = 0; i < pHdr->cThreads; i++)
+    for (KU32 i = 0; i < pHdr->cThreads; i++)
     {
         KPRF_TYPE(PC,THREAD) pCur = &paThreads[i];
@@ -248 +248 @@
 {
     /** AVL node core. The key is the data set offset of the module segment record. */
-    AVLU32NODECORE              Core;
+    KDBGADDR                    offSegment;
+    struct KPRF_TYPE(,REPORTMODSEG) *mpLeft;    /**< AVL left branch. */
+    struct KPRF_TYPE(,REPORTMODSEG) *mpRight;   /**< AVL rigth branch. */
     /** Pointer to the next segment for the module. */
     KPRF_TYPE(P,REPORTMODSEG)   pNext;
@@ -256 +258 @@
     KPRF_TYPE(P,REPORTMOD)      pMod;
     /** The time this segment has spent on the stack.. */
-    uint64_t                    OnStackTicks;
+    KU64                        OnStackTicks;
     /** The time this segment has spent on the top of the stack.. */
-    uint64_t                    OnTopOfStackTicks;
+    KU64                        OnTopOfStackTicks;
     /** The number of profiled functions from this segment. */
-    uint32_t                    cFunctions;
+    KU32                        cFunctions;
+    KU8                         mHeight;        /**< AVL Subtree height. */
 } KPRF_TYPE(,REPORTMODSEG), *KPRF_TYPE(P,REPORTMODSEG);
 
+/* Instantiate the AVL tree code. */
+#define KAVL_CHECK_FOR_EQUAL_INSERT
+#define KAVL_MAX_STACK          32
+#define KAVL_STD_KEY_COMP
+#define mKey                    offSegment
+#define KAVLKEY                 KDBGADDR
+#define KAVLNODE                KPRF_TYPE(,REPORTMODSEG)
+#define KAVL_FN(name)           KPRF_NAME(ReportTree ## name)
+#define KAVL_TYPE(prefix,name)  KPRF_TYPE(prefix, REPORTMODESEG ## name)
+#define KAVL_INT(name)          KPRF_NAME(REPORTMODESEGINT ## name)
+#define KAVL_DECL(type)         K_DECL_INLINE(type)
+#include <k/kAvlTmpl/kAvlBase.h>
+#include <k/kAvlTmpl/kAvlDestroy.h>
+#include <k/kAvlTmpl/kAvlGet.h>
+#include <k/kAvlTmpl/kAvlUndef.h>
+
 
 /**
@@ -272 +291 @@
 {
     /** The module number. */
-    uint32_t                    iMod;
+    KU32                        iMod;
     /** Pointer to the next module in the list. */
     KPRF_TYPE(P,REPORTMOD)      pNext;
@@ -278 +297 @@
     KPRF_TYPE(P,REPORTMODSEG)   pFirstSeg;
     /** The debug module handle. */
-    PRTDBGMOD                   pDbgMod;
+    PKDBGMOD                    pDbgMod;
     /** The time this segment has spent on the stack.. */
-    uint64_t                    OnStackTicks;
+    KU64                        OnStackTicks;
     /** The time this segment has spent on the top of the stack.. */
-    uint64_t                    OnTopOfStackTicks;
+    KU64                        OnTopOfStackTicks;
     /** The number of profiled functions from this segment. */
-    uint32_t                    cFunctions;
+    KU32                        cFunctions;
 } KPRF_TYPE(,REPORTMOD), *KPRF_TYPE(P,REPORTMOD);
 
@@ -300 +319 @@
     KPRF_TYPE(P,REPORTMODSEG)   pModSeg;
     /** Pointer to the function symbol. */
-    PRTDBGSYMBOL                pSym;
+    PKDBGSYMBOL                 pSym;
     /** Pointer to the function line number. */
-    PKDBGLINE                  pLine;
+    PKDBGLINE                   pLine;
 } KPRF_TYPE(,REPORTFUNC), *KPRF_TYPE(P,REPORTFUNC);
 
@@ -499 +518 @@
 {
     /** Pointer to the data set. */
-    KPRF_TYPE(PC,HDR)   pHdr;
+    KPRF_TYPE(PC,HDR)           pHdr;
 
     /** @name Data-set item wrappers.
@@ -510 +529 @@
     KPRF_TYPE(P,REPORTMOD)      pFirstMod;
     /** The number of modules in the list. */
-    uint32_t                    cMods;
+    KU32                        cMods;
     /** The module segment tree. */
-    PAVLU32NODECORE             pModSegTree;
+    KPRF_TYPE(P,REPORTMODSEG)   pModSegTree;
     /** The number of module segments in the tree. */
-    uint32_t                    cModSegs;
+    KU32                        cModSegs;
     /** @} */
 
@@ -528 +547 @@
      * @{ */
     /** Sum of the profiled ticks. */
-    uint64_t                    ProfiledTicks;
+    KU64                        ProfiledTicks;
     /** Sum of the overhead ticks. */
-    uint64_t                    OverheadTicks;
+    KU64                        OverheadTicks;
     /** Sum of the sleep ticks. */
-    uint64_t                    SleepTicks;
+    KU64                        SleepTicks;
     /** Sum of calls performed. */
-    uint64_t                    cCalls;
+    KU64                        cCalls;
     /** @} */
 
@@ -552 +571 @@
      * Everything but the mods and modsegs is allocated in the same block as the report.
      */
-    size_t cb = KPRF_ALIGN(KPRF_SIZEOF(REPORT), 32);
-    uintptr_t offThreads = cb;
+    KSIZE cb = KPRF_ALIGN(KPRF_SIZEOF(REPORT), 32);
+    KUPTR offThreads = cb;
     cb += KPRF_ALIGN(KPRF_SIZEOF(REPORTTHREAD) * pHdr->cThreads, 32);
-    uintptr_t offFunctions = cb;
+    KUPTR offFunctions = cb;
     cb += KPRF_ALIGN(KPRF_SIZEOF(REPORTFUNC) * pHdr->cFunctions, 32);
-    uintptr_t offSortedThreads = cb;
+    KUPTR offSortedThreads = cb;
     cb += KPRF_ALIGN(sizeof(KPRF_TYPE(P,REPORTTHREAD)) * pHdr->cThreads, 32);
-    uintptr_t offSortedFunctions = cb;
+    KUPTR offSortedFunctions = cb;
     cb += KPRF_ALIGN(sizeof(KPRF_TYPE(P,REPORTFUNC)) * pHdr->cFunctions, 32);
     KPRF_TYPE(P,REPORT) pReport = (KPRF_TYPE(P,REPORT))malloc(cb);
@@ -569 +588 @@
      */
     pReport->pHdr = pHdr;
-    pReport->paThreads = (KPRF_TYPE(P,REPORTTHREAD))((uint8_t *)pReport + offThreads);
-    pReport->paFunctions = (KPRF_TYPE(P,REPORTFUNC))((uint8_t *)pReport + offFunctions);
+    pReport->paThreads = (KPRF_TYPE(P,REPORTTHREAD))((KU8 *)pReport + offThreads);
+    pReport->paFunctions = (KPRF_TYPE(P,REPORTFUNC))((KU8 *)pReport + offFunctions);
     pReport->pFirstMod = NULL;
     pReport->cMods = 0;
     pReport->pModSegTree = NULL;
     pReport->cModSegs = 0;
-    pReport->papSortedThreads = (KPRF_TYPE(P,REPORTTHREAD) *)((uint8_t *)pReport + offSortedThreads);
-    pReport->papSortedFunctions = (KPRF_TYPE(P,REPORTFUNC) *)((uint8_t *)pReport + offSortedFunctions);
+    pReport->papSortedThreads = (KPRF_TYPE(P,REPORTTHREAD) *)((KU8 *)pReport + offSortedThreads);
+    pReport->papSortedFunctions = (KPRF_TYPE(P,REPORTFUNC) *)((KU8 *)pReport + offSortedFunctions);
     pReport->ProfiledTicks = 0;
     pReport->OverheadTicks = 0;
@@ -593 +612 @@
  * @param   pvParam     User parameter, ignored.
  */
-static DECLCALLBACK(int) KPRF_NAME(DeleteModSeg)(PAVLU32NODECORE pCore, void *pvParam)
+static int KPRF_NAME(DeleteModSeg)(KPRF_TYPE(P,REPORTMODSEG) pCore, void *pvParam)
 {
     free(pCore);
@@ -614 +633 @@
         KPRF_TYPE(P,REPORTMOD) pFree = pReport->pFirstMod;
         pReport->pFirstMod = pFree->pNext;
-        RTDbgModuleClose(pFree->pDbgMod);
+        kDbgModuleClose(pFree->pDbgMod);
         free(pFree);
     }
 
-    RTAvlU32Destroy(&pReport->pModSegTree, KPRF_NAME(DeleteModSeg), NULL);
+    KPRF_NAME(ReportTreeDestroy)(&pReport->pModSegTree, KPRF_NAME(DeleteModSeg), NULL);
 
     /*
      * The function debug info.
      */
-    uint32_t i = pReport->pHdr->cFunctions;
+    KU32 i = pReport->pHdr->cFunctions;
     while (i-- > 0)
     {
-        RTDbgSymbolFree(pReport->paFunctions[i].pSym);
-        RTDbgLineFree(pReport->paFunctions[i].pLine);
+        kDbgSymbolFree(pReport->paFunctions[i].pSym);
+        kDbgLineFree(pReport->paFunctions[i].pLine);
     }
 
@@ -645 +664 @@
  * @param   pReport     The report to work on.
  */
-static int KPRF_NAME(AnalyseModSegs)(KPRF_TYPE(P,REPORT) pReport)
-{
-    const uint32_t offEnd = pReport->pHdr->offModSegs + pReport->pHdr->cbModSegs;
-    uint32_t off = pReport->pHdr->offModSegs;
+static int KPRF_NAME(AnalyzeModSegs)(KPRF_TYPE(P,REPORT) pReport)
+{
+    const KU32 offEnd = pReport->pHdr->offModSegs + pReport->pHdr->cbModSegs;
+    KU32 off = pReport->pHdr->offModSegs;
     while (off < offEnd)
     {
         KPRF_TYPE(PC,MODSEG) pCur = KPRF_OFF2PTR(PC,MODSEG, off, pReport->pHdr);
-        uint32_t cbCur = KPRF_OFFSETOF(MODSEG, szPath[pCur->cchPath + 1]);
+        KU32 cbCur = KPRF_OFFSETOF(MODSEG, szPath[pCur->cchPath + 1]);
         cbCur = KPRF_ALIGN(cbCur, KPRF_SIZEOF(UPTR));
 
@@ -662 +681 @@
             return -1;
 
-        pSeg->Core.Key = off;
+        pSeg->offSegment = off;
         pSeg->pModSeg = pCur;
         pSeg->pMod = NULL; /* below */
@@ -669 +688 @@
         pSeg->cFunctions = 0;
 
-        if (!RTAvlU32Insert(&pReport->pModSegTree, &pSeg->Core))
+        if (!KPRF_NAME(ReportTreeInsert)(&pReport->pModSegTree, pSeg))
         {
             free(pSeg);
@@ -707 +726 @@
             pMod->cFunctions = 0;
 
-            int rc = RTDbgModuleOpen(pSeg->pModSeg->szPath, &pMod->pDbgMod);
-            if (RT_FAILURE(rc))
+            int rc = kDbgModuleOpen(&pMod->pDbgMod, pSeg->pModSeg->szPath, NULL /* kLdrMod */);
+            if (rc)
                 pMod->pDbgMod = NULL;
         }
@@ -729 +748 @@
 static int KPRF_NAME(AnalyseFunctions)(KPRF_TYPE(P,REPORT) pReport)
 {
-    uint32_t iFunc = pReport->pHdr->cFunctions;
+    KU32 iFunc = pReport->pHdr->cFunctions;
     KPRF_TYPE(PC,FUNC) pFunc = KPRF_OFF2PTR(PC,FUNC, pReport->pHdr->offFunctions + iFunc * sizeof(*pFunc), pReport->pHdr);
     KPRF_TYPE(P,REPORTFUNC) pReportFunc = &pReport->paFunctions[iFunc];
@@ -739 +758 @@
         pReport->papSortedFunctions[iFunc] = pReportFunc;
         pReportFunc->pFunc = pFunc;
-        pReportFunc->pModSeg = (KPRF_TYPE(P,REPORTMODSEG))RTAvlU32Get(&pReport->pModSegTree, pFunc->offModSeg);
+        pReportFunc->pModSeg = KPRF_NAME(ReportTreeGet)(&pReport->pModSegTree, pFunc->offModSeg);
         pReportFunc->pSym = NULL;
         pReportFunc->pLine = NULL;
@@ -756 +775 @@
 
             /* Get debug info. */
-            RTUINTPTR offSegment = (RTUINTPTR)(pFunc->uEntryPtr - pModSeg->pModSeg->uBasePtr);
-            int rc = RTDbgModuleQuerySymbolA(pMod->pDbgMod, pModSeg->pModSeg->iSegment, offSegment, &pReportFunc->pSym);
+            KDBGADDR offSegment = pFunc->uEntryPtr - pModSeg->pModSeg->uBasePtr;
+            int rc = kDbgModuleQuerySymbolA(pMod->pDbgMod, pModSeg->pModSeg->iSegment, offSegment, &pReportFunc->pSym);
             /** @todo check displacement! */
-            if (RT_FAILURE(rc))
+            if (rc)
                 pReportFunc->pSym = NULL;
-            rc = RTDbgModuleQueryLineA(pMod->pDbgMod, pModSeg->pModSeg->iSegment, offSegment, &pReportFunc->pLine);
-            if (RT_FAILURE(rc))
+            rc = kDbgModuleQueryLineA(pMod->pDbgMod, pModSeg->pModSeg->iSegment, offSegment, &pReportFunc->pLine);
+            if (rc)
                 pReportFunc->pLine = NULL;
         }
@@ -779 +798 @@
 static int KPRF_NAME(AnalyseThreads)(KPRF_TYPE(P,REPORT) pReport)
 {
-    uint32_t iThread = pReport->pHdr->cThreads;
+    KU32 iThread = pReport->pHdr->cThreads;
     KPRF_TYPE(PC,THREAD) pThread = KPRF_OFF2PTR(PC,THREAD, pReport->pHdr->offThreads + iThread * sizeof(*pThread), pReport->pHdr);
     KPRF_TYPE(P,REPORTTHREAD) pReportThread = &pReport->paThreads[iThread];
@@ -820 +839 @@
 
     /* read module segments */
-    int rc = KPRF_NAME(AnalyseModSegs)(pReport);
+    int rc = KPRF_NAME(AnalyzeModSegs)(pReport);
     if (!rc)
     {
@@ -846 +865 @@
  * @internal
  */
-static void KPRF_NAME(HtmlWriteRowU32X32)(FILE *pOut, const char *pszName, uint32_t u32, const char *pszUnit)
+static void KPRF_NAME(HtmlWriteRowU32X32)(FILE *pOut, const char *pszName, KU32 u32, const char *pszUnit)
 {
     fprintf(pOut,
@@ -862 +881 @@
  * @internal
  */
-static void KPRF_NAME(HtmlWriteRowU32)(FILE *pOut, const char *pszName, uint32_t u32, const char *pszUnit)
+static void KPRF_NAME(HtmlWriteRowU32)(FILE *pOut, const char *pszName, KU32 u32, const char *pszUnit)
 {
     fprintf(pOut,
@@ -878 +897 @@
  * @internal
  */
-static void KPRF_NAME(HtmlWriteRowU64)(FILE *pOut, const char *pszName, uint64_t u64, const char *pszUnit)
+static void KPRF_NAME(HtmlWriteRowU64)(FILE *pOut, const char *pszName, KU64 u64, const char *pszUnit)
 {
     fprintf(pOut,
@@ -894 +913 @@
  * @internal
  */
-static void KPRF_NAME(HtmlWriteRowX64)(FILE *pOut, const char *pszName, uint64_t u64, const char *pszUnit)
+static void KPRF_NAME(HtmlWriteRowX64)(FILE *pOut, const char *pszName, KU64 u64, const char *pszUnit)
 {
     fprintf(pOut,
@@ -909 +928 @@
  * Writes a ticks.
  */
-static void KPRF_NAME(HtmlWriteParts)(FILE *pOut, uint64_t cTicks, uint64_t cTotalTicks)
+static void KPRF_NAME(HtmlWriteParts)(FILE *pOut, KU64 cTicks, KU64 cTotalTicks)
 {
     /** U+2030 PER MILLE SIGN */
-    static const uint8_t s_szPerMilleSignUtf8[4] = { 0xe2, 0x80, 0xb0, 0};
+    static const KU8 s_szPerMilleSignUtf8[4] = { 0xe2, 0x80, 0xb0, 0};
 
     if (cTicks * 100 / cTotalTicks)
     {
-        uint32_t u = (uint32_t)((cTicks * 1000) / cTotalTicks);
+        KU32 u = (KU32)((cTicks * 1000) / cTotalTicks);
         fprintf(pOut, "%u.%01u%%", u / 10, u %10);
     }
     else //if (cTicks * 100000 / cTotalTicks)
     {
-        uint32_t u = (uint32_t)((cTicks * 100000) / cTotalTicks);
+        KU32 u = (KU32)((cTicks * 100000) / cTotalTicks);
         fprintf(pOut, "%u.%02u%s", u / 100, u % 100, s_szPerMilleSignUtf8);
     }
@@ -936 +955 @@
  * Writes a ticks.
  */
-static void KPRF_NAME(HtmlWriteTicks)(FILE *pOut, uint64_t cTicks, uint64_t cTotalTicks)
+static void KPRF_NAME(HtmlWriteTicks)(FILE *pOut, KU64 cTicks, KU64 cTotalTicks)
 {
     fprintf(pOut, "%" KPRF_FMT_U64 "", cTicks);
@@ -956 +975 @@
  * @internal
  */
-static void KPRF_NAME(HtmlWriteRowTicks)(FILE *pOut, const char *pszName, uint64_t cTicks, uint64_t cTotalTicks)
+static void KPRF_NAME(HtmlWriteRowTicks)(FILE *pOut, const char *pszName, KU64 cTicks, KU64 cTotalTicks)
 {
     fprintf(pOut,
@@ -980 +999 @@
  * @internal
  */
-static void KPRF_NAME(HtmlWriteRowTimeStat)(FILE *pOut, const char *pszName, KPRF_TYPE(PC,TIMESTAT) pTimeStat, uint64_t cTotalTicks)
+static void KPRF_NAME(HtmlWriteRowTimeStat)(FILE *pOut, const char *pszName, KPRF_TYPE(PC,TIMESTAT) pTimeStat, KU64 cTotalTicks)
 {
     fprintf(pOut,
@@ -1008 +1027 @@
  * @internal
  */
-static void KPRF_NAME(HtmlWriteRowCalls)(FILE *pOut, const char *pszName, uint64_t cCalls, uint64_t cTotalCalls)
+static void KPRF_NAME(HtmlWriteRowCalls)(FILE *pOut, const char *pszName, KU64 cCalls, KU64 cTotalCalls)
 {
     fprintf(pOut,
@@ -1123 +1142 @@
             "  </tr>\n");
 
-    for (uint32_t iFunc = 0; iFunc < pReport->pHdr->cFunctions; iFunc++)
+    for (KU32 iFunc = 0; iFunc < pReport->pHdr->cFunctions; iFunc++)
     {
         KPRF_TYPE(P,REPORTFUNC) pReportFunc = pReport->papSortedFunctions[iFunc];
@@ -1243 +1262 @@
             "<head>\n"
             "  <meta http-equiv=\"Content-Type\" content=\"text/html;charset=utf-8\">\n"
-            "  <title>kProfile 2 - %s</title>\n"
+            "  <title>kProfiler 2 - %s</title>\n"
             "</head>\n"
             "<style>\n"
@@ -1396 +1415 @@
     KPRF_NAME(HtmlWriteRowCalls)(pOut, "Recorded Calls", pReport->cCalls, pReport->cCalls);
     fprintf(pOut, "<tr><td class=\"BlankRow\" colspan=7>&nbsp;</td></tr>\n");
-    KPRF_NAME(HtmlWriteRowString)(pOut, "kProfile Version ", NULL, "Mark 2 Alpha 1");
-    KPRF_NAME(HtmlWriteRowString)(pOut, "kProfile Build Time ", NULL, __DATE__ " " __TIME__);
+    KPRF_NAME(HtmlWriteRowString)(pOut, "kProfiler Version ", NULL, "Mark 2 Alpha 1");
+    KPRF_NAME(HtmlWriteRowString)(pOut, "kProfiler Build Time ", NULL, __DATE__ " " __TIME__);
     fprintf(pOut,
             "</table>\n"
@@ -1440 +1459 @@
             "<p>\n"
             "<table class=\"Functions\">\n");
-    for (uint32_t iFunc = 0; iFunc < pHdr->cFunctions; iFunc++)
+    for (KU32 iFunc = 0; iFunc < pHdr->cFunctions; iFunc++)
     {
         KPRF_TYPE(P,REPORTFUNC) pReportFunc = &pReport->paFunctions[iFunc];
@@ -1486 +1505 @@
             "<table class=\"Threads\">\n");
 
-    for (uint32_t iThread = 0; iThread < pHdr->cThreads; iThread++)
+    for (KU32 iThread = 0; iThread < pHdr->cThreads; iThread++)
     {
         KPRF_TYPE(PC,THREAD) pThread = pReport->paThreads[iThread].pThread;
@@ -1527 +1546 @@
 
     KPRF_TYPE(P,REPORTMOD) pMod = pReport->pFirstMod;
-    uint32_t iMod = 0;
+    KU32 iMod = 0;
     while (pMod)
     {