Tue Aug 20 16:35:15 2013

Asterisk developer's documentation


sched.c File Reference

Scheduler Routines (from cheops-NG). More...

#include "asterisk.h"
#include <sys/time.h>
#include "asterisk/sched.h"
#include "asterisk/channel.h"
#include "asterisk/lock.h"
#include "asterisk/utils.h"
#include "asterisk/linkedlists.h"
#include "asterisk/dlinkedlists.h"
#include "asterisk/hashtab.h"
#include "asterisk/heap.h"
#include "asterisk/threadstorage.h"

Go to the source code of this file.

Data Structures

struct  ast_sched_thread
struct  sched
struct  sched_context

Defines

#define DEBUG(a)

Functions

static void __init_last_del_id (void)
int ast_sched_add (struct sched_context *con, int when, ast_sched_cb callback, const void *data)
 Adds a scheduled event Schedule an event to take place at some point in the future. callback will be called with data as the argument, when milliseconds into the future (approximately) If callback returns 0, no further events will be re-scheduled.
int ast_sched_add_variable (struct sched_context *con, int when, ast_sched_cb callback, const void *data, int variable)
 Schedule callback(data) to happen when ms into the future.
int ast_sched_del (struct sched_context *con, int id)
 Delete the schedule entry with number "id". It's nearly impossible that there would be two or more in the list with that id.
void ast_sched_dump (struct sched_context *con)
 Dump the contents of the scheduler to LOG_DEBUG.
const void * ast_sched_find_data (struct sched_context *con, int id)
 Find a sched structure and return the data field associated with it.
int ast_sched_replace (int old_id, struct sched_context *con, int when, ast_sched_cb callback, const void *data)
 replace a scheduler entry
int ast_sched_replace_variable (int old_id, struct sched_context *con, int when, ast_sched_cb callback, const void *data, int variable)
 replace a scheduler entry
void ast_sched_report (struct sched_context *con, struct ast_str **buf, struct ast_cb_names *cbnames)
 Show statics on what it is in the schedule queue.
int ast_sched_runq (struct sched_context *con)
 Launch all events which need to be run at this time.
int ast_sched_thread_add (struct ast_sched_thread *st, int when, ast_sched_cb cb, const void *data)
 Add a scheduler entry.
int ast_sched_thread_add_variable (struct ast_sched_thread *st, int when, ast_sched_cb cb, const void *data, int variable)
 Add a variable reschedule time scheduler entry.
struct ast_sched_threadast_sched_thread_create (void)
 Create a scheduler with a dedicated thread.
struct ast_sched_threadast_sched_thread_destroy (struct ast_sched_thread *st)
 Destroy a scheduler and its thread.
struct sched_contextast_sched_thread_get_context (struct ast_sched_thread *st)
 Get the scheduler context for a given ast_sched_thread.
void ast_sched_thread_poke (struct ast_sched_thread *st)
 Force re-processing of the scheduler context.
int ast_sched_wait (struct sched_context *con)
 Return the number of milliseconds until the next scheduled event.
long ast_sched_when (struct sched_context *con, int id)
 Returns the number of seconds before an event takes place.
static struct schedsched_alloc (struct sched_context *con)
static int sched_cmp (const void *a, const void *b)
struct sched_contextsched_context_create (void)
 New schedule context.
void sched_context_destroy (struct sched_context *con)
 destroys a schedule context Destroys (free's) the given sched_context structure
static unsigned int sched_hash (const void *obj)
static void sched_release (struct sched_context *con, struct sched *tmp)
static void * sched_run (void *data)
static int sched_settime (struct timeval *t, int when)
 given the last event *tv and the offset in milliseconds 'when', computes the next value,
static int sched_time_cmp (void *a, void *b)
static void schedule (struct sched_context *con, struct sched *s)
 Take a sched structure and put it in the queue, such that the soonest event is first in the list.

Variables

static struct ast_threadstorage last_del_id = { .once = PTHREAD_ONCE_INIT , .key_init = __init_last_del_id , .custom_init = NULL , }

Detailed Description

Scheduler Routines (from cheops-NG).

Author:
Mark Spencer <markster@digium.com>

Definition in file sched.c.


Define Documentation

#define DEBUG (  ) 

Definition at line 40 of file sched.c.


Function Documentation

static void __init_last_del_id ( void   )  [static]

Definition at line 55 of file sched.c.

00057 {

int ast_sched_add ( struct sched_context con,
int  when,
ast_sched_cb  callback,
const void *  data 
)

Adds a scheduled event Schedule an event to take place at some point in the future. callback will be called with data as the argument, when milliseconds into the future (approximately) If callback returns 0, no further events will be re-scheduled.

Parameters:
con Scheduler context to add
when how many milliseconds to wait for event to occur
callback function to call when the amount of time expires
data data to pass to the callback
Returns:
Returns a schedule item ID on success, -1 on failure

Definition at line 446 of file sched.c.

References ast_sched_add_variable().

Referenced by __oh323_update_info(), ast_readaudio_callback(), ast_readvideo_callback(), ast_rtp_raw_write(), ast_rtp_read(), ast_sched_replace(), ast_sched_thread_add(), build_peer(), create_esc_entry(), do_register(), do_reload(), dundi_discover(), dundi_query(), dundi_send(), handle_command_response(), handle_request_invite(), handle_response_invite(), handle_response_subscribe(), mgcp_postrequest(), network_change_event_cb(), parse_register_contact(), populate_addr(), precache_trans(), qualify_peer(), receive_digit(), rtp_red_init(), sip_cc_agent_start_offer_timer(), sip_cc_monitor_request_cc(), sip_hangup(), sip_scheddestroy(), sip_send_all_mwi_subscriptions(), start_session_timer(), submit_scheduled_batch(), submit_unscheduled_batch(), transmit_register(), and update_provisional_keepalive().

00447 {
00448    return ast_sched_add_variable(con, when, callback, data, 0);
00449 }

int ast_sched_add_variable ( struct sched_context con,
int  when,
ast_sched_cb  callback,
const void *  data,
int  variable 
)

Schedule callback(data) to happen when ms into the future.

Adds a scheduled event with rescheduling support

Parameters:
con Scheduler context to add
when how many milliseconds to wait for event to occur
callback function to call when the amount of time expires
data data to pass to the callback
variable If true, the result value of callback function will be used for rescheduling Schedule an event to take place at some point in the future. Callback will be called with data as the argument, when milliseconds into the future (approximately) If callback returns 0, no further events will be re-scheduled
Returns:
Returns a schedule item ID on success, -1 on failure

Definition at line 406 of file sched.c.

References ast_debug, ast_mutex_lock, ast_mutex_unlock, ast_sched_dump(), ast_tv(), sched::callback, sched::data, DEBUG, sched_context::eventcnt, sched::id, sched_context::lock, option_debug, sched::resched, sched_alloc(), sched_release(), sched_settime(), schedule(), sched::variable, and sched::when.

Referenced by _misdn_tasks_add_variable(), ast_sched_add(), ast_sched_replace_variable(), ast_sched_thread_add_variable(), dnsmgr_start_refresh(), and do_reload().

00407 {
00408    struct sched *tmp;
00409    int res = -1;
00410 
00411    DEBUG(ast_debug(1, "ast_sched_add()\n"));
00412 
00413    ast_mutex_lock(&con->lock);
00414    if ((tmp = sched_alloc(con))) {
00415       tmp->id = con->eventcnt++;
00416       tmp->callback = callback;
00417       tmp->data = data;
00418       tmp->resched = when;
00419       tmp->variable = variable;
00420       tmp->when = ast_tv(0, 0);
00421       if (sched_settime(&tmp->when, when)) {
00422          sched_release(con, tmp);
00423       } else {
00424          schedule(con, tmp);
00425          res = tmp->id;
00426       }
00427    }
00428 #ifdef DUMP_SCHEDULER
00429    /* Dump contents of the context while we have the lock so nothing gets screwed up by accident. */
00430    if (option_debug)
00431       ast_sched_dump(con);
00432 #endif
00433    ast_mutex_unlock(&con->lock);
00434 
00435    return res;
00436 }

int ast_sched_del ( struct sched_context con,
int  id 
)

Delete the schedule entry with number "id". It's nearly impossible that there would be two or more in the list with that id.

Deletes a scheduled event Remove this event from being run. A procedure should not remove its own event, but return 0 instead. In most cases, you should not call this routine directly, but use the AST_SCHED_DEL() macro instead (especially if you don't intend to do something different when it returns failure).

Definition at line 468 of file sched.c.

References ast_assert, ast_debug, ast_hashtab_lookup(), ast_hashtab_remove_this_object(), ast_heap_remove(), ast_log(), ast_mutex_lock, ast_mutex_unlock, ast_sched_dump(), ast_threadstorage_get(), DEBUG, sched::id, last_del_id, sched_context::lock, LOG_WARNING, option_debug, sched_context::sched_heap, sched_release(), sched_context::schedcnt, and sched_context::schedq_ht.

Referenced by __sip_ack(), ast_rtp_prop_set(), ast_rtp_stop(), and destroy_event().

00472 {
00473    struct sched *s, tmp = {
00474       .id = id,
00475    };
00476    int *last_id = ast_threadstorage_get(&last_del_id, sizeof(int));
00477 
00478    DEBUG(ast_debug(1, "ast_sched_del(%d)\n", id));
00479 
00480    if (id < 0) {
00481       return 0;
00482    }
00483 
00484    ast_mutex_lock(&con->lock);
00485    s = ast_hashtab_lookup(con->schedq_ht, &tmp);
00486    if (s) {
00487       if (!ast_heap_remove(con->sched_heap, s)) {
00488          ast_log(LOG_WARNING,"sched entry %d not in the sched heap?\n", s->id);
00489       }
00490 
00491       if (!ast_hashtab_remove_this_object(con->schedq_ht, s)) {
00492          ast_log(LOG_WARNING,"Found sched entry %d, then couldn't remove it?\n", s->id);
00493       }
00494 
00495       con->schedcnt--;
00496 
00497       sched_release(con, s);
00498    }
00499 
00500 #ifdef DUMP_SCHEDULER
00501    /* Dump contents of the context while we have the lock so nothing gets screwed up by accident. */
00502    if (option_debug)
00503       ast_sched_dump(con);
00504 #endif
00505    ast_mutex_unlock(&con->lock);
00506 
00507    if (!s && *last_id != id) {
00508       ast_debug(1, "Attempted to delete nonexistent schedule entry %d!\n", id);
00509 #ifndef AST_DEVMODE
00510       ast_assert(s != NULL);
00511 #else
00512       {
00513       char buf[100];
00514       snprintf(buf, sizeof(buf), "s != NULL, id=%d", id);
00515       _ast_assert(0, buf, file, line, function);
00516       }
00517 #endif
00518       *last_id = id;
00519       return -1;
00520    } else if (!s) {
00521       return -1;
00522    }
00523 
00524    return 0;
00525 }

void ast_sched_dump ( struct sched_context con  ) 

Dump the contents of the scheduler to LOG_DEBUG.

Dumps the scheduler contents Debugging: Dump the contents of the scheduler to stderr.

Definition at line 565 of file sched.c.

References ast_debug, ast_heap_peek(), ast_heap_size(), ast_mutex_lock, ast_mutex_unlock, ast_tvnow(), ast_tvsub(), sched_context::eventcnt, sched_context::highwater, sched_context::lock, sched_context::sched_heap, sched_context::schedccnt, and sched_context::schedcnt.

Referenced by ast_sched_add_variable(), ast_sched_del(), handle_dump_sched(), sip_do_reload(), and unload_module().

00566 {
00567    struct sched *q;
00568    struct timeval when = ast_tvnow();
00569    int x;
00570    size_t heap_size;
00571 #ifdef SCHED_MAX_CACHE
00572    ast_debug(1, "Asterisk Schedule Dump (%d in Q, %d Total, %d Cache, %d high-water)\n", con->schedcnt, con->eventcnt - 1, con->schedccnt, con->highwater);
00573 #else
00574    ast_debug(1, "Asterisk Schedule Dump (%d in Q, %d Total, %d high-water)\n", con->schedcnt, con->eventcnt - 1, con->highwater);
00575 #endif
00576 
00577    ast_debug(1, "=============================================================\n");
00578    ast_debug(1, "|ID    Callback          Data              Time  (sec:ms)   |\n");
00579    ast_debug(1, "+-----+-----------------+-----------------+-----------------+\n");
00580    ast_mutex_lock(&con->lock);
00581    heap_size = ast_heap_size(con->sched_heap);
00582    for (x = 1; x <= heap_size; x++) {
00583       struct timeval delta;
00584       q = ast_heap_peek(con->sched_heap, x);
00585       delta = ast_tvsub(q->when, when);
00586       ast_debug(1, "|%.4d | %-15p | %-15p | %.6ld : %.6ld |\n", 
00587          q->id,
00588          q->callback,
00589          q->data,
00590          (long)delta.tv_sec,
00591          (long int)delta.tv_usec);
00592    }
00593    ast_mutex_unlock(&con->lock);
00594    ast_debug(1, "=============================================================\n");
00595 }

const void* ast_sched_find_data ( struct sched_context con,
int  id 
)

Find a sched structure and return the data field associated with it.

Parameters:
con scheduling context in which to search fro the matching id
id ID of the scheduled item to find
Returns:
the data field from the matching sched struct if found; else return NULL if not found.
Since:
1.6.1

Definition at line 451 of file sched.c.

References ast_hashtab_lookup(), sched::data, sched::id, and sched_context::schedq_ht.

00452 {
00453    struct sched tmp,*res;
00454    tmp.id = id;
00455    res = ast_hashtab_lookup(con->schedq_ht, &tmp);
00456    if (res)
00457       return res->data;
00458    return NULL;
00459 }

int ast_sched_replace ( int  old_id,
struct sched_context con,
int  when,
ast_sched_cb  callback,
const void *  data 
)

replace a scheduler entry

Deprecated:
You should use the AST_SCHED_REPLACE() macro instead.

This deletes the scheduler entry for old_id if it exists, and then calls ast_sched_add to create a new entry. A negative old_id will be ignored.

Return values:
-1 failure
otherwise,returns scheduled item ID

Definition at line 438 of file sched.c.

References ast_sched_add(), and AST_SCHED_DEL.

00439 {
00440    if (old_id > -1) {
00441       AST_SCHED_DEL(con, old_id);
00442    }
00443    return ast_sched_add(con, when, callback, data);
00444 }

int ast_sched_replace_variable ( int  old_id,
struct sched_context con,
int  when,
ast_sched_cb  callback,
const void *  data,
int  variable 
)

replace a scheduler entry

Deprecated:
You should use the AST_SCHED_REPLACE_VARIABLE() macro instead.

This deletes the scheduler entry for old_id if it exists, and then calls ast_sched_add to create a new entry. A negative old_id will be ignored.

Return values:
-1 failure
otherwise,returns scheduled item ID

Definition at line 394 of file sched.c.

References ast_sched_add_variable(), and AST_SCHED_DEL.

00395 {
00396    /* 0 means the schedule item is new; do not delete */
00397    if (old_id > 0) {
00398       AST_SCHED_DEL(con, old_id);
00399    }
00400    return ast_sched_add_variable(con, when, callback, data, variable);
00401 }

void ast_sched_report ( struct sched_context con,
struct ast_str **  buf,
struct ast_cb_names cbnames 
)

Show statics on what it is in the schedule queue.

Parameters:
con Schedule context to check
buf dynamic string to store report
cbnames to check against
Since:
1.6.1

Definition at line 527 of file sched.c.

References ast_heap_peek(), ast_heap_size(), ast_mutex_lock, ast_mutex_unlock, ast_str_append(), ast_str_set(), sched::callback, ast_cb_names::cblist, sched_context::highwater, ast_cb_names::list, sched_context::lock, ast_cb_names::numassocs, sched_context::sched_heap, and sched_context::schedcnt.

Referenced by sip_show_sched().

00528 {
00529    int i, x;
00530    struct sched *cur;
00531    int countlist[cbnames->numassocs + 1];
00532    size_t heap_size;
00533    
00534    memset(countlist, 0, sizeof(countlist));
00535    ast_str_set(buf, 0, " Highwater = %d\n schedcnt = %d\n", con->highwater, con->schedcnt);
00536 
00537    ast_mutex_lock(&con->lock);
00538 
00539    heap_size = ast_heap_size(con->sched_heap);
00540    for (x = 1; x <= heap_size; x++) {
00541       cur = ast_heap_peek(con->sched_heap, x);
00542       /* match the callback to the cblist */
00543       for (i = 0; i < cbnames->numassocs; i++) {
00544          if (cur->callback == cbnames->cblist[i]) {
00545             break;
00546          }
00547       }
00548       if (i < cbnames->numassocs) {
00549          countlist[i]++;
00550       } else {
00551          countlist[cbnames->numassocs]++;
00552       }
00553    }
00554 
00555    ast_mutex_unlock(&con->lock);
00556 
00557    for (i = 0; i < cbnames->numassocs; i++) {
00558       ast_str_append(buf, 0, "    %s : %d\n", cbnames->list[i], countlist[i]);
00559    }
00560 
00561    ast_str_append(buf, 0, "   <unknown> : %d\n", countlist[cbnames->numassocs]);
00562 }

int ast_sched_runq ( struct sched_context con  ) 

Launch all events which need to be run at this time.

Runs the queue.

Definition at line 600 of file sched.c.

References ast_debug, ast_hashtab_remove_this_object(), ast_heap_peek(), ast_heap_pop(), ast_log(), ast_mutex_lock, ast_mutex_unlock, ast_tv(), ast_tvadd(), ast_tvcmp(), ast_tvnow(), sched::callback, sched::data, DEBUG, sched::id, sched_context::lock, LOG_ERROR, sched::resched, sched_context::sched_heap, sched_release(), sched_settime(), sched_context::schedcnt, sched_context::schedq_ht, schedule(), sched::variable, and sched::when.

Referenced by background_detect_exec(), dial_exec_full(), do_cdr(), do_monitor(), do_refresh(), handle_speechrecognize(), misdn_tasks_thread_func(), network_thread(), reload_config(), sched_run(), speech_background(), wait_for_winner(), and waitstream_core().

00601 {
00602    struct sched *current;
00603    struct timeval when;
00604    int numevents;
00605    int res;
00606 
00607    DEBUG(ast_debug(1, "ast_sched_runq()\n"));
00608       
00609    ast_mutex_lock(&con->lock);
00610 
00611    when = ast_tvadd(ast_tvnow(), ast_tv(0, 1000));
00612    for (numevents = 0; (current = ast_heap_peek(con->sched_heap, 1)); numevents++) {
00613       /* schedule all events which are going to expire within 1ms.
00614        * We only care about millisecond accuracy anyway, so this will
00615        * help us get more than one event at one time if they are very
00616        * close together.
00617        */
00618       if (ast_tvcmp(current->when, when) != -1) {
00619          break;
00620       }
00621       
00622       current = ast_heap_pop(con->sched_heap);
00623 
00624       if (!ast_hashtab_remove_this_object(con->schedq_ht, current)) {
00625          ast_log(LOG_ERROR,"Sched entry %d was in the schedq list but not in the hashtab???\n", current->id);
00626       }
00627 
00628       con->schedcnt--;
00629 
00630       /*
00631        * At this point, the schedule queue is still intact.  We
00632        * have removed the first event and the rest is still there,
00633        * so it's permissible for the callback to add new events, but
00634        * trying to delete itself won't work because it isn't in
00635        * the schedule queue.  If that's what it wants to do, it 
00636        * should return 0.
00637        */
00638          
00639       ast_mutex_unlock(&con->lock);
00640       res = current->callback(current->data);
00641       ast_mutex_lock(&con->lock);
00642          
00643       if (res) {
00644          /*
00645           * If they return non-zero, we should schedule them to be
00646           * run again.
00647           */
00648          if (sched_settime(&current->when, current->variable? res : current->resched)) {
00649             sched_release(con, current);
00650          } else {
00651             schedule(con, current);
00652          }
00653       } else {
00654          /* No longer needed, so release it */
00655          sched_release(con, current);
00656       }
00657    }
00658 
00659    ast_mutex_unlock(&con->lock);
00660    
00661    return numevents;
00662 }

int ast_sched_thread_add ( struct ast_sched_thread st,
int  when,
ast_sched_cb  cb,
const void *  data 
)

Add a scheduler entry.

Parameters:
st the handle to the scheduler and thread
when the number of ms in the future to run the task. A value <= 0 is treated as "run now".
cb the function to call when the scheduled time arrives
data the parameter to pass to the scheduler callback
Return values:
-1 Failure
>=0 Sched ID of added task

Definition at line 210 of file sched.c.

References ast_cond_signal, ast_mutex_lock, ast_mutex_unlock, ast_sched_add(), ast_sched_thread::cond, ast_sched_thread::context, and ast_sched_thread::lock.

Referenced by cc_generic_agent_start_offer_timer(), cc_generic_monitor_request_cc(), iax2_hangup(), iax2_key_rotate(), iax2_sched_add(), and iax2_sched_replace().

00212 {
00213    int res;
00214 
00215    ast_mutex_lock(&st->lock);
00216    res = ast_sched_add(st->context, when, cb, data);
00217    if (res != -1) {
00218       ast_cond_signal(&st->cond);
00219    }
00220    ast_mutex_unlock(&st->lock);
00221 
00222    return res;
00223 }

int ast_sched_thread_add_variable ( struct ast_sched_thread st,
int  when,
ast_sched_cb  cb,
const void *  data,
int  variable 
)

Add a variable reschedule time scheduler entry.

Parameters:
st the handle to the scheduler and thread
when the number of ms in the future to run the task. A value <= 0 is treated as "run now".
cb the function to call when the scheduled time arrives
data the parameter to pass to the scheduler callback
variable If this value is non-zero, then the scheduler will use the return value of the scheduler as the amount of time in the future to run the task again. Normally, a return value of 0 means do not re-schedule, and non-zero means re-schedule using the time provided when the scheduler entry was first created.
Return values:
-1 Failure
>=0 Sched ID of added task

Definition at line 195 of file sched.c.

References ast_cond_signal, ast_mutex_lock, ast_mutex_unlock, ast_sched_add_variable(), ast_sched_thread::cond, ast_sched_thread::context, and ast_sched_thread::lock.

Referenced by stun_start_monitor().

00197 {
00198    int res;
00199 
00200    ast_mutex_lock(&st->lock);
00201    res = ast_sched_add_variable(st->context, when, cb, data, variable);
00202    if (res != -1) {
00203       ast_cond_signal(&st->cond);
00204    }
00205    ast_mutex_unlock(&st->lock);
00206 
00207    return res;
00208 }

struct ast_sched_thread* ast_sched_thread_create ( void   )  [read]

Create a scheduler with a dedicated thread.

This function should be used to allocate a scheduler context and a dedicated thread for processing scheduler entries. The thread is started immediately.

Return values:
NULL error
non-NULL a handle to the scheduler and its dedicated thread.

Definition at line 167 of file sched.c.

References ast_calloc, ast_cond_init, ast_log(), ast_mutex_init, ast_pthread_create_background, AST_PTHREADT_NULL, ast_sched_thread_destroy(), ast_sched_thread::cond, ast_sched_thread::context, ast_sched_thread::lock, LOG_ERROR, sched_context_create(), sched_run(), and ast_sched_thread::thread.

Referenced by ast_cc_init(), load_module(), and stun_start_monitor().

00168 {
00169    struct ast_sched_thread *st;
00170 
00171    if (!(st = ast_calloc(1, sizeof(*st)))) {
00172       return NULL;
00173    }
00174 
00175    ast_mutex_init(&st->lock);
00176    ast_cond_init(&st->cond, NULL);
00177 
00178    st->thread = AST_PTHREADT_NULL;
00179 
00180    if (!(st->context = sched_context_create())) {
00181       ast_log(LOG_ERROR, "Failed to create scheduler\n");
00182       ast_sched_thread_destroy(st);
00183       return NULL;
00184    }
00185    
00186    if (ast_pthread_create_background(&st->thread, NULL, sched_run, st)) {
00187       ast_log(LOG_ERROR, "Failed to create scheduler thread\n");
00188       ast_sched_thread_destroy(st);
00189       return NULL;
00190    }
00191 
00192    return st;
00193 }

struct ast_sched_thread* ast_sched_thread_destroy ( struct ast_sched_thread st  )  [read]

Destroy a scheduler and its thread.

This function is used to destroy a scheduler context and the dedicated thread that was created for handling scheduler entries. Any entries in the scheduler that have not yet been processed will be thrown away. Once this function is called, the handle must not be used again.

Parameters:
st the handle to the scheduler and thread
Returns:
NULL for convenience

Definition at line 143 of file sched.c.

References ast_cond_destroy, ast_cond_signal, ast_free, ast_mutex_destroy, ast_mutex_lock, ast_mutex_unlock, AST_PTHREADT_NULL, ast_sched_thread::cond, ast_sched_thread::context, ast_sched_thread::lock, sched_context_destroy(), ast_sched_thread::stop, and ast_sched_thread::thread.

Referenced by __unload_module(), ast_sched_thread_create(), cc_shutdown(), load_module(), stun_start_monitor(), and stun_stop_monitor().

00144 {
00145    if (st->thread != AST_PTHREADT_NULL) {
00146       ast_mutex_lock(&st->lock);
00147       st->stop = 1;
00148       ast_cond_signal(&st->cond);
00149       ast_mutex_unlock(&st->lock);
00150       pthread_join(st->thread, NULL);
00151       st->thread = AST_PTHREADT_NULL;
00152    }
00153 
00154    ast_mutex_destroy(&st->lock);
00155    ast_cond_destroy(&st->cond);
00156 
00157    if (st->context) {
00158       sched_context_destroy(st->context);
00159       st->context = NULL;
00160    }
00161 
00162    ast_free(st);
00163 
00164    return NULL;
00165 }

struct sched_context* ast_sched_thread_get_context ( struct ast_sched_thread st  )  [read]

Get the scheduler context for a given ast_sched_thread.

This function should be used only when direct access to the scheduler context is required. Its use is discouraged unless necessary. The cases where this is currently required is when you want to take advantage of one of the AST_SCHED macros.

Parameters:
st the handle to the scheduler and thread
Returns:
the sched_context associated with an ast_sched_thread

Definition at line 138 of file sched.c.

References ast_sched_thread::context.

Referenced by iax2_destroy_helper().

00139 {
00140    return st->context;
00141 }

void ast_sched_thread_poke ( struct ast_sched_thread st  ) 

Force re-processing of the scheduler context.

Parameters:
st the handle to the scheduler and thread
Returns:
nothing

Definition at line 131 of file sched.c.

References ast_cond_signal, ast_mutex_lock, ast_mutex_unlock, ast_sched_thread::cond, and ast_sched_thread::lock.

00132 {
00133    ast_mutex_lock(&st->lock);
00134    ast_cond_signal(&st->cond);
00135    ast_mutex_unlock(&st->lock);
00136 }

int ast_sched_wait ( struct sched_context con  ) 

Return the number of milliseconds until the next scheduled event.

Determines number of seconds until the next outstanding event to take place Determine the number of seconds until the next outstanding event should take place, and return the number of milliseconds until it needs to be run. This value is perfect for passing to the poll call.

Definition at line 334 of file sched.c.

References ast_debug, ast_heap_peek(), ast_mutex_lock, ast_mutex_unlock, ast_tvdiff_ms(), ast_tvnow(), DEBUG, sched_context::lock, sched_context::sched_heap, and sched::when.

Referenced by background_detect_exec(), dial_exec_full(), do_cdr(), do_monitor(), do_refresh(), handle_speechrecognize(), misdn_tasks_thread_func(), network_thread(), sched_run(), speech_background(), wait_for_winner(), and waitstream_core().

00335 {
00336    int ms;
00337    struct sched *s;
00338 
00339    DEBUG(ast_debug(1, "ast_sched_wait()\n"));
00340 
00341    ast_mutex_lock(&con->lock);
00342    if ((s = ast_heap_peek(con->sched_heap, 1))) {
00343       ms = ast_tvdiff_ms(s->when, ast_tvnow());
00344       if (ms < 0) {
00345          ms = 0;
00346       }
00347    } else {
00348       ms = -1;
00349    }
00350    ast_mutex_unlock(&con->lock);
00351 
00352    return ms;
00353 }

long ast_sched_when ( struct sched_context con,
int  id 
)

Returns the number of seconds before an event takes place.

Parameters:
con Context to use
id Id to dump

Definition at line 664 of file sched.c.

References ast_debug, ast_hashtab_lookup(), ast_mutex_lock, ast_mutex_unlock, ast_tvnow(), DEBUG, sched::id, sched_context::lock, sched_context::schedq_ht, and sched::when.

Referenced by _sip_show_peer(), handle_cli_status(), and parse_register_contact().

00665 {
00666    struct sched *s, tmp;
00667    long secs = -1;
00668    DEBUG(ast_debug(1, "ast_sched_when()\n"));
00669 
00670    ast_mutex_lock(&con->lock);
00671    
00672    /* these next 2 lines replace a lookup loop */
00673    tmp.id = id;
00674    s = ast_hashtab_lookup(con->schedq_ht, &tmp);
00675    
00676    if (s) {
00677       struct timeval now = ast_tvnow();
00678       secs = s->when.tv_sec - now.tv_sec;
00679    }
00680    ast_mutex_unlock(&con->lock);
00681    
00682    return secs;
00683 }

static struct sched* sched_alloc ( struct sched_context con  )  [static, read]

Definition at line 296 of file sched.c.

References ast_calloc, AST_LIST_REMOVE_HEAD, sched_context::schedc, and sched_context::schedccnt.

Referenced by ast_sched_add_variable().

00297 {
00298    struct sched *tmp;
00299 
00300    /*
00301     * We keep a small cache of schedule entries
00302     * to minimize the number of necessary malloc()'s
00303     */
00304 #ifdef SCHED_MAX_CACHE
00305    if ((tmp = AST_LIST_REMOVE_HEAD(&con->schedc, list)))
00306       con->schedccnt--;
00307    else
00308 #endif
00309       tmp = ast_calloc(1, sizeof(*tmp));
00310 
00311    return tmp;
00312 }

static int sched_cmp ( const void *  a,
const void *  b 
) [static]

Definition at line 227 of file sched.c.

References sched::id.

Referenced by sched_context_create().

00228 {
00229    const struct sched *as = a;
00230    const struct sched *bs = b;
00231    return as->id != bs->id; /* return 0 on a match like strcmp would */
00232 }

struct sched_context* sched_context_create ( void   )  [read]

New schedule context.

Note:
Create a scheduling context
Returns:
Returns a malloc'd sched_context structure, NULL on failure

Definition at line 246 of file sched.c.

References ast_calloc, ast_hashtab_create(), ast_hashtab_newsize_java(), ast_hashtab_resize_java(), ast_heap_create(), ast_mutex_init, sched_context::eventcnt, sched_context::lock, sched_cmp(), sched_context_destroy(), sched_hash(), sched_context::sched_heap, sched_time_cmp(), and sched_context::schedq_ht.

Referenced by __ast_channel_alloc_ap(), ast_cdr_engine_init(), ast_sched_thread_create(), dnsmgr_init(), load_module(), and misdn_tasks_init().

00247 {
00248    struct sched_context *tmp;
00249 
00250    if (!(tmp = ast_calloc(1, sizeof(*tmp))))
00251       return NULL;
00252 
00253    ast_mutex_init(&tmp->lock);
00254    tmp->eventcnt = 1;
00255 
00256    tmp->schedq_ht = ast_hashtab_create(23, sched_cmp, ast_hashtab_resize_java, ast_hashtab_newsize_java, sched_hash, 1);
00257 
00258    if (!(tmp->sched_heap = ast_heap_create(8, sched_time_cmp,
00259          offsetof(struct sched, __heap_index)))) {
00260       sched_context_destroy(tmp);
00261       return NULL;
00262    }
00263 
00264    return tmp;
00265 }

void sched_context_destroy ( struct sched_context c  ) 

destroys a schedule context Destroys (free's) the given sched_context structure

Parameters:
c Context to free
Returns:
Returns 0 on success, -1 on failure

Definition at line 267 of file sched.c.

References ast_free, ast_hashtab_destroy(), ast_heap_destroy(), ast_heap_pop(), AST_LIST_REMOVE_HEAD, ast_mutex_destroy, ast_mutex_lock, ast_mutex_unlock, sched_context::lock, sched_context::sched_heap, sched_context::schedc, and sched_context::schedq_ht.

Referenced by ast_channel_destructor(), ast_hangup(), ast_sched_thread_destroy(), cdr_engine_shutdown(), dnsmgr_shutdown(), load_module(), misdn_tasks_destroy(), sched_context_create(), and unload_module().

00268 {
00269    struct sched *s;
00270 
00271    ast_mutex_lock(&con->lock);
00272 
00273 #ifdef SCHED_MAX_CACHE
00274    /* Eliminate the cache */
00275    while ((s = AST_LIST_REMOVE_HEAD(&con->schedc, list)))
00276       ast_free(s);
00277 #endif
00278 
00279    if (con->sched_heap) {
00280       while ((s = ast_heap_pop(con->sched_heap))) {
00281          ast_free(s);
00282       }
00283       ast_heap_destroy(con->sched_heap);
00284       con->sched_heap = NULL;
00285    }
00286 
00287    ast_hashtab_destroy(con->schedq_ht, NULL);
00288    con->schedq_ht = NULL;
00289    
00290    /* And the context */
00291    ast_mutex_unlock(&con->lock);
00292    ast_mutex_destroy(&con->lock);
00293    ast_free(con);
00294 }

static unsigned int sched_hash ( const void *  obj  )  [static]

Definition at line 234 of file sched.c.

References sched::id.

Referenced by sched_context_create().

00235 {
00236    const struct sched *s = obj;
00237    unsigned int h = s->id;
00238    return h;
00239 }

static void sched_release ( struct sched_context con,
struct sched tmp 
) [static]

Definition at line 314 of file sched.c.

References ast_free, AST_LIST_INSERT_HEAD, SCHED_MAX_CACHE, sched_context::schedc, and sched_context::schedccnt.

Referenced by ast_sched_add_variable(), ast_sched_del(), and ast_sched_runq().

00315 {
00316    /*
00317     * Add to the cache, or just free() if we
00318     * already have too many cache entries
00319     */
00320 
00321 #ifdef SCHED_MAX_CACHE   
00322    if (con->schedccnt < SCHED_MAX_CACHE) {
00323       AST_LIST_INSERT_HEAD(&con->schedc, tmp, list);
00324       con->schedccnt++;
00325    } else
00326 #endif
00327       ast_free(tmp);
00328 }

static void* sched_run ( void *  data  )  [static]

Definition at line 90 of file sched.c.

References ast_cond_timedwait, ast_cond_wait, ast_mutex_lock, ast_mutex_unlock, ast_samp2tv(), ast_sched_runq(), ast_sched_wait(), ast_tvadd(), ast_tvnow(), ast_sched_thread::cond, ast_sched_thread::context, ast_sched_thread::lock, and ast_sched_thread::stop.

Referenced by ast_sched_thread_create().

00091 {
00092    struct ast_sched_thread *st = data;
00093 
00094    while (!st->stop) {
00095       int ms;
00096       struct timespec ts = {
00097          .tv_sec = 0,   
00098       };
00099 
00100       ast_mutex_lock(&st->lock);
00101 
00102       if (st->stop) {
00103          ast_mutex_unlock(&st->lock);
00104          return NULL;
00105       }
00106 
00107       ms = ast_sched_wait(st->context);
00108 
00109       if (ms == -1) {
00110          ast_cond_wait(&st->cond, &st->lock);
00111       } else { 
00112          struct timeval tv;
00113          tv = ast_tvadd(ast_tvnow(), ast_samp2tv(ms, 1000));
00114          ts.tv_sec = tv.tv_sec;
00115          ts.tv_nsec = tv.tv_usec * 1000;
00116          ast_cond_timedwait(&st->cond, &st->lock, &ts);
00117       }
00118 
00119       ast_mutex_unlock(&st->lock);
00120 
00121       if (st->stop) {
00122          return NULL;
00123       }
00124 
00125       ast_sched_runq(st->context);
00126    }
00127 
00128    return NULL;
00129 }

static int sched_settime ( struct timeval *  t,
int  when 
) [static]

given the last event *tv and the offset in milliseconds 'when', computes the next value,

Definition at line 380 of file sched.c.

References ast_samp2tv(), ast_tvadd(), ast_tvcmp(), ast_tvnow(), and ast_tvzero().

Referenced by ast_sched_add_variable(), and ast_sched_runq().

00381 {
00382    struct timeval now = ast_tvnow();
00383 
00384    /*ast_debug(1, "TV -> %lu,%lu\n", tv->tv_sec, tv->tv_usec);*/
00385    if (ast_tvzero(*t))  /* not supplied, default to now */
00386       *t = now;
00387    *t = ast_tvadd(*t, ast_samp2tv(when, 1000));
00388    if (ast_tvcmp(*t, now) < 0) {
00389       *t = now;
00390    }
00391    return 0;
00392 }

static int sched_time_cmp ( void *  a,
void *  b 
) [static]

Definition at line 241 of file sched.c.

References ast_tvcmp().

Referenced by sched_context_create().

00242 {
00243    return ast_tvcmp(((struct sched *) b)->when, ((struct sched *) a)->when);
00244 }

static void schedule ( struct sched_context con,
struct sched s 
) [static]

Take a sched structure and put it in the queue, such that the soonest event is first in the list.

Definition at line 361 of file sched.c.

References ast_hashtab_insert_safe(), ast_heap_push(), ast_log(), sched_context::highwater, sched::id, LOG_WARNING, sched_context::sched_heap, sched_context::schedcnt, and sched_context::schedq_ht.

Referenced by ast_sched_add_variable(), and ast_sched_runq().

00362 {
00363    ast_heap_push(con->sched_heap, s);
00364 
00365    if (!ast_hashtab_insert_safe(con->schedq_ht, s)) {
00366       ast_log(LOG_WARNING,"Schedule Queue entry %d is already in table!\n", s->id);
00367    }
00368 
00369    con->schedcnt++;
00370 
00371    if (con->schedcnt > con->highwater) {
00372       con->highwater = con->schedcnt;
00373    }
00374 }


Variable Documentation

struct ast_threadstorage last_del_id = { .once = PTHREAD_ONCE_INIT , .key_init = __init_last_del_id , .custom_init = NULL , } [static]

Definition at line 55 of file sched.c.

Referenced by ast_sched_del().


Generated on 20 Aug 2013 for Asterisk - The Open Source Telephony Project by  doxygen 1.6.1