Храмцов П.Б. Открытые системы
Подождите немного. Документ загружается.
211
new_line = (buf [0] == '\n');
}
shutdown (sds [1], SHUT_WR);
(void) wait (NULL);
/* Опросим данные о времени конца выполнения, */
/* вычислим и выдадим результаты измерений */
if ((en_ct = times (&en_cpt)) == (clock_t) (-1)) {
perror ("TIMES-2");
return (4);
}
tck_p_sec = sysconf (_SC_CLK_TCK);
fprintf (stderr, "Тактов в секунде: %ld\n", tck_p_sec);
fprintf (stderr, "Астрономическое время работы программы: %g
сек.\n",
(double) (en_ct - st_ct) / tck_p_sec);
fprintf (stderr, "Процессорное время, затраченное процессом: %g
сек.\n",
(double) (en_cpt.tms_utime - st_cpt.tms_utime) / tck_p_sec);
fprintf (stderr, "Процессорное время, затраченное системой: %g
сек.\n",
(double) (en_cpt.tms_stime - st_cpt.tms_stime) / tck_p_sec);
fprintf (stderr, "Аналогичные данные для порожденных
процессов:\n");
fprintf (stderr, "%g сек.\n%g сек.\n",
(double) (en_cpt.tms_cutime - st_cpt.tms_cutime) / tck_p_sec,
(double) (en_cpt.tms_cstime - st_cpt.tms_cstime) / tck_p_sec);
return (0);
}
Листинг 12.20. Пример программы, использующей функцию
times().
Если перенаправить стандартный ввод в какой-либо текстовый
файл заметных размеров, а стандартный вывод - в другой файл, можно
получить результаты, подобные тем, что показаны в листинге 12.21
.
Тактов в секунде: 100
Астрономическое время работы программы: 1.19 сек.
Процессорное время, затраченное процессом: 0.02 сек.
Процессорное время, затраченное системой: 0.08 сек.
Аналогичные данные для порожденных процессов:
0.09 сек.
1 сек.
212
Листинг 12.21. Возможные результаты работы программы,
использующей функцию times().
Прямое манипулирование часами процессорного времени
возможно после обращения к функции clock_getcpuclockid() (см. листинг
12.22), позволяющей выяснить их идентификатор. Оговоримся, однако,
что эта функция не входит в обязательную часть стандарта POSIX-2001
(она относится к продвинутым средствам реального времени).
#include <time.h>
int clock_getcpuclockid
(pid_t pid, clockid_t *clock_id);
Листинг 12.22. Описание функции clock_getcpuclockid().
Идентификатор часов процессорного времени, обслуживающих
заданный аргументом pid процесс, возвращается по адресу,
специфицированному аргументом clock_id. Если значение pid равно
нулю, имеется в виду вызывающий процесс. Признаком успешного
завершения является нулевой результат; в противном случае
возвращается код ошибки.
В листинге 12.23
показан пример употребления функции
clock_getcpuclockid() и манипулирования часами процессорного
времени. Возможные результаты выполнения этой программы - в
листинге 12.24
.
#include <stdio.h>
#include <time.h>
#include <sys/types.h>
#include <errno.h>
int main (void) {
clockid_t clk_id; /* Идентификатор часов процессорного
времени */
struct timespec tmsp;
double s = 0;
double d = 1;
int i;
if ((errno = clock_getcpuclockid ((pid_t) 0, &clk_id)) != 0) {
perror ("CLOCK_GETCPUCLOCKID");
return (1);
}
if (clock_getres (clk_id, &tmsp) == -1) {
perror ("CLOCK_GETRES");
return (2);
}
printf ("Разрешающая способность часов процессорного времени:
%ld нсек.\n",
213
tmsp.tv_nsec);
/* Измерим процессорное время выполнения цикла. */
fprintf (stderr, "Начало выполнения цикла\n");
tmsp.tv_sec = tmsp.tv_nsec = 0;
if (clock_settime (clk_id, &tmsp) == -1) {
perror ("CLOCK_SETTIME");
return (3);
}
for (i = 1; i <= 100000000; i++) {
s += d / i;
d = -d;
}
if (clock_gettime (clk_id, &tmsp) == -1) {
perror ("CLOCK_GETTIME");
return (4);
}
fprintf (stderr, "Процессорное время выполнения цикла: %ld сек.
%ld нсек.\n",
tmsp.tv_sec, tmsp.tv_nsec);
return (0);
}
Листинг 12.23. Пример программы, манипулирующей часами
процессорного времени.
Разрешающая способность часов процессорного времени: 2 нсек.
Начало выполнения цикла
Процессорное время выполнения цикла: 15 сек. 350313054 нсек.
Листинг 12.24. Возможные результаты работы программы,
манипулирующей часами процессорного времени.
Обратим внимание на два момента. Перед началом измеряемого
участка программы на часах процессорного времени были установлены
нулевые показания, что, разумеется, не влияет на приоритет процесса и
его планирование. Конечно, можно было обойтись без переустановки,
запомнив показания часов в начале и конце измеряемого промежутка и
произведя затем их вычитание, но технически это чуть сложнее; кроме
того, нам хотелось применить функцию clock_settime(). Второй
заслуживающий отдельного упоминания момент состоит в отсутствии
необходимости выяснять идентификатор часов процессорного времени
вызывающего процесса с помощью функции clock_getcpuclockid():
можно воспользоваться именованной константой
CLOCK_PROCESS_CPUTIME_ID.
Опрос и изменение данных о времени, ассоциированных с
файлами
214
Информацию о файле, в том числе данные о времени последнего
доступа и изменения, можно получить с помощью описанных ранее
функций семейства stat().
Для изменения ассоциированных с файлами данных о времени
служит функция utime() (см. листинг 12.25
), оперирующая в терминах
секунд от начала отсчета.
#include <utime.h>
int utime (const char *path,
const struct utimbuf *times);
Листинг 12.25. Описание функции utime().
Если значение аргумента times равно пустому указателю,
используется текущее время. В этом случае для успешного изменения
данных о времени действующий идентификатор процесса должен
соответствовать владельцу файла либо процесс должен иметь права на
запись в файл или соответствующие привилегии.
Если значение times отлично от NULL, оно трактуется как
указатель на структуру типа utimbuf, которая, согласно стандарту
POSIX-2001, содержит по крайней мере следующие поля:
time_t actime;
/* Время последнего доступа */
time_t modtime;
/* Время последнего изменения */
При этом данные о времени устанавливаются по указуемой
структуре, а вызывающий процесс должен обладать соответствующими
привилегиями или действующим идентификатором, совпадающим с
идентификатором владельца файла (наличия права на запись
недостаточно).
В случае успешного завершения функция utime() возвращает
нулевой результат и, кроме того, переустанавливает время последнего
изменения статуса файла.
Приведем пример программы, изменяющей время последнего
доступа к файлу (см. листинг 12.26
).
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* Программа устанавливает время последнего доступа к файлу -
*/
/* аргументу командной строки, равное текущему времени */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
#include <stdio.h>
#include <sys/stat.h>
#include <time.h>
#include <utime.h>
int main (int argc, char *argv []) {
215
struct stat st_buf; /* Буфер для опроса данных о файле
*/
struct utimbuf ut_buf; /* Буфер для формирования изменяемых
данных о файле */
if (argc != 2) {
fprintf (stderr, "Использование: %s файл\n", argv [0]);
return (1);
}
if (stat (argv [1], &st_buf) != 0) {
perror ("STAT");
return (2);
}
ut_buf.actime = time (NULL);
ut_buf.modtime = st_buf.st_mtime;
if (utime (argv [1], &ut_buf) != 0) {
perror ("UTIME");
return (3);
}
return (0);
}
Листинг 12.26. Пример программы, изменяющей время
последнего доступа к файлу.
Чтобы изменить только одно из двух ассоциированных с файлом
времен, необходимо с помощью функции stat() получить информацию о
файле, перенести неизменяемое значение из структуры типа stat в
utimbuf, установить требуемым образом второй элемент структуры типа
utimbuf и только после этого обратиться к функции utime().
Читателю предлагается убедиться, что приведенная программа
работает должным образом и что опция -u служебной программы ls
предписывает оперировать со временем последнего доступа вместо
времени последнего изменения.
Приостановка выполнения на заданное время
Обычным средством ожидания наступления каких-либо событий,
не прерывающих выполнения процесса (потока управления), является
циклическое чередование приостановки выполнения на заданное время
и опроса статуса события.
Функция sleep() (см. листинг 12.27
) позволяет приостановить
выполнение процесса (потока управления) на заданное число секунд.
Если в это время будет доставлен сигнал, который не игнорируется,
вызов sleep() завершится досрочно, а результат будет равен
216
"недоспанному" числу секунд. (В случае нормального завершения
результат равен нулю, что формально можно считать частным случаем
предыдущего.)
#include <unistd.h>
unsigned sleep (unsigned seconds);
Листинг 12.27. Описание функции sleep().
Обратим внимание на то, что аргумент и результат функции sleep()
описаны как unsigned. Это значит, что приложения, строго
соответствующие стандарту POSIX-2001, не должны передавать sleep()
величины, превышающие минимально допустимое значение
конфигурационной константы UINT_MAX, которое в стандарте ISO C
[5] полагается равным 65535. Использование больших величин, вообще
говоря, ограничивает мобильность приложений.
Если вместо функции sleep() воспользоваться ее более
современным аналогом nanosleep() (см. листинг 12.28
), можно убить
сразу двух зайцев: избавиться от обременительного ограничения на
максимальную длительность приостановки выполнения и получить
возможность задавать эту длительность с существенно более высокой
точностью, ограниченной только разрешающей способностью часов
реального времени.
#include <time.h>
int nanosleep (const struct timespec *rqtp,
struct timespec *rmtp);
Листинг 12.28. Описание функции nanosleep().
Аргумент rqtp функции nanosleep() задает запрашиваемую
длительность приостановки. По указателю rmtp, если он не пуст,
возвращается "недоспанное" время. В отличие от sleep(), результат
nanosleep() равен -1 - как в результате ошибки, так и при "недосыпании",
вызванном доставкой сигнала.
В общем случае ожидание наступления какого-либо события
может быть активным или пассивным. Активное ожидание предполагает
постоянный, повторяющийся в цикле опрос ассоциированных с
событием значений и, следовательно, вызывает расход процессорного
времени. При пассивном ожидании процесс приостанавливается
(например, на семафоре) до наступления события, не занимая процессор.
Функции sleep() и nanosleep() позволяют выбрать компромиссный
способ ожидания, когда процессорного времени расходуется немного и
оперативность реагирования на события оказывается
удовлетворительной.
В листинге 12.29
показан пример использования функции sleep()
для "полупассивного" ожидания изменения файла. Разумеется,
обработка файла может быть более содержательной, однако
представленная схема действий носит весьма общий характер и
используется, например, служебными программами cron, tail и др.
/* * * * * * * * * * * * * * * * * * * * * * * * * */
217
/* Программа отслеживает изменение размера файла, */
/* заданного как аргумент командной строки */
/* * * * * * * * * * * * * * * * * * * * * * * * * */
#include <unistd.h>
#include <stdio.h>
#include <sys/stat.h>
#include <time.h>
#include <limits.h>
static time_t lt_mod = 0; /* Время последнего изменения файла
*/
static struct stat st_buf; /* Данные о файле */
/* Функция начальной обработки файла */
static void proc_init (const char *path) {
fprintf (stderr, "Данные о размере файла %s\n", path);
fprintf (stderr, "Время изменения Размер\n");
}
/* Функция проверки, нужно ли обрабатывать файл */
/* Результат > 0 - нужно */
/* 0 - не нужно */
/* < 0 - ошибка */
static int check_mod (const char *path) {
if (stat (path, &st_buf) != 0) {
perror ("STAT");
return (-1);
}
if (st_buf.st_mtime != lt_mod) {
/* Файл изменился и, следовательно, нуждается в обработке */
lt_mod = st_buf.st_mtime;
return (1);
}
return 0;
}
/* Функция обработки файла. */
/* Выведем время последнего изменения и текущий размер */
static void proc_mod (void) {
char dtbuf [LINE_MAX]; /* Буфер для данных о времени */
(void) strftime (dtbuf, sizeof (dtbuf), "%c", localtime (<_mod));
218
fprintf (stderr, "%s %ld\n", dtbuf, st_buf.st_size);
}
int main (int argc, char *argv []) {
int res;
if (argc != 2) {
fprintf (stderr, "Использование: %s файл\n", argv [0]);
return (1);
}
proc_init (argv [1]);
while (1) {
if ((res = check_mod (argv [1])) > 0) {
proc_mod ();
} else if (res < 0) {
return (res);
}
sleep (1);
}
return 0;
}
Листинг 12.29. Пример программы, использующей функцию
sleep().
Возможные результаты работы этой программы показаны в
листинге 12.30
.
Данные о размере файла /var/log/cron
Время изменения Размер
Tue Jan 6 12:50:00 2004 11191
Tue Jan 6 13:01:00 2004 11263
Tue Jan 6 13:10:00 2004 11409
Tue Jan 6 13:20:00 2004 11481
. . .
Tue Jan 6 13:40:00 2004 11624
. . .
Листинг 12.30. Возможные результаты работы программы,
использующей функцию sleep().
Функция nanosleep() позволяет до некоторой степени
промоделировать работу функций poll() и select(), реализующих
пассивное ожидание готовности данных, в тех ситуациях, когда данные
поступают из разнородных источников, которые poll() и select() не
обслуживают (не только из файлов, но и из очередей сообщений, как
результат опроса значений семафоров и т.п.). В листинге 12.31
показан
219
цикл "полуактивного" (с короткими приостановками) ожидания
поступления данных из канала и обнуления значения семафора.
#define N ...
#define MY_BUFSIZ ...
struct timespec tmsp = {0, 20000000};
int fds [2]; /* Файловые дескрипторы канала */
int semid; /* Идентификатор набора семафоров
*/
struct sembuf sembuf [1]; /* Массив для задания операций над
семафором */
char buf [MY_BUFSIZ]; /* Буфер для чтения данных из
канала */
int brd; /* Число прочитанных байт */
int i;
. . .
fcntl (fds [0], F_SETFL, O_NONBLOCK);
sembuf [0].sem_num = 0;
sembuf [0].sem_flg = IPC_NOWAIT;
sembuf [0].sem_op = 0;
for (i = 0; i < N; i++) {
nanosleep (&tmsp, NULL);
if ((brd = read (fds [0], buf, MY_BUFSIZ) > 0) {
/* Обработка прочитанных данных. */
/* Возможно, поступление данных на этом не закончилось */
. . .
continue;
}
if (semop (semid, sembuf, 1) == 0) {
/* Значение семафора обнулено, ждать больше нечего */
. . .
if (brd <= 0) {
close (fds [0]);
break;
}
}
}
. . .
220
Листинг 12.31. Пример реализации полуактивного ожидания
наступления нескольких событий с помощью функции nanosleep().
Подобные действия характерны для функций аккуратного
завершения многопроцессных приложений, когда значение семафора
играет роль счетчика активных порожденных процессов, от которых
через канал поступают данные.
Работа с интервальными таймерами
Интервальным таймером называется механизм, способный
известить процесс (поток управления) об истечении заданного
промежутка времени.
Описываемые далее средства для работы с интервальными
таймерами входят в необязательную часть стандарта POSIX-2001,
именуемую "X/Open-расширение системного интерфейса" (XSI).
Реализация должна предоставлять каждому процессу по крайней
мере три интервальных таймера, обозначаемых следующими
идентификаторами.
ITIMER_REAL
Таймер реального времени. Он ассоциирован с часами
CLOCK_REALTIME и, следовательно, его показания уменьшаются в
реальном масштабе времени. Когда он срабатывает, процессу
доставляется сигнал SIGALRM.
ITIMER_VIRTUAL
Таймер виртуального времени процесса. Его показания
уменьшаются в соответствии с течением виртуального времени
процесса, т. е. только тогда, когда процесс выполняется. При
срабатывании таймера процессу доставляется сигнал SIGVTALRM.
ITIMER_PROF
Таймер профилирования. Показания этого таймера уменьшаются с
течением виртуального времени процесса, а также тогда, когда работают
запрошенные им системные сервисы. Он предназначен для построения
статистическими методами профилей расходования процессом
процессорного времени. При его срабатывании процессу доставляется
сигнал SIGPROF.
Согласно стандарту POSIX-2001, интервальные таймеры
обслуживаются функциями getitimer() и setitimer() (см. листинг 12.32)
.
#include <sys/time.h>
int getitimer (int timer_id,
struct itimerval *cvalue);
int setitimer (int timer_id,
const struct itimerval *restrict nvalue,
struct itimerval *restrict ovalue);
Листинг 12.32. Описание функций getitimer() и setitimer().
Поддерживаемые стандартом значения аргумента timer_id
перечислены выше. Другие характеристики интервальных таймеров