[c++] µS delays nodig

[TriLithium]

Na 2 dagen zoeken heb ik het tocht echt wel gehad, ik zoek dus een stuk code wat µS delays kan doen, 50µS is eigenlijk wel minimaal en dan mag het wel in stappen van 10µS omhoog gaan dat maakt me dan ook niks meer uit.
Ik ben bezig met een grafisch display te besturen en hoop zo m'n c++ kennis wat op te krikken door lekker veel te proberen en fout te doen.
Heb een paar maanden elke week op school een stuk of wat uren gehad, maar ik kan toch al redelijk met structs, pointers, arrays en combinaties van die 3 werken, toch al heel wat vind ik zelf
Als iemand wat heeft waar ik wat aan heb, dan zeer bedankt.

[Verwijderd]

QueryPerformanceCounter

[TriLithium]

iets meer mag hoor

[Gerco]

Op donderdag 13 september 2001 18:43 schreef TriLithium het volgende:
iets meer mag hoor

Als je die functie opzoekt in de MSDN staat daar allerlei handige info. imo is dat ene woord genoeg info

_{In dit geval}

[Verwijderd]

Ik ging net eten, denk rammel ff snel een antwoord in, hij's slim zat, figured ie wel uit Als je even zoekt in een van de c++/asm benchmark draden kom je vast wel een mooi voorbeeldtje tegen .

[TriLithium]

ohh ik pruts wel hoor, maar meer info is altijd welkom, ben ook nog maar een beginner

[curry684]

Op donderdag 13 september 2001 18:47 schreef Yarvieh het volgende:
Ik ging net eten, denk rammel ff snel een antwoord in, hij's slim zat, figured ie wel uit Als je even zoekt in een van de c++/asm benchmark draden kom je vast wel een mooi voorbeeldtje tegen .

Volgens mij staat de QueryPerformanceCounter alleen in deze genoemd.

Overigens vraag ik me af waar je in GODESNAAM microsecond delays voor nodig hebt, en dan nog precieze ook. Waarschijnlijk doet Sleep(0) dit al voldoende, omdat dan alle waiting threads ff een timeslice krijgen, waarschijnlijk duurt dat zelfs langer al dan 50 microseconden op de meeste machines met een paar processen open.

[TriLithium]

Super precies hoeft het niet,als ik maar een van 50µS heb, een instuctie van dat display duurt 40..45µS. Tevens zijn er instructies die 100 en 400µS duren. Ik heb nog niet stil gestaan bij die Sleep(0), maar ik heb liever dat ik vertrouwen kan op m'n 50µ delay, ook al duurt die wat langer.
Ook moet die zo kort zijn omdat ik als ik grafisch schrijf ik bij de init 8000 bytes moet leegschrijven, en dat mag toch best wel een beetje snel gaan eigenlijk.

[Verwijderd]

http://www.demogl.com/sourcecode.asp
Haal de sourcecode op, kijk in dgl_dlldemodat.cpp en dgl_dlldemodat.h

korte snippets:

code:

// Purpose: calculates the elapsed time in seconds
void
CDemoDat::CalcElapsedTimeInSeconds()
{
    __int64         lCurrentTicks;

    if(m_bTickerStarted)
    {
        QueryPerformanceCounter((LARGE_INTEGER *)&lCurrentTicks);
        // now we have lTickFrequency ticks per second. We can now calc how long it took since the start. 
        m_fElapsedTimeInSecs=(float) ((double)(lCurrentTicks - m_lTickerStart)/(double)m_lTickFrequency);
    }
}

code:

// Purpose: sets up the high resolution ticker. 
// If not available, we can't time, so return SYS_NOK otherwise return  SYS_OK
int
CDemoDat::SetupTicker()
{
    if(!QueryPerformanceFrequency((LARGE_INTEGER *)&m_lTickFrequency))
    {
        // no timer available. 
        return SYS_NOK;
    }
    // get tickerstart.
    QueryPerformanceCounter((LARGE_INTEGER *)&m_lTickerStart);
    m_bTickerStarted=true;
    m_lFramesSinceStart = 0;
    m_iFramesThisSecond=0;
    m_lMilliSecondsPassed=0;
    m_lMilliSecondsLastTime=0;
    m_fElapsedTimeInSecs=0;

    // Insert starttime into the ticker.
    SetTimePassed(m_lCurrentTimeAtTickerReset);
    return SYS_OK;
}

code:

// Purpose: sets the timerticker to a value so that the call GetfElapsedTimeInSeconds will return the time passed to this function.
void
CDemoDat::SetTimePassed(long lMilliseconds)
{
    __int64     llTimeTicksDelta;
    long        lMillisecondsDelta;

    // the elapsed time is calculated with a ticker. That ticker is checked with a startvalue. the difference
    // of these 2 is an indication how many time has passed. If we move the startvalue up or down, we can set the
    // time to the value that is passed.
    lMillisecondsDelta = lMilliseconds - (long)(m_fElapsedTimeInSecs * 1000.0f);
    llTimeTicksDelta = (__int64)((float)(lMillisecondsDelta/1000.0f) * m_lTickFrequency);
    m_lTickerStart -=llTimeTicksDelta;
}

[curry684]

edit:

Stuk over SetWaitableTimer geschrapt, heeft niet genoeg precisie voor zo'n kleine delays

[Verwijderd]

De volgende code geeft een voorbeeld van de RDTSC instructie die in de nieuwere (lees Pentium) CPU's zit.
Bepaal wel eerst de 'counter' waarde aan de hand van een klok omdat deze funktie cpu cycles telt en je dus de frequentie van de CPU moet meten.

-------------------------------------------

#include "stdio.h"
#include "conio.h"

void main(void)
{
static __int64 iRDTSC = 0;

while ( ! _kbhit() )
{
__asm {
push eax
push ebx
push edx
_emit 0x0F ; The RDTSC instruction consists
_emit 0x31 ; of these two bytes.
mov ebx, OFFSET iRDTSC ; Put the address where the
; timestamp goes in ebx
mov [ebx],eax ; Save low 4 bytes of timestamp
mov [ebx+4],edx ; Save high 4 bytes of timestamp
pop edx
pop ebx
pop eax
}
printf("\r%I64d ", iRDTSC);
}
}

[Verwijderd]

Ik gebruik liever QueryPerformanceCounter die 't zelfde doet Je kan trouwens die RDTSC gewoon in je asm rotten hoor hoef je geen emits voor te doen.