Are there any timing functions in JavaScript with microsecond resolution?
I am aware of timer.js for Chrome, and am hoping there will be a solution for other friendly browsers, like Firefox, Safari, Opera, Epiphany, Konqueror, etc. I'm not interested in supporting any IE, but answers including IE are welcome.
(Given the poor accuracy of millisecond timing in JS, I'm not holding my breath on this one!)
Update: timer.js advertises microsecond resolution, but it simply multiplies the millisecond reading by 1,000. Verified by testing and code inspection. Disappointed. :[
As alluded to in Mark Rejhon's answer, there is an API available in modern browsers that exposes sub-millisecond resolution timing data to script: the W3C High Resolution Timer, aka window.performance.now().
now() is better than the traditional Date.getTime() in two important ways:
now() is a double with submillisecond resolution that represents the number of milliseconds since the start of the page's navigation. It returns the number of microseconds in the fractional (e.g. a value of 1000.123 is 1 second and 123 microseconds).
now() is monotonically increasing. This is important as Date.getTime() can possibly jump forward or even backward on subsequent calls. Notably, if the OS's system time is updated (e.g. atomic clock synchronization), Date.getTime() is also updated. now() is guaranteed to always be monotonically increasing, so it is not affected by the OS's system time -- it will always be wall-clock time (assuming your wall clock is not atomic...).
now() can be used in almost every place that new Date.getTime(), + new Date and Date.now() are. The exception is that Date and now() times don't mix, as Date is based on unix-epoch (the number of milliseconds since 1970), while now() is the number of milliseconds since your page navigation started (so it will be much smaller than Date).
now() is supported in Chrome stable, Firefox 15+, and IE10. There are also several polyfills available.
Note: When using Web Workers, the window variable isn't available, but you can still use performance.now().
There's now a new method of measuring microseconds in javascript:
http://gent.ilcore.com/2012/06/better-timer-for-javascript.html
However, in the past, I found a crude method of getting 0.1 millisecond precision in JavaScript out of a millisecond timer. Impossible? Nope. Keep reading:
I'm doing some high-precisio experiments that requires self-checked timer accuracies, and found I was able to reliably get 0.1 millisecond precision with certain browsers on certain systems.
I have found that in modern GPU-accelerated web browsers on fast systems (e.g. i7 quad core, where several cores are idle, only browser window) -- I can now trust the timers to be millisecond-accurate. In fact, it's become so accurate on an idle i7 system, I've been able to reliably get the exact same millisecond, over more than 1,000 attempts. Only when I'm trying to do things like load an extra web page, or other, the millisecond accuracy degrades (And I'm able to successfully catch my own degraded accuracy by doing a before-and-after time check, to see if my processing time suddenly lengthened to 1 or more milliseconds -- this helps me invalidate results that has probably been too adversely affected by CPU fluctuations).
It's become so accurate in some GPU accelerated browsers on i7 quad-core systems (when the browser window is the only window), that I've found I wished I could access a 0.1ms precision timer in JavaScript, since the accuracy is finally now there on some high-end browsing systems to make such timer precision worthwhile for certain types of niche applications that requires high-precision, and where the applications are able to self-verify for accuracy deviations.
Obviously if you are doing several passes, you can simply run multiple passes (e.g. 10 passes) then divide by 10 to get 0.1 millisecond precision. That is a common method of getting better precision -- do multiple passes and divide the total time by number of passes.
HOWEVER...If I can only do a single benchmark pass of a specific test due to an unusually unique situation, I found out that I can get 0.1 (And sometimes 0.01ms) precision by doing this:
Initialization/Calibration:
Run a busy loop to wait until timer increments to the next millisecond (align timer to beginning of next millisecond interval) This busy loop lasts less than a millisecond.
Run another busy loop to increment a counter while waiting for timer to increment. The counter tells you how many counter increments occured in one millisecond. This busy loop lasts one full millisecond.
Repeat the above, until the numbers become ultra-stable (loading time, JIT compiler, etc). 4. NOTE: The stability of the number gives you your attainable precision on an idle system. You can calculate the variance, if you need to self-check the precision. The variances are bigger on some browsers, and smaller on other browsers. Bigger on faster systems and slower on slower systems. Consistency varies too. You can tell which browsers are more consistent/accurate than others. Slower systems and busy systems will lead to bigger variances between initialization passes. This can give you an opportunity to display a warning message if the browser is not giving you enough precision to allow 0.1ms or 0.01ms measurements. Timer skew can be a problem, but some integer millisecond timers on some systems increment quite accurately (quite right on the dot), which will result in very consistent calibration values that you can trust.
Save the final counter value (or average of the last few calibration passes)
Benchmarking one pass to sub-millisecond precision:
Run a busy loop to wait until timer increments to the next millisecond (align timer to beginning of next millisecond interval). This busy loop lasts less than a millisecond.
Execute the task you want to precisely benchmark the time.
Check the timer. This gives you the integer milliseconds.
Run a final busy loop to increment a counter while waiting for timer to increment. This busy loop lasts less than a millisecond.
Divide this counter value, by the original counter value from initialization.
Now you got the decimal part of milliseconds!!!!!!!!
WARNING: Busy loops are NOT recommended in web browsers, but fortunately, these busy loops run for less than 1 millisecond each, and are only run a very few times.
Variables such as JIT compilation and CPU fluctuations add massive inaccuracies, but if you run several initialization passes, you'll have full dynamic recompilation, and eventually the counter settles to something very accurate. Make sure that all busy loops is exactly the same function for all cases, so that differences in busy loops do not lead to differences. Make sure all lines of code are executed several times before you begin to trust the results, to allow JIT compilers to have already stabilized to a full dynamic recompilation (dynarec).
In fact, I witnessed precision approaching microseconds on certain systems, but I wouldn't trust it yet. But the 0.1 millisecond precision appears to work quite reliably, on an idle quad-core system where I'm the only browser page. I came to a scientific test case where I could only do one-off passes (due to unique variables occuring), and needed to precisely time each pass, rather than averaging multiple repeat pass, so that's why I did this.
I did several pre-passes and dummy passes (also to settle the dynarec), to verify reliability of 0.1ms precision (stayed solid for several seconds), then kept my hands off the keyboard/mouse, while the benchmark occured, then did several post-passes to verify reliability of 0.1ms precision (stayed solid again). This also verifies that things such as power state changes, or other stuff, didn't occur between the before-and-after, interfering with results. Repeat the pre-test and post-test between every single benchmark pass. Upon this, I was quite virtually certain the results in between were accurate. There is no guarantee, of course, but it goes to show that accurate <0.1ms precision is possible in some cases in a web browser.
This method is only useful in very, very niche cases. Even so, it literally won't be 100% infinitely guaranteeable, you can gain quite very trustworthy accuracy, and even scientific accuracy when combined with several layers of internal and external verifications.
Here is an example showing my high-resolution timer for node.js:
function startTimer() {
const time = process.hrtime();
return time;
}
function endTimer(time) {
function roundTo(decimalPlaces, numberToRound) {
return +(Math.round(numberToRound + `e+${decimalPlaces}`) + `e-${decimalPlaces}`);
}
const diff = process.hrtime(time);
const NS_PER_SEC = 1e9;
const result = (diff[0] * NS_PER_SEC + diff[1]); // Result in Nanoseconds
const elapsed = result * 0.0000010;
return roundTo(6, elapsed); // Result in milliseconds
}
Usage:
const start = startTimer();
console.log('test');
console.log(`Time since start: ${endTimer(start)} ms`);
Normally, you might be able to use:
console.time('Time since start');
console.log('test');
console.timeEnd('Time since start');
If you are timing sections of code that involve looping, you cannot gain access to the value of console.timeEnd() in order to add your timer results together. You can, but it get gets nasty because you have to inject the value of your iterating variable, such as i, and set a condition to detect if the loop is done.
Here is an example because it can be useful:
const num = 10;
console.time(`Time til ${num}`);
for (let i = 0; i < num; i++) {
console.log('test');
if ((i+1) === num) { console.timeEnd(`Time til ${num}`); }
console.log('...additional steps');
}
Cite: https://nodejs.org/api/process.html#process_process_hrtime_time
The answer is "no", in general. If you're using JavaScript in some server-side environment (that is, not in a browser), then all bets are off and you can try to do anything you want.
edit — this answer is old; the standards have progressed and newer facilities are available as solutions to the problem of accurate time. Even so, it should be remembered that outside the domain of a true real-time operating system, ordinary non-privileged code has limited control over its access to compute resources. Measuring performance is not the same (necessarily) as predicting performance.
editing again — For a while we had performance.now(), but at present (2022 now) browsers have degraded the accuracy of that API for security reasons.
I have a function that does simple performance benchmarking of arbitrary JS function invocation like this:
function benchmark(f) {
var startTime = Date.now();
f();
var endTime = Date.now();
console.log('Elapsed: %d ms', endTime - startTime);
}
The functions that I test with it take typically 2-5s to execute, so the overhead of counting one full call to Date.now() is negligible.
Nevertheless, the benchmark times vary quite considerably based on what other processes happen to be running on my machine, so even if I run the benchmark several times and take the smallest value I can still see variations of 20-50% between between successive (sets of) runs—even when the machine is "mostly" idle. This makes it difficult to see performance changes of <5%.
I end up having to watch Activity Monitor and wait until the system looks (mostly) idle, then hope that nothing else starts up in the middle of the run. I'd like, instead, to modify the benchmark to measure elapsed CPU time instead of elapsed wall time. This should make it mostly insensitive to being blocked on I/O and considerably less sensitive to CPU contention (though not insensitive: due to hyper-threading I expect that if the number of runnable threads exceeds the number of physical CPU cores that the apparent performance will decrease as hyper-threads contend for actual hardware).
How can I query the elapsed CPU time of the node process from within Node?
I want to measure the time it takes for a javascript method to execute in an Android web application. Unfortunately Date.now() does not work since measuring in milliseconds is too inaccurate. To my knowledge performance.now() does not work in the Android browser.
Is there any way to get the current time in microseconds in javascript in the android browser?
This is my usage scenario:
function measure_time(){
var start = Date.now();
....do something....
var end = Date.now();
alert(end-start);
}
call System.nanoTime() when you start and stop. Note that System.nanoTime() has precision, but not accuracy, so it's most likely not synced up to the world clock in real time but still useful for measuring how long something took to do. Divide the result by 1000 to get the number in microseconds
You simply loop the script you want to test 1000 times and then divide the outcome by 1000.
Chapter 6 "Responsive Interfaces" of "High Performance JavaScript" book by Nicholas C. Zakas says the following thing about Timer Precision:
Timer resolution on Windows systems is 15 milliseconds, meaning that
it will interpret a timer delay of 15 as either 0 or 15, depending on
when the system time was last updated. Setting timer delays of less
than 15 can cause browser locking in Internet Explorer, so the
smallest recommended delay is 25 milliseconds (which will end up as
either 15 or 30) to ensure a delay of at least 15 milliseconds.
What is the meaning of "browser locking" here? Does that mean that widely used approach setTimeout(task, 0) to move a task to the end of UI thread queue can make IE hang?
setTimeout runs your task once, I don't think this will cause a lockup.
My interpretation of your book snippet is that he is referring to repeated executions, such as with setInterval. If you set code to execute every 0 milliseconds, then yeah, I could see IE having a problem with that.
I have been using it and no I have not experienced any issues with it. It allows the browser to use time slots for its rendering thread which actually is very useful in some cases.
Obviously I can set the delay to the number of miliseconds until the date I want, but that's not really going to work well in some cases, max int values are going to be a problem. If Kue can't do it, I can store date-specific jobs that are too far away in the main database that the client facing app uses, or maybe a third store, I'm just trying to avoid using more than one store for this process.
UPDATE: This is a silly question, I did some math in my head quickly and failed horribly, I guess, then asked, I should have calculated exactly before I asked.
Kue doesn't have any other way to scheduling a job, unfortunately. I do wonder what jobs you have that are need to be scheduled so far out as to overflow an integer. Considering Kue is backed by Redis I probably wouldn't want to rely on it to schedule jobs many years into the future.
If you really have to do it, then you could store the execute date with the job, and have the delay set as high as possible. When it comes time to execute, check if that date has passed, and if not then just requeue the job with the remaining ms, or with the max if the remaining is still too high.
I wouldn't worry about it due to the size of the max integer in JavaScript.
The documentation states that the dates are relative to now,
so you can schedule jobs to start up to 285,427.017 years (9,007,199,254,740,992 milliseconds) into the future. Even though it says that it most likely converts the date to an absolute date which has a smaller but still rather large limit of just under: 243,090.534 years 97,671,189,983,570,992 milliseconds).
Time wise I'd be more considered about the 32-bit second overflow in 2038.