kenmirrors
/
freeswitch
mirror of https://github.com/signalwire/freeswitch.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

marry mod_threadsoft with mod_softtimer 

git-svn-id: http://svn.freeswitch.org/svn/freeswitch/trunk@2713 d0543943-73ff-0310-b7d9-9358b9ac24b2
This commit is contained in:
Anthony Minessale 2006-09-16 20:18:24 +00:00
parent 555bd0af08
commit 88a9179a25
4 changed files with 165 additions and 538 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/mod/endpoints/mod_exosip/mod_exosip.c
View File

@ -585,7 +585,7 @@ static switch_status_t activate_rtp(struct private_object *tech_pvt)
ms,
flags,
key,
"thread_soft",
"soft",
&err, switch_core_session_get_pool(tech_pvt->session));
if (switch_rtp_ready(tech_pvt->rtp_session)) {

236
src/mod/timers/mod_softtimer/mod_softtimer.c
View File

@ -32,121 +32,131 @@
#include <switch.h>
#include <stdio.h>
static const char modname[] = "mod_softtimer";
static switch_memory_pool_t *module_pool = NULL;
#ifdef WIN32
//#define WINTIMER
#endif
static struct {
int32_t RUNNING;
switch_mutex_t *mutex;
uint32_t timer_milliseconds;
uint32_t timer_microseconds;
} globals;
static const char modname[] = "mod_softtimer";
#define MAX_ELEMENTS 1000
struct timer_private {
#ifdef WINTIMER
LARGE_INTEGER freq;
LARGE_INTEGER base;
LARGE_INTEGER now;
#else
switch_time_t reference;
#endif
uint32_t reference;
};
typedef struct timer_private timer_private_t;
static inline switch_status_t soft_timer_init(switch_timer_t *timer)
struct timer_matrix {
uint64_t tick;
uint32_t count;
};
typedef struct timer_matrix timer_matrix_t;
static timer_matrix_t TIMER_MATRIX[MAX_ELEMENTS+1];
#define IDLE_SPEED 100
static inline void set_timer(void)
{
struct timer_private *private;
uint32_t index = 0, min = IDLE_SPEED;
private = switch_core_alloc(timer->memory_pool, sizeof(*private));
timer->private_info = private;
for(index = 0; index < MAX_ELEMENTS; index++) {
if (TIMER_MATRIX[index].count) {
if (min > index) {
min = index;
}
}
}
#ifdef WINTIMER
QueryPerformanceFrequency(&private->freq);
QueryPerformanceCounter(&private->base);
#else
private->reference = switch_time_now();
#endif
globals.timer_milliseconds = min;
globals.timer_microseconds = min * 1000;
}
static inline switch_status_t timer_init(switch_timer_t *timer)
{
timer_private_t *private_info;
if ((private_info = switch_core_alloc(timer->memory_pool, sizeof(*private_info)))) {
switch_mutex_lock(globals.mutex);
TIMER_MATRIX[timer->interval].count++;
switch_mutex_unlock(globals.mutex);
timer->private_info = private_info;
private_info->reference = TIMER_MATRIX[timer->interval].tick;
set_timer();
return SWITCH_STATUS_SUCCESS;
}
static inline switch_status_t soft_timer_next(switch_timer_t *timer)
return SWITCH_STATUS_MEMERR;
}
static inline switch_status_t timer_step(switch_timer_t *timer)
{
struct timer_private *private = timer->private_info;
timer_private_t *private_info = timer->private_info;
#ifdef WINTIMER
private->base.QuadPart += timer->interval * (private->freq.QuadPart / 1000);
for (;;) {
QueryPerformanceCounter(&private->now);
if (private->now.QuadPart >= private->base.QuadPart) {
break;
}
switch_yield(100);
}
#else
private->reference += timer->interval * 1000;
private_info->reference += timer->interval;
while (switch_time_now() < private->reference) {
return SWITCH_STATUS_SUCCESS;
}
static inline switch_status_t timer_next(switch_timer_t *timer)
{
timer_private_t *private_info = timer->private_info;
timer_step(timer);
while (TIMER_MATRIX[timer->interval].tick < private_info->reference) {
switch_yield(1000);
}
#endif
timer->samplecount += timer->samples;
return SWITCH_STATUS_SUCCESS;
}
static inline switch_status_t soft_timer_step(switch_timer_t *timer)
{
struct timer_private *private = timer->private_info;
#ifdef WINTIMER
private->base.QuadPart += timer->interval * (private->freq.QuadPart / 1000);
#else
private->reference += timer->interval * 1000;
#endif
return SWITCH_STATUS_SUCCESS;
}
static inline switch_status_t soft_timer_check(switch_timer_t *timer)
static inline switch_status_t timer_check(switch_timer_t *timer)
{
struct timer_private *private = timer->private_info;
#ifdef WINTIMER
QueryPerformanceCounter(&private->now);
if (private->now.QuadPart >= private->base.QuadPart) {
private->base.QuadPart += timer->interval * (private->freq.QuadPart / 1000);
return SWITCH_STATUS_SUCCESS;
timer_private_t *private_info = timer->private_info;
switch_status_t status;
if (TIMER_MATRIX[timer->interval].tick < private_info->reference) {
status = SWITCH_STATUS_FALSE;
} else {
return SWITCH_STATUS_FALSE;
private_info->reference += timer->interval;
status = SWITCH_STATUS_SUCCESS;
}
#else
if (switch_time_now() < private->reference) {
return SWITCH_STATUS_FALSE;
} else {
private->reference += timer->interval * 1000;
return SWITCH_STATUS_SUCCESS;
}
#endif
return status;
}
static inline switch_status_t soft_timer_destroy(switch_timer_t *timer)
static inline switch_status_t timer_destroy(switch_timer_t *timer)
{
switch_mutex_lock(globals.mutex);
TIMER_MATRIX[timer->interval].count--;
switch_mutex_unlock(globals.mutex);
set_timer();
timer->private_info = NULL;
return SWITCH_STATUS_SUCCESS;
}
static const switch_timer_interface_t soft_timer_interface = {
/*.interface_name */ "soft",
/*.timer_init */ soft_timer_init,
/*.timer_next */ soft_timer_next,
/*.timer_step */ soft_timer_step,
/*.timer_check */ soft_timer_check,
/*.timer_destroy */ soft_timer_destroy
static const switch_timer_interface_t timer_interface = {
/*.interface_name */ "thread_soft",
/*.timer_init */ timer_init,
/*.timer_next */ timer_next,
/*.timer_step */ timer_step,
/*.timer_check */ timer_check,
/*.timer_destroy */ timer_destroy
};
static const switch_loadable_module_interface_t mod_timers_module_interface = {
static const switch_loadable_module_interface_t mod_softtimer_module_interface = {
/*.module_name */ modname,
/*.endpoint_interface */ NULL,
/*.timer_interface */ &soft_timer_interface,
/*.timer_interface */ &timer_interface,
/*.switch_dialplan_interface */ NULL,
/*.switch_codec_interface */ NULL,
/*.switch_application_interface */ NULL
@ -155,9 +165,81 @@ static const switch_loadable_module_interface_t mod_timers_module_interface = {
SWITCH_MOD_DECLARE(switch_status_t) switch_module_load(const switch_loadable_module_interface_t **module_interface, char *filename)
{
if (switch_core_new_memory_pool(&module_pool) != SWITCH_STATUS_SUCCESS) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "OH OH no pool\n");
return SWITCH_STATUS_MEMERR;
}
/* connect my internal structure to the blank pointer passed to me */
*module_interface = &mod_timers_module_interface;
*module_interface = &mod_softtimer_module_interface;
/* indicate that the module should continue to be loaded */
return SWITCH_STATUS_SUCCESS;
}
SWITCH_MOD_DECLARE(switch_status_t) switch_module_runtime(void)
{
switch_time_t reference = switch_time_now();
uint32_t current_ms = 0;
uint32_t x;
memset(&globals, 0, sizeof(globals));
switch_mutex_init(&globals.mutex, SWITCH_MUTEX_NESTED, module_pool);
globals.timer_microseconds = IDLE_SPEED * 1000;
globals.timer_milliseconds = IDLE_SPEED;
globals.RUNNING = 1;
while(globals.RUNNING == 1) {
reference += globals.timer_microseconds;
while (switch_time_now() < reference) {
//switch_yield((reference - now) - 1000);
switch_yield(globals.timer_microseconds >> 1);
}
current_ms += globals.timer_milliseconds;
for (x = 0; x < MAX_ELEMENTS; x++) {
int i = x, index;
if (i == 0) {
i = 1;
}
index = (current_ms % i == 0) ? i : 0;
if (TIMER_MATRIX[index].count) {
TIMER_MATRIX[index].tick += index;
}
}
if (current_ms == MAX_ELEMENTS) {
current_ms = 0;
}
}
switch_mutex_lock(globals.mutex);
globals.RUNNING = 0;
switch_mutex_unlock(globals.mutex);
return SWITCH_STATUS_TERM;
}
SWITCH_MOD_DECLARE(switch_status_t) switch_module_shutdown(void)
{
if (globals.RUNNING) {
switch_mutex_lock(globals.mutex);
globals.RUNNING = -1;
switch_mutex_unlock(globals.mutex);
while (globals.RUNNING) {
switch_yield(10000);
}
}
return SWITCH_STATUS_SUCCESS;
}

245
src/mod/timers/mod_threadtimer/mod_threadtimer.c
View File

@ -1,245 +0,0 @@
/*
* FreeSWITCH Modular Media Switching Software Library / Soft-Switch Application
* Copyright (C) 2005/2006, Anthony Minessale II <anthmct@yahoo.com>
*
* Version: MPL 1.1
*
* The contents of this file are subject to the Mozilla Public License Version
* 1.1 (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is FreeSWITCH Modular Media Switching Software Library / Soft-Switch Application
*
* The Initial Developer of the Original Code is
* Anthony Minessale II <anthmct@yahoo.com>
* Portions created by the Initial Developer are Copyright (C)
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
*
* Anthony Minessale II <anthmct@yahoo.com>
*
*
* mod_threadtimer.c -- Software Timer Module
*
*/
#include <switch.h>
#include <stdio.h>
static switch_memory_pool_t *module_pool = NULL;
static struct {
int32_t RUNNING;
switch_mutex_t *mutex;
uint32_t timer_milliseconds;
uint32_t timer_microseconds;
} globals;
static const char modname[] = "mod_threadtimer";
#define MAX_ELEMENTS 1000
struct timer_private {
uint32_t reference;
};
typedef struct timer_private timer_private_t;
struct timer_matrix {
uint64_t tick;
uint32_t count;
};
typedef struct timer_matrix timer_matrix_t;
static timer_matrix_t TIMER_MATRIX[MAX_ELEMENTS+1];
#define IDLE_SPEED 100
static inline void set_timer(void)
{
uint32_t index = 0, min = IDLE_SPEED;
for(index = 0; index < MAX_ELEMENTS; index++) {
if (TIMER_MATRIX[index].count) {
if (min > index) {
min = index;
}
}
}
globals.timer_milliseconds = min;
globals.timer_microseconds = min * 1000;
}
static inline switch_status_t timer_init(switch_timer_t *timer)
{
timer_private_t *private_info;
if ((private_info = switch_core_alloc(timer->memory_pool, sizeof(*private_info)))) {
switch_mutex_lock(globals.mutex);
TIMER_MATRIX[timer->interval].count++;
switch_mutex_unlock(globals.mutex);
timer->private_info = private_info;
private_info->reference = TIMER_MATRIX[timer->interval].tick;
set_timer();
return SWITCH_STATUS_SUCCESS;
}
return SWITCH_STATUS_MEMERR;
}
static inline switch_status_t timer_step(switch_timer_t *timer)
{
timer_private_t *private_info = timer->private_info;
private_info->reference += timer->interval;
return SWITCH_STATUS_SUCCESS;
}
static inline switch_status_t timer_next(switch_timer_t *timer)
{
timer_private_t *private_info = timer->private_info;
timer_step(timer);
while (TIMER_MATRIX[timer->interval].tick < private_info->reference) {
switch_yield(1000);
}
timer->samplecount += timer->samples;
return SWITCH_STATUS_SUCCESS;
}
static inline switch_status_t timer_check(switch_timer_t *timer)
{
timer_private_t *private_info = timer->private_info;
switch_status_t status;
if (TIMER_MATRIX[timer->interval].tick < private_info->reference) {
status = SWITCH_STATUS_FALSE;
} else {
private_info->reference += timer->interval;
status = SWITCH_STATUS_SUCCESS;
}
return status;
}
static inline switch_status_t timer_destroy(switch_timer_t *timer)
{
switch_mutex_lock(globals.mutex);
TIMER_MATRIX[timer->interval].count--;
switch_mutex_unlock(globals.mutex);
set_timer();
timer->private_info = NULL;
return SWITCH_STATUS_SUCCESS;
}
static const switch_timer_interface_t timer_interface = {
/*.interface_name */ "thread_soft",
/*.timer_init */ timer_init,
/*.timer_next */ timer_next,
/*.timer_step */ timer_step,
/*.timer_check */ timer_check,
/*.timer_destroy */ timer_destroy
};
static const switch_loadable_module_interface_t mod_threadtimer_module_interface = {
/*.module_name */ modname,
/*.endpoint_interface */ NULL,
/*.timer_interface */ &timer_interface,
/*.switch_dialplan_interface */ NULL,
/*.switch_codec_interface */ NULL,
/*.switch_application_interface */ NULL
};
SWITCH_MOD_DECLARE(switch_status_t) switch_module_load(const switch_loadable_module_interface_t **module_interface, char *filename)
{
if (switch_core_new_memory_pool(&module_pool) != SWITCH_STATUS_SUCCESS) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "OH OH no pool\n");
return SWITCH_STATUS_MEMERR;
}
/* connect my internal structure to the blank pointer passed to me */
*module_interface = &mod_threadtimer_module_interface;
/* indicate that the module should continue to be loaded */
return SWITCH_STATUS_SUCCESS;
}
SWITCH_MOD_DECLARE(switch_status_t) switch_module_runtime(void)
{
switch_time_t reference = switch_time_now();
uint32_t current_ms = 0;
uint32_t x;
memset(&globals, 0, sizeof(globals));
switch_mutex_init(&globals.mutex, SWITCH_MUTEX_NESTED, module_pool);
globals.timer_microseconds = IDLE_SPEED * 1000;
globals.timer_milliseconds = IDLE_SPEED;
globals.RUNNING = 1;
while(globals.RUNNING == 1) {
reference += globals.timer_microseconds;
while (switch_time_now() < reference) {
//switch_yield((reference - now) - 1000);
switch_yield(globals.timer_microseconds >> 1);
}
current_ms += globals.timer_milliseconds;
for (x = 0; x < MAX_ELEMENTS; x++) {
int i = x, index;
if (i == 0) {
i = 1;
}
index = (current_ms % i == 0) ? i : 0;
if (TIMER_MATRIX[index].count) {
TIMER_MATRIX[index].tick += index;
}
}
if (current_ms == MAX_ELEMENTS) {
current_ms = 0;
}
}
switch_mutex_lock(globals.mutex);
globals.RUNNING = 0;
switch_mutex_unlock(globals.mutex);
return SWITCH_STATUS_TERM;
}
SWITCH_MOD_DECLARE(switch_status_t) switch_module_shutdown(void)
{
if (globals.RUNNING) {
switch_mutex_lock(globals.mutex);
globals.RUNNING = -1;
switch_mutex_unlock(globals.mutex);
while (globals.RUNNING) {
switch_yield(10000);
}
}
return SWITCH_STATUS_SUCCESS;
}

210
src/mod/timers/mod_threadtimer/mod_threadtimer.vcproj
View File

@ -1,210 +0,0 @@
<?xml version="1.0" encoding="Windows-1252"?>
<VisualStudioProject
ProjectType="Visual C++"
Version="8.00"
Name="mod_threadtimer"
ProjectGUID="{F2DCC46E-3BE4-4392-81BF-973B2E47EB64}"
RootNamespace="mod_threadtimer"
Keyword="Win32Proj"
>
<Platforms>
<Platform
Name="Win32"
/>
</Platforms>
<ToolFiles>
</ToolFiles>
<Configurations>
<Configuration
Name="Debug|Win32"
OutputDirectory="$(ConfigurationName)"
IntermediateDirectory="$(ConfigurationName)"
ConfigurationType="2"
InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"
CharacterSet="2"
>
<Tool
Name="VCPreBuildEventTool"
/>
<Tool
Name="VCCustomBuildTool"
/>
<Tool
Name="VCXMLDataGeneratorTool"
/>
<Tool
Name="VCWebServiceProxyGeneratorTool"
/>
<Tool
Name="VCMIDLTool"
/>
<Tool
Name="VCCLCompilerTool"
Optimization="0"
AdditionalIncludeDirectories="&quot;$(InputDir)..\..\..\include&quot;;&quot;$(InputDir)include&quot;;&quot;$(InputDir)..\..\..\..\libs\include&quot;"
PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;_USRDLL;MOD_EXPORTS"
MinimalRebuild="true"
BasicRuntimeChecks="3"
RuntimeLibrary="1"
UsePrecompiledHeader="0"
WarningLevel="4"
WarnAsError="true"
Detect64BitPortabilityProblems="true"
DebugInformationFormat="3"
/>
<Tool
Name="VCManagedResourceCompilerTool"
/>
<Tool
Name="VCResourceCompilerTool"
/>
<Tool
Name="VCPreLinkEventTool"
/>
<Tool
Name="VCLinkerTool"
OutputFile="$(SolutionDir)$(OutDir)/mod/$(InputName).dll"
LinkIncremental="1"
AdditionalLibraryDirectories="..\..\..\..\w32\vsnet\$(OutDir)"
GenerateDebugInformation="true"
ProgramDatabaseFile="$(OutDir)$(TargetName).pdb"
SubSystem="2"
ImportLibrary="$(OutDir)/mod_threadtimer.lib"
TargetMachine="1"
/>
<Tool
Name="VCALinkTool"
/>
<Tool
Name="VCManifestTool"
/>
<Tool
Name="VCXDCMakeTool"
/>
<Tool
Name="VCBscMakeTool"
/>
<Tool
Name="VCFxCopTool"
/>
<Tool
Name="VCAppVerifierTool"
/>
<Tool
Name="VCWebDeploymentTool"
/>
<Tool
Name="VCPostBuildEventTool"
/>
</Configuration>
<Configuration
Name="Release|Win32"
OutputDirectory="$(ConfigurationName)"
IntermediateDirectory="$(ConfigurationName)"
ConfigurationType="2"
InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"
CharacterSet="2"
>
<Tool
Name="VCPreBuildEventTool"
/>
<Tool
Name="VCCustomBuildTool"
/>
<Tool
Name="VCXMLDataGeneratorTool"
/>
<Tool
Name="VCWebServiceProxyGeneratorTool"
/>
<Tool
Name="VCMIDLTool"
/>
<Tool
Name="VCCLCompilerTool"
AdditionalIncludeDirectories="&quot;$(InputDir)..\..\..\include&quot;;&quot;$(InputDir)include&quot;;&quot;$(InputDir)..\..\..\..\libs\include&quot;"
PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;_USRDLL;MOD_EXPORTS"
RuntimeLibrary="0"
UsePrecompiledHeader="0"
WarningLevel="4"
WarnAsError="true"
Detect64BitPortabilityProblems="true"
DebugInformationFormat="3"
/>
<Tool
Name="VCManagedResourceCompilerTool"
/>
<Tool
Name="VCResourceCompilerTool"
/>
<Tool
Name="VCPreLinkEventTool"
/>
<Tool
Name="VCLinkerTool"
OutputFile="$(SolutionDir)$(OutDir)/mod/$(InputName).dll"
LinkIncremental="1"
AdditionalLibraryDirectories="..\..\..\..\w32\vsnet\$(OutDir)"
GenerateDebugInformation="true"
ProgramDatabaseFile="$(OutDir)$(TargetName).pdb"
SubSystem="2"
OptimizeReferences="2"
EnableCOMDATFolding="2"
ImportLibrary="$(OutDir)/mod_threadtimer.lib"
TargetMachine="1"
/>
<Tool
Name="VCALinkTool"
/>
<Tool
Name="VCManifestTool"
/>
<Tool
Name="VCXDCMakeTool"
/>
<Tool
Name="VCBscMakeTool"
/>
<Tool
Name="VCFxCopTool"
/>
<Tool
Name="VCAppVerifierTool"
/>
<Tool
Name="VCWebDeploymentTool"
/>
<Tool
Name="VCPostBuildEventTool"
/>
</Configuration>
</Configurations>
<References>
</References>
<Files>
<Filter
Name="Source Files"
Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm;asmx"
UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
>
<File
RelativePath=".\mod_threadtimer.c"
>
</File>
</Filter>
<Filter
Name="Header Files"
Filter="h;hpp;hxx;hm;inl;inc;xsd"
UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
>
</Filter>
<Filter
Name="Resource Files"
Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx"
UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}"
>
</Filter>
</Files>
<Globals>
</Globals>
</VisualStudioProject>