טיימר ב C++

[spinchicken]

אני מתכנת ב C++,

אני מנסה לגרום לפונקציה להיקרא כל מספר קבוע של 40 מילישניות בתוכנית.

ניסיתי להשתמש ב QueryPerformanceCounter ובדיקה אבל זה מעמיס לי על הCPU וזה גורם לתוכנית להיות איטית.

מישהו מכיר דרך טובה יותר לעשות את זה?

[Boomerang]

תן קצת יותר מידע -

אתה עובד בסביבת MFC? או סתם Win32?

עד כמה הדיוק קריטי לך?

מה אתה מצפה שייקרה אם יעברו 40 מילי-שניות ואתה נמצא בתוך פונקציה אחרת?

הדרך הכי קלה ב- Windows היא להשתמש ב- SetTimer כדי לקבל הודעות לחלון שלך כל פרק זמן, או אם אין לך חלון - לקבל קריאה ל- Callback שאתה מספק.

[Zelig]

1) מה לגבי אורך הפונקציה שתקרא כל 40 מילי? אם זמן הביצוע שלה הוא 40 מילי, תצפה לעומס על המחשב...

2) האם יכול להיות שכתבת לולאת busy waiting? לולאות מסוג זה הן כמעט תמיד הדרך הלא נכונה להשיג המתנה, שכן הן מבזבזות CPU.

כמו כן אולי כדאי שתתאר מה אתה רוצה להשיג ברמה גבוהה יותר, ואז אולי נוכל להציע פתרון מתאים. יכול להיות שהפתרון לבעיה שלך הוא דווקא אחר ולא קריאה לפונקציה כל 40 מילי.

עריכה: הנה דוגמא ללולאת BUSY WAIT שהיא הדרך הלא מתאימה (ברוב המקרים) לפתרון הבעיה שלך:

while( true )
{
  old_time = get_current_time_ms();
  while ( (get_current_time_ms() - old_time) > 40 ) { /* do Nothing */ }  // EVIL busy waiting loop
  call_my_function(); 
}

[spinchicken]

נכון באמת כתבתי כזאת פונקציה וזה יצר לי עומס על המערכת,

הפונקציה שתקרא צריכה להיות מדויקת ברמה של מילישניות בודדות,

ניסיתי את set timer אבל בינתיים מצאתי משהו יותר מדוייק במולטי מדיה (winmm)

זה נקרא time set event

עדיין לפעמים יש לי חורים של כמה מילי שניות, אני חושב שזה עומס על ה CPU, מישהו מכם השתמש פעם בפונקציה הזו?

[Zelig]

קשה לדבר בלי להכיר את המערכת שלך אבל קח בחשבון ש-Windows הוא לא real time ולכן לא יכול להתחייב ללוחות זמנים מדוייקים תמיד.

פעולת paging עלולה להתחיל בדיוק לפני שהפונקציה שלך אמורה להקרא, ולכן הפוקנציה לא תקרא בזמן. גם הרזולוציה הפנימית של ה-scheduling היא בוודאי של 10ms.

אני לא מכיר את Windows טוב, סביר להניח שיש עוד הרבה סיבות אחרות לכך שהפונקציה לא תמיד נקראת בזמן.

איך מדדת את האיחור במילישניות? איך מדדת את העומס על ה-CPU?

[spinchicken]

את התזמונים מדדתי בצורה הכי פרימיטיבית שיש -

לפקודה אתה מכניס פונקציית callin וכשהיא נקראת פשוט כתבתי בקובץ טקסט הודעה עם הזמן לפי

QueryPerformanceCounter

את העומס על ה CPU לא ממש מדדתי רק ראיתי שבאופן כללי אני מקבל חורים גם בפונקציה שנקראת בתזמונים וגם בעבודה של פונקציות נוספות שעובדות במקביל.

[Zelig]

ברור לך שפלט לקובץ זה אולי הפעולה הכי לא דטרמיניסטית שיש מבחינת הזמן שהיא לוקחת, כן?

[Boomerang]

כתיבה לדיסק היא פעולה מאוד כבדה (seek לוקח 8-16 מילישניות - תלוי בדיסק).

אם ה- cache של הדיסק עובד, אז זה לא ייקח את הזמן הזה על כל פעולת כתיבה, אבל מדי פעם הוא כן יצטרך לכתוב ממש, ואז זה ייקח זמן.

[spinchicken]

האם פעולת הכתיבה על הcash תשנה?

אין איזשהו תור ששומר את הפעולות בזמן הכתיבה ויעדכן אחר כך?

הרי פעולת הכתיבה לא צריכה בעצמה להיות מדוייקת מבחינת הזמן רק ההודעות בה צריכות להופיע בסדר כרונולוגי לא?

[Zelig]

זה עסק מאוד מסובך:

יש buffer ברמת התהליך (fprintf הוא line buffered לרוב).

יש cache ברמת מערכת הקבצים.

יתכן גם cache נוסף ברמת הדרייבר.

בכונן הקשיח עצמו גם כן יש cache.

באופן ספציפי הסדר של הכתיבות אכן נשמר, אבל הנקודה היא שקשה לדעת מראש כמה זמן תיקח פעולת כתיבה לקובץ.

[spinchicken]

נו, אז אם סדר הפעולות נשמר,

והחותמת של הזמן תלוייה רק בזמן הקריאה לפונקציה,

ופעולת הכתיבה אינה משפיעה על ריצת התוכנית אז אני יכול לסמוך על מה שקיבלתי בפלט לא?

[Zelig]

נו, אז אם סדר הפעולות נשמר,

והחותמת של הזמן תלוייה רק בזמן הקריאה לפונקציה,

ופעולת הכתיבה אינה משפיעה על ריצת התוכנית אז אני יכול לסמוך על מה שקיבלתי בפלט לא?

אז זהו שלא. כל פעם שאתה עושה fprintf זה יכול לקחת זמן אחר. פעולת הכתיבה עלולה לעכב את הפעולה הבאה שתבצע.

זו רק תיאוריה, כיוון שאני לא יודע בדיוק מה אתה עושה, וגם אני לא מכיר את win32 כל כך טוב.

אני מציע שתנסה לשמור רק את הזמנים באיזושהיא רשימה, ותוציא את הרשימה לקובץ רק אחרי נניח 10000 ריצות של הפונקציה שלך. זה לפחות יבטל אלמנט אחד של שאי וודאות. אני גם מציע שתקצה את כל הזכרון לרשימה/מערך/מבנה נתונים מראש, וכך תוכל להיות יותר בטוח שכל ריצה של הפוקנציה לוקחת זמן דומה.

כמו כן כדאי לך לקבל יותר מידע קונקרטי: בכמה מתוך N ריצות יש פספוס של הדדליין? בכמה מילישניות העיכוב הממוצע? האם יש מחזוריות?

בסופו של דבר, יתכן שלעולם לא תוכל לקבל בוודאות קריאה לפונקציה כל בדיוק 40 מילישניות לאורך זמן. win32 פשוט לא מתוכנן לסוג כזה של עמידה בלוחות זמנים.

[spinchicken]

תודה,

אני אעשה את זה ואראה אם יש באמת שיפור בקריאה.