QPC and QPF in Assembly interpretation.

I could use some advise on how to properly interpret (QueryPerformanceCounter) QPC and QPF (QueryPerformanceFrequency) into assembly (64-bit windows);

This is from MSDN:

Code:

LARGE_INTEGER StartingTime, EndingTime, ElapsedMicroseconds;
LARGE_INTEGER Frequency;

QueryPerformanceFrequency(&Frequency); 
QueryPerformanceCounter(&StartingTime);

// Activity to be timed

QueryPerformanceCounter(&EndingTime);
ElapsedMicroseconds.QuadPart = EndingTime.QuadPart - StartingTime.QuadPart;


//
// We now have the elapsed number of ticks, along with the
// number of ticks-per-second. We use these values
// to convert to the number of elapsed microseconds.
// To guard against loss-of-precision, we convert
// to microseconds *before* dividing by ticks-per-second.
//

ElapsedMicroseconds.QuadPart *= 1000000;
ElapsedMicroseconds.QuadPart /= Frequency.QuadPart;

This is the interpretation test code I wrote;

Code:

format PE64 console
include 'win64axp.inc'

        mov     rsi,1000 ;loop 1000 times
.again:
        mov     rcx,freq
        cinvoke QPF
        mov     rcx,starting
        cinvoke QPC

        ;*************************
        ;Activity to be timed
        mov     rax,rsp
        call    prtreg
        ;*************************

        mov     rcx,ending
        cinvoke QPC
        call    newline

        ;Get the difference between ending and starting
        ;Convert others from integer to double for later use
        mov     rax,[ending]
        mov     rbx,[starting]
        sub     rax,rbx     ;Get the difference
        call    int2dbl       ;routine to convert int in rax to double
        mov     [elapsed],rax ;Copy the double to elapsed
        mov     rax,[freq]
        call    int2dbl
        mov     [freq],rax

        ;ElapsedMicroseconds.QuadPart *= 1000000;
        ;ElapsedMicroseconds.QuadPart /= Frequency.QuadPart;
        fld     [rate]      ;1000000.00
        fld     [elapsed]
        fmul    st0,st1
        fld     [freq]
        fdiv    st0,st1
        fstp    [sec]

        ;Display the result in seconds??
        mov     rax,[sec]
        call    prtdbl
        mov     al,'s'
        call    prtchr
        call    newline
        finit
        dec     rsi
        jnz     .again

call exitp
elapsed rq 1
starting rq 1
ending rq 1
freq rq 1
rate dq 1000000.00
sec dq 0.0
;....
;....

;my other routines

;Import table down below
data import
     library msvcrt,'msvcrt.dll',kernel32,'kernel32.dll'
     import msvcrt,\
     EXIT,'exit',putchar,'putchar',getchar,'getchar'
     import kernel32,\
     QPC,'QueryPerformanceCounter',QPF,'QueryPerformanceFrequency'
end data

Is this the correct interpretation of QPC / QPF into assembly or there are some other technical things that I am missing?

Thanks in advance.

;definitions QPC_start dq ? QPC_end dq ? QPC_freq dq ? generate_time dd ? ;... invoke QueryPerformanceFrequency,addr QPC_freq invoke QueryPerformanceCounter,addr QPC_start ;... <do stuff> invoke QueryPerformanceCounter,addr QPC_end fild [QPC_end] fild [QPC_start] fsubp fild [QPC_freq] fdivp mov [generate_time],1000 ;convert to milliseconds fimul [generate_time] fistp [generate_time]