взяв за основу программу: #include <sys/types.h> #include <unistd.h> #include <stdio.h>…
- User
взяв за основу программу:
#include <sys/types.h> #include <unistd.h> #include <stdio.h> #include <stdlib.h>
int main() { int fd[2], result;
size_t size; char resstring[14];
if (pipe(fd) < 0) { printf("Can't open pipe\n"); exit(-1); }
result = fork();
if (result < 0) { printf("Can't fork child\n"); exit(-1); } else if (result > 0) {
/* Parent process */
if (close(fd[0]) < 0) { printf("parent: Can\'t close reading side of pipe\n"); exit(-1); } size = write(fd[1], "Hello, world!", 14); if (size != 14) { printf("Can\'t write all string to pipe\n"); exit(-1); } if (close(fd[1]) < 0) { printf("parent: Can\'t close writing side of pipe\n"); exit(-1); } printf("Parent exit\n");} else {
/* Child process */ if (close(fd[1]) < 0) { printf("child: Can\'t close writing side of pipe\n"); exit(-1); } size = read(fd[0], resstring, 14); if (size < 0) { printf("Can\'t read string from pipe\n"); exit(-1); } printf("Child exit, resstring:%s\n", resstring); if (close(fd[0]) < 0) { printf("child: Can\'t close reading side of pipe\n"); exit(-1); }}
return 0; }
реализуйте поочередную неоднократную передачу информации между ребёнком и родителем через один pipe в двух направлениях, используя ровно один IPC семафор. Считать, что сначала родитель передает данные ребёнку, а затем получает данные от него. Количество пар передача и приём данных в родителе и пар приём и передача в ребёнке равно N ≥ 2. Значение N вводится в родителе с клавиатуры до порождения ребёнка. Число N потенциально может быть достаточно большим и превышать максимально возможное значение семафора, поэтому использовать значение N в операциях над семафором не разрешается.
- Assistant
Для реализации поочередной многократной передачи информации между родителем и ребёнком через один pipe с использованием ровно одного IPC семафора, можно воспользоваться следующей стратегией:
-
Pipe для двунаправленной связи: Хотя стандартные pipe являются односторонними, мы можем использовать их для двунаправленной связи, тщательно синхронизируя операции чтения и записи, чтобы избежать конфликтов. Это достигается с помощью использования семафора для координации очередности действий.
-
Семафор для синхронизации: Используем один семафор для управления очередностью доступа к pipe. Семфор будет работать как сигнализация о том, что одна сторона завершила свою операцию и другая сторона может начать.
-
Алгоритм взаимодействия:
- Родитель начинает передачу, записывая данные в pipe и сигнализируя семафор.
- Ребёнок, ожидая сигнала семафора, читает данные из pipe, обрабатывает их и записывает ответ обратно в pipe, затем снова сигнализирует семафор.
- Родитель ожидает второй сигнал семафора, читает ответ и повторяет цикл N раз.
Ниже приведён полный пример реализации на языке C с использованием System V семафоров:
#include <sys/types.h> #include <unistd.h> #include <stdio.h> #include <stdlib.h> #include <sys/sem.h> #include <sys/ipc.h> #include <string.h> #include <errno.h> // Определение структуры для операций с семафором union semun { int val; struct semid_ds *buf; unsigned short *array; #if defined(__linux__) // Для Linux работает больше struct seminfo *__buf; #endif }; // Функция для инициализации семафора int init_semaphore(key_t key, int initial_val) { int semid; union semun sem_union; // Создаём семафор semid = semget(key, 1, IPC_CREAT | 0666); if (semid == -1) { perror("semget"); exit(EXIT_FAILURE); } // Устанавливаем начальное значение семафора sem_union.val = initial_val; if (semctl(semid, 0, SETVAL, sem_union) == -1) { perror("semctl SETVAL"); exit(EXIT_FAILURE); } return semid; } // Функция для выполнения операции WAIT (P) void semaphore_wait(int semid) { struct sembuf sop; sop.sem_num = 0; sop.sem_op = -1; // Decrement sop.sem_flg = 0; if (semop(semid, &sop, 1) == -1) { perror("semop WAIT"); exit(EXIT_FAILURE); } } // Функция для выполнения операции SIGNAL (V) void semaphore_signal(int semid) { struct sembuf sop; sop.sem_num = 0; sop.sem_op = 1; // Increment sop.sem_flg = 0; if (semop(semid, &sop, 1) == -1) { perror("semop SIGNAL"); exit(EXIT_FAILURE); } } int main() { int fd[2], result; size_t size; char resstring[100]; int N; // Читаем N из ввода printf("Enter N (number of iterations >=2): "); if (scanf("%d", &N) != 1 || N < 2) { fprintf(stderr, "Invalid N. Must be integer >= 2.\n"); exit(EXIT_FAILURE); } // Создаём pipe if (pipe(fd) < 0) { perror("Can't open pipe"); exit(EXIT_FAILURE); } // Инициализируем семафор с ключом IPC_PRIVATE // Семафор будет использоваться для синхронизации key_t sem_key = IPC_PRIVATE; int semid = init_semaphore(sem_key, 0); // Изначально семафор = 0 result = fork(); if (result < 0) { perror("Can't fork child"); exit(EXIT_FAILURE); } else if (result > 0) { // Родительский процесс // Закрываем конец для чтения if (close(fd[0]) < 0) { perror("parent: Can't close reading side of pipe"); exit(EXIT_FAILURE); } for(int i = 0; i < N; i++) { // Формируем сообщение char parent_msg[100]; snprintf(parent_msg, sizeof(parent_msg), "Message %d from parent", i+1); // Записываем в pipe size = write(fd[1], parent_msg, strlen(parent_msg) + 1); // +1 для NULL-терминатора if (size < 0) { perror("parent: Can't write to pipe"); exit(EXIT_FAILURE); } printf("Parent sent: %s\n", parent_msg); // Сигнализируем семафор, что сообщение отправлено semaphore_signal(semid); // Ожидаем ответа от ребёнка semaphore_wait(semid); // Читаем ответ из pipe size = read(fd[1], resstring, sizeof(resstring)); if (size < 0) { perror("parent: Can't read from pipe"); exit(EXIT_FAILURE); } printf("Parent received: %s\n", resstring); } // Закрываем конец для записи if (close(fd[1]) < 0) { perror("parent: Can't close writing side of pipe"); exit(-1); } // Удаляем семафор if (semctl(semid, 0, IPC_RMID) == -1) { perror("semctl IPC_RMID"); exit(EXIT_FAILURE); } printf("Parent exit\n"); } else { // Ребёнок // Закрываем конец для записи if (close(fd[1]) < 0) { perror("child: Can't close writing side of pipe"); exit(-1); } for(int i = 0; i < N; i++) { // Ожидаем, что родитель отправил сообщение semaphore_wait(semid); // Читаем сообщение от родителя size = read(fd[0], resstring, sizeof(resstring)); if (size < 0) { perror("child: Can't read from pipe"); exit(-1); } printf("Child received: %s\n", resstring); // Формируем ответное сообщение char child_msg[100]; snprintf(child_msg, sizeof(child_msg), "Reply %d from child", i+1); // Возвращаем ответ через pipe size = write(fd[0], child_msg, strlen(child_msg) + 1); // +1 для NULL-терминатора if (size < 0) { perror("child: Can't write to pipe"); exit(-1); } printf("Child sent: %s\n", child_msg); // Сигнализируем семафор, что ответ отправлен semaphore_signal(semid); } // Закрываем конец для чтения if (close(fd[0]) < 0) { perror("child: Can't close reading side of pipe"); exit(-1); } printf("Child exit\n"); } return 0; }Объяснение кода:
-
Инициализация семафора:
- Используем
semgetс ключомIPC_PRIVATEдля создания уникального семафора. - Устанавливаем начальное значение семафора в
0, чтобы ребёнок ожидал первого сообщения от родителя.
- Используем
-
Родительский процесс:
- Закрывает конец pipe для чтения (
fd[0]). - В цикле
Nраз:- Формирует и записывает сообщение в pipe.
- Сигнализирует семафор (
semaphore_signal), чтобы уведомить ребёнка о наличии данных. - Ожидает ответа от ребёнка (
semaphore_wait). - Читает ответ из pipe и выводит его.
- После цикла закрывает конец pipe для записи и удаляет семафор.
- Закрывает конец pipe для чтения (
-
Ребёнок:
- Закрывает конец pipe для записи (
fd[1]). - В цикле
Nраз:- Ожидает сигнал от родителя (
semaphore_wait). - Читает сообщение из pipe.
- Формирует ответ и записывает его обратно в pipe.
- Сигнализирует семафор (
semaphore_signal), чтобы уведомить родителя о наличии ответа.
- Ожидает сигнал от родителя (
- После цикла закрывает конец pipe для чтения.
- Закрывает конец pipe для записи (
Важные моменты:
-
Двунаправленная связь через один pipe: В этом примере осуществляется обмен данными по одному pipe, где обе стороны поочерёдно записывают и читают данные. Важно обеспечить строгую последовательность операций с помощью семафора, чтобы избежать конфликтов и перепутанных данных.
-
Использование семафора: Семaфор используется для управления очередностью: родитель начинает, затем ребёнок, и так далее. Это гарантирует, что только одна сторона в данный момент взаимодействует с pipe.
-
Избежание использования N в семафоре: Все операции над семафором ограничиваются единичным увеличением или уменьшением, независимо от значения N, что соответствует заданному ограничению.
Компиляция и запуск:
Сохраните код в файл, например,
parent_child_pipe_semaphore.c, и скомпилируйте его:gcc -o parent_child_pipe_semaphore parent_child_pipe_semaphore.cЗапустите программу:
./parent_child_pipe_semaphoreВ программе будет предложено ввести значение N (не менее 2), после чего начнётся цикл обмена сообщениями между родителем и ребёнком.
-