Copyright © 2015 W3C® (MIT, ERCIM, Keio, Beihang). W3C liability, trademark and document use rules apply.
This specification defines an API that provides the current time in sub-millisecond resolution and such that it is not subject to system clock skew or adjustments.
This section describes the status of this document at the time of its publication. Other documents may supersede this document. A list of current W3C publications and the latest revision of this technical report can be found in the W3C technical reports index at http://www.w3.org/TR/.
This is a work in progress and may change without any notices.
High Resolution Time Level 2 replaces the first version of High Resolution Time [HR-TIME] and includes:
Performance
interface, including support for the Performance.now
method in Web Workers [WORKERS];
This document was published by the Web Performance Working Group as a Working Draft.
This document is intended to become a W3C Recommendation.
If you wish to make comments regarding this document, please send them to
public-web-perf@w3.org
(subscribe,
archives)
with [hr-time]
at the start of your email's subject.
All comments are welcome.
Publication as a Working Draft does not imply endorsement by the W3C Membership. This is a draft document and may be updated, replaced or obsoleted by other documents at any time. It is inappropriate to cite this document as other than work in progress.
This document was produced by a group operating under the 5 February 2004 W3C Patent Policy. W3C maintains a public list of any patent disclosures made in connection with the deliverables of the group; that page also includes instructions for disclosing a patent. An individual who has actual knowledge of a patent which the individual believes contains Essential Claim(s) must disclose the information in accordance with section 6 of the W3C Patent Policy.
This document is governed by the 1 September 2015 W3C Process Document.
This section is non-normative.
The ECMAScript Language specification [ECMA-262] defines the Date object as a time value representing time in milliseconds since 01 January, 1970 UTC. For most purposes, this definition of time is sufficient as these values represent time to millisecond precision for any instant that is within approximately 285,616 years from 01 January, 1970 UTC. The DOMTimeStamp is defined similarly [WebIDL].
In practice, these definitions of time are subject to both clock skew and adjustment of the system clock. The value of time may not always be monotonically increasing and subsequent values may either decrease or remain the same.
For example, the following script may log a positive number, negative number, or zero.
var mark_start = Date.now(); doTask(); // Some task if (window.console) window.console.log('Duration of task: ' + (Date.now() - mark_start));
For certain tasks this definition of time may not be sufficient as it does not allow for sub-millisecond resolution and is subject to system clock skew. For example,
This specification does not propose changing the behavior of Date.now()
[ECMA-262] as it is genuinely useful in determining the current value of the calendar time and has a long history of
usage. The DOMHighResTimeStamp
type and the Performance.now
method of the
Performance
interface resolve the issues summarized in this section by providing a monotonically increasing time value in sub-millisecond resolution.
This section is non-normative.
A developer may wish to construct a timeline of their entire application, including events from dedicated or shared workers, which have a different time origin. To display such events on the same timeline, the application can translate the DOMHighResTimeStamps
from the worker with the Performance.translateTime
method.
// ---- worker.js ----------------------------- // Shared worker script onconnect = function(e) { var port = e.ports[0]; port.onmessage = function(e) { // Time execution in worker var task_start = performance.now(); result = runSomeWorkerTask(); var task_end = performance.now(); port.postMessage({ 'task': 'Some worker task', 'start_time': task_start, 'end_time': task_end, 'result': result }); } } // ---- application.js ------------------------ // Timing tasks in the document var task_start = performance.now(); result = runSomeWorkerTask(); var task_end = performance.now(); plotEventOnTimeline({ 'task': 'Some document task', 'start_time': task_start, 'end_time': task_end, 'result': result }); // Translating worker timestamps into document's time origin var worker = new SharedWorker('worker.js'); worker.port.onmessage = function (event) { var msg = event.data; // translate timestamps into document's time origin msg.start_time = performance.translateTime(msg.start_time, worker); msg.end_time = performance.translateTime(msg.end_time, worker); // plot the results on document's timeline plotEventOnTimeline(msg); }
As well as sections marked as non-normative, all authoring guidelines, diagrams, examples, and notes in this specification are non-normative. Everything else in this specification is normative.
The key words MUST and SHOULD are to be interpreted as described in [RFC2119].
Some conformance requirements are phrased as requirements on attributes, methods or objects. Such requirements are to be interpreted as requirements on user agents.
The IDL fragments in this specification must be interpreted as required for conforming IDL fragments, as described in the Web IDL specification. [WebIDL]
The time origin is the time value from which time is measured:
Window
object, the time origin must be equal to the time of starting the navigation responsible for loading the Window object's newest Document object, unless a confirmation dialog is displayed during the prompt to unload algorithm, in which case the time of the user confirming the navigation must be used instead. If there is no previous document, the time origin must be equal to the time when the browsing context is first created. [HTML51]WorkerGlobalScope
object, the time origin must be equal to the official moment of creation of the worker. [WORKERS]DOMHighResTimeStamp
Type
The DOMHighResTimeStamp
type is used to store a time value measured relative from the
time origin or a time value that represents a duration
between two DOMHighResTimeStamp
s.
typedef double DOMHighResTimeStamp;
A DOMHighResTimeStamp
SHOULD represent a time in milliseconds accurate to 5 microseconds - see 8. Privacy and Security.
If the User Agent is unable to provide a time value accurate to 5 microseconds due to hardware or software constraints, the User Agent can represent a DOMHighResTimeStamp
as a time in milliseconds accurate to a millisecond.
Performance
interface[Exposed=(Window,Worker)]
interface Performance : EventTarget {
DOMHighResTimeStamp
now
();
serializer = {attribute};
};
The now()
method MUST
return a DOMHighResTimeStamp
representing the time in milliseconds
from the time origin to the occurrence of the call to the Performance.now
method.
The translateTime(time, timeSource)
method MUST return a DOMHighResTimeStamp
as follows:
time
argument.
timeSource
object.
this
value for the Performance.translateTime
call.
performance
attribute
The GlobalPerformance.performance
attribute allows access to performance related attributes and methods from the global object.
[NoInterfaceObject, Exposed=(Window,Worker)] interface GlobalPerformance { [Replaceable] readonly attributePerformance
performance; }; Window implementsGlobalPerformance
; WorkerGlobalScope implementsGlobalPerformance
;
The time values returned when calling the Performance.now
method on Performance
objects with the same time origin MUST be monotonically increasing and not subject to system clock
adjustments or system clock skew. The difference between any two chronologically recorded time values returned from the
Performance.now
method MUST never be negative if the two time values have the same time origin. Performance.translateTime
MUST be used to compare two chronologically recorded time values of different time origin.
Cache attacks and statistical fingerprinting is a privacy and security concern where a malicious web site may use high resolution timing data of various browser or application-initiated operations to identify a particular user - see [CACHE-ATTACKS]. To mitigate such attacks, the recommended minimum resolution of the Performance
interface should be set to 5 microseconds.
The editors would like to thank the following people for contributing to this specification: Karen Anderson, Nat Duca, Tony Gentilcore, Arvind Jain, Jason Weber, Boris Zbarsky, Yossef Oren, Vasileios P. Kemerlis, Simha Sethumadhavan, and Angelos D. Keromytis to acknowledge their contributions to this work.