Thread: Minute Delay Loop

I'm needing minutes to always be 00 seconds. But after running my code for a few minutes, it jumps to 58 seconds. I cannot see any reason why. Anyone have any ideas? Thanks.

Code:

#include <windows.h>
#include <ctime>
#include <iostream>// cout

using namespace std;

int main(){
	string dataStr;
	clock_t cSecs; time_t tSecs;
	int Secs,elapsedTime=0,iStall=1;
	Secs=(60-((int)time(0)%60))*1000;// first 00
	bool looping=true;
	while(looping){
		Sleep(Secs); cSecs=clock(); tSecs=time(0);
		char timestamp[20]; struct tm pSecs;
		localtime_s(&pSecs,&tSecs);
		strftime(timestamp, 20, "%X", &pSecs);
		cout << Secs <<" + "<< elapsedTime <<"\t= "<< timestamp <<"\n";
		Sleep(753*(iStall%5)); iStall++;
		elapsedTime=(clock()-cSecs)*1000/CLOCKS_PER_SEC;
		Secs=(60000-elapsedTime);
	}
	return 0;
}

Unfortunately this eats up the CPU:

Code:

	do{
		elapsedTime=(clock()-cSecs)*1000/CLOCKS_PER_SEC;
	} while(elapsedTime<60000);

Any suggections?

Hey, that's fine with me. I've actually already invisioned doing this... very ugly stuff so far. I've tried modulus math tricks and a Sleep(500) loop with time(0) check release.

But, I really do not know of a clever K.I.S.S. way that works to get 00 seconds every time (in sync with the computer clock). I would still love any suggestions.

It's part of a time sync tool used to monitor the NYSE.

Anybody else?

I really only need it to be 00 seconds.
It doesn't matter too much if it is 00+few extra millis (even up to 00.999), but not 59 or 01 seconds.
Thanks for your help.

By the way, I'm currently testing this:

Code:

Sleep((60-((int)time(0)%60))*1000);
iSecs=((int)time(0)%60); if(iSecs>40) Sleep((60-iSecs)*1000);

And, it seems to be good, but I find that hard to believe since that would be way too KISS

Earlier, you said: "It will sleep for >= specificed milliseconds"
And now, you use the word "oversleep".
Do you mean that I should expect random increased Sleep millis each cycle?

Something like this?

Code:

while (looping)
{
     int time_of_next_00_in_ms = ((current_time_in_ms() / (1000*60)) + 1) * (1000*60);
     sleep_ms(time_of_next_00_in_ms - current_time_in_ms());
     ....
}

Basically round current time to last time second was 00, add 1 minute, gives the time you should sleep until.

Then, you can just sleep the time between the calculated time and current time.

This should give you 00 most of the time. Unfortunately, since Windows is not a real-time system (meaning it doesn't make any timing guarantees), theoretically, if it's very busy, it can decide to not schedule (run) your process for as long as it wants.

If timing is VERY critical (eg. in a life support device, or vehicle computer), a real time system should be used, but that is a lot of hassle, and may not be practical. There is a kernel patch that makes Linux real time, but I'm not aware of any real time variant of Windows. Another option is to just accept that your code will work 99.99% of the time, and make sure nothing catastrophic will happen if it oversleeps.

Do you mean that I should expect random increased Sleep millis each cycle?

The only guarantee Sleep(ms) gives you is that, your thread/process will be suspended for AT LEAST ms. Theoretically, Windows can suspend your process for 2 years even if you only asked for 2 seconds. Not likely, but Windows doesn't guarantee it won't do that.