# ./s5 -b54 -e56 -n2
signal SIGRTMIN=41 - signal SIGRTMAX=56
CHILD: signal mask set
signal sent: 54 with val = 0
signal sent: 54 with val = 1
signal sent: 55 with val = 0
signal sent: 55 with val = 1
signal sent: 56 with val = 0
signal sent: 56 with val = 1
PARENT: finished!
# CHILD: signal unblock
received signal 56 code = -2 val = 0
received signal 56 code = -2 val = 1
received signal 55 code = -2 val = 0
received signal 55 code = -2 val = 1
received signal 54 code = -2 val = 0
received signal 54 code = -2 val = 1
Независимо от порядка отправки сигналов порядок доставки их из очереди принимающему процессу сохраняется от старших номеров сигналов, которые являются более приоритетными, к младшим. А это в точности противоположно тому, что обещает документация, и соответствует картине, которую У. Стивенс наблюдал в ОС Sun Solaris 2.6 и которую он же комментирует словами: "Похоже, что в реализации Solaris 2.6 есть ошибка".
Выполним ту же задачу, но теперь не относительно сигналов диапазона реального времени, а относительно стандартных UNIX-сигналов. Выберем для этого произвольный диапазон сигналов (<signal.h>):
#define SIGVTALRM 28 /* virtual timer expired */
#define SIGPROF 29 /* profiling timer expired */
#define SIGXCPU 30 /* exceeded cpu limit */
#define SIGXFSZ 31 /* exceeded file size limit */
Посмотрим результат в этом случае:
# ./s5 -b28 -e31 -n2
signal SIGRTMIN=41 - signal SIGRTMAX=56
CHILD: signal mask set
signal sent: 28 with val = 0
signal sent: 28 with val = 1
signal sent: 29 with val = 0
signal sent: 29 with val = 1
signal sent: 30 with val = 0
signal sent: 30 with val = 1
signal sent: 31 with val = 0
signal sent: 31 with val = 1
PARENT finished!
# CHILD signal unblock
received signal 31 code = -2 val = 0
received signal 31 code = -2 val = 1
received signal 30 code = -2 val = 0
received signal 30 code = -2 val = 1
received signal 29 code = -2 val = 0
received signal 29 code = -2 val = 1
received signal 28 code = -2 val = 0
received signal 28 code = -2 val = 1
QNX при установке обработчика с флагом SA_SIGINFO использует модель работы реального времени не только относительно сигналов диапазона SIGRTMIN...SIGRTMAX, но и для всего множества стандартных UNIX-сигналов. Это расширение, впрочем, не противоречит приведенному выше утверждению POSIX, что такое решение факультативно (см. пункт 9 описания модели сигналов реального времени) и оставляется на усмотрение разработчика ОС.
Любопытным может оказаться и рассмотрение реакции на сигналы, которые никак не определены в QNX (в исследуемый диапазон для сравнения включены как неопределенные, так и определенные сигналы системы):
# ./s5 -b39 -e41 -n2
signal SIGRTMIN=41 - signal SIGRTMAX=56
CHILD: signal mask set
signal sent: 39 with val = 0
signal sent: 39 with val = 1
signal sent: 40 with val = 0
signal sent: 40 with val = 1
signal sent: 41 with val = 0
signal sent: 41 with val = 1
PARENT finished!
# CHILD: signal unblock
received signal 41 code = -2 val = 0
received signal 41 code = -2 val = 1
received signal 40 code = -2 val = 0
received signal 40 code = -2 val = 1
received signal 39 code = -2 val = 0
received signal 39 code = -2 val = 1
Для них реакция никак не отличается от реакции на другие сигналы, что, впрочем, неудивительно, учитывая замечание в цитировавшемся выше фрагменте документации о том, что возбуждение сигнала и посылка импульса (сообщения) микроядра в QNX - одно и то же, и обрабатываются они единым механизмом.
Посмотрим также реакцию системы на специальные сигналы QNX, номера которых выше SIGRTMAX (в исследуемый диапазон опять для сравнения включим как специальные сигналы (57…64), так и сигналы из диапазона 1…SIGRTMAX):
# ./s5 -b56 -e59 -n2
signal SIGRTMIN=41 - signal SIGRTMAX=56
set signal handler... Invalid argument
set signal handler... Invalid argument
set signal handler... Invalid argument
CHILD: signal mask set
signal sent: 56 with val = 0
signal sent: 56 with val = 1
signal sent: 57 with val = 0
signal sent: 57 with val = 1
signal sent: 58 with val = 0
signal sent: 58 with val = 1
signal sent: 59 with val = 0
signal sent: 59 with val = 1
PARENT: finished!
# CHILD: signal unblock
received signal 56 code = -2 val = 0
received signal 56 code = -2 val = 1
Из вывода видно, что на сигнал с номером 56 реакция ожидаемая, а на остальные сигналы реакции нет вовсе. Как и следует из предупреждения в документации, заблокировать или изменить реакцию на эти сигналы невозможно, и попытка установки sigaction() для них завершается ошибкой.
Таким образом, система фактически никак не выделяет сигналы диапазона реального времени (41…56), но обрабатывает аналогичным образом и стандартные сигналы UNIX (1…31), и специальные сигналы QNX (57…64), и даже сигналы, никак не специфицируемые системой вообще (32…40). Корректнее говорить не об обработке сигналов реального времени и даже не о модели сигналов реального времени, а об еще одном способе работы с любыми сигналами - обработке сигналов на базе очередей сигналов.
Примечание
Для полноты картины приведем конкретную спецификацию типа siginfo_t для QNX (выше мы рассматривали минимальную спецификацию этого типа, требуемую POSIX). Спецификация весьма объемна (вся информация до конца раздела может быть безболезненно пропущена теми, кому это неинтересно), но предоставляет программисту исчерпывающую информацию о полученном сигнале:
typedef struct {
int si_signo;
int si_code; /* if SI_NOINFO, only si_signo is valid */
int si_errno;
union {
int __pad[7];
struct {
pid_t __pid;
union {
struct {
uid_t __uid;
union sigval __value;
} kill; /* si_code <= 0 SI_FROMUSER */
struct {
_CSTD clock_t __utime;
/* CLD_EXITED status, else signo */
int _status;
_CSTD clock_t __stime;
} __chld;
/* si_signo=SlGCHLD si_code=CLD_* */
} __pdata;
} __proc;
struct {
int __fltno;
void* __fltip;
void* __addr;
} fault; /* si_signo=SIGSEGV,ILL,FPE,TRAP,BUS */
} __data;
} siginfo_t;
#define si_pid __data.__proc.__pid
#define si_value __data.__proc.__pdata.__kill.__value
#define si_uid __data.__proc.__pdata.__kill.__uid
#define si_status __data.__proc.__pdata.__chld.__status
#define si_utime __data.__proc.__pdata.__chld.__utime
#define si_stime __data.__proc.__pdata.__chld.__stime
#define si_fltno __data.__fault.__fltno
#define si_trapno si_fltno
#define si_addr __data.__fault.__addr
#define si_fltip __data.__fault.__fltip
И полный перечень определений символьных констант, используемых для установки значений поля si_code:
#define SI_USER 0
#define SI_RESERVED1 (-1)
#define SI_QUEUE (-2)
#define SI_TIMER (-3)
#define SI_ASYNCIO (-4)
#define SI_MESGQ (-5)
#define SI_NOTIFY (-6)
#define SI_IRQ (-7)
// QNX managers will never use this range.
#define SI_MINAVAIL (-128)
#define SI_MAXAVAIL (-64)
#define SI_NOINFO 127
#define SI_MAXSZ 126
Значение SI_QUEUE, равное -2, - это и есть то значение, которое мы видели в выводе тестовой задачи выше.
Соображения производительности
Ранее мы производили оценку затрат производительности процессора на переключение между контекстами для процессов и для потоков (тестовые задачи, которые мы по их структуре именовали как "симметричные"). Проделаем теперь то же самое, но синхронизацию процессов выполним посылкой и приемом сигнала (переключение контекстов будет происходить именно на операторе pause() - переходе к приему сигнала) (файл p6s.cc):
Затраты на переключение процессов посылкой сигналов
#include <stdlib.h>
#include <stdio.h>
#include <inttypes.h>
#include <iostream.h>
#include <unistd.h>
#include <sched.h>
#include <sys/neutrino.h>
// "пустые" обработчики сигналов
static void nhand(int signo) {}
static void qhand(int signo, siginfo_t* info, void* context) {}
int main(int argc, char *argv[]) {
unsigned long N = 1000;
bool que = false;
int opt, val;
while ((opt = getopt(argc, argv, "n:q")) != -1) {
switch(opt) {
case 'n':
if (sscanf(optarg, "%i", &val) != 1)
cout << "parse command line error" << endl, exit(EXIT_FAILURE);
if (val > 0) N = val;
break;
// ключ q определяет схему обработки сигнала
case 'q':
que = true;
break;
default:
exit(EXIT_FAILURE);
}
}
// установка сигнальных обработчиков
sigset_t sig;
sigemptyset(&sig);
sigaddset(&sig, SIGUSR1);
sigprocmask(SIG_UNBLOCK, &sig, NULL);
struct sigaction act;
act.sa_mask = sig;
act.sa_sigaction = qhand;
act.sa_handler = nhand;
act.sa_flags = que ? SA_SIGINFO : 0;
if (sigaction(SIGUSR1, &act, NULL) < 0)
cout << "set signal handler" << endl, exit(EXIT_FAILURE);
pid_t pid = fork();
if (pid == -1)
cout << "fork error" << endl, exit(EXIT_FAILURE);
// кому отправлять сигнал?
pid_t did = (pid == 0 ? getppid() : pid);
unsigned long i = 0;
uint64_t t = ClockCycles();
while (true) {
kill(did, SIGUSR1);
if (++i == N) break;
pause();
}
t = ClockCycles() - t;
cout << getpid() << " -> " << did << "\t: cycles - " << t <<
"; on signal - " << (t / N) / 2 << endl;
exit(EXIT_SUCCESS);
}
Этим приложением мы можем тестировать и традиционную схему обработки сигналов (модель надежных сигналов), и схему обработки с очередью поступления сигналов (модель сигналов реального времени), когда при старте программы указан ключ -q. Посмотрим на результаты тестовых запусков:
# nice -n-19 p6s -n1000
2904115 -> 2912308 : cycles - 5792027; on signal - 2896
2912308 -> 2904115 : cycles - 5828952; on signal - 2914
# nice -n-19 p6s -n10000
2920499 -> 2928692 : cycles - 57522753, on signal - 2876
2928692 -> 2920499 : cycles - 57530378; on signal- 2876
# nice -n-19 p6s -n100000
2936883 -> 2945076 : cycles - 573730469; on signal - 2868
2945076 -> 2936883 : cycles - 573738122; on signal - 2868
# nice -n-19 p6s -n1000000
2953267 -> 2961460 : cycles - 5747418203, on signal - 2873
2961460 -> 2953267 : cycles - 5747425310; on signal - 2873
Вспомним, что при изучении тестов простого переключения процессов (см. в главе 2) мы получали цифру порядка 600 процессорных циклов на переключение. Сейчас у нас затраты заметно больше: порядка 2850 циклов, из которых "лишние" 2250 - это не что иное, как затраты на посылку и прием сигнала, возбуждение функции обработчика и ее завершение (разделить их по компонентам мы не можем). Это и может служить ориентировочной оценкой трудоемкости обмена сигналами.
Проделаем то же самое, но уже при обработке сигналов в порядке очереди их поступления:
# nice -n-19 p6s -n1000 -q
2838579 -> 2846772 : cycles - 5772106; on signal - 2886
2846772 -> 2838579 : cycles - 5782138; on signal - 2891
# nice -n-19 p6s -n10000 -q
2854963 -> 2863156 : cycles - 57194634; on signal - 2859
2863156 -> 2854963 : cycles - 57199831; on signal - 2859
# nice -n-19 p6s -n1000000 -q
2871347 -> 2879540 : cycles - 571543013; on signal - 2857
2879540 -> 2871347 : cycles - 571550847; on signal - 2857
# nice -n-19 p6s -n1000000 -q
2887731 -> 2895924 : cycles - 5715903548; on signal - 2857
2895924 -> 2887731 : cycles - 5715908318; on signal - 2857
Это практически те же цифры, поэтому мы можем предположить, что, вообще-то говоря, для всех рассмотренных ранее схем обработки реализуется один и тот же внутренний механизм приема сигналов, который только лишь модифицируется в зависимости от используемой схемы.