|
|
|
@ -1,374 +1,370 @@ |
|
|
|
/*
|
|
|
|
* Implemented with token bucket algorithm. |
|
|
|
* On average, the rate of bytes/s never exceeds the specified limit |
|
|
|
* but allows small bursts of previously unused bandwidth (max rate*2 for 1 second). |
|
|
|
*/ |
|
|
|
|
|
|
|
#include <lighttpd/base.h> |
|
|
|
#include <lighttpd/throttle.h> |
|
|
|
#include <math.h> |
|
|
|
|
|
|
|
static void li_throttle_pool_rearm(liWorker *wrk, liThrottlePool *pool); |
|
|
|
/* max amount of bytes we release in one query */ |
|
|
|
#define THROTTLE_MAX_STEP (64*1024) |
|
|
|
/* even if the magazine is empty release "overload" bytes to get requests started */ |
|
|
|
#define THROTTLE_OVERLOAD (8*1024) |
|
|
|
|
|
|
|
liThrottlePool *li_throttle_pool_new(liServer *srv, liThrottlePoolType type, gpointer param, guint rate) { |
|
|
|
liThrottlePool *pool; |
|
|
|
guint i; |
|
|
|
/* debug */ |
|
|
|
#if 0 |
|
|
|
#define STRINGIFY(x) #x |
|
|
|
#define _STRINGIFY(x) STRINGIFY(x) |
|
|
|
#define throttle_debug(...) fprintf(stderr, "throttle.c:" _STRINGIFY(__LINE__) ": " __VA_ARGS__) |
|
|
|
#else |
|
|
|
#define throttle_debug(...) do { } while (0) |
|
|
|
#endif |
|
|
|
|
|
|
|
g_mutex_lock(srv->action_mutex); |
|
|
|
/* rates all in bytes/sec */ |
|
|
|
|
|
|
|
if (type == LI_THROTTLE_POOL_NAME) { |
|
|
|
/* named pool */ |
|
|
|
GString *name = param; |
|
|
|
/* check if we already have a pool with that name */ |
|
|
|
for (i = 0; i < srv->throttle_pools->len; i++) { |
|
|
|
pool = g_array_index(srv->throttle_pools, liThrottlePool*, i); |
|
|
|
typedef struct liThrottlePoolState liThrottlePoolState; |
|
|
|
typedef struct liThrottlePoolWorkerState liThrottlePoolWorkerState; |
|
|
|
|
|
|
|
if (g_string_equal(pool->data.name, name)) { |
|
|
|
g_atomic_int_inc(&pool->refcount); |
|
|
|
g_mutex_unlock(srv->action_mutex); |
|
|
|
g_string_free(name, TRUE); |
|
|
|
return pool; |
|
|
|
} |
|
|
|
} |
|
|
|
} else { |
|
|
|
/* IP address pool */ |
|
|
|
liSocketAddress *remote_addr = param; |
|
|
|
|
|
|
|
if (remote_addr->addr->plain.sa_family == AF_INET) |
|
|
|
pool = li_radixtree_lookup_exact(srv->throttle_ip_pools, &remote_addr->addr->ipv4.sin_addr.s_addr, 32); |
|
|
|
else |
|
|
|
pool = li_radixtree_lookup_exact(srv->throttle_ip_pools, &remote_addr->addr->ipv6.sin6_addr.s6_addr, 128); |
|
|
|
|
|
|
|
if (pool) { |
|
|
|
g_mutex_unlock(srv->action_mutex); |
|
|
|
return pool; |
|
|
|
} |
|
|
|
} |
|
|
|
struct liThrottlePoolState { |
|
|
|
liThrottlePool *pool; |
|
|
|
GList pool_link; |
|
|
|
|
|
|
|
if (rate == 0) { |
|
|
|
g_mutex_unlock(srv->action_mutex); |
|
|
|
return NULL; |
|
|
|
} |
|
|
|
/* currently available for use */ |
|
|
|
gint magazine; |
|
|
|
}; |
|
|
|
|
|
|
|
pool = g_slice_new0(liThrottlePool); |
|
|
|
pool->type = type; |
|
|
|
pool->rate = rate; |
|
|
|
pool->last_rearm = THROTTLE_EVTSTAMP_TO_GINT(ev_time()); |
|
|
|
|
|
|
|
/*
|
|
|
|
* We if we are not in LI_SERVER_INIT state, we can initialize the queues directly. |
|
|
|
* Otherwise they'll get initialized in the worker prepare callback. |
|
|
|
*/ |
|
|
|
if (g_atomic_int_get(&srv->state) != LI_SERVER_INIT) { |
|
|
|
pool->worker_magazine = g_new0(gint, srv->worker_count); |
|
|
|
pool->worker_last_rearm = g_new0(gint, srv->worker_count); |
|
|
|
pool->worker_num_cons_queued = g_new0(gint, srv->worker_count); |
|
|
|
pool->worker_queues = g_new0(GQueue*, srv->worker_count); |
|
|
|
|
|
|
|
for (i = 0; i < srv->worker_count; i++) { |
|
|
|
pool->worker_queues[i] = g_queue_new(); |
|
|
|
pool->worker_last_rearm[i] = pool->last_rearm; |
|
|
|
} |
|
|
|
} |
|
|
|
struct liThrottleState { |
|
|
|
gint magazine; /* currently available for use */ |
|
|
|
|
|
|
|
if (type == LI_THROTTLE_POOL_NAME) { |
|
|
|
pool->refcount = 1; |
|
|
|
pool->data.name = param; |
|
|
|
g_array_append_val(srv->throttle_pools, pool); |
|
|
|
} else { |
|
|
|
liSocketAddress *remote_addr = param; |
|
|
|
pool->data.addr = li_sockaddr_dup(*remote_addr); |
|
|
|
|
|
|
|
if (remote_addr->addr->plain.sa_family == AF_INET) |
|
|
|
li_radixtree_insert(srv->throttle_ip_pools, &remote_addr->addr->ipv4.sin_addr.s_addr, 32, pool); |
|
|
|
else |
|
|
|
li_radixtree_insert(srv->throttle_ip_pools, &remote_addr->addr->ipv6.sin6_addr.s6_addr, 128, pool); |
|
|
|
} |
|
|
|
guint interested; |
|
|
|
liWaitQueueElem wqueue_elem; |
|
|
|
liThrottleNotifyCB notify_callback; |
|
|
|
|
|
|
|
g_mutex_unlock(srv->action_mutex); |
|
|
|
/* max values for this single state */ |
|
|
|
gint single_magazine; |
|
|
|
guint single_rate, single_burst; |
|
|
|
guint single_last_rearm; |
|
|
|
|
|
|
|
return pool; |
|
|
|
} |
|
|
|
/* shared pools */ |
|
|
|
GPtrArray *pools; /* <liThrottlePoolState> */ |
|
|
|
}; |
|
|
|
|
|
|
|
void li_throttle_pool_free(liServer *srv, liThrottlePool *pool) { |
|
|
|
guint i; |
|
|
|
struct liThrottlePoolWorkerState { |
|
|
|
gint magazine; |
|
|
|
guint last_rearm; |
|
|
|
guint connections; /* waiting.length; needed for atomic access */ |
|
|
|
GQueue waiting; /* <liThrottlePoolState.pool_link> waiting to get filled */ |
|
|
|
}; |
|
|
|
|
|
|
|
if (!g_atomic_int_dec_and_test(&pool->refcount)) |
|
|
|
return; |
|
|
|
struct liThrottlePool { |
|
|
|
int refcount; |
|
|
|
|
|
|
|
g_mutex_lock(srv->action_mutex); |
|
|
|
GMutex *rearm_mutex; |
|
|
|
guint rate, burst; |
|
|
|
guint last_rearm; |
|
|
|
|
|
|
|
if (pool->type == LI_THROTTLE_POOL_NAME) { |
|
|
|
for (i = 0; i < srv->throttle_pools->len; i++) { |
|
|
|
if (pool == g_array_index(srv->throttle_pools, liThrottlePool*, i)) { |
|
|
|
g_array_remove_index_fast(srv->throttle_pools, i); |
|
|
|
break; |
|
|
|
} |
|
|
|
} |
|
|
|
liThrottlePoolWorkerState *workers; |
|
|
|
}; |
|
|
|
|
|
|
|
g_string_free(pool->data.name, TRUE); |
|
|
|
} else { |
|
|
|
if (pool->data.addr.addr->plain.sa_family == AF_INET) |
|
|
|
li_radixtree_remove(srv->throttle_ip_pools, &pool->data.addr.addr->ipv4.sin_addr.s_addr, 32); |
|
|
|
else |
|
|
|
li_radixtree_remove(srv->throttle_ip_pools, &pool->data.addr.addr->ipv6.sin6_addr.s6_addr, 128); |
|
|
|
li_sockaddr_clear(&pool->data.addr); |
|
|
|
} |
|
|
|
g_mutex_unlock(srv->action_mutex); |
|
|
|
static guint msec_timestamp(li_tstamp now) { |
|
|
|
return (1000u * (guint64) floor(now)) + (guint64)(1000.0 * fmod(now, 1.0)); |
|
|
|
} |
|
|
|
|
|
|
|
if (pool->worker_queues) { |
|
|
|
for (i = 0; i < srv->worker_count; i++) { |
|
|
|
g_queue_free(pool->worker_queues[i]); |
|
|
|
} |
|
|
|
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; |
|
|
|
|
|
|
|
g_free(pool->worker_magazine); |
|
|
|
g_free(pool->worker_last_rearm); |
|
|
|
g_free(pool->worker_num_cons_queued); |
|
|
|
g_free(pool->worker_queues); |
|
|
|
for (i = 0; i < worker_count; ++i) { |
|
|
|
wrk_connections[i] = g_atomic_int_get((gint*) &pool->workers[i].connections); |
|
|
|
connections += wrk_connections[i]; |
|
|
|
} |
|
|
|
|
|
|
|
g_slice_free(liThrottlePool, pool); |
|
|
|
} |
|
|
|
if (0 == connections) return; |
|
|
|
|
|
|
|
void li_throttle_pool_acquire(liVRequest *vr, liThrottlePool *pool) { |
|
|
|
/* already in this pool */ |
|
|
|
if (vr->throttle.pool.ptr == pool || vr->throttle.ip.ptr == pool) |
|
|
|
return; |
|
|
|
time_diff = MIN(time_diff, 1000); |
|
|
|
|
|
|
|
g_atomic_int_inc(&pool->refcount); |
|
|
|
fill = MIN((guint64) pool->burst, ((guint64) pool->rate * time_diff) / 1000u); |
|
|
|
|
|
|
|
if (pool->type == LI_THROTTLE_POOL_NAME) { |
|
|
|
if (vr->throttle.pool.ptr != NULL) { |
|
|
|
/* already in a different pool */ |
|
|
|
li_throttle_pool_release(vr, vr->throttle.pool.ptr); |
|
|
|
} |
|
|
|
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); |
|
|
|
|
|
|
|
vr->throttle.pool.ptr = pool; |
|
|
|
} else { |
|
|
|
vr->throttle.ip.ptr = pool; |
|
|
|
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); |
|
|
|
} |
|
|
|
|
|
|
|
vr->throttled = TRUE; |
|
|
|
|
|
|
|
li_throttle_pool_rearm(vr->wrk, pool); |
|
|
|
li_throttle_update(vr, 0, 0); |
|
|
|
} |
|
|
|
|
|
|
|
void li_throttle_pool_release(liVRequest *vr, liThrottlePool *pool) { |
|
|
|
if (pool->type == LI_THROTTLE_POOL_NAME) { |
|
|
|
if (vr->throttle.pool.queue) { |
|
|
|
g_atomic_int_add(&pool->worker_num_cons_queued[vr->wrk->ndx], -1); |
|
|
|
g_queue_unlink(vr->throttle.pool.queue, &vr->throttle.pool.lnk); |
|
|
|
vr->throttle.pool.queue = NULL; |
|
|
|
} |
|
|
|
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; |
|
|
|
|
|
|
|
vr->throttle.pool.magazine = 0; |
|
|
|
vr->throttle.pool.ptr = NULL; |
|
|
|
} else { |
|
|
|
if (vr->throttle.ip.queue) { |
|
|
|
g_atomic_int_add(&pool->worker_num_cons_queued[vr->wrk->ndx], -1); |
|
|
|
g_queue_unlink(vr->throttle.ip.queue, &vr->throttle.ip.lnk); |
|
|
|
vr->throttle.ip.queue = NULL; |
|
|
|
} |
|
|
|
if (G_UNLIKELY(time_diff >= 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 >= 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); |
|
|
|
} |
|
|
|
|
|
|
|
vr->throttle.ip.magazine = 0; |
|
|
|
vr->throttle.ip.ptr = NULL; |
|
|
|
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; |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
li_throttle_pool_free(vr->wrk->srv, pool); |
|
|
|
static void throttle_register(liThrottlePoolWorkerState *pwstate, liThrottlePoolState *pstate) { |
|
|
|
if (NULL == pstate->pool_link.data) { |
|
|
|
g_queue_push_tail_link(&pwstate->waiting, &pstate->pool_link); |
|
|
|
pstate->pool_link.data = &pwstate->waiting; |
|
|
|
g_atomic_int_inc((gint*) &pwstate->connections); |
|
|
|
} |
|
|
|
} |
|
|
|
static void throttle_unregister(liThrottlePoolWorkerState *pwstate, liThrottlePoolState *pstate) { |
|
|
|
if (NULL != pstate->pool_link.data) { |
|
|
|
g_queue_unlink(&pwstate->waiting, &pstate->pool_link); |
|
|
|
pstate->pool_link.data = NULL; |
|
|
|
g_atomic_int_add((gint*) &pwstate->connections, -1); |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
static void li_throttle_pool_rearm(liWorker *wrk, liThrottlePool *pool) { |
|
|
|
gint time_diff, supply, num_cons, magazine; |
|
|
|
guint i; |
|
|
|
GQueue *queue; |
|
|
|
GList *lnk, *lnk_next; |
|
|
|
guint now = THROTTLE_EVTSTAMP_TO_GINT(li_cur_ts(wrk)); |
|
|
|
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; |
|
|
|
|
|
|
|
time_diff = now - pool->worker_last_rearm[wrk->ndx]; |
|
|
|
/* overflow after 31 days... */ |
|
|
|
if (G_UNLIKELY(time_diff < 0)) |
|
|
|
time_diff = 1000; |
|
|
|
if (NULL == state) return interested; |
|
|
|
|
|
|
|
if (G_LIKELY(time_diff < THROTTLE_GRANULARITY) && G_LIKELY(time_diff > 0)) |
|
|
|
return; |
|
|
|
state->notify_callback = NULL; |
|
|
|
state->wqueue_elem.data = NULL; |
|
|
|
|
|
|
|
/* milliseconds since last global rearm */ |
|
|
|
time_diff = now - g_atomic_int_get(&pool->last_rearm); |
|
|
|
if (G_UNLIKELY(time_diff < 0)) |
|
|
|
time_diff = 1000; |
|
|
|
throttle_debug("li_throttle_query[%u]: interested %i, magazine %i\n", now, interested, state->magazine); |
|
|
|
|
|
|
|
/* check if we have to rearm any magazines */ |
|
|
|
if (G_UNLIKELY(time_diff >= THROTTLE_GRANULARITY)) { |
|
|
|
/* spinlock while we rearm the magazines */ |
|
|
|
if (g_atomic_int_compare_and_exchange(&pool->rearming, 0, 1)) { |
|
|
|
gint worker_num_cons[wrk->srv->worker_count]; |
|
|
|
|
|
|
|
/* calculate total cons, take a safe "snapshot" */ |
|
|
|
num_cons = 0; |
|
|
|
for (i = 0; i < wrk->srv->worker_count; i++) { |
|
|
|
worker_num_cons[i] = g_atomic_int_get(&pool->worker_num_cons_queued[i]); |
|
|
|
num_cons += worker_num_cons[i]; |
|
|
|
} |
|
|
|
if (interested > THROTTLE_MAX_STEP) interested = THROTTLE_MAX_STEP; |
|
|
|
|
|
|
|
if (num_cons) { |
|
|
|
/* rearm the worker magazines */ |
|
|
|
supply = ((pool->rate / 1000) * MIN(time_diff, 1000)) / num_cons; |
|
|
|
for (i = 0; i < wrk->srv->worker_count; i++) { |
|
|
|
if (worker_num_cons[i] == 0) |
|
|
|
continue; |
|
|
|
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 >= THROTTLE_GRANULARITY) { |
|
|
|
guint single_fill = ((guint64) state->single_rate) * 1000u / (now - state->single_last_rearm); |
|
|
|
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); |
|
|
|
} |
|
|
|
|
|
|
|
g_atomic_int_add(&pool->worker_magazine[i], supply * worker_num_cons[i]); |
|
|
|
/* 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); |
|
|
|
|
|
|
|
g_atomic_int_set(&pool->last_rearm, now); |
|
|
|
g_atomic_int_set(&pool->rearming, 0); |
|
|
|
} else { |
|
|
|
/* wait for pool rearm to finish */ |
|
|
|
while (g_atomic_int_get(&pool->rearming) == 1) { } |
|
|
|
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; |
|
|
|
} |
|
|
|
|
|
|
|
/* select current queue */ |
|
|
|
queue = pool->worker_queues[wrk->ndx]; |
|
|
|
throttle_debug("query success: %i\n", state->magazine + THROTTLE_OVERLOAD); |
|
|
|
|
|
|
|
if (queue->length) { |
|
|
|
g_atomic_int_set(&pool->worker_num_cons_queued[wrk->ndx], 0); |
|
|
|
if ((gint) interested <= state->magazine + THROTTLE_OVERLOAD) return interested; |
|
|
|
return state->magazine + THROTTLE_OVERLOAD; |
|
|
|
} |
|
|
|
|
|
|
|
magazine = g_atomic_int_get(&pool->worker_magazine[wrk->ndx]); |
|
|
|
g_atomic_int_add(&pool->worker_magazine[wrk->ndx], -magazine); |
|
|
|
supply = magazine / queue->length; |
|
|
|
void li_throttle_update(liThrottleState *state, guint used) { |
|
|
|
state->magazine -= used; |
|
|
|
} |
|
|
|
|
|
|
|
/* rearm connections */ |
|
|
|
for (lnk = g_queue_peek_head_link(queue); lnk != NULL; lnk = lnk_next) { |
|
|
|
if (pool->type == LI_THROTTLE_POOL_NAME) { |
|
|
|
((liVRequest*)lnk->data)->throttle.pool.magazine += supply; |
|
|
|
((liVRequest*)lnk->data)->throttle.pool.queue = NULL; |
|
|
|
} else { |
|
|
|
((liVRequest*)lnk->data)->throttle.ip.magazine += supply; |
|
|
|
((liVRequest*)lnk->data)->throttle.ip.queue = NULL; |
|
|
|
} |
|
|
|
lnk_next = lnk->next; |
|
|
|
lnk->next = NULL; |
|
|
|
lnk->prev = NULL; |
|
|
|
} |
|
|
|
void li_throttle_pool_acquire(liThrottlePool *pool) { |
|
|
|
assert(g_atomic_int_get(&pool->refcount) > 0); |
|
|
|
g_atomic_int_inc(&pool->refcount); |
|
|
|
} |
|
|
|
|
|
|
|
/* clear current connection queue */ |
|
|
|
g_queue_init(queue); |
|
|
|
void li_throttle_pool_release(liThrottlePool *pool, liServer *srv) { |
|
|
|
assert(g_atomic_int_get(&pool->refcount) > 0); |
|
|
|
if (g_atomic_int_dec_and_test(&pool->refcount)) { |
|
|
|
g_mutex_free(pool->rearm_mutex); |
|
|
|
pool->rearm_mutex = NULL; |
|
|
|
if (NULL != pool->workers) { |
|
|
|
g_slice_free1(sizeof(liThrottlePoolWorkerState) * srv->worker_count, pool->workers); |
|
|
|
pool->workers = NULL; |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
pool->worker_last_rearm[wrk->ndx] = now; |
|
|
|
} |
|
|
|
|
|
|
|
void li_throttle_reset(liVRequest *vr) { |
|
|
|
if (!vr->throttled) |
|
|
|
return; |
|
|
|
gboolean li_throttle_add_pool(liWorker *wrk, liThrottleState *state, liThrottlePool *pool) { |
|
|
|
liThrottlePoolState *pstate; |
|
|
|
guint i, len; |
|
|
|
assert(NULL != wrk); |
|
|
|
assert(NULL != state); |
|
|
|
|
|
|
|
/* remove from throttle queue */ |
|
|
|
li_waitqueue_remove(&vr->wrk->throttle_queue, &vr->throttle.wqueue_elem); |
|
|
|
if (NULL == pool) return FALSE; |
|
|
|
for (i = 0, len = state->pools->len; i < len; ++i) { |
|
|
|
pstate = g_ptr_array_index(state->pools, i); |
|
|
|
if (pstate->pool == pool) return FALSE; |
|
|
|
} |
|
|
|
|
|
|
|
if (vr->throttle.pool.ptr) |
|
|
|
li_throttle_pool_release(vr, vr->throttle.pool.ptr); |
|
|
|
if (vr->throttle.ip.ptr) |
|
|
|
li_throttle_pool_release(vr, vr->throttle.ip.ptr); |
|
|
|
li_throttle_pool_acquire(pool); |
|
|
|
pstate = g_slice_new0(liThrottlePoolState); |
|
|
|
pstate->pool = pool; |
|
|
|
g_ptr_array_add(state->pools, pstate); |
|
|
|
|
|
|
|
vr->throttle.pool.magazine = 0; |
|
|
|
vr->throttle.ip.magazine = 0; |
|
|
|
vr->throttle.con.rate = 0; |
|
|
|
vr->throttle.magazine = 0; |
|
|
|
vr->throttled = FALSE; |
|
|
|
return TRUE; |
|
|
|
} |
|
|
|
|
|
|
|
void li_throttle_cb(liWaitQueue *wq, gpointer data) { |
|
|
|
liWaitQueueElem *wqe; |
|
|
|
liVRequest *vr; |
|
|
|
liWorker *wrk; |
|
|
|
gint supply; |
|
|
|
|
|
|
|
wrk = data; |
|
|
|
void li_throttle_remove_pool(liWorker *wrk, liThrottleState *state, liThrottlePool *pool) { |
|
|
|
guint i, len; |
|
|
|
assert(NULL != wrk); |
|
|
|
if (NULL == state || NULL == pool) return; |
|
|
|
|
|
|
|
for (i = 0, len = state->pools->len; i < len; ++i) { |
|
|
|
liThrottlePoolState *pstate = g_ptr_array_index(state->pools, i); |
|
|
|
if (pstate->pool == pool) { |
|
|
|
throttle_unregister(&pool->workers[wrk->ndx], pstate); |
|
|
|
g_ptr_array_remove_index_fast(state->pools, i); |
|
|
|
li_throttle_pool_release(pool, wrk->srv); |
|
|
|
g_slice_free(liThrottlePoolState, pstate); |
|
|
|
return; |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
while (NULL != (wqe = li_waitqueue_pop(wq))) { |
|
|
|
vr = wqe->data; |
|
|
|
liThrottleState* li_throttle_new() { |
|
|
|
liThrottleState *state = g_slice_new0(liThrottleState); |
|
|
|
state->pools = g_ptr_array_new(); |
|
|
|
return state; |
|
|
|
} |
|
|
|
|
|
|
|
if (vr->throttle.pool.ptr) { |
|
|
|
/* throttled by pool */ |
|
|
|
li_throttle_pool_rearm(wrk, vr->throttle.pool.ptr); |
|
|
|
void li_throttle_set(liWorker *wrk, liThrottleState *state, guint rate, guint burst) { |
|
|
|
UNUSED(wrk); |
|
|
|
state->single_rate = rate; |
|
|
|
state->single_burst = burst; |
|
|
|
state->single_magazine = burst; |
|
|
|
state->single_last_rearm = msec_timestamp(li_cur_ts(wrk)); |
|
|
|
} |
|
|
|
|
