P1:                       P2:
       1 <- R(x);                W(x, 1);
       2 <- R(x);                1 <- R(y);
       W(y, 1);                  W(x, 2);

   P1:                       P2:                       P3:
       W(a, 0)                   1 <- R(a)                 2 <- R(b)
       W(a, 1)                   W(b, 2)                   0 <- R(a) 

byte[] byteArray = (byte [])System.SharedMemory( 4096 );

Processes P0 and P1 will execute the following program at the same time.
public class SharedMemory {
    public static int main( String args[] ) {
        int pid = Integer.parseInt( args[0] ); // args[0] should be 0 or 1 as process ID. 
        // allocate a 4096-byte zero-initialized shared memory
        byte[] byteArray = (byte [])System.SharedMemory( 4096 ); 

        while ( true ) {
            if ( ++byteArray[ pid * 32 ] % 100 ) { 
            // every 100-time increment of byteArray[0] by P0 or byteArray[32] by P1
                while ( byteArray[64] != pid );       // wait for my turn
                byteArray[64] = ( pid + 1 ) % 2;      // then, let the other process go
            }
        }
    }
}

public class FileContents implements Serializable {
    private byte[] contents;
    private Date time;
    public FileContents( byte[] contents ) {
        this.contents = contents;
    }
    public byte[] get( ) {
        return contents;
    }
    public Date timestamp( ) { // the timestampe when downloaded from the server
        return time;
    }
}

public interface ServerInterface extends Remote {
    // download a given file from the server                                                                      
    public FileContents download( String filename ) throws RemoteException;

    // upload a given file's contents to the server                                                               
    public boolean upload( String filename, FileContents contents ) throws RemoteException;

    // check the timestampe of a given file                                                                       
    public Date timestamp( String filename ) throws RemoteException;
}

public interface ClientInterface extends Remote {
    // invalidate the client cache                                                                                
    public void invalidate( ) throws RemoteException;
    public FileContents writeback( ) throws RemoteException;
}

public class FileClient extends UnicastRemoteObject implements ClientInterface {
    private String cachedFilename = null;     // the name of the file cached at the client                        
    private FileContents fileContents = null; // the file contents cached at the client                           
    private String cachedFileStatus = null;    // "r" or "w"                                                      

    public static void main( String[] args ) throws RemoteException {
        new FileClient( args );
    }
    public FileClient ( String[] args ) throws RemoteException {
        try {
            Scanner input = new Scanner( System.in ); // keyboard input                                           
            ServerInterface server                    // access a file server                                     
                = ( ServerInterface )
                Naming.lookup( "rmi://" + args[0] + ":" + args[1] + "fileserver" );

            while ( true ) {
                System.out.print( "FileClient: file [r/w]: " );
                String filename = input.next( );  // read a file name to operate                                  
                String r_w = input.next( );       // check the read/write mode of this file                       

                // Client-initiated file validation before accessing a file                                       
                if ( cachedFilename != null ) {   // some file cached at the client                               
                    if ( !filename.equals( cachedFilename ) ) { // need a different file                          
                        if ( cachedFileStatus.equals( "w" ) ) { // the client wants to write

                            // ITEM 4 and 5:
                            // Write the current cached file back to the server before downloading a differen file
                            // Implement it (Both CLIENT and SERVER-INVALIDATION)

                        }
                    }

                    // ITEM 4: CLIENT-INITIATED INVALIDATION
                    // Need to check the timestamp here, right?

                }
                else // no file is cached at the client                                                           
                    fileContents = server.download( filename );

                // start a text editor to open the file.                                                          
                cachedFilename = filename;
                cachedFileStatus = r_w;
                runTextEditor( fileContents, cachedFileStatus );
            }
        } catch ( Exception e ) {
        }
    }

    public void invalidate( ) {
        // ITEM 5: SERVER-INITIATED INVALIDATION 
        // Implement it
    }
    public FileContents writeback( ) {
        // ITEM 5: SERVER-INITIATED INVALIDATION
        // Implement it
    }

    private void runTextEditor( FileContents file, String r_w ) {
        // assume that it has been already implemented                                                            
    }
}

• Could the gossip architecture be used for a distributed computer game as described below? The players move figures around a common scene. The state of the game is replicated at the players' workstations and at a server, which contains services controlling the game overall, such as collision detection. Updates are multicast to all replicas.
• The quorum-based replication protocol can address network partition problems. Why didn't Code use this protocol? Explain the reason.
• To cope with the network partition problem, what featreus does Coda have?

• Consider why HDFS maintains only one primary and only one secondary name server? Why not multiple name nodes?
• Explain how HDFS maintain replicas.
• On top of HDFS, a MpaReduce program can run in parallel. For fault tolerance, how does MapReduce rerun a crashed job?

import mpi.*;

public class FT_MPI {
    private static int rank = 0;
    private static int size = 0;
    private static int[] data = new int[1];
    private static int i;

    public static void main( String[] args ) throws MPIException {
        MPI.Init( args );
        rank = MPI.COMM_WORLD.Rank( );
        size = MPI.COMM_WORLD.Size( );

        data[0] = 0;
        resume( );
        for ( i = 0; i < 1000000; i++ ) {
            // communication from the left neighbor                                                                              
            if ( rank > 0 )
                MPI.COMM_WORLD.Recv( data, 0, 1, MPI.INT, rank - 1, 0 );

            // do some dummy computation                                                                                         
            data[0] += rank + 1;

            if ( rank < size - 1 )
                MPI.COMM_WORLD.Send( data, 0, 1, MPI.INT, rank + 1, 0 );

            // communication to the right neighbor                                                                               
            if ( rank == size - 1 )
                System.out.println( data[0] );

            checkpoint( );
        }

        MPI.Finalize( );
    }

    private static void checkpoint( ) {
        // any arguments?                                                                                                        
        // what data to save into a snapshot file                                                                                
    }

    private static void resume( ) {
        // any arguments?                                                                                                        
        // what data to resume from a snapshot file                                                                              
    }
}