kenmirrors/asterisk
1
0
Fork 0
mirror of https://github.com/asterisk/asterisk.git synced 2025-10-13 00:04:53 +00:00
Code Issues Packages Projects Releases Wiki Activity

Multiple revisions 400318-400319

Browse Source 
........
  r400318 | mmichelson | 2013-10-02 17:08:49 -0500 (Wed, 02 Oct 2013) | 12 lines
  
  Remove unnecessary waits from stasis.
  
  Since caches are updated on publisher threads, there is no need
  to wait for the cache updates to occur after a stasis message
  is published.
  
  In the case of chan_pjsip device state changes, this set of
  changes caused an improvement to performance.
  
  Review: https://reviewboard.asterisk.org/r/2890
........
  r400319 | mmichelson | 2013-10-02 17:10:54 -0500 (Wed, 02 Oct 2013) | 3 lines
  
  Remove svn:mergeinfo property.
........

Merged revisions 400318-400319 from http://svn.asterisk.org/svn/asterisk/branches/12


git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@400335 65c4cc65-6c06-0410-ace0-fbb531ad65f3
This commit is contained in:
Mark Michelson
2013-10-02 22:22:17 +00:00
parent e4ed9886e6
commit addbf276f5
8 changed files with 8 additions and 164 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
main/stasis.c
View File

@@ -814,11 +814,6 @@ int stasis_init(void)
/* Be sure the types are cleaned up after the message bus */
ast_register_cleanup(stasis_cleanup);
if (stasis_wait_init() != 0) {
ast_log(LOG_ERROR, "Stasis initialization failed\n");
return -1;
}
cache_init = stasis_cache_init();
if (cache_init != 0) {
return -1;

6
main/stasis_endpoints.c
View File

@@ -187,7 +187,7 @@ void ast_endpoint_blob_publish(struct ast_endpoint *endpoint, struct stasis_mess
}
struct ast_endpoint_snapshot *ast_endpoint_latest_snapshot(const char *tech,
const char *name, unsigned int guaranteed)
const char *name)
{
RAII_VAR(char *, id, NULL, ast_free);
RAII_VAR(struct stasis_message *, msg, NULL, ao2_cleanup);
@@ -198,10 +198,6 @@ struct ast_endpoint_snapshot *ast_endpoint_latest_snapshot(const char *tech,
return NULL;
}
if (guaranteed) {
stasis_topic_wait(ast_endpoint_topic_all_cached());
}
msg = stasis_cache_get(ast_endpoint_cache(),
ast_endpoint_snapshot_type(), id);
if (!msg) {

133
main/stasis_wait.c
View File

@@ -1,133 +0,0 @@
/*
* Asterisk -- An open source telephony toolkit.
*
* Copyright (C) 2013, Digium, Inc.
*
* Joshua Colp <jcolp@digium.com>
*
* See http://www.asterisk.org for more information about
* the Asterisk project. Please do not directly contact
* any of the maintainers of this project for assistance;
* the project provides a web site, mailing lists and IRC
* channels for your use.
*
* This program is free software, distributed under the terms of
* the GNU General Public License Version 2. See the LICENSE file
* at the top of the source tree.
*/
/*! \file
*
* \brief Wait support for Stasis topics.
*
* \author Joshua Colp <jcolp@digium.com>
*/
/*** MODULEINFO
<support_level>core</support_level>
***/
#include "asterisk.h"
ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
#include "asterisk/astobj2.h"
#include "asterisk/stasis.h"
static struct stasis_message_type *cache_guarantee_type(void);
STASIS_MESSAGE_TYPE_DEFN(cache_guarantee_type);
/*! \internal */
struct caching_guarantee {
ast_mutex_t lock;
ast_cond_t cond;
unsigned int done:1;
};
static void caching_guarantee_dtor(void *obj)
{
struct caching_guarantee *guarantee = obj;
ast_assert(guarantee->done == 1);
ast_mutex_destroy(&guarantee->lock);
ast_cond_destroy(&guarantee->cond);
}
static void guarantee_handler(void *data, struct stasis_subscription *sub,
struct stasis_message *message)
{
/* Wait for our particular message */
if (data == message) {
struct caching_guarantee *guarantee;
ast_assert(cache_guarantee_type() == stasis_message_type(message));
guarantee = stasis_message_data(message);
ast_mutex_lock(&guarantee->lock);
guarantee->done = 1;
ast_cond_signal(&guarantee->cond);
ast_mutex_unlock(&guarantee->lock);
}
}
static struct stasis_message *caching_guarantee_create(void)
{
RAII_VAR(struct caching_guarantee *, guarantee, NULL, ao2_cleanup);
RAII_VAR(struct stasis_message *, msg, NULL, ao2_cleanup);
if (!(guarantee = ao2_alloc(sizeof(*guarantee), caching_guarantee_dtor))) {
return NULL;
}
ast_mutex_init(&guarantee->lock);
ast_cond_init(&guarantee->cond, NULL);
if (!(msg = stasis_message_create(cache_guarantee_type(), guarantee))) {
return NULL;
}
ao2_ref(msg, +1);
return msg;
}
int stasis_topic_wait(struct stasis_topic *topic)
{
RAII_VAR(struct stasis_message *, msg, NULL, ao2_cleanup);
RAII_VAR(struct stasis_subscription *, sub, NULL, stasis_unsubscribe);
struct caching_guarantee *guarantee;
msg = caching_guarantee_create();
if (!msg) {
return -1;
}
sub = stasis_subscribe(topic, guarantee_handler, msg);
if (!sub) {
return -1;
}
guarantee = stasis_message_data(msg);
ast_mutex_lock(&guarantee->lock);
stasis_publish(topic, msg);
while (!guarantee->done) {
ast_cond_wait(&guarantee->cond, &guarantee->lock);
}
ast_mutex_unlock(&guarantee->lock);
return 0;
}
static void wait_cleanup(void)
{
STASIS_MESSAGE_TYPE_CLEANUP(cache_guarantee_type);
}
int stasis_wait_init(void)
{
ast_register_cleanup(wait_cleanup);
if (STASIS_MESSAGE_TYPE_INIT(cache_guarantee_type) != 0) {
return -1;
}
return 0;
}