• Download CFInRT_used_for_actual_measurements.exe.
  
• Download RTCF.exe.
  
• Download Win32CEAppInRT.exe.

// This is the function GetTimingInfo that exists in the
// unmanaged Win32 DLL. The function is fed with information,
// originating in an Interrupt Service Thread in the same 
// DLL. On request of the managed application, timing 
// information is copied using a double buffering mechanism.
RTCF_API DWORD GetTimingInfo(LPDWORD lpdwAvgPerfTicks,
    LPDWORD lpdwMax,
    LPDWORD lpdwMin,
    LPDWORD lpdwDeltaMax,
    LPDWORD lpdwDeltaMin)
{
    g_bRequestData = TRUE;
    if (WaitForSingleObject(g_hNewDataEvent,
        1000)==WAIT_OBJECT_0)
    {
        *lpdwAvgPerfTicks = g_dwBufferedAvgPerfTicks;
        *lpdwMax = g_dwBufferedMax;
        *lpdwMin = g_dwBufferedMin;
        *lpdwDeltaMax = g_dwBufferedDeltaMax;
        *lpdwDeltaMin = g_dwBufferedDeltaMin;
        return 1;
    }
    else
        return 0;
}

// GetTimingInfo prototype
#ifdef RTCF_EXPORTS
#define RTCF_API __declspec(dllexport)
#else
#define RTCF_API __declspec(dllimport)
#endif

extern "C"
{
    RTCF_API BOOL Init();
    RTCF_API BOOL DeInit();
    RTCF_API DWORD GetTimingInfo(LPDWORD lpdwAvgPerfTicks,
        LPDWORD lpdwMax,
        LPDWORD lpdwMin,
        LPDWORD lpdwDeltaMax,
        LPDWORD lpdwDeltaMin);
}

// Wrapper class to be able to P/Invoke into a DLL.
// Exported functions in the DLL are imported by this
// wrapper. Note the use of compiler attributes to identify
// the physical DLL that hosts the exported functions.
using System;
using System.Runtime.InteropServices;

namespace CFinRT
{
    public class WCEThreadIntf
    {
        [DllImport("RTCF.dll")]
        public static extern bool Init();
        [DllImport("RTCF.dll")]
        public static extern bool DeInit();
        [DllImport("RTCF.Dll")]
        public static extern uint GetTimingInfo(
            ref uint perfAvg,
            ref uint perfMax,
            ref uint perfMin,
            ref uint perfTickMax,
            ref uint perfTickMin);
    }
}

// Call an unmanaged function from within managed code 
public void CollectValue() 
{
    if (WCEThreadIntf.GetTimingInfo(ref aveSleepTime,
        ref maxSleepTime,
        ref minSleepTime,
        ref curMaxSleepTime,
        ref curMinSleepTime) != 0) 
    {
        curMaxSleepTime = (uint)(float)((curMaxSleepTime *
            scaleValue) / 1.19318);
        curMinSleepTime = (uint)(float)((curMinSleepTime *
            scaleValue) / 1.19318);
        aveSleepTime = (uint)(float)((aveSleepTime *
            scaleValue) / 1.19318);
        maxSleepTime = (uint)(float)((maxSleepTime *
            scaleValue) / 1.19318);
        minSleepTime = (uint)(float)((minSleepTime *
            scaleValue) / 1.19318);
    } 

    StoreValue();
    counter = (counter + 1) % samplesInMinute;
}

Figure 1. Real-time scenario using both managed and unmanaged code

RTCF_API BOOL Init()
{
    BOOL bRet = FALSE;
    DWORD dwIRQ = IRQ;    // in our case IRQ = 5

    // Get a SysIntr for the specified IRQ   
    if (KernelIoControl(IOCTL_HAL_TRANSLATE_IRQ,
        &dwIRQ,
        sizeof(DWORD),
        &g_dwSysIntr,
        sizeof(DWORD),
        NULL))
    {
        // create an event that will activate our IST
        g_hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);

        if (g_hEvent)
        {
            // Connect the interrupt to our event and
            // create our Interrupt Service Thread.
            // The actual IST is shown in listing 4
            InterruptDisable(g_dwSysIntr);

            if (InterruptInitialize(g_dwSysIntr,
                g_hEvent, NULL, 0))
            {
                g_bFinish = FALSE;
                g_hThread = CreateThread(NULL,
                    0,
                    IST,
                    NULL,
                    0,
                    NULL);
                if (g_hThread)
                {
                    bRet = TRUE;
                }
                else
                {
                    InterruptDisable(g_dwSysIntr);
                    CloseHandle(g_hEvent);
                    g_hEvent = NULL;
                }
            }
        }
    }
    return bRet;
}

Interrupt Service Thread:
Wait
On IRQ 5 send probe pulse to the parallel port
Measure time with QueryPerformanceCounter
Store measured time (min, max, current, average) locally
if (userInterfaceRequestsData) {
    copy measured time information
    reset statistic measure values
    set dataReady event
    userInterfaceRequestsData = false
}  

disable timer     // See pitfalls
call with P/Invoke into the DLL
// The following code is implemented in the DLL
userInterfaceRequestsData = true
wait for dataReady event
return measured values
draw measured values on the display, each time using new graphics objects
update marker    // A running vertical bar on the display
enable timer

Figure 2. Managed application: IRQ. IST latency

Figure 3. Managed application: IST activation times after running 10 minutes

// Our periodic timer method in which we want to collect new
// data and refresh the screen
private void OnTimer(object source) 
{
    // Temporarily stop the timer, to prevent against
    // a whole bunch of OnTimer calls to be invoked
    if (theTimer != null) 
    {
        theTimer.Change(Timeout.Infinite, dp.Interval);
    }
    Pen blackPen = new Pen(Color.Black);
    Pen yellowPen = new Pen(Color.Yellow);
    Graphics gfx = CreateGraphics();

    td.SetTimePointer(dp.CurrentSample, gfx, blackPen);

    for (int i = 0; i < dp.SamplesPerMeasure; i++) 
    {
        td.ShowValue(dp.CurrentSample, dp[i], gfx, i);
    }

    dp.CollectValue();
    td.SetTimePointer(dp.CurrentSample, gfx, yellowPen);

    gfx.Dispose();
    yellowPen.Dispose();
    blackPen.Dispose();

    // Restart the timer again for the next update
    if (theTimer != null) 
    {
        theTimer.Change(dp.Interval, dp.Interval);
    }
}

Table 1. .NET Compact Framework performance results after running the test for five minutes

Table 2. .NET Compact Framework performance results after running the test for 100 minutes

Figure 4. Managed application: IST activation times after running 100 minutes

Figure 5. Remote process viewer showing the managed application

Figure 6. Win32 application: IST activation times after running 10 minutes

Figure 7. Win32 application: IST activation times after running 10 minutes