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
Defines
#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)
	ASTERISK_FILE_VERSION (__FILE__,"$Revision: 386159 $")
static int	check_timer (struct pthread_timer *timer)
static void *	do_timing (void *arg)
static struct pthread_timer *	find_timer (int handle, int unlinkobj)
static int	init_timing_thread (void)
static int	load_module (void)
static int	pthread_timer_ack (int handle, unsigned int quantity)
static void	pthread_timer_close (int handle)
static int	pthread_timer_cmp (void obj, void arg, int flags)
static void	pthread_timer_destructor (void *obj)
static int	pthread_timer_disable_continuous (int handle)
static int	pthread_timer_enable_continuous (int handle)
static enum ast_timer_event	pthread_timer_get_event (int handle)
static unsigned int	pthread_timer_get_max_rate (int handle)
static int	pthread_timer_hash (const void *obj, const int flags)
static int	pthread_timer_open (void)
static int	pthread_timer_set_rate (int handle, 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, .load = load_module, .unload = unload_module, .load_pri = AST_MODPRI_TIMING, }
static 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 <russell@digium.com>

Definition in file res_timing_pthread.c.

Define Documentation

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

#define PTHREAD_TIMER_BUCKETS 563

Definition at line 74 of file res_timing_pthread.c.

Referenced by load_module().

Enumeration Type Documentation

anonymous enum

Enumerator:

PIPE_READ
PIPE_WRITE

Definition at line 76 of file res_timing_pthread.c.

     {
   PIPE_READ =  0,
   PIPE_WRITE = 1
};

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

static void __reg_module ( void ) [static]

Definition at line 536 of file res_timing_pthread.c.

static void __unreg_module ( void ) [static]

Definition at line 536 of file res_timing_pthread.c.

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

Definition at line 374 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);
   }
}

ASTERISK_FILE_VERSION	(	__FILE__	,
		"$Revision: 386159 $"
	)

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

static void* do_timing ( void * arg ) [static]

Definition at line 457 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(), 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;
}

static struct pthread_timer * find_timer	(	int	handle,
		int	unlinkobj
	)		`[static, read]`

Definition at line 289 of file res_timing_pthread.c.

References ao2_find, ast_assert, OBJ_POINTER, OBJ_UNLINK, pthread_timer::pipe, PIPE_READ, and timer.

Referenced by pthread_timer_ack(), pthread_timer_close(), pthread_timer_disable_continuous(), pthread_timer_enable_continuous(), pthread_timer_get_event(), and pthread_timer_set_rate().

{
   struct pthread_timer *timer;
   struct pthread_timer tmp_timer;
   int flags = OBJ_POINTER;

   tmp_timer.pipe[PIPE_READ] = handle;

   if (unlinkobj) {
      flags |= OBJ_UNLINK;
   }

   if (!(timer = ao2_find(pthread_timers, &tmp_timer, flags))) {
      ast_assert(timer != NULL);
      return NULL;
   }

   return timer;
}

static int init_timing_thread ( void ) [static]

Definition at line 485 of file res_timing_pthread.c.

References ast_cond_init, ast_log(), ast_mutex_init, ast_pthread_create_background, do_timing(), LOG_ERROR, 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;
}

static int load_module ( void ) [static]

Definition at line 498 of file res_timing_pthread.c.

References ao2_container_alloc, ao2_ref, AST_MODULE_LOAD_DECLINE, AST_MODULE_LOAD_SUCCESS, ast_register_timing_interface, init_timing_thread(), PTHREAD_TIMER_BUCKETS, pthread_timer_cmp(), pthread_timer_hash(), and timing_funcs_handle.

{
   if (!(pthread_timers = ao2_container_alloc(PTHREAD_TIMER_BUCKETS,
      pthread_timer_hash, pthread_timer_cmp))) {
      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;
}

static int pthread_timer_ack	(	int	handle,
		unsigned int	quantity
	)		`[static]`

Definition at line 203 of file res_timing_pthread.c.

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

{
   struct pthread_timer *timer;

   ast_assert(quantity > 0);

   if (!(timer = find_timer(handle, 0))) {
      return -1;
   }

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

   ao2_ref(timer, -1);

   return 0;
}

static void pthread_timer_close ( int handle ) [static]

Definition at line 156 of file res_timing_pthread.c.

References ao2_ref, find_timer(), and timer.

{
   struct pthread_timer *timer;

   if (!(timer = find_timer(handle, 1))) {
      return;
   }

   ao2_ref(timer, -1);
}

static int pthread_timer_cmp	(	void *	obj,
		void *	arg,
		int	flags
	)		`[static]`

Note:: only PIPE_READ is guaranteed valid

Definition at line 337 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;
}

static void pthread_timer_destructor ( void * obj ) [static]

Definition at line 309 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;
   }
}

static int pthread_timer_disable_continuous ( int handle ) [static]

Definition at line 243 of file res_timing_pthread.c.

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

{
   struct pthread_timer *timer;

   if (!(timer = find_timer(handle, 0))) {
      errno = EINVAL;
      return -1;
   }

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

   ao2_ref(timer, -1);

   return 0;
}

static int pthread_timer_enable_continuous ( int handle ) [static]

Definition at line 222 of file res_timing_pthread.c.

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

{
   struct pthread_timer *timer;

   if (!(timer = find_timer(handle, 0))) {
      errno = EINVAL;
      return -1;
   }

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

   ao2_ref(timer, -1);

   return 0;
}

static enum ast_timer_event pthread_timer_get_event ( int handle ) [static]

Definition at line 264 of file res_timing_pthread.c.

References ao2_lock, ao2_ref, ao2_unlock, AST_TIMING_EVENT_CONTINUOUS, AST_TIMING_EVENT_EXPIRED, pthread_timer::continuous, find_timer(), and timer.

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

   if (!(timer = find_timer(handle, 0))) {
      return res;
   }

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

   ao2_ref(timer, -1);

   return res;
}

static unsigned int pthread_timer_get_max_rate ( int handle ) [static]

Definition at line 284 of file res_timing_pthread.c.

References MAX_RATE.

{
   return MAX_RATE;
}

static int pthread_timer_hash	(	const void *	obj,
		const int	flags
	)		`[static]`

Note:: only PIPE_READ is guaranteed valid

Definition at line 327 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];
}

static int pthread_timer_open ( void ) [static]

Definition at line 115 of file res_timing_pthread.c.

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

{
   struct pthread_timer *timer;
   int fd;
   int i;

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

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

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

   for (i = 0; i < ARRAY_LEN(timer->pipe); ++i) {
      int flags = fcntl(timer->pipe[i], F_GETFL);
      flags |= O_NONBLOCK;
      fcntl(timer->pipe[i], F_SETFL, flags);
   }
   
   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(pthread_timers, timer);
   ao2_unlock(pthread_timers);

   fd = timer->pipe[PIPE_READ];

   ao2_ref(timer, -1);

   return fd;
}

static int pthread_timer_set_rate	(	int	handle,
		unsigned int	rate
	)		`[static]`

Definition at line 167 of file res_timing_pthread.c.

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

{
   struct pthread_timer *timer;

   if (!(timer = find_timer(handle, 0))) {
      errno = EINVAL;
      return -1;
   }

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

   ao2_ref(timer, -1);

   return 0;
}

static int run_timer	(	void *	obj,
		void *	arg,
		int	flags
	)		`[static]`

Definition at line 439 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;
}

static void signal_pipe ( struct pthread_timer * timer ) [static]

Definition at line 399 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;
   }
}

static int unload_module ( void ) [static]

Definition at line 515 of file res_timing_pthread.c.

References ao2_ref, ast_cond_signal, ast_mutex_lock, ast_mutex_unlock, ast_unregister_timing_interface(), 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;
}

static void unsignal_pipe ( struct pthread_timer * timer ) [static]

Definition at line 421 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

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, .load = load_module, .unload = unload_module, .load_pri = AST_MODPRI_TIMING, } [static]

Definition at line 536 of file res_timing_pthread.c.

struct ast_module_info* ast_module_info = &__mod_info [static]

Definition at line 536 of file res_timing_pthread.c.

ast_cond_t cond

Definition at line 111 of file res_timing_pthread.c.

ast_mutex_t lock

Definition at line 110 of file res_timing_pthread.c.

struct ao2_container* pthread_timers [static]

Definition at line 73 of file res_timing_pthread.c.

struct ast_timing_interface pthread_timing [static]

Definition at line 57 of file res_timing_pthread.c.

unsigned int stop