Олег Цилюрик - QNX/UNIX: Анатомия параллелизма

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");

}

}

//--------------------------------------------------------

// "пустой" обработчик реакции на ^C (сигнал SIGINT)

inline static void empty(int signo) {}

//--------------------------------------------------------

// главная программа, которая все это "хозяйство" установит

// и будет безропотно ждать завершения по ^C ;)

int main(int argc, char *argv[]) {

cout << "SRR server: " << VERSION << endl;

// открывается менеджер ресурса ...

int fd = open(DEVNAME, O_RDONLY);

// если менеджер открылся, то это нам не нужно -

// дубликаты не создавать!

if (fd > 0)

close(fd), cout << "already in use " << DEVNAME << endl, exit(EXIT_FAILURE);

// перехватываем реакцию ^C:

cout << ". . . . . . waiting ^C. . . . . ." << flush;

signal(SIGINT, empty);

// создается канал для обмена низкоуровневыми сообщениями

data.chid = ChannelCreate(0);

// и запускается отдельным потоком ретранслятор с этого канала

if (pthread_create(NULL, NULL, msginout, NULL) != EOK)

exit("message thread");

// запускается менеджер ресурса

if (pthread_create(NULL, NULL, install, NULL) != EOK)

exit("manager thread");

// ... все! Мы свое дело сделали и ожидаем ^C ...

pause();

cout << "\rFinalization... " << endl;

// ... очистка, завершение ...

ChannelDestroy(data.chid);

return EXIT_SUCCESS;

}

Первая клиентская программа ( файл cli.cc ) посылает серверу блок данных указанной длины (длина может изменяться в широких пределах указанием при запуске ключа -b) и ожидает от него ретрансляции, после чего замеряет время ответа от сервера. Этот процесс повторяется многократно (ключ -m).

#include "common.h"

static uint64_t *tim;

static int num = 10;

// вывод результатов с оценкой статистики: среднее, С.К.О...

static void outtim(void) {

double m = 0., s = 0.;

for (int i = 0; i < num; i++) {

double d = (double)tim[i];

m += d;

s += d * d;

}

m /= num;

s = sqrt(s / num - m * m);

cout << '\t' << (uint64_t)floor(m + 5) << "\t~" << (uint64_t)floor(s + .5) <<

"\t{" << (uint64_t)floor(s / m * 100 + .5) << "%}" << endl;

}

int main(int argc, char **argv) {

cout << "SRR client: " << VERSION << endl;

int opt, val;

unsigned int blk = 100;

char PATH[_POSIX_PATH_MAX] = "";

while ((opt = getopt(argc, argv, "n:b:m:")) != -1) {

switch (opt) {

case 'n': // имя хоста сервера

strcpy(PATH, "/net/");

strcat(PATH, optarg);

break;

case 'b': // размер блока обмена (байт)

if (sscanf(optarg, "%i", &blk) != 1)

exit("parse command line failed");

break;

case 'm': // число повторений таких блоков

if (sscanf(optarg, "%i", &num) != 1)

exit("parse command line failed");

break;

default:

exit(EXIT_FAILURE);

}

}

// "составить" полное имя менеджера

strcat(PATH, DEVNAME);

cout << "server path. " << PATH << ", block size = "

<< blk << " bytes, repeat = " << num << endl;

// при инициализации мы сразу получаем скорость процессора клиента

result data;

cout << "CPU speed [с.p.s ]: client = " << data.cps;

// пытаемся подключиться к серверу-менеджеру

int fd = open(PATH, O_RDONLY);

if (fd < 0) exit("server not found");

// читаем его параметры

if (read(fd, &data, sizeof(result)) == -1)

exit("parameter block read");

cout << ", server = " << data.cps << endl;

tim = new uint64_t[num];

uint64_t tim2;

uint8_t *bufin = new uint8_t[blk];

*bufou = new uint8_t[blk];

// определяем дескриптор сетевого узла

int32_t node = netmgr_strtond(PATH, NULL);

// это интересное место: если в имени нет сетевого префикса пути,

// но это имя удается открыть, то это локальный хост!

if (node == -1 && fd > 0 && errno == ENOENT)

node = ND_LOCAL_NODE;

// по адресным данным, полученным ранее по read(), создаем канал

// для прямого обмена сообщениями с тем же процессом:

int coid = ConnectAttach(node, data.pid, data.chid, _NTO_SIDE_CHANNEL, 0);

if (coid < 0) exit("connect to message channel");

cout << " - message exchange:" << flush;

// обмен по каналу низкоуровневых сообщений

for (int i = 0; i < num; i++) {

tim[i] = ClockCycles();

if (MsgSend(coid, bufou, blk, bufin, blk) == -1)

exit("exchange data with channel");

tim[i] = ClockCycles() - tim[i];

}

outtim();

ConnectDetach(coid);

// повторяем в точности тот же обмен, но по запросу devctl()

unsigned int DCTL = (blk<<16) + DCMD_SRR;

cout << "- manager exchange:" << flush;

for (int i = 0; i < num; i++) {

tim[i] = ClockCycles();

if (devctl(fd, DCTL, bufou, blk, NULL) ! = EOK)

exit("DEVCTL error");

tim[i] = ClockCycles() - tim[i];

}

outtim();

close(fd);

delete [] bufin;

delete [] bufou;

delete [] tim;

return EXIT_SUCCESS;

}

Смотрим локальные результаты исполнения и оценки, которые дает нам эта клиентская программа (знаком отмечено С.К.О. предшествующего ему в выводе значения измеренной средней величины, после чего в скобках — процентное отношение этого С.К.О. к измеряемой величине):

# nice -n-19 cli -b1 -m1000

SRR client: vers. 1.03

server path: /dev/srr, block size = 1 bytes, repeat = 1000

CPU speed [c.p.s.]: client = 534639500, server = 534639500

- message exchange: 2693 ~168 {6%}

- manager exchange: 6579 ~357 {5%}

# nice -n-19 cli -b10 -m1000

SRR client: vers. 1.03

server path: /dev/srr, block size = 10 bytes, repeat = 1000

CPU speed [c.p.s.]: client = 534639500, server = 534639500

- message exchange: 2726 ~258 {9%}

- manager exchange: 6725 ~378 {6%}

# nice -n-19 cli -b100 -m1000

SRR client: vers. 1.03

server path: /dev/srr, block size = 100 bytes, repeat = 1000

CPU speed [c.p.s.]: client = 534639500, server = 534639500

- message exchange: 3351 ~190 {6%}

- manager exchange: 7055 ~414 {6%}

# nice -n-19 cli -b1000 -m1000

SRR client: vers 1.03

server path: /dev/srr, block size = 1000 bytes, repeat = 1000

CPU speed [c.p.s.]: client = 534639500, server = 534639500

- message exchange: 3912 ~369 {9%}

- manager exchange: 8312 ~4024 {48%}

# nice -n-19 cli -b4000 -m1000

SRR client: vers 1.03

server path: /dev/srr, block size = 4000 bytes, repeat = 1000

CPU speed [c.p.s.] client = 534639500, server = 534639500

- message exchange: 5393 ~518 {10%}

- manager exchange: 10666 ~770 {7%}

# nice -n-19 cli -b6000 -m1000

SRR client vers 1.03

server path /dev/srr, block size = 6000 bytes, repeat = 1000

CPU speed [c.p.s.]: client = 534639500, server = 534639500

- message exchange: 7373 ~612 {8%}

- manager exchange: 12423 ~995 {8%}