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 ? cur << 1 : 16;                 \
      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 + 1;
      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];

          fprintf (stderr, "0 %f, %d c%d\n", w->at, w->active, timercnt);//D
      /* 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 += ceil ((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
        {
          fprintf (stderr, "c %f, %d c%d\n", w->at, w->active, timercnt);//D
        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)
    {
      /* this formula differs from the one in timer_reify becuse we do not round up */
      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)
{
  fprintf (stderr, "-topping %d, %d\n", w->active, timercnt);//D
  if (!ev_is_active (w))
    return;

  fprintf (stderr, "stopping %d, %d\n", w->active, timercnt);//D
  if (w->active < timercnt)
    {
      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 t[1000];

  int i;
  for (i = 0; i < 1000; ++i)
    {
      struct ev_timer *w = t + i;
      evw_init (w, ocb, i);
      evtimer_set_rel (w, drand48 (), 0);
      evtimer_start (w);
      if (drand48 () < 0.5)
        evtimer_stop (w);
    }

  ev_loop (0);

  return 0;
}

#endif


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