sparkles · instrument.d

// instrument.d — shared stderr instrumentation logger for the WSI scaffolds/demos.
// Defined by the F01 first-pixel demo (../../features/f01-first-pixel.md); the
// other demos copy this file verbatim.
//
// Line format (one event per line, to stderr):
//
//     <monotonic_us> <DEMO> <EVENT_KIND> key=value ...
//
// `<monotonic_us>` is microseconds since `instrInit` (core.time.MonoTime, so it
// is immune to wall-clock jumps). `<DEMO>` is a per-demo tag (e.g. "APPKIT").
// Everything after the event kind is a printf-formatted `key=value` payload.
module 
(module) instrumentinstrument;

import 
(package) corecore.
(package) core.stdcstdc.
(module) core.stdc.stdioD header file for C99 <stdio.h>
pubs.opengroup.org/onlinepubs/009695399/basedefs/stdio.h.html, stdio.h
Source
core/stdc/stdio.d
@copyrightCopyright Sean Kelly 2005 - 2009.@licenseDistributed under the
Boost Software License 1.0.
(See accompanying file LICENSE)@authorsSean Kelly,
Alex Rønne Petersen@standardsISO/IEC 9899:1999 (E)stdio : 
(alias) instrument.fprintf = int core.stdc.stdio.fprintf(shared(core.stdc.stdio._IO_FILE)* stream, scope const(char*) format, scope const ...) nothrow @nogcfprintf, 
(alias) instrument.fflush = int core.stdc.stdio.fflush(shared(core.stdc.stdio._IO_FILE)* stream) nothrow @nogc @trustedfflush, 
(alias shared global) instrument.stderr = shared(core.stdc.stdio._IO_FILE*) core.stdc.stdio.stderrstderr;
import 
(package) corecore.
(module) core.timeModule containing core time functionality, such as Duration (which
represents a duration of time) or MonoTime (which represents a
timestamp of the system's monotonic clock).
Various functions take a string (or strings) to represent a unit of time
(e.g. convert!("days", "hours")(numDays)). The valid strings to use
with such functions are "years", "months", "weeks", "days", "hours",
"minutes", "seconds", "msecs" (milliseconds), "usecs" (microseconds),
"hnsecs" (hecto-nanoseconds - i.e. 100 ns) or some subset thereof. There
are a few functions that also allow "nsecs", but very little actually
has precision greater than hnsecs.
Symbol Description 
Types
Duration Represents a duration of time of weeks or less (kept internally as hnsecs). (e.g. 22 days or 700 seconds). 
TickDuration DEPRECATED Represents a duration of time in system clock ticks, using the highest precision that the system provides. 
MonoTime Represents a monotonic timestamp in system clock ticks, using the highest precision that the system provides. 
Functions
convert Generic way of converting between two time units. 
dur Allows constructing a Duration from the given time units with the given length. 
weeks&nbsp;days&nbsp;hours
minutes&nbsp;seconds&nbsp;msecs
usecs&nbsp;hnsecs&nbsp;nsecs |
Convenience aliases for dur. |
| abs |  Returns the absolute value of a duration. |
  
From Duration 
From TickDuration 
From units 
To Duration 
tickDuration.to, std,conv!Duration() 
dur!"msecs"(5) or 5.msecs() 
| To TickDuration |
duration.to, std,conv!TickDuration() |
|
TickDuration.from!"msecs"(msecs) |
| To units |
duration.total!"days" |
tickDuration.msecs |
convert!("days", "msecs")(msecs) |
Source
core/time.d
@copyrightCopyright 2010 - 2012@licenseBoost License 1.0.@authorsJonathan M Davis and Kato Shoichitime : 
(struct) core.time.MonoTimeImpl!(ClockType.normal)MonoTime;

private __gshared 
(struct) core.time.MonoTimeImpl!(ClockType.normal)MonoTime 
(__gshared global) core.time.MonoTimeImpl!(ClockType.normal) instrument.g_epochg_epoch;
private __gshared bool 
(__gshared global) bool instrument.g_epochSetg_epochSet = false;
private __gshared const(char)* 
(__gshared global) const(char)* instrument.g_demoTagg_demoTag = "DEMO";

/// Set the demo tag and the monotonic epoch. Call first thing in `main`.
void 
void instrument.instrInit(const(char)* demoTag) nothrow @nogc @trustedSet the demo tag and the monotonic epoch. Call first thing in main.instrInit(const(char)* 
(parameter) const(char)* demoTagdemoTag) @trusted nothrow @nogc
{
    
(__gshared global) const(char)* instrument.g_demoTagg_demoTag = 
(parameter) const(char)* demoTagdemoTag;
    
(__gshared global) core.time.MonoTimeImpl!(ClockType.normal) instrument.g_epochg_epoch = 
(struct) core.time.MonoTimeImpl!(ClockType.normal)MonoTime.
core.time.MonoTimeImpl!(ClockType.normal) core.time.MonoTimeImpl!(ClockType.normal).currTime() nothrow @nogc @property @trustedThe current time of the system's monotonic clock. This has no relation
to the wall clock time, as the wall clock time can be adjusted (e.g.
by NTP), whereas the monotonic clock always moves forward. The source
of the monotonic time is system-specific.
On Windows, QueryPerformanceCounter is used. On Mac OS X,
mach_absolute_time is used, while on other POSIX systems,
clock_gettime is used.
Warning: On some systems, the monotonic clock may stop counting
when the computer goes to sleep or hibernates. So, the
monotonic clock may indicate less time than has actually
passed if that occurs. This is known to happen on
Mac OS X. It has not been tested whether it occurs on
either Windows or Linux.currTime;
    
(__gshared global) bool instrument.g_epochSetg_epochSet = true;
}

/// Microseconds since `instrInit` (lazily self-initializing).
ulong 
ulong instrument.instrNowUs() nothrow @nogc @trustedMicroseconds since instrInit (lazily self-initializing).instrNowUs() @trusted nothrow @nogc
{
    if (!
(__gshared global) bool instrument.g_epochSetg_epochSet)
        
void instrument.instrInit(const(char)* demoTag) nothrow @nogc @trustedSet the demo tag and the monotonic epoch. Call first thing in main.instrInit(
(__gshared global) const(char)* instrument.g_demoTagg_demoTag);
    return cast(ulong) (
(struct) core.time.MonoTimeImpl!(ClockType.normal)MonoTime.
core.time.MonoTimeImpl!(ClockType.normal) core.time.MonoTimeImpl!(ClockType.normal).currTime() nothrow @nogc @property @trustedThe current time of the system's monotonic clock. This has no relation
to the wall clock time, as the wall clock time can be adjusted (e.g.
by NTP), whereas the monotonic clock always moves forward. The source
of the monotonic time is system-specific.
On Windows, QueryPerformanceCounter is used. On Mac OS X,
mach_absolute_time is used, while on other POSIX systems,
clock_gettime is used.
Warning: On some systems, the monotonic clock may stop counting
when the computer goes to sleep or hibernates. So, the
monotonic clock may indicate less time than has actually
passed if that occurs. This is known to happen on
Mac OS X. It has not been tested whether it occurs on
either Windows or Linux.currTime - 
core.time.Duration core.time.MonoTimeImpl!(ClockType.normal).opBinary!"-"(core.time.MonoTimeImpl!(ClockType.normal) rhs) const pure nothrow @nogc @safeSubtracting two MonoTimes results in a Duration representing
the amount of time which elapsed between them.
The primary way that programs should time how long something takes is to
do
MonoTime before = MonoTime.currTime;
// do stuff
MonoTime after = MonoTime.currTime;

// How long it took.
Duration timeElapsed = after - before;
or to use a wrapper (such as a stop watch type) which does that.
Warning:
Because Duration is in hnsecs, whereas MonoTime is in system
ticks, it's usually the case that this assertion will fail
auto before = MonoTime.currTime;
// do stuff
auto after = MonoTime.currTime;
auto timeElapsed = after - before;
assert(before + timeElapsed == after);
This is generally fine, and by its very nature, converting from
system ticks to any type of seconds (hnsecs, nsecs, etc.) will
introduce rounding errors, but if code needs to avoid any of the
small rounding errors introduced by conversion, then it needs to use
MonoTime's ticks property and keep all calculations in ticks
rather than using Duration.g_epoch).
long core.time.Duration.total!"usecs"() const pure nothrow @nogc @property @safeReturns the total number of the given units in this Duration.
So, unlike split, it does not strip out the larger units.
Examples
assert(dur!"weeks"(12).total!"weeks" == 12);
assert(dur!"weeks"(12).total!"days" == 84);

assert(dur!"days"(13).total!"weeks" == 1);
assert(dur!"days"(13).total!"days" == 13);

assert(dur!"hours"(49).total!"days" == 2);
assert(dur!"hours"(49).total!"hours" == 49);

assert(dur!"nsecs"(2007).total!"hnsecs" == 20);
assert(dur!"nsecs"(2007).total!"nsecs" == 2000);
total!"usecs";
}

/// Emit one event line. `fmt`/`args` are an optional printf-style
/// `key=value ...` payload, e.g. `instr("resize", "size=%dx%d scale=%.1f", w, h, s)`.
void 
void instr(Args...)(const(char)* eventKind, const(char)* fmt = null, Args args)Emit one event line. fmt/args are an optional printf-style
key=value ... payload, e.g. ``instr("resize", "size=%dx%d scale=%.1f", w, h, s).instr(Args...)(const(char)* 
(parameter) const(char)* eventKindeventKind, const(char)* 
(parameter) const(char)* fmtfmt = null, Args 
(parameter) Args argsargs)
{
    immutable 
_error_ usus = instrNowUs();
    if (fmt is null)
        fprintf(stderr, "%llu %s %s\n", us, g_demoTag, eventKind);
    else
    {
        fprintf(stderr, "%llu %s %s ", us, g_demoTag, eventKind);
        fprintf(stderr, fmt, args);
        fprintf(stderr, "\n");
    }
    fflush(stderr);
}
Symbol	Description
Types
`Duration`	Represents a duration of `time` of weeks or less (kept internally as hnsecs). (e.g. 22 days or 700 seconds).
`TickDuration`	DEPRECATED Represents a duration of `time` in system clock ticks, using the highest precision that the system provides.
`MonoTime`	Represents a monotonic timestamp in system clock ticks, using the highest precision that the system provides.
Functions
`convert`	Generic way of converting between two `time` units.
`dur`	Allows constructing a `Duration` from the given `time` units with the given length.
`weeks` `days` `hours`
To `Duration`
`tickDuration.`to, std,conv`!Duration()`
`dur!"msecs"(5)` or `5.msecs()`