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.

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, 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, pthread_timer::pipe, and PIPE_READ.

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, 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, 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(), 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 = "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.

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.

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 { ... } timing_thread

Data for the timing thread.

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