res_timing_pthread.c File Reference

pthread timing interface More...

#include "asterisk.h"
#include <stdbool.h>
#include <math.h>
#include <unistd.h>
#include <fcntl.h>
#include "asterisk/module.h"
#include "asterisk/timing.h"
#include "asterisk/utils.h"
#include "asterisk/astobj2.h"
#include "asterisk/time.h"
#include "asterisk/lock.h"

Include dependency graph for res_timing_pthread.c:

Go to the source code of this file.

Data Structures
struct	pthread_timer

Macros
#define	MAX_RATE   100
#define	PTHREAD_TIMER_BUCKETS   563

Enumerations
enum	{ PIPE_READ = 0, PIPE_WRITE = 1 }
enum	pthread_timer_state { TIMER_STATE_IDLE, TIMER_STATE_TICKING }

Functions
static void	__reg_module (void)
static void	__unreg_module (void)
static void	ack_ticks (struct pthread_timer *timer, unsigned int num)
struct ast_module *	AST_MODULE_SELF_SYM (void)
static int	check_timer (struct pthread_timer *timer)
static void *	do_timing (void *arg)
static int	init_timing_thread (void)
static int	load_module (void)
static int	pthread_timer_ack (void *data, unsigned int quantity)
static void	pthread_timer_close (void *data)
static int	pthread_timer_cmp (void *obj, void *arg, int flags)
static void	pthread_timer_destructor (void *obj)
static int	pthread_timer_disable_continuous (void *data)
static int	pthread_timer_enable_continuous (void *data)
static int	pthread_timer_fd (void *data)
static enum ast_timer_event	pthread_timer_get_event (void *data)
static unsigned int	pthread_timer_get_max_rate (void *data)
static int	pthread_timer_hash (const void *obj, const int flags)
static void *	pthread_timer_open (void)
static int	pthread_timer_set_rate (void *data, unsigned int rate)
static int	run_timer (void *obj, void *arg, int flags)
static void	signal_pipe (struct pthread_timer *timer)
static int	unload_module (void)
static void	unsignal_pipe (struct pthread_timer *timer)

Variables
static struct ast_module_info	__mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_LOAD_ORDER , .description = "pthread Timing Interface" , .key = "This paragraph is copyright (c) 2006 by Digium, Inc. \In order for your module to load, it must return this \key via a function called \"key\". Any code which \includes this paragraph must be licensed under the GNU \General Public License version 2 or later (at your \option). In addition to Digium's general reservations \of rights, Digium expressly reserves the right to \allow other parties to license this paragraph under \different terms. Any use of Digium, Inc. trademarks or \logos (including \"Asterisk\" or \"Digium\") without \express written permission of Digium, Inc. is prohibited.\n" , .buildopt_sum = AST_BUILDOPT_SUM, .support_level = AST_MODULE_SUPPORT_EXTENDED, .load = load_module, .unload = unload_module, .load_pri = AST_MODPRI_TIMING, }
static const struct ast_module_info *	ast_module_info = &__mod_info
static struct ao2_container *	pthread_timers
static struct ast_timing_interface	pthread_timing
static void *	timing_funcs_handle
struct {
ast_cond_t   cond
ast_mutex_t   lock
unsigned int   stop:1
pthread_t   thread
}	timing_thread
	Data for the timing thread. More...

Detailed Description

pthread timing interface

Author

Russell Bryant russe.nosp@m.ll@d.nosp@m.igium.nosp@m..com

Definition in file res_timing_pthread.c.

Macro Definition Documentation

MAX_RATE

#define MAX_RATE   100

Definition at line 71 of file res_timing_pthread.c.

Referenced by pthread_timer_get_max_rate(), and pthread_timer_set_rate().

PTHREAD_TIMER_BUCKETS

#define PTHREAD_TIMER_BUCKETS   563

Definition at line 74 of file res_timing_pthread.c.

Referenced by load_module().

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
PIPE_READ
PIPE_WRITE

Definition at line 76 of file res_timing_pthread.c.

 {
 PIPE_READ = 0,
 PIPE_WRITE = 1
};

pthread_timer_state

enum pthread_timer_state

Enumerator
TIMER_STATE_IDLE
TIMER_STATE_TICKING

Definition at line 81 of file res_timing_pthread.c.

 {
 TIMER_STATE_IDLE,
 TIMER_STATE_TICKING,
};

Function Documentation

__reg_module()

static void __reg_module ( void  )

static

Definition at line 476 of file res_timing_pthread.c.

__unreg_module()

static void __unreg_module ( void  )

static

Definition at line 476 of file res_timing_pthread.c.

ack_ticks()

static void ack_ticks ( struct pthread_timer *  timer, unsigned int  num  )

static

Definition at line 312 of file res_timing_pthread.c.

References ast_assert, pthread_timer::continuous, pthread_timer::pending_ticks, and unsignal_pipe().

Referenced by pthread_timer_ack().

{
 int pending_ticks = timer->pending_ticks;

 ast_assert(quantity);

 if (quantity > pending_ticks) {
 quantity = pending_ticks;
 }

 if (!quantity) {
 return;
 }

 timer->pending_ticks -= quantity;

 if ((0 == timer->pending_ticks) && !timer->continuous) {
 unsignal_pipe(timer);
 }
}

AST_MODULE_SELF_SYM()

struct ast_module* AST_MODULE_SELF_SYM

(

void

)

Definition at line 476 of file res_timing_pthread.c.

check_timer()

static int check_timer ( struct pthread_timer *  timer )

static

Return values

0	no timer tick needed
non-zero	write to the timing pipe needed

Definition at line 286 of file res_timing_pthread.c.

References ast_tvdiff_ms(), ast_tvnow(), pthread_timer::interval, pthread_timer::start, pthread_timer::state, pthread_timer::tick_count, and TIMER_STATE_IDLE.

Referenced by run_timer().

{
 struct timeval now;

 if (timer->state == TIMER_STATE_IDLE) {
 return 0;
 }

 now = ast_tvnow();

 if (timer->tick_count < (ast_tvdiff_ms(now, timer->start) / timer->interval)) {
 timer->tick_count++;
 if (!timer->tick_count) {
 /* Handle overflow. */
 timer->start = now;
 }
 return 1;
 }

 return 0;
}

do_timing()

static void* do_timing ( void *  arg )

static

Definition at line 395 of file res_timing_pthread.c.

References ao2_callback, ao2_container_count(), ast_cond_timedwait, ast_cond_wait, ast_mutex_lock, ast_mutex_unlock, ast_tv(), ast_tvadd(), ast_tvnow(), NULL, OBJ_NODATA, run_timer(), and timing_thread.

Referenced by init_timing_thread().

{
 struct timeval next_wakeup = ast_tvnow();

 while (!timing_thread.stop) {
 struct timespec ts = { 0, };

 ao2_callback(pthread_timers, OBJ_NODATA, run_timer, NULL);

 next_wakeup = ast_tvadd(next_wakeup, ast_tv(0, 5000));

 ts.tv_sec = next_wakeup.tv_sec;
 ts.tv_nsec = next_wakeup.tv_usec * 1000;

 ast_mutex_lock(&timing_thread.lock);
 if (!timing_thread.stop) {
 if (ao2_container_count(pthread_timers)) {
 ast_cond_timedwait(&timing_thread.cond, &timing_thread.lock, &ts);
 } else {
 ast_cond_wait(&timing_thread.cond, &timing_thread.lock);
 }
 }
 ast_mutex_unlock(&timing_thread.lock);
 }

 return NULL;
}

init_timing_thread()

static int init_timing_thread ( void  )

static

Definition at line 423 of file res_timing_pthread.c.

References ast_cond_init, ast_log, ast_mutex_init, ast_pthread_create_background, do_timing(), LOG_ERROR, NULL, and timing_thread.

Referenced by load_module().

{
 ast_mutex_init(&timing_thread.lock);
 ast_cond_init(&timing_thread.cond, NULL);

 if (ast_pthread_create_background(&timing_thread.thread, NULL, do_timing, NULL)) {
 ast_log(LOG_ERROR, "Unable to start timing thread.\n");
 return -1;
 }

 return 0;
}

load_module()

static int load_module ( void  )

static

Definition at line 436 of file res_timing_pthread.c.

References AO2_ALLOC_OPT_LOCK_MUTEX, ao2_container_alloc_hash, ao2_ref, AST_MODULE_LOAD_DECLINE, AST_MODULE_LOAD_SUCCESS, ast_register_timing_interface, init_timing_thread(), NULL, PTHREAD_TIMER_BUCKETS, pthread_timer_cmp(), pthread_timer_hash(), and timing_funcs_handle.

Referenced by unload_module().

{
 pthread_timers = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0,
 PTHREAD_TIMER_BUCKETS, pthread_timer_hash, NULL, pthread_timer_cmp);
 if (!pthread_timers) {
 return AST_MODULE_LOAD_DECLINE;
 }

 if (init_timing_thread()) {
 ao2_ref(pthread_timers, -1);
 pthread_timers = NULL;
 return AST_MODULE_LOAD_DECLINE;
 }

 return (timing_funcs_handle = ast_register_timing_interface(&pthread_timing)) ?
 AST_MODULE_LOAD_SUCCESS : AST_MODULE_LOAD_DECLINE;
}

pthread_timer_ack()

static int pthread_timer_ack ( void *  data, unsigned int  quantity  )

static

Definition at line 180 of file res_timing_pthread.c.

References ack_ticks(), ao2_lock, ao2_unlock, ast_assert, and timer.

{
 struct pthread_timer *timer = data;

 ast_assert(quantity > 0);

 ao2_lock(timer);
 ack_ticks(timer, quantity);
 ao2_unlock(timer);

 return 0;
}

pthread_timer_close()

static void pthread_timer_close ( void *  data )

static

Definition at line 143 of file res_timing_pthread.c.

References ao2_ref, ao2_unlink, and timer.

{
 struct pthread_timer *timer = data;

 ao2_unlink(pthread_timers, timer);
 ao2_ref(timer, -1);
}

pthread_timer_cmp()

static int pthread_timer_cmp ( void *  obj, void *  arg, int  flags  )

static

Note

only PIPE_READ is guaranteed valid

Definition at line 275 of file res_timing_pthread.c.

References CMP_MATCH, CMP_STOP, pthread_timer::pipe, and PIPE_READ.

Referenced by load_module().

{
 struct pthread_timer *timer1 = obj, *timer2 = arg;

 return (timer1->pipe[PIPE_READ] == timer2->pipe[PIPE_READ]) ? CMP_MATCH | CMP_STOP : 0;
}

pthread_timer_destructor()

static void pthread_timer_destructor ( void *  obj )

static

Definition at line 247 of file res_timing_pthread.c.

References pthread_timer::pipe, PIPE_READ, PIPE_WRITE, and timer.

Referenced by pthread_timer_open().

{
 struct pthread_timer *timer = obj;

 if (timer->pipe[PIPE_READ] > -1) {
 close(timer->pipe[PIPE_READ]);
 timer->pipe[PIPE_READ] = -1;
 }

 if (timer->pipe[PIPE_WRITE] > -1) {
 close(timer->pipe[PIPE_WRITE]);
 timer->pipe[PIPE_WRITE] = -1;
 }
}

pthread_timer_disable_continuous()

static int pthread_timer_disable_continuous ( void *  data )

static

Definition at line 207 of file res_timing_pthread.c.

References ao2_lock, ao2_unlock, pthread_timer::continuous, timer, and unsignal_pipe().

{
 struct pthread_timer *timer = data;

 ao2_lock(timer);
 if (timer->continuous) {
 timer->continuous = false;
 unsignal_pipe(timer);
 }
 ao2_unlock(timer);

 return 0;
}

pthread_timer_enable_continuous()

static int pthread_timer_enable_continuous ( void *  data )

static

Definition at line 193 of file res_timing_pthread.c.

References ao2_lock, ao2_unlock, pthread_timer::continuous, signal_pipe(), and timer.

{
 struct pthread_timer *timer = data;

 ao2_lock(timer);
 if (!timer->continuous) {
 timer->continuous = true;
 signal_pipe(timer);
 }
 ao2_unlock(timer);

 return 0;
}

pthread_timer_fd()

static int pthread_timer_fd ( void *  data )

static

Definition at line 240 of file res_timing_pthread.c.

References pthread_timer::pipe, PIPE_READ, and timer.

{
 struct pthread_timer *timer = data;

 return timer->pipe[PIPE_READ];
}

pthread_timer_get_event()

static enum ast_timer_event pthread_timer_get_event ( void *  data )

static

Definition at line 221 of file res_timing_pthread.c.

References ao2_lock, ao2_unlock, AST_TIMING_EVENT_CONTINUOUS, AST_TIMING_EVENT_EXPIRED, pthread_timer::continuous, and timer.

{
 struct pthread_timer *timer = data;
 enum ast_timer_event res = AST_TIMING_EVENT_EXPIRED;

 ao2_lock(timer);
 if (timer->continuous) {
 res = AST_TIMING_EVENT_CONTINUOUS;
 }
 ao2_unlock(timer);

 return res;
}

pthread_timer_get_max_rate()

static unsigned int pthread_timer_get_max_rate ( void *  data )

static

Definition at line 235 of file res_timing_pthread.c.

References MAX_RATE.

{
 return MAX_RATE;
}

pthread_timer_hash()

static int pthread_timer_hash ( const void *  obj, const int  flags  )

static

Note

only PIPE_READ is guaranteed valid

Definition at line 265 of file res_timing_pthread.c.

References pthread_timer::pipe, PIPE_READ, and timer.

Referenced by load_module().

{
 const struct pthread_timer *timer = obj;

 return timer->pipe[PIPE_READ];
}

pthread_timer_open()

static void * pthread_timer_open ( void  )

static

Definition at line 114 of file res_timing_pthread.c.

References ao2_alloc, ao2_container_count(), ao2_link_flags, ao2_lock, ao2_ref, ao2_unlock, ast_cond_signal, ast_mutex_lock, ast_mutex_unlock, ast_pipe_nonblock, errno, NULL, OBJ_NOLOCK, pthread_timer::pipe, PIPE_READ, PIPE_WRITE, pthread_timer_destructor(), pthread_timer::state, timer, TIMER_STATE_IDLE, and timing_thread.

{
 struct pthread_timer *timer;

 if (!(timer = ao2_alloc(sizeof(*timer), pthread_timer_destructor))) {
 errno = ENOMEM;
 return NULL;
 }

 timer->pipe[PIPE_READ] = timer->pipe[PIPE_WRITE] = -1;
 timer->state = TIMER_STATE_IDLE;

 if (ast_pipe_nonblock(timer->pipe)) {
 ao2_ref(timer, -1);
 return NULL;
 }

 ao2_lock(pthread_timers);
 if (!ao2_container_count(pthread_timers)) {
 ast_mutex_lock(&timing_thread.lock);
 ast_cond_signal(&timing_thread.cond);
 ast_mutex_unlock(&timing_thread.lock);
 }
 ao2_link_flags(pthread_timers, timer, OBJ_NOLOCK);
 ao2_unlock(pthread_timers);

 return timer;
}

pthread_timer_set_rate()

static int pthread_timer_set_rate ( void *  data, unsigned int  rate  )

static

Definition at line 151 of file res_timing_pthread.c.

References ao2_lock, ao2_unlock, ast_log, ast_tv(), ast_tvnow(), errno, pthread_timer::interval, LOG_ERROR, MAX_RATE, pthread_timer::rate, roundf(), pthread_timer::start, pthread_timer::state, pthread_timer::tick_count, timer, TIMER_STATE_IDLE, and TIMER_STATE_TICKING.

{
 struct pthread_timer *timer = data;

 if (rate > MAX_RATE) {
 ast_log(LOG_ERROR, "res_timing_pthread only supports timers at a "
 "max rate of %d / sec\n", MAX_RATE);
 errno = EINVAL;
 return -1;
 }

 ao2_lock(timer);

 if ((timer->rate = rate)) {
 timer->interval = roundf(1000.0 / ((float) rate));
 timer->start = ast_tvnow();
 timer->state = TIMER_STATE_TICKING;
 } else {
 timer->interval = 0;
 timer->start = ast_tv(0, 0);
 timer->state = TIMER_STATE_IDLE;
 }
 timer->tick_count = 0;

 ao2_unlock(timer);

 return 0;
}

run_timer()

static int run_timer ( void *  obj, void *  arg, int  flags  )

static

Definition at line 377 of file res_timing_pthread.c.

References ao2_lock, ao2_unlock, check_timer(), pthread_timer::pending_ticks, signal_pipe(), pthread_timer::state, timer, and TIMER_STATE_IDLE.

Referenced by do_timing().

{
 struct pthread_timer *timer = obj;

 if (timer->state == TIMER_STATE_IDLE) {
 return 0;
 }

 ao2_lock(timer);
 if (check_timer(timer)) {
 timer->pending_ticks++;
 signal_pipe(timer);
 }
 ao2_unlock(timer);

 return 0;
}

signal_pipe()

static void signal_pipe ( struct pthread_timer *  timer )

static

Definition at line 337 of file res_timing_pthread.c.

References ast_log, errno, LOG_ERROR, pthread_timer::pipe, pthread_timer::pipe_signaled, and PIPE_WRITE.

Referenced by pthread_timer_enable_continuous(), and run_timer().

{
 ssize_t res;
 unsigned char x = 42;

 if (timer->pipe_signaled) {
 return;
 }

 res = write(timer->pipe[PIPE_WRITE], &x, 1);
 if (-1 == res) {
 ast_log(LOG_ERROR, "Error writing to timing pipe: %s\n",
 strerror(errno));
 } else {
 timer->pipe_signaled = true;
 }
}

unload_module()

static int unload_module ( void  )

static

Definition at line 454 of file res_timing_pthread.c.

References ao2_ref, ast_cond_signal, AST_MODFLAG_LOAD_ORDER, AST_MODPRI_TIMING, AST_MODULE_INFO(), AST_MODULE_SUPPORT_EXTENDED, ast_mutex_lock, ast_mutex_unlock, ast_unregister_timing_interface(), ASTERISK_GPL_KEY, load_module(), NULL, timing_funcs_handle, and timing_thread.

{
 int res;

 ast_mutex_lock(&timing_thread.lock);
 timing_thread.stop = 1;
 ast_cond_signal(&timing_thread.cond);
 ast_mutex_unlock(&timing_thread.lock);
 pthread_join(timing_thread.thread, NULL);

 if (!(res = ast_unregister_timing_interface(timing_funcs_handle))) {
 ao2_ref(pthread_timers, -1);
 pthread_timers = NULL;
 }

 return res;
}

unsignal_pipe()

static void unsignal_pipe ( struct pthread_timer *  timer )

static

Definition at line 359 of file res_timing_pthread.c.

References ast_log, errno, LOG_ERROR, pthread_timer::pipe, PIPE_READ, and pthread_timer::pipe_signaled.

Referenced by ack_ticks(), and pthread_timer_disable_continuous().

{
 ssize_t res;
 unsigned long buffer;

 if (!timer->pipe_signaled) {
 return;
 }

 res = read(timer->pipe[PIPE_READ], &buffer, sizeof(buffer));
 if (-1 == res) {
 ast_log(LOG_ERROR, "Error reading from pipe: %s\n",
 strerror(errno));
 } else {
 timer->pipe_signaled = false;
 }
}

Variable Documentation

__mod_info

struct ast_module_info __mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_LOAD_ORDER , .description = "pthread Timing Interface" , .key = "This paragraph is copyright (c) 2006 by Digium, Inc. \In order for your module to load, it must return this \key via a function called \"key\". Any code which \includes this paragraph must be licensed under the GNU \General Public License version 2 or later (at your \option). In addition to Digium's general reservations \of rights, Digium expressly reserves the right to \allow other parties to license this paragraph under \different terms. Any use of Digium, Inc. trademarks or \logos (including \"Asterisk\" or \"Digium\") without \express written permission of Digium, Inc. is prohibited.\n" , .buildopt_sum = AST_BUILDOPT_SUM, .support_level = AST_MODULE_SUPPORT_EXTENDED, .load = load_module, .unload = unload_module, .load_pri = AST_MODPRI_TIMING, }

static

Definition at line 476 of file res_timing_pthread.c.

ast_module_info

const struct ast_module_info* ast_module_info = &__mod_info

static

Definition at line 476 of file res_timing_pthread.c.

cond

ast_cond_t cond

Definition at line 110 of file res_timing_pthread.c.

lock

ast_mutex_t lock

Definition at line 109 of file res_timing_pthread.c.

pthread_timers

struct ao2_container* pthread_timers

static

Definition at line 73 of file res_timing_pthread.c.

pthread_timing

struct ast_timing_interface pthread_timing

static

Definition at line 56 of file res_timing_pthread.c.

stop

unsigned int stop

Definition at line 111 of file res_timing_pthread.c.

thread

pthread_t thread

Definition at line 108 of file res_timing_pthread.c.

timing_funcs_handle

void* timing_funcs_handle

static

Definition at line 44 of file res_timing_pthread.c.

Referenced by load_module(), and unload_module().

timing_thread

struct { ... } timing_thread

Data for the timing thread.

Referenced by do_timing(), init_timing_thread(), pthread_timer_open(), and unload_module().