Question

10) Unlike a signal, which conveys only the occurrence of a particular event and contains no information content, a pipe can be thought of as a scratch file created by a system call. It can be used as a communications channel between concurrently running processes. The interface call to a pipe is similar to that for any file. In fact, the process reads and writes to a pipe just like any file. Unlike files, however, pipes do not represent actual devices or areas on disk. Instead, they are transient areas in memory. Just as a pipe is used by the shell to pass information on the command line, a program pipe is used to pass information from one process to another. A pipe's main advantage is that it can provide much higher bandwidths than if the processes read and write from a physically moving media (as would be the case with ordinary disk files).

Pipes have a finite capacity and relay their information on a first-in, first-out (FIFO) basis. The system blocks a process until the read/write can be satisfied. That is, if the reader gets ahead of the writer, the reader just waits for more data. If the writer gets too far ahead of the reader and manages to completely fill the pipe (the size of which is system dependent), it sleeps until the reader has a chance to catch up. Also, once information is read from the pipe, it is erased, thereby freeing up pipe space.

It should be noted that pipes do have some disadvantages. One of the more notable ones is the fact that the processes communicating over the pipe must be related, typically as a parent and child, or as two siblings. The reason for this is because one process has to tell the other what the file (pipe) descriptor is; however, the descriptor

is only valid in the context of a particular execution environment. Therefore, two unrelated processes generally cannot share a pipe. This can be a constraint for many applications where the potential reader and writer of the pipe originate from different, unrelated processes. On the other hand, if a pipe is established in a process before creating (forking) another process, the new process will inherit the pipe file descriptor thereby making it valid in both execution environments.

A sample initialization sequence for a pipe that will enable messages of 15 characters to be exchanged between processes is of the form:

#include <stdio.h>
#define MSGSIZE 16 /* This figure should include room for a terminating null */

int pfd[2], retval;
char msg [MSGSIZE], buffer[MSGSIZE];

retval = pipe(pfd);
write (pfd[1], msg, MSGSIZE); read (pfd[0], buffer, MSGSIZE);

The call creates a pipe represented by two file descriptors that are returned in the pfd array. Writing to pfd[1] puts data in the pipe; reading from pfd[0] gets data out.

a) Write a single program which will create a pipe, write at least four messages down it, and then read them back. Although this particular exercise does not demonstrate IPC (since there is only one process), it demonstrates how pipes can be used as a scratchpad FIFO buffer within a process. [9 pts]

b) Write a program which will spawn a child process and establish a one-way communication pipe from the parent to the child. The parent process should write at least four messages down the pipe. The child process should read all the messages from the pipe. Insert process ID statements so that the progress of the two processes can be traced. [9 pts] For example:

"This is the parent process. Writing first message into pipe."
"This is the child process. Reading first message from pipe. Contents is:"

c) Using the timer capability of one of the previous problems, design a program which will determine the size limit of a pipe on the system you are using. Only a certain number of bytes can be put in the pipe without it being read. Knowing this limit is important. Normally, if there is room in the pipe, the write function will return immediately. However, if a write is attempted that would overfill the pipe, process execution is suspended until room is made by another process which can read from the pipe.

Create a program which will input data into a pipe one character at a time. Count the number of characters as they are written into the pipe. Print out a message after every 1K (1024) characters are written to the pipe. If the process does not read from the pipe, eventually the pipe will fill and the next attempted write to the pipe will block the process. Use the alarm function to prevent the process from hanging indefinitely after the pipe gets full, but be sure to set the time limit large enough so that you can be sure the pipe is completely filled. In the interrupt handler function, print out a message showing the final count of characters that can be input to the pipe (i.e., the maximum size of pipes on your system). [15 pts]

So, the printout will appear something like: 1024 characters in pipe 2048 characters in pipe xxxx characters in pipe

Write blocked after yyyy characters.

Answer 1

Answers to all parts are provided below. If you have any queries, feel free to comment.

a)

Program Screenshot:

Sample Output:

Program Code to copy:

#include<stdio.h>
#include<stdlib.h>
#include<fcntl.h>
#include<unistd.h>

#define BUFSIZE 16

int main(){
    //pipe descriptors
    char msg[BUFSIZE];
    char buf[BUFSIZE];
    int pipefd[2];
    if(pipe(pipefd) == -1){
        //pipe creation error
        perror("pipe");
        exit(EXIT_FAILURE);
    }
    //pipe creation successfull
    //write four messages
    sprintf(msg , "apple");
    write(pipefd[1], msg, BUFSIZE);
    printf("Written %s\n", msg);
    sprintf(msg , "boy");
    write(pipefd[1], msg, BUFSIZE);
    printf("Written %s\n", msg);
    sprintf(msg , "cat");
    write(pipefd[1], msg, BUFSIZE);
    printf("Written %s\n", msg);
    sprintf(msg , "dog");
    write(pipefd[1], msg, BUFSIZE);
    printf("Written %s\n", msg);

    //read
    read(pipefd[0], buf, BUFSIZE);
    printf("Read: %s\n", buf);
    read(pipefd[0], buf, BUFSIZE);
    printf("Read: %s\n", buf);
    read(pipefd[0], buf, BUFSIZE);
    printf("Read: %s\n", buf);
    read(pipefd[0], buf, BUFSIZE);
    printf("Read: %s\n", buf);
    close(pipefd[0]);
    close(pipefd[1]);
    return 0;
  
}

b)

Program Screenshot:

Sample Output:

Program code to copy:

#include<stdio.h>
#include<stdlib.h>
#include<fcntl.h>
#include<unistd.h>
#include<wait.h>

#define BUFSIZE 16

int main(){
    //pipe descriptors
    char msg[BUFSIZE];
    char buf[BUFSIZE];
    int pipefd[2];
    if(pipe(pipefd) == -1){
        //pipe creation error
        perror("pipe");
        exit(EXIT_FAILURE);
    }
    //pipe creation successfull
    //write four messages
    if(fork() == 0){
        //this is child
        //close unused write end
        close(pipefd[1]);
        read(pipefd[0], buf, BUFSIZE);
        printf("This is child process reading first message. Content is %s\n", buf);
        read(pipefd[0], buf, BUFSIZE);
        printf("This is child process reading second message. Content is %s\n", buf);
        read(pipefd[0], buf, BUFSIZE);
        printf("This is child process reading third message. Content is %s\n", buf);
        read(pipefd[0], buf, BUFSIZE);
        printf("This is child process reading fourth message. Content is %s\n", buf);

        close(pipefd[0]);
        //exit from child
        exit(EXIT_SUCCESS);

    }
    //this is parent process

    //close unused read end
    close(pipefd[0]);

    sprintf(msg , "apple");
    printf("This is parent process. Writing first message into pipe\n");
    write(pipefd[1], msg, BUFSIZE);

    sprintf(msg , "boy");
    printf("This is parent process. Writing second message into pipe\n");
    write(pipefd[1], msg, BUFSIZE);

    sprintf(msg , "cat");
    printf("This is parent process. Writing third message into pipe\n");
    write(pipefd[1], msg, BUFSIZE);

    sprintf(msg , "dog");
    printf("This is parent process. Writing fourth message into pipe\n");
    write(pipefd[1], msg, BUFSIZE);

    close(pipefd[1]);

    //wait for child
    wait(NULL);

    return 0;
  
}

c)

Program Screenshot:

Sample Output:

Program code to copy:

#include<stdio.h>
#include<stdlib.h>
#include<fcntl.h>
#include<unistd.h>
#include<sys/wait.h>
#include<sys/types.h>
#include<signal.h>

typedef struct sigaction Sigaction;

unsigned long long size = 0;

void alarmhandler(int sig){
    //alarm fired writing blocked
    printf("Write blocked after %llu characters\n", size);
    exit(EXIT_SUCCESS);
}

int main(){
    //pipe descriptors
    int pipefd[2];
    if(pipe(pipefd) == -1){
        //pipe creation error
        perror("pipe");
        exit(EXIT_FAILURE);
    }

    //install handler
    sigset_t mask , prev;
    sigemptyset(&mask);
    sigaddset(&mask , SIGALRM);
    sigprocmask(SIG_BLOCK , &mask , &prev);
    Sigaction new_action;
    sigemptyset(&new_action.sa_mask);
    new_action.sa_flags = SA_RESTART;
    new_action.sa_handler = alarmhandler;
    sigaction(SIGALRM , &new_action , NULL);
    sigprocmask(SIG_SETMASK , &prev, NULL);

    while(1){
      
        //print size on multiple of 4
        if(size != 0 && size % 1024 == 0){
            printf("%llu characters in pipe\n", size);
        }
        //reset previous alarm
        alarm(0);
        //set new alarm for 5 seconds
        alarm(5);
        //write to pipe one character
        write(pipefd[1], "A", sizeof(char));
        size++;
    }
    return 0;
  
}