libev/ev.c

#include <math.h>
#include <stdlib.h>

#include <stdio.h>

#include <errno.h>
#include <sys/time.h>
#include <time.h>

#ifdef CLOCK_MONOTONIC
# define HAVE_MONOTONIC 1
#endif

#define HAVE_EPOLL 1
#define HAVE_REALTIME 1
#define HAVE_SELECT 0

#define MAX_BLOCKTIME 60.

#include "ev.h"

struct ev_watcher {
  EV_WATCHER (ev_watcher);
};

struct ev_watcher_list {
  EV_WATCHER_LIST (ev_watcher_list);
};

ev_tstamp ev_now;
int ev_method;

static int have_monotonic; /* runtime */

static ev_tstamp method_fudge; /* stupid epoll-returns-early bug */
static void (*method_reify)(void);
static void (*method_poll)(ev_tstamp timeout);

ev_tstamp
ev_time (void)
{
#if HAVE_REALTIME
  struct timespec ts;
  clock_gettime (CLOCK_REALTIME, &ts);
  return ts.tv_sec + ts.tv_nsec * 1e-9;
#else
  struct timeval tv;
  gettimeofday (&tv, 0);
  return tv.tv_sec + tv.tv_usec * 1e-6;
#endif
}

static ev_tstamp
get_clock (void)
{
#if HAVE_MONOTONIC
  if (have_monotonic)
    {
      struct timespec ts;
      clock_gettime (CLOCK_MONOTONIC, &ts);
      return ts.tv_sec + ts.tv_nsec * 1e-9;
    }
#endif

  return ev_time ();
}

#define array_needsize(base,cur,cnt,init)               \
  if ((cnt) > cur)                                      \
    {                                                   \
      int newcnt = cur;                                 \
      do                                                \
        {                                               \
          newcnt += (newcnt >> 1) + 16;                 \
        }                                               \
      while ((cnt) > newcnt);                           \
      fprintf (stderr, "resize(" # base ") from %d to %d\n", cur, newcnt);\
      base = realloc (base, sizeof (*base) * (newcnt)); \
      init (base + cur, newcnt - cur);                  \
      cur = newcnt;                                     \
    }

typedef struct
{
  struct ev_io *head;
  unsigned char wev, rev; /* want, received event set */
} ANFD;

static ANFD *anfds;
static int anfdmax;

static int *fdchanges;
static int fdchangemax, fdchangecnt;

static void
anfds_init (ANFD *base, int count)
{
  while (count--)
    {
      base->head = 0;
      base->wev = base->rev = EV_NONE;
      ++base;
    }
}

typedef struct
{
  struct ev_watcher *w;
  int events;
} ANPENDING;

static ANPENDING *pendings;
static int pendingmax, pendingcnt;

static void
event (struct ev_watcher *w, int events)
{
  w->pending = ++pendingcnt;
  array_needsize (pendings, pendingmax, pendingcnt, );
  pendings [pendingcnt - 1].w      = w;
  pendings [pendingcnt - 1].events = events;
}

static void
fd_event (int fd, int events)
{
  ANFD *anfd = anfds + fd;
  struct ev_io *w;

  for (w = anfd->head; w; w = w->next)
    {
      int ev = w->events & events;

      if (ev)
        event ((struct ev_watcher *)w, ev);
    }
}

static struct ev_timer **timers;
static int timermax, timercnt;

static void
upheap (int k)
{
  struct ev_timer *w = timers [k];

  while (k && timers [k >> 1]->at > w->at)
    {
      timers [k] = timers [k >> 1];
      timers [k]->active = k + 1;
      k >>= 1;
    }

  timers [k] = w;
  timers [k]->active = k + 1;

}

static void
downheap (int k)
{
  struct ev_timer *w = timers [k];

  while (k <= (timercnt >> 1))
    {
      int j = k << 1;

      if (j + 1 < timercnt && timers [j]->at > timers [j + 1]->at)
        ++j;

      if (w->at <= timers [j]->at)
        break;

      timers [k] = timers [j];
      timers [k]->active = k;
      k = j;
    }

  timers [k] = w;
  timers [k]->active = k + 1;
}

static struct ev_signal **signals;
static int signalmax, signalcnt;

static void
signals_init (struct ev_signal **base, int count)
{
  while (count--)
    *base++ = 0;
}

#if HAVE_EPOLL
# include "ev_epoll.c"
#endif
#if HAVE_SELECT
# include "ev_select.c"
#endif

int ev_init (int flags)
{
#if HAVE_MONOTONIC
  {
    struct timespec ts;
    if (!clock_gettime (CLOCK_MONOTONIC, &ts))
      have_monotonic = 1;
  }
#endif

  ev_now = ev_time ();

#if HAVE_EPOLL
  if (epoll_init (flags))
    return ev_method;
#endif
#if HAVE_SELECT
  if (select_init (flags))
    return ev_method;
#endif

  ev_method = EVMETHOD_NONE;
  return ev_method;
}

void ev_prefork (void)
{
}

void ev_postfork_parent (void)
{
}

void ev_postfork_child (void)
{
#if HAVE_EPOLL
  epoll_postfork_child ();
#endif
}

static void
call_pending ()
{
  int i;

  for (i = 0; i < pendingcnt; ++i)
    {
      ANPENDING *p = pendings + i;

      if (p->w)
        {
          p->w->pending = 0;
          p->w->cb (p->w, p->events);
        }
    }

  pendingcnt = 0;
}

static void
timer_reify (void)
{
  while (timercnt && timers [0]->at <= ev_now)
    {
      struct ev_timer *w = timers [0];

      /* first reschedule timer */
      if (w->repeat)
        {
          fprintf (stderr, "a %f now %f repeat %f, %f\n", w->at, ev_now, w->repeat, w->repeat *1e30);//D
          if (w->is_abs)
            w->at += floor ((ev_now - w->at) / w->repeat + 1.) * w->repeat;
          else
            w->at = ev_now + w->repeat;

          fprintf (stderr, "b %f\n", w->at);//D

          downheap (0);
        }
      else
        evtimer_stop (w); /* nonrepeating: stop timer */

      event ((struct ev_watcher *)w, EV_TIMEOUT);
    }
}

int ev_loop_done;

int ev_loop (int flags)
{
  double block;
  ev_loop_done = flags & EVLOOP_ONESHOT;

  do
    {
      /* update fd-related kernel structures */
      method_reify (); fdchangecnt = 0;

      /* calculate blocking time */
      ev_now = ev_time ();

      if (flags & EVLOOP_NONBLOCK)
        block = 0.;
      else if (!timercnt)
        block = MAX_BLOCKTIME;
      else
        {
          block = timers [0]->at - ev_now + method_fudge;
          if (block < 0.) block = 0.;
          else if (block > MAX_BLOCKTIME) block = MAX_BLOCKTIME;
        }

      fprintf (stderr, "block %f\n", block);//D
      method_poll (block);

      /* put pending timers into pendign queue and reschedule them */
      timer_reify ();

      ev_now = ev_time ();
      call_pending ();
    }
  while (!ev_loop_done);
}

static void
wlist_add (struct ev_watcher_list **head, struct ev_watcher_list *elem)
{
  elem->next = *head;
  *head = elem;
}

static void
wlist_del (struct ev_watcher_list **head, struct ev_watcher_list *elem)
{
  while (*head)
    {
      if (*head == elem)
        {
          *head = elem->next;
          return;
        }

      head = &(*head)->next;
    }
}

static void
ev_start (struct ev_watcher *w, int active)
{
  w->pending = 0;
  w->active = active;
}

static void
ev_stop (struct ev_watcher *w)
{
  if (w->pending)
    pendings [w->pending - 1].w = 0;

  w->active = 0;
  /* nop */
}

void
evio_start (struct ev_io *w)
{
  if (ev_is_active (w))
    return;

  int fd = w->fd;

  ev_start ((struct ev_watcher *)w, 1);
  array_needsize (anfds, anfdmax, fd + 1, anfds_init);
  wlist_add ((struct ev_watcher_list **)&anfds[fd].head, (struct ev_watcher_list *)w);

  ++fdchangecnt;
  array_needsize (fdchanges, fdchangemax, fdchangecnt, );
  fdchanges [fdchangecnt - 1] = fd;
}

void
evio_stop (struct ev_io *w)
{
  if (!ev_is_active (w))
    return;

  wlist_del ((struct ev_watcher_list **)&anfds[w->fd].head, (struct ev_watcher_list *)w);
  ev_stop ((struct ev_watcher *)w);

  ++fdchangecnt;
  array_needsize (fdchanges, fdchangemax, fdchangecnt, );
  fdchanges [fdchangecnt - 1] = w->fd;
}

void
evtimer_start (struct ev_timer *w)
{
  if (ev_is_active (w))
    return;

  fprintf (stderr, "t1 %f a %d\n", w->at, w->is_abs);//D
  if (w->is_abs)
    {
      if (w->repeat)
        w->at += ceil ((ev_now - w->at) / w->repeat) * w->repeat;
    }
  else
    w->at += ev_now;
  fprintf (stderr, "t2 %f a %d\n", w->at, w->is_abs);//D

  ev_start ((struct ev_watcher *)w, ++timercnt);
  array_needsize (timers, timermax, timercnt, );
  timers [timercnt - 1] = w;
  upheap (timercnt - 1);
}

void
evtimer_stop (struct ev_timer *w)
{
  if (!ev_is_active (w))
    return;

  timers [w->active - 1] = timers [--timercnt];
  downheap (w->active - 1);
  ev_stop ((struct ev_watcher *)w);
}

void
evsignal_start (struct ev_signal *w)
{
  if (ev_is_active (w))
    return;

  ev_start ((struct ev_watcher *)w, 1);
  array_needsize (signals, signalmax, w->signum, signals_init);
  wlist_add ((struct ev_watcher_list **)&signals [w->signum - 1], (struct ev_watcher_list *)w);
}

void
evsignal_stop (struct ev_signal *w)
{
  if (!ev_is_active (w))
    return;

  wlist_del ((struct ev_watcher_list **)&signals [w->signum - 1], (struct ev_watcher_list *)w);
  ev_stop ((struct ev_watcher *)w);
}

/*****************************************************************************/
#if 1

static void
sin_cb (struct ev_io *w, int revents)
{
  fprintf (stderr, "sin %d, revents %d\n", w->fd, revents);
}

static void
ocb (struct ev_timer *w, int revents)
{
  fprintf (stderr, "timer %f,%f (%x) (%f) d%p\n", w->at, w->repeat, revents, w->at - ev_time (), w->data);
}

int main (void)
{
  struct ev_io sin;

  ev_init (0);

  evw_init (&sin, sin_cb, 55);
  evio_set (&sin, 0, EV_READ);
  evio_start (&sin);

  struct ev_timer t1;
  evw_init (&t1, ocb, 1);
  evtimer_set_rel (&t1, 1, 0);
  evtimer_start (&t1);

  struct ev_timer t2;
  evw_init (&t2, ocb, 2);
  evtimer_set_abs (&t2, ev_time () + 2, 0);
  evtimer_start (&t2);

  ev_loop (0);

  return 0;
}

#endif


Revision:	1.1
Committed:	Tue Oct 30 20:59:31 2007 UTC (16 years, 6 months ago) by root
Content type:	text/plain
Branch:	MAIN
Log Message:	initial roguh cut that doesn't immediately barf
#	Content
1	#include <math.h>
2	#include <stdlib.h>
3
4	#include <stdio.h>
5
6	#include <errno.h>
7	#include <sys/time.h>
8	#include <time.h>
9
10	#ifdef CLOCK_MONOTONIC
11	# define HAVE_MONOTONIC 1
12	#endif
13
14	#define HAVE_EPOLL 1
15	#define HAVE_REALTIME 1
16	#define HAVE_SELECT 0
17
18	#define MAX_BLOCKTIME 60.
19
20	#include "ev.h"
21
22	struct ev_watcher {
23	EV_WATCHER (ev_watcher);
24	};
25
26	struct ev_watcher_list {
27	EV_WATCHER_LIST (ev_watcher_list);
28	};
29
30	ev_tstamp ev_now;
31	int ev_method;
32
33	static int have_monotonic; /* runtime */
34
35	static ev_tstamp method_fudge; /* stupid epoll-returns-early bug */
36	static void (*method_reify)(void);
37	static void (*method_poll)(ev_tstamp timeout);
38
39	ev_tstamp
40	ev_time (void)
41	{
42	#if HAVE_REALTIME
43	struct timespec ts;
44	clock_gettime (CLOCK_REALTIME, &ts);
45	return ts.tv_sec + ts.tv_nsec * 1e-9;
46	#else
47	struct timeval tv;
48	gettimeofday (&tv, 0);
49	return tv.tv_sec + tv.tv_usec * 1e-6;
50	#endif
51	}
52
53	static ev_tstamp
54	get_clock (void)
55	{
56	#if HAVE_MONOTONIC
57	if (have_monotonic)
58	{
59	struct timespec ts;
60	clock_gettime (CLOCK_MONOTONIC, &ts);
61	return ts.tv_sec + ts.tv_nsec * 1e-9;
62	}
63	#endif
64
65	return ev_time ();
66	}
67
68	#define array_needsize(base,cur,cnt,init) \
69	if ((cnt) > cur) \
70	{ \
71	int newcnt = cur; \
72	do \
73	{ \
74	newcnt += (newcnt >> 1) + 16; \
75	} \
76	while ((cnt) > newcnt); \
77	fprintf (stderr, "resize(" # base ") from %d to %d\n", cur, newcnt);\
78	base = realloc (base, sizeof (base) (newcnt)); \
79	init (base + cur, newcnt - cur); \
80	cur = newcnt; \
81	}
82
83	typedef struct
84	{
85	struct ev_io *head;
86	unsigned char wev, rev; /* want, received event set */
87	} ANFD;
88
89	static ANFD *anfds;
90	static int anfdmax;
91
92	static int *fdchanges;
93	static int fdchangemax, fdchangecnt;
94
95	static void
96	anfds_init (ANFD *base, int count)
97	{
98	while (count--)
99	{
100	base->head = 0;
101	base->wev = base->rev = EV_NONE;
102	++base;
103	}
104	}
105
106	typedef struct
107	{
108	struct ev_watcher *w;
109	int events;
110	} ANPENDING;
111
112	static ANPENDING *pendings;
113	static int pendingmax, pendingcnt;
114
115	static void
116	event (struct ev_watcher *w, int events)
117	{
118	w->pending = ++pendingcnt;
119	array_needsize (pendings, pendingmax, pendingcnt, );
120	pendings [pendingcnt - 1].w = w;
121	pendings [pendingcnt - 1].events = events;
122	}
123
124	static void
125	fd_event (int fd, int events)
126	{
127	ANFD *anfd = anfds + fd;
128	struct ev_io *w;
129
130	for (w = anfd->head; w; w = w->next)
131	{
132	int ev = w->events & events;
133
134	if (ev)
135	event ((struct ev_watcher *)w, ev);
136	}
137	}
138
139	static struct ev_timer **timers;
140	static int timermax, timercnt;
141
142	static void
143	upheap (int k)
144	{
145	struct ev_timer *w = timers [k];
146
147	while (k && timers [k >> 1]->at > w->at)
148	{
149	timers [k] = timers [k >> 1];
150	timers [k]->active = k + 1;
151	k >>= 1;
152	}
153
154	timers [k] = w;
155	timers [k]->active = k + 1;
156
157	}
158
159	static void
160	downheap (int k)
161	{
162	struct ev_timer *w = timers [k];
163
164	while (k <= (timercnt >> 1))
165	{
166	int j = k << 1;
167
168	if (j + 1 < timercnt && timers [j]->at > timers [j + 1]->at)
169	++j;
170
171	if (w->at <= timers [j]->at)
172	break;
173
174	timers [k] = timers [j];
175	timers [k]->active = k;
176	k = j;
177	}
178
179	timers [k] = w;
180	timers [k]->active = k + 1;
181	}
182
183	static struct ev_signal **signals;
184	static int signalmax, signalcnt;
185
186	static void
187	signals_init (struct ev_signal **base, int count)
188	{
189	while (count--)
190	*base++ = 0;
191	}
192
193	#if HAVE_EPOLL
194	# include "ev_epoll.c"
195	#endif
196	#if HAVE_SELECT
197	# include "ev_select.c"
198	#endif
199
200	int ev_init (int flags)
201	{
202	#if HAVE_MONOTONIC
203	{
204	struct timespec ts;
205	if (!clock_gettime (CLOCK_MONOTONIC, &ts))
206	have_monotonic = 1;
207	}
208	#endif
209
210	ev_now = ev_time ();
211
212	#if HAVE_EPOLL
213	if (epoll_init (flags))
214	return ev_method;
215	#endif
216	#if HAVE_SELECT
217	if (select_init (flags))
218	return ev_method;
219	#endif
220
221	ev_method = EVMETHOD_NONE;
222	return ev_method;
223	}
224
225	void ev_prefork (void)
226	{
227	}
228
229	void ev_postfork_parent (void)
230	{
231	}
232
233	void ev_postfork_child (void)
234	{
235	#if HAVE_EPOLL
236	epoll_postfork_child ();
237	#endif
238	}
239
240	static void
241	call_pending ()
242	{
243	int i;
244
245	for (i = 0; i < pendingcnt; ++i)
246	{
247	ANPENDING *p = pendings + i;
248
249	if (p->w)
250	{
251	p->w->pending = 0;
252	p->w->cb (p->w, p->events);
253	}
254	}
255
256	pendingcnt = 0;
257	}
258
259	static void
260	timer_reify (void)
261	{
262	while (timercnt && timers [0]->at <= ev_now)
263	{
264	struct ev_timer *w = timers [0];
265
266	/* first reschedule timer */
267	if (w->repeat)
268	{
269	fprintf (stderr, "a %f now %f repeat %f, %f\n", w->at, ev_now, w->repeat, w->repeat *1e30);//D
270	if (w->is_abs)
271	w->at += floor ((ev_now - w->at) / w->repeat + 1.) * w->repeat;
272	else
273	w->at = ev_now + w->repeat;
274
275	fprintf (stderr, "b %f\n", w->at);//D
276
277	downheap (0);
278	}
279	else
280	evtimer_stop (w); /* nonrepeating: stop timer */
281
282	event ((struct ev_watcher *)w, EV_TIMEOUT);
283	}
284	}
285
286	int ev_loop_done;
287
288	int ev_loop (int flags)
289	{
290	double block;
291	ev_loop_done = flags & EVLOOP_ONESHOT;
292
293	do
294	{
295	/* update fd-related kernel structures */
296	method_reify (); fdchangecnt = 0;
297
298	/* calculate blocking time */
299	ev_now = ev_time ();
300
301	if (flags & EVLOOP_NONBLOCK)
302	block = 0.;
303	else if (!timercnt)
304	block = MAX_BLOCKTIME;
305	else
306	{
307	block = timers [0]->at - ev_now + method_fudge;
308	if (block < 0.) block = 0.;
309	else if (block > MAX_BLOCKTIME) block = MAX_BLOCKTIME;
310	}
311
312	fprintf (stderr, "block %f\n", block);//D
313	method_poll (block);
314
315	/* put pending timers into pendign queue and reschedule them */
316	timer_reify ();
317
318	ev_now = ev_time ();
319	call_pending ();
320	}
321	while (!ev_loop_done);
322	}
323
324	static void
325	wlist_add (struct ev_watcher_list *head, struct ev_watcher_list elem)
326	{
327	elem->next = *head;
328	*head = elem;
329	}
330
331	static void
332	wlist_del (struct ev_watcher_list *head, struct ev_watcher_list elem)
333	{
334	while (*head)
335	{
336	if (*head == elem)
337	{
338	*head = elem->next;
339	return;
340	}
341
342	head = &(*head)->next;
343	}
344	}
345
346	static void
347	ev_start (struct ev_watcher *w, int active)
348	{
349	w->pending = 0;
350	w->active = active;
351	}
352
353	static void
354	ev_stop (struct ev_watcher *w)
355	{
356	if (w->pending)
357	pendings [w->pending - 1].w = 0;
358
359	w->active = 0;
360	/* nop */
361	}
362
363	void
364	evio_start (struct ev_io *w)
365	{
366	if (ev_is_active (w))
367	return;
368
369	int fd = w->fd;
370
371	ev_start ((struct ev_watcher *)w, 1);
372	array_needsize (anfds, anfdmax, fd + 1, anfds_init);
373	wlist_add ((struct ev_watcher_list *)&anfds[fd].head, (struct ev_watcher_list )w);
374
375	++fdchangecnt;
376	array_needsize (fdchanges, fdchangemax, fdchangecnt, );
377	fdchanges [fdchangecnt - 1] = fd;
378	}
379
380	void
381	evio_stop (struct ev_io *w)
382	{
383	if (!ev_is_active (w))
384	return;
385
386	wlist_del ((struct ev_watcher_list *)&anfds[w->fd].head, (struct ev_watcher_list )w);
387	ev_stop ((struct ev_watcher *)w);
388
389	++fdchangecnt;
390	array_needsize (fdchanges, fdchangemax, fdchangecnt, );
391	fdchanges [fdchangecnt - 1] = w->fd;
392	}
393
394	void
395	evtimer_start (struct ev_timer *w)
396	{
397	if (ev_is_active (w))
398	return;
399
400	fprintf (stderr, "t1 %f a %d\n", w->at, w->is_abs);//D
401	if (w->is_abs)
402	{
403	if (w->repeat)
404	w->at += ceil ((ev_now - w->at) / w->repeat) * w->repeat;
405	}
406	else
407	w->at += ev_now;
408	fprintf (stderr, "t2 %f a %d\n", w->at, w->is_abs);//D
409
410	ev_start ((struct ev_watcher *)w, ++timercnt);
411	array_needsize (timers, timermax, timercnt, );
412	timers [timercnt - 1] = w;
413	upheap (timercnt - 1);
414	}
415
416	void
417	evtimer_stop (struct ev_timer *w)
418	{
419	if (!ev_is_active (w))
420	return;
421
422	timers [w->active - 1] = timers [--timercnt];
423	downheap (w->active - 1);
424	ev_stop ((struct ev_watcher *)w);
425	}
426
427	void
428	evsignal_start (struct ev_signal *w)
429	{
430	if (ev_is_active (w))
431	return;
432
433	ev_start ((struct ev_watcher *)w, 1);
434	array_needsize (signals, signalmax, w->signum, signals_init);
435	wlist_add ((struct ev_watcher_list *)&signals [w->signum - 1], (struct ev_watcher_list )w);
436	}
437
438	void
439	evsignal_stop (struct ev_signal *w)
440	{
441	if (!ev_is_active (w))
442	return;
443
444	wlist_del ((struct ev_watcher_list *)&signals [w->signum - 1], (struct ev_watcher_list )w);
445	ev_stop ((struct ev_watcher *)w);
446	}
447
448	/*****************************************************************************/
449	#if 1
450
451	static void
452	sin_cb (struct ev_io *w, int revents)
453	{
454	fprintf (stderr, "sin %d, revents %d\n", w->fd, revents);
455	}
456
457	static void
458	ocb (struct ev_timer *w, int revents)
459	{
460	fprintf (stderr, "timer %f,%f (%x) (%f) d%p\n", w->at, w->repeat, revents, w->at - ev_time (), w->data);
461	}
462
463	int main (void)
464	{
465	struct ev_io sin;
466
467	ev_init (0);
468
469	evw_init (&sin, sin_cb, 55);
470	evio_set (&sin, 0, EV_READ);
471	evio_start (&sin);
472
473	struct ev_timer t1;
474	evw_init (&t1, ocb, 1);
475	evtimer_set_rel (&t1, 1, 0);
476	evtimer_start (&t1);
477
478	struct ev_timer t2;
479	evw_init (&t2, ocb, 2);
480	evtimer_set_abs (&t2, ev_time () + 2, 0);
481	evtimer_start (&t2);
482
483	ev_loop (0);
484
485	return 0;
486	}
487
488	#endif
489
490
491
492