Printable View
I am traying to create a delay function using time.h
But as you see this function get seconds (int) and I want it to work with miliseconds (like delay & sleep).Code:#include <time.h>
void Delay (unsigned int Sec)
{
clock_t ticks1 = clock(), ticks2 = ticks1;
while ( ( ticks2/CLOCKS_PER_SEC - ticks1/CLOCKS_PER_SEC ) < Sec)
ticks2 = clock();
}
So how can I do that? (maybe another type (clock_t)?)
Thanks.
If you multiply ticks/CLOCKS_PER_SEC by 1000 you should get ticks/"CLOCKS_PER_MILLISEC", since there are 1000 milliseconds in a second. You may also need to do some casting to double, so as not to have the intermediate results (seconds) truncated.
To avoid having to work with delay and CLOCKS_PER_SEC, perhaps you could use
difftime (which gives you seconds but it gives it to you as a double, not an int).
(and btw, sleep() returns seconds, not milliseconds).
Here's an example of difftime():
You'd want to only work with the part of the seconds after the decimal point, and it certainly wouldn't be any more accurate than delay. It would free you from having to work with CLOCKS_PER_SEC, (which would perhaps vary from one computer to the next), however.Code:#include <time.h>
#include <stdio.h>
#include <dos.h>
int main(void)
{
int c;
time_t first, second;
first = time(NULL); /* Gets system time */
delay(2000); /* Waits 2 secs */
second = time(NULL); /* Gets system time again */
printf("The difference is: %f seconds\n",difftime(second,first));
c = getchar();
return 0;
}
On Windows, Sleep() takes the number of milliseconds to sleep.Quote:
Originally Posted by Adak
On UNIX, sleep() takes seconds.
Sleep() was not mentioned, however:Quote:
Originally Posted by cpjust
The sleep() function still uses seconds on Windows.Quote:
... and I want it to work with miliseconds (like delay & sleep).
No it's ms (on windows).
Anyway thank you Adak (:
Edit: humm it doesn't work O: infinite loop probably \:
Where I go wrong?Code:void Delay (int ms)
{
time_t first = time(NULL), second = first;
while (second - first < ms)
second = time(NULL);
}
---
Anon, Adak is right ("which would perhaps vary from one computer to the next") but thank you too (8
See how we got rid of a whole heap of division? ;-) [Of course, it doesn't make much difference here, as we should really not be spending the entire time calling clock - that is pretty bad, really.]Code:#include <time.h>
void Delay (unsigned int Sec)
{
clock_t ticks1 = clock(), ticks2 = ticks1;
clock_t target = Sec * CLOCKS_PER_SEC;
while ( ( ticks2 - ticks1) < target)
ticks2 = clock();
}
Note that whilst CLOCKS_PER_SEC is not guaranteed to be 1000 - it could be 50, 100, 643, 1142 or any other number the system implementer fancies using. It is COMMONLY 1000, but that's not the same as a guarantee by the standard.
You could of course change your interface to take a millisecond value, and then adjust it by multiplying by CLOCKS_PER_SEC and dividing by 1000 - as long as you don't need excessively long periods (as in MANY DAYS, 46 days with CLOCKS_PER_SEC = 1000) it should be OK.
In linux/unix, there is "usleep()" which gives you a sleep time in microseconds. It may not be as precise as the input value indicates, but it's definitely a better way to not waste all the CPU capacity on checking what time it is. Let some other task run if you don't want to do something.
--
Mats
Humm ok but you probably haven't seen my last post.
I am traying to create a delay function with the same arguments as the Sleep function - why am I using time.h? cause I want it to be permanent (I mean that I want it to be the same between different computers).
Clear? (:
What?!
I think that post is spam, and I have reported it...
I also think that my reply gives a sane suggestion as to how you could implement your code. However, I seriously suggest that you make a wrapper that calls the releveant sleep-type function on the platform you choose to use, rather than spinning on calls to clock() - it is wasting CPU time that can be used to do other useful work.
--
Mats
ohh
I tried not using "clock" (as Adak has suggested) but it's no working and I really don't understand what "wrapper" means(?)
(I am just traying to create a delay function @_@)
A "wrapper" function is a function that "hides the name" of a non-portable function, e.g. we have the functions linuxfunc (which is also available on other Unix) and WindowsFunc, which takes different arguments, and return different return values, but otherwise does the same thing, so we could do something like this:
--Code:int wrappedfunc(int a)
{
#if defined(WINDOWS)
BOOL res;
res = WindwosFunc(a, NULL);
if (res) return 0; // Success.
else return -1; // Fail
#elseif defined(LINUX) || defined(UNIX)
return linuxfunc(a * 10); // Returns -1 for fail, 0 for success.
#else
// We don't know what to do if it's not LINUX/UNIX, so let the compiler tell us
#error "This only works for only Linux, Unix and Windows - please add code here to support other OS's"
#endif
}
Mats
Do you mean something like this:
?Code:#ifdef linux
#define clr() system("clear");
#elif _WIN32
#define clr() system("cls");
#endif
Anyway I don't care about the OS..
"Sleep" influence changes between diffrent computers right?
Yes, that's another way to do the same thing. Although I would try to avoid using system() to achieve something like that.Quote:
Originally Posted by gavra
If you mean that "Sleep" in Windows is different (besides capitalization) from the "sleep" in Linux, yes they are. And there is a "usleep" that you can use in Linux to get the same effect as Sleep if you want millisecond (or thereabouts) precision.Quote:
Anyway I don't care about the OS..
"Sleep" influence changes between diffrent computers right?
--
Mats
avoid and replace it with..?
no no no XD
I meant diffrent computers not diffrent operation systems (for example a slow one and a faster one - the outcome will be diffrent [right?])
Sleep in windows will "delay" your program for X milliseconds - as long as your system clock is working correct, it will be precise, no matter what speed your system is (within a few milliseconds assuming no other application loading the system - if your system is heavily loaded, no delay operation is guaranteed anyways). The same applies to the corresponding functions in Linux.
--
Mats
Fine, so what should I do if I want to "delay" my program for X milliseconds (I want it to be precise) no matter if my system clock is working correct?
What do you mean "no matter if my system clock is working correct" - if you have broken hardware, it's not going to be reliable. Period.Quote:
Originally Posted by gavra
--
Mats
XD
hum I checked 2 computers to see how many clocks they do for 1 sec' and the results were diffrent - ?!
What do you mean? You mean how many loops of "time2 = clock()" they will do - yes, sure, that will vary from one system to another depending on CPU speed. However, this:Quote:
Originally Posted by gavra
should give you the same number on different machines, because your system is ticking at the same rate.Code:#include <stdio.h>
#include <time.h>
#include <windows.h>
int main()
{
clock_t t1 = clock(), t2;
Sleep(1000);
t2 = clock()-t1;
printf("time=%d\n", (int)t2);
return 0;
}
--
Mats
1000 I guess it's the same.
when I do something similar I got 907..
Post your code.Quote:
Originally Posted by gavra
But I would also point out that you can not expect the timing in any non-Real-Time-OS to be precise [and RTOS's are only precise if you follow certain rules, e.g. higher priority threads would dictate the real-time behaviour of low priority tasks].
--
Mats
Code:#include <time.h>
#include <stdio.h>
int main(void)
{
clock_t ticks1 = clock(), ticks2 = ticks1;
while((ticks2/CLOCKS_PER_SEC-ticks1/CLOCKS_PER_SEC) < 1)
ticks2=clock();
printf("Took %d ticks to wait one second.\n",ticks2-ticks1);
getchar();
return 0;
}
I don't seem to be able to reproduce it. I rewrote your program to run in an infinite loop and track the min/max values, like this:
The first time, I get a start of 15 and end of 1015.Code:
#include <time.h>
#include <stdio.h>
int main(void)
{
int minT = 10000, maxT = 0;
int t = 0;
do {
clock_t ticks1 = clock(), ticks2 = ticks1;
while((ticks2/CLOCKS_PER_SEC-ticks1/CLOCKS_PER_SEC) < 1)
ticks2=clock();
t = ticks2 - ticks1;
if (minT > t) minT = t;
if (maxT < t) maxT = t;
printf("Took %d ticks to wait one second (%d, %d, min=%d, max=%d).\n",t, (int)ticks1, (int)ticks2, minT, maxT);
} while(1);
return 0;
}
--
Mats
ohh cool it starts with 907 and then all the next get to 1000 - why? XD
Don't know. I'll play with it a bit and see if I can figure something out.Quote:
Originally Posted by gavra
--
Mats
O:
Ok if this thread won't be here PM me.
I still cant get it BELOW 1015 for the first iteration, but I beleive this is more accurate as it doesn't throw away any of the bits in the input number:Quote:
Originally Posted by gavra
--Code:clock_t ticks1 = clock(), ticks2 = ticks1;
clock_t target = 1 * CLOCKS_PER_SEC;
while(ticks2-ticks1 < target)
ticks2=clock();
Mats