libev/ev.c

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

#include <stdio.h>

#include <assert.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 1

#define MIN_TIMEJUMP  1. /* minimum timejump that gets detected (if monotonic clock available) */
#define MAX_BLOCKTIME 60.

#include "ev.h"

struct ev_watcher {
  EV_WATCHER (ev_watcher);
};

struct ev_watcher_list {
  EV_WATCHER_LIST (ev_watcher_list);
};

static ev_tstamp now, diff; /* monotonic clock */
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_modify)(int fd, int oev, int nev);
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 **atimers;
static int atimermax, atimercnt;

static struct ev_timer **rtimers;
static int rtimermax, rtimercnt;

static void
upheap (struct ev_timer **timers, 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 (struct ev_timer **timers, int N, int k)
{
  struct ev_timer *w = timers [k];

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

      if (j + 1 < N && 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;

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 ();
  now    = get_clock ();
  diff   = ev_now - now;

#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
  if (ev_method == EVMETHOD_EPOLL)
    epoll_postfork_child ();
#endif
}

static void
fd_reify (void)
{
  int i;

  for (i = 0; i < fdchangecnt; ++i)
    {
      int fd = fdchanges [i];
      ANFD *anfd = anfds + fd;
      struct ev_io *w;

      int wev = 0;

      for (w = anfd->head; w; w = w->next)
        wev |= w->events;

      if (anfd->wev != wev)
        {
          method_modify (fd, anfd->wev, wev);
          anfd->wev = wev;
        }
    }

  fdchangecnt = 0;
}

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
timers_reify (struct ev_timer **timers, int timercnt, ev_tstamp now)
{
  while (timercnt && timers [0]->at <= now)
    {
      struct ev_timer *w = timers [0];

      /* first reschedule or stop timer */
      if (w->repeat)
        {
          if (w->is_abs)
            w->at += floor ((now - w->at) / w->repeat + 1.) * w->repeat;
          else
            w->at = now + w->repeat;

          assert (w->at > now);

          downheap (timers, timercnt, 0);
        }
      else
        {
          evtimer_stop (w); /* nonrepeating: stop timer */
          --timercnt; /* maybe pass by reference instead? */
        }

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

static void
time_update ()
{
  int i;
  ev_now = ev_time ();

  if (have_monotonic)
    {
      ev_tstamp odiff = diff;

      /* detecting time jumps is much more difficult */
      for (i = 2; --i; ) /* loop a few times, before making important decisions */
        {
          now = get_clock ();
          diff = ev_now - now;

          if (fabs (odiff - diff) < MIN_TIMEJUMP)
            return; /* all is well */

          ev_now = ev_time ();
        }

      /* time jump detected, reschedule atimers */
      for (i = 0; i < atimercnt; ++i)
        {
          struct ev_timer *w = atimers [i];
          w->at += ceil ((ev_now - w->at) / w->repeat + 1.) * w->repeat;
        }
    }
  else
    {
      if (now > ev_now || now < ev_now - MAX_BLOCKTIME - MIN_TIMEJUMP)
        /* time jump detected, adjust rtimers */
        for (i = 0; i < rtimercnt; ++i)
          rtimers [i]->at += ev_now - now;

      now = ev_now;
    }
}

int ev_loop_done;

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

  do
    {
      /* update fd-related kernel structures */
      fd_reify ();

      /* calculate blocking time */
      if (flags & EVLOOP_NONBLOCK)
        block = 0.;
      else
        {
          block = MAX_BLOCKTIME;

          if (rtimercnt)
            {
              ev_tstamp to = rtimers [0]->at - get_clock () + method_fudge;
              if (block > to) block = to;
            }

          if (atimercnt)
            {
              ev_tstamp to = atimers [0]->at - ev_time   () + method_fudge;
              if (block > to) block = to;
            }

          if (block < 0.) block = 0.;
        }

      method_poll (block);

      /* update ev_now, do magic */
      time_update ();

      /* put pending timers into pendign queue and reschedule them */
      /* absolute timers first */
      timers_reify (atimers, atimercnt, ev_now);
      /* relative timers second */
      timers_reify (rtimers, rtimercnt, now);

      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;

  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;

      ev_start ((struct ev_watcher *)w, ++atimercnt);
      array_needsize (atimers, atimermax, atimercnt, );
      atimers [atimercnt - 1] = w;
      upheap (atimers, atimercnt - 1);
    }
  else
    {
      w->at += now;

      ev_start ((struct ev_watcher *)w, ++rtimercnt);
      array_needsize (rtimers, rtimermax, rtimercnt, );
      rtimers [rtimercnt - 1] = w;
      upheap (rtimers, rtimercnt - 1);
    }

}

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

  if (w->is_abs)
    {
      if (w->active < atimercnt--)
        {
          atimers [w->active - 1] = atimers [atimercnt];
          downheap (atimers, atimercnt, w->active - 1);
        }
    }
  else
    {
      if (w->active < rtimercnt--)
        {
          rtimers [w->active - 1] = rtimers [rtimercnt];
          downheap (rtimers, rtimercnt, 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);
  evtimer_stop (w);
  evtimer_start (w);
}

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[10000];

#if 1
  int i;
  for (i = 0; i < 10000; ++i)
    {
      struct ev_timer *w = t + i;
      evw_init (w, ocb, i);
      evtimer_set_abs (w, drand48 (), 0.99775533);
      evtimer_start (w);
      if (drand48 () < 0.5)
        evtimer_stop (w);
    }
#endif

  struct ev_timer t1;
  evw_init (&t1, ocb, 0);
  evtimer_set_abs (&t1, 5, 10);
  evtimer_start (&t1);

  ev_loop (0);

  return 0;
}

#endif


Revision:	1.5
Committed:	Tue Oct 30 23:54:38 2007 UTC (16 years, 6 months ago) by root
Content type:	text/plain
Branch:	MAIN
Changes since 1.4:	+31 -4 lines
Log Message:	implement select method
#	Content
1	#include <math.h>
2	#include <stdlib.h>
3
4	#include <stdio.h>
5
6	#include <assert.h>
7	#include <errno.h>
8	#include <sys/time.h>
9	#include <time.h>
10
11	#ifdef CLOCK_MONOTONIC
12	# define HAVE_MONOTONIC 1
13	#endif
14
15	#define HAVE_EPOLL 1
16	#define HAVE_REALTIME 1
17	#define HAVE_SELECT 1
18
19	#define MIN_TIMEJUMP 1. /* minimum timejump that gets detected (if monotonic clock available) */
20	#define MAX_BLOCKTIME 60.
21
22	#include "ev.h"
23
24	struct ev_watcher {
25	EV_WATCHER (ev_watcher);
26	};
27
28	struct ev_watcher_list {
29	EV_WATCHER_LIST (ev_watcher_list);
30	};
31
32	static ev_tstamp now, diff; /* monotonic clock */
33	ev_tstamp ev_now;
34	int ev_method;
35
36	static int have_monotonic; /* runtime */
37
38	static ev_tstamp method_fudge; /* stupid epoll-returns-early bug */
39	static void (*method_modify)(int fd, int oev, int nev);
40	static void (*method_poll)(ev_tstamp timeout);
41
42	ev_tstamp
43	ev_time (void)
44	{
45	#if HAVE_REALTIME
46	struct timespec ts;
47	clock_gettime (CLOCK_REALTIME, &ts);
48	return ts.tv_sec + ts.tv_nsec * 1e-9;
49	#else
50	struct timeval tv;
51	gettimeofday (&tv, 0);
52	return tv.tv_sec + tv.tv_usec * 1e-6;
53	#endif
54	}
55
56	static ev_tstamp
57	get_clock (void)
58	{
59	#if HAVE_MONOTONIC
60	if (have_monotonic)
61	{
62	struct timespec ts;
63	clock_gettime (CLOCK_MONOTONIC, &ts);
64	return ts.tv_sec + ts.tv_nsec * 1e-9;
65	}
66	#endif
67
68	return ev_time ();
69	}
70
71	#define array_needsize(base,cur,cnt,init) \
72	if ((cnt) > cur) \
73	{ \
74	int newcnt = cur ? cur << 1 : 16; \
75	fprintf (stderr, "resize(" # base ") from %d to %d\n", cur, newcnt);\
76	base = realloc (base, sizeof (base) (newcnt)); \
77	init (base + cur, newcnt - cur); \
78	cur = newcnt; \
79	}
80
81	typedef struct
82	{
83	struct ev_io *head;
84	unsigned char wev, rev; /* want, received event set */
85	} ANFD;
86
87	static ANFD *anfds;
88	static int anfdmax;
89
90	static int *fdchanges;
91	static int fdchangemax, fdchangecnt;
92
93	static void
94	anfds_init (ANFD *base, int count)
95	{
96	while (count--)
97	{
98	base->head = 0;
99	base->wev = base->rev = EV_NONE;
100	++base;
101	}
102	}
103
104	typedef struct
105	{
106	struct ev_watcher *w;
107	int events;
108	} ANPENDING;
109
110	static ANPENDING *pendings;
111	static int pendingmax, pendingcnt;
112
113	static void
114	event (struct ev_watcher *w, int events)
115	{
116	w->pending = ++pendingcnt;
117	array_needsize (pendings, pendingmax, pendingcnt, );
118	pendings [pendingcnt - 1].w = w;
119	pendings [pendingcnt - 1].events = events;
120	}
121
122	static void
123	fd_event (int fd, int events)
124	{
125	ANFD *anfd = anfds + fd;
126	struct ev_io *w;
127
128	for (w = anfd->head; w; w = w->next)
129	{
130	int ev = w->events & events;
131
132	if (ev)
133	event ((struct ev_watcher *)w, ev);
134	}
135	}
136
137	static struct ev_timer **atimers;
138	static int atimermax, atimercnt;
139
140	static struct ev_timer **rtimers;
141	static int rtimermax, rtimercnt;
142
143	static void
144	upheap (struct ev_timer **timers, int k)
145	{
146	struct ev_timer *w = timers [k];
147
148	while (k && timers [k >> 1]->at > w->at)
149	{
150	timers [k] = timers [k >> 1];
151	timers [k]->active = k + 1;
152	k >>= 1;
153	}
154
155	timers [k] = w;
156	timers [k]->active = k + 1;
157
158	}
159
160	static void
161	downheap (struct ev_timer **timers, int N, int k)
162	{
163	struct ev_timer *w = timers [k];
164
165	while (k < (N >> 1))
166	{
167	int j = k << 1;
168
169	if (j + 1 < N && timers [j]->at > timers [j + 1]->at)
170	++j;
171
172	if (w->at <= timers [j]->at)
173	break;
174
175	timers [k] = timers [j];
176	timers [k]->active = k + 1;
177	k = j;
178	}
179
180	timers [k] = w;
181	timers [k]->active = k + 1;
182	}
183
184	static struct ev_signal **signals;
185	static int signalmax;
186
187	static void
188	signals_init (struct ev_signal **base, int count)
189	{
190	while (count--)
191	*base++ = 0;
192	}
193
194	#if HAVE_EPOLL
195	# include "ev_epoll.c"
196	#endif
197	#if HAVE_SELECT
198	# include "ev_select.c"
199	#endif
200
201	int ev_init (int flags)
202	{
203	#if HAVE_MONOTONIC
204	{
205	struct timespec ts;
206	if (!clock_gettime (CLOCK_MONOTONIC, &ts))
207	have_monotonic = 1;
208	}
209	#endif
210
211	ev_now = ev_time ();
212	now = get_clock ();
213	diff = ev_now - now;
214
215	#if HAVE_EPOLL
216	if (epoll_init (flags))
217	return ev_method;
218	#endif
219	#if HAVE_SELECT
220	if (select_init (flags))
221	return ev_method;
222	#endif
223
224	ev_method = EVMETHOD_NONE;
225	return ev_method;
226	}
227
228	void ev_prefork (void)
229	{
230	}
231
232	void ev_postfork_parent (void)
233	{
234	}
235
236	void ev_postfork_child (void)
237	{
238	#if HAVE_EPOLL
239	if (ev_method == EVMETHOD_EPOLL)
240	epoll_postfork_child ();
241	#endif
242	}
243
244	static void
245	fd_reify (void)
246	{
247	int i;
248
249	for (i = 0; i < fdchangecnt; ++i)
250	{
251	int fd = fdchanges [i];
252	ANFD *anfd = anfds + fd;
253	struct ev_io *w;
254
255	int wev = 0;
256
257	for (w = anfd->head; w; w = w->next)
258	wev \|= w->events;
259
260	if (anfd->wev != wev)
261	{
262	method_modify (fd, anfd->wev, wev);
263	anfd->wev = wev;
264	}
265	}
266
267	fdchangecnt = 0;
268	}
269
270	static void
271	call_pending ()
272	{
273	int i;
274
275	for (i = 0; i < pendingcnt; ++i)
276	{
277	ANPENDING *p = pendings + i;
278
279	if (p->w)
280	{
281	p->w->pending = 0;
282	p->w->cb (p->w, p->events);
283	}
284	}
285
286	pendingcnt = 0;
287	}
288
289	static void
290	timers_reify (struct ev_timer **timers, int timercnt, ev_tstamp now)
291	{
292	while (timercnt && timers [0]->at <= now)
293	{
294	struct ev_timer *w = timers [0];
295
296	/* first reschedule or stop timer */
297	if (w->repeat)
298	{
299	if (w->is_abs)
300	w->at += floor ((now - w->at) / w->repeat + 1.) * w->repeat;
301	else
302	w->at = now + w->repeat;
303
304	assert (w->at > now);
305
306	downheap (timers, timercnt, 0);
307	}
308	else
309	{
310	evtimer_stop (w); /* nonrepeating: stop timer */
311	--timercnt; /* maybe pass by reference instead? */
312	}
313
314	event ((struct ev_watcher *)w, EV_TIMEOUT);
315	}
316	}
317
318	static void
319	time_update ()
320	{
321	int i;
322	ev_now = ev_time ();
323
324	if (have_monotonic)
325	{
326	ev_tstamp odiff = diff;
327
328	/* detecting time jumps is much more difficult */
329	for (i = 2; --i; ) /* loop a few times, before making important decisions */
330	{
331	now = get_clock ();
332	diff = ev_now - now;
333
334	if (fabs (odiff - diff) < MIN_TIMEJUMP)
335	return; /* all is well */
336
337	ev_now = ev_time ();
338	}
339
340	/* time jump detected, reschedule atimers */
341	for (i = 0; i < atimercnt; ++i)
342	{
343	struct ev_timer *w = atimers [i];
344	w->at += ceil ((ev_now - w->at) / w->repeat + 1.) * w->repeat;
345	}
346	}
347	else
348	{
349	if (now > ev_now \|\| now < ev_now - MAX_BLOCKTIME - MIN_TIMEJUMP)
350	/* time jump detected, adjust rtimers */
351	for (i = 0; i < rtimercnt; ++i)
352	rtimers [i]->at += ev_now - now;
353
354	now = ev_now;
355	}
356	}
357
358	int ev_loop_done;
359
360	void ev_loop (int flags)
361	{
362	double block;
363	ev_loop_done = flags & EVLOOP_ONESHOT;
364
365	do
366	{
367	/* update fd-related kernel structures */
368	fd_reify ();
369
370	/* calculate blocking time */
371	if (flags & EVLOOP_NONBLOCK)
372	block = 0.;
373	else
374	{
375	block = MAX_BLOCKTIME;
376
377	if (rtimercnt)
378	{
379	ev_tstamp to = rtimers [0]->at - get_clock () + method_fudge;
380	if (block > to) block = to;
381	}
382
383	if (atimercnt)
384	{
385	ev_tstamp to = atimers [0]->at - ev_time () + method_fudge;
386	if (block > to) block = to;
387	}
388
389	if (block < 0.) block = 0.;
390	}
391
392	method_poll (block);
393
394	/* update ev_now, do magic */
395	time_update ();
396
397	/* put pending timers into pendign queue and reschedule them */
398	/* absolute timers first */
399	timers_reify (atimers, atimercnt, ev_now);
400	/* relative timers second */
401	timers_reify (rtimers, rtimercnt, now);
402
403	call_pending ();
404	}
405	while (!ev_loop_done);
406	}
407
408	static void
409	wlist_add (struct ev_watcher_list *head, struct ev_watcher_list elem)
410	{
411	elem->next = *head;
412	*head = elem;
413	}
414
415	static void
416	wlist_del (struct ev_watcher_list *head, struct ev_watcher_list elem)
417	{
418	while (*head)
419	{
420	if (*head == elem)
421	{
422	*head = elem->next;
423	return;
424	}
425
426	head = &(*head)->next;
427	}
428	}
429
430	static void
431	ev_start (struct ev_watcher *w, int active)
432	{
433	w->pending = 0;
434	w->active = active;
435	}
436
437	static void
438	ev_stop (struct ev_watcher *w)
439	{
440	if (w->pending)
441	pendings [w->pending - 1].w = 0;
442
443	w->active = 0;
444	/* nop */
445	}
446
447	void
448	evio_start (struct ev_io *w)
449	{
450	if (ev_is_active (w))
451	return;
452
453	int fd = w->fd;
454
455	ev_start ((struct ev_watcher *)w, 1);
456	array_needsize (anfds, anfdmax, fd + 1, anfds_init);
457	wlist_add ((struct ev_watcher_list *)&anfds[fd].head, (struct ev_watcher_list )w);
458
459	++fdchangecnt;
460	array_needsize (fdchanges, fdchangemax, fdchangecnt, );
461	fdchanges [fdchangecnt - 1] = fd;
462	}
463
464	void
465	evio_stop (struct ev_io *w)
466	{
467	if (!ev_is_active (w))
468	return;
469
470	wlist_del ((struct ev_watcher_list *)&anfds[w->fd].head, (struct ev_watcher_list )w);
471	ev_stop ((struct ev_watcher *)w);
472
473	++fdchangecnt;
474	array_needsize (fdchanges, fdchangemax, fdchangecnt, );
475	fdchanges [fdchangecnt - 1] = w->fd;
476	}
477
478	void
479	evtimer_start (struct ev_timer *w)
480	{
481	if (ev_is_active (w))
482	return;
483
484	if (w->is_abs)
485	{
486	/* this formula differs from the one in timer_reify becuse we do not round up */
487	if (w->repeat)
488	w->at += ceil ((ev_now - w->at) / w->repeat) * w->repeat;
489
490	ev_start ((struct ev_watcher *)w, ++atimercnt);
491	array_needsize (atimers, atimermax, atimercnt, );
492	atimers [atimercnt - 1] = w;
493	upheap (atimers, atimercnt - 1);
494	}
495	else
496	{
497	w->at += now;
498
499	ev_start ((struct ev_watcher *)w, ++rtimercnt);
500	array_needsize (rtimers, rtimermax, rtimercnt, );
501	rtimers [rtimercnt - 1] = w;
502	upheap (rtimers, rtimercnt - 1);
503	}
504
505	}
506
507	void
508	evtimer_stop (struct ev_timer *w)
509	{
510	if (!ev_is_active (w))
511	return;
512
513	if (w->is_abs)
514	{
515	if (w->active < atimercnt--)
516	{
517	atimers [w->active - 1] = atimers [atimercnt];
518	downheap (atimers, atimercnt, w->active - 1);
519	}
520	}
521	else
522	{
523	if (w->active < rtimercnt--)
524	{
525	rtimers [w->active - 1] = rtimers [rtimercnt];
526	downheap (rtimers, rtimercnt, w->active - 1);
527	}
528	}
529
530	ev_stop ((struct ev_watcher *)w);
531	}
532
533	void
534	evsignal_start (struct ev_signal *w)
535	{
536	if (ev_is_active (w))
537	return;
538
539	ev_start ((struct ev_watcher *)w, 1);
540	array_needsize (signals, signalmax, w->signum, signals_init);
541	wlist_add ((struct ev_watcher_list *)&signals [w->signum - 1], (struct ev_watcher_list )w);
542	}
543
544	void
545	evsignal_stop (struct ev_signal *w)
546	{
547	if (!ev_is_active (w))
548	return;
549
550	wlist_del ((struct ev_watcher_list *)&signals [w->signum - 1], (struct ev_watcher_list )w);
551	ev_stop ((struct ev_watcher *)w);
552	}
553
554	/*****************************************************************************/
555	#if 1
556
557	static void
558	sin_cb (struct ev_io *w, int revents)
559	{
560	fprintf (stderr, "sin %d, revents %d\n", w->fd, revents);
561	}
562
563	static void
564	ocb (struct ev_timer *w, int revents)
565	{
566	//fprintf (stderr, "timer %f,%f (%x) (%f) d%p\n", w->at, w->repeat, revents, w->at - ev_time (), w->data);
567	evtimer_stop (w);
568	evtimer_start (w);
569	}
570
571	int main (void)
572	{
573	struct ev_io sin;
574
575	ev_init (0);
576
577	evw_init (&sin, sin_cb, 55);
578	evio_set (&sin, 0, EV_READ);
579	evio_start (&sin);
580
581	struct ev_timer t[10000];
582
583	#if 1
584	int i;
585	for (i = 0; i < 10000; ++i)
586	{
587	struct ev_timer *w = t + i;
588	evw_init (w, ocb, i);
589	evtimer_set_abs (w, drand48 (), 0.99775533);
590	evtimer_start (w);
591	if (drand48 () < 0.5)
592	evtimer_stop (w);
593	}
594	#endif
595
596	struct ev_timer t1;
597	evw_init (&t1, ocb, 0);
598	evtimer_set_abs (&t1, 5, 10);
599	evtimer_start (&t1);
600
601	ev_loop (0);
602
603	return 0;
604	}
605
606	#endif
607
608
609
610