Poll function of--I/O multiplexing for Linux network programming

First, review the previous Select

Select Advantages:

currently supported on almost all platforms, and its good cross-platform support is one of its advantages

Select Cons:

1. Each call to select () requires that the FD collection be copied from the user state to the kernel state, which is very expensive when FD is very large, and each call to select () requires the kernel to traverse all the FD that is passed in, which is also very expensive in FD.

2. There is a maximum limit on the number of file descriptors that a single process can monitor, typically 1024 on Linux, which can be improved by modifying the macro definition or even recompiling the kernel, but this also results in reduced efficiency

Ii. Overview of poll functions

Like the essence of the Select () and poll () system calls, the mechanism of poll () is similar to select (), with no significant difference in nature with select (), and the management of multiple descriptors is also polling, which is handled according to the state of the descriptor, but poll () There is no limit to the maximum number of file descriptors (but performance is also degraded if the number is too large). The disadvantage of poll () and select () is that an array containing a large number of file descriptors is copied in between the user state and the kernel's address space, regardless of whether the file descriptor is ready, and its overhead increases linearly as the number of file descriptors increases. The poll () function describes the header file: [CSharp]View Plain Copy

1. #include <poll.h>

function Body: [CSharp]View Plain Copy

1. int poll (struct POLLFD *fds, nfds_t nfds, int timeout);

Features:

Monitor and wait for property changes for multiple file descriptors

Parameters:

FDS: A pointer to the NO. 0 element of a struct array, each of which is a struct POLLFD structure that specifies the condition for testing a given FD

 

[CSHARP]  view plain  copy  

1. STRUCT&NBSP;POLLFD{&NBSP;&NBSP;
2.     int  fd;         //file descriptor   
3.     short events;    //waiting event   
4.     short revents;  //the events actually occurred   
5. };&NBSP;&NBSP;

FD: Each pollfd struct specifies a monitored file descriptor that can pass multiple structures, indicating that poll () monitors multiple file descriptors.

Events: Specifies the event (input, output, error) that monitors FD, with multiple values for each event, as follows:

The Revents:revents field is the action result event for the file descriptor, and the kernel sets the field when the call returns. Any events requested in the events domain may be returned in the revents domain.

Note: The events field of each struct is set by the user, telling the kernel what we are interested in, and the revents domain is the kernel set at the time of the return to indicate what happened to the descriptor.

Nfds: Used to specify the number of elements in the first parameter array

Timeout: Specifies the number of milliseconds to wait for poll () to return, regardless of whether I/O is ready.

return value:

On success, poll () returns the number of file descriptors that are not 0 in the Revents field in the struct, or poll () returns 0 if no events occur before the timeout;

On Failure, poll () returns 1 and sets errno to one of the following values:

EBADF: Invalid file descriptor specified in one or more structs.

The address that the Efault:fds pointer points to exceeds the address space of the process.

EINTR: The requested event generates a signal before the call can be re-initiated.

The Einval:nfds parameter exceeds the Plimit_nofile value.

Enomem: There is not enough memory available to complete the request.

Iii. Examples of poll example

Implement UDP to send and receive code with poll: [CSharp]View Plain Copy

2. #include <string.h>
4. #include <stdio.h>
6. #include <stdlib.h>
8. #include <unistd.h>
10. #include <sys/select.h>
12. #include <sys/time.h>
14. #include <sys/socket.h>
16. #include <netinet/in.h>
18. #include <arpa/inet.h>
20. #include <poll.h>
24. int main (int argc,char *argv[])
26. {
28. int udpfd = 0;
30. int ret = 0;
32. struct POLLFD fds[2]; //Monitor file Description structure array: 2 x
34. struct sockaddr_in saddr;
36. struct sockaddr_in caddr;
40. Bzero (&saddr,sizeof (SADDR));
42. saddr.sin_family = af_inet;
44. Saddr.sin_port = htons (8000);
46. SADDR.SIN_ADDR.S_ADDR = htonl (Inaddr_any);
50. Bzero (&caddr,sizeof (CADDR));
52. caddr.sin_family = af_inet;
54. Caddr.sin_port = htons (8000);
58. //Create sockets
60. if ((UDPFD = socket (af_inet,sock_dgram, 0)) < 0)
62. {
64. Perror ("socket error");
66. Exit (-1);
68. }
72. //Socket Port binding
74. if (Bind (UDPFD, (struct sockaddr*) &saddr, sizeof (SADDR))! = 0)
76. {
78. Perror ("bind error");
80. Close (UDPFD);
82. Exit (-1);
84. }
88. printf ("input: \" Sayto 192.168.220.x\ "to Sendmsg to somebody\033[32m\n");
90. FDS[0].FD = 0; //Standard input descriptor
92. FDS[1].FD = UDPFD; //UDP Descriptor
96. Fds[0].events = Pollin; //Normal or priority with data- readable
98. Fds[1].events = Pollin; //Normal or priority with data- readable
102. While (1)
104. {
106. //monitor and wait for multiple files (standard input, UDP socket) Descriptor property changes (readable)
108. //No attribute changes, this function blocks until a change is performed, no timeout is set here
110. RET = Poll (FDS, 2,-1);
114. Write (1,"UDPQQ:", 6);
118. if (ret = =-1) { //error
120. Perror ("poll ()");
122. }
124. Else if (Ret > 0) { //prepared file descriptor
126. char buf[100] = {0};
128. if ((fds[0].revents & pollin) = = Pollin) { //Standard input
132. Fgets (buf, sizeof (BUF), stdin);
134. Buf[strlen (BUF)-1] = ' + ';
136. if (strncmp (buf, "Sayto", 5) = = 0)
138. {
140. char ipbuf[16] = "";
142. Inet_pton (Af_inet, buf+6, &caddr.sin_addr);  //Assign a value to the addr socket address.
144. printf ("\rsay to%s\n", Inet_ntop (Af_inet,&caddr.sin_addr,ipbuf,sizeof (IPBUF)));
146. continue;
148. }
150. Else if (strcmp (buf, "exit") ==0)
152. {
154. Close (UDPFD);
156. Exit (0);
158. }
160. SendTo (UDPFD, buf, strlen (BUF), 0, (struct sockaddr*) &caddr, sizeof (CADDR));
164. }
166. Else if ((fds[1].revents & pollin) = = Pollin) { //udp socket
168. struct sockaddr_in addr;
170. char Ipbuf[inet_addrstrlen] = "";
172. socklen_t Addrlen = sizeof (addr);
176. Bzero (&addr,sizeof (addr));
180. Recvfrom (UDPFD, buf, 0, (struct sockaddr*) &addr, &addrlen);
182. printf ("\r\033[31m[%s]:\033[32m%s\n", Inet_ntop (Af_inet,&addr.sin_addr,ipbuf,sizeof (IPBUF)), buf);
184. }
188. }
190. Else if (0 = = ret) { //timeout
192. printf ("Time out\n");
194. }
196. }
200. return 0;
202. }

Operation Result:

Poll function of--I/O multiplexing for Linux network programming