kenmirrors/asterisk
1
0
Fork 0
mirror of https://github.com/asterisk/asterisk.git synced 2025-09-18 18:58:22 +00:00
Code Issues Packages Projects Releases Wiki Activity

timing: Improve performance for most timing implementations.

Browse Source 
This change allows timing implementation data to be stored directly
on the timer itself thus removing the requirement for many
implementations to do a container lookup for the same information.

This means that API calls into timing implementations can directly
access the information they need instead of having to find it.

Review: https://reviewboard.asterisk.org/r/3175/


git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@407749 65c4cc65-6c06-0410-ace0-fbb531ad65f3
This commit is contained in:
Joshua Colp
2014-02-07 20:01:45 +00:00
parent 5fd63e2d0b
commit e8e2f91bba
6 changed files with 268 additions and 481 deletions
Download Patch File Download Diff File Expand all files Collapse all files

17
include/asterisk/timing.h
View File

@@ -71,14 +71,15 @@ struct ast_timing_interface {
/*! This handles the case where multiple timing modules are loaded. /*! This handles the case where multiple timing modules are loaded.
* The highest priority timing interface available will be used. */ * The highest priority timing interface available will be used. */
unsigned int priority; unsigned int priority;
int (*timer_open)(void); void *(*timer_open)(void);
void (*timer_close)(int handle); void (*timer_close)(void *data);
int (*timer_set_rate)(int handle, unsigned int rate); int (*timer_set_rate)(void *data, unsigned int rate);
int (*timer_ack)(int handle, unsigned int quantity); int (*timer_ack)(void *data, unsigned int quantity);
int (*timer_enable_continuous)(int handle); int (*timer_enable_continuous)(void *data);
int (*timer_disable_continuous)(int handle); int (*timer_disable_continuous)(void *data);
enum ast_timer_event (*timer_get_event)(int handle); enum ast_timer_event (*timer_get_event)(void *data);
unsigned int (*timer_get_max_rate)(int handle); unsigned int (*timer_get_max_rate)(void *data);
int (*timer_fd)(void *data);
}; };
/*! /*!

56
main/timing.c
View File

@@ -54,7 +54,7 @@ struct timing_holder {
static struct ast_heap *timing_interfaces; static struct ast_heap *timing_interfaces;
struct ast_timer { struct ast_timer {
int fd; void *data;
struct timing_holder *holder; struct timing_holder *holder;
}; };
@@ -84,7 +84,8 @@ void *_ast_register_timing_interface(struct ast_timing_interface *funcs,
!funcs->timer_get_event || !funcs->timer_get_event ||
!funcs->timer_get_max_rate || !funcs->timer_get_max_rate ||
!funcs->timer_enable_continuous || !funcs->timer_enable_continuous ||
!funcs->timer_disable_continuous) { !funcs->timer_disable_continuous ||
!funcs->timer_fd) {
return NULL; return NULL;
} }
@@ -122,22 +123,22 @@ int ast_unregister_timing_interface(void *handle)
struct ast_timer *ast_timer_open(void) struct ast_timer *ast_timer_open(void)
{ {
int fd = -1; void *data = NULL;
struct timing_holder *h; struct timing_holder *h;
struct ast_timer *t = NULL; struct ast_timer *t = NULL;
ast_heap_rdlock(timing_interfaces); ast_heap_rdlock(timing_interfaces);
if ((h = ast_heap_peek(timing_interfaces, 1))) { if ((h = ast_heap_peek(timing_interfaces, 1))) {
fd = h->iface->timer_open(); data = h->iface->timer_open();
ast_module_ref(h->mod); ast_module_ref(h->mod);
} }
if (fd != -1) { if (data) {
if (!(t = ast_calloc(1, sizeof(*t)))) { if (!(t = ast_calloc(1, sizeof(*t)))) {
h->iface->timer_close(fd); h->iface->timer_close(data);
} else { } else {
t->fd = fd; t->data = data;
t->holder = h; t->holder = h;
} }
} }
@@ -149,69 +150,44 @@ struct ast_timer *ast_timer_open(void)
void ast_timer_close(struct ast_timer *handle) void ast_timer_close(struct ast_timer *handle)
{ {
handle->holder->iface->timer_close(handle->fd); handle->holder->iface->timer_close(handle->data);
handle->fd = -1;
ast_module_unref(handle->holder->mod); ast_module_unref(handle->holder->mod);
ast_free(handle); ast_free(handle);
} }
int ast_timer_fd(const struct ast_timer *handle) int ast_timer_fd(const struct ast_timer *handle)
{ {
return handle->fd; return handle->holder->iface->timer_fd(handle->data);
} }
int ast_timer_set_rate(const struct ast_timer *handle, unsigned int rate) int ast_timer_set_rate(const struct ast_timer *handle, unsigned int rate)
{ {
int res = -1; return handle->holder->iface->timer_set_rate(handle->data, rate);
res = handle->holder->iface->timer_set_rate(handle->fd, rate);
return res;
} }
int ast_timer_ack(const struct ast_timer *handle, unsigned int quantity) int ast_timer_ack(const struct ast_timer *handle, unsigned int quantity)
{ {
int res = -1; return handle->holder->iface->timer_ack(handle->data, quantity);
res = handle->holder->iface->timer_ack(handle->fd, quantity);
return res;
} }
int ast_timer_enable_continuous(const struct ast_timer *handle) int ast_timer_enable_continuous(const struct ast_timer *handle)
{ {
int res = -1; return handle->holder->iface->timer_enable_continuous(handle->data);
res = handle->holder->iface->timer_enable_continuous(handle->fd);
return res;
} }
int ast_timer_disable_continuous(const struct ast_timer *handle) int ast_timer_disable_continuous(const struct ast_timer *handle)
{ {
int res = -1; return handle->holder->iface->timer_disable_continuous(handle->data);
res = handle->holder->iface->timer_disable_continuous(handle->fd);
return res;
} }
enum ast_timer_event ast_timer_get_event(const struct ast_timer *handle) enum ast_timer_event ast_timer_get_event(const struct ast_timer *handle)
{ {
enum ast_timer_event res = -1; return handle->holder->iface->timer_get_event(handle->data);
res = handle->holder->iface->timer_get_event(handle->fd);
return res;
} }
unsigned int ast_timer_get_max_rate(const struct ast_timer *handle) unsigned int ast_timer_get_max_rate(const struct ast_timer *handle)
{ {
unsigned int res = 0; return handle->holder->iface->timer_get_max_rate(handle->data);
res = handle->holder->iface->timer_get_max_rate(handle->fd);
return res;
} }
const char *ast_timer_get_name(const struct ast_timer *handle) const char *ast_timer_get_name(const struct ast_timer *handle)

80
res/res_timing_dahdi.c
View File

@@ -45,14 +45,15 @@ ASTERISK_FILE_VERSION(__FILE__, "$Revision$");
static void *timing_funcs_handle; static void *timing_funcs_handle;
static int dahdi_timer_open(void); static void *dahdi_timer_open(void);
static void dahdi_timer_close(int handle); static void dahdi_timer_close(void *data);
static int dahdi_timer_set_rate(int handle, unsigned int rate); static int dahdi_timer_set_rate(void *data, unsigned int rate);
static int dahdi_timer_ack(int handle, unsigned int quantity); static int dahdi_timer_ack(void *data, unsigned int quantity);
static int dahdi_timer_enable_continuous(int handle); static int dahdi_timer_enable_continuous(void *data);
static int dahdi_timer_disable_continuous(int handle); static int dahdi_timer_disable_continuous(void *data);
static enum ast_timer_event dahdi_timer_get_event(int handle); static enum ast_timer_event dahdi_timer_get_event(void *data);
static unsigned int dahdi_timer_get_max_rate(int handle); static unsigned int dahdi_timer_get_max_rate(void *data);
static int dahdi_timer_fd(void *data);
static struct ast_timing_interface dahdi_timing = { static struct ast_timing_interface dahdi_timing = {
.name = "DAHDI", .name = "DAHDI",
@@ -65,27 +66,48 @@ static struct ast_timing_interface dahdi_timing = {
.timer_disable_continuous = dahdi_timer_disable_continuous, .timer_disable_continuous = dahdi_timer_disable_continuous,
.timer_get_event = dahdi_timer_get_event, .timer_get_event = dahdi_timer_get_event,
.timer_get_max_rate = dahdi_timer_get_max_rate, .timer_get_max_rate = dahdi_timer_get_max_rate,
.timer_fd = dahdi_timer_fd,
}; };
static int dahdi_timer_open(void) struct dahdi_timer {
int fd;
};
static void *dahdi_timer_open(void)
{ {
return open("/dev/dahdi/timer", O_RDWR); struct dahdi_timer *timer;
if (!(timer = ast_calloc(1, sizeof(*timer)))) {
return NULL;
}
if ((timer->fd = open("/dev/dahdi/timer", O_RDWR)) < 0) {
ast_log(LOG_ERROR, "Failed to create dahdi timer: %s\n", strerror(errno));
ast_free(timer);
return NULL;
}
return timer;
} }
static void dahdi_timer_close(int handle) static void dahdi_timer_close(void *data)
{ {
close(handle); struct dahdi_timer *timer = data;
close(timer->fd);
ast_free(timer);
} }
static int dahdi_timer_set_rate(int handle, unsigned int rate) static int dahdi_timer_set_rate(void *data, unsigned int rate)
{ {
struct dahdi_timer *timer = data;
int samples; int samples;
/* DAHDI timers are configured using a number of samples, /* DAHDI timers are configured using a number of samples,
* based on an 8 kHz sample rate. */ * based on an 8 kHz sample rate. */
samples = (unsigned int) roundf((8000.0 / ((float) rate))); samples = (unsigned int) roundf((8000.0 / ((float) rate)));
if (ioctl(handle, DAHDI_TIMERCONFIG, &samples)) { if (ioctl(timer->fd, DAHDI_TIMERCONFIG, &samples)) {
ast_log(LOG_ERROR, "Failed to configure DAHDI timing fd for %u sample timer ticks\n", ast_log(LOG_ERROR, "Failed to configure DAHDI timing fd for %u sample timer ticks\n",
samples); samples);
return -1; return -1;
@@ -94,31 +116,36 @@ static int dahdi_timer_set_rate(int handle, unsigned int rate)
return 0; return 0;
} }
static int dahdi_timer_ack(int handle, unsigned int quantity) static int dahdi_timer_ack(void *data, unsigned int quantity)
{ {
return ioctl(handle, DAHDI_TIMERACK, &quantity) ? -1 : 0; struct dahdi_timer *timer = data;
return ioctl(timer->fd, DAHDI_TIMERACK, &quantity) ? -1 : 0;
} }
static int dahdi_timer_enable_continuous(int handle) static int dahdi_timer_enable_continuous(void *data)
{ {
struct dahdi_timer *timer = data;
int flags = 1; int flags = 1;
return ioctl(handle, DAHDI_TIMERPING, &flags) ? -1 : 0; return ioctl(timer->fd, DAHDI_TIMERPING, &flags) ? -1 : 0;
} }
static int dahdi_timer_disable_continuous(int handle) static int dahdi_timer_disable_continuous(void *data)
{ {
struct dahdi_timer *timer = data;
int flags = -1; int flags = -1;
return ioctl(handle, DAHDI_TIMERPONG, &flags) ? -1 : 0; return ioctl(timer->fd, DAHDI_TIMERPONG, &flags) ? -1 : 0;
} }
static enum ast_timer_event dahdi_timer_get_event(int handle) static enum ast_timer_event dahdi_timer_get_event(void *data)
{ {
struct dahdi_timer *timer = data;
int res; int res;
int event; int event;
res = ioctl(handle, DAHDI_GETEVENT, &event); res = ioctl(timer->fd, DAHDI_GETEVENT, &event);
if (res) { if (res) {
event = DAHDI_EVENT_TIMER_EXPIRED; event = DAHDI_EVENT_TIMER_EXPIRED;
@@ -133,11 +160,18 @@ static enum ast_timer_event dahdi_timer_get_event(int handle)
} }
} }
static unsigned int dahdi_timer_get_max_rate(int handle) static unsigned int dahdi_timer_get_max_rate(void *data)
{ {
return 1000; return 1000;
} }
static int dahdi_timer_fd(void *data)
{
struct dahdi_timer *timer = data;
return timer->fd;
}
#define SEE_TIMING "For more information on Asterisk timing modules, including ways to potentially fix this problem, please see https://wiki.asterisk.org/wiki/display/AST/Timing+Interfaces\n" #define SEE_TIMING "For more information on Asterisk timing modules, including ways to potentially fix this problem, please see https://wiki.asterisk.org/wiki/display/AST/Timing+Interfaces\n"
static int dahdi_test_timer(void) static int dahdi_test_timer(void)

188
res/res_timing_kqueue.c
View File

@@ -48,14 +48,15 @@
static void *timing_funcs_handle; static void *timing_funcs_handle;
static int kqueue_timer_open(void); static void *kqueue_timer_open(void);
static void kqueue_timer_close(int handle); static void kqueue_timer_close(void *data);
static int kqueue_timer_set_rate(int handle, unsigned int rate); static int kqueue_timer_set_rate(void *data, unsigned int rate);
static int kqueue_timer_ack(int handle, unsigned int quantity); static int kqueue_timer_ack(void *data, unsigned int quantity);
static int kqueue_timer_enable_continuous(int handle); static int kqueue_timer_enable_continuous(void *data);
static int kqueue_timer_disable_continuous(int handle); static int kqueue_timer_disable_continuous(void *data);
static enum ast_timer_event kqueue_timer_get_event(int handle); static enum ast_timer_event kqueue_timer_get_event(void *data);
static unsigned int kqueue_timer_get_max_rate(int handle); static unsigned int kqueue_timer_get_max_rate(void *data);
static int kqueue_timer_fd(void *data);
static struct ast_timing_interface kqueue_timing = { static struct ast_timing_interface kqueue_timing = {
.name = "kqueue", .name = "kqueue",
@@ -68,10 +69,9 @@ static struct ast_timing_interface kqueue_timing = {
.timer_disable_continuous = kqueue_timer_disable_continuous, .timer_disable_continuous = kqueue_timer_disable_continuous,
.timer_get_event = kqueue_timer_get_event, .timer_get_event = kqueue_timer_get_event,
.timer_get_max_rate = kqueue_timer_get_max_rate, .timer_get_max_rate = kqueue_timer_get_max_rate,
.timer_fd = kqueue_timer_fd,
}; };
static struct ao2_container *kqueue_timers;
struct kqueue_timer { struct kqueue_timer {
int handle; int handle;
uint64_t nsecs; uint64_t nsecs;
@@ -79,73 +79,34 @@ struct kqueue_timer {
unsigned int is_continuous:1; unsigned int is_continuous:1;
}; };
static int kqueue_timer_hash(const void *obj, const int flags)
{
const struct kqueue_timer *timer = obj;
return timer->handle;
}
static int kqueue_timer_cmp(void *obj, void *args, int flags)
{
struct kqueue_timer *timer1 = obj, *timer2 = args;
return timer1->handle == timer2->handle ? CMP_MATCH | CMP_STOP : 0;
}
static void timer_destroy(void *obj) static void timer_destroy(void *obj)
{ {
struct kqueue_timer *timer = obj; struct kqueue_timer *timer = obj;
close(timer->handle); close(timer->handle);
} }
#define lookup_timer(a) _lookup_timer(a, __FILE__, __LINE__, __PRETTY_FUNCTION__) static void *kqueue_timer_open(void)
static struct kqueue_timer *_lookup_timer(int handle, const char *file, int line, const char *func)
{
struct kqueue_timer *our_timer, find_helper = {
.handle = handle,
};
if (!(our_timer = ao2_find(kqueue_timers, &find_helper, OBJ_POINTER))) {
ast_log(__LOG_ERROR, file, line, func, "Couldn't find timer with handle %d\n", handle);
/* API says we set errno */
errno = ESRCH;
return NULL;
}
return our_timer;
}
static int kqueue_timer_open(void)
{ {
struct kqueue_timer *timer; struct kqueue_timer *timer;
int handle;
if (!(timer = ao2_alloc(sizeof(*timer), timer_destroy))) { if (!(timer = ao2_alloc(sizeof(*timer), timer_destroy))) {
ast_log(LOG_ERROR, "Could not allocate memory for kqueue_timer structure\n"); ast_log(LOG_ERROR, "Could not allocate memory for kqueue_timer structure\n");
return -1; return -1;
} }
if ((handle = kqueue()) < 0) { if ((timer->handle = kqueue()) < 0) {
ast_log(LOG_ERROR, "Failed to create kqueue timer: %s\n", strerror(errno)); ast_log(LOG_ERROR, "Failed to create kqueue timer: %s\n", strerror(errno));
ao2_ref(timer, -1); ao2_ref(timer, -1);
return -1; return -1;
} }
timer->handle = handle; return timer;
ao2_link(kqueue_timers, timer);
/* Get rid of the reference from the allocation */
ao2_ref(timer, -1);
return handle;
} }
static void kqueue_timer_close(int handle) static void kqueue_timer_close(void *data)
{ {
struct kqueue_timer *our_timer; struct kqueue_timer *timer = data;
if (!(our_timer = lookup_timer(handle))) { ao2_ref(timer, -1);
return;
}
ao2_unlink(kqueue_timers, our_timer);
ao2_ref(our_timer, -1);
} }
static void kqueue_set_nsecs(struct kqueue_timer *our_timer, uint64_t nsecs) static void kqueue_set_nsecs(struct kqueue_timer *our_timer, uint64_t nsecs)
@@ -183,107 +144,90 @@ static void kqueue_set_nsecs(struct kqueue_timer *our_timer, uint64_t nsecs)
#endif #endif
} }
static int kqueue_timer_set_rate(int handle, unsigned int rate) static int kqueue_timer_set_rate(void *data, unsigned int rate)
{ {
struct kqueue_timer *our_timer; struct kqueue_timer *timer = data;
if (!(our_timer = lookup_timer(handle))) { kqueue_set_nsecs(timer, (timer->nsecs = rate ? (long) (1000000000 / rate) : 0L));
return -1;
}
kqueue_set_nsecs(our_timer, (our_timer->nsecs = rate ? (long) (1000000000 / rate) : 0L));
ao2_ref(our_timer, -1);
return 0; return 0;
} }
static int kqueue_timer_ack(int handle, unsigned int quantity) static int kqueue_timer_ack(void *data, unsigned int quantity)
{ {
struct kqueue_timer *our_timer; struct kqueue_timer *timer = data;
if (!(our_timer = lookup_timer(handle))) { if (timer->unacked < quantity) {
return -1;
}
if (our_timer->unacked < quantity) {
ast_debug(1, "Acking more events than have expired?!!\n"); ast_debug(1, "Acking more events than have expired?!!\n");
our_timer->unacked = 0; timer->unacked = 0;
ao2_ref(our_timer, -1);
return -1; return -1;
} else { } else {
our_timer->unacked -= quantity; timer->unacked -= quantity;
} }
ao2_ref(our_timer, -1);
return 0; return 0;
} }
static int kqueue_timer_enable_continuous(int handle) static int kqueue_timer_enable_continuous(void *data)
{ {
struct kqueue_timer *our_timer; struct kqueue_timer *timer = data;
if (!(our_timer = lookup_timer(handle))) { kqueue_set_nsecs(timer, 1);
return -1; timer->is_continuous = 1;
} timer->unacked = 0;
kqueue_set_nsecs(our_timer, 1);
our_timer->is_continuous = 1;
our_timer->unacked = 0;
ao2_ref(our_timer, -1);
return 0; return 0;
} }
static int kqueue_timer_disable_continuous(int handle) static int kqueue_timer_disable_continuous(void *data)
{ {
struct kqueue_timer *our_timer; struct kqueue_timer *timer = data;
if (!(our_timer = lookup_timer(handle))) { kqueue_set_nsecs(timer, timer->nsecs);
return -1; timer->is_continuous = 0;
} timer->unacked = 0;
kqueue_set_nsecs(our_timer, our_timer->nsecs);
our_timer->is_continuous = 0;
our_timer->unacked = 0;
ao2_ref(our_timer, -1);
return 0; return 0;
} }
static enum ast_timer_event kqueue_timer_get_event(int handle) static enum ast_timer_event kqueue_timer_get_event(void *data)
{ {
struct kqueue_timer *timer = data;
enum ast_timer_event res = -1; enum ast_timer_event res = -1;
struct kqueue_timer *our_timer;
struct timespec sixty_seconds = { 60, 0 }; struct timespec sixty_seconds = { 60, 0 };
struct kevent kev; struct kevent kev;
if (!(our_timer = lookup_timer(handle))) {
return -1;
}
/* If we have non-ACKed events, just return immediately */ /* If we have non-ACKed events, just return immediately */
if (our_timer->unacked == 0) { if (timer->unacked == 0) {
if (kevent(handle, NULL, 0, &kev, 1, &sixty_seconds) > 0) { if (kevent(timer->handle, NULL, 0, &kev, 1, &sixty_seconds) > 0) {
our_timer->unacked += kev.data; timer->unacked += kev.data;
} }
} }
if (our_timer->unacked > 0) { if (timer->unacked > 0) {
res = our_timer->is_continuous ? AST_TIMING_EVENT_CONTINUOUS : AST_TIMING_EVENT_EXPIRED; res = timer->is_continuous ? AST_TIMING_EVENT_CONTINUOUS : AST_TIMING_EVENT_EXPIRED;
} }
ao2_ref(our_timer, -1);
return res; return res;
} }
static unsigned int kqueue_timer_get_max_rate(int handle) static unsigned int kqueue_timer_get_max_rate(void *data)
{ {
/* Actually, the max rate is 2^64-1 seconds, but that's not representable in a 32-bit integer. */ /* Actually, the max rate is 2^64-1 seconds, but that's not representable in a 32-bit integer. */
return UINT_MAX; return UINT_MAX;
} }
static int kqueue_timer_fd(void *data)
{
struct kqueue_timer *timer = data;
return timer->handle;
}
#ifdef TEST_FRAMEWORK #ifdef TEST_FRAMEWORK
AST_TEST_DEFINE(test_kqueue_timing) AST_TEST_DEFINE(test_kqueue_timing)
{ {
int res = AST_TEST_PASS, handle, i; int res = AST_TEST_PASS, i;
uint64_t diff; uint64_t diff;
struct pollfd pfd = { 0, POLLIN, 0 }; struct pollfd pfd = { 0, POLLIN, 0 };
struct kqueue_timer *kt; struct kqueue_timer *kt;
@@ -300,14 +244,14 @@ AST_TEST_DEFINE(test_kqueue_timing)
break; break;
} }
if (!(handle = kqueue_timer_open())) { if (!(kt = kqueue_timer_open())) {
ast_test_status_update(test, "Cannot open timer!\n"); ast_test_status_update(test, "Cannot open timer!\n");
return AST_TEST_FAIL; return AST_TEST_FAIL;
} }
do { do {
pfd.fd = handle; pfd.fd = ast_timer_fd(kt);
if (kqueue_timer_set_rate(handle, 1000)) { if (kqueue_timer_set_rate(kt, 1000)) {
ast_test_status_update(test, "Cannot set timer rate to 1000/s\n"); ast_test_status_update(test, "Cannot set timer rate to 1000/s\n");
res = AST_TEST_FAIL; res = AST_TEST_FAIL;
break; break;
@@ -322,12 +266,7 @@ AST_TEST_DEFINE(test_kqueue_timing)
res = AST_TEST_FAIL; res = AST_TEST_FAIL;
break; break;
} }
if (!(kt = lookup_timer(handle))) { if (kqueue_timer_get_event(kt) <= 0) {
ast_test_status_update(test, "Could not find timer structure in container?!!\n");
res = AST_TEST_FAIL;
break;
}
if (kqueue_timer_get_event(handle) <= 0) {
ast_test_status_update(test, "No events generated after a poll returned successfully?!!\n"); ast_test_status_update(test, "No events generated after a poll returned successfully?!!\n");
res = AST_TEST_FAIL; res = AST_TEST_FAIL;
break; break;
@@ -339,7 +278,7 @@ AST_TEST_DEFINE(test_kqueue_timing)
break; break;
} }
#endif #endif
kqueue_timer_enable_continuous(handle); kqueue_timer_enable_continuous(kt);
start = ast_tvnow(); start = ast_tvnow();
for (i = 0; i < 100; i++) { for (i = 0; i < 100; i++) {
if (ast_poll(&pfd, 1, 1000) < 1) { if (ast_poll(&pfd, 1, 1000) < 1) {
@@ -347,7 +286,7 @@ AST_TEST_DEFINE(test_kqueue_timing)
res = AST_TEST_FAIL; res = AST_TEST_FAIL;
break; break;
} }
if (kqueue_timer_get_event(handle) <= 0) { if (kqueue_timer_get_event(kt) <= 0) {
ast_test_status_update(test, "No events generated in continuous mode after 1 microsecond?!!\n"); ast_test_status_update(test, "No events generated in continuous mode after 1 microsecond?!!\n");
res = AST_TEST_FAIL; res = AST_TEST_FAIL;
break; break;
@@ -362,7 +301,7 @@ AST_TEST_DEFINE(test_kqueue_timing)
} }
*/ */
} while (0); } while (0);
kqueue_timer_close(handle); kqueue_timer_close(kt);
return res; return res;
} }
#endif #endif
@@ -379,12 +318,7 @@ AST_TEST_DEFINE(test_kqueue_timing)
*/ */
static int load_module(void) static int load_module(void)
{ {
if (!(kqueue_timers = ao2_container_alloc(563, kqueue_timer_hash, kqueue_timer_cmp))) {
return AST_MODULE_LOAD_DECLINE;
}
if (!(timing_funcs_handle = ast_register_timing_interface(&kqueue_timing))) { if (!(timing_funcs_handle = ast_register_timing_interface(&kqueue_timing))) {
ao2_ref(kqueue_timers, -1);
return AST_MODULE_LOAD_DECLINE; return AST_MODULE_LOAD_DECLINE;
} }
@@ -394,15 +328,9 @@ static int load_module(void)
static int unload_module(void) static int unload_module(void)
{ {
int res;
AST_TEST_UNREGISTER(test_kqueue_timing); AST_TEST_UNREGISTER(test_kqueue_timing);
if (!(res = ast_unregister_timing_interface(timing_funcs_handle))) {
ao2_ref(kqueue_timers, -1);
kqueue_timers = NULL;
}
return res; return ast_unregister_timing_interface(timing_funcs_handle);
} }
AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_LOAD_ORDER, "KQueue Timing Interface", AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_LOAD_ORDER, "KQueue Timing Interface",

114
res/res_timing_pthread.c
View File

@@ -45,14 +45,15 @@ ASTERISK_FILE_VERSION(__FILE__, "$Revision$");
static void *timing_funcs_handle; static void *timing_funcs_handle;
static int pthread_timer_open(void); static void *pthread_timer_open(void);
static void pthread_timer_close(int handle); static void pthread_timer_close(void *data);
static int pthread_timer_set_rate(int handle, unsigned int rate); static int pthread_timer_set_rate(void *data, unsigned int rate);
static int pthread_timer_ack(int handle, unsigned int quantity); static int pthread_timer_ack(void *data, unsigned int quantity);
static int pthread_timer_enable_continuous(int handle); static int pthread_timer_enable_continuous(void *data);
static int pthread_timer_disable_continuous(int handle); static int pthread_timer_disable_continuous(void *data);
static enum ast_timer_event pthread_timer_get_event(int handle); static enum ast_timer_event pthread_timer_get_event(void *data);
static unsigned int pthread_timer_get_max_rate(int handle); static unsigned int pthread_timer_get_max_rate(void *data);
static int pthread_timer_fd(void *data);
static struct ast_timing_interface pthread_timing = { static struct ast_timing_interface pthread_timing = {
.name = "pthread", .name = "pthread",
@@ -65,6 +66,7 @@ static struct ast_timing_interface pthread_timing = {
.timer_disable_continuous = pthread_timer_disable_continuous, .timer_disable_continuous = pthread_timer_disable_continuous,
.timer_get_event = pthread_timer_get_event, .timer_get_event = pthread_timer_get_event,
.timer_get_max_rate = pthread_timer_get_max_rate, .timer_get_max_rate = pthread_timer_get_max_rate,
.timer_fd = pthread_timer_fd,
}; };
/* 1 tick / 10 ms */ /* 1 tick / 10 ms */
@@ -97,7 +99,6 @@ struct pthread_timer {
}; };
static void pthread_timer_destructor(void *obj); static void pthread_timer_destructor(void *obj);
static struct pthread_timer *find_timer(int handle, int unlinkobj);
static void signal_pipe(struct pthread_timer *timer); static void signal_pipe(struct pthread_timer *timer);
static void unsignal_pipe(struct pthread_timer *timer); static void unsignal_pipe(struct pthread_timer *timer);
static void ack_ticks(struct pthread_timer *timer, unsigned int num); static void ack_ticks(struct pthread_timer *timer, unsigned int num);
@@ -112,15 +113,14 @@ static struct {
unsigned int stop:1; unsigned int stop:1;
} timing_thread; } timing_thread;
static int pthread_timer_open(void) static void *pthread_timer_open(void)
{ {
struct pthread_timer *timer; struct pthread_timer *timer;
int fd;
int i; int i;
if (!(timer = ao2_alloc(sizeof(*timer), pthread_timer_destructor))) { if (!(timer = ao2_alloc(sizeof(*timer), pthread_timer_destructor))) {
errno = ENOMEM; errno = ENOMEM;
return -1; return NULL;
} }
timer->pipe[PIPE_READ] = timer->pipe[PIPE_WRITE] = -1; timer->pipe[PIPE_READ] = timer->pipe[PIPE_WRITE] = -1;
@@ -128,7 +128,7 @@ static int pthread_timer_open(void)
if (pipe(timer->pipe)) { if (pipe(timer->pipe)) {
ao2_ref(timer, -1); ao2_ref(timer, -1);
return -1; return NULL;
} }
for (i = 0; i < ARRAY_LEN(timer->pipe); ++i) { for (i = 0; i < ARRAY_LEN(timer->pipe); ++i) {
@@ -146,32 +146,19 @@ static int pthread_timer_open(void)
ao2_link(pthread_timers, timer); ao2_link(pthread_timers, timer);
ao2_unlock(pthread_timers); ao2_unlock(pthread_timers);
fd = timer->pipe[PIPE_READ]; return timer;
ao2_ref(timer, -1);
return fd;
} }
static void pthread_timer_close(int handle) static void pthread_timer_close(void *data)
{ {
struct pthread_timer *timer; struct pthread_timer *timer = data;
if (!(timer = find_timer(handle, 1))) {
return;
}
ao2_ref(timer, -1); ao2_ref(timer, -1);
} }
static int pthread_timer_set_rate(int handle, unsigned int rate) static int pthread_timer_set_rate(void *data, unsigned int rate)
{ {
struct pthread_timer *timer; struct pthread_timer *timer = data;
if (!(timer = find_timer(handle, 0))) {
errno = EINVAL;
return -1;
}
if (rate > MAX_RATE) { if (rate > MAX_RATE) {
ast_log(LOG_ERROR, "res_timing_pthread only supports timers at a " ast_log(LOG_ERROR, "res_timing_pthread only supports timers at a "
@@ -195,38 +182,25 @@ static int pthread_timer_set_rate(int handle, unsigned int rate)
ao2_unlock(timer); ao2_unlock(timer);
ao2_ref(timer, -1);
return 0; return 0;
} }
static int pthread_timer_ack(int handle, unsigned int quantity) static int pthread_timer_ack(void *data, unsigned int quantity)
{ {
struct pthread_timer *timer; struct pthread_timer *timer = data;
ast_assert(quantity > 0); ast_assert(quantity > 0);
if (!(timer = find_timer(handle, 0))) {
return -1;
}
ao2_lock(timer); ao2_lock(timer);
ack_ticks(timer, quantity); ack_ticks(timer, quantity);
ao2_unlock(timer); ao2_unlock(timer);
ao2_ref(timer, -1);
return 0; return 0;
} }
static int pthread_timer_enable_continuous(int handle) static int pthread_timer_enable_continuous(void *data)
{ {
struct pthread_timer *timer; struct pthread_timer *timer = data;
if (!(timer = find_timer(handle, 0))) {
errno = EINVAL;
return -1;
}
ao2_lock(timer); ao2_lock(timer);
if (!timer->continuous) { if (!timer->continuous) {
@@ -235,19 +209,12 @@ static int pthread_timer_enable_continuous(int handle)
} }
ao2_unlock(timer); ao2_unlock(timer);
ao2_ref(timer, -1);
return 0; return 0;
} }
static int pthread_timer_disable_continuous(int handle) static int pthread_timer_disable_continuous(void *data)
{ {
struct pthread_timer *timer; struct pthread_timer *timer = data;
if (!(timer = find_timer(handle, 0))) {
errno = EINVAL;
return -1;
}
ao2_lock(timer); ao2_lock(timer);
if (timer->continuous) { if (timer->continuous) {
@@ -256,54 +223,33 @@ static int pthread_timer_disable_continuous(int handle)
} }
ao2_unlock(timer); ao2_unlock(timer);
ao2_ref(timer, -1);
return 0; return 0;
} }
static enum ast_timer_event pthread_timer_get_event(int handle) static enum ast_timer_event pthread_timer_get_event(void *data)
{ {
struct pthread_timer *timer; struct pthread_timer *timer = data;
enum ast_timer_event res = AST_TIMING_EVENT_EXPIRED; enum ast_timer_event res = AST_TIMING_EVENT_EXPIRED;
if (!(timer = find_timer(handle, 0))) {
return res;
}
ao2_lock(timer); ao2_lock(timer);
if (timer->continuous) { if (timer->continuous) {
res = AST_TIMING_EVENT_CONTINUOUS; res = AST_TIMING_EVENT_CONTINUOUS;
} }
ao2_unlock(timer); ao2_unlock(timer);
ao2_ref(timer, -1);
return res; return res;
} }
static unsigned int pthread_timer_get_max_rate(int handle) static unsigned int pthread_timer_get_max_rate(void *data)
{ {
return MAX_RATE; return MAX_RATE;
} }
static struct pthread_timer *find_timer(int handle, int unlinkobj) static int pthread_timer_fd(void *data)
{ {
struct pthread_timer *timer; struct pthread_timer *timer = data;
struct pthread_timer tmp_timer;
int flags = OBJ_POINTER;
tmp_timer.pipe[PIPE_READ] = handle; return timer->pipe[PIPE_READ];
if (unlinkobj) {
flags |= OBJ_UNLINK;
}
if (!(timer = ao2_find(pthread_timers, &tmp_timer, flags))) {
ast_assert(timer != NULL);
return NULL;
}
return timer;
} }
static void pthread_timer_destructor(void *obj) static void pthread_timer_destructor(void *obj)

250
res/res_timing_timerfd.c
View File

@@ -41,14 +41,15 @@
static void *timing_funcs_handle; static void *timing_funcs_handle;
static int timerfd_timer_open(void); static void *timerfd_timer_open(void);
static void timerfd_timer_close(int handle); static void timerfd_timer_close(void *data);
static int timerfd_timer_set_rate(int handle, unsigned int rate); static int timerfd_timer_set_rate(void *data, unsigned int rate);
static int timerfd_timer_ack(int handle, unsigned int quantity); static int timerfd_timer_ack(void *data, unsigned int quantity);
static int timerfd_timer_enable_continuous(int handle); static int timerfd_timer_enable_continuous(void *data);
static int timerfd_timer_disable_continuous(int handle); static int timerfd_timer_disable_continuous(void *data);
static enum ast_timer_event timerfd_timer_get_event(int handle); static enum ast_timer_event timerfd_timer_get_event(void *data);
static unsigned int timerfd_timer_get_max_rate(int handle); static unsigned int timerfd_timer_get_max_rate(void *data);
static int timerfd_timer_fd(void *data);
static struct ast_timing_interface timerfd_timing = { static struct ast_timing_interface timerfd_timing = {
.name = "timerfd", .name = "timerfd",
@@ -61,152 +62,93 @@ static struct ast_timing_interface timerfd_timing = {
.timer_disable_continuous = timerfd_timer_disable_continuous, .timer_disable_continuous = timerfd_timer_disable_continuous,
.timer_get_event = timerfd_timer_get_event, .timer_get_event = timerfd_timer_get_event,
.timer_get_max_rate = timerfd_timer_get_max_rate, .timer_get_max_rate = timerfd_timer_get_max_rate,
.timer_fd = timerfd_timer_fd,
}; };
static struct ao2_container *timerfd_timers;
#define TIMERFD_TIMER_BUCKETS 563
#define TIMERFD_MAX_RATE 1000 #define TIMERFD_MAX_RATE 1000
struct timerfd_timer { struct timerfd_timer {
int handle; int fd;
struct itimerspec saved_timer; struct itimerspec saved_timer;
unsigned int is_continuous:1; unsigned int is_continuous:1;
}; };
static int timerfd_timer_hash(const void *obj, const int flags)
{
const struct timerfd_timer *timer = obj;
return timer->handle;
}
static int timerfd_timer_cmp(void *obj, void *args, int flags)
{
struct timerfd_timer *timer1 = obj, *timer2 = args;
return timer1->handle == timer2->handle ? CMP_MATCH | CMP_STOP : 0;
}
static void timer_destroy(void *obj) static void timer_destroy(void *obj)
{ {
struct timerfd_timer *timer = obj; struct timerfd_timer *timer = obj;
close(timer->handle);
timer->handle = -1; close(timer->fd);
} }
static int timerfd_timer_open(void) static void *timerfd_timer_open(void)
{ {
struct timerfd_timer *timer; struct timerfd_timer *timer;
int handle;
if (!(timer = ao2_alloc(sizeof(*timer), timer_destroy))) { if (!(timer = ao2_alloc(sizeof(*timer), timer_destroy))) {
ast_log(LOG_ERROR, "Could not allocate memory for timerfd_timer structure\n"); ast_log(LOG_ERROR, "Could not allocate memory for timerfd_timer structure\n");
return -1; return NULL;
} }
if ((handle = timerfd_create(CLOCK_MONOTONIC, 0)) < 0) { if ((timer->fd = timerfd_create(CLOCK_MONOTONIC, 0)) < 0) {
ast_log(LOG_ERROR, "Failed to create timerfd timer: %s\n", strerror(errno)); ast_log(LOG_ERROR, "Failed to create timerfd timer: %s\n", strerror(errno));
ao2_ref(timer, -1); ao2_ref(timer, -1);
return -1; return NULL;
} }
timer->handle = handle; return timer;
ao2_link(timerfd_timers, timer);
/* Get rid of the reference from the allocation */
ao2_ref(timer, -1);
return handle;
} }
static void timerfd_timer_close(int handle) static void timerfd_timer_close(void *data)
{ {
struct timerfd_timer *our_timer, find_helper = { ao2_ref(data, -1);
.handle = handle,
};
if (handle == -1) {
ast_log(LOG_ERROR, "Attempting to close timerfd handle -1");
return;
}
if (!(our_timer = ao2_find(timerfd_timers, &find_helper, OBJ_POINTER))) {
ast_log(LOG_ERROR, "Couldn't find timer with handle %d\n", handle);
return;
}
ao2_unlink(timerfd_timers, our_timer);
ao2_ref(our_timer, -1);
} }
static int timerfd_timer_set_rate(int handle, unsigned int rate) static int timerfd_timer_set_rate(void *data, unsigned int rate)
{ {
struct timerfd_timer *our_timer, find_helper = { struct timerfd_timer *timer = data;
.handle = handle,
};
int res = 0; int res = 0;
if (handle == -1) { ao2_lock(timer);
ast_log(LOG_ERROR, "Attempting to set rate on timerfd handle -1");
return -1; timer->saved_timer.it_value.tv_sec = 0;
timer->saved_timer.it_value.tv_nsec = rate ? (long) (1000000000 / rate) : 0L;
timer->saved_timer.it_interval.tv_sec = timer->saved_timer.it_value.tv_sec;
timer->saved_timer.it_interval.tv_nsec = timer->saved_timer.it_value.tv_nsec;
if (!timer->is_continuous) {
res = timerfd_settime(timer->fd, 0, &timer->saved_timer, NULL);
} }
if (!(our_timer = ao2_find(timerfd_timers, &find_helper, OBJ_POINTER))) { ao2_unlock(timer);
ast_log(LOG_ERROR, "Couldn't find timer with handle %d\n", handle);
return -1;
}
ao2_lock(our_timer);
our_timer->saved_timer.it_value.tv_sec = 0;
our_timer->saved_timer.it_value.tv_nsec = rate ? (long) (1000000000 / rate) : 0L;
our_timer->saved_timer.it_interval.tv_sec = our_timer->saved_timer.it_value.tv_sec;
our_timer->saved_timer.it_interval.tv_nsec = our_timer->saved_timer.it_value.tv_nsec;
if (!our_timer->is_continuous) {
res = timerfd_settime(handle, 0, &our_timer->saved_timer, NULL);
}
ao2_unlock(our_timer);
ao2_ref(our_timer, -1);
return res; return res;
} }
static int timerfd_timer_ack(int handle, unsigned int quantity) static int timerfd_timer_ack(void *data, unsigned int quantity)
{ {
struct timerfd_timer *timer = data;
uint64_t expirations; uint64_t expirations;
int read_result = 0; int read_result = 0;
int res = 0; int res = 0;
struct timerfd_timer *our_timer, find_helper = {
.handle = handle,
};
if (handle == -1) { ao2_lock(timer);
ast_log(LOG_ERROR, "Attempting to ack timerfd handle -1");
return -1;
}
if (!(our_timer = ao2_find(timerfd_timers, &find_helper, OBJ_POINTER))) {
ast_log(LOG_ERROR, "Couldn't find a timer with handle %d\n", handle);
return -1;
}
ao2_lock(our_timer);
do { do {
struct itimerspec timer_status; struct itimerspec timer_status;
if (timerfd_gettime(handle, &timer_status)) { if (timerfd_gettime(timer->fd, &timer_status)) {
ast_log(LOG_ERROR, "Call to timerfd_gettime() using handle %d error: %s\n", handle, strerror(errno)); ast_log(LOG_ERROR, "Call to timerfd_gettime() using handle %d error: %s\n", timer->fd, strerror(errno));
expirations = 0; expirations = 0;
res = -1; res = -1;
break; break;
} }
if (timer_status.it_value.tv_sec == 0 && timer_status.it_value.tv_nsec == 0) { if (timer_status.it_value.tv_sec == 0 && timer_status.it_value.tv_nsec == 0) {
ast_debug(1, "Avoiding read on disarmed timerfd %d\n", handle); ast_debug(1, "Avoiding read on disarmed timerfd %d\n", timer->fd);
expirations = 0; expirations = 0;
break; break;
} }
read_result = read(handle, &expirations, sizeof(expirations)); read_result = read(timer->fd, &expirations, sizeof(expirations));
if (read_result == -1) { if (read_result == -1) {
if (errno == EINTR || errno == EAGAIN) { if (errno == EINTR || errno == EAGAIN) {
continue; continue;
@@ -218,121 +160,93 @@ static int timerfd_timer_ack(int handle, unsigned int quantity)
} }
} while (read_result != sizeof(expirations)); } while (read_result != sizeof(expirations));
ao2_unlock(our_timer); ao2_unlock(timer);
ao2_ref(our_timer, -1);
if (expirations != quantity) { if (expirations != quantity) {
ast_debug(2, "Expected to acknowledge %u ticks but got %llu instead\n", quantity, (unsigned long long) expirations); ast_debug(2, "Expected to acknowledge %u ticks but got %llu instead\n", quantity, (unsigned long long) expirations);
} }
return res; return res;
} }
static int timerfd_timer_enable_continuous(int handle) static int timerfd_timer_enable_continuous(void *data)
{ {
struct timerfd_timer *timer = data;
int res; int res;
struct itimerspec continuous_timer = { static const struct itimerspec continuous_timer = {
.it_value.tv_nsec = 1L, .it_value.tv_nsec = 1L,
}; };
struct timerfd_timer *our_timer, find_helper = {
.handle = handle,
};
if (handle == -1) { ao2_lock(timer);
ast_log(LOG_ERROR, "Attempting to enable timerfd handle -1");
return -1;
}
if (!(our_timer = ao2_find(timerfd_timers, &find_helper, OBJ_POINTER))) { if (timer->is_continuous) {
ast_log(LOG_ERROR, "Couldn't find timer with handle %d\n", handle);
return -1;
}
ao2_lock(our_timer);
if (our_timer->is_continuous) {
/*It's already in continous mode, no need to do /*It's already in continous mode, no need to do
* anything further * anything further
*/ */
ao2_unlock(our_timer); ao2_unlock(timer);
ao2_ref(our_timer, -1);
return 0; return 0;
} }
res = timerfd_settime(handle, 0, &continuous_timer, &our_timer->saved_timer); res = timerfd_settime(timer->fd, 0, &continuous_timer, &timer->saved_timer);
our_timer->is_continuous = 1; timer->is_continuous = 1;
ao2_unlock(our_timer); ao2_unlock(timer);
ao2_ref(our_timer, -1);
return res; return res;
} }
static int timerfd_timer_disable_continuous(int handle) static int timerfd_timer_disable_continuous(void *data)
{ {
struct timerfd_timer *timer = data;
int res; int res;
struct timerfd_timer *our_timer, find_helper = {
.handle = handle,
};
if (handle == -1) { ao2_lock(timer);
ast_log(LOG_ERROR, "Attempting to disable timerfd handle -1");
return -1;
}
if (!(our_timer = ao2_find(timerfd_timers, &find_helper, OBJ_POINTER))) { if (!timer->is_continuous) {
ast_log(LOG_ERROR, "Couldn't find timer with handle %d\n", handle);
return -1;
}
ao2_lock(our_timer);
if (!our_timer->is_continuous) {
/* No reason to do anything if we're not /* No reason to do anything if we're not
* in continuous mode * in continuous mode
*/ */
ao2_unlock(our_timer); ao2_unlock(timer);
ao2_ref(our_timer, -1);
return 0; return 0;
} }
res = timerfd_settime(handle, 0, &our_timer->saved_timer, NULL); res = timerfd_settime(timer->fd, 0, &timer->saved_timer, NULL);
our_timer->is_continuous = 0; timer->is_continuous = 0;
memset(&our_timer->saved_timer, 0, sizeof(our_timer->saved_timer)); memset(&timer->saved_timer, 0, sizeof(timer->saved_timer));
ao2_unlock(our_timer); ao2_unlock(timer);
ao2_ref(our_timer, -1);
return res; return res;
} }
static enum ast_timer_event timerfd_timer_get_event(int handle) static enum ast_timer_event timerfd_timer_get_event(void *data)
{ {
struct timerfd_timer *timer = data;
enum ast_timer_event res; enum ast_timer_event res;
struct timerfd_timer *our_timer, find_helper = {
.handle = handle,
};
if (handle == -1) { ao2_lock(timer);
ast_log(LOG_ERROR, "Attempting to get event from timerfd handle -1");
return -1;
}
if (!(our_timer = ao2_find(timerfd_timers, &find_helper, OBJ_POINTER))) { if (timer->is_continuous) {
ast_log(LOG_ERROR, "Couldn't find timer with handle %d\n", handle);
return -1;
}
ao2_lock(our_timer);
if (our_timer->is_continuous) {
res = AST_TIMING_EVENT_CONTINUOUS; res = AST_TIMING_EVENT_CONTINUOUS;
} else { } else {
res = AST_TIMING_EVENT_EXPIRED; res = AST_TIMING_EVENT_EXPIRED;
} }
ao2_unlock(our_timer); ao2_unlock(timer);
ao2_ref(our_timer, -1);
return res; return res;
} }
static unsigned int timerfd_timer_get_max_rate(int handle) static unsigned int timerfd_timer_get_max_rate(void *data)
{ {
return TIMERFD_MAX_RATE; return TIMERFD_MAX_RATE;
} }
static int timerfd_timer_fd(void *data)
{
struct timerfd_timer *timer = data;
return timer->fd;
}
static int load_module(void) static int load_module(void)
{ {
int fd; int fd;
@@ -345,12 +259,7 @@ static int load_module(void)
close(fd); close(fd);
if (!(timerfd_timers = ao2_container_alloc(TIMERFD_TIMER_BUCKETS, timerfd_timer_hash, timerfd_timer_cmp))) {
return AST_MODULE_LOAD_DECLINE;
}
if (!(timing_funcs_handle = ast_register_timing_interface(&timerfd_timing))) { if (!(timing_funcs_handle = ast_register_timing_interface(&timerfd_timing))) {
ao2_ref(timerfd_timers, -1);
return AST_MODULE_LOAD_DECLINE; return AST_MODULE_LOAD_DECLINE;
} }
@@ -359,14 +268,7 @@ static int load_module(void)
static int unload_module(void) static int unload_module(void)
{ {
int res; return ast_unregister_timing_interface(timing_funcs_handle);
if (!(res = ast_unregister_timing_interface(timing_funcs_handle))) {
ao2_ref(timerfd_timers, -1);
timerfd_timers = NULL;
}
return res;
} }
AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_LOAD_ORDER, "Timerfd Timing Interface", AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_LOAD_ORDER, "Timerfd Timing Interface",