[SOLVED] COP4600 Ex7-Pipes

The aim of this exercise is to familiarize you with pipes in Linux. Pipes are a common form of interprocess communication. Structure

The assignment is broken into three main parts. In each part, you will learn about a different way to implement pipes. The three parts are as follows:

1. Basic Pipes
2. Named Pipes
3. Pipe System Call

Basic Pipes

Basic pipes can be created in the terminal by placing the | operator between commands. Using | causes the output of the left command to be piped in as the input to the right command. For example, running cat result.txt | grep -o COP4600 | wc -l would return the number of times that the pattern COP4600 is found in result.txt. The contents of the file are being piped into the grep command which then passed any matches into the wc command. The wc -l option returns the number of newlines which, in this case, equals the number of occurrences of the pattern.

For this part, an executable file named part1.o is provided via Canvas. When run, the executable will perform basic operations until it encounters a failure. The amount of successful operations completed before failing will vary. Here is a sample output of this program:

Your task is to create a C++ program that, when the output of part1.o is piped in, determines which operation number caused the failure. For example, your program would print Program failed on operation 12 if it were run with the information from the above screenshot. For this part you will need to submit a screenshot that shows your code successfully running twice with input provided by part1.o through a basic pipe.

Named Pipes

Named pipes, also known as FIFOs (first-in first-out), are functionally similar to basic pipes except they are represented as a special file and are, therefore, a non-temporary part of the filesystem. A FIFO can be created using the mkfifo [name] command (similar to mkdir). A FIFO does not store the communicated data in the file system and only acts as a reference point for processes to establish a connection. Because of this, when a writer process opens the FIFO, it will block until a reader process opens the other end. Utilizing named pipes through the command line, therefore, will likely require multiple terminal windows.

For this part, implement the following:

1. Create a named pipe.
2. Modify your part 1 C++ code to read its input from a file (your named pipe). This program should be named lastname_part2.cpp where lastname is your last name.
3. Run part1.o and redirect its output into the named pipe.
4. Compile and run your part 2 program (input should not be redirected from the command line).
5. Repeat steps 3 and 4 then take a screenshot that shows the programs running to completion twice. Be sure to include all terminal windows that were used.

Pipe System Call

Both piping methods used above have required some form of post-compile time actions (i.e. redirecting output or creating a named pipe). In many cases, this may be a drawback. To set up a pipe entirely within the process code, the pipe system call can be used.

For this part you will use the fork() and pipe() system calls to implement the following:

1. Create a new C++ program named lastname_part3.cpp where lastname is your last name. The program should accept 5 command-line arguments (all integers).
2. The program should create two new child processes and utilize four pipes.
3. The parent process will send the 5 integers to the first child process using a pipe. This child will sort the integers and send the result to the parent process and the second child process using one pipe for each. The parent will print the result.
4. After receiving the sorted list from the first child process, the second child process will identify the median value of the list and send the result to the parent using a pipe. The parent will print the result.
5. Take a screenshot of the program running with the following integers passed in as command-line arguments (in the specified order): 42, 15, 8, 16, and 23.