static void
rtpp_proc_async_run(void *arg)
{
struct cfg *cf;
double last_tick_time;
int alarm_tick, i, ndrain, rtp_only;
struct rtpp_proc_async_cf *proc_cf;
long long ncycles_ref;
#ifdef RTPP_DEBUG
int ncycles_ref_pre, last_ctick;
#endif
struct sign_arg *s_a;
struct rtpp_wi *wi, *wis[10];
struct sthread_args *sender;
double tp[4];
struct rtpp_proc_rstats *rstats;
struct rtpp_stats_obj *stats_cf;
cf = (struct cfg *)arg;
proc_cf = cf->stable->rtpp_proc_cf;
stats_cf = cf->stable->rtpp_stats;
rstats = &proc_cf->rstats;
last_tick_time = 0;
wi = rtpp_queue_get_item(proc_cf->time_q, 0);
s_a = (struct sign_arg *)rtpp_wi_sgnl_get_data(wi, NULL);
#ifdef RTPP_DEBUG
last_ctick = s_a->clock_tick;
ncycles_ref_pre = s_a->ncycles_ref;
#endif
rtpp_wi_free(wi);
tp[0] = getdtime();
for (;;) {
i = rtpp_queue_get_items(proc_cf->time_q, wis, 10, 0);
if (i <= 0) {
continue;
}
i -= 1;
s_a = (struct sign_arg *)rtpp_wi_sgnl_get_data(wis[i], NULL);
ndrain = (s_a->ncycles_ref - ncycles_ref) / (cf->stable->target_pfreq / MAX_RTP_RATE);
#ifdef RTPP_DEBUG
last_ctick = s_a->clock_tick;
ncycles_ref_pre = ncycles_ref;
#endif
ncycles_ref = s_a->ncycles_ref;
for(; i > -1; i--) {
rtpp_wi_free(wis[i]);
}
tp[1] = getdtime();
#if RTPP_DEBUG
if (last_ctick % (unsigned int)cf->stable->target_pfreq == 0 || last_ctick < 1000) {
rtpp_log_write(RTPP_LOG_DBUG, cf->stable->glog, "run %lld sptime %f, CSV: %f,%f,%f", \
last_ctick, tp[1], (double)last_ctick / cf->stable->target_pfreq, \
((double)ncycles_ref / cf->stable->target_pfreq) - tp[1], tp[1]);
}
#endif
if (ndrain < 1) {
ndrain = 1;
}
#if RTPP_DEBUG
if (ndrain > 1) {
rtpp_log_write(RTPP_LOG_DBUG, cf->stable->glog, "run %lld " \
"ncycles_ref %lld, ncycles_ref_pre %lld, ndrain %d CSV: %f,%f,%d", \
last_ctick, ncycles_ref, ncycles_ref_pre, ndrain, \
(double)last_ctick / cf->stable->target_pfreq, ndrain);
}
#endif
alarm_tick = 0;
if (last_tick_time == 0 || last_tick_time > tp[1]) {
last_tick_time = tp[1];
} else if (last_tick_time + (double)TIMETICK < tp[1]) {
alarm_tick = 1;
last_tick_time = tp[1];
}
if (alarm_tick || (ncycles_ref % 7) == 0) {
rtp_only = 0;
} else {
rtp_only = 1;
}
pthread_mutex_lock(&cf->sessinfo.lock);
if (cf->sessinfo.nsessions > 0) {
if (rtp_only == 0) {
i = poll(cf->sessinfo.pfds_rtcp, cf->sessinfo.nsessions, 0);
}
i = poll(cf->sessinfo.pfds_rtp, cf->sessinfo.nsessions, 0);
pthread_mutex_unlock(&cf->sessinfo.lock);
if (i < 0 && errno == EINTR) {
rtpp_command_async_wakeup(cf->stable->rtpp_cmd_cf);
tp[0] = getdtime();
continue;
}
} else {
pthread_mutex_unlock(&cf->sessinfo.lock);
}
tp[2] = getdtime();
sender = rtpp_anetio_pick_sender(proc_cf->op);
if (rtp_only == 0) {
pthread_mutex_lock(&cf->glock);
process_rtp(cf, tp[2], alarm_tick, ndrain, sender, rstats);
} else {
process_rtp_only(cf, tp[2], ndrain, sender, rstats);
pthread_mutex_lock(&cf->glock);
}
if (cf->rtp_nsessions > 0) {
process_rtp_servers(cf, tp[2], sender, rstats);
}
pthread_mutex_unlock(&cf->glock);
rtpp_anetio_pump_q(sender);
rtpp_command_async_wakeup(cf->stable->rtpp_cmd_cf);
tp[3] = getdtime();
flush_rstats(stats_cf, rstats);
#if RTPP_DEBUG
recfilter_apply(&proc_cf->sleep_time, tp[1] - tp[0]);
recfilter_apply(&proc_cf->poll_time, tp[2] - tp[1]);
recfilter_apply(&proc_cf->proc_time, tp[3] - tp[2]);
#endif
tp[0] = tp[3];
#if RTPP_DEBUG
if (last_ctick % (unsigned int)cf->stable->target_pfreq == 0 || last_ctick < 1000) {
#if 0
rtpp_log_write(RTPP_LOG_DBUG, cf->stable->glog, "run %lld eptime %f, CSV: %f,%f,%f", \
last_ctick, tp[3], (double)last_ctick / cf->stable->target_pfreq, tp[3] - tp[1], tp[3]);
#endif
rtpp_log_write(RTPP_LOG_DBUG, cf->stable->glog, "run %lld eptime %f sleep_time %f poll_time %f proc_time %f CSV: %f,%f,%f,%f", \
last_ctick, tp[3], proc_cf->sleep_time.lastval, proc_cf->poll_time.lastval, proc_cf->proc_time.lastval, \
(double)last_ctick / cf->stable->target_pfreq, proc_cf->sleep_time.lastval, proc_cf->poll_time.lastval, proc_cf->proc_time.lastval);
}
#endif
}
}
static void
rtpp_cmd_acceptor_run(void *arg)
{
struct rtpp_cmd_async_cf *cmd_cf;
struct pollfd *tp;
struct rtpp_cmd_pollset *psp;
struct rtpp_cmd_accptset *asp;
struct rtpp_cmd_connection *rcc;
int nready, controlfd, i, tstate;
struct sockaddr_storage raddr;
cmd_cf = (struct rtpp_cmd_async_cf *)arg;
psp = &cmd_cf->pset;
asp = &cmd_cf->aset;
for (;;) {
#ifndef LINUX_XXX
nready = poll(asp->pfds, asp->pfds_used, INFTIM);
#else
nready = poll(asp->pfds, asp->pfds_used, 100);
#endif
pthread_mutex_lock(&cmd_cf->cmd_mutex);
tstate = cmd_cf->tstate_acceptor;
pthread_mutex_unlock(&cmd_cf->cmd_mutex);
if (tstate == TSTATE_CEASE) {
break;
}
if (nready <= 0)
continue;
for (i = 0; i < asp->pfds_used; i++) {
if ((asp->pfds[i].revents & POLLIN) == 0) {
continue;
}
pthread_mutex_lock(&psp->pfds_mutex);
if (psp->pfds_used >= RTPC_MAX_CONNECTIONS) {
pthread_mutex_unlock(&psp->pfds_mutex);
continue;
}
controlfd = accept_connection(cmd_cf->cf_save, asp->csocks[i],
sstosa(&raddr));
if (controlfd < 0) {
pthread_mutex_unlock(&psp->pfds_mutex);
continue;
}
tp = realloc(psp->pfds, sizeof(struct pollfd) * (psp->pfds_used + 1));
if (tp == NULL) {
pthread_mutex_unlock(&psp->pfds_mutex);
close(controlfd); /* Yeah, sorry, please try later */
continue;
}
rcc = rtpp_cmd_connection_ctor(controlfd, controlfd, asp->csocks[i],
sstosa(&raddr));
if (rcc == NULL) {
pthread_mutex_unlock(&psp->pfds_mutex);
close(controlfd); /* Yeah, sorry, please try later */
continue;
}
psp->pfds = tp;
psp->pfds[psp->pfds_used].fd = controlfd;
psp->pfds[psp->pfds_used].events = POLLIN | POLLERR | POLLHUP;
psp->pfds[psp->pfds_used].revents = 0;
psp->rccs[psp->pfds_used] = rcc;
psp->pfds_used++;
pthread_mutex_unlock(&psp->pfds_mutex);
rtpp_command_async_wakeup(&cmd_cf->pub);
}
}
}
