std.datetime.stopwatch - D Programming Language
Description: D Programming Language
Keywords: D programming language

Menu

- Learn
- Documentation
  - Language Reference
  - Library Reference
  - Command-line Reference
  - Feature Overview
  - Articles
- Downloads
- Packages
- Community
  - Blog
  - Orgs using D
  - Twitter
  - Calendar
  - Forums
  - IRC
  - Community Discord
  - Wiki
  - GitHub
  - Issues
  - Get involved
  - Contributors
  - Foundation
  - Security Team
  - Donate
  - Sponsors
- Resources
  - Tour
  - Books
  - Tutorials
  - Tools
  - Editors
  - IDEs
  - run.dlang.io
  - Visual D
  - Acknowledgments
  - D Style
  - Glossary
  - Sitemap

Search
Report a bug
If you spot a problem with this page, click here to create a Bugzilla issue.
Improve this page
Quickly fork, edit online, and submit a pull request for this page. Requires a signed-in GitHub account. This works well for small changes. If you'd like to make larger changes you may want to consider using a local clone.

# std.datetime.stopwatch

Module containing some basic benchmarking and timing functionality.
For convenience, this module publicly imports core.time.

Category | Functions
--- | ---
Main functionality | StopWatch benchmark
Flags | AutoStart

Unlike the other modules in std.datetime, this module is not currently publicly imported in std.datetime.package, because the old versions of this functionality which use core.time.TickDuration are in std.datetime.package and would conflict with the symbols in this module. After the old symbols have gone through the deprecation cycle and have been fully removed, then this module will be publicly imported in std.datetime.package. The old, deprecated symbols has been removed from the documentation in December 2019 and currently scheduled to be fully removed from Phobos after 2.094.
So, for now, when using std.datetime.stopwatch, if other modules from std.datetime are needed, then either import them individually rather than importing std.datetime, or use selective or static imports to import std.datetime.stopwatch. e.g.

    import std.datetime;
    import std.datetime.stopwatch : benchmark, StopWatch;

The compiler will then know to use the symbols from std.datetime.stopwatch rather than the deprecated ones from std.datetime.package.
License:
Boost License 1.0.
Authors:
Jonathan M Davis and Kato Shoichi

Source std/datetime/stopwatch.d

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`;
  StopWatch is used to measure time just like one would do with a physical stopwatch, including stopping, restarting, and/or resetting it.
  core.time.MonoTime is used to hold the time, and it uses the system's monotonic clock, which is high precision and never counts backwards (unlike the wall clock time, which can count backwards, which is why std.datetime.systime.SysTime should not be used for timing).
  Note that the precision of StopWatch differs from system to system. It is impossible for it to be the same for all systems, since the precision of the system clock and other system-dependent and situation-dependent factors (such as the overhead of a context switch between threads) varies from system to system and can affect StopWatch's accuracy.
  Examples:
  Measure a time in milliseconds, microseconds, or nanoseconds

      auto sw = StopWatch(AutoStart.no);
      sw.start();
      // ... Insert operations to be timed here ...
      sw.stop();

      long msecs = sw.peek.total!"msecs";
      long usecs = sw.peek.total!"usecs";
      long nsecs = sw.peek.total!"nsecs";

      assert(usecs >= msecs * 1000);
      assert(nsecs >= usecs * 1000);

  Examples:

      import core.thread : Thread;

      auto sw = StopWatch(AutoStart.yes);

      Duration t1 = sw.peek();
      Thread.sleep(usecs(1));
      Duration t2 = sw.peek();
      assert(t2 > t1);

      Thread.sleep(usecs(1));
      sw.stop();

      Duration t3 = sw.peek();
      assert(t3 > t2);
      Duration t4 = sw.peek();
      writeln(t3); // t4

      sw.start();
      Thread.sleep(usecs(1));

      Duration t5 = sw.peek();
      assert(t5 > t4);

      // If stopping or resetting the StopWatch is not required, then
      // MonoTime can easily be used by itself without StopWatch.
      auto before = MonoTime.currTime;
      // do stuff...
      auto timeElapsed = MonoTime.currTime - before;

  nothrow @nogc @safe this(AutoStart `autostart`);
    Constructs a StopWatch. Whether it starts immediately depends on the AutoStart argument.
    If StopWatch.init is used, then the constructed StopWatch isn't running (and can't be, since no constructor ran).
    Examples:

        import core.thread : Thread;

        {
            auto sw = StopWatch(AutoStart.yes);
            assert(sw.running);
            Thread.sleep(usecs(1));
            assert(sw.peek() > Duration.zero);
        }
        {
            auto sw = StopWatch(AutoStart.no);
            assert(!sw.running);
            Thread.sleep(usecs(1));
            writeln(sw.peek()); // Duration.zero
        }
        {
            StopWatch sw;
            assert(!sw.running);
            Thread.sleep(usecs(1));
            writeln(sw.peek()); // Duration.zero
        }

        writeln(StopWatch.init); // StopWatch(AutoStart.no)
        assert(StopWatch.init != StopWatch(AutoStart.yes));

  nothrow @nogc @safe void `reset`();
    Resets the StopWatch.
    The StopWatch can be reset while it's running, and resetting it while it's running will not cause it to stop.
    Examples:

        import core.thread : Thread;

        auto sw = StopWatch(AutoStart.yes);
        Thread.sleep(usecs(1));
        sw.stop();
        assert(sw.peek() > Duration.zero);
        sw.reset();
        writeln(sw.peek()); // Duration.zero

  nothrow @nogc @safe void `start`();
    Starts the StopWatch.
    start should not be called if the StopWatch is already running.
    Examples:

        import core.thread : Thread;

        StopWatch sw;
        assert(!sw.running);
        writeln(sw.peek()); // Duration.zero
        sw.start();
        assert(sw.running);
        Thread.sleep(usecs(1));
        assert(sw.peek() > Duration.zero);

  nothrow @nogc @safe void `stop`();
    Stops the StopWatch.
    stop should not be called if the StopWatch is not running.
    Examples:

        import core.thread : Thread;

        auto sw = StopWatch(AutoStart.yes);
        assert(sw.running);
        Thread.sleep(usecs(1));
        immutable t1 = sw.peek();
        assert(t1 > Duration.zero);

        sw.stop();
        assert(!sw.running);
        immutable t2 = sw.peek();
        assert(t2 >= t1);
        immutable t3 = sw.peek();
        writeln(t2); // t3

  const nothrow @nogc @safe Duration `peek`();
    Peek at the amount of time that the the StopWatch has been running.
    This does not include any time during which the StopWatch was stopped but does include all of the time that it was running and not just the time since it was started last.
    Calling reset will reset this to Duration.zero.
    Examples:

        import core.thread : Thread;

        auto sw = StopWatch(AutoStart.no);
        writeln(sw.peek()); // Duration.zero
        sw.start();

        Thread.sleep(usecs(1));
        assert(sw.peek() >= usecs(1));

        Thread.sleep(usecs(1));
        assert(sw.peek() >= usecs(2));

        sw.stop();
        immutable stopped = sw.peek();
        Thread.sleep(usecs(1));
        writeln(sw.peek()); // stopped

        sw.start();
        Thread.sleep(usecs(1));
        assert(sw.peek() > stopped);

  nothrow @nogc @safe void `setTimeElapsed`(Duration `timeElapsed`);
    Sets the total time which the StopWatch has been running (i.e. what peek returns).
    The StopWatch does not have to be stopped for setTimeElapsed to be called, nor will calling it cause the StopWatch to stop.
    Examples:

        import core.thread : Thread;

        StopWatch sw;
        sw.setTimeElapsed(hours(1));

        // As discussed in MonoTime's documentation, converting between
        // Duration and ticks is not exact, though it will be close.
        // How exact it is depends on the frequency/resolution of the
        // system's monotonic clock.
        assert(abs(sw.peek() - hours(1)) < usecs(1));

        sw.start();
        Thread.sleep(usecs(1));
        assert(sw.peek() > hours(1) + usecs(1));

  const pure nothrow @nogc @property @safe bool `running`();
    Returns whether this StopWatch is currently running.
    Examples:

        StopWatch sw;
        assert(!sw.running);
        sw.start();
        assert(sw.running);
        sw.stop();
        assert(!sw.running);

Duration[fun.length] `benchmark`(fun...)(uint `n`);
  Benchmarks code for speed assessment and comparison.
  Parameters:

  fun | aliases of callable objects (e.g. function names). Each callable object 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.Duration) 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.
  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);
      Duration f0Result = r[0]; // time f0 took to run 10,000 times
      Duration f1Result = r[1]; // time f1 took to run 10,000 times
      Duration f2Result = r[2]; // time f2 took to run 10,000 times

Copyright © 1999-2022 by the D Language Foundation | Page generated by Ddoc on Thu Apr 7 14:47:32 2022