std.datetime

auto currentTime = Clock.currTime();
auto timeString = currentTime.toISOExtString();
auto restoredTime = SysTime.fromISOExtString(timeString);

alias AutoStart = std.typecons.Flag!"autoStart".Flag;

Used by StopWatch to indicate whether it should start immediately upon construction.

If set to AutoStart.no, then the stopwatch is not started when it is constructed.

Otherwise, if set to AutoStart.yes, then the stopwatch is started when it is constructed.

struct StopWatch;

This will be deprecated in 2.076. Please use StopWatch">std.datetime.stopwatch.StopWatch instead. It uses core.time.Monotime and core.time.Duration rather than core.time.TickDuration, which will also be deprecated in 2.076.

StopWatch measures time as precisely as possible.

This class uses a high-performance counter. On Windows systems, it uses QueryPerformanceCounter, and on Posix systems, it uses clock_gettime if available, and gettimeofday otherwise.

But the precision of StopWatch differs from system to system. It is impossible to for it to be the same from system to system since the precision of the system clock varies from system to system, and other system-dependent and situation-dependent stuff (such as the overhead of a context switch between threads) can also affect StopWatch's accuracy.

Examples:

void writeln(S...)(S args){}
static void bar() {}

StopWatch sw;
enum n = 100;
TickDuration[n] times;
TickDuration last = TickDuration.from!"seconds"(0);
foreach (i; 0 .. n)
{
   sw.start(); //start/resume mesuring.
   foreach (unused; 0 .. 1_000_000)
       bar();
   sw.stop();  //stop/pause measuring.
   //Return value of peek() after having stopped are the always same.
   writeln((i + 1) * 1_000_000, " times done, lap time: ",
           sw.peek().msecs, "[ms]");
   times[i] = sw.peek() - last;
   last = sw.peek();
}
real sum = 0;
// To get the number of seconds,
// use properties of TickDuration.
// (seconds, msecs, usecs, hnsecs)
foreach (t; times)
   sum += t.hnsecs;
writeln("Average time: ", sum/n, " hnsecs");

@nogc @safe this(AutoStart autostart);

Auto start with constructor.

const pure nothrow @nogc @safe bool opEquals(const StopWatch rhs);

const pure nothrow @nogc @safe bool opEquals(ref const StopWatch rhs);

@nogc @safe void reset();

Resets the stop watch.

Examples:

StopWatch sw;
sw.start();
sw.stop();
sw.reset();
writeln(sw.peek().to!("seconds", real)()); // 0

@nogc @safe void start();

Starts the stop watch.

@nogc @safe void stop();

Stops the stop watch.

const @nogc @safe TickDuration peek();

Peek at the amount of time which has passed since the stop watch was started.

@nogc @safe void setMeasured(TickDuration d);

Set the amount of time which has been measured since the stop watch was started.

const pure nothrow @nogc @property @safe bool running();

Confirm whether this stopwatch is measuring time.

TickDuration[fun.length] benchmark(fun...)(uint n);

This will be deprecated in 2.076. Please use benchmark">std.datetime.stopwatch.benchmark instead. It uses core.time.Monotime and core.time.Duration rather than core.time.TickDuration, which will also be deprecated in 2.076.

Benchmarks code for speed assessment and comparison.

Parameters:

fun	aliases of callable objects (e.g. function names). Each should take no arguments.
uint n	The number of times each function is to be executed.

Returns:

The amount of time (as a core.time.TickDuration) that it took to call each function n times. The first value is the length of time that it took to call fun[0] n times. The second value is the length of time it took to call fun[1] n times. Etc.

Note that casting the TickDurations to core.time.Durations will make the results easier to deal with (and it may change in the future that benchmark will return an array of Durations rather than TickDurations).

See Also:

measureTime

Examples:

import std.conv : to;
int a;
void f0() {}
void f1() {auto b = a;}
void f2() {auto b = to!string(a);}
auto r = benchmark!(f0, f1, f2)(10_000);
auto f0Result = to!Duration(r[0]); // time f0 took to run 10,000 times
auto f1Result = to!Duration(r[1]); // time f1 took to run 10,000 times
auto f2Result = to!Duration(r[2]); // time f2 took to run 10,000 times

struct ComparingBenchmarkResult;

Return value of benchmark with two functions comparing.

const pure nothrow @property @safe real point();

Evaluation value

This returns the evaluation value of performance as the ratio of baseFunc's time over targetFunc's time. If performance is high, this returns a high value.

const pure nothrow @property @safe TickDuration baseTime();

The time required of the base function

const pure nothrow @property @safe TickDuration targetTime();

The time required of the target function

ComparingBenchmarkResult comparingBenchmark(alias baseFunc, alias targetFunc, int times = 4095)();

This will be deprecated in 2.076. Please use std.datetime.stopwatch.benchmark instead. This function has not been ported to core.time.Monotime and core.time.Duration, because it is a trivial wrapper around benchmark.

Benchmark with two functions comparing.

Parameters:

baseFunc	The function to become the base of the speed.
targetFunc	The function that wants to measure speed.
times	The number of times each function is to be executed.

Examples:

void f1x() {}
void f2x() {}
@safe void f1o() {}
@safe void f2o() {}
auto b1 = comparingBenchmark!(f1o, f2o, 1)(); // OK
//writeln(b1.point);

@safe auto measureTime(alias func)()
if (isSafe!(() { StopWatch sw; unaryFun!func(sw.peek()); } ));

This will be deprecated in 2.076. Please use std.datetime.stopwatch.StopWatch instead. This function has not been ported to core.time.Monotime and core.time.Duration, because it is a trivial wrapper around StopWatch.

Function for starting to a stop watch time when the function is called and stopping it when its return value goes out of scope and is destroyed.

When the value that is returned by this function is destroyed, func will run. func is a unary function that takes a core.time.TickDuration.

Example

{
    auto mt = measureTime!((TickDuration a)
        { /+ do something when the scope is exited +/ });
    // do something that needs to be timed
}

which is functionally equivalent to

{
    auto sw = StopWatch(Yes.autoStart);
    scope(exit)
    {
        TickDuration a = sw.peek();
        /+ do something when the scope is exited +/
    }
    // do something that needs to be timed
}

See Also:

benchmark