Figure 1 Ring Structures

Transcription

1 CS 460 Lab 10 The Token Ring I Tong Lai Yu ( The materials here are adopted from Practical Unix Programming: A Guide to Concurrency, Communication and Multithreading by Kay Robbins and Steven Robbins. ) 1 Introduction The ring topology is one of the simplest configurations for connecting communicating entities. A ring network topology connects each node to exactly two other nodes, forming a single continuous pathway for signals through each node. Data travels from node to node, with each node along the way handling every packet. Figure 1 illustrates two ring structures. Figure 1 Ring Structures Because a ring topology provides only one pathway between any two nodes, ring networks may be disrupted by the failure of a single link. A node failure or cable break might isolate every node attached to the ring. To overcome this vulnerability, many ring networks such as Spatial Reuse Protocol, Fiber Distributed Data Interface (FDDI), and Resilient Packet Ring, add a counter-rotating ring to form a redundant topology. In FDDI networks, when a break occurs, data are wrapped back onto the complementary ring before they reach the end of the cable, maintaining a path to every node along the resulting C-Ring. Some network protocols lik IEEE token bus avoid the weakness of a ring by physically arranging the nodes in a bus but logically forming a ring. This lab implements a ring of processes that communicate via pipes. Each process represents a node on the ring; it reads from standard input and writes to standard output. Process n 1 redirects its standard output to the standard input of process n through a pipe. The ring structure can be easily extended to simulate ring networks or implement algorithms for mutual exclusion and leader election. Before moving on, use the man command to study the following functions: e.g. man dup2 dup2 read write pipe fprintf atoi getpid wait 1

2 Exercise 0 Explain briefly in your own words what each of the above functions does. 2 Forming a Ring We shall use the system call dup2 to copy file descriptors to the appropriate entry of the file descriptor table. As shown below, the function takes two parameters, filedes1 and filedes2. It closes entry filedes2 of the file descriptor table and then copies the pointer of entry filedes1 into entry filedes2. #include <unistd.h> int dup2 ( int filedes1, int filedes2 ); The following code connects the standard output of a process to its standard input through a pipe and Figures 2-4 show the status of the process of after certain statements have been executed. The numbers in square brackets (e.g ) are indices of the process file descriptor table entry. The entries in the file descriptor table are pointers to entries in the system file table. For example, write in entry [4] means a pointer to the write entry in the system file table for. Figure 2 depicts the file descriptor table after has been created. A program can write to the pipe at this point using a file descriptor value of 4 in a write. #include <unistd.h> int fd[2]; pipe ( fd ); dup2 ( fd, STDIN_FILENO ); dup2 ( fd, STDOUT_FILENO ); [3] Figure 2 [2] ; [4] File descriptor table standard input standard output [3] read [4] write Status of Process After Execution of pipe (fd) [3] Figure 3 [2] [4] File descriptor table read write [3] read [4] write Status of Process After Execution of dup2 s 2

3 The instruction dup2 ( fd, STDIN FILENO ) does the following: 1. It closes the stdandard input file descriptor. 2. It makes file descriptor be a copy of fd. On the other hand dup2 ( fd, STDOUT FILENO ) closes the standard output file descriptor and makes it to be a copy of fd. Figure 3 shows the status of the file descriptor table after executing the two dup2 in the above code. At this point, the program can write to the pipe using a file descriptor value of either 1 or 4; it can read from the pipe using or [3]. Therefore, we can close [3] ( fclose ( fd ) ) and [4] ( fclose ( fd ) ). Figure 4 shows the status after descriptors 3 and 4 are closed. [2] File descriptor table read write Figure 4 Status of Process After Execution of close(fd) and close(fd) Exercise 1 What happens if, after connecting standard output to standard input via a pipe, the process of the above code executes the following code segment? Explain. int n = 98; for ( int i = 0; i < 10; i++ ) { write ( STDOUT_FILENO, &i, sizeof(i) ); read ( STDIN_FILENO, &n, sizeof (n) ); fprintf( stderr, "%d\n", n ); Exercise 2a What happens if the code in Exercise 1 is replaced by the following code? Explain. int n = 98; for ( int i = 0; i < 10; i++ ) { read ( STDIN_FILENO, &n, sizeof (n) ); write ( STDOUT_FILENO, &i, sizeof(i) ); fprintf( stderr, "%d\n", n ); Hint: The program hangs on the first read. Why? Exercise 2b What happens if the code in Exercise 1 is replaced by the following code? Explain. int n = 98; for ( int i = 0; i < 10; i++ ) { printf("%d ", i ); scanf ( "%d", &n ); fprintf( stderr, "%d\n", n ); Answers: The program hangs on scanf because the pipe reading and writing are fully buffered. The funciton printf does not write anything to the pipe until the buffer is full. Put a fflush ( std ) statement after the printf to get output. 3

4 We can create a ring of two processes using this piping technique as shown in the ring-twop.cpp program below: //ring-twop.cpp #include<unistd.h> using namespace std; int main() { int fd[2]; pipe ( fd ); dup2 ( fd, STDIN_FILENO ); dup2 ( fd, STDOUT_FILENO ); pipe ( fd ); if ( fork() ) //parent dup2(fd, STDOUT_FILENO); else //child dup2(fd, STDIN_FILENO); //parent redirects std output //child redirects std input The parent process of the code shown above redirects standard input through the first pipe to the standard output of the child and redirects standard output through the second pipe to standard input of the child. Exercise 3 Draw a diagram like those of Figures 2-4 to show the connections of the processes after the second pipe ( fd ) has been executed. Then draw a diagram after fork() but before the rest of the if statement, showing pipe x, pipe y, the two processes ( parent and child ) and the connections with file descriptors labeled along the edges. You may click on the link to see the answers. The function fork() of ring-twop.cpp creates a child process (suppose is the parent process and Y is the child process). The parent makes standard output be the copy of fd. The child process makes standard input be the copy of fd. It then closes both fd and fd. The final status of the pipes is shown in Figure 5. The parent process and the child process Y can now communicate via pipex x and y: sends messages to Y via pipe y and Y sends messages to via. 4

5 [2] Y pipe y Process fd table read pipe y write Process Y fd table pipe y read write Figure 5 [2] Status of Process (parent) and Y (child) at the end of code. The code of ring-twop.cpp shown above for forming a ring of two processes can be easily extended to rings of arbitrary size. The program ring.cpp shown in Listing 1 sets up a unidirectional ring of n processes where n is passed on the command line (and converted to the variable nprocess). A total of n pipes are required. Note, however, that the program only needs an array of size 2 rather than 2n to hold the file descriptors. Program Listing 1 Creating a Ring of Processes //ring.cpp #include <unistd.h> #include <string.h> #include <errno.h> #include <stdlib.h> #include <iostream> using namespace std; int main( int argc, char *argv[] ) { int fd[2]; int childpid; //process id of child int nprocs; //total number of processes in the ring int error; //return value from dup2 call int i; if ( argc < 2 (nprocs = atoi( argv)) <= 0 ){ cout << "Usage: " << argv << " nprocesses" << endl; if ( pipe ( fd ) == -1 ){ perror("could not create pipe"); if ( dup2 ( fd, STDIN_FILENO ) == -1 dup2 ( fd, STDOUT_FILENO ) == -1 ) { perror ("Could not dup pipes"); for ( i = 1; i < nprocs; i++ ) { 5

6 if ( pipe( fd ) == -1 ) { fprintf(stderr, "Could not create pipe %d: %s\n", i, strerror ( errno ) ); if ( ( childpid = fork() ) == -1 ) { fprintf(stderr, "Could not create child %d: %s\n", i, strerror ( errno ) ); if ( childpid > 0 ) //for parent, reassign stdout error = dup2 ( fd, STDOUT_FILENO ); else //for child, reassign stdin error = dup2 ( fd, STDIN_FILENO ); if ( error == -1 ) { fprintf(stderr, "Could not dup pipes for iteration %d: %s\n", i, strerror( errno ) ); if ( childpid ) //parent done break; //say hello to the world fprintf( stderr, "This is process %d with ID %d and parent ID is %d\n", i, getpid(), getppid() ); return 0; Exercise 4 1. Compile and run the program ring.cpp shown in Listing Create a Makefile to compile the program. 3. Run ring for several values of the command-line argument and observe what happens as the number of processes in the ring varies from 1 to Modify the original program by putting in a wait system call before the final fprintf statement. ( Name your program ring1. ) How does this affect the output of the program? 5. Modify the original program by putting in a wait system call after the final fprintf statement. ( Name your program ring2. ) How does this affect the output of the program? 6. Replace the fprintf statement in the original program, ring, with calls to sprintf and prtastr. ( Name your program ring3. ) write the function void prtastr( const char *s, int fd, int n ); which prints the s string one character at a time to the file specified specified by the descriptor fd using write. After each character is output, prtastr executes the following loop: for ( i = 0; i < n; i++ ); This loop just wastes some CPU time. Use prtastr to output the string to the standard error. The value of n is is passed as an optional command-line argument to ring3. The default value for this parameter is 1. Run the program with a value of n that causes a small, but barely noticeable, delay between the output of characters. 7. Extra Credit ( 2 points ). Modify ring1 to create a bidirectional torus of processes. Accumulate ID arrays to test connectivity. A torus has a two-dimensional structure. It is like a mesh except that the processes at the ends are connected together. The n 2 processes are arranged in n rings in each dimension. Each process has four connections ( North, South, East, and West ). 6

7 Write a report containing the following. 1. Solutions to all the exercises and questions with sample screen shots. 2. Comment on your work and state if you have finished the lab successfully. 7