core.time

Переметиться к: bootTime · coarse · normal · precise · processCPUTime · raw · second · threadCPUTime · uptime · uptimeCoarse · uptimePrecise

enum ClockType: int;

Какой тип часов использовать с MonoTime / MonoTimeImpl или std.datetime.Clock.currTime. По-умолчанию используется ClockType.normal, и большинству программ никогда не потребуется что-то другое.

Другие варианты ClockType предусмотрены с таким расчетом, чтобы другие часы, предоставляемые нижележащими системными вызовами на C, можно было использовать с MonoTimeImpl или std.datetime.Clock.currTime без необходимости задействовать C API напрямую.

В случае монотонного времени, MonoTimeImpl шаблонизирован на ClockType, тогда как у std.datetime.Clock.currTime аргумент времени выполнения, поскольку в случае монотонного времени тип часов влияет на разрешение объекта MonoTimeImpl, а у std.datetime.SysTime разрешение всегда является гекто-наносекундным, независимо от источника времени.

ClockType.normal, ClockType.coarse, и ClockType.precise работают как с Clock.currTime, так и с MonoTimeImpl. ClockType.second работает только с Clock.currTime. Остальные работают только с MonoTimeImpl.

normal

Использовать часы normal.

bootTime

Только Linux

Используется CLOCK_BOOTTIME.

coarse

Использовать грубые (coarse) часы, а не обычные normal (например, в Linux, это CLOCK_REALTIME_COARSE вместо CLOCK_REALTIME для clock_gettime, если функция использует часы реального времени). Как правило, получение значения времени с грубыми часами происходит быстрее, чем с обычными часами, но они менее точные (например, точность 1 мс вместо 1 мксек или 1 нсек). Однако, гарантируется, что они всё ещё имеют точность более высокую, чем одна секунда (но не такую высокую, как в случае с ClockType.normal).

В системах, которые не поддерживают грубые часы, MonoTimeImpl!(ClockType.coarse) будет использовать те же часы, что и Monotime, а Clock.currTime!(ClockType.coarse) будет использовать те же часы, что и Clock.currTime. Это связано с тем, что грубые часы делают то же самое, что и обычные часы (только с меньшей точностью), тогда как некоторые другие типы часов (например, ClockType.processCPUTime) означают что-то принципиально иное. Таким образом, трактование их их в качестве ClockType.normal в системах, где они не поддерживаются изначально, даст ложные результаты.

Большинству программ не понадобятся грубые часы именно потому, что они менее точны, и большинству программ не нужно получать время настолько часто, чтобы скорость получения значений была важна, но для тех редких программ, которые должны получать время чрезвычайно часто (например, сотни тысяч раз в секунду), но не важна высокая точность, грубые часы могут быть уместными.

В настоящее время только Linux и FreeBSD поддерживают грубые часы, а на других платформах они рассматриваются как ClockType.normal.

precise

Использовать более точные (precise) часы, чем обычные normal (которые уже очень точные), но для получения значения времени требуется больше времени. Точно так же, как в случае с ClockType.coarse, если они используются в системе, которая не поддерживает более точные часы, чем normal, они считаются эквивалентными ClockType.normal.

В настоящее время только FreeBSD поддерживает более точные часы, где для этого используется CLOCK_MONOTONIC_PRECISE для монотонного времени и CLOCK_REALTIME_PRECISE для wall clock time (Как я понял, имеется ввиду вот это понятие: Wall clock time, не знаю, как это правильно перевести, но ясно, что простой вариант "настенные часы" не подходит — прим.пер.).

processCPUTime

Только Linux, Solaris

Используется CLOCK_PROCESS_CPUTIME_ID.

raw

Только Linux

Используется CLOCK_MONOTONIC_RAW.

second

Используются часы с точностью до одной секунды (в противоположность с грубыми (coarse) часами, которые имеют более высокую точность, чем секунда, также, как часы normal).

FreeBSD — единственная система, для которой существуют именно таким образом настроенные часы (в ней возможно использовать CLOCK_SECOND с функцией clock_gettime, которая использует встроенное кешированное значение), но в других системах будет использоваться самая быстрая функция, результат которой будет округлён в SysTime до секунд, если часы, которые были использованы, дали время с более точным разрешением. Таким образом, гарантируется, что время будет дано с точностью до одной секунды, и, скорее всего, результат будет получен быстрее, чем в случае ClockType.normal, так как в системе существует несколько вариантов для получения времени с низкими разрешениями, и они имеют тенденцию быть быстрее, чем получение времени с высокими разрешениями.

Таким образом, основное различие между ClockType.coarse и ClockType.second заключается в том, что ClockType.coarse жертвует некоторой точностью для получения скорости, но всё ещё довольно точное, тогда как ClockType.second пытается быть как можно быстрее за счет потери любой суб-секундной точности.

threadCPUTime

Только Linux, Solaris

Используется CLOCK_THREAD_CPUTIME_ID.

uptime

Только FreeBSD

Используется CLOCK_UPTIME.

uptimeCoarse

Только FreeBSD

Используется CLOCK_UPTIME_FAST.

uptimePrecise

Только FreeBSD

Используется CLOCK_UPTIME_PRECISE.

Переметиться к: isNegative · max · min · opBinary · opBinaryRight · opCast · opCmp · opOpAssign · opUnary · split · toString · total · zero

struct Duration;

Представляет длительность (отрезок времени) в неделях или в ещё меньших единицах (внутренне хранится в виде количества hnsecs) (например, 22 дня или 700 секунд).

Используется для представления продолжительности отрезка времени — например, как долго нужно спать при вызове функции core.thread.Thread.sleep.

В модуле std.datetime она также является результатом различных арифметических операций над отметками времени.

Используйте функцию dur или один из её неуниверсальных псевдонимов для создания экземпляров Duration.

Невозможно создать Duration в единицах месяцев или лет, поскольку переменное число дней в месяце или в году не позволяет выполнять преобразования между месяцами или годами и меньшими единицами без информации об определённой дате. Таким образом, ничто не использует Duration, когда дело касается месяцев или лет. Вместо неё определяются функции, специфичные для месяцев и лет. Например, у структуры std.datetime.Date есть функции add!"years" и add!"months" для добавления лет и месяцев вместо создания Duration с количеством лет или месяцев и добавления её к std.datetime.Date. Но Duration используется при работе с единицами от недели и меньше.

Примеры:

assert(dur!"days"(12) == dur!"hnsecs"(10_368_000_000_000L));
assert(dur!"hnsecs"(27) == dur!"hnsecs"(27));
assert(std.datetime.Date(2010, 9, 7) + dur!"days"(5) ==
       std.datetime.Date(2010, 9, 12));

assert(days(-12) == dur!"hnsecs"(-10_368_000_000_000L));
assert(hnsecs(-27) == dur!"hnsecs"(-27));
assert(std.datetime.Date(2010, 9, 7) - std.datetime.Date(2010, 10, 3) ==
       days(-26));

Примеры:

import core.time;

// использование шаблона dur
auto numDays = dur!"days"(12);

// использование функции days
numDays = days(12);

// альтернативно с использованием синтаксиса UFCS
numDays = 12.days;

auto myTime = 100.msecs + 20_000.usecs + 30_000.hnsecs;
assert(myTime == 123.msecs);

static pure nothrow @nogc @property @safe Duration zero();

Длительность размером 0. Эта функция короче, чем делать что-то вроде dur!"seconds"(0) и более явная, чем Duration.init.

static pure nothrow @nogc @property @safe Duration max();

Самое большое значение Duration из возможных.

static pure nothrow @nogc @property @safe Duration min();

Самое большое отрицательное значение Duration из возможных.

const pure nothrow @nogc @safe int opCmp(Duration rhs);

Сравнивает эту Duration с данной Duration.

Возвращает:

this < rhs	< 0
this == rhs	0
this > rhs	> 0

Переметиться к: 2 · 3

const nothrow @nogc Duration opBinary(string op, D)(D rhs)
if ((op == "+" || op == "-" || op == "%") && is(_Unqual!D == Duration) || (op == "+" || op == "-") && is(_Unqual!D == TickDuration));

Сложение, вычитание или вычисление по модулю между двумя длительностями.

Допустимые типы арифметики для Duration с использованием этого оператора:

Duration	+	Duration	-->	Duration
Duration	-	Duration	-->	Duration
Duration	%	Duration	-->	Duration
Duration	+	TickDuration	-->	Duration
Duration	-	TickDuration	-->	Duration

Параметры:

D rhs

Длительность, добавляемая к или вычитаемая из этой Длительности.

Переметиться к: 2

const nothrow @nogc Duration opBinaryRight(string op, D)(D lhs)
if ((op == "+" || op == "-") && is(_Unqual!D == TickDuration));

Сложение или вычитание между двумя длительностями.

Допустимые типы арифметики для Duration с использованием этого оператора:

TickDuration	+	Duration	-->	Duration
TickDuration	-	Duration	-->	Duration

Параметры:

D lhs

TickDuration, к которой добавляется или из которой вычитается эта Duration.

Переметиться к: 2

nothrow @nogc ref Duration opOpAssign(string op, D)(in D rhs)
if ((op == "+" || op == "-" || op == "%") && is(_Unqual!D == Duration) || (op == "+" || op == "-") && is(_Unqual!D == TickDuration));

Сложение, вычитание или вычисление по модулю между двумя длительностями, с присвоением результата этой Duration.

Допустимые типы арифметики для Duration с использованием этого оператора:

Duration	+	Duration	-->	Duration
Duration	-	Duration	-->	Duration
Duration	%	Duration	-->	Duration
Duration	+	TickDuration	-->	Duration
Duration	-	TickDuration	-->	Duration

Параметры:

D rhs

Длительность, добавляемая к или вычитаемая из этой Duration.

const nothrow @nogc Duration opBinary(string op)(long value)
if (op == "*" || op == "/");

Умножает или делит длительность на целое значение value.

Допустимые типы арифметики для Duration с использованием этой перегрузки оператора:

Duration	*	long	-->	Duration
Duration	/	long	-->	Duration

Параметры:

long value

Значение, на которое умножается или делится эта Duration.

nothrow @nogc ref Duration opOpAssign(string op)(long value)
if (op == "*" || op == "/");

Умножает/делит длительность на целое значение value, с присвоением результата этой Duration.

Допустимые типы арифметики для Duration с использованием этой перегрузки оператора:

Duration	*	long	-->	Duration
Duration	/	long	-->	Duration

Параметры:

long value

Значение, на которое умножается или делится эта Duration.

const nothrow @nogc long opBinary(string op)(Duration rhs)
if (op == "/");

Делит две длительности.

Допустимые типы арифметики для Duration с использованием этого оператора:

Duration

/

Duration

-->

long

Параметры:

Duration rhs

Длительность, на которую делится эта Duration.

const nothrow @nogc Duration opBinaryRight(string op)(long value)
if (op == "*");

Перемножает целое число value и Duration.

Допустимые типы арифметики для Duration с использованием этой перегрузки оператора:

long

*

Duration

-->

Duration

Параметры:

long value

Количество единиц для умножения на эту Duration.

const nothrow @nogc Duration opUnary(string op)()
if (op == "-");

Возвращает отрицание этой Duration.

const nothrow @nogc TickDuration opCast(T)()
if (is(_Unqual!T == TickDuration));

Возвращает значение TickDuration с тем же числом hnsecs (гекто-наносекунд), что и эта Duration. Обратите внимание, что обычным способом преобразования между Duration и TickDuration является использование шаблона std.conv.to, например: duration.to!TickDuration()

Переметиться к: split

template split(units...) if (allAreAcceptedUnits!("weeks", "days", "hours", "minutes", "seconds", "msecs", "usecs", "hnsecs", "nsecs")(units) && unitsAreInDescendingOrder(units))

Разделяет длительность по заданным единицам.

split принимает список из единиц времени в качестве аргументов шаблона для разделения длительности. Строки с единицами измерения времени должны указываться в порядке убывания. То, каким образом возвращаются значения для этих единиц, зависит от используемой перегрузки.

Перегрузка с аргументами функции принимает целые типы в том порядке, в котором указаны строки с единицами измерения времени, и эти целые числа передаются по ссылке (by ref). split присваивает значения количества единиц времени каждому соответствующему целому. Можно использовать любой целочисленный тип, но не предпринимается никаких попыток предотвратить переполнение целых чисел, поэтому не используйте малоразмерные целые типы в тех случаях, когда значения для этих единиц времени вряд ли будут соответствовать слушком малому целому типу.

Перегрузка без аргументов возвращает значения для единиц времени в структуре, имена членов которой совпадают с указанными строками единиц измерения времени. Все члены структуры имеют тип long. Эта перегрузка также будет работать без указания строк с единицами времени, и в этом случае будут предоставлены все единицы времени от недель (weeks) до hnsec (но не nsecs, так как их количество всегда будет 0).

Для обеих перегрузок всё значение длительности Duration делится между этими единицами (вместо того, чтобы разбивать длительность по всем единицам, а затем предоставлять значения только для запрашиваемых единиц), поэтому, если даётся только одна единица, результат эквивалентен методу total.

"nsecs" (наносекунды) функцией split принимается, но "years" (годы) и "months" (месяцы) — нет.

Для отрицательных длительностей все результаты split будут отрицательными.

Примеры:

{
    auto d = dur!"days"(12) + dur!"minutes"(7) + dur!"usecs"(501223); // дни, минуты, микросекунды
    long days;	         // дни
    int seconds;	 // секунды
    short msecs;	 // миллисекунды
    d.split!("days", "seconds", "msecs")(days, seconds, msecs);  // дни, секунды, миллисекунды
    assert(days == 12);
    assert(seconds == 7 * 60);
    assert(msecs == 501);

    auto splitStruct = d.split!("days", "seconds", "msecs")();  // дни, секунды, миллисекунды
    assert(splitStruct.days == 12);
    assert(splitStruct.seconds == 7 * 60);
    assert(splitStruct.msecs == 501);

    auto fullSplitStruct = d.split();
    assert(fullSplitStruct.weeks == 1);   // недели
    assert(fullSplitStruct.days == 5);    // дни
    assert(fullSplitStruct.hours == 0);   // часы
    assert(fullSplitStruct.minutes == 7); // минуты
    assert(fullSplitStruct.seconds == 0); // секунды
    assert(fullSplitStruct.msecs == 501); // миллисекунды
    assert(fullSplitStruct.usecs == 223); // микросекунды
    assert(fullSplitStruct.hnsecs == 0);  // гекто-наносекунды

    assert(d.split!"minutes"().minutes == d.total!"minutes"); // минуты
}

{
    auto d = dur!"days"(12); // дни
    assert(d.split!"weeks"().weeks == 1); // недели
    assert(d.split!"days"().days == 12);  // дни

    assert(d.split().weeks == 1); // недели
    assert(d.split().days == 5);  // дни
}

{
    auto d = dur!"days"(7) + dur!"hnsecs"(42);             // дни, гекто-наносекунды
    assert(d.split!("seconds", "nsecs")().nsecs == 4200);  // секунды, наносекунды
}

{
    auto d = dur!"days"(-7) + dur!"hours"(-9);   // дни, часы
    auto result = d.split!("days", "hours")();   // дни, часы
    assert(result.days == -7);    // дни
    assert(result.hours == -9);   // часы
}

const nothrow @nogc void split(Args...)(out Args args)
if (units.length != 0 && args.length == units.length && allAreMutableIntegralTypes!Args);

const nothrow @nogc auto split();

Тоже самое

const nothrow @nogc @property long total(string units)()
if (units == "weeks" || units == "days" || units == "hours" || units == "minutes" || units == "seconds" || units == "msecs" || units == "usecs" || units == "hnsecs" || units == "nsecs");

Возвращает суммарное количество данных единиц в этой длительности Duration. Таким образом, в отличие от split, он не отделяет единицы большего размера.

Примеры:

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); // наносекунды, наносекунды

const pure nothrow @safe string toString();

Преобразует эту Duration в строку string.

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

Возвращает, является ли эта Duration отрицательной.

pure nothrow @nogc @safe T to(string units, T, D)(D td)
if (is(_Unqual!D == TickDuration) && (units == "seconds" || units == "msecs" || units == "usecs" || units == "hnsecs" || units == "nsecs"));

Преобразует значение TickDuration в данные единицы в виде целого значения или значения с плавающей точкой.

Параметры:

units	Единицы в которые надо преобразовать. Принимает только "seconds" (секунды) и меньше.
T	Тип, в который преобразовывать (тип целых чисел или тип с плавающей точкой).
D td	Преобразуемый TickDuration

Примеры:

auto t = TickDuration.from!"seconds"(1000);

long tl = to!("seconds",long)(t);
assert(tl == 1000);

double td = to!("seconds",double)(t);
assert(_abs(td - 1000) < 0.001);

pure nothrow @nogc @safe Duration dur(string units)(long length)
if (units == "weeks" || units == "days" || units == "hours" || units == "minutes" || units == "seconds" || units == "msecs" || units == "usecs" || units == "hnsecs" || units == "nsecs");

alias weeks = dur!"weeks".dur;

alias days = dur!"days".dur;

alias hours = dur!"hours".dur;

alias minutes = dur!"minutes".dur;

alias seconds = dur!"seconds".dur;

alias msecs = dur!"msecs".dur;

alias usecs = dur!"usecs".dur;

alias hnsecs = dur!"hnsecs".dur;

alias nsecs = dur!"nsecs".dur;

Эти функции позволяют вам строить длительность Duration из заданных единиц времени с заданной длиной length.

Вы можете либо использовать общую функцию dur и передавать ей единицы времени в виде строки, или использовать именованные псевдонимы.

Возможные значения для единиц: "weeks" (недели), "days" (дни), "hours" (часы), "minutes" (минуты), "seconds" (секунды), "msecs" (миллисекунды), "usecs" (микросекунды), "hnsecs" (гекто-наносекунды - то есть 100 нс) и "nsecs" (наносекунды).

Параметры:

units	Единицы времени для длительности Duration (например, "days").
long length	Количество единиц в Duration.

Примеры:

// Обобщённый вариант
assert(dur!"weeks"(142).total!"weeks" == 142);      // недели
assert(dur!"days"(142).total!"days" == 142);        // дни
assert(dur!"hours"(142).total!"hours" == 142);      // часы
assert(dur!"minutes"(142).total!"minutes" == 142);  // минуты
assert(dur!"seconds"(142).total!"seconds" == 142);  // секунды
assert(dur!"msecs"(142).total!"msecs" == 142);      // миллисекунды
assert(dur!"usecs"(142).total!"usecs" == 142);      // микросекунды
assert(dur!"hnsecs"(142).total!"hnsecs" == 142);    // гекто-наносекунды
assert(dur!"nsecs"(142).total!"nsecs" == 100);      // наносекунды

// Неуниверсальный вариант
assert(weeks(142).total!"weeks" == 142);      // недели
assert(days(142).total!"days" == 142);        // дни
assert(hours(142).total!"hours" == 142);      // часы
assert(minutes(142).total!"minutes" == 142);  // минуты
assert(seconds(142).total!"seconds" == 142);  // секунды
assert(msecs(142).total!"msecs" == 142);      // миллисекунды
assert(usecs(142).total!"usecs" == 142);      // микросекунды
assert(hnsecs(142).total!"hnsecs" == 142);    // гекто-наносекунды
assert(nsecs(142).total!"nsecs" == 100);      // наносекунды

alias MonoTime = MonoTimeImpl!cast(ClockType)0.MonoTimeImpl;

Псевдоним для MonoTimeImpl, созданный с параметром ClockType.normal. Большинство программ должно использовать именно его. Также он используется в большей части документации по MonoTimeImpl (особенно в примерах), потому что это наиболее частоупотебимый вариант для большинства программ.

Переметиться к: currTime · max · min · opBinary · opCmp · opOpAssign · ticks · ticksPerSecond · toString · zero

struct MonoTimeImpl(ClockType clockType);

Представляет метку времени системных монотонных часов.

Монотонные часы — это то, что всегда идет вперёд и никогда не движется назад, в отличие от системных wall clock time (которые представлены структурой std.datetime.SysTime). Системные wall clock time могут быть отрегулированы пользователем или самой системой через такие сервисы, как NTP, поэтому ненадёжно использовать wall clock time для синхронизации. Таймеры, которые используют время wall clock time, могут в конечном итоге никогда выключиться из-за изменений, внесенных в wall clock time, или отсчитать период времени, отличающийся от заданного программистом. Однако, поскольку монотонные часы всегда увеличивают своё значение с фиксированной скоростью и на них не влияют корректировки wall clock time, он идеально подходит для использования в таймерах или в чём-либо, что требует синхронизации с высокой точностью.

Таким образом, MonoTime следует использовать для чего-либо, связанного с таймерами и синхронизацией, тогда как std.datetime.SysTime следует использовать, когда требуется wall clock time.

Монотонные часы не имеют отношения к wall clock time. Скорее, они хранят своё время в виде количества тиков часов, которые произошли с момента запуска часов (обычно при загрузке системы). Таким образом, чтобы определить, сколько времени прошло между двумя моментами времени, одно монотонное время вычитается из другого, чтобы определить количество тиков, которые произошли между двумя отметками времени, и эти тики делятся на количество тиков, которые происходят каждую секунду (это значение представлено в MonoTime.ticksPerSecond), чтобы получить значимую длительность времени. Обычно MonoTime выполняет эти вычисления для программиста, но свойства ticks и ticksPerSecond предоставляются для тех, кому требуется прямой доступ к системным тикам. Обычное использование MonoTime:

    MonoTime before = MonoTime.currTime;
    // что-то делать...
    MonoTime after = MonoTime.currTime;
    Duration timeElapsed = after - before;

MonoTime — это псевдоним для MonoTimeImpl!(ClockType.normal), большинство программ должно использовать именно его. Также он используется в большей части документации по MonoTimeImpl (особенно в примерах), потому что это наиболее частоупотебимый вариант для большинства программ. Но MonoTimeImpl можно создать с другими типами часов для тех редких программ, которые в этом нуждаются.

Смотрите также:

ClockType

static nothrow @nogc @property @trusted MonoTimeImpl currTime();

Текущее время монотонных часов системы. Оно не имеет отношения к wall clock time, так как wall clock time может быть отрегулировано (например, через NTP), тогда как монотонные часы всегда двигаются вперёд. Источник монотонного времени является системо-зависимым.

В Windows используется QueryPerformanceCounter. В Mac OS X используется mach_absolute_time, тогда как в других POSIX-системах используется clock_gettime.

Предупреждение: В некоторых системах монотонные часы могут перестать отсчитывать время, когда компьютер перейдёт в спящий режим или в гибернацию. Таким образом, если это произойдет, монотонные часы могут указывать на меньшее время, чем прошло фактически. Известно, что так происходит в Mac OS X. Не проверялось, происходит ли это в Windows или Linux.

MonoTimeImpl zero();

MonoTime со значением 0 тиков. Предоставляется для соответствия с Duration.zero, и является более явным, чем MonoTime.init.

MonoTimeImpl max();

Максимально возможное значение MonoTime.

MonoTimeImpl min();

Максимально возможное отрицательное значение MonoTime.

const pure nothrow @nogc int opCmp(MonoTimeImpl rhs);

Сравнивает эту структуру MonoTime с переданной rhs.

Возвращает:

this < rhs	< 0
this == rhs	0
this > rhs	> 0

Переметиться к: 2

const pure nothrow @nogc Duration opBinary(string op)(MonoTimeImpl rhs)
if (op == "-");

Результатом вычитания двух меток времени MonoTime является длительность Duration, представляющая количество времени, прошедшего между ними.

Простейший способ, которым программы должны выяснять, как долго что-то выполнялось:

MonoTime before = MonoTime.currTime;
// что-то сделать
MonoTime after = MonoTime.currTime;

// Сколько времени это заняло.
Duration timeElapsed = after - before;

или использовать обертку (например, тип секундомера), которая делает это.

Предупреждение: поскольку значение Duration хранится в единицах hnsec (гекто-наносекунды), тогда как значение MonoTime хранится в количестве системных тиков, в большинстве случаев это утверждение assert не будет выполнено:

auto before = MonoTime.currTime;
// что-то сделать
auto after = MonoTime.currTime;
auto timeElapsed = after - before;
assert(before + timeElapsed == after);

Как правило, это нормально, и по самой своей сути преобразование из системных тиков в любой тип долей секунд (hnsecs, nsecs и т. д.) приведёт к ошибкам округления, но если код должен избегать любых небольших ошибок округления, привносимых преобразованием, тогда он должен использовать свойство ticks структуры MonoTime и сохранять все вычисления в тиках, а не использовать Duration.

const pure nothrow @nogc MonoTimeImpl opBinary(string op)(Duration rhs)
if (op == "+" || op == "-");

pure nothrow @nogc ref MonoTimeImpl opOpAssign(string op)(Duration rhs)
if (op == "+" || op == "-");

Добавление или вычитание длительности Duration к/из MonoTime даст в результате MonoTime, изменённое на это значение.

const pure nothrow @nogc @property long ticks();

Количество тиков в монотонном времени.

Большинство программ не должны использовать его напрямую, но оно доступно для тех немногих программ, которые в нём нуждаются.

Основными причинами, по которым программе может потребоваться непосредственное использование ticks, является то, что системные часы имеют более высокую точность, чем hnsec (гекто-наносекунды), и для этой программы требуется более высокая точность, или если программе необходимо избегать ошибок округления, вызванных преобразованием в hnsec.

static pure nothrow @nogc @property long ticksPerSecond();

Количество тиков, выполняемых в секунду, то есть разрешение или частота монотонных часов системы.

Например, если системные часы имеют разрешение в 1 микросекунду, тогда ticksPerSecond будет равно 1_000_000.

const pure nothrow string toString();

pure nothrow @nogc @safe long convClockFreq(long ticks, long srcTicksPerSecond, long dstTicksPerSecond);

Преобразует заданное время из одной тактовой частоты/разрешения к другой.

Смотрите также:

ticksToNSecs

Примеры:

// один тик - одна секунда -> один тик - одна гекто-наносекунда
assert(convClockFreq(45, 1, 10_000_000) == 450_000_000);

// один тик - одна микросекунда -> один тик - одна миллисекунда 
assert(convClockFreq(9029, 1_000_000, 1_000) == 9);

// один тик - 1/3_515_654 секунды -> 1/1_001_010 секунды
assert(convClockFreq(912_319, 3_515_654, 1_001_010) == 259_764);

// один тик - 1/MonoTime.ticksPerSecond -> один тик - одна наносекунда
// Эквивалентно ticksToNSecs
auto nsecs = convClockFreq(1982, MonoTime.ticksPerSecond, 1_000_000_000);

pure nothrow @nogc @safe long ticksToNSecs(long ticks);

Удобная обёртка вокруг convClockFreq, которая преобразует ticks с тактовой частотой MonoTime.ticksPerSecond в наносекунды.

Используется в первую очередь тогда, когда MonoTime.ticksPerSecond точнее, чем гекто-наносекундное разрешение, а приложение требует более высокой точности, чем гекто-наносекунды.

Смотрите также:

convClockFreq

Примеры:

auto before = MonoTime.currTime;
// что-то сделать
auto after = MonoTime.currTime;
auto diffInTicks = after.ticks - before.ticks;
auto diffInNSecs = ticksToNSecs(diffInTicks);
assert(diffInNSecs == convClockFreq(diffInTicks, MonoTime.ticksPerSecond, 1_000_000_000));

pure nothrow @nogc @safe long nsecsToTicks(long ticks);

Функция, обратная к ticksToNSecs.

Переметиться к: appOrigin · currSystemTick · from · hnsecs · length · max · min · msecs · nsecs · opBinary · opCast · opCmp · opOpAssign · opUnary · seconds · this · ticksPerSec · usecs · zero

struct TickDuration;

Предупреждение: Структура TickDuration будет устаревшей в ближайшем будущем (как только всё её использование в Phobos будет объявлено устаревшим). Пожалуйста, используйте MonoTime для случаев, когда требуется монотонная отметка времени, и Duration, когда требуется длительность, вместо использования TickDuration. Было решено, что TickDuration слишком запутана (например, в ней объединяются монотонная отметка времени и длительность тиков монотонных часов) и что наличие нескольких типов длительности слишком неудачно и запутывает.

Представляет собой длительность времени в тиках системы.

Системные тактовые сигналы (system clock ticks) — это тики системных часов с максимально возможной точностью, которую предоставляет система.

Так как эта структура объявлена устаревшей, то моя лень не позволила мне переводить описание всех её свойств и методов — прим. пер.

static immutable long ticksPerSec;

The number of ticks that the system clock has in one second.

If ticksPerSec is 0, then then TickDuration failed to get the value of ticksPerSec on the current system, and TickDuration is not going to work. That would be highly abnormal though.

static immutable TickDuration appOrigin;

The tick of the system clock (as a TickDuration) when the application started.

static pure nothrow @nogc @property @safe TickDuration zero();

It's the same as TickDuration(0), but it's provided to be consistent with Duration and FracSec, which provide zero properties.

static pure nothrow @nogc @property @safe TickDuration max();

Largest TickDuration possible.

static pure nothrow @nogc @property @safe TickDuration min();

Most negative TickDuration possible.

long length;

The number of system ticks in this TickDuration.

You can convert this length into the number of seconds by dividing it by ticksPerSec (or using one the appropriate property function to do it).

const pure nothrow @nogc @property @safe long seconds();

Returns the total number of seconds in this TickDuration.

const pure nothrow @nogc @property @safe long msecs();

Returns the total number of milliseconds in this TickDuration.

const pure nothrow @nogc @property @safe long usecs();

Returns the total number of microseconds in this TickDuration.

const pure nothrow @nogc @property @safe long hnsecs();

Returns the total number of hecto-nanoseconds in this TickDuration.

const pure nothrow @nogc @property @safe long nsecs();

Returns the total number of nanoseconds in this TickDuration.

pure nothrow @nogc @safe TickDuration from(string units)(long length)
if (units == "seconds" || units == "msecs" || units == "usecs" || units == "hnsecs" || units == "nsecs");

This allows you to construct a TickDuration from the given time units with the given length.

Параметры:

units	The time units of the TickDuration (e.g. "msecs").
long length	The number of units in the TickDuration.

const pure nothrow @nogc @safe Duration opCast(T)()
if (is(_Unqual!T == Duration));

Returns a Duration with the same number of hnsecs as this TickDuration. Note that the conventional way to convert between TickDuration and Duration is using std.conv.to, e.g.: tickDuration.to!Duration()

Переметиться к: 2 · 3

pure nothrow @nogc ref @safe TickDuration opOpAssign(string op)(TickDuration rhs)
if (op == "+" || op == "-");

Adds or subtracts two TickDurations as well as assigning the result to this TickDuration.

The legal types of arithmetic for TickDuration using this operator are

TickDuration	+=	TickDuration	-->	TickDuration
TickDuration	-=	TickDuration	-->	TickDuration

Параметры:

TickDuration rhs

The TickDuration to add to or subtract from this TickDuration.

Переметиться к: 2 · 3

const pure nothrow @nogc @safe TickDuration opBinary(string op)(TickDuration rhs)
if (op == "+" || op == "-");

Adds or subtracts two TickDurations.

The legal types of arithmetic for TickDuration using this operator are

TickDuration	+	TickDuration	-->	TickDuration
TickDuration	-	TickDuration	-->	TickDuration

Параметры:

TickDuration rhs

The TickDuration to add to or subtract from this TickDuration.

const pure nothrow @nogc @safe TickDuration opUnary(string op)()
if (op == "-");

Returns the negation of this TickDuration.

const pure nothrow @nogc @safe int opCmp(TickDuration rhs);

operator overloading "<, >, <=, >="

pure nothrow @nogc @safe void opOpAssign(string op, T)(T value)
if (op == "*" && (__traits(isIntegral, T) || __traits(isFloating, T)));

The legal types of arithmetic for TickDuration using this operator overload are

TickDuration	*	long	-->	TickDuration
TickDuration	*	floating point	-->	TickDuration

Параметры:

T value

The value to divide from this duration.

pure @safe void opOpAssign(string op, T)(T value)
if (op == "/" && (__traits(isIntegral, T) || __traits(isFloating, T)));

The legal types of arithmetic for TickDuration using this operator overload are

TickDuration	/	long	-->	TickDuration
TickDuration	/	floating point	-->	TickDuration

Параметры:

T value

The value to divide from this TickDuration.

Исключения:

TimeException if an attempt to divide by 0 is made.

const pure nothrow @nogc @safe TickDuration opBinary(string op, T)(T value)
if (op == "*" && (__traits(isIntegral, T) || __traits(isFloating, T)));

The legal types of arithmetic for TickDuration using this operator overload are

TickDuration	*	long	-->	TickDuration
TickDuration	*	floating point	-->	TickDuration

Параметры:

T value

The value to divide from this TickDuration.

const pure @safe TickDuration opBinary(string op, T)(T value)
if (op == "/" && (__traits(isIntegral, T) || __traits(isFloating, T)));

The legal types of arithmetic for TickDuration using this operator overload are

TickDuration	/	long	-->	TickDuration
TickDuration	/	floating point	-->	TickDuration

Параметры:

T value

The value to divide from this TickDuration.

Исключения:

TimeException if an attempt to divide by 0 is made.

pure nothrow @nogc @safe this(long ticks);

Параметры:

long ticks

The number of ticks in the TickDuration.

static nothrow @nogc @property @trusted TickDuration currSystemTick();

The current system tick. The number of ticks per second varies from system to system. currSystemTick uses a monotonic clock, so it's intended for precision timing by comparing relative time values, not for getting the current system time.

On Windows, QueryPerformanceCounter is used. On Mac OS X, mach_absolute_time is used, while on other Posix systems, clock_gettime is used. If mach_absolute_time or clock_gettime is unavailable, then Posix systems use gettimeofday (the decision is made when TickDuration is compiled), which unfortunately, is not monotonic, but if mach_absolute_time and clock_gettime aren't available, then gettimeofday is the the best that there is.

Предупреждение: On some systems, the monotonic clock may stop counting when the computer goes to sleep or hibernates. So, the monotonic clock could be off if that occurs. This is known to happen on Mac OS X. It has not been tested whether it occurs on either Windows or on Linux.

Исключения:

TimeException if it fails to get the time.

pure nothrow @nogc @safe long convert(string from, string to)(long value)
if ((from == "weeks" || from == "days" || from == "hours" || from == "minutes" || from == "seconds" || from == "msecs" || from == "usecs" || from == "hnsecs" || from == "nsecs") && (to == "weeks" || to == "days" || to == "hours" || to == "minutes" || to == "seconds" || to == "msecs" || to == "usecs" || to == "hnsecs" || to == "nsecs") || (from == "years" || from == "months") && (to == "years" || to == "months"));

Обобщённый способ преобразования между двумя единицами времени. Преобразования в меньшие единицы используют усекающее деление. Годы и месяцы можно преобразовывать друг в друга, единицы меньшего размера можно преобразовывать друг в друга, но годы и месяцы не могут быть преобразованы в или из меньших единиц (из-за различного количества дней в месяце или в году).

Параметры:

from	Единицы времени, из которых ведётся преобразование.
to	Единицы времени, в которые ведётся преобразование.
long value	Преобразуемое значение.

Примеры:

assert(convert!("years", "months")(1) == 12);             // годы, месяцы
assert(convert!("months", "years")(12) == 1);             // месяцы, годы

assert(convert!("weeks", "days")(1) == 7);                // недели, дни
assert(convert!("hours", "seconds")(1) == 3600);          // часы, секунды
assert(convert!("seconds", "days")(1) == 0);              // секунды, дни
assert(convert!("seconds", "days")(86_400) == 1);         // секунды, дни

assert(convert!("nsecs", "nsecs")(1) == 1);               // наносекунды, наносекунды
assert(convert!("nsecs", "hnsecs")(1) == 0);              // наносекунды, гекто-наносекунды
assert(convert!("hnsecs", "nsecs")(1) == 100);            // гекто-наносекунды, наносекунды
assert(convert!("nsecs", "seconds")(1) == 0);             // наносекунды, секунды
assert(convert!("seconds", "nsecs")(1) == 1_000_000_000); // секунды, наносекунды

Переметиться к: from · hnsecs · msecs · nsecs · opUnary · toString · usecs · zero

struct FracSec;

Представляет дробные части секунды.

Это часть времени, которая меньше секунды, и она не может содержать значения, которые были бы больше или равны секунде (или меньше или равны отрицательной секунде).

Внутри хранит время в виде hnsec, но вы можете создавать его с помощью миллисекунд, микросекунд или hnsec. Он позволяет простым способом установить или отрегулировать дробные части секунды Duration или std.datetime.SysTime, не беспокоясь о том, имеете ли вы дело с миллисекундами, с микросекундами или с hnsec.

Функции FracSec, которые принимают единицы времени в виде строк, принимают "nsecs", но поскольку разрешение у Duration и std.datetime.SysTime равно hnsec, вы фактически не получите точность выше, чем hnsec. "nsecs" принимается просто для удобства. Любые значения, заданные как nsecs, будут преобразованы в hnsecs с использованием convert (который использует усекающее деление при преобразовании в меньшие единицы).

В документации к версии 2.072 с этой структурой все нормально, и я перевожу её описание. Но, начиная с версии 2.077 в документации сказано, что структура FracSec объявлена устаревшей, и будет удалена из кодовой базы в октябре 2019 года, так что использовать её не рекомендуется (да и смысла её использования я так и не понял) — прим.пер.

static pure nothrow @nogc @property @safe FracSec zero();

FracSec, равный 0. Это короче, чем делать что-то вроде FracSec.from!"msecs"(0), и более явно, чем FracSec.init.

FracSec from(string units)(long value)
if (units == "msecs" || units == "usecs" || units == "hnsecs" || units == "nsecs");

Создать экземпляр FracSec из данных единиц ("msecs", "usecs", или "hnsecs").

Параметры:

units	Единицы измерения времени для создания FracSec.
long value	Количество передаваемых единиц.

Исключения:

TimeException, если переданное значение приведет к тому, что FracSec будет больше или равно 1 секунде или меньше или равно -1 секунде.

const nothrow @nogc FracSec opUnary(string op)()
if (op == "-");

Возвращает отрицание этого FracSec.

Переметиться к: 2

const pure nothrow @nogc @property @safe int msecs();

Значение этого FracSec в миллисекундах.

pure @property @safe void msecs(int milliseconds);

Задать значение этого FracSec в миллисекундах.

Параметры:

int milliseconds

Число миллисекунд

Исключения:

TimeException, если переданное значение не меньше, чем 1 секунда и не больше, чем -1 секунда.

Переметиться к: 2

const pure nothrow @nogc @property @safe int usecs();

Значение этого FracSec в микросекундах.

pure @property @safe void usecs(int microseconds);

Задать значение этого FracSec в микросекундах.

Параметры:

int microseconds

Число микросекунд.

Исключения:

TimeException, если переданное значение не меньше, чем 1 секунда и не больше, чем -1 секунда.

Переметиться к: 2

const pure nothrow @nogc @property @safe int hnsecs();

Значение этого FracSec в hnsecs (гекто-наносекундах).

pure @property @safe void hnsecs(int hnsecs);

Задать значение этого FracSec в hnsecs (гекто-наносекундах).

Параметры:

int hnsecs

Число hnsecs.

Исключения:

TimeException, если переданное значение не меньше, чем 1 секунда и не больше, чем -1 секунда.

Переметиться к: 2

const pure nothrow @nogc @property @safe int nsecs();

Значение этого FracSec в наносекундах.

Обратите внимание, что это не даст вам большей точности, чем получение значения этого FracSec в виде hnsecs.

pure @property @safe void nsecs(long nsecs);

Задать значение этого FracSec в наносекундах.

Обратите внимание, что это не даст вам большей точности, чем задание значения этого FracSec в виде hnsecs.

Параметры:

long nsecs

Число наносекунд.

Исключения:

TimeException, если переданное значение не меньше, чем 1 секунда и не больше, чем -1 секунда.

const pure nothrow @safe string toString();

Преобразовать TickDuration в строку.

Переметиться к: this

class TimeException: object.Exception;

Тип исключения, используемый в core.time.

Переметиться к: 2

pure nothrow @safe this(string msg, string file = __FILE__, size_t line = __LINE__, Throwable next = null);

Параметры:

string msg	Сообщение об исключении.
string file	Файл, в котором произошло исключение.
size_t line	Номер строки, в которой произошло исключение.
Throwable next	Предыдущее исключение в цепочке исключений, если оно есть.

pure nothrow @safe this(string msg, Throwable next, string file = __FILE__, size_t line = __LINE__);

Параметры:

string msg	Сообщение об исключении.
Throwable next	Предыдущее исключение в цепочке исключений.
string file	Файл, в котором произошло исключение.
size_t line	Номер строки, в которой произошло исключение.

pure nothrow @nogc @safe Duration abs(Duration duration);

pure nothrow @nogc @safe TickDuration abs(TickDuration duration);

Возвращает абсолютное значение длительности.