Assignment 2 Group 5 Simon Gerber Systems Group Dept. Computer Science ETH Zurich - Switzerland

Transcription

1 Assignment 2 Group 5 Simon Gerber Systems Group Dept. Computer Science ETH Zurich - Switzerland

2 t Your task Write a simple file server Client has to be implemented in Java Server has to be implemented in C

3 t Protocol 1. Client opens connection (server accepts) 2. Client sends users first name prefixed by its length 3. Client sends users last name prefixed by its length 4. Server sends back a greeting message 5. Server loads the file data/message.txt to a buffer in RAM 6. Server sends the content of the buffer, prefixed by its length. We use TCP (why?)

4 t Sockets in Java Clients Creating a client socket: Socket clientsocket = new Socket("localhost", 12234); To get a stream to write to: clientsocket.getoutputstream(); To get the input stream: clientsocket.getinputstream(); Done (now: implement the protocol using these streams) BufferedReader has some handy methods (BufferedWriter too ): BufferedReader br = new BufferedReader(new InputStreamReader(clientSocket));

5 t Sockets in Java Servers Create a ServerSocket Socket.accept() will return a new socket From there: use the same methods as for client sockets

6 t Socket in C In C, everything gets a bit more complicated There is no standard socket library instead we use system calls and socket descriptors (under Unix) System calls and functions (read their man pages!!): socket kernel creates a socket descriptor (does not establish a connection!!!) bind assigns an address to a socket getaddrinfo resolves host names, fills the structs needed for bind/connect etc preferred over gethostbyname (does also make DNS requests for you) connect establish a connection listen tells OS to turn a socket into a listener accept accepts an incoming connection returns new socket

7 t getaddrinfo VERY useful function -> makes everything easier First Argument is a host name Second a service name (for example http or 80 ) Allocates memory (has to be freed with freeaddrinfo see man page) Returns usually an array with possible endpoints (should check all in productive code we won t)

8 t Socket Straightforward if you use getaddrinfo:

9 t bind Used to name a socket You will need this system call before you can call accept

10 0 t listen Informs the OS, that the bound socket wants to listen (creates a server socket from a given socket)

11 1 t accept Blocks until a client opens a connection cs is the socket to the client (type of int)

12 2 t Working with threads Problem: only one connection at a time Classical solution: have a thread pool and in the main thread call accept and assign the client socket to an unemployed thread

13 3 t Problems with threads Since calls to recv, send etc block, we need to oversubscribe (have more threads than CPU cores) to scale Oversubscribing results always in bad latency (context switches in the operating system are expensive) For clients, this is usually ok For servers not anymore Latency is today the biggest bottleneck (SSD vs HDD, Ethernet vs Infiniband) In ~10 years, low latency networks will be commodity (today: Infiniband is roughly equally expensive as 10 Gbit Ethernet)

14 4 t Event driven programming Old idea that got more and more popular in the last few years: node.js boost::asio libevent java.nio In this course, you will learn how to do it low-level! POSIX system call: select On Linux: select and epoll (epoll is faster) On BSD/Mac OS X: select and kqueue (kqueue is faster) We will only cover select (does essentially the same)

15 5 t Idea Receiving: When a packet arrives, it gets parsed by the kernel (TCP-Stack) and the kernel pushes the data on a queue recv will copy it to a memory location held by the program If recv is blocking, it will wait until something to copy is on the queue Otherwise it will either copy from the queue or immediately return Sending: send passed the package to the OS The OS will generate a TCP (or UDP) packet The OS will wait, till it can send, if send is blocking If it is not blocking, it will check whether it can send or return immediately

16 6 t Idea (II) We could now execute send or receive in a loop Impractical: has the same problems as blocking and is even slower We want to do other useful work while we wait for the network select gives a set of sockets to the OS The OS answers with a set of Sockets, which have pending operations (ready for write/receive/accept etc) One thread can handle lots of connections Multithreading still possible but not straight forward boost::asio implements an own processing queue to scale over several threads (very fast in practice)

17 7 t Setting syscalls to non-blocking send, recv etc usually have a flags argument which can be used to tell them to execute in an asynchronous way Other (often preferred option): use the fcntl system call

18 Select (I) select(int nfds, fd_set *readfds, fd_set writefds, fd_set *exceptfds, struct timeval *timeout) nfds = max(fd in union(readfds, writefds, exceptfds))+1 fd_set: data structure representing a set of fds, operations are void FD_CLR(int fd, fd_set *set) removes fd from set int FD_ISSET(int fd, fd_set *set) checks if fd is contained in set void FD_SET(int fd, fd_set *set) adds fd to set void FD_ZERO(fd_set *set) zeroes set readfds = set of fds we want to read from writefds = set of fds we want to write to exceptfds = set of fds we want to know exceptions of (errors) timeout = set to NULL if you want to wait however long it takes to get some activity on one of the fds (check man page for more details).

19 0 t Select (II) we only need the readfds set for our server add all the client sockets to the readfds set so you know when some client has sent data Call select and block until something happens Service all ready sockets (check with FD_ISSET)

20 Strings and Files in C size_t strlen(const char *s) returns the length of a \0 terminated string at s snprintf(char *str, size_t size, const char *format, ) works like printf but instead of printing to the console, writes the output (at most size characters) to the buffer at str FILE *fopen(const char *path, const char *mode) opens a file; for opening a text file to read from use r as argument for mode size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream) read nmemb elements of data each of size `size` from `stream` and store them at `ptr` e.g. assuming that FILE *f = fopen( data/message.txt, r ); size_t read = fread(buf, 1, BUFSIZE, f); // or fread(buf, BUFSIZE, 1, f)

21 3 t That s all folks Questions?