Distributed programming

Transcription

1 Distributed programming Previously discussed Every SCC is a component in a distributed system that executes distributed programs on a combination of the SCC and one or more other machines. Physically distributed systems concepts Network architecture and the ISO/OSI reference model The device abstraction for communicating: remote computers as devices The client / server architecture

2 What we will learn Computations are based on the idea of a sequential computation. Distributed computations are collections of interacting sequential computations. Sequential computations can be implemented in a physically distributed system Client-server computing makes heavy use of the ISO OSI transport layer to implement datagram (UDP) and connected (TCP) communication across sequential computations running in their own AUCs on distinct machines. Remote procedures as a tool for distributed computing Sequential computations A computer performs useful work by specifying a sequence of instruction that accomplishes some information processing task The instruction sequence is called a sequential computation sequential: instructions are executed one after the other computation: the collection of instruction executions controls the behavior of the computer to accomplish a desired information processing task.

3 Sequential computations Sequential computation rule: the next instruction in the sequence does not start executing until the previous one has completed its execution... int x=2; scanf( %d, &x); printf( f(%d) = %d\n, x, x*x); Sequential computation does not distinguish between I/O instructions and other instructions #define BUF_LEN 100 Example int main() { int infid, outfid; int numread; int i; char buf[buf_len]; if((infid = open("myinput.txt", O_RDONLY)) == -1) { fprintf(stderr, "usage: open() failed, halting\n"); exit(-1); if((outfid = open("myoutput.txt", O_CREAT O_WRONLY)) == -1) { fprintf(stderr, "usage: open() failed, halting\n"); exit(-1); /* Input & output files are ready to use */ while((numread = read(infid, buf, BUF_LEN))!= 0) // Read MyInput write(outfid, buf, numread); // Copy to MyOutput /* File copy complete */ close(infid); close(outfid); exit(0);

4 Sequential computations: AUC Autonomous Unit of Computation (AUC): generic abstract machine that executes a sequential computation Abstract machine: a simulation of a physical machine Examples: coroutines, threads, lightweight processes, heavyweight processes, tasks Sequential computations: AUC Realization example: multiprogramming OS

5 Distributed computations A distributed computation is a set of cooperating sequential computations. Created by defining a collection of sequential computations executing in AUCs that coordinate their efforts by exchanging information Distributed computations extend sequential computation & AUCs by adding means for intercommunication mechanisms among the relevant AUCs Distributed computations Sequential computation rule: the computation is determinate: each execution of the program (on the same input data) produces the same output. SCR violated: the program can still be made to be determinate, if the programmer used some other mechanism to assure determinacy. Distributed programming is the art of writing programs that will be executed on a distributed system, generally as determinate programs.

6 Example: sequential computations... startread(dev_3, x); while(dev_3.busy == 1) (wait); // The device is done y = f(x);... CPU while(dev_3.busy == 0) (wait); DEV_3.busy = 1; // Perform an input op return(value); DEV3.busy = 0 Sequential operation DEV_3 Hardware Example: distributed computations... startread(dev_3, x); while(dev_3.busy == 1) executecodefragment(); // The device is done y = f(x);... CPU while(dev_3.busy == 0) (wait); DEV_3.busy = 1; // Perform an input op return(value); DEV3.busy = 0 Overlapped operation DEV_3 Hardware

7 Distributed computations General idea: partition the work of an algorithm into subalgorithms, Each subalgorithm can be executed relatively independent: A subalgorithm can be implemented by a small sequential computation Each subalgorithm is assigned its own AUC when it is executed by the OS. Distributed computations Difficulties: defining subalgorithms that can execute relatively independently from one another, yet contribute to the solution of the general algorithm ensuring that in the few cases where the subalgorithms interact with one another to coordinate their execution, that they do so in such a way that the logical pattern of sequential execution of the general algorithm is preserved.

8 The Client / Server model Using the Network for Distributed Computations Application Presentation Session Transport Network Data Link Physical Application Presentation Session Transport Network Data Link Physical implemented in the OS implemented in the network device controller (NIC ) We will discuss how to write programs that uses ISO OSI compliant networks

9 ISO OSI Model Transport Network Data Link Physical Transport Network Data Link Physical Dominant Transport layer net: TCP-based network ISO OSI & TCP/IP ISO OSI Session ISO OSI packet ISO OSI TLI ISO OSI frame ISO OSI Network ISO OSI Session ISO OSI packet ARPAnet TCP IP frame ARPAnet IP Ethernet packet MAC Ethernet

10 Client/Server via TCP/IP Client AUC Server AUC Socket layer Socket layer ARPAnet TCP IP frame ARPAnet IP Ethernet packet Ethernet driver ARPAnet TCP IP frame ARPAnet IP Ethernet packet Ethernet driver Transport Layer Provides yet another address extension IP references only networks and hosts Transport layer adds ports -- logical endpoints Address form is <net, host, port> Two primary protocols (both from ARPAnet) Transmission Control Protocol (TCP) User Datagram Protocol (UDP)

11 DNS Transport Layer Transmission Control Protocol (TCP) Telephone call (connection) Provides a stream-oriented interface to the network Reliable delivery but more overhead Higher level transactions User Datagram Protocol (UDP) Telegram User-space interface to IP packets No guarantee that packet will be delivered, but less data MPEG transmission (connectionless) Programming the Transport Layer The network layer identifies senders and receivers in terms of a <net, host> pair The transport layer address space is extended beyond internet addresses so that transmitter can reference a specific port on a remote host on a remote network mumble.cs.colorado.edu ports port numbers Host: 34 Net: P P P P Transport Layer Network Layer Low Layers n

12 DNS DNS Programming the Transport Layer Each machine can support a number of ports to represent places for information to be sent and received from/to software in the machine ports are OS resources: an AUC must obtain the right to use a particular port either by dynamically requesting the port, or by having the port permanently reserved mumble.cs.colorado.edu ports port numbers Host: 34 Net: P P P P Transport Layer Network Layer Low Layers n Programming the Transport Layer A BSD socket is an OS data structure that can be dynamically associated with a port. The socket is designed so that a sequential computation can configure it to connect to the port, and then to transmit and receive information using a variety of transport layer protocols, including TCP and UDP. mumble.cs.colorado.edu ports Host: 34 Net: P P P P Transport Layer Network Layer Low Layers

13 Socket-programming using TCP Socket: a door between application process and end-endtransport protocol (UDP or TCP) TCP service: reliable transfer of bytes from one process to another controlled by application developer controlled by operating system process socket TCP with buffers, variables internet process socket TCP with buffers, variables controlled by application developer controlled by operating system host or server host or server Socket-programming using TCP Connected (or virtual circuit) protocol: full duplex byte stream channel Interface allows programmer to read/write a byte stream over the network Byte stream is mapped into a series of packets Reliable delivery Each packet must be acknowledged Effectively 2 packets per transmission Must open/close a connection before use

14 Socket-programming using TCP Byte stream I/O: enables a sequential computation to write an arbitrary collection of bytes to the stream, and for another sequential computation to simply read the collection of bytes. POSIX system call interface: includes the functions read() and write() to receive and transmit bytes on a byte stream virtual device The device : a physical device, a file, a pipe, or another abstraction of an I/O device. Socket-programming using TCP Client must contact server server process must first be running server must have created socket (door) that welcomes client s contact Client contacts server by: creating client-local TCP socket when client creates socket: client TCP establishes connection to server TCP specifying IP address, port number of server process When contacted by client, server TCP creates new socket for server process to communicate with client allows server to talk with multiple clients 28

15 Client/server socket interaction: TCP Server (running on hostid) create socket skt = socket() what port am I on? bind() will somebody please call me? listen() Client create socket, clientsocket = socket() Thanks for calling port XXX connectskt = accept() read request from connectskt TCP connection setup Hey, you! connect() send request using clientsocket write reply to connectskt close connectskt read reply from connectskt close clientsocket 29 Socket data structures Structures are used in socket programming to hold information about the address struct sockaddr{ unsigned short sa_family; /* address family, AF_xxx */ char! sa_data[14]; /* 14 bytes of protocol address */ ; struct sockaddr_in { short int! sin_family; /* Address family */ unsigned short int sin_port;! /* Port */ struct in_addr! sin_addr;! /* Internet Address */ unsigned char! sin_zero[8]; /* not used */ ; struct in_addr{ unsigned long s_addr; /* address */ ;

16 Creating the socket A BSD socket is an OS data structure that can be dynamically associated with a port: socket int socket(int domain, int sockettype, int protocolno) handle = "AF_INET" to use ARPA For Stream Socket the type must be 0 = default index into an internal table internet protocols or SOCK_STREAM of socket descriptions "AF_UNIX" to create For Datagram Socket the type must sockets for inside be SOCK_DGRAM comunication S P P P P Transport Layer Network Layer Low Layers What port am I on? Once a socket has been created, it can be bound to an internet port int bind(int sktid, struct sockadrr *addr, int addrlength) socket handle specifies the <<net, host> port> length of the addr field S P P P P Transport Layer Network Layer Low Layers

17 Will somebody please call me? int listen(sktid, socket descriptor returned by socket() call int backlog) the number of allowed connections: the maximum queue length waiting for incoming connections if you want someone to connect to your machine. when a server arranges to accept connections over a virtual circuit, the kernel must queue incoming requests until it can service them Before calling listen(), you must call bind() or you'll be listening on a random port Hey you! connect() is used to connect to an IP address on a defined port. int connect(sktid, struct sockaddr *serv_addr, int addrlen); socket handle Address of the TARGET socket: pointer to struct sockaddr that contains destination IP address and port sizeof(struct sockaddr) when connect() returns, the client has a virtual circuit to the server. Returns -1 on error.

18 Thanks for calling port XXX! When someone is trying to connect, you must use accept() to get the connection. NEW socket handle int accept(int sktid, void *addr, int *addrlen); socket handle pointer to struct sockaddr_in where you can determine which host is calling you from which port sizeof(struct sockaddr) usage example: sin_size=sizeof(struct sockaddr_in); if ((new_sktid = accept(sktid,(struct sockaddr *) &client,&sin_size))==-1)! printf("accept() error\n");! exit(-1); new_ sktid will be used for communication Using TCP -- Client (Unix domain) #include <sys/types.h> #include <sys/socket.h> #include <stdio.h> #include <stdlib.h> #include <string.h> #define MAX_DIM 256 #define Error_(x) { puts(x); exit (1); int main() {! int ds_sock, res;! struct sockaddr indirizzoserver;! char buff[max_dim], nomesocket[20];! printf("\ninserisci nome socket -> "); scanf("%s",nomesocket);! strcpy(indirizzoserver.sa_data, nomesocket);! ds_sock = socket(af_unix, SOCK_STREAM, 0);! printf("client: Mi connetto al socket...\n");! res = connect(ds_sock, &indirizzoserver, sizeof(indirizzoserver));! if (res == -1) Error_("CLIENT: Errore nella connessione\n");! printf("client: Trasmetto messaggio...\n");! write(ds_sock,"ciao ciao dal Client!", MAX_DIM);! read(ds_sock, buff, MAX_DIM);! printf("client: Ho letto %s", buff);! close(ds_sock);! exit(0);

19 Using TCP -- Server (Unix domain) #define MAX_DIM 256 #define Error_(x) { perror(x); exit (1); int main() {! int ds_sock, new_sock, res;! struct sockaddr indirizzoserver, indirizzoclient;! int client_lgth;! char buff[max_dim], nomesocket[20];!! printf("\ninserisci nome socket -> "); scanf("%s",nomesocket);!! strcpy(indirizzoserver.sa_data,nomesocket);! ds_sock = socket(af_unix, SOCK_STREAM, 0);! if (ds_sock == -1) Error_("SERVER: Non creo la socket");! if ((bind(ds_sock, &indirizzoserver, sizeof(indirizzoserver))) == -1) Error_("SERVER: Errore nella bind");!! listen(ds_sock, 1);! printf("server: Socket pronta! Attendo connessioni...\n"); fflush(stdout);!!! new_sock= accept(ds_sock, &indirizzoclient, &client_lgth);! printf("server: Ho accettato una connessione\n");! close(ds_sock);!!!! read(new_sock, buff, MAX_DIM);! printf("server: Ho letto %s", buff);! fflush(stdout);!!! write(new_sock, "SERVER: messaggio ricevuto!\n",30 );! close(new_sock);! exit(0);! Using TCP -- Server (Internet domain) #include <sys/types.h> #include <sys/socket.h> #include <sys/signal.h> #include <netinet/in.h> #include <netdb.h> #include <stdio.h> #include <stdlib.h> #define MAX_DIM 1024 #define Error_(x) { perror(x); exit (1); int main() {! int ds_sock, new_sock, res;! struct sockaddr_in client, server;! unsigned int client_lgth;!! char buff[max_dim];!! ds_sock = socket(af_inet, SOCK_STREAM, 0);! if (ds_sock == -1) Error_("\nSERVER: Non creo la socket");!! server.sin_family = AF_INET;! server.sin_port = 2000;! server.sin_addr.s_addr = INADDR_ANY; //non specifica l'ip address!!! if ((bind(ds_sock, (struct sockaddr*)&server, sizeof(server))) == -1) Error_("\nSERVER: Errore nella bind");! listen(ds_sock, 3);! printf("\nserver: Socket pronta! Attendo connessioni...\n");fflush(stdout);! client_lgth = sizeof(client);!!!! new_sock = accept(ds_sock, (struct sockaddr*)&client, &client_lgth);! printf("\nserver: Ho accettato una connessione\n");!!! do {!!! read(new_sock, buff, MAX_DIM);!!! printf("%s ", buff); fflush(stdout);!!!! while ( strcmp(buff, "quit")!= 0 );! write(new_sock, "\n ricevuto tutto!\n", 30);! close(ds_sock);! close(new_sock);! exit(0);!

20 Using TCP -- Client (Internet domain) #include <sys/types.h> #include <sys/socket.h> #include <netinet/in.h> #include <netdb.h> #include <stdio.h> #include <stdlib.h> #include <strings.h> #define MAX_DIM 1024 #define Error_(x) { puts(x); exit (1); int main() {! int ds_sock, res;! struct sockaddr_in client;! struct hostent *phost;! char buff[max_dim];! ds_sock = socket(af_inet, SOCK_STREAM, 0);! client.sin_family = AF_INET;! client.sin_port = 2000;! //recupera info relativa all'host! phost = gethostbyname("macbook-di-giuseppe-boccignone.local");! //phost->h_addr: contiene l'indirizzo dell'host phost->h_length: lunghezza in byte dell'indirizzo! bcopy(phost->h_addr, &client.sin_addr, phost->h_length);! res = connect(ds_sock, (struct sockaddr*)&client, sizeof(client));! if (res == -1) Error_("CLIENT: Errore nella connessione\n");! printf("client: Digitare le stringhe: ");! do {!! scanf("%s", buff);!! write(ds_sock, buff, MAX_DIM);! while ( strcmp(buff, "quit")!= 0 );! read(ds_sock, buff, MAX_DIM);! printf("client: IL server risponde: %s\n", buff);! close(ds_sock); UDP Datagram ( connectionless ) service Similar to disk I/O level of service Logically associated with an IP packet & Data Link frame (but not physically) Best-effort delivery of datagrams, but: Datagram may be dropped (lost) Datagrams may be delivered out of order Efficient, relative to TCP

21 TCP Readers and writers TCP Readers and writers

22 TCP: the writer Server... skt = socket(af_inet, SOCK_STREAM, 0); /* Build the writer's address */... /* The socket has to be bound to an IP address to get data sent to IP */ if(bind(skt, (struct sockaddr *) &writer, sizeof(writer))) { fprintf(stderr, "Bind error, restart...\n"); exit(1); /* Set up the socket to listen for connect requests */ listen(skt, MAX_REQUESTS); newskt = accept(skt, (struct sockaddr *) &writer, &addrlen); close(skt); // Close the listener socket, skt, use the newskt /* Run the writer part of the distributed computation */ /* Open the destination file */... while((numrcvd = read(newskt, buf, BUF_LEN)) > 0) { write(outfid, buf, numrcvd); /* Clean up and quit */ printf("writer: terminating...\n"); exit(0); Using TCP: the Reader Client /* Set up a socket to talk to the writer */ skt = socket(af_inet, SOCK_STREAM, 0); /* Build the writer's address */... /* Open the connection to writer */ if(connect(skt, (struct sockaddr *) &writer, sizeof(writer)) < 0) { fprintf(stderr, "reader: connect() failed, halting\n"); exit(1); /* Run the reader part of the distributed computation */ /* Open the source file */... /* Here is the main reader loop */ while((numread = read(infid, buf, BUF_LEN)) > 0) { write(skt, buf, numread); /* trasmitting */ /* Clean up and quit */ printf("reader: Terminating...\n"); exit(0);

23 The smart thermometer The smart thermometer... /* The Control Path is data flowing from the large computer to the * SCC via the TCP connection. Thermometer data flows * from the SCC to the large computer over the same TCP * connection. */ skt = socket( ); read(skt, high_threshold_value); // SCC reads control info from host read(skt, low_threshold_value); // SCC reads control info from host while( ) { read(thermometer, value); if(value > high_threshold_value){ write(skt, value); // Write data to the host computer continue; if(value < low_threshold_value){ write(skt, value); // Write data to the host computer continue;

24 Remote Procedure Call (RPC) Summary Computations are based on the idea of a sequential computation. Distributed computations are collections of interacting sequential computations. Sequential computations can be implemented in a physically distributed system Client-server computing makes heavy use of the ISO OSI transport layer to implement datagram (UDP) and connected (TCP) communication across sequential computations running in their own AUCs on distinct machines. RPC allows an SCC to invoke compute intensive and data intensive services that are implemented on a large networkaccessible machine without special concern about determinacy and adherence to the sequential computation rule.