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 = ASTERISK_GPL_KEY , .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.

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.

PTHREAD_TIMER_BUCKETS

#define PTHREAD_TIMER_BUCKETS   563

Definition at line 74 of file res_timing_pthread.c.

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.

{
    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);
    }
}

References ast_assert, timer, and unsignal_pipe().

Referenced by pthread_timer_ack().

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.

{
    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;
}

References ast_tvdiff_ms(), ast_tvnow(), timer, and TIMER_STATE_IDLE.

Referenced by run_timer().

do_timing()

static void * do_timing ( void *  arg )

static

Definition at line 395 of file res_timing_pthread.c.

{
    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;
}

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, pthread_timers, run_timer(), and timing_thread.

Referenced by init_timing_thread().

init_timing_thread()

static int init_timing_thread ( void  )

static

Definition at line 423 of file res_timing_pthread.c.

{
    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;
}

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().

load_module()

static int load_module ( void  )

static

Definition at line 436 of file res_timing_pthread.c.

{
    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;
}

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(), pthread_timers, pthread_timing, and timing_funcs_handle.

pthread_timer_ack()

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

static

Definition at line 180 of file res_timing_pthread.c.

{
    struct pthread_timer *timer = data;
 
    ast_assert(quantity > 0);
 
    ao2_lock(timer);
    ack_ticks(timer, quantity);
    ao2_unlock(timer);
 
    return 0;
}

References ack_ticks(), ao2_lock, ao2_unlock, ast_assert, pthread_timer::start, and timer.

pthread_timer_close()

static void pthread_timer_close ( void *  data )

static

Definition at line 143 of file res_timing_pthread.c.

{
    struct pthread_timer *timer = data;
 
    ao2_unlink(pthread_timers, timer);
    ao2_ref(timer, -1);
}

References ao2_ref, ao2_unlink, pthread_timers, and timer.

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.

{
    struct pthread_timer *timer1 = obj, *timer2 = arg;
 
    return (timer1->pipe[PIPE_READ] == timer2->pipe[PIPE_READ]) ? CMP_MATCH | CMP_STOP : 0;
}

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

Referenced by load_module().

pthread_timer_destructor()

static void pthread_timer_destructor ( void *  obj )

static

Definition at line 247 of file res_timing_pthread.c.

{
    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;
    }
}

References PIPE_READ, PIPE_WRITE, and timer.

Referenced by pthread_timer_open().

pthread_timer_disable_continuous()

static int pthread_timer_disable_continuous ( void *  data )

static

Definition at line 207 of file res_timing_pthread.c.

{
    struct pthread_timer *timer = data;
 
    ao2_lock(timer);
    if (timer->continuous) {
        timer->continuous = false;
        unsignal_pipe(timer);
    }
    ao2_unlock(timer);
 
    return 0;
}

References ao2_lock, ao2_unlock, timer, and unsignal_pipe().

pthread_timer_enable_continuous()

static int pthread_timer_enable_continuous ( void *  data )

static

Definition at line 193 of file res_timing_pthread.c.

{
    struct pthread_timer *timer = data;
 
    ao2_lock(timer);
    if (!timer->continuous) {
        timer->continuous = true;
        signal_pipe(timer);
    }
    ao2_unlock(timer);
 
    return 0;
}

References ao2_lock, ao2_unlock, signal_pipe(), and timer.

pthread_timer_fd()

static int pthread_timer_fd ( void *  data )

static

Definition at line 240 of file res_timing_pthread.c.

{
    struct pthread_timer *timer = data;
 
    return timer->pipe[PIPE_READ];
}

References PIPE_READ, and timer.

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.

{
    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;
}

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

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.

{
    return MAX_RATE;
}

References 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.

{
    const struct pthread_timer *timer = obj;
 
    return timer->pipe[PIPE_READ];
}

References PIPE_READ, and timer.

Referenced by load_module().

pthread_timer_open()

static void * pthread_timer_open ( void  )

static

Definition at line 114 of file res_timing_pthread.c.

{
    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;
}

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, PIPE_READ, PIPE_WRITE, pthread_timer_destructor(), pthread_timers, pthread_timer::start, timer, TIMER_STATE_IDLE, and timing_thread.

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.

{
    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;
}

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

run_timer()

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

static

Definition at line 377 of file res_timing_pthread.c.

{
    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;
}

References ao2_lock, ao2_unlock, check_timer(), signal_pipe(), timer, and TIMER_STATE_IDLE.

Referenced by do_timing().

signal_pipe()

static void signal_pipe ( struct pthread_timer *  timer )

static

Definition at line 337 of file res_timing_pthread.c.

{
    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;
    }
}

References ast_log, errno, LOG_ERROR, PIPE_WRITE, and timer.

Referenced by pthread_timer_enable_continuous(), and run_timer().

unload_module()

static int unload_module ( void  )

static

Definition at line 454 of file res_timing_pthread.c.

{
    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;
}

References ao2_ref, ast_cond_signal, ast_mutex_lock, ast_mutex_unlock, ast_unregister_timing_interface(), NULL, pthread_timers, timing_funcs_handle, and timing_thread.

unsignal_pipe()

static void unsignal_pipe ( struct pthread_timer *  timer )

static

Definition at line 359 of file res_timing_pthread.c.

{
    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;
    }
}

References ast_log, errno, LOG_ERROR, PIPE_READ, and timer.

Referenced by ack_ticks(), and pthread_timer_disable_continuous().

Variable Documentation

__mod_info

struct ast_module_info __mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_LOAD_ORDER , .description = "pthread Timing Interface" , .key = ASTERISK_GPL_KEY , .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.

Referenced by do_timing(), load_module(), pthread_timer_close(), pthread_timer_open(), and unload_module().

pthread_timing

struct ast_timing_interface pthread_timing

static

Definition at line 56 of file res_timing_pthread.c.

                                                    {
    .name = "pthread",
    .priority = 0, /* use this as a last resort */
    .timer_open = pthread_timer_open,
    .timer_close = pthread_timer_close,
    .timer_set_rate = pthread_timer_set_rate,
    .timer_ack = pthread_timer_ack,
    .timer_enable_continuous = pthread_timer_enable_continuous,
    .timer_disable_continuous = pthread_timer_disable_continuous,
    .timer_get_event = pthread_timer_get_event,
    .timer_get_max_rate = pthread_timer_get_max_rate,
    .timer_fd = pthread_timer_fd,
};

Referenced by load_module().

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().

[struct]

struct { ... } timing_thread

Data for the timing thread.

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