mirrors/bird
mirrors/bird
0
0
Fork 0
mirror of https://gitlab.nic.cz/labs/bird.git synced 2024-11-10 13:18:42 +00:00
Code Releases Activity
57d0ecb9b7
bird/lib/event.h

112 lines
2.3 KiB
C
Raw Normal View History

Grrr, forgot to commit the event routines themselves :|
1999-02-11 22:18:36 +00:00
/*
* BIRD Library -- Event Processing
*
* (c) 1999 Martin Mares <mj@ucw.cz>
*
* Can be freely distributed and used under the terms of the GNU GPL.
*/
#ifndef _BIRD_EVENT_H_
#define _BIRD_EVENT_H_
#include "lib/resource.h"
Converting the former BFD loop to a universal IO loop and protocol loop. There is a simple universal IO loop, taking care of events, timers and sockets. Primarily, one instance of a protocol should use exactly one IO loop to do all its work, as is now done in BFD. Contrary to previous versions, the loop is now launched and cleaned by the nest/proto.c code, allowing for a protocol to just request its own loop by setting the loop's lock order in config higher than the_bird. It is not supported nor checked if any protocol changed the requested lock order in reconfigure. No protocol should do it at all.
2021-06-19 18:50:18 +00:00
#include "lib/locking.h"
#include <stdatomic.h>
DEFINE_DOMAIN(event);
Adding a generic cork mechanism for events
2021-10-20 21:08:58 +00:00
DEFINE_DOMAIN(cork);
Grrr, forgot to commit the event routines themselves :|
1999-02-11 22:18:36 +00:00
typedef struct event {
resource r;
Event handlers no longer return re-queue flag. Instead of using it, just call ev_schedule() on the same handler which should work perfectly now.
2000-04-27 22:28:49 +00:00
void (*hook)(void *);
Grrr, forgot to commit the event routines themselves :|
1999-02-11 22:18:36 +00:00
void *data;
node n; /* Internal link */
Converting the former BFD loop to a universal IO loop and protocol loop. There is a simple universal IO loop, taking care of events, timers and sockets. Primarily, one instance of a protocol should use exactly one IO loop to do all its work, as is now done in BFD. Contrary to previous versions, the loop is now launched and cleaned by the nest/proto.c code, allowing for a protocol to just request its own loop by setting the loop's lock order in config higher than the_bird. It is not supported nor checked if any protocol changed the requested lock order in reconfigure. No protocol should do it at all.
2021-06-19 18:50:18 +00:00
struct event_list *list; /* List where this event is put in */
Adding a generic cork mechanism for events
2021-10-20 21:08:58 +00:00
struct event_cork *cork; /* Event execution limiter */
node cork_node;
Grrr, forgot to commit the event routines themselves :|
1999-02-11 22:18:36 +00:00
} event;
Converting the former BFD loop to a universal IO loop and protocol loop. There is a simple universal IO loop, taking care of events, timers and sockets. Primarily, one instance of a protocol should use exactly one IO loop to do all its work, as is now done in BFD. Contrary to previous versions, the loop is now launched and cleaned by the nest/proto.c code, allowing for a protocol to just request its own loop by setting the loop's lock order in config higher than the_bird. It is not supported nor checked if any protocol changed the requested lock order in reconfigure. No protocol should do it at all.
2021-06-19 18:50:18 +00:00
typedef struct event_list {
list events;
pool *pool;
struct birdloop *loop;
DOMAIN(event) lock;
} event_list;
Grrr, forgot to commit the event routines themselves :|
1999-02-11 22:18:36 +00:00
Adding a generic cork mechanism for events
2021-10-20 21:08:58 +00:00
struct event_cork {
DOMAIN(cork) lock;
u32 count;
list events;
};
Grrr, forgot to commit the event routines themselves :|
1999-02-11 22:18:36 +00:00
extern event_list global_event_list;
Rate-limit scheduling of work-events In general, events are code handling some some condition, which is scheduled when such condition happened and executed independently from I/O loop. Work-events are a subgroup of events that are scheduled repeatedly until some (often significant) work is done (e.g. feeding routes to protocol). All scheduled events are executed during each I/O loop iteration. Separate work-events from regular events to a separate queue and rate limit their execution to a fixed number per I/O loop iteration. That should prevent excess latency when many work-events are scheduled at one time (e.g. simultaneous reload of many BGP sessions).
2021-03-12 14:35:56 +00:00
extern event_list global_work_list;
Grrr, forgot to commit the event routines themselves :|
1999-02-11 22:18:36 +00:00
event *ev_new(pool *);
Event handlers no longer return re-queue flag. Instead of using it, just call ev_schedule() on the same handler which should work perfectly now.
2000-04-27 22:28:49 +00:00
void ev_run(event *);
Converting the former BFD loop to a universal IO loop and protocol loop. There is a simple universal IO loop, taking care of events, timers and sockets. Primarily, one instance of a protocol should use exactly one IO loop to do all its work, as is now done in BFD. Contrary to previous versions, the loop is now launched and cleaned by the nest/proto.c code, allowing for a protocol to just request its own loop by setting the loop's lock order in config higher than the_bird. It is not supported nor checked if any protocol changed the requested lock order in reconfigure. No protocol should do it at all.
2021-06-19 18:50:18 +00:00
static inline void ev_init_list(event_list *el, struct birdloop *loop, const char *name)
{
init_list(&el->events);
el->loop = loop;
el->lock = DOMAIN_NEW(event, name);
}
Adding a generic cork mechanism for events
2021-10-20 21:08:58 +00:00
static inline void ev_init_cork(struct event_cork *ec, const char *name)
{
init_list(&ec->events);
ec->lock = DOMAIN_NEW(cork, name);
ec->count = 0;
};
Converting the former BFD loop to a universal IO loop and protocol loop. There is a simple universal IO loop, taking care of events, timers and sockets. Primarily, one instance of a protocol should use exactly one IO loop to do all its work, as is now done in BFD. Contrary to previous versions, the loop is now launched and cleaned by the nest/proto.c code, allowing for a protocol to just request its own loop by setting the loop's lock order in config higher than the_bird. It is not supported nor checked if any protocol changed the requested lock order in reconfigure. No protocol should do it at all.
2021-06-19 18:50:18 +00:00
void ev_send(event_list *, event *);
#define ev_send_loop(l, e) ev_send(birdloop_event_list((l)), (e))
#define ev_schedule(e) ({ ASSERT_THE_BIRD_LOCKED; if (!ev_active((e))) ev_send(&global_event_list, (e)); })
#define ev_schedule_work(e) ({ ASSERT_THE_BIRD_LOCKED; if (!ev_active((e))) ev_send(&global_work_list, (e)); })
Grrr, forgot to commit the event routines themselves :|
1999-02-11 22:18:36 +00:00
void ev_postpone(event *);
ev_run() now returns whether the event has been requeued or not. ev_run_list() now returns number of events which remain in the list.
1999-11-17 12:01:11 +00:00
int ev_run_list(event_list *);
Rate-limit scheduling of work-events In general, events are code handling some some condition, which is scheduled when such condition happened and executed independently from I/O loop. Work-events are a subgroup of events that are scheduled repeatedly until some (often significant) work is done (e.g. feeding routes to protocol). All scheduled events are executed during each I/O loop iteration. Separate work-events from regular events to a separate queue and rate limit their execution to a fixed number per I/O loop iteration. That should prevent excess latency when many work-events are scheduled at one time (e.g. simultaneous reload of many BGP sessions).
2021-03-12 14:35:56 +00:00
int ev_run_list_limited(event_list *, uint);
Grrr, forgot to commit the event routines themselves :|
1999-02-11 22:18:36 +00:00
Converting the former BFD loop to a universal IO loop and protocol loop. There is a simple universal IO loop, taking care of events, timers and sockets. Primarily, one instance of a protocol should use exactly one IO loop to do all its work, as is now done in BFD. Contrary to previous versions, the loop is now launched and cleaned by the nest/proto.c code, allowing for a protocol to just request its own loop by setting the loop's lock order in config higher than the_bird. It is not supported nor checked if any protocol changed the requested lock order in reconfigure. No protocol should do it at all.
2021-06-19 18:50:18 +00:00
#define LEGACY_EVENT_LIST(l) (((l) == &global_event_list) || ((l) == &global_work_list))
Adding a generic cork mechanism for events
2021-10-20 21:08:58 +00:00
void ev_cork(struct event_cork *);
void ev_uncork(struct event_cork *);
static inline u32 ev_corked(struct event_cork *ec)
{
if (!ec)
return 0;
LOCK_DOMAIN(cork, ec->lock);
u32 out = ec->count;
UNLOCK_DOMAIN(cork, ec->lock);
return out;
}
Converting the former BFD loop to a universal IO loop and protocol loop. There is a simple universal IO loop, taking care of events, timers and sockets. Primarily, one instance of a protocol should use exactly one IO loop to do all its work, as is now done in BFD. Contrary to previous versions, the loop is now launched and cleaned by the nest/proto.c code, allowing for a protocol to just request its own loop by setting the loop's lock order in config higher than the_bird. It is not supported nor checked if any protocol changed the requested lock order in reconfigure. No protocol should do it at all.
2021-06-19 18:50:18 +00:00
_Bool birdloop_inside(struct birdloop *loop);
Fininshing integrated OSPF.
2014-11-03 09:42:55 +00:00
static inline int
ev_active(event *e)
{
Converting the former BFD loop to a universal IO loop and protocol loop. There is a simple universal IO loop, taking care of events, timers and sockets. Primarily, one instance of a protocol should use exactly one IO loop to do all its work, as is now done in BFD. Contrary to previous versions, the loop is now launched and cleaned by the nest/proto.c code, allowing for a protocol to just request its own loop by setting the loop's lock order in config higher than the_bird. It is not supported nor checked if any protocol changed the requested lock order in reconfigure. No protocol should do it at all.
2021-06-19 18:50:18 +00:00
if (e->list == NULL)
return 0;
ASSERT_DIE(birdloop_inside(e->list->loop));
return enlisted(&e->n);
Fininshing integrated OSPF.
2014-11-03 09:42:55 +00:00
}
Lib: Add and use ev_new_init()
2018-10-01 13:55:23 +00:00
static inline event*
ev_new_init(pool *p, void (*hook)(void *), void *data)
{
event *e = ev_new(p);
e->hook = hook;
e->data = data;
return e;
}
Fininshing integrated OSPF.
2014-11-03 09:42:55 +00:00
Grrr, forgot to commit the event routines themselves :|
1999-02-11 22:18:36 +00:00
#endif
Copy Permalink