QNX/UNIX: Анатомия параллелизма

 uint64_t cps;
 result(void) {
  pid = getpid();
  // если уж возвращать, то и служебную информацию ;)
  cps = SYSPAGE_ENTRY(qtime)->cycles_per_sec;
 }
}
// завершение с извещением кода причины
inline void exit(const char *msg) {
 cout << '
';
 perror(msg);
 exit(EXIT_FAILURE);
}

В этой части каких-либо комментариев заслуживает разве что структура result. Наш сервер устроен «наоборот»: информационный обмен данными он осуществляет по запросу devctl() , запрос read() нам «не нужен», и мы используем его только для возврата информации (PID + CHID) об автономном канале обмена сообщениями. Заодно мы передаем в поле cps этой структуры значение тактовой частоты процессора сервера, что позволяет знать, «с кем мы имеем дело» при экспериментах в сети.

Теперь мы вполне готовы написать код сервера. Этот сервер (файл srv.cc), в отличие от традиционных, имеет два независимых канала подключения: как менеджер ресурсов и как сервер простого обмена сообщениями. Как менеджер он по запросу read() возвращает адресные компоненты (PID, CHID) для обмена сообщениями (ND клиент должен восстановить самостоятельно). По запросу devctl(), а также по запросу по автономному каналу обмена сообщениями сервер просто ретранслирует обратно полученный от клиента блок данных (в каком-то смысле по обоим каналам обмена наш сервер является «зеркалом», отражающим данные).

Сервер запросов

result data;
//---------------------------------------------------------
// реализация обработчика read()
static int readfunc(resmgr_context_t *ctp, io_read_t *msg,
 iofunc_ocb_t *ocb) {
 int sts = iofunc_read_verify(ctp, msg, ocb, NULL);
 if (sts != EOK) return sts;
 // возвращать одни и те же статические данные...
 MsgReply(ctp->rcvid, sizeof(result), &data, sizeof(result));
 return _RESMGR_NOREPLY;
}
//---------------------------------------------------------
// реализация обработчика devctl.
static int devctlfunc(resmgr_context_t *ctp, io_devctl_t *msg,
 iofunc_ocb_t *ocb) {
 int sts = iofunc_devctl_default(ctp, msg, ocb);
 if (sts != _RESMGR_DEFAULT) return sts;
 // разбор динамически создаваемого кода devctl(),
 // извлечение из него длины принятого блока
 unsigned int nbytes = (msg->i.dcmd - DCMD_SRR) >> 16;
 msg->o.nbytes = nbytes;
 // и тут же ретрансляция блока назад
 return _RESMGR_PTR(ctp, &msg->i, sizeof(msg->i) + nbytes);
}
//---------------------------------------------------------
// установка однопоточного менеджера, выполняемая
// в отдельном потоке
static void* install(void* data) {
 dispatch_t *dpp;
 if ((dpp = dispatch_create()) == NULL)
  exit('dispatch allocate');
 resmgr_attr_t resmgr_attr;
 memset(&resmgr_attr, 0, sizeof(resmgr_attr));
 resmgr_attr.nparts_max = 1;
 resmgr_attr.msg_max_size = 2048;
 static resmgr_connect_funcs_t connect_funcs;
 static resmgr_io_funcs_t io_funcs;
 iofunc_func_init(_RESMGR_CONNECT_NFUNCS, &connect_funcs,
  _RESMGR_IO_NFUNCS, &io_funcs);
 // определяем обработку, отличную от обработки по умолчанию,
 // только для двух команд: read() & devctl()
 io_funcs.read = &readfunc;
 io_funcs.devctl = &devctlfunc;
 static iofunc_attr_t attr;
 iofunc_attr_init(&attr, S_IFNAM | 0666, 0, 0);
 // связываем менеджер с его префиксным именем
 if (resmgr_attach(dpp, &resmgr_attr, DEVNAME,
  _FTYPE_ANY, 0, &connect_funcs, &io_funcs, &attr) == -1)
  exit('prefix attach');
 dispatch_context_t* ctp = dispatch_context_alloc(dpp);
 while (true) {
  if ((ctp = dispatch_block(ctp)) == NULL)
   exit('block error');
  dispatch_handler(ctp);
 }
}
// размер буфера для обмена сообщениями,
// этого нам хватит с большим запасом и надолго ;)
const int blk = 100000;
// обработчик низкоуровневых сообщений,
// также работающий в отдельном потоке
void* msginout(void* с) {
 static uint8_t bufin[blk];
 struct _msg_info info;
 while (true) {
  int rcvid = MsgReceive(data chid, &bufin, blk, &info);
  if (rcvid < 0) exit('message receive');
  if (MsgReply(rcvid, EOK, &bufin, info.msglen) < 0)
  exit('message reply');