Храмцов П.Б. Открытые системы
Подождите немного. Документ загружается.
201
Для выполнения преобразований между разными представлениями
данных о времени служат описываемые далее функции (см. также рис.
12.1).
Рис. 12.1. Функции для выполнения преобразований между разными
представлениями данных о времени.
Функции gmtime() и localtime() (см. листинг 12.8) преобразуют
значения типа time_t в структуру типа tm. Соотношение между
временем в секундах от начала отсчета и значениями полей структуры
типа tm дается в приведенной выше формуле. Кроме того, функция
localtime() учитывает данные о часовом поясе и сезонных поправках.
#include <time.h>
struct tm *gmtime (const time_t *tloc);
struct tm *localtime (const time_t *tloc)
Листинг 12.8. Описание функций gmtime() и localtime().
Для учета данных о часовом поясе и сезонных поправках
используются внешние переменные tzname, timezone, daylight, значения
которых функция tzset() устанавливает по переменной окружения TZ
(см. листинг 12.9
).
#include <time.h>
extern char *tzname[2];
extern long timezone;
extern int daylight;
void tzset (void);
Листинг 12.9. Описание функции tzset() и ассоциированных
внешних переменных.
Элементам массива tzname присваиваются имена местного
часового пояса в стандартном (tzname [0]) и "летнем" (tzname [1])
вариантах. Значение переменной timezone устанавливается равным
разности в секундах между всемирным и местным поясным временем.
202
Переменной daylight присваивается отличное от нуля значение, если для
местного часового пояса предусмотрен переход на летнее время.
Отметим, что в общем случае значение переменой окружения TZ
устроено довольно сложным образом:
Станд_поясСмещение[Лет_пояс[Смещение]
[,Нач_лет[/Время],Кон_лет[/Время]]]
Здесь Станд_пояс и Лет_пояс - имена, присваиваемые элементам
массива tzname [], Смещение - разность между всемирным и местным
поясным временем (в виде чч[:мм[:сс]]), Нач_лет и Кон_лет,
соответственно, даты начала и окончания действия летнего времени
(обычно их задают в виде Mмм.н.д - месяц, неделя, день), время - время
перехода (по умолчанию - два часа ночи). Можно видеть, что данных
для вычисления местного времени оказывается вполне достаточно.
Функцию mktime() (см. листинг 12.10
) можно считать обратной по
отношению к localtime(). Она преобразует местное время, заданное в
виде структуры типа tm, в значение типа time_t, т. е. в секунды от начала
отсчета по всемирному времени.
#include <time.h>
time_t mktime (struct tm *tmptr);
Листинг 12.10. Описание функции mktime().
При входе в функцию mktime() значения полей tm_wday и tm_yday
структуры tm, на которую указывает аргумент tmptr, игнорируются; при
выходе они устанавливаются должным образом. Значения других полей
также приводятся к стандартным для них диапазонам (при входе это
условие может не выполняться).
Другим весьма мощным средством преобразования местного
времени из структурного в текстовое представление является функция
strftime() (см. листинг 12.11
). Как и служебная программа date, она
преобразует дату и время в соответствии с заданным форматом, только
исходными данными служит не текущий момент времени, а структура
типа tm, на которую указывает аргумент tmptr, и результат направляется
не на стандартный вывод, а в буфер, заданный указателем s и длиной
maxsize.
#include <time.h>
size_t strftime (char *restrict s,
size_t maxsize, const char *restrict format,
const struct tm *restrict tmptr);
Листинг 12.11. Описание функции strftime().
По сравнению с date, функция strftime() содержит несколько
дополнительных спецификаторов форматных преобразований.
Перечислим наиболее употребительные из них.
Таблица 12.1. Спецификаторы преобразований
Спецификатор Описание
%F Представление даты в соответствии со
203
стандартом ISO 8601:2000: эквивалент
последовательности спецификаторов %Y-%m-%d.
%R
Часы и минуты (%H:%M) в 24-часовом
представлении.
%z
Смещение относительно всемирного
времени, представленное по стандарту ISO
8601:2000: +ччмм или -ччмм (положительные
значения соответствуют часовым поясам к
востоку от Гринвича).
Функция strftime() возвращает число байт, помещенное в буфер
(без учета завершающего нулевого байта). Если буфер оказался мал,
возвращается ноль.
На роль обратной по отношению к strftime() могут претендовать
сразу две функции: strptime() и getdate() (см. листинг 12.12
).
#include <time.h>
char *strptime (const char *restrict s,
const char *restrict format,
struct tm *restrict tmptr);
struct tm *getdate (const char *s);
Листинг 12.12. Описание функций strptime() и getdate().
Функция strptime() напоминает sscanf(): она сканирует цепочку
символов, на которую указывает аргумент s, в соответствии с заданным
форматом, включающим описанные выше спецификаторы
преобразований, а также, быть может, пробельные и обычные символы,
и помещает извлеченные значения в структуру типа tm по указателю
tmptr. В качестве результата возвращается указатель на первый
несканированный символ или NULL в случае неудачи.
Функция getdate(), по сути аналогичная strptime(), использует для
разбора входной цепочки s форматы, содержащиеся в файле, чье полное
маршрутное имя задано переменной окружения DATEMSK (для
интерпретации выбирается первый подходящий формат). Если дата и
время специфицированы не полностью (например, задан только день
недели), как исходные берутся данные о первом подходящем моменте
времени, начиная с текущего. Если в формате присутствует
спецификатор %Z, выходная структура инициализируется текущим
временем в сканируемом часовом поясе. В противном случае
применяется местное время.
С помощью внешней переменной (или макроса) getdate_err
функция getdate() возвращает коды ошибок.
Приведем пример использования описанных функций
преобразования данных о времени (см. листинг 12.13
).
#include <stdio.h>
#include <time.h>
#include <limits.h>
204
int main (void) {
char dtbuf [LINE_MAX]; /* Буфер для данных о времени */
time_t st;
struct tm stm;
(void) time (&st);
(void) strftime (dtbuf, sizeof (dtbuf), "%c", gmtime (&st));
printf ("Текущее всемирное время: %s\n", dtbuf);
(void) strftime (dtbuf, sizeof (dtbuf), "%c", localtime (&st));
printf ("Текущее местное время: %s\n", dtbuf);
/* Узнаем, каким днем недели будет 01 января 2038 года */
stm.tm_year = 2038 - 1900;
stm.tm_mon = 1 - 1;
stm.tm_mday = 1;
stm.tm_hour = 0;
stm.tm_min = 0;
stm.tm_sec = 0;
stm.tm_isdst = -1;
if ((st = mktime (&stm)) == (time_t) (-1)) {
perror ("MKTIME");
} else {
(void) strftime (dtbuf, sizeof (dtbuf), "%A", &stm);
printf ("День недели 01 января 2038 года: %s\n", dtbuf);
printf ("Число секунд от начала отсчета в начале 2038 года
(шест.): %x\n",
(unsigned int) st);
}
/* Узнаем, когда наступит переполнение значений типа time_t, */
/* представленных как 32-разрядное целое со знаком */
st = (time_t) 0x7fffffff;
(void) strftime (dtbuf, sizeof (dtbuf), "%c", gmtime (&st));
printf ("Всемирное время конца 32-разрядного отсчета: %s\n",
dtbuf);
/* Преобразуем эту дату в формат ISO 8601:2000 */
if (strptime (dtbuf, "%c", &stm) == NULL) {
perror ("STRPTIME");
} else {
(void) strftime (dtbuf, sizeof (dtbuf), "%F", &stm);
205
printf ("Дата конца 32-разрядного отсчета в формате ISO
8601:2000: %s\n",
dtbuf);
}
return (0);
}
Листинг 12.13. Пример программы, использующей функции
преобразования данных о времени.
Возможные результаты выполнения этой программы показаны в
листинге 12.14
.
Текущее всемирное время: Sat Jan 3 13:54:02 2004
Текущее местное время: Sat Jan 3 16:54:02 2004
День недели 01 января 2038 года: Friday
Число секунд от начала отсчета в начале 2038 года (шест.):
7fe7ed50
Всемирное время конца 32-разрядного отсчета: Tue Jan 19 03:14:07
2038
Дата конца 32-разрядного отсчета в формате ISO 8601:2000: 2038-
01-19
Листинг 12.14. Возможные результаты работы программы,
использующей функции преобразования данных о времени.
Последовательность инструкций языка C
char dtbuf [];
time_t st;
(void) strftime (dtbuf, sizeof (dtbuf), "%c",
localtime (&st));
является стандартной для получения текущего времени в
текстовом виде. (Разумеется, вместо "%c" допустим другой
спецификатор преобразования.) Нужно помнить только, что функции
gmtime() и localtime() возвращают указатели на статические структуры,
содержимое которых, возможно, перезаписывается при каждом вызове,
поэтому, если оно понадобится в дальнейшем, его следует скопировать в
собственные объекты.
Опрос показаний часов процессорного времени
Базовым средством для работы с часами процессорного времени
является функция clock() (см. листинг 12.15
). Она возвращает в качестве
результата процессорное время, затраченное процессом с некоего
момента, зависящего от реализации и связанного только с его (процесса)
запуском. В случае ошибки результат равен (clock_t) (-1).
#include <time.h>
clock_t clock (void);
Листинг 12.15. Описание функции clock().
Чтобы перевести время, возвращаемое функцией clock(), в
секунды, его следует поделить на константу CLOCKS_PER_SEC,
206
которая определена в заголовочном файле <time.h> равной одному
миллиону, хотя разрешающая способность часов процессорного времени
в конкретной реализации может и отличаться от микросекунды.
Отметим, что если значения типа clock_t представлены как 32-
разрядные целые со знаком, то менее чем через 36 минут (процессорного
времени) наступит переполнение.
В листинге 12.16
показан пример использования функции clock().
Поскольку начало отсчета для часов процессорного времени не
специфицировано, их показания опрашиваются в начале и конце
измеряемого промежутка, а результатом измерения затраченного
процессорного времени служит разность этих показаний.
#include <stdio.h>
#include <time.h>
int main (void) {
time_t st;
clock_t ct;
double s = 0;
double d = 1;
int i;
fprintf (stderr, "Начало выполнения цикла\n");
(void) time (&st);
ct = clock;
for (i = 1; i <= 100000000; i++) {
s += d / i;
d = -d;
}
fprintf (stderr, "Процессорное время выполнения цикла: %g сек.\n",
(double) (clock - ct) / CLOCKS_PER_SEC);
fprintf (stderr, "Астрономическое время выполнения цикла: %g
сек.\n",
difftime (time (NULL), st));
return (0);
}
Листинг 12.16. Пример программы, использующей функции
опроса показаний часов реального и процессорного времени.
Возможные результаты работы этой программы показаны в
листинге 12.17
. Процессорное время получилось больше
астрономического из-за ошибок округления.
Начало выполнения цикла
Процессорное время выполнения цикла: 15.19 сек.
Астрономическое время выполнения цикла: 15 сек.
207
Листинг 12.17. Возможные результаты работы программы,
использующей функции опроса показаний часов реального и
процессорного времени.
Для измерения времени выполнения простой команды можно
воспользоваться служебной программой time (не входящей, правда, в
обязательную часть стандарта POSIX-2001):
time [-p] команда [аргумент ...]
Она выдает в стандартный протокол астрономическое и
процессорное время, прошедшее от запуска до завершения команды с
указанными аргументами. Если задана опция -p, время выдается в
секундах в виде вещественных чисел. Процессорное время
подразделяется на пользовательское (затраченное самой командой) и
системное (ушедшее на оказание системных услуг команде). Если
предположить, что выполнимый файл приведенной выше программы
называется my_tcex, то командная строка
time -p my_tcex
выдаст в стандартный протокол примерно следующее (см. листинг
12.18):
Начало выполнения цикла
Процессорное время выполнения цикла: 15.2 сек.
Астрономическое время выполнения цикла: 15 сек.
real 15.20
user 15.20
sys 0.00
Листинг 12.18. Возможные результаты измерения времени
работы программы, использующей функции опроса показаний
часов реального и процессорного времени.
Если нужно измерить время выполнения конвейера или списка
команд, их можно поместить в файл, превратив тем самым в простую
команду, или воспользоваться конструкцией вида
time sh -c 'составная команда'
Оружием более крупного калибра является специальная
встроенная в shell команда
times
Она выдает на стандартный вывод процессорное время,
затраченное командным интерпретатором и порожденными им
процессами. Например, после выполнения команд
my_tcex & my_tcex
times
на стандартный вывод может быть выдано:
0m0.010s 0m0.000s
0m30.410s 0m0.000s
Можно видеть, что сам командный интерпретатор практически не
занимал процессор, а два порожденных им процесса в сумме потребили
208
чуть меньше тридцати с половиной секунд; время системных услуг в
обоих случаях оказалось пренебрежимо малым.
Реализация описанных выше утилит time и times опирается на
функцию times() (см. листинг 12.19
). Она опрашивает данные о времени
выполнения вызывающего процесса и порожденных процессов,
завершение которых ожидалось с помощью функций wait() или
waitpid(). В отличие от clock(), функция times() измеряет время в тактах
часов, и переполнение 32-разрядного представления значений типа
clock_t происходит не через полчаса, а примерно в течение года (если
секунда делится на 60 - 100 тактов). Соответственно, для перевода
результатов работы times() в секунды их нужно делить на sysconf
(_SC_CLK_TCK), а не на CLOCKS_PER_SEC.
#include <sys/times.h>
clock_t times (struct tms *buffer);
Листинг 12.19. Описание функции times().
В качестве результата функция times() возвращает
астрономическое время, прошедшее от некоторого момента в прошлом
(например, от загрузки системы), но основные, содержательные данные,
относящиеся к вызывающему процессу и его потомкам, помещаются в
структуру типа tms, которая описана в заголовочном файле <sys/times.h>
и, согласно стандарту POSIX-2001, должна содержать по крайней мере
следующие поля:
clock_t tms_utime;
/* Процессорное время, затраченное */
/* вызывающим процессом */
clock_t tms_stime;
/* Процессорное время, затраченное системой */
/* на обслуживание вызывающего процесса */
clock_t tms_cutime;
/* Процессорное время, затраченное
/*завершившимися порожденными процессами */
clock_t tms_cstime;
/* Процессорное время, затраченное системой */
/* на обслуживание завершившихся */
/* порожденных процессов */
Значения времени завершившихся порожденных процессов
(tms_utime и tms_cutime, а также tms_stime и tms_cstime) добавляются,
соответственно, к элементам tms_cutime и tms_cstime структуры
родительского процесса при возврате из функций wait() или waitpid().
Это происходит рекурсивно: если порожденный процесс ожидал
завершения своих потомков, то в упомянутых элементах структуры
накопятся данные о времени выполнения поддерева процессов.
209
В качестве примера использования функции times() измерим время
работы рассматривавшейся ранее программы, копирующей строки со
стандартного ввода на стандартный вывод через сокеты адресного
семейства AF_UNIX с помощью порожденного процесса (см. листинг
12.20).
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* Программа копирует строки со стандартного ввода на
стандартный вывод, */
/* "прокачивая" их через пару сокетов. */
/* Используются функции ввода/вывода нижнего уровня.
*/
/* Измеряется астрономическое и процессорное время
*/
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <sys/socket.h>
#include <sys/wait.h>
#include <sys/times.h>
#define MY_PROMPT "Вводите строки\n"
#define MY_MSG "Вы ввели: "
int main (void) {
int sds [2];
char buf [1];
int new_line = 1; /* Признак того, что надо выдать сообщение
MY_MSG */
/* перед отображением очередной строки
*/
clock_t st_ct; /* Данные об астрономическом и процессорном
времени */
struct tms st_cpt; /* в начале работы программы */
clock_t en_ct; /* Данные об астрономическом и процессорном
времени */
struct tms en_cpt; /* в конце работы программы */
long tck_p_sec; /* Количество тактов часов в секунде
*/
/* Опросим данные о времени начала выполнения */
if ((st_ct = times (&st_cpt)) == (clock_t) (-1)) {
perror ("TIMES-1");
return (1);
210
}
/* Создадим пару соединенных безымянных сокетов */
if (socketpair (AF_UNIX, SOCK_STREAM, 0, sds) < 0) {
perror ("SOCKETPAIR");
return (2);
}
switch (fork ()) {
case -1:
perror ("FORK");
return (3);
case 0:
/* Чтение из сокета sds [0] и выдачу на стандартный вывод */
/* реализуем в порожденном процессе */
while (read (sds [0], buf, 1) == 1) {
if (write (STDOUT_FILENO, buf, 1) != 1) {
perror ("WRITE TO STDOUT");
break;
}
}
exit (0);
}
/* Чтение со стандартного ввода и запись в сокет sds [1] */
/* возложим на родительский процесс */
if (write (sds [1], MY_PROMPT, sizeof (MY_PROMPT) - 1) !=
sizeof (MY_PROMPT) - 1) {
perror ("WRITE TO SOCKET-1");
}
while (read (STDIN_FILENO, buf, 1) == 1) {
/* Перед отображением очередной строки */
/* нужно выдать сообщение MY_MSG */
if (new_line) {
if (write (sds [1], MY_MSG, sizeof (MY_MSG) - 1) != sizeof
(MY_MSG) - 1) {
perror ("WRITE TO SOCKET-2");
break;
}
}
if (write (sds [1], buf, 1) != 1) {
perror ("WRITE TO SOCKET-3");
break;
}