Distributed Real-Time Control Systems. Lecture 17 C++ Exceptions Synchronous I/O

Transcription

1 Distributed Real-Time Control Systems Lecture 17 C++ Exceptions Synchronous I/O 1

2 Traditional Error Handling Well behaved code should notonlyfocus on operation under normal conditions but also under error conditions. Unfortunately traditional error handling is based on checkingfunction return values that indicate error states. This makes code ugly and tedious to write. Programmers most often ignore error conditions in the development phase (leave error handling for future work!) which turns code unreliable. Code becomes very complex and hard to maintain. Even with carefull coding, many error conditions are left unhandled. For instance printf() returns the number of characters successfully writen, but no one checks for it. int main() { int *p = (int *)malloc(1000*sizeof(int)); if(p == NULL) { printf( Error Allocating Memory\n ); return -1; FILE *fp = fopen( FILE.TXT, r ); if(fp == NULL) { printf( Error Opening File\n ); free(p); return -2; free(p); fclose(fp); 2

3 C++ Exceptions C++ provides structured error handling (exceptions). You write the code you want to happen in a try section; later in a catch section you write the code to cope with the problems. const int DivideByZero = 10; double divide(double x, double y) { if(y==0) throw DivideByZero; return x/y; int main() { try { divide(10, 0); catch (int i) { if(i==dividebyzero) cerr<<"divide by zero error"; When there is an error the throw keyword interrupts function execution and returns an object to the caller. Anything can be thrown, from built in types to user defined types. The functions exits on a clean way, i.e. temporary objects are destroyed as if the function terminates normally. Code inside the try block is not bloated with error checking, thus more legible and maintainable If no function catches the exception the program terminates. 3

4 Catching Exceptions All arror treatment is done in the catch blocks, depending on the type of the exceptions thrown. An object or reference to a derived class will match an handler to the base class. The catch( ) blockpicksanyexception not found before. If the function cannot treat the exception it should re-throw itto anotherlevel. If no function can treat the error, the program exits. After an exception has been handled the program, execution resumes after the trycatch block. void somefunc(){ try { //somecode that may fail catch (ErrType1 &e1) { //treat exception of type ErrType1 catch (ErrType2 &e2) { //treat exception of type ErrType3 // catch (ErrTypeN &en) { //treat exception of type ErrTypeN catch ( ) //treat default exception { // Exception is not know throw; //re-throw to higher level // Execution resumes here... 4

5 Standard Library Exceptions std::exception The base class for all the exceptions thrown by the C++ standard library. You can ask what( ) and retrieve the optional string with which the exception was initialized. #include <exception> #include <iostream> using namespace std; classmyerr : public exception { public: MyErr(char const*const &msg = ""): exception(msg) { ; int main() { try { throw MyErr("my message"); catch (MyErr& x) { cout << x.what() << endl; 5

6 C++ exception hierarchy 6

7 Error Management in iostream Streams maintain state flags that identify whether I/O was successful and, if not, the reason for the failure: ios::goodbit everything is ok ios::eofbit end-of-file was encountered ios::failbit recoverable error: an I/O operation was not successful ios::badbit fatal error: undefined state State access functions: ios::rdstate() - Returns the stream state flags: ios::eofbit, ios::failbit, ios::badbit, ios::goodbit. ios::eof() - End-of file has been encountered ios::fail() - Format errors have been found but no chars lost (recoverable) ios::bad() - Error with loss of data (nonrecoverable) ios::good() - Is good() if not bad(), fail() and eof(). ios::clear() - Restore stream state Exceptions are disabled by default. To enable them use the member function exceptions(flags) of the object to throw exceptions. Exceptions thrown are objects of the class: std::ios_base::failure #include <iostream> // std::cerr #include <fstream> // std::ifstream int main () { ifstream file; //enable fail() and bad() exceptions in stream file file.exceptions(ifstream::failbit ifstream::badbit); try { file.open ("test.txt"); while (!file.eof()) file.get(); file.close(); catch (ifstream::failure e) { cerr << Exception: << e.what() << endl; return 0; 7

8 The Boost Library General purpose, opensource, multi-platform C++ libraries. Peer reviewed, well documented, currently being included in the C++ Standard Libraries. Useful Libraries in Concurrent Programming: Asio Synchronous and Asynchronous I/O Interprocess Interprocess Communication and Synchronization MPI message passing interfaces sudo apt-get update sudo apt-get install libboost-all-dev 8

9 Boost ASIO Main Concepts Must create at least one io_service object - the link to the operating system's I/O services. YOUR PROGRAM I/O OBJECT I/O objects, such as a serial port, sockets or files, mediate connecting, reading and writing operations : I/O SERVICE Operating System Your program interfaces with the operating system resources via the I/O object or the io_service synchonous or asynchronous calls: (async_)read_some (existing in buffer) (async_)read (fixed amount) (async_)read_until (until delimiter) (async_)read_at (random access streams) (async_)write_some (in buffer) (async_)write (fixed amount) (async_)write_at (random access streams) 9

10 Synchronous Serial Example Compile with g++ V4.7.0 or bigger: g++ -std=c++11 serialread.cpp lpthread lboost_system //SERIALREAD.CPP #include <iostream> #include <boost/asio.hpp> using namespace std; using namespace boost::asio; //SERIALWRITE.CPP #include <iostream> #include <boost/asio.hpp> using namespace std; using namespace boost::asio; int main() { io_service io; //initialize services serial_port sp(io); //create io object boost::system::error_code ec; sp.open( /dev/ttyacm0, ec); //connect to port if( ec ) {cout << Error ; return -1; //set baud rate sp.set_option(serial_port_base::baud_rate(9600),ec); if( ec ) { cout << Error ; return -1; for (;;) { boost::asio::streambuf str; read_until(sp, str, \n ); cout << &str; int main() { io_service io; //initialize services serial_port sp(io); //create io object boost::system::error_code ec; sp.open( /dev/ttyacm0, ec); //connect to port if( ec ) {cout << Error ; return -1; //set baud rate sp.set_option(serial_port_base::baud_rate(9600),ec); if( ec ) { cout << Error ; return -1; for (;;) { string str; getline(cin, str); int nbytes = write(sp, boost::asio::buffer(str)); cout << Wrote << nbytes << bytes to port << endl; 10

11 Boost error handling Boost handles errors via error codes or exceptions. Error code boost::system::error_code Exception boost::system::system_error Functions typically have overloads to accept both cases. //ERROR HANDLING WITH ERROR CODES #include <boost/system/error_code.hpp> #include <boost/asio.hpp> #include <iostream> int main() { io_service io; serial_port sp(io); boost::system::error_code ec; sp.open( /dev/ttyacm0, ec); if(ec) std::cerr << ec.value() << std::endl; //ERROR HANDLING WITH EXCEPTIONS int main() { try { io_service io; serial_port sp(io); sp.open( /dev/ttyacm0 ); catch (boost::system::system_error &e) { boost::system::error_code ec = e.code(); std::cerr << ec.value() << std::endl; 11

12 Boost Synchronous Model 1. Your program initiates the connect operation by calling the I/O object 2. The I/O object forwards the request to the io_service. 3. The io_service calls on the operating system to perform the I/O operation. The program blocks at this point waiting for the execution of the I/O operation. 4. The operating system returns the result of the operation to the io_service. 5. The io_service returns any error in an object of type boost::system::error_code 6. Control returns to your program. 12

13 Boost Asio Stream Buffers boost::asio::buffer( ) is a function that creates a streambuf object that manages raw memory. If can manage POD types (plain old data arrays), vectors of POD and strings. //initialize from char* char d1[128]; auto b1 = boost::asio::buffer(d1); //initialize from char vector std::vector<char> d2(128); auto b2 = boost::asio::buffer(d2); //initialize from char array std::array<char, 128> d3; auto b3 = boost::asio::buffer(d3); 13

14 Boost Asio Communication Functions Boost Asio abstracts communication channels as streams. Streams can be sockets (UDP, TCP, ICMP), serial I/O, files. It provides the following functions to read or write synchronously or asynchronously to streams: async_read(stream, stream_buffer, [completion_test,] completion_handler); read(stream, stream_buffer, [completion_test]); async_write(stream, stream_buffer, [completion_test,] completion_handler); write(stream, stream_buffer, [completion_test]); async_read_until(stream, stream_buffer, delim, completion_handler); read_until(stream, stream_buffer, delim); async_read_at(stream, offset, buffer [, completion_test], completion_handler); read_at(stream, offset, buffer [, completion_test]); async_write_at(stream, offset, buffer [, completion_test], completion_handler) write_at(stream, offset, buffer [, completion_test]) 14

15 Boost Asio Completion Test The completion function is optional. If present, it is called after each successful read, and tells Boost.Asio if the read/write operation is complete (if not, it will continue to read/write); Function prototype is: size_t completion(const boost::system::error_code& err, size_t bytes_transfered) ; Boost.Asio comes with a few helper completion_test functions: transfer_at_least(n) transfer_exactly(n) transfer_all() 15

16 Boost Asio Completion Each read or write operation will end when one of these conditions occur: The supplied buffer is full (for read) or all the data in the buffer has been written (for write). The completion function returns 0 (if you supplied one such function). A delimiter is provided in the (async_)read_until functions (a char, string or regex). An error occurs 16

17 Network Programming with Sockets Sockets are probably the most widely used objects in programming networked communications. What is a socket? To the kernel, a socket is an endpoint of communication: IP address, port number, and protocol (TCP, UDP, etc). To an application, a socket is a file descriptor that lets the application read/write from/to the network Clients and servers communicate with each by reading from and writing to socket. 17

18 The Ethernet Frame-based Technology Ethernet stations communicate by sending each other data packets. Each Ethernet station is given a single 48-bit MAC address, which is used both to specify the destination and the source of each data packet. 18

19 The OSI stack model APDU Application Application Protocol Application 7 PPDU Presentation Presentation Protocol Presentation 6 SPDU Session Session Protocol Session 5 TPDU Transport Trasport Protocol Host-Router communication boundary Transport 4 packet Network Network Network Network 3 Frame Data Link Data Link Data Link Data Link 2 Bit Physical Physical Physical Physical 1 Host-Router internal protocol 19

20 IP Addressing There are two versions of an IP address : IPv4 and IPv6. Because of its prevalence, "IP address" typically refers to those defined by IPv4. Using reserved values for the first octet, network addresses are broken into classes: Class A very large networks (up to 2 24 hosts) Class B large networks (up to 2 16 hosts) Class C small networks (up to 255 hosts) Class D multi-cast messages to multiple hosts Class E addresses not allocated and reserved. 20

21 IP Classes 7 24 Class A: 0 Network ID Host ID Class B: 1 0 Network ID Host ID 21 8 Class C: Network ID Host ID 28 Class D (multicast): Multicast address Class E (reserv ed): unused Class Range within 1st octet Network ID Host ID 27 Possible number of networks Possible number of hosts A a b.c.d ,777,214 B a.b c.d 16,384 65,534 C a.b.c d 2,097,

22 Special Addresses Adapter Loopback Private addresses (will not be routed)

23 Subnet Masking Subnetwork or Subnet is a range of logical addresses within the address space that is assigned to an organization. Subnetworking simplifies routing. Dot-decimal Address Full Network Address Subnet Mask Network Portion Host Portion Binary

24 Address Resolution The Address Resolution Protocol (ARP) is a method for finding a host s hardware address when only its network layer address is known. E.g. IP addresses to MAC addresses. ARP is used in four cases of two hosts communicating: 1. When two hosts are on the same network and one desires to send a packet to the other 2. When two hosts are on different networks and must use a gateway/router to reach the other host 3. When a router needs to forward a packet for one host through another router 4. When a router needs to forward a packet from one host to the destination host on the same network 24

25 Stream Sockets Connection oriented, require handshake Use TCP protocol Local address: IP address and port number. Remote address: IP address and port number. Datagram Sockets Connectionless, low overhead Use UDP protocol Types of Sockets 25

26 Connection-Oriented Model The connection-oriented model is implemented with Stream Sockets using the TCP protocol. TCP provides a variety or error correction and performance features for transmission of byte streams. Implements a client-server architecture. 26

27 Connection Oriented Model Server Listening socket Welcomes some initial contact from a client Connection socket It is created at initial contact of client New socket that is dedicated to the particular client Client Client socket Specify the address of the server process, namely, the IP address of the server and the port number of the process 27

28 Connection-Oriented Model Server Process socket() Client Process socket() bind() listen() accept() get a blocked client read() write() read() 3-way handshake client request server response close notification connect() write() read() close() close() 28

29 Socket Primitives socket() creates a new socket of a certain socket type (tcp,udp), identified by an integer number, and allocates system resources to it. bind() is typically used on the server side, and associates a socket with a socket address structure, i.e. a specified local port number and IP address. listen() is used on the server side, and causes a bound TCP socket to enter listening state. connect() is used on the client side, and assigns a free local port number to a socket. In case of a TCP socket, it causes an attempt to establish a new TCP connection. accept() is used on the server side. It accepts a received incoming attempt to create a new TCP connection from the remote client, and creates a new socket associated with the socket address pair of this connection. send() and recv(), or write() and read(), or sendto() and recvfrom(), are used for sending and receiving data to/from a remote socket. 29

30 Boost Stream Sockets Boost Stream Sockets are part of the ASIO library: #include <boost/asio.hpp> Important classes ip::tcp::acceptor ip::tcp::endpoint ip::tcp::iostream ip::tcp::resolver ip::tcp::socket Important functions socket::socket() acceptor::acceptor() acceptor::accept() ip::tcp::connect() ip::tcp::read() ip::tcp::write() 30

31 //TCPSERVER.CPP #include <boost/asio.hpp> using namespace boost::asio; using ip::tcp; Boost Synchronous TCP Example Compile with g++ V4.7.0 or bigger: g++ -std=c++11 tcpserver.cpp lpthread lboost_system-mt int main() { //initialize services io_service io; //create a listening socket // bind and start listening at port tcp::acceptor acceptor(io, tcp::endpoint(tcp::v4(), 10000)); for (;;) { //create service socket tcp::socket socket(io); //wait client to connect tcp::acceptor.accept(socket); //client isaccessingservice write(socket, buffer( Hello World\n )); //TCPCLIENT.CPP #include <iostream> #include <boost/array.hpp> #include <boost/asio.hpp> using namespace boost::asio; using ip::tcp; int main() { io_service io; boost::system::error_code err; tcp::resolver resolver(io); tcp::resolver::query query( , ); tcp::resolver::iterator endpoint = resolver.resolve(query); tcp::socket socket(io); socket.connect(*endpoint,err); //connect and wait for (;;) { boost::array<char, 128> buf; size_t len = socket.read_some(buffer(buf), err); if (err == error::eof) break; // Closed cleanly by peer. else if (err) std::cout << Unknown Error ; std::cout.write(buf.data(), len); 31

32 Connectionless-Oriented Model The connectionless model uses UDP protocol with no guarantee of delivery. UDP packets may arrive out of order, multiple times, or not at all. UDP hasconsiderably less overhead than TCP Implements a peer-to-peer architecture. 32

33 Connectionless-Oriented Model Server Process socket() bind() Client Process socket() bind() read_from() write_to() request response write_to() read_from() close() close() 33

34 Boost Datagram Sockets Important classes ip::udp::endpoint ip::udp::resolver ip::udp::socket Important functions socket::receive_from() socket::send_to() 34

35 Boost Synchronous UDP Example //UDP SERVER #iinclude <iostream> #include <boost/asio.hpp> using namespace boost::asio; using ip::udp; int main() { io_service io; udp::socket socket(io,udp::endpoint(udp::v4(),10000)); for (;;) { boost::array<char, 1> recv; udp::endpoint client; boost::system::error_code err; //client endpoint retrieved on receive_from socket.receive_from(buffer(recv),client, 0, err); if (err && err!= error::message_size) { std::cout << Error << std::endl; return -1; boost::system::error_code ignored; socket.send_to(buffer( Hello\n ), client, 0, ignored); // UDP CLIENT #iinclude <iostream> #include <boost/asio.hpp> using namespace boost::asio; using ip::udp; int main() { io_service io; udp::resolver resolver(io); udp::resolver::query query(udp::v4(), " ", "10000"); udp::endpoint receiver = *resolver.resolve(query); udp::socket socket(io); socket.open(udp::v4()); boost::array<char, 1> send_buf = {{ 0 ; //send dummy data to initiate communication socket.send_to(buffer(send_buf), receiver); boost::array<char, 128> recv_buf; udp::endpoint sender; size_t len = socket.receive_from( buffer(recv_buf), sender); //write received data to console std::cout.write(recv_buf.data(), len); 35