trace.cpp

一个基于windows mobile 的GPS 接受IC 驱动程序。

    if (closeTrace)
    {
        tracePause = true;
    }
    traceResumeCounter = traceCounter;
#endif              // }  _TRACE_BODY_
}

//------------------------------------------------------------------------------
//
//      traceResume()
//
//------------------------------------------------------------------------------

void traceResume()
{
    tracePause = false;
    traceResumeCounter = traceCounter;
}

//------------------------------------------------------------------------------
//
//      traceInit()
//
//------------------------------------------------------------------------------

void traceInit()
{
    traceCounter = 0;
    traceResumeCounter = 0;
    tracePrev    = 0;
#ifdef  _TRACE_BODY_        // {
    traceCur     = traceArray;
    traceEnd     = traceCur + MAX_TRACES;
#endif  // } _TRACE_BODY_        
    traceRepeat  = 0;
    tracePause   = false;
    dummyTimer   = 0;

    totalReads     = 0;
    totalReadBytes = 0;
    totalReadBytes = 0;
    totalReadTime  = 0;
    totalWrites    = 0;
    totalWriteTime = 0;

    totalInterrupts = 0;
    totalIntAck     = 0;
    totalIntAckReal = 0;
}

//------------------------------------------------------------------------------
//
//      traceTime()
//
//------------------------------------------------------------------------------

void
traceTime(unsigned short line)
{
    traceSave(line, TR_TIME, GetTickCount());
}

//------------------------------------------------------------------------------
//
//      traceSave()
//
//------------------------------------------------------------------------------

void
traceSave(unsigned short line, char cmd, DWORD val)
{
    // GL_PRINT((MSG("traceSave(%lu %lu %d %8x)\n\r"), *pGpsTimer, line, cmd, val));
    switch (cmd)
    {
    case TR_STATS_READ:
        ++totalReads;
        totalReadBytes += line;
        totalReadTime  += val;
        break;

    case TR_STATS_WRITE:
        ++totalWrites;
        totalWriteBytes += line;
        totalWriteTime  += val;
        break;

    case TR_INT_ACK:
        ++totalIntAck;
        if (val) ++totalIntAckReal;
        break;
    }

#ifdef  _TRACE_BODY_        // {

    if (!traceCur || tracePause) return;

    ++dummyTimer;

    if (traceCur->isr)
    {
        TraceStruct* pTmp = traceCur;
        int isr   = pTmp->isr;
        pTmp->isr = 0;      // temporarily clear the ISR.

        //  There was an ISR some time in the recent past (at time
        //  traceIsrTime, we think), so save the time.
        traceSave(isr, TR_ISR, GetTickCount());

        pTmp->isr = isr;    // get past the ISR so we don't recurse.
    }

    TraceStruct* p = traceNext(traceCur);

    //  tenative save:  to commit a save requires us to save
    //  p into traceCur and increment traceCounter.

    //  The ISR happened at "traceIsrTime"; not right now.
    p->time = (cmd == TR_ISR) ? traceIsrTime : *pGpsTimer;
    p->line = line;
    p->cmd  = cmd;
    p->isr  = 0;
    p->val  = val;

    //  We commit the trace right away if:
    //  a)  No previous trace to compare to.
    //  b)  The trace is a "REPEAT" indicator.
    if (!tracePrev || (cmd == TR_REPEAT))
    {
        goto COMMIT_TRACE_SAVE;
    }

    if (*p == *tracePrev)
    {
        ++traceRepeat;      // repeat - don't commit the save.
        return;
    }

    // This is a new trace, so see if we need to put in a "REPEAT".
    if (traceRepeat)
    {
        traceSave(traceRepeat,TR_REPEAT,cmd);
        traceRepeat = 0;
        tracePrev   = 0;

        //  Since we put in a repeat, need to save this new one.
        traceSave(line,cmd,val);
        return;
    }

COMMIT_TRACE_SAVE:
    ++traceCounter;
    tracePrev = p;
    traceCur  = p;

    if (TR_SW == cmd)
    {
        //  software traces save the time automatically.
        traceTime(line);
    }
#endif              // }  _TRACE_BODY_
}

//------------------------------------------------------------------------------
//
//      traceIsr()
//
//  OR in some flags into the ISR field.
//  This RWM is not protected.
//  It is needed because these light-weight traces
//  are not protected by mutual-exclusion locks.
//
//------------------------------------------------------------------------------

void traceIsr(int isr, DWORD time)
{
    if (isr == 1)               // ISR_OCCURRED.
    {
        ++totalInterrupts;
    }
    GL_PRINT((MSG("traceIsr(%d)\n\r"), isr));
    if (!traceCur || tracePause) return;
    traceCur->isr |= isr;
    traceIsrTime   = time;
}

//------------------------------------------------------------------------------
//
//      traceCopy()
//
//  Copy the trace to the caller's buffer.
//
//  Special kludge note for this trace:
//
//  Field   Normal Usage        Special Usage
//  time    number of ticks     tick clock frequency
//  line    __LINE__            [ maj << 8 ] | minor
//  cmd     Type of trace       TR_TRACE
//  isr     bitmask for ISR     bPauseTemp
//  val     application value   traceCounter
//
//------------------------------------------------------------------------------

DWORD traceCopy(PBYTE pBufOut, DWORD dwLenOut, int maj, int min)
{
    if (!traceCur)
    {
        return 0;
    }

#ifdef  _TRACE_BODY_        // {

    TraceStruct* p  = traceNext(traceCur);
    int nTraces1    = traceEnd - p;
    int nTraces2    = traceCur - traceArray;
    if (traceCounter <= MAX_TRACES)
    {
        // Special case - not-filled traceArray[]
        p = traceArray + 1; // skip the first one (due to the pre-
                                // increment in the traceSave().
        nTraces2 = 0;
    }
    DWORD totalSize = (1 + nTraces1 + nTraces2) * sizeof(TraceStruct);
    if (totalSize > dwLenOut)
    {
        return 0;           // refuse to copy partial buffers.
    }

    //  Special first entry:

    TraceStruct t;
    t.time = 3250000;                   // 3.25 MHz
    t.line = (maj << 8) | min;
    t.cmd  = TR_TRACE;
    t.isr  = tracePause;
    t.val  = traceCounter;

    memcpy(pBufOut, &t, sizeof(TraceStruct));
    pBufOut += sizeof(TraceStruct);

    if (nTraces1)
    {
        memcpy(pBufOut, p, nTraces1 * sizeof(TraceStruct));
        pBufOut += nTraces1 * sizeof(TraceStruct);
    }
    if (nTraces2)
    {
        memcpy(pBufOut, traceArray, nTraces2 * sizeof(TraceStruct));
    }
#else
    
    DWORD totalSize = 0;

#endif              // }  _TRACE_BODY_

    return totalSize;
}

//------------------------------------------------------------------------------
//
//      traceParamSet()
//
//  Here is the opportunity to contol the tracing.
//
//------------------------------------------------------------------------------

void
traceParamSet(const PBYTE pBufIn, DWORD dwLenIn)
{
}

#endif // }

//----------------------------------------------------------------------------
//
//      glFormatTime()
//
//----------------------------------------------------------------------------

const TCHAR* 
glFormatTime(void)
{
    static TCHAR timeString[80];

    SYSTEMTIME t;
    GetLocalTime(&t);

    wsprintf(timeString, _T("%02d/%02d/%02d %02d:%02d:%02d"),
                        t.wMonth, t.wDay,    t.wYear % 100, 
                        t.wHour,  t.wMinute, t.wSecond);
    return timeString;
}

//----------------------------------------------------------------------------
//
//      glReportTime()
//
//----------------------------------------------------------------------------

void glReportTime(void)
{
    NKDbgPrintfW(TEXT("%s %lu %lu "), glFormatTime(), GetTickCount(), *pGpsTimer);
}