markow
/
ckpool
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

Use the terse hash helpers in the stratifier

master
Con Kolivas 10 years ago
parent
9a1e59637f
commit
950a20e76f
1 changed files with 38 additions and 38 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 76
      src/stratifier.c

76
src/stratifier.c
Unescape View File

@ -1178,14 +1178,14 @@ static proxy_t *existing_subproxy(sdata_t *sdata, const int id, const int subid)
/* Set proxy to the current proxy and calculate how much headroom it has */ /* Set proxy to the current proxy and calculate how much headroom it has */
static int64_t current_headroom(sdata_t *sdata, proxy_t **proxy) static int64_t current_headroom(sdata_t *sdata, proxy_t **proxy)
{ {
proxy_t *subproxy, *tmp;
int64_t headroom = 0; int64_t headroom = 0;
proxy_t *subproxy;
mutex_lock(&sdata->proxy_lock); mutex_lock(&sdata->proxy_lock);
*proxy = sdata->proxy; *proxy = sdata->proxy;
if (!*proxy) if (!*proxy)
goto out_unlock; goto out_unlock;
HASH_ITER(sh, (*proxy)->subproxies, subproxy, tmp) { HASH_FOREACH(sh, (*proxy)->subproxies, subproxy) {
if (subproxy->dead) if (subproxy->dead)
continue; continue;
headroom += subproxy->max_clients - subproxy->clients; headroom += subproxy->max_clients - subproxy->clients;
@ -1212,8 +1212,8 @@ static void generator_recruit(const ckpool_t *ckp, const int recruits)
* switched lazily. */ * switched lazily. */
static void reconnect_clients(sdata_t *sdata) static void reconnect_clients(sdata_t *sdata)
{ {
stratum_instance_t *client, *tmpclient;
int reconnects = 0, hard = 0; int reconnects = 0, hard = 0;
stratum_instance_t *client;
int64_t headroom; int64_t headroom;
proxy_t *proxy; proxy_t *proxy;
@ -1222,7 +1222,7 @@ static void reconnect_clients(sdata_t *sdata)
return; return;
ck_rlock(&sdata->instance_lock); ck_rlock(&sdata->instance_lock);
HASH_ITER(hh, sdata->stratum_instances, client, tmpclient) { HASH_ITERATE(sdata->stratum_instances, client) {
if (client->proxyid == proxy->id) if (client->proxyid == proxy->id)
continue; continue;
if (headroom-- < 1) if (headroom-- < 1)
@ -1248,10 +1248,10 @@ static void reconnect_clients(sdata_t *sdata)
static bool __subproxies_alive(proxy_t *proxy) static bool __subproxies_alive(proxy_t *proxy)
{ {
proxy_t *subproxy, *tmp;
bool alive = false; bool alive = false;
proxy_t *subproxy;
HASH_ITER(sh, proxy->subproxies, subproxy, tmp) { HASH_FOREACH(sh, proxy->subproxies, subproxy) {
if (!subproxy->dead) { if (!subproxy->dead) {
alive = true; alive = true;
break; break;
@ -1264,13 +1264,13 @@ static bool __subproxies_alive(proxy_t *proxy)
* the highest priority alive one. Uses ckp sdata */ * the highest priority alive one. Uses ckp sdata */
static void check_bestproxy(sdata_t *sdata) static void check_bestproxy(sdata_t *sdata)
{ {
proxy_t *proxy, *tmp;
int changed_id = -1; int changed_id = -1;
proxy_t *proxy;
mutex_lock(&sdata->proxy_lock); mutex_lock(&sdata->proxy_lock);
if (sdata->proxy && !__subproxies_alive(sdata->proxy)) if (sdata->proxy && !__subproxies_alive(sdata->proxy))
sdata->proxy = NULL; sdata->proxy = NULL;
HASH_ITER(hh, sdata->proxies, proxy, tmp) { HASH_ITERATE(sdata->proxies, proxy) {
if (!__subproxies_alive(proxy)) if (!__subproxies_alive(proxy))
continue; continue;
if (!sdata->proxy || sdata->proxy->id > proxy->id) { if (!sdata->proxy || sdata->proxy->id > proxy->id) {
@ -1288,8 +1288,8 @@ static void check_bestproxy(sdata_t *sdata)
static void dead_proxyid(sdata_t *sdata, const int id, const int subid) static void dead_proxyid(sdata_t *sdata, const int id, const int subid)
{ {
stratum_instance_t *client, *tmp;
int reconnects = 0, hard = 0; int reconnects = 0, hard = 0;
stratum_instance_t *client;
int64_t headroom; int64_t headroom;
proxy_t *proxy; proxy_t *proxy;
@ -1301,7 +1301,7 @@ static void dead_proxyid(sdata_t *sdata, const int id, const int subid)
headroom = current_headroom(sdata, &proxy); headroom = current_headroom(sdata, &proxy);
ck_rlock(&sdata->instance_lock); ck_rlock(&sdata->instance_lock);
HASH_ITER(hh, sdata->stratum_instances, client, tmp) { HASH_ITERATE(sdata->stratum_instances, client) {
if (client->proxyid != id || client->subproxyid != subid) if (client->proxyid != id || client->subproxyid != subid)
continue; continue;
reconnects++; reconnects++;
@ -1514,7 +1514,7 @@ static void stratum_send_diff(sdata_t *sdata, const stratum_instance_t *client);
static void update_diff(ckpool_t *ckp, const char *cmd) static void update_diff(ckpool_t *ckp, const char *cmd)
{ {
sdata_t *sdata = ckp->data, *dsdata; sdata_t *sdata = ckp->data, *dsdata;
stratum_instance_t *client, *tmp; stratum_instance_t *client;
double old_diff, diff; double old_diff, diff;
int id = 0, subid = 0; int id = 0, subid = 0;
const char *buf; const char *buf;
@ -1568,7 +1568,7 @@ static void update_diff(ckpool_t *ckp, const char *cmd)
/* If the diff has dropped, iterate over all the clients and check /* If the diff has dropped, iterate over all the clients and check
* they're at or below the new diff, and update it if not. */ * they're at or below the new diff, and update it if not. */
ck_rlock(&sdata->instance_lock); ck_rlock(&sdata->instance_lock);
HASH_ITER(hh, sdata->stratum_instances, client, tmp) { HASH_ITERATE(sdata->stratum_instances, client) {
if (client->proxyid != id) if (client->proxyid != id)
continue; continue;
if (client->subproxyid != subid) if (client->subproxyid != subid)
@ -1602,14 +1602,14 @@ static void free_proxy(proxy_t *proxy)
* those. */ * those. */
static void reap_proxies(ckpool_t *ckp, sdata_t *sdata) static void reap_proxies(ckpool_t *ckp, sdata_t *sdata)
{ {
proxy_t *proxy, *proxytmp, *subproxy, *subtmp; proxy_t *proxy, *subproxy, *subtmp;
int dead = 0; int dead = 0;
if (!ckp->proxy) if (!ckp->proxy)
return; return;
mutex_lock(&sdata->proxy_lock); mutex_lock(&sdata->proxy_lock);
HASH_ITER(hh, sdata->proxies, proxy, proxytmp) { HASH_ITERATE(sdata->proxies, proxy) {
HASH_ITER(sh, proxy->subproxies, subproxy, subtmp) { HASH_ITER(sh, proxy->subproxies, subproxy, subtmp) {
if (!subproxy->bound_clients && !subproxy->dead) { if (!subproxy->bound_clients && !subproxy->dead) {
/* Reset the counter to reuse this proxy */ /* Reset the counter to reuse this proxy */
@ -1682,10 +1682,10 @@ static stratum_instance_t *ref_instance_by_id(sdata_t *sdata, const int64_t id)
/* Has this client_id already been used and is now in one of the dropped lists */ /* Has this client_id already been used and is now in one of the dropped lists */
static bool __dropped_instance(sdata_t *sdata, const int64_t id) static bool __dropped_instance(sdata_t *sdata, const int64_t id)
{ {
stratum_instance_t *client, *tmp; stratum_instance_t *client;
bool ret = false; bool ret = false;
HASH_ITER(hh, sdata->disconnected_instances, client, tmp) { HASH_ITERATE(sdata->disconnected_instances, client) {
if (unlikely(client->id == id)) { if (unlikely(client->id == id)) {
ret = true; ret = true;
goto out; goto out;
@ -1802,8 +1802,8 @@ static stratum_instance_t *__stratum_add_instance(ckpool_t *ckp, const int64_t i
static uint64_t disconnected_sessionid_exists(sdata_t *sdata, const char *sessionid, const int64_t id) static uint64_t disconnected_sessionid_exists(sdata_t *sdata, const char *sessionid, const int64_t id)
{ {
stratum_instance_t *client, *tmp;
uint64_t enonce1_64 = 0, ret = 0; uint64_t enonce1_64 = 0, ret = 0;
stratum_instance_t *client;
int64_t old_id = 0; int64_t old_id = 0;
int slen; int slen;
@ -1820,7 +1820,7 @@ static uint64_t disconnected_sessionid_exists(sdata_t *sdata, const char *sessio
hex2bin(&enonce1_64, sessionid, slen); hex2bin(&enonce1_64, sessionid, slen);
ck_wlock(&sdata->instance_lock); ck_wlock(&sdata->instance_lock);
HASH_ITER(hh, sdata->stratum_instances, client, tmp) { HASH_ITERATE(sdata->stratum_instances, client) {
if (client->id == id) if (client->id == id)
continue; continue;
if (client->enonce1_64 == enonce1_64) { if (client->enonce1_64 == enonce1_64) {
@ -1869,7 +1869,7 @@ static void stratum_broadcast(sdata_t *sdata, json_t *val)
{ {
ckpool_t *ckp = sdata->ckp; ckpool_t *ckp = sdata->ckp;
sdata_t *ckp_sdata = ckp->data; sdata_t *ckp_sdata = ckp->data;
stratum_instance_t *client, *tmp; stratum_instance_t *client;
ckmsg_t *bulk_send = NULL; ckmsg_t *bulk_send = NULL;
time_t now_t = time(NULL); time_t now_t = time(NULL);
int hard_reconnect = 0; int hard_reconnect = 0;
@ -1882,7 +1882,7 @@ static void stratum_broadcast(sdata_t *sdata, json_t *val)
/* Use this locking as an opportunity to test other clients. */ /* Use this locking as an opportunity to test other clients. */
ck_rlock(&ckp_sdata->instance_lock); ck_rlock(&ckp_sdata->instance_lock);
HASH_ITER(hh, ckp_sdata->stratum_instances, client, tmp) { HASH_ITERATE(ckp_sdata->stratum_instances, client) {
ckmsg_t *client_msg; ckmsg_t *client_msg;
smsg_t *msg; smsg_t *msg;
@ -2003,7 +2003,7 @@ static void stratum_broadcast_message(sdata_t *sdata, const char *msg)
static void request_reconnect(sdata_t *sdata, const char *cmd) static void request_reconnect(sdata_t *sdata, const char *cmd)
{ {
char *port = strdupa(cmd), *url = NULL; char *port = strdupa(cmd), *url = NULL;
stratum_instance_t *client, *tmp; stratum_instance_t *client;
json_t *json_msg; json_t *json_msg;
strsep(&port, ":"); strsep(&port, ":");
@ -2023,7 +2023,7 @@ static void request_reconnect(sdata_t *sdata, const char *cmd)
/* Tag all existing clients as dropped now so they can be removed /* Tag all existing clients as dropped now so they can be removed
* lazily */ * lazily */
ck_wlock(&sdata->instance_lock); ck_wlock(&sdata->instance_lock);
HASH_ITER(hh, sdata->stratum_instances, client, tmp) { HASH_ITERATE(sdata->stratum_instances, client) {
client->dropped = true; client->dropped = true;
} }
ck_wunlock(&sdata->instance_lock); ck_wunlock(&sdata->instance_lock);
@ -2031,14 +2031,14 @@ static void request_reconnect(sdata_t *sdata, const char *cmd)
static void reset_bestshares(sdata_t *sdata) static void reset_bestshares(sdata_t *sdata)
{ {
user_instance_t *user, *tmpuser; stratum_instance_t *client;
stratum_instance_t *client, *tmp; user_instance_t *user;
ck_rlock(&sdata->instance_lock); ck_rlock(&sdata->instance_lock);
HASH_ITER(hh, sdata->stratum_instances, client, tmp) { HASH_ITERATE(sdata->stratum_instances, client) {
client->best_diff = 0; client->best_diff = 0;
} }
HASH_ITER(hh, sdata->user_instances, user, tmpuser) { HASH_ITERATE(sdata->user_instances, user) {
worker_instance_t *worker; worker_instance_t *worker;
user->best_diff = 0; user->best_diff = 0;
@ -2561,7 +2561,7 @@ static void stratum_send_message(sdata_t *sdata, const stratum_instance_t *clien
* running out of room. */ * running out of room. */
static sdata_t *select_sdata(const ckpool_t *ckp, sdata_t *ckp_sdata) static sdata_t *select_sdata(const ckpool_t *ckp, sdata_t *ckp_sdata)
{ {
proxy_t *current, *proxy, *subproxy, *best = NULL, *tmp, *tmpsub; proxy_t *current, *proxy, *subproxy, *best = NULL;
int best_subid = 0, best_id; int best_subid = 0, best_id;
if (!ckp->proxy || ckp->passthrough) if (!ckp->proxy || ckp->passthrough)
@ -2574,12 +2574,12 @@ static sdata_t *select_sdata(const ckpool_t *ckp, sdata_t *ckp_sdata)
best_id = maxint; best_id = maxint;
mutex_lock(&ckp_sdata->proxy_lock); mutex_lock(&ckp_sdata->proxy_lock);
HASH_ITER(hh, ckp_sdata->proxies, proxy, tmp) { HASH_ITERATE(ckp_sdata->proxies, proxy) {
int64_t max_headroom; int64_t max_headroom;
best = NULL; best = NULL;
proxy->headroom = max_headroom = 0; proxy->headroom = max_headroom = 0;
HASH_ITER(sh, proxy->subproxies, subproxy, tmpsub) { HASH_FOREACH(sh, proxy->subproxies, subproxy) {
int64_t subproxy_headroom; int64_t subproxy_headroom;
if (subproxy->dead) if (subproxy->dead)
@ -4610,7 +4610,7 @@ out:
static void update_workerstats(ckpool_t *ckp, sdata_t *sdata) static void update_workerstats(ckpool_t *ckp, sdata_t *sdata)
{ {
json_entry_t *json_list = NULL, *entry, *tmpentry; json_entry_t *json_list = NULL, *entry, *tmpentry;
user_instance_t *user, *tmp; user_instance_t *user;
char cdfield[64]; char cdfield[64];
time_t now_t; time_t now_t;
ts_t ts_now; ts_t ts_now;
@ -4628,7 +4628,7 @@ static void update_workerstats(ckpool_t *ckp, sdata_t *sdata)
now_t = ts_now.tv_sec; now_t = ts_now.tv_sec;
ck_rlock(&sdata->instance_lock); ck_rlock(&sdata->instance_lock);
HASH_ITER(hh, sdata->user_instances, user, tmp) { HASH_ITERATE(sdata->user_instances, user) {
worker_instance_t *worker; worker_instance_t *worker;
uint8_t cycle_mask; uint8_t cycle_mask;
@ -4732,10 +4732,10 @@ static void *statsupdate(void *arg)
double ghs, ghs1, ghs5, ghs15, ghs60, ghs360, ghs1440, ghs10080, per_tdiff; double ghs, ghs1, ghs5, ghs15, ghs60, ghs360, ghs1440, ghs10080, per_tdiff;
char suffix1[16], suffix5[16], suffix15[16], suffix60[16], cdfield[64]; char suffix1[16], suffix5[16], suffix15[16], suffix60[16], cdfield[64];
char suffix360[16], suffix1440[16], suffix10080[16]; char suffix360[16], suffix1440[16], suffix10080[16];
stratum_instance_t *client, *tmp;
log_entry_t *log_entries = NULL; log_entry_t *log_entries = NULL;
user_instance_t *user, *tmpuser;
char_entry_t *char_list = NULL; char_entry_t *char_list = NULL;
stratum_instance_t *client;
user_instance_t *user;
int idle_workers = 0; int idle_workers = 0;
char *fname, *s, *sp; char *fname, *s, *sp;
tv_t now, diff; tv_t now, diff;
@ -4748,7 +4748,7 @@ static void *statsupdate(void *arg)
timersub(&now, &stats->start_time, &diff); timersub(&now, &stats->start_time, &diff);
ck_rlock(&sdata->instance_lock); ck_rlock(&sdata->instance_lock);
HASH_ITER(hh, sdata->stratum_instances, client, tmp) { HASH_ITERATE(sdata->stratum_instances, client) {
if (!client_active(client)) if (!client_active(client))
continue; continue;
@ -4768,7 +4768,7 @@ static void *statsupdate(void *arg)
} }
} }
HASH_ITER(hh, sdata->user_instances, user, tmpuser) { HASH_ITERATE(sdata->user_instances, user) {
worker_instance_t *worker; worker_instance_t *worker;
bool idle = false; bool idle = false;
@ -4934,7 +4934,7 @@ static void *statsupdate(void *arg)
fclose(fp); fclose(fp);
if (ckp->proxy && sdata->proxy) { if (ckp->proxy && sdata->proxy) {
proxy_t *proxy, *proxytmp, *subproxy, *subtmp; proxy_t *proxy, *subproxy;
mutex_lock(&sdata->proxy_lock); mutex_lock(&sdata->proxy_lock);
JSON_CPACK(val, "{sI,si,si}", JSON_CPACK(val, "{sI,si,si}",
@ -4949,7 +4949,7 @@ static void *statsupdate(void *arg)
dealloc(s); dealloc(s);
mutex_lock(&sdata->proxy_lock); mutex_lock(&sdata->proxy_lock);
HASH_ITER(hh, sdata->proxies, proxy, proxytmp) { HASH_ITERATE(sdata->proxies, proxy) {
JSON_CPACK(val, "{sI,si,sI,sb}", JSON_CPACK(val, "{sI,si,sI,sb}",
"id", proxy->id, "id", proxy->id,
"subproxies", proxy->subproxy_count, "subproxies", proxy->subproxy_count,
@ -4960,7 +4960,7 @@ static void *statsupdate(void *arg)
ASPRINTF(&sp, "Proxies:%s", s); ASPRINTF(&sp, "Proxies:%s", s);
dealloc(s); dealloc(s);
add_msg_entry(&char_list, &sp); add_msg_entry(&char_list, &sp);
HASH_ITER(sh, proxy->subproxies, subproxy, subtmp) { HASH_FOREACH(sh, proxy->subproxies, subproxy) {
JSON_CPACK(val, "{sI,si,si,sI,sI,sf,sb}", JSON_CPACK(val, "{sI,si,si,sI,sI,sf,sb}",
"id", subproxy->id, "id", subproxy->id,
"subid", subproxy->subid, "subid", subproxy->subid,

Write Preview
Loading…
Cancel
Save