नींद (1) और एसडीएल_Delay (1) 15 एमएस

Question

लेता है मैं एक सी ++/एसडीएल/ओपनजीएल आवेदन लिख रहा हूं, और मेरे पास सबसे असाधारण बग है। यह गेम एक साधारण परिवर्तनीय टाइमस्टेप के साथ ठीक काम कर रहा था। लेकिन फिर एफपीएस ने अजीब तरीके से व्यवहार करना शुरू कर दिया। मुझे पता चला कि दोनों नींद (1) और एसडीएल_Delay (1) पूरा करने के लिए 15 एमएस लेते हैं।

किसी भी इनपुट उन कार्यों में 0-15 के बीच पूरा करने के लिए 15ms लेता है, 64 के बारे में में एफपीएस ताला लगा अगर मैं 16 के लिए सेट है, यह 30 एमएस o.o

मैं कोई विचार क्यों यह हो रहा है है लेता है। यह सबसे अजीब बग है जिसे मैंने कभी सामना किया है।

मेरे पाश इस तरह दिखता है:

while (1){ 
    GLuint t = SDL_GetTicks(); 
    Sleep(1); //or SDL_Delay(1) 
    cout << SDL_GetTicks() - t << endl; //outputs 15 
} 

यह बहुत मुश्किल से ही 1ms लेने के रूप में यह माना जाता है, लेकिन समय के बहुमत यह 15ms लेता है।

मेरा ओएस विंडोज 8.1 है। सीपीयू एक इंटेल i7 है। मैं एसडीएल 2 का उपयोग कर रहा हूँ। किसी भी विचार की सराहना की जाएगी, क्योंकि मैं अनजान हूं।

Answer 1

टिकर 64 हर्ट्ज या 15.625 एमएस/टिक तक डिफ़ॉल्ट है। आपको समय के साथ 1000hz == 1ms में बदलने की आवश्यकता है BeginPeriod (1)। MSDN लेख:

http://msdn.microsoft.com/en-us/library/windows/desktop/dd757624(v=vs.85).aspx

लक्ष्य यहाँ एक निश्चित आवृत्ति अनुक्रम प्राप्त करने के लिए है, तो आप एक उच्च संकल्प टाइमर का उपयोग करना चाहिए, लेकिन दुर्भाग्य से इनमें से केवल सर्वेक्षण में शामिल किया जा सकता है, तो मतदान और नींद का एक संयोजन cpu कम करने के लिए ओवरहेड की जरूरत है। उदाहरण कोड, जो मानता है कि एक नींद (1) लगभग 2 एमएस तक ले सकती है (जो विंडोज एक्सपी के साथ होती है, लेकिन विंडोज के बाद के संस्करणों के साथ नहीं)।

/* code for a thread to run at fixed frequency */ 
#define FREQ 400      /* frequency */ 

typedef unsigned long long UI64;  /* unsigned 64 bit int */ 

LARGE_INTEGER liPerfTemp;    /* used for query */ 
UI64 uFreq = FREQ;      /* process frequency */ 
UI64 uOrig;        /* original tick */ 
UI64 uWait;        /* tick rate/freq */ 
UI64 uRem = 0;       /* tick rate % freq */ 
UI64 uPrev;        /* previous tick based on original tick */ 
UI64 uDelta;       /* current tick - previous */ 
UI64 u2ms;        /* 2ms of ticks */ 
#if 0         /* for optional error check */ 
static DWORD dwLateStep = 0; 
#endif 

    /* wait for some event to start this thread code */ 
    timeBeginPeriod(1);     /* set period to 1ms */ 
    Sleep(128);       /* wait for it to stabilize */ 

    u2ms = ((UI64)(liPerfFreq.QuadPart)+499)/((UI64)500); 

    QueryPerformanceCounter((PLARGE_INTEGER)&liPerfTemp); 
    uOrig = uPrev = liPerfTemp.QuadPart; 

    while(1){ 
     /* update uWait and uRem based on uRem */ 
     uWait = ((UI64)(liPerfFreq.QuadPart) + uRem)/uFreq; 
     uRem = ((UI64)(liPerfFreq.QuadPart) + uRem) % uFreq; 
     /* wait for uWait ticks */ 
     while(1){ 
      QueryPerformanceCounter((PLARGE_INTEGER)&liPerfTemp); 
      uDelta = (UI64)(liPerfTemp.QuadPart - uPrev); 
      if(uDelta >= uWait) 
       break; 
      if((uWait - uDelta) > u2ms) 
       Sleep(1); 
     } 
     #if 0     /* optional error check */ 
     if(uDelta >= (uWait*2)) 
      dwLateStep += 1; 
     #endif 
     uPrev += uWait; 
     /* fixed frequency code goes here */ 
     /* along with some type of break when done */ 
    } 

    timeEndPeriod(1);     /* restore period */ 

Answer 2

एसडीएल_Delay()/नींद() 10-15 मिलीसेकंड से कम समय के साथ विश्वसनीय रूप से उपयोग नहीं किया जा सकता है। सीपीयू टिक 1 एमएस अंतर का पता लगाने के लिए पर्याप्त तेज़ी से पंजीकरण नहीं करते हैं।

SDL docs here देखें।

Answer 3

ऐसा लगता है कि 15 एमएस ओएस आपको सबसे छोटा टुकड़ा देगा। मुझे आपके विशिष्ट ढांचे के बारे में निश्चित नहीं है लेकिन नींद आमतौर पर कम से कम सोने का समय गारंटी देती है। (यानी यह कम से कम 1ms के लिए सो जाएगा।)