Средства межпроцессного взаимодействия в реальном времени

#include <semaphore.h>

sem_t *sem_open (const char *name, int oflag, ...);

int sem_init (sem_t *sem, int pshared, unsigned value);

#include <semaphore.h>

int sem_close (sem_t *sem);

int sem_unlink (const char *name);

int sem_destroy (sem_t *sem);

#include <semaphore.h>

int sem_wait (sem_t *sem);

int sem_trywait (sem_t *sem);

#include <semaphore.h>
#include <time.h>
int sem_timedwait (sem_t *restrict sem, 
	const struct timespec *restrict abstime);

#include <semaphore.h>
int sem_post (sem_t *sem);

#include <semaphore.h>
int sem_getvalue (sem_t *restrict sem, int *restrict sval);

/* * * * * * * * * * * * * * * * * * * * * * * * * * */
/* Программа реализует взаимодействие                */
/* поставщик/потребитель (писатель/читатель).        */
/* Поставщик генерирует случайные целые числа и помещает их буфер */
/* на один элемент, потребитель извлекает их оттуда и суммирует. */
/* Для синхронизации используются неименованные семафоры*/
/* * * * * * * * * * * * * * * * * * * * * * * * * * */

#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <semaphore.h>
#include <pthread.h>
#include <errno.h>
/* Буфер для хранения генерируемых данных */
static int my_buf;

/* Семафор, разрешающий записывать в буфер новые данные */
static sem_t w_sem;

/* Семафор, разрешающий читать данные из буфера */
static sem_t r_sem;

/* Общий результат суммирования */
static int sum = 0;

/* * * * * * * * * * * * * * * * * * * * * * * */
/* Стартовая функция потока, генерирующего числа */
/* * * * * * * * * * * * * * * * * * * * * * * */
void *start_writer (void *dummy) {
	while (sem_wait (&w_sem) == 0) {
		my_buf = rand ();
		if (sem_post (&r_sem) != 0) {
			perror ("SEM_POST-R");
			return (NULL);
		}
	}

	return (NULL);
}

/* * * * * * * * * * * * * * * * * * * * * * * * * * */
/* Стартовая функция потока, читающего и суммирующего числа */
/* * * * * * * * * * * * * * * * * * * * * * * * * * */
void *start_reader (void *dummy) {
	while (sem_wait (&r_sem) == 0) {
		sum += my_buf;
		if (sem_post (&w_sem) != 0) {
			perror ("SEM_POST-W");
			return (NULL);
		}
	}

	return (NULL);
}
/* * * * * * * * * * * * * * * * * * * * * * * */
/* Инициализация семафоров,                    */
/* создание и терминирование потоков управления*/
/* * * * * * * * * * * * * * * * * * * * * * * */
int main (void) {
	pthread_t w_ptid;/* Идентификатор потока-писателя */
	pthread_t r_ptid;/* Идентификатор потока-читателя */

	/* Инициализируем семафоры.      */
	/* Семафор записи будет свободен,*/
	/* семафор чтения - захвачен     */
	if (sem_init (&w_sem, 0, 1) == -1) {
		perror ("SEM_INIT-W");
		return (-1);
	}
	if (sem_init (&r_sem, 0, 0) == -1) {
		perror ("SEM_INIT-R");
		return (-1);
	}

	/* Создадим потоки управления - писателя и читателя */
	if ((errno = pthread_create (&w_ptid, NULL, 
			start_writer, NULL)) != 0) {
		perror ("PTHREAD_CREATE-W");
		return (errno);
	}
	if ((errno = pthread_create (&r_ptid, NULL, 
			start_reader, NULL)) != 0) {
		perror ("PTHREAD_CREATE-R");
		return (errno);
	}

	/* Дадим потокам повыполняться */
	sleep (10);

	/* Терминируем потоки */
	(void) pthread_cancel (w_ptid);
	(void) pthread_cancel (r_ptid);

	/* Дождемся завершения потоков */
	(void) pthread_join (w_ptid, NULL);
	(void) pthread_join (r_ptid, NULL);
	/* Ликвидируем семафоры */
	if (sem_destroy (&w_sem) != 0) {
		perror ("SEM_DESTROY-W");
		return (-1);
	}
	if (sem_destroy (&r_sem) != 0) {
		perror ("SEM_DESTROY-R");
		return (-1);
	}

	printf ("Сумма сгенерированных чисел: %d\n", sum);

	return 0;
}

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

#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <semaphore.h>
#include <pthread.h>
#include <errno.h>

/* Буфер для хранения генерируемых данных */
static int my_buf [BUFSIZ];

/* Индекс, по которому можно записать очередной элемент */
static int w_ind = 0;

/* Индекс, по которому можно прочитать очередной элемент */
static int r_ind = 0;

/* Семафор, разрешающий записывать в буфер новые данные */
static sem_t w_sem;

/* Семафор, разрешающий читать данные из буфера */
static sem_t r_sem;

/* Общий результат суммирования */
static int sum = 0;


/* * * * * * * * * * * * * * * * * * * * * * * */
/* Стартовая функция потока, генерирующего числа*/
/* * * * * * * * * * * * * * * * * * * * * * * */
void *start_writer (void *dummy) {
	while (sem_wait (&w_sem) == 0) {
		my_buf [w_ind] = rand ();
		w_ind = (w_ind + 1) % BUFSIZ;
		if (sem_post (&r_sem) != 0) {
			perror ("SEM_POST-R");
			return (NULL);
		}
	}

	return (NULL);
}

/* * * * * * * * * * * * * * * */
/* Стартовая функция потока,   */
/* читающего и суммирующего числа*/
/* * * * * * * * * * * * * * * */
void *start_reader (void *dummy) {
	while (sem_wait (&r_sem) == 0) {
		sum += my_buf [r_ind];
		r_ind = (r_ind + 1) % BUFSIZ;
		if (sem_post (&w_sem) != 0) {
			perror ("SEM_POST-W");
			return (NULL);
		}
	}

	return (NULL);
}

/* * * * * * * * * * * * * * * * * * * * * * * */
/* Инициализация семафоров,                    */
/* создание и терминирование потоков управления*/
/* * * * * * * * * * * * * * * * * * * * * * * */
int main (void) {
	pthread_t w_ptid;/* Идентификатор потока-писателя */
	pthread_t r_ptid;/* Идентификатор потока-читателя */


	/* Инициализируем семафоры.      */
	/* Семафор записи будет свободен,*/
	/* разрешая заполнить весь буфер,*/
	/* семафор чтения - захвачен     */
	if (sem_init (&w_sem, 0, BUFSIZ) == -1) {
		perror ("SEM_INIT-W");
		return (-1);
	}
	if (sem_init (&r_sem, 0, 0) == -1) {
		perror ("SEM_INIT-R");
		return (-1);
	}

	/* Создадим потоки управления - писателя и читателя */
	if ((errno = pthread_create (&w_ptid, NULL, 
			start_writer, NULL)) != 0) {
		perror ("PTHREAD_CREATE-W");
		return (errno);
	}
	if ((errno = pthread_create (&r_ptid, NULL, 
			start_reader, NULL)) != 0) {
		perror ("PTHREAD_CREATE-R");
		return (errno);
	}

	/* Дадим потокам повыполняться */
	sleep (10);

	/* Терминируем потоки */
	(void) pthread_cancel (w_ptid);
	(void) pthread_cancel (r_ptid);

	/* Дождемся завершения потоков */
	(void) pthread_join (w_ptid, NULL);
	(void) pthread_join (r_ptid, NULL);

	/* Ликвидируем семафоры */
	if (sem_destroy (&w_sem) != 0) {
		perror ("SEM_DESTROY-W");
		return (-1);
	}

	if (sem_destroy (&r_sem) != 0) {
		perror ("SEM_DESTROY-R");
		return (-1);
	}

	printf ("Сумма сгенерированных чисел: %d\n", sum);

	return 0;
}

/*
Обедающие философы. Многопотоковая реализация с помощью семафоров. Запуск:
	mudrecSem [-a | -p | -I] [-t число_секунд] имя_философа ...

Опции:
	-t число_секунд - сколько секунд моделируется

	Стратегии захвата вилок:
	-a - сначала захватывается вилка с меньшим номером;
	-p - сначала захватывается нечетная вилка;
	-I - некорректная (но эффективная) интеллигентная 
		стратегия: во время ожидания уже захваченная 
		вилка кладется.

Пример запуска:
	mudrecSem -p -t 300   A B C D E F G H I J K L M N\  
		O P Q R S T U V W X Y Z
*/

static char rcsid[] __attribute__((unused)) = \
	"$Id: mudrecSem.c,v 1.2 2004/03/18 10:28:38 sambor Exp $";

#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <pthread.h>
#include <semaphore.h>
#include <signal.h>
#include <string.h>
#include <fcntl.h>
#include <limits.h>
#include <errno.h>

#define max(a,b) ((a)>(b)?(a):(b))
#define min(a,b) ((a)>(b)?(b):(a))

struct mudrec {
	char *name;
	int left_fork, right_fork;
	int eat_time, wait_time, think_time, max_wait_time;
	int count;
	pthread_t thread;
	int private_pFdIn;
} *kafedra;

/* Глобальные счетчики и логические переменные */
int Stop = 0; /* Признак конца обеда */

/* Различные дескрипторы */
int protokol [2] = {-1, -1};
#define pFdIn (protokol [1])
#define pFdOut (protokol [0])

/* Массив семафоров для синхронизации доступа к вилкам */
sem_t *semFork;

/* Разные алгоритмы захвата вилок */
static void get_forks_simple (struct mudrec *this);
static void get_forks_odd (struct mudrec *this);
static void get_forks_maybe_infinit_time (struct mudrec *this);

/* Используемый метод захвата вилок */
void (*get_forks) (struct mudrec *this) = get_forks_simple;

/* Возвращение вилок */
static void put_forks (struct mudrec *this);

/*
 * Потоки-философы
 */
void *filosof (void *arg) {
	struct mudrec *this = arg;
	char buffer [LINE_MAX];
	int bytes;
	int private_pFdIn = this->private_pFdIn;

	while (!Stop) {
		/* Пора подкрепиться */
		{
			int wait_time, tm = time (NULL);

			sprintf (buffer, "%s: хочет есть\n", this->name);
			bytes = write (private_pFdIn, buffer, 
			strlen (buffer));

			(*get_forks) (this);

			wait_time = time (NULL) - tm;
			this->wait_time += wait_time;
			this->max_wait_time = max (wait_time, 
			this->max_wait_time);

			sprintf (buffer,"%s: ждал вилок %d сек\n", 
				this->name, wait_time);
			bytes = write (private_pFdIn, buffer, 
				strlen (buffer));
		}

		/* Может, обед уже закончился? */
		if (Stop) {
			put_forks (this);
			break;
		}

		/* Ест */
		{
			int eat_time = rand () % 20 + 1;

			sleep (eat_time);

			this->eat_time += eat_time;
			this->count++;
			sprintf (buffer,"%s: ел %d сек\n", this->name, 
						eat_time);
			bytes = write (private_pFdIn, buffer, 
									strlen (buffer));
		}

		/* Отдает вилки */
		put_forks (this);

		if (Stop) break;

		/* Размышляет */
		{
			int think_time = rand () % 10 + 1;

			sleep (think_time);
			this->think_time += think_time;
		}
	} /* while (!Stop) */

	sprintf (buffer,"%s: уходит\n", this->name);
	bytes = write (private_pFdIn, buffer, strlen (buffer));

	close (private_pFdIn);

	return (NULL);
} /* Поток-философ */

/* Кладет вилки одну за другой */
static void put_forks (struct mudrec *this) {
	sem_post (&semFork [this->left_fork - 1]);
	sem_post (&semFork [this->right_fork - 1]);
}

/* Берет вилки по очереди в порядке номеров */
static void get_forks_simple (struct mudrec *this) {
	int first = min (this->left_fork, this->right_fork);
	int last = max (this->left_fork, this->right_fork);

	sem_wait (&semFork [first - 1]);
	sem_wait (&semFork [last - 1]);
}

/* Берем сначала нечетную вилку 	*/
/* (если обе нечетные - то с большим номером) */
static void get_forks_odd (struct mudrec *this) {
	int left = this->left_fork, right = this->right_fork;

	int first;
	int last;

	if ((left & 1) > (right & 1)) {
		first = left;
		last  = right;
	} else if ((left & 1) < (right & 1)) {
		first = right;
		last  = left;
	} else {
		first = max (left, right);
		last  = min (left, right);
	}

	sem_wait (&semFork [first - 1]);
	sem_wait (&semFork [last - 1]);
}

/* Берем вилки по очереди, в произвольном порядке.
 * Но если вторая вилка не берется сразу, то кладем первую.
 * То есть философ не расходует вилочное время впустую.
 */
static void get_forks_maybe_infinit_time 
		(struct mudrec *this) {
	int left = this->left_fork, right = this->right_fork;

	for (;;) {
		sem_wait (&semFork [left - 1]);
		if (0 == sem_trywait (&semFork [right - 1])) return;
		sem_post (&semFork [left - 1]);
		sem_wait (&semFork [right - 1]);
		if (0 == sem_trywait (&semFork [left - 1])) return;
		sem_post (&semFork [right - 1]);
	}
}

/* Мелкие служебные функции */
static void stop (int dummy) {
	Stop = 1;
}

static void usage (char name []) {
	fprintf (stderr, 
		"Использование: %s [-a | -p | -I] [-t число_секунд] "
		"имя_философа ...\n",  name);
	exit (1);
}

/* Точка входа демонстрационной программы */
int main (int argc, char *argv []) {
	char buffer [LINE_MAX], *p;
	int i, n, c;
	int open_room_time = 300;
	int nMudr;
	struct sigaction sact;

	while ((c = getopt (argc, argv, "apIt:")) != -1) {
		switch (c) {
			case 'a': get_forks = get_forks_simple; break;
			case 'p': get_forks = get_forks_odd; break;
			case 'I': get_forks = get_forks_maybe_infinit_time; 
				break;
			case 't': open_room_time = strtol (optarg, &p, 0);
				if (optarg [0] == 0 || *p != 0) usage (argv [0]);
				break;
			default : usage (argv [0]);
		}
	}

	nMudr = argc - optind;
	if (nMudr < 2) usage (argv [0]); /* Меньше двух 	*/
	/* философов неинтересно ... */

	/* Создание канала для протокола обработки событий */
	pipe (protokol);

	kafedra = calloc (sizeof (struct mudrec), nMudr);

	/* Зачисление на кафедру */
	for (i = 0; i < nMudr; i++, optind++) {
		kafedra [i].name = argv [optind];
		/* Выдадим телефон */
		kafedra [i].private_pFdIn = fcntl (pFdIn, F_DUPFD, 0);
		/* Укажем новичку, какими вилками пользоваться */
		kafedra [i].left_fork = i + 1;
		kafedra [i].right_fork = i + 2;
	}
	kafedra [nMudr - 1].right_fork = 1; /* Последний*/
	/* пользуется вилкой первого */

	/* Зададим реакцию на сигналы и установим будильник */
	/* на конец обеда */
	sact.sa_handler = stop;
	(void) sigemptyset (&sact.sa_mask);
	sact.sa_flags = 0;
	(void) sigaction (SIGINT, &sact, (
		struct sigaction *) NULL);
	(void) sigaction (SIGALRM, &sact, 
		(struct sigaction *) NULL);
	alarm (open_room_time);

	/* Создадим семафоры для охраны вилок */
	semFork = calloc (sizeof (sem_t), nMudr);
	for (i = 0; i < nMudr; i++) {
		sem_init (&semFork [i], 0, 1 /* На каждое место */
		/* по одной вилке */);
	}

	/* Философы входят в столовую */
	for (i = 0; i < nMudr; i++)
		pthread_create (&kafedra [i].thread, NULL, &filosof, 
			(void *) &kafedra [i]);

	/* Выдача сообщений на стандартный вывод и выход */
	/* после окончания всех задач */
	close (pFdIn);
	while (1) {
		n = read (pFdOut, buffer, LINE_MAX);
		if (n == 0 || (n < 0 && errno != EINTR)) break;
		for (i = 0; i < n; i++) putchar (buffer [i]);
	}
	close (pFdOut);

	/* Уничтожение семафоров */
	for (i = 0; i < nMudr; i++) {
		sem_destroy (&semFork [i]);
	}

	/* Выдача сводной информации */
	{
		int full_eating_time = 0;
		int full_waiting_time = 0;
		int full_thinking_time = 0;
		for (i = 1; i <= nMudr; i++) {
			struct mudrec *this = &kafedra [i - 1];

			full_eating_time += this->eat_time;
			full_waiting_time += this->wait_time;
			full_thinking_time += this->think_time;

			if (this->count > 0) {
			float count = this->count;
			float think_time = this->think_time / count;
			float eat_time = this->eat_time / count;
			float wait_time = this->wait_time / count;

			printf ("%s: ел %d раз в среднем: думал=%.1f "
				"ел=%.1f ждал=%.1f (максимум %d)\n", 
				this->name, this->count, think_time, 
				eat_time, wait_time, this->max_wait_time);
			} else
			printf ("%s: не поел\n", this->name);
		} /* for */

		{
			float total_time = (full_eating_time + 
				full_waiting_time + full_thinking_time) / 
				(float) nMudr;

			printf("Среднее число одновременно едящих = %.3f\n",
				full_eating_time / total_time);
			printf("Среднее число одновременно ждущих = %.3f\n",
				full_waiting_time / total_time);
		}
	} /* Выдача сводной информации */

	free (semFork);
	free (kafedra);

	/* Сообщим об окончании работы. */
	printf ("Конец обеда\n");

	return 0;
}