【开源】C++异步网络框架，希望对感兴趣的同学带来一些启发。

myworkstation

回复 20# cxytz01


    调试程序啊，通常来讲assert会明确的报告错误所在的代码信息（文件名，行号等）。通常用在不可能出错却出错的地方。

AssassinPig

1， sample_server.cc里面 实现 my_client要继承ez_handler, 而my_server : ez_listen_handler， 实在感觉有点突兀
2， 感觉ez_data 跟ez_connection 有共同的on_event，这里不是很明白可不可以直接存个ez_connection的指针算了给epoll_data结构体算了
胡乱说的，LZ明鉴

linux_c_py_php

AssassinPig 发表于 2013-10-26 11:14
1， sample_server.cc里面 实现 my_client要继承ez_handler, 而my_server : ez_listen_handler， 实在感觉有 ...

嗯, 是的, ez_listen_handler可以统一到ez_handler里, 我设计ez_server的时候想过, 但没有落实, 我会考虑统一到ez_handler.

linux_c_py_php

AssassinPig 发表于 2013-10-26 11:14
1， sample_server.cc里面 实现 my_client要继承ez_handler, 而my_server : ez_listen_handler， 实在感觉有 ...

对了,问题2没有回答你, 问题2我想是不可以的.

epoll_ctl修改事件的接口要求必须知道fd已经注册了什么事件, 所以我希望有一个地方可以记录这些信息, 所以这个信息记录在哪里是一个选择.

真正的意义是ez_poll的接口是int fd -> ez_fd *的关系, 而ez_fd是用户资源, 我不希望将属于框架内部的信息暴露在用户可触摸的ez_fd结构中, 尤其是涉及到"延迟删除"的部分的逻辑, 一个用户的资源ez_fd, 而我却依赖它的生命期来做框架内部逻辑的维持, 非常不合理.

如果你亲自去设计, 估计也遇到同样的思考, 做出类似的决定.

自由若水

怎么代码的连接失效了

linux_c_py_php

自由若水 发表于 2014-05-16 15:19
怎么代码的连接失效了

可以看这个：https://code.csdn.net/qq120848369/simple_io/tree/master

tklist

楼主404啊，想围观下代码

zylthinking

我也发一个， 刚写完

1. 
   
2. #include "list_head.h"
   
3. #include "fdset.h"
   
4. #include "fdset_in.h"
   
5. #include "mem.h"
   
6. #include "lock.h"
   
7. #include "now.h"
   
8. #include "mbuf.h"
   
9. #include "utils.h"
   
10. #include "fdctxpool.h"
    
11. #include <unistd.h>
    
12. #include <sys/socket.h>
    
13. #include <sys/epoll.h>
    
14. #include <sys/eventfd.h>
    
15. #include <sys/timerfd.h>
    
16. #include <string.h>
    
17. 
    
18. #define epoll_mask(x) (x | EPOLLONESHOT | EPOLLET)
    
19. #define stat_ready 0
    
20. #define stat_busy 1
    
21. 
    
22. typedef struct tag_fdset {
    
23.     int fd, efd, tfd;
    
24.     int threads;
    
25.     int fdctx_lck, timer_lck;
    
26.     struct list_head fdctx_head;
    
27.     struct list_head timer_head;
    
28. } fdset;
    
29. 
    
30. typedef struct tag_timer_notify {
    
31.     uint32_t id;
    
32.     uint32_t tms;
    
33.     fd_contex* fdctx;
    
34.     struct list_head fdset_entry;
    
35.     struct list_head fdctx_entry;
    
36. } timer_notify;
    
37. 
    
38. struct my_buffer* buffer_reserve(fd_contex* fdctx, uint32_t bytes)
    
39. {
    
40.     struct my_buffer* mbuf = NULL;
    
41.     if (fdctx->read_mbuf != NULL) {
    
42.         mbuf = fdctx->read_mbuf;
    
43.         fdctx->read_mbuf = NULL;
    
44.     } else {
    
45.         mbuf = mbuf_alloc_2(bytes);
    
46.     }
    
47.     return mbuf;
    
48. }
    
49. 
    
50. static int io_read(fd_contex* fdctx)
    
51. {
    
52.     int n, error = 0;
    
53.     struct fd_struct* fds = fdctx->fds;
    
54.     struct my_buffer* mbuf = NULL;
    
55. 
    
56.     if (fds->bytes > 0) {
    
57. LABEL:
    
58.         mbuf = buffer_reserve(fdctx, fds->bytes);
    
59.         if (mbuf != NULL) {
    
60.             if (fds->tcp0_udp1 == 0) {
    
61.                 n = do_tcp_read(fds->fd, mbuf);
    
62.                 if (n == -1) {
    
63.                     error = errno;
    
64.                 }
    
65.             } else {
    
66.                 n = do_udp_read(fds->fd, mbuf);
    
67.                 if (n == -1) {
    
68.                     error = EAGAIN;
    
69.                 }
    
70.             }
    
71.         } else {
    
72.             error = ENOMEM;
    
73.         }
    
74.     }
    
75. 
    
76.     if (error != EWOULDBLOCK && error != EAGAIN) {
    
77.         n = fds->read(fds, mbuf, error);
    
78.         if (n > 0) {
    
79.             fds->bytes = n;
    
80.             goto LABEL;
    
81.         }
    
82.     } else {
    
83.         fds->bytes = mbuf->length;
    
84.         fdctx->read_mbuf = mbuf;
    
85.         n = 0;
    
86.     }
    
87.     return n;
    
88. }
    
89. 
    
90. static int io_write(fd_contex* fdctx)
    
91. {
    
92.     int n;
    
93.     struct sockaddr_in* in;
    
94.     fdctx->fds->mask &= (~EPOLLOUT);
    
95.     struct my_buffer* mbuf = NULL;
    
96. 
    
97.     while (1) {
    
98.         if (fdctx->write_mbuf != NULL) {
    
99.             mbuf = fdctx->write_mbuf;
    
100.             fdctx->write_mbuf = NULL;
     
101.         } else {
     
102.             mbuf = fdctx->fds->write(fdctx->fds, &in);
     
103.         }
     
104. 
     
105.         if (mbuf == NULL) {
     
106.             break;
     
107.         }
     
108. 
     
109.         if (fdctx->fds->tcp0_udp1 == 0) {
     
110.             n = do_tcp_write(fdctx->fds->fd, mbuf);
     
111.         } else {
     
112.             n = do_udp_write(fdctx->fds->fd, mbuf, in);
     
113.         }
     
114. 
     
115.         if (mbuf->length != 0) {
     
116.             fdctx->write_mbuf = mbuf;
     
117.             fdctx->fds->mask |= EPOLLOUT;
     
118.             break;
     
119.         }
     
120.         mbuf->mop->free(mbuf);
     
121.     }
     
122.     return n;
     
123. }
     
124. 
     
125. static int io_proc(fd_contex* fdctx, uint32_t mask)
     
126. {
     
127.     int n = 0;
     
128.     struct fd_struct* fds = fdctx->fds;
     
129. 
     
130.     if (mask & (EPOLLERR | EPOLLHUP)) {
     
131.         fds->read(fds, NULL, EBADF);
     
132.         return -1;
     
133.     }
     
134. 
     
135.     if (mask & (EPOLLIN | EPOLLPRI)) {
     
136.         n = io_read(fdctx);
     
137.         if (n == -1) {
     
138.             return -1;
     
139.         }
     
140.     }
     
141. 
     
142.     if (mask & EPOLLRDHUP) {
     
143.         n = fds->read(fds, NULL, ESHUTDOWN);
     
144.         if (n == -1) {
     
145.             return -1;
     
146.         }
     
147.     }
     
148. 
     
149.     if (mask & EPOLLOUT) {
     
150.         n = io_write(fdctx);
     
151.     }
     
152. 
     
153.     fdctx->ev.events = epoll_mask(fdctx->fds->mask);
     
154.     if (n == -1) {
     
155.         n = fds->read(fds, NULL, errno);
     
156.     }
     
157.     return n;
     
158. }
     
159. 
     
160. static void timer_expires(fdset* fset)
     
161. {
     
162.     fd_contex* fdctx;
     
163.     uint32_t tms = now();
     
164.     LIST_HEAD(head);
     
165.     struct list_head* ent;
     
166. 
     
167.     lock(&fset->timer_lck);
     
168.     for (ent = fdctx->timer_head.next; ent != &fdctx->timer_head; ent = ent->next) {
     
169.         timer_notify* notify = list_entry(ent, timer_notify, fdset_entry);
     
170.         if (notify->tms > tms) {
     
171.             break;
     
172.         }
     
173. 
     
174.         fdctx = notify->fdctx;
     
175.         handle_clone(fdctx->self);
     
176. 
     
177.         list_del_init(&notify->fdset_entry);
     
178.         list_del(&notify->fdctx_entry);
     
179.         list_add(&notify->fdctx_entry, &head);
     
180.     }
     
181.     unlock(&fset->timer_lck);
     
182. 
     
183.     while (!list_empty(&head)) {
     
184.         timer_notify* notify = list_entry(head.next, timer_notify, fdctx_entry);
     
185.         list_del(head.next);
     
186. 
     
187.         fdctx = notify->fdctx;
     
188.         fdctx->fds->notify(fdctx->fds, notify->id);
     
189.         handle_release(fdctx->self);
     
190.         my_free(notify);
     
191.     }
     
192. }
     
193. 
     
194. static void looper(void* any, int fd, int efd)
     
195. {
     
196.     struct epoll_event events;
     
197.     my_handle* handle = (my_handle *) any;
     
198. 
     
199.     while (1) {
     
200.         int nr = epoll_wait(fd, &events, 1, -1);
     
201.         fdset* fset = (fdset *) handle_get(handle);
     
202.         if (__builtin_expect(fset == NULL, 0)) {
     
203.             break;
     
204.         }
     
205. 
     
206.         if (__builtin_expect(nr == 1, 1)) {
     
207.             fd_contex* fdctx = (fd_contex *) events.data.ptr;
     
208.             if (__builtin_expect(fdctx != NULL, 1)) {
     
209.                 lock(&fdctx->busy_lck);
     
210.                 int stat = __sync_val_compare_and_swap(&fdctx->stat, stat_ready, stat_busy);
     
211.                 unlock(&fdctx->busy_lck);
     
212. 
     
213.                 if (stat == stat_ready) {
     
214.                     handle_get(fdctx->self);
     
215.                     while (fdctx->busy);
     
216.                     fdctx->ev.events = 0;
     
217. 
     
218.                     nr = io_proc(fdctx, events.events);
     
219.                     if (nr != -1) {
     
220.                         epoll_ctl(fd, EPOLL_CTL_MOD, fdctx->fds->fd, &fdctx->ev);
     
221.                     }
     
222.                     fdctx->stat = stat_ready;
     
223.                     handle_put(fdctx->self);
     
224.                 }
     
225.             } else {
     
226.                 timer_expires(fset);
     
227.             }
     
228.         } else if (nr != -1 || EINTR != errno) {
     
229.             printf("what's up? n = %d, errno = %d\n", nr, errno);
     
230.         }
     
231. 
     
232.         handle_put(handle);
     
233.     }
     
234. 
     
235.     int n = handle_release(handle);
     
236.     if (n == 0) {
     
237.         epoll_ctl(fd, EPOLL_CTL_DEL, efd, NULL);
     
238.         close(efd);
     
239.         close(fd);
     
240.     }
     
241. }
     
242. 
     
243. static void fset_delete(void* addr)
     
244. {
     
245.     fdset* fset = (fdset *) addr;
     
246.     epoll_ctl(fset->fd, EPOLL_CTL_DEL, fset->tfd, NULL);
     
247.     close(fset->tfd);
     
248. 
     
249.     while (!list_empty(&fset->timer_head)) {
     
250.         struct list_head* ent = fset->timer_head.next;
     
251.         list_del_init(ent);
     
252.     }
     
253. 
     
254.     while (!list_empty(&fset->fdctx_head)) {
     
255.         struct list_head* ent = fset->fdctx_head.next;
     
256.         list_del(ent);
     
257.         fd_contex* fdctx = list_entry(ent, fd_contex, set_entry);
     
258.         epoll_ctl(fset->fd, EPOLL_CTL_DEL, fdctx->fds->fd, NULL);
     
259.         handle_dettach(fdctx->self);
     
260.     }
     
261. 
     
262.     if (fset->threads != 0) {
     
263.         uint64_t n = 1;
     
264.         write(fset->efd, &n, sizeof(n));
     
265.     } else {
     
266.         epoll_ctl(fset->fd, EPOLL_CTL_DEL, fset->efd, NULL);
     
267.         close(fset->efd);
     
268.         close(fset->fd);
     
269.     }
     
270.     my_free(fset);
     
271. }
     
272. 
     
273. int fdset_join(void* set)
     
274. {
     
275.     my_handle* hset = (my_handle *) set;
     
276.     fdset* fset = (fdset *) handle_get(hset);
     
277.     if (fset == NULL) {
     
278.         errno = -EBADF;
     
279.         return -1;
     
280.     }
     
281. 
     
282.     int fd = fset->fd;
     
283.     int efd = fset->efd;
     
284.     __sync_add_and_fetch(&fset->threads, 1);
     
285. 
     
286.     handle_clone(hset);
     
287.     handle_put(hset);
     
288.     looper(hset, fd, efd);
     
289.     return 0;
     
290. }
     
291. 
     
292. void* fdset_new(uint32_t size)
     
293. {
     
294.     struct epoll_event event;
     
295.     int tfd = timerfd_create(CLOCK_MONOTONIC, 0);
     
296.     if (tfd == -1) {
     
297.         return NULL;
     
298.     }
     
299. 
     
300.     struct itimerspec timerspec = {
     
301.         .it_interval = {0, 0},
     
302.         .it_value = {0, 0}
     
303.     };
     
304.     int n = timerfd_settime(tfd, 0, &timerspec, NULL);
     
305.     if (n == -1) {
     
306.         goto LABEL5;
     
307.     }
     
308. 
     
309.     int fd = epoll_create(size);
     
310.     if (fd == -1) {
     
311.         goto LABEL5;
     
312.     }
     
313. 
     
314.     event.events = epoll_mask(EPOLLIN);
     
315.     event.data.ptr = NULL;
     
316.     n = epoll_ctl(fd, EPOLL_CTL_ADD, tfd, &event);
     
317.     if (n == -1) {
     
318.         goto LABEL4;
     
319.     }
     
320. 
     
321.     int efd = eventfd(0, 0);
     
322.     if (efd == -1) {
     
323.         goto LABEL3;
     
324.     }
     
325. 
     
326.     event.data.fd = fd;
     
327.     event.events = EPOLLIN;
     
328.     n = epoll_ctl(fd, EPOLL_CTL_ADD, efd, &event);
     
329.     if (n == -1) {
     
330.         goto LABEL2;
     
331.     }
     
332. 
     
333.     errno = -ENOMEM;
     
334.     fdset* fset = (fdset *) my_malloc(sizeof(fdset));
     
335.     if (fset == NULL) {
     
336.         goto LABEL1;
     
337.     }
     
338. 
     
339.     my_handle* handle = handle_attach(fset, fset_delete);
     
340.     if (handle == NULL) {
     
341.         goto LABEL0;
     
342.     }
     
343. 
     
344.     INIT_LIST_HEAD(&fset->fdctx_head);
     
345.     INIT_LIST_HEAD(&fset->timer_head);
     
346.     fset->fdctx_lck = 0;
     
347.     fset->timer_lck = 0;
     
348.     fset->fd = fd;
     
349.     fset->efd = efd;
     
350.     fset->threads = 0;
     
351.     fset->tfd = tfd;
     
352.     return (void *) handle;
     
353. 
     
354. LABEL0:
     
355.     my_free(fset);
     
356. LABEL1:
     
357.     epoll_ctl(fd, EPOLL_CTL_DEL, efd, NULL);
     
358. LABEL2:
     
359.     close(efd);
     
360. LABEL3:
     
361.     epoll_ctl(fd, EPOLL_CTL_DEL, tfd, NULL);
     
362. LABEL4:
     
363.     close(fd);
     
364. LABEL5:
     
365.     close(tfd);
     
366.     return NULL;
     
367. }
     
368. 
     
369. static void unlink_from_fdset(fdset* fset, fd_contex* fdctx)
     
370. {
     
371.     lock(&fset->fdctx_lck);
     
372.     list_del(&fdctx->set_entry);
     
373.     unlock(&fset->fdctx_lck);
     
374. 
     
375.     struct list_head* ent = fdctx->timer_head.next;
     
376.     if (!list_empty(ent)) {
     
377.         lock(&fset->timer_lck);
     
378.         for (; ent != &fdctx->timer_head; ent = ent->next) {
     
379.             timer_notify* notify = list_entry(ent, timer_notify, fdctx_entry);
     
380.             list_del_init(&notify->fdset_entry);
     
381.         }
     
382.         unlock(&fset->timer_lck);
     
383.     }
     
384. 
     
385.     struct fd_struct* fds = fdctx->fds;
     
386.     epoll_ctl(fset->fd, EPOLL_CTL_DEL, fds->fd, NULL);
     
387. }
     
388. 
     
389. static void fd_contex_free(void* addr)
     
390. {
     
391.     fd_contex* fdctx = (fd_contex *) addr;
     
392.     while (1) {
     
393.         int stat = __sync_val_compare_and_swap(&fdctx->stat, stat_ready, stat_busy);
     
394.         if (stat == stat_ready) {
     
395.             break;
     
396.         }
     
397.         sched_yield();
     
398.     }
     
399. 
     
400.     int need_notify = 1;
     
401.     fdset* fset = (fdset *) handle_get(fdctx->hset);
     
402.     if (fset != NULL) {
     
403.         if (!list_empty(&fdctx->set_entry)) {
     
404.             unlink_from_fdset(fset, fdctx);
     
405.         } else {
     
406.             need_notify = 0;
     
407.         }
     
408.         handle_release(fdctx->self);
     
409.         handle_put(fdctx->hset);
     
410.     }
     
411.     handle_release(fdctx->hset);
     
412. 
     
413.     while (!list_empty(&fdctx->timer_head)) {
     
414.         struct list_head* ent = fdctx->timer_head.next;
     
415.         list_del(ent);
     
416.         timer_notify* notify = list_entry(ent, timer_notify, fdctx_entry);
     
417.         my_free(notify);
     
418.     }
     
419. 
     
420.     if (need_notify == 1) {
     
421.         struct fd_struct* fds = fdctx->fds;
     
422.         fds->detach(fds);
     
423.     }
     
424. 
     
425.     if (fdctx->read_mbuf != NULL) {
     
426.         fdctx->read_mbuf->mop->free(fdctx->read_mbuf);
     
427.     }
     
428. 
     
429.     if (fdctx->write_mbuf != NULL) {
     
430.         fdctx->write_mbuf->mop->free(fdctx->write_mbuf);
     
431.     }
     
432.     fd_contex_put(fdctx);
     
433. }
     
434. 
     
435. my_handle* fdset_attach_fd(void* set, struct fd_struct* fds)
     
436. {
     
437.     if (fds->fd == -1) {
     
438.         errno = -EINVAL;
     
439.         return NULL;
     
440.     }
     
441. 
     
442.     if (-1 == make_none_block(fds->fd)) {
     
443.         return NULL;
     
444.     }
     
445. 
     
446.     my_handle* hset = (my_handle *) set;
     
447.     fdset* fset = (fdset *) handle_get(hset);
     
448.     if (fset == NULL) {
     
449.         errno = -EBADF;
     
450.         return NULL;
     
451.     }
     
452.     errno = -ENOMEM;
     
453. 
     
454.     fd_contex* fdctx = fd_contex_get();
     
455.     if (fdctx == NULL) {
     
456.         handle_put(hset);
     
457.         return NULL;
     
458.     }
     
459. 
     
460.     my_handle* handle = handle_attach(fdctx, fd_contex_free);
     
461.     if (handle == NULL) {
     
462.         fd_contex_put(fdctx);
     
463.         handle_put(hset);
     
464.         return NULL;
     
465.     }
     
466. 
     
467.     handle_clone(handle);
     
468.     fdctx->self = handle;
     
469.     handle_clone(hset);
     
470.     fdctx->hset = hset;
     
471. 
     
472.     fdctx->fds = fds;
     
473.     fdctx->read_mbuf = NULL;
     
474.     fdctx->write_mbuf = NULL;
     
475.     fdctx->busy = 0;
     
476.     fdctx->busy_lck = 0;
     
477.     INIT_LIST_HEAD(&fdctx->set_entry);
     
478.     INIT_LIST_HEAD(&fdctx->timer_head);
     
479. 
     
480.     fdctx->ev.events = epoll_mask(fds->mask);
     
481.     fdctx->ev.data.ptr = fdctx;
     
482. 
     
483.     int n = epoll_ctl(fset->fd, EPOLL_CTL_ADD, fds->fd, &fdctx->ev);
     
484.     if (-1 == n) {
     
485.         handle_release(handle);
     
486.         handle_dettach(handle);
     
487.         handle = NULL;
     
488.     } else {
     
489.         lock(&fset->fdctx_lck);
     
490.         list_add(&fdctx->set_entry, &fset->fdctx_head);
     
491.         unlock(&fset->fdctx_lck);
     
492.         fdctx->stat = stat_ready;
     
493.     }
     
494.     handle_put(hset);
     
495.     return handle;
     
496. }
     
497. 
     
498. void fdset_delete(void* hset)
     
499. {
     
500.     handle_dettach((my_handle *) hset);
     
501. }
     
502. 
     
503. int fdset_update_fdmask(my_handle* handle)
     
504. {
     
505.     errno = -EBADF;
     
506.     fd_contex* fdctx = (fd_contex *) handle_get(handle);
     
507.     if (fdctx == NULL) {
     
508.         return -1;
     
509.     }
     
510. 
     
511.     fdset* fset = (fdset *) handle_get(fdctx->hset);
     
512.     if (fset == NULL) {
     
513.         handle_put(handle);
     
514.         return -1;
     
515.     }
     
516. 
     
517.     struct fd_struct* fds = fdctx->fds;
     
518.     lock(&fdctx->busy_lck);
     
519.     fdctx->busy = 1;
     
520.     unlock(&fdctx->busy_lck);
     
521. 
     
522.     uint32_t old_mask = fdctx->ev.events;
     
523.     uint32_t new_mask = epoll_mask(fds->mask);
     
524. 
     
525.     if (old_mask == new_mask || fdctx->stat == stat_busy) {
     
526.         fdctx->busy = 0;
     
527.         handle_put(fdctx->hset);
     
528.         handle_put(handle);
     
529.         return 0;
     
530.     }
     
531. 
     
532.     fdctx->ev.events = new_mask;
     
533.     int n = epoll_ctl(fset->fd, EPOLL_CTL_MOD, fds->fd, &fdctx->ev);
     
534.     if (n == -1) {
     
535.         fdctx->ev.events = old_mask;
     
536.     }
     
537.     fdctx->busy = 0;
     
538. 
     
539.     handle_put(fdctx->hset);
     
540.     handle_put(handle);
     
541.     return n;
     
542. }
     
543. 
     
544. static int fdset_add_timer(fdset* fset, timer_notify* notify, uint32_t ms)
     
545. {
     
546.     struct list_head* ent;
     
547.     lock(&fset->timer_lck);
     
548.     for (ent = fset->timer_head.prev; ent != &fset->timer_head; ent = ent->prev) {
     
549.         timer_notify* cur = list_entry(ent, timer_notify, fdset_entry);
     
550.         if (cur->tms <= notify->tms) {
     
551.             break;
     
552.         }
     
553.     }
     
554. 
     
555.     int n = 0;
     
556.     if (ent == &fset->timer_head) {
     
557.         struct itimerspec timerspec;
     
558. 
     
559.         timerspec.it_value.tv_sec = ms / 1000;
     
560.         timerspec.it_value.tv_nsec = (ms - timerspec.it_value.tv_sec * 1000) * 1000000;
     
561.         timerspec.it_interval.tv_sec = 0;
     
562.         timerspec.it_interval.tv_nsec = 0;
     
563.         n = timerfd_settime(fset->tfd, 0, &timerspec, NULL);
     
564.     }
     
565. 
     
566.     if (n == 0) {
     
567.         list_add(&notify->fdset_entry, ent);
     
568.     }
     
569.     unlock(&fset->timer_lck);
     
570.     return n;
     
571. }
     
572. 
     
573. int fdset_sched(my_handle* handle, uint32_t ms, uint32_t id)
     
574. {
     
575.     fd_contex* fdctx = (fd_contex *) handle_get(handle);
     
576.     if (fdctx == NULL) {
     
577.         errno = -EBADF;
     
578.         return -1;
     
579.     }
     
580.     fdset* fset = (fdset *) handle_get(fdctx->hset);
     
581.     assert(fset != NULL);
     
582. 
     
583.     int n = -1;
     
584.     errno = -ENOMEM;
     
585.     timer_notify* notify = (timer_notify *) my_malloc(sizeof(timer_notify));
     
586.     if (notify != NULL) {
     
587.         notify->id = id;
     
588.         notify->tms = now() + ms;
     
589.         notify->fdctx = fdctx;
     
590.         list_add(&notify->fdctx_entry, &fdctx->timer_head);
     
591.         n = fdset_add_timer(fset, notify, ms);
     
592.         if (n == -1) {
     
593.             my_free(notify);
     
594.         } else {
     
595.             handle_clone(handle);
     
596.         }
     
597.     }
     
598. 
     
599.     handle_put(fdctx->hset);
     
600.     handle_put(handle);
     
601.     return n;
     
602. }
     
603. 
     
604. struct fd_struct* fd_struct_from(void* any)
     
605. {
     
606.     if (any == NULL) {
     
607.         return NULL;
     
608.     }
     
609. 
     
610.     fd_contex* fdctx = (fd_contex *) any;
     
611.     struct fd_struct* fds = fdctx->fds;
     
612.     return fds;
     
613. }
     

复制代码

linux_c_py_php 发表于 2014-05-17 13:11
可以看这个：https://code.csdn.net/qq120848369/simple_io/tree/master

wgzh1615

想看看，学习学习

yulihua49

linux_c_py_php 发表于 2013-10-23 16:37
发布一个源创的linux C++异步网络框架, 基于工作需求，偏重工程实践。

开发者不需关心 连接，监听，以及 ...

发现epoll有惊群，即使使用了EPOLLONESHOT。
很偶然，今天又被扑捉到一次。程序新增的防惊群代码：

1. 
   
2.             fds = epoll_wait(g_epoll_fd, &event, 1 , -1);
   
3.             if(fds < 0){
   
4.                     ShowLog(1,"%s:epoll_wait err=%d,%s",__FUNCTION__,errno,strerror(errno));
   
5.                 usleep(30000000);
   
6.                 continue;
   
7.                 }
   
8.             task = (TCB *)event.data.ptr;
   
9.             if(task->events) {//在加入epoll前清0
   
10.                 ShowLog(1,"%s:task->events=%08X,conflict!",__FUNCTION__,task->events);//发现惊群
    
11.                 continue;//丢掉它
    
12.             }
    
13.             task->events=event.events;
    

复制代码