xsharp.eu

Code: Select all

function T() as void strict
    local mystruct is myint64
    local f as float 
    mystruct.r8 := GetTickCount64()
    ?
    // in a float you could loose data, because e.g. float is signed.
    f := mystruct.ul.LowPart * 1.0 + mystruct.ul.HighPart * 0xFFFFFFFFU
    ? Str(f,-1,0)
    // the raw data, without loss.
    ? mystruct.ul.HighPart , mystruct.ul.LowPart

    return

function Start()
    ? "Hello World"
    do while true
        T()
        // the pause is not exact, so the interval is not exact either
        Sleep(100)
    end
    WAIT
    return nil

_dll function GetTickCount64() as real8 pascal:Kernel32.GetTickCount64
    // returns 8 bytes
    // _winULARGE_INTEGER

union myint64
    member r8 as real8
    member ul is _winULARGE_INTEGER

Code: Select all

class StopWatch3
    protect StartMoment_high as longint
    protect StartMoment_Low as dword
    protect Frequency as dword
    
    declare method Start
    declare method Stop
    
method Init() class StopWatch3
    // frequency added to make the recorded time comparable independend of the hardware etc.
    local frequency_high := GetQueryPerformanceFrequencyHigh() as longint
    self:Frequency := GetQueryPerformanceFrequencyLow()
    if frequency_high != 0
        _DebOut32(String2Psz("GetQueryPerformanceFrequencyHigh() != 0! (" + NTrim(frequency_high) + ")"))
    endif
    
    return self

method Start() as void strict class StopWatch3

    local start_high as longint
    local start_low as dword
    GetQueryPerformanceCounter(@start_high,@start_low)
    
    self:StartMoment_high := start_high
    self:StartMoment_Low := start_low
    
    return
    
method Stop() as real8 strict class StopWatch3
    //#l get the elapsed time upto now since the Start.
    
    local stop_high as longint
    local stop_low as dword
    local delta as dword
    
    GetQueryPerformanceCounter(@stop_high,@stop_low)
    delta := hldif(stop_high,stop_low,self:StartMoment_high,self:StartMoment_Low)
    return real8(delta)/Frequency 

function GetQueryPerformanceFrequencyHigh() as longint strict
    
    local lpFreqebcy is _WINLARGE_INTEGER
    QueryPerformanceFrequency(@lpFreqebcy)
    return lpFreqebcy.u.HighPart

function GetQueryPerformanceCounter(highPart ref longint , LowPart ref dword) as void strict
    local qpcValue is _WINLARGE_INTEGER
    QueryPerformanceCounter(@qpcValue)
    HighPart := qpcValue.u.HighPart
    LowPart := qpcValue.u.LowPart
    return 

function hldif(ah as longint,al as dword, bh as longint, bl as dword ) as dword strict
    //#l calculate a-b
    //#l assume a>b
    //#l assume that the difference is lower than dword_max
    
    local highPartDiff as longint

    highPartDiff := ah-bh

    do case
    case highPartDiff == 0
        do case
        case al==bl
            return 0u
        case al<bl
            // wtf?
            return maxdword
        otherwise
            return al-bl
        endcase
    case highPartDiff == 1
        if al>= bl
            // would be a overflow
            return maxdword
        else
            return al + (maxdword-bl)
        endif
    case highPartDiff < 0 
        // wtf?
        return maxdword
    case highPartDiff > 1
        // would be a overflow
        return maxdword
    endcase

    return 0