static void throttle_wait(size_t total_bytes_processed TSRMLS_DC)
{
struct timeval tv;
double time;
double min_time;
size_t bytes_processed;
bytes_processed = total_bytes_processed - THROTTLE_G(post_bytes_processed);
throttle_debug("throttle: bytes processed: %zd (total: %zd)\n", bytes_processed, total_bytes_processed);
min_time = (double) bytes_processed / (double) THROTTLE_G(speed);
gettimeofday(&tv, NULL);
time = (double) tv.tv_sec + tv.tv_usec / 1000000.0;
if (time < THROTTLE_G(lasttime) + min_time) {
useconds_t usec;
throttle_debug("throttle: waiting for %f seconds (until %f)\n", THROTTLE_G(lasttime) + min_time - time, THROTTLE_G(lasttime) + min_time);
usec = (THROTTLE_G(lasttime) + min_time - time) * 1000000.0;
usleep(usec);
gettimeofday(&tv, NULL);
time = (double) tv.tv_sec + tv.tv_usec / 1000000.0;
}
THROTTLE_G(post_bytes_processed) = total_bytes_processed;
THROTTLE_G(lasttime) = time;
}
static void S_throttle_pool_rearm_workers(liThrottlePool *pool, guint worker_count, guint time_diff) {
guint i;
gint64 connections = 0;
gint64 wrk_connections[worker_count];
gint64 fill;
for (i = 0; i < worker_count; ++i) {
wrk_connections[i] = g_atomic_int_get((gint*) &pool->workers[i].connections);
connections += wrk_connections[i];
}
if (0 == connections) return;
time_diff = MIN(time_diff, 1000);
fill = MIN((guint64) pool->burst, ((guint64) pool->rate * time_diff) / 1000u);
throttle_debug("rearm workers: refill %i after %u (or more) msecs (rate %u, burst %u)\n",
(guint) fill, (guint) time_diff, pool->rate, pool->burst);
for (i = 0; i < worker_count; ++i) {
gint wrk_fill;
if (0 == wrk_connections[i]) continue;
wrk_fill = (fill * wrk_connections[i]) / connections;
throttle_debug("rearm worker %u: refill %u\n", i, wrk_fill);
g_atomic_int_add(&pool->workers[i].magazine, wrk_fill);
}
}
void li_throttle_waitqueue_cb(liWaitQueue *wq, gpointer data) {
liWaitQueueElem *wqe;
UNUSED(data); /* should contain worker */
throttle_debug("li_throttle_waitqueue_cb\n");
while (NULL != (wqe = li_waitqueue_pop(wq))) {
liThrottleState *state = LI_CONTAINER_OF(wqe, liThrottleState, wqueue_elem);
liThrottleNotifyCB notify_callback = state->notify_callback;
gpointer notify_data = wqe->data;
if (NULL == notify_data || NULL == notify_callback || 0 == state->interested) continue;
notify_callback(state, notify_data);
}
li_waitqueue_update(wq);
}
static void throttle_pool_rearm(liWorker *wrk, liThrottlePool *pool, guint now) {
liThrottlePoolWorkerState *wpool = &pool->workers[wrk->ndx];
guint last = g_atomic_int_get((gint*) &pool->last_rearm);
guint time_diff = now - last;
if (G_UNLIKELY(time_diff >= LI_THROTTLE_GRANULARITY)) {
g_mutex_lock(pool->rearm_mutex);
/* check again */
last = g_atomic_int_get((gint*) &pool->last_rearm);
time_diff = now - last;
if (G_LIKELY(time_diff >= LI_THROTTLE_GRANULARITY)) {
S_throttle_pool_rearm_workers(pool, wrk->srv->worker_count, time_diff);
g_atomic_int_set((gint*) &pool->last_rearm, now);
}
g_mutex_unlock(pool->rearm_mutex);
}
if (G_UNLIKELY(wpool->last_rearm < last)) {
/* distribute wpool->magazine */
GList *lnk;
guint connections = wpool->connections;
gint magazine = g_atomic_int_get(&wpool->magazine);
gint supply = magazine / connections;
g_atomic_int_add(&wpool->magazine, -supply * connections);
wpool->last_rearm = now;
throttle_debug("throttle_pool_rearm: distribute supply %i on each of %i connections\n",
supply, connections);
if (0 == supply) return;
g_atomic_int_set((gint*) &wpool->connections, 0);
while (NULL != (lnk = g_queue_pop_head_link(&wpool->waiting))) {
liThrottlePoolState *pstate = LI_CONTAINER_OF(lnk, liThrottlePoolState, pool_link);
pstate->magazine += supply;
lnk->data = NULL;
}
}
}
guint li_throttle_query(liWorker *wrk, liThrottleState *state, guint interested, liThrottleNotifyCB notify_callback, gpointer data) {
guint now = msec_timestamp(li_cur_ts(wrk));
gint fill, pool_fill;
guint i, len;
if (NULL == state) return interested;
state->notify_callback = NULL;
state->wqueue_elem.data = NULL;
throttle_debug("li_throttle_query[%u]: interested %i, magazine %i\n", now, interested, state->magazine);
if (interested > THROTTLE_MAX_STEP) interested = THROTTLE_MAX_STEP;
if ((gint) interested <= state->magazine + THROTTLE_OVERLOAD) return interested;
/* also try to balance negative magazine */
fill = interested - state->magazine;
if (state->single_rate != 0) {
if (now - state->single_last_rearm >= LI_THROTTLE_GRANULARITY) {
guint single_fill = (((guint64) state->single_rate) * (now - state->single_last_rearm)) / 1000u;
state->single_last_rearm = now;
if (state->single_burst - state->single_magazine < single_fill) {
state->single_magazine = state->single_burst;
} else {
state->single_magazine += single_fill;
}
}
if (fill > state->single_magazine) fill = state->single_magazine;
throttle_debug("single_magazine: %i\n", state->single_magazine);
}
/* pool_fill <= fill in the loop */
pool_fill = fill;
for (i = 0, len = state->pools->len; i < len; ++i) {
liThrottlePoolState *pstate = g_ptr_array_index(state->pools, i);
liThrottlePool *pool = pstate->pool;
liThrottlePoolWorkerState *pwstate = &pool->workers[wrk->ndx];
if (fill > pstate->magazine) {
throttle_register(pwstate, pstate);
throttle_pool_rearm(wrk, pool, now);
if (fill > pstate->magazine) {
throttle_register(pwstate, pstate);
if (pool_fill > pstate->magazine) {
pool_fill = pstate->magazine;
}
}
}
throttle_debug("pool %i magazine: %i\n", i, state->single_magazine);
}
throttle_debug("query refill: %i\n", pool_fill);
if (pool_fill > 0) {
if (state->single_rate != 0) {
state->single_magazine -= pool_fill;
}
for (i = 0, len = state->pools->len; i < len; ++i) {
liThrottlePoolState *pstate = g_ptr_array_index(state->pools, i);
pstate->magazine -= pool_fill;
}
state->magazine += pool_fill;
}
if (state->magazine + THROTTLE_OVERLOAD <= 0) {
throttle_debug("query queueing\n");
state->wqueue_elem.data = data;
state->notify_callback = notify_callback;
state->interested = interested;
if (!state->wqueue_elem.queued) {
li_waitqueue_push(&wrk->throttle_queue, &state->wqueue_elem);
}
return 0;
}
throttle_debug("query success: %i\n", state->magazine + THROTTLE_OVERLOAD);
if ((gint) interested <= state->magazine + THROTTLE_OVERLOAD) return interested;
return state->magazine + THROTTLE_OVERLOAD;
}
