Van gettimeofday () garantáltan a us felbontás?

szavazat
82

Én portolása egy játék, amelyet eredetileg írt a Win32 API, Linux (jó, portolása az OS X port a Win32 port Linux).

Azt már végre QueryPerformanceCounterazzal, hogy a uSeconds mivel az eljárás elindításához:

BOOL QueryPerformanceCounter(LARGE_INTEGER* performanceCount)
{
    gettimeofday(&currentTimeVal, NULL);
    performanceCount->QuadPart = (currentTimeVal.tv_sec - startTimeVal.tv_sec);
    performanceCount->QuadPart *= (1000 * 1000);
    performanceCount->QuadPart += (currentTimeVal.tv_usec - startTimeVal.tv_usec);

    return true;
}

Ez, párosulva QueryPerformanceFrequency()így állandó 1000000 a frekvencia, jól működik a gépemen , hogy nekem egy 64 bites változót, amely uSeconds, mivel a program induló.

Így van ez a hordozható? Nem akarom, hogy felfedezzék azt másként működik, ha a kernel-ben összeállított egy bizonyos módon, vagy ilyesmi. Jól vagyok vele, hogy nem hordozható, hogy valami más, mint a Linux, de.

A kérdést 01/08/2008 15:36
a forrás felhasználó
Más nyelveken...                            


10 válasz

szavazat
4

Az én tapasztalataim és amit olvastam az interneten keresztül, a válasz „Nem”, akkor nem garantált. Attól függ, hogy a processzor sebességét, az operációs rendszer, ízét Linux, stb

Válaszolt 01/08/2008 15:46
a forrás felhasználó

szavazat
54

Talán. De van nagyobb problémákat. gettimeofday()eredményezhet helytelen időzítés, ha vannak olyan folyamatok a rendszer, hogy a változás az időzítő (azaz ntpd). Egy „normális” linux, bár úgy vélem, a felbontás gettimeofday()is 10us. Meg lehet ugrani előre és hátra, és időt, következésképpen alapuló folyamatok fut a rendszer. Ez hatékonyan teszi a választ a kérdésre nincs.

Meg kell nézni clock_gettime(CLOCK_MONOTONIC)az időzítés időközönként. Ez azonban számos kisebb problémák miatt a dolgok, mint a többmagos rendszerek és külső órajel beállításokat.

Is, nézd át a clock_getres()funkciót.

Válaszolt 01/08/2008 15:53
a forrás felhasználó

szavazat
8

A tényleges felbontása gettimeofday () függ a hardver architektúra. Intel processzorok, valamint a SPARC gépeket kínálnak nagyfelbontású időzítő, amelyek mérik ezredmásodperc. Egyéb hardverarchitektúrák esik vissza a rendszer időzítő, amely tipikusan beállítása 100 Hz. Ezekben az esetekben az idő felbontás kevésbé lesznek pontosak.

Kaptam ezt a választ High Resolution Időmérés és időzítők, I. rész

Válaszolt 01/08/2008 15:55
a forrás felhasználó

szavazat
39

Nagy felbontású, alacsony rezsi időzítése Intel processzorok

Ha az Intel hardver, itt van, hogy olvassa el a CPU valós idejű használati számláló. Azt fogja mondani, a CPU-ciklusok számát óta végrehajtott processzort elindult. Ez talán a legfinomabb szemcséjű számláló kaphat a teljesítmény méréséhez.

Megjegyzendő, hogy ez a szám a CPU ciklusokat. A linux kaphat a processzor sebességét a / proc / cpuinfo és osztódnak, hogy a másodpercek száma. Alakítja át ezt a kettős elég praktikus.

Amikor futtatom ezt én doboz, kapok

11867927879484732
11867927879692217
it took this long to call printf: 207485

Itt a Intel fejlesztői útmutatót ad tonna részletességgel.

#include <stdio.h>
#include <stdint.h>

inline uint64_t rdtsc() {
    uint32_t lo, hi;
    __asm__ __volatile__ (
      "xorl %%eax, %%eax\n"
      "cpuid\n"
      "rdtsc\n"
      : "=a" (lo), "=d" (hi)
      :
      : "%ebx", "%ecx");
    return (uint64_t)hi << 32 | lo;
}

main()
{
    unsigned long long x;
    unsigned long long y;
    x = rdtsc();
    printf("%lld\n",x);
    y = rdtsc();
    printf("%lld\n",y);
    printf("it took this long to call printf: %lld\n",y-x);
}
Válaszolt 02/08/2008 09:08
a forrás felhasználó

szavazat
9

Tehát azt mondja ezredmásodperc kifejezetten, de azt mondja, a felbontás a rendszer órája nincs megadva. Gondolom felbontás ebben az összefüggésben azt jelenti, hogy az a legkisebb összeg, hogy valaha is növekedhet?

Az adatstruktúra úgy definiáljuk, mint amelynek mikroszekundum, mint egy mértékegység, de ez nem jelenti azt, hogy az óra vagy az operációs rendszer valójában képes mérni, hogy finoman.

Mint a többi ember azt, gettimeofday()rossz, mert az idő beállításával okozhat órajelelcsúszás és dobja ki a számításból. clock_gettime(CLOCK_MONOTONIC)az, amit akarsz, és clock_getres()megmondja, hogy a pontosság az óra.

Válaszolt 02/08/2008 18:57
a forrás felhasználó

szavazat
18

@Bernard:

Be kell vallanom, a legtöbb példa egyenesen a fejem fölött. Ez nem fordul le, és úgy tűnik, működik, mégis. Biztonságos ez az SMP rendszerek vagy SpeedStep?

Ez egy jó kérdés ... Azt hiszem, hogy a kód rendben van. Gyakorlati szempontból, tudjuk használni a cégem minden nap, és mi fut elég széles skáláját dobozok, minden 2-8 magot. Természetesen YMMV stb, de úgy tűnik, hogy egy megbízható és alacsony rezsi (mert nem teszi vál- tani rendszer-space) módszer az időzítés.

Általában hogyan működik:

  • állapítsa meg a blokk kódot kell szerelő (és illékony, ezért az optimalizáló hagyják egyedül).
  • végrehajtja a CPUID utasítást. Amellett, hogy egyre néhány CPU információk (amelyek nem teszünk semmit) szinkronizálja a CPU végrehajtási puffert úgy hogy az időzítést nem befolyásolja out-of-order végrehajtás.
  • végrehajtja a rdtsc (értsd timestamp) végrehajtását. Ez letölti száma gépi ciklus óta végrehajtott processzor alaphelyzetbe állt. Ez egy 64 bites érték, így a jelenlegi CPU sebességet akkor körülveszi minden 194 év múlva. Érdekes, hogy az eredeti Pentium referencia megjegyzik, hogy körbe minden 5800 évben.
  • Az elmúlt pár sor tárolja az értékeket a regiszterek a változók hi és lo, és tegye, hogy a 64 bites visszatérési értéke.

Különös megjegyzések:

  • out-of-order végrehajtás okozhat hibás eredményeket, így végre a „CPUID” utasítás, amely azon túlmenően, hogy egy kis információt a processzor is szinkronizálja bármely out-of-order utasítás végrehajtását.

  • A legtöbb operációs rendszer szinkronizálja a számlálók a CPU mikor indul el, így a válasz jó, hogy egy pár nano-másodperc.

  • A téli álmot alvó megjegyzés valószínűleg igaz, de a gyakorlatban valószínűleg nem törődnek időzítések között hibernáció határokat.

  • kapcsolatos SpeedStep: Újabb Intel CPU kompenzálja a sebesség változik, és visszatér egy beállított száma. Tettem egy gyors át néhány doboz a hálózatunkon, és már csak egy doboz, amely nem volt meg: a Pentium 3 fut néhány régi adatbázis szerver. (Ezek linux dobozokat, így egyeztettem: grep constant_tsc / proc / cpuinfo)

  • Nem vagyok biztos abban, hogy a AMD CPU vagyunk elsősorban Intel bolt, bár tudom, hogy néhány alacsony szintű rendszerek guruk volt egy AMD értékelést.

Remélem ez kielégíti a kíváncsiságát, ez egy érdekes és (IMHO) keretében tanulmányozott programozás területén. Tudod, amikor Jeff és Joel volt szó, hogy egy programozó kell tudni C? Azt kiabált nekik, hogy „hé elfelejteni, hogy a magas szintű C dolgok ... szerelő, amit meg kell tanulni, ha azt szeretné tudni, hogy mi a számítógép csinál!”

Válaszolt 04/08/2008 01:51
a forrás felhasználó

szavazat
11

A bor valóban használja gettimeofday (), hogy végre QueryPerformanceCounter (), és köztudott, hogy sok Windows játékok dolgozni Linux és Mac.

Elindítja http://source.winehq.org/source/dlls/kernel32/cpu.c#L312

vezet http://source.winehq.org/source/dlls/ntdll/time.c#L448

Válaszolt 04/08/2008 15:44
a forrás felhasználó

szavazat
3

Reading a RDTSC nem megbízható az SMP rendszerek, mivel minden egyes CPU fenntartja saját számlálót és minden ellen nem garantált, hogy a szinkronizált a másikhoz képest CPU.

Lehet, hogy azt sugallják, próbál clock_gettime(CLOCK_REALTIME). A POSIX utasítás azt jelzi, hogy ez végre kell hajtani minden kompatibilis rendszereket. Ez olyan ns száma, de valószínűleg ellenőrizni fogja majd clock_getres(CLOCK_REALTIME)a rendszer, hogy mi a tényleges felbontás.

Válaszolt 18/08/2008 16:40
a forrás felhasználó

szavazat
14

Lehet, hogy érdekli a Linux GYIK-clock_gettime(CLOCK_REALTIME)

Válaszolt 18/08/2008 16:51
a forrás felhasználó

szavazat
5

Ez a válasz említi problémák az óra beállítása közben. Mindkét problémákra garantálja kullancs egységek és a problémák az idő beállítása is megoldódnak C ++ 11 a <chrono>könyvtárban.

Az óra std::chrono::steady_clockgarantáltan nem kell korrigálni, továbbá előre lép állandó sebességgel képest valós időben, így technológiák, mint a SpeedStep nem befolyásolja azt.

Tudod kap typesafe egységek átalakításával az egyik std::chrono::durationszakterületek, például std::chrono::microseconds. Az ilyen típusú, nincs kétség, az egységek által használt kullancs értéket. Ugyanakkor szem előtt tartani, hogy az óra nem feltétlenül ezt az állásfoglalást. Ön tudja alakítani egy időtartamot attoseconds nélkül, hogy ténylegesen egy órát, hogy pontos.

Válaszolt 26/06/2012 16:57
a forrás felhasználó

Cookies help us deliver our services. By using our services, you agree to our use of cookies. Learn more