Основы применения операционной системы реального времени QNX

Процессы и потоки

На самом высоком уровне абстракции система состоит из множества процессов. Каждый процесс ответственен за обеспечение служебных функций определенного характера, независимо от того, является ли он элементом файловой системы, драйвером дисплея, модулем сбора данных, модулем управления или чем-либо еще.

В пределах каждого процесса может быть множество потоков. Число потоков варьируется. Один разработчик ПО, используя только единственный поток, может реализовать те же самые функциональные возможности, что и другой, использующий пять потоков. Некоторые задачи сами по себе приводят к многопоточности и дают относительно простые решения, другие в силу своей природы, являются однопоточными, и свести их к многопоточной реализации достаточно трудно.

Почему процессы?

# gcc pthread.c

# `pwd`a.out

Prog threads PID 852000

Eto pervii potok, TID 0 - N povtora 0

Eto vtoroi potok, TID 0 - N povtora 0

Eto vtoroi potok, TID 3 - N povtora 1

Eto pervii potok, TID 2 - N povtora 1

Eto vtoroi potok, TID 3 - N povtora 2

Eto vtoroi potok, TID 3 - N povtora 3

Eto pervii potok, TID 2 - N povtora 2

Eto vtoroi potok, TID 3 - N povtora 4

Eto pervii potok, TID 2 - N povtora 3

Eto pervii potok, TID 2 - N povtora 4

#

2.3 Лабораторная работа №3 «Обмен сообщениями»

Клиент, который желает послать запрос серверу, блокируется до тех пор, пока сервер не завершит обработку запроса. Затем, после завершения сервером обработки, запроса клиент разблокируется, чтобы принять «ответ».

Это подразумевает обеспечение двух условий: клиент должен «уметь» сначала установить соединение с сервером, а потом обмениваться с ним данными с помощью сообщений -- как в одну сторону (запрос -- «send»), так и в другую (ответ -- «reply»).

Установление соединения

Первое, что должны сделать клиент -- это установить соединение с помощью функции ConnectAttach(), описанной следующим образом:

#include <sys/neutrino.h>

int ConnectAttach

(int nd,pid_t pid, int chid, unsigned index, int flags);

Функции ConnectAttach() передаются три идентификатора;

· nd-- дескриптор узла (Node Descriptor),

· pid-- идентификатор процесса (process ID)

· chid -- идентификатор канала (channel ID).

Вместе эти три идентификатора, которые обычно записываются в виде «ND/PID/CHID», однозначно идентифицируют сервер, с которым клиент желает соединиться. Аргументы index и flags мы здесь просто проигнорируем (установим их в ноль).

Итак, предположим, что мы хотим подсоединиться к процессу, находящемуся на нашем узле и имеющему идентификатор 77, по каналу с идентификатором 1. Ниже приведен пример программы для выполнения этого:

int coid;

coid = ConnectAttach (0, 77, 1, 0, 0);

Можно видеть, что присвоением идентификатору узла (nd) нулевого значения мы сообщаем ядру о том, что мы желаем установить соединение на локальном узле.

Соединиться надо с процессом 77 и по каналу 1.

С этого момента есть идентификатор соединения -- небольшое целое число, которое однозначно идентифицирует соединение моего клиента с конкретным сервером по заданному каналу.

Теперь можно применять этот идентификатор для отправки запросов серверу сколько угодно раз. Выполнив все, для чего предназначалось соединение, его можно уничтожить с помощью функции:

ConnectDetach (coid);

Передача сообщений (sending)

Передача сообщения со стороны клиента осуществляется применением функции MsgSend(). Мы рассмотрим это на примере:

#include <sys/neutrino.h>

int MsgSend (int coid,

const void *smsg, int sbytes, void *rmsg, int rbytes);

Аргументами функции MsgSend() являются:

· идентификатор соединения с целевым сервером (coid);

· указатель на передаваемое сообщение (smsg);

· размер передаваемого сообщения (sbytes);

· указатель на буфер для ответного сообщения (rmsg);

· размер ответного сообщения (rbytes).

Передадим сообщение процессу с идентификатором 77 по каналу 1:

#include <sys/neutrino.h>

char *smsg = «Это буфер вывода»; char rmsg [200]; int coid;

// Установить соединение

coid = ConnectAttach (0, 77, 1, 0, 0);

if (coid == -1) {

fprintf (stderr, «Ошибка ConnectAttach к 0/77/1!\n»);

perror (NULL);

exit (EXIT_FAILURE);

// Послать сообщение

if(MsgSend(coid, smsg,strlen (smsg) + 1,rmsg,sizeof(rmsg)) == -1)

{ fprintf (stderr, «Ошибка MsgSendXn»);

perror (NULL);

exit (EXIT_FAILURE);

if (strlen (rmsg) > 0)

{

printf («Процесс с ID 77 возвратил \«%s\»\n», rmsg);

}

Предположим, что процесс с идентификатором 77 был действительно активным сервером, ожидающим сообщение именно такого формата по каналу с идентификатором 1. После приема сообщения сервер обрабатывает его и в некоторый момент времени выдает ответ с результатами обработки. В этот момент функция MsgSend() должна возвратить ноль (0), указывая этим, что все прошло успешно. Если бы сервер послал нам в ответ какие-то данные, мы смогли бы вывести их на экран с помощью последней строки в программе. программа драйвер сервер

Сервер. Создание канала

Сервер должен создать канал -- то, к чему присоединялся клиент, когда вызывал функцию ConnectAttach(). Обычно сервер, однажды создав канал, приберегает его «впрок». Канал создается с помощью функции ChannelCreate() и уничтожается с помощью функции ChannelDestroy():

#include <sys/neutrino.h>

int ChannelCreate (unsigned flags);

int ChannelDestroy (int chid);

Таким образом, для создания канала сервер должен сделать так:

int chid;

chid = ChannelCreate (0);

Теперь у нас есть канал. В этом пункте клиенты могут подсоединиться (с помощью функции ConnectAttach()) к этому каналу и начать передачу сообщений:

Рис. 3 Связь между каналом сервера и клиентским соединением

Обработка сообщений

В терминах обмена сообщениями, сервер отрабатывает схему обмена в два этапа:

· этап «приема» (receive);

· этап «ответа» (reply).

Рис.4 Взаимосвязь функций клиента и сервера при обмене сообщениями

Обсудим два простейших варианта соответствующих функций, MsgReceive() и MsgReply().

#include <sys/neutrino.h>

int MsgReceive (int chid,void *rmsg, int rbytes, struct _msg_info *info);

int MsgReply (int rcvid, int status, const void *msg, int nbytes);

Четыре основных элемента:

1 Клиент вызывает функцию MsgSend() и указывает ей на буфер передачи (указателем smsg и длиной sbytes). Данные передаются в буфер функции MsgReceive() на стороне сервера, по адресу rmsg и длиной rbytes. Клиент блокируется.

2 Функция MsgReceive() сервера разблокируется и возвращает идентификатор отправителя rcvid, который будет впоследствии использован для ответа. Теперь сервер может использовать полученные от клиента данные.

3 Сервер завершил обработку сообщения и теперь использует идентификатор отправителя rcvid, полученный от функции MsgReceive(), передавая его функции MsgReply(). Заметьте, что местоположение данных для передачи функции MsgReply() задается как указатель на буфер (smsg) определенного размера (sbytes). Ядро передает данные клиенту.

4 Наконец, ядро передает параметр sts, который используется функцией MsgSend() клиента как возвращаемое значение. После этого клиент разблокируется.

Для каждой буферной передачи указываются два размера (в случае запроса от клиента это sbytes на стороне клиента и rbytes на стороне сервера; в случае ответа сервера это sbytes на стороне сервера и rbytes на стороне клиента). Это сделано для того, чтобы разработчики каждого компонента смогли определить размеры своих буферов -- из соображений дополнительной безопасности.

2.3.2 Текст программы

// server.c

#include <stdio.h>

#include <pthread.h>

#include <inttypes.h>

#include <errno.h>

#include <sys/neutrino.h>

void server(void)

{

int rcvid; //Ykazivaet komy nado otvechat

int chid; //Identifikator kanala

char message[512]; //

printf("Server start working \n");

chid=ChannelCreate(0); //Sozdanie Kanala

printf("Chanel id: %d \n", chid);

printf("Pid: %d \n", getpid());

// vipolniaetsa vechno- dlia servera eto normalno

while(1)

{

// Polychit i vivesti soobshenie

rcvid=MsgReceive(chid,message,sizeof(message), NULL);

printf("Polychili soobshenie, rcvid %X \n",rcvid );

printf("Soobshenie takoe: \"%s\". \n", message );

// Podgotovit otvet

strcpy(message,"Eto otvet");

MsgReply(rcvid, EOK, message, sizeof(message));

printf("\"%s\". \n", message );

}

}

int main(void)

{

printf("Prog server \n");

server();

sleep(5);

return(1);

}

//client.c

#include <stdio.h>

#include <pthread.h>

#include <inttypes.h>

#include <errno.h>

#include <sys/neutrino.h>

int main(void)

{

char smsg[20];

char rmsg[200];

int coid;

long serv_pid;

printf("Prog client, Vvedite PID servera \n");

scanf ("%ld",&serv_pid);

printf("Vveli %ld \n", serv_pid);

coid=ConnectAttach(0,serv_pid,1,0,0);

printf("Connect res %d \n, vvedite soobshenie ", coid);

scanf("%s",&smsg);

printf("Vveli %s \n", smsg);

if(MsgSend(coid,smsg,strlen(smsg)+1,rmsg, sizeof(rmsg))==-1)

{

printf("Error MsgSend \n");

}

return(1);

}

2.3.3 Последовательность действий

После компиляции программ сервера и клиента у нас будет 2 исполняемых файла. Назовём их server и client соответственно.

Программу server необходимо запустить в фоновом режиме # server &. Она начнёт работать: создаст канал, выведет номер канала и идентификатор процесса сервера, будет ждать сообщения от клиента.

Потом необходимо запустить клиента. Он попросит ввести идентификатор процесса сервера, для установления соединения с ним, и само сообщение (20 символов). Далее можно наблюдать, как сервер получит сообщение, выведет его и пошлёт ответ.

На этом клиент закончит свою работу, но его можно запустить ещё раз и послать другое сообщение.

Остановить работу сервера можно функцией kill < идентификатор процесса сервера >.

2.3.4 Результаты

# `pwd`/server &

[3] 2019364

# Prog server

Server start working

Chanel id: 1

Pid: 2019364

# `pwd`/client

Prog client, Vvedite PID servera

2019364

Vveli 2019364

Connect res 3

, vvedite soobshenie Hello_server

Vveli Hello_server

Polychili soobshenie, rcvid 2

Soobshenie takoe: "Hello_server".

"Eto otvet".

# `pwd`/client

Prog client, Vvedite PID servera

2019364

Vveli 2019364

Connect res 3

, vvedite soobshenie I_snova_Privet

Vveli I_snova_Privet

Polychili soobshenie, rcvid 2

Soobshenie takoe: "I_snova_Privet".

"Eto otvet".

# kill 2019364

#

2.4 Лабораторная работа №4 «Тайм-ауты»

Все становятся несколько сложнее, когда вы используете тайм-ауты ядра при обмене сообщениями. На момент отправки клиентом сообщения сервер может как ожидать его, так и нет. Это означает, что клиент может заблокироваться как по передаче (если сервер еще не принял сообщение), так и по ответу (если сервер принял сообщение, но еще не ответил). Основной смысл здесь в том, что вы должны предусмотреть оба блокирующих состояния в параметре flags функции TimerTimeout(), потому что клиент может оказаться в любом из них.

Чтобы задать несколько состояний, сложите их операцией ИЛИ (OR): TimerTimeout(_NTO_TIMEOUT_SEND | _NTO_TIMEOUT_REPLY).

Это вызовет тайм-аут всякий раз, когда ядро переведет клиента в состояние блокировки по передаче (SEND) или по ответу (REPLY). В тайм-ауте SEND-блокировки нет ничего особенного -- сервер еще не принял сообщение, значит, ничего для этого клиента он не делает. Это значит, что если ядро генерирует тайм-аут для SEND-блокированного клиента, сервер об этом информировать не обязательно. Функция MsgSend() клиента возвратит признак ETIMEDOUT и обработка тайм-аута завершится.

Однако, если сервер уже принял сообщение клиента и клиент желает разблокироваться, для сервера существует два варианта реакции. Если сервер не указал флаг _NTO_CHF_UNBLOCK на канале, по которому было принято сообщение, клиент будет разблокирован немедленно, и сервер не получит об этом никакого оповещения. У большинства серверов, флаг _NTO_CHF_UNBLIOCK всегда установлен. В этом случае ядро посылает серверу импульс, а клиент остается заблокированным до тех пор, пока сервер ему не ответит! Это сделано для того, чтобы сервер мог узнать о запросе клиента на разблокирование и выполнить по этому поводу какие-то действия.

2.4.2 Текст программы