int init_workers(int desired_workers) { specialized_workers = dkhash_create(512); if (!specialized_workers) { logit(NSLOG_RUNTIME_ERROR, TRUE, "wproc: Failed to allocate specialized worker table.\n"); return -1; } /* Register our query handler before launching workers, so other workers * can join us whenever they're ready. */ if (!qh_register_handler("wproc", "Worker process management and info", 0, wproc_query_handler)) logit(NSLOG_INFO_MESSAGE, TRUE, "wproc: Successfully registered manager as @wproc with query handler\n"); else logit(NSLOG_RUNTIME_ERROR, TRUE, "wproc: Failed to register manager with query handler\n"); if (desired_workers <= 0) { int cpus = online_cpus(); /* Always at least 1 CPU. */ if (desired_workers < 0) { /* @note This is an undocumented case of questionable utility, and * should be removed. Users reading this note have been warned. */ desired_workers = cpus - desired_workers; /* desired_workers is now > 0. */ } else { desired_workers = cpus * 1.5; if (desired_workers < 4) { /* Use at least 4 workers when autocalculating so we have some * level of parallelism. */ desired_workers = 4; } else if (desired_workers > 48) { /* Limit the autocalculated workers so we don't spawn too many * on systems with many schedulable cores (>32). */ desired_workers = 48; } } } wproc_num_workers_desired = desired_workers; if (workers_alive() == desired_workers) return 0; /* can't shrink the number of workers (yet) */ if (desired_workers < (int)workers.len) return -1; while (desired_workers-- > 0) spawn_core_worker(); return 0; }
int init_workers(int desired_workers) { int i; /* * we register our query handler before launching workers, * so other workers can join us whenever they're ready */ specialized_workers = dkhash_create(512); if(!qh_register_handler("wproc", "Worker process management and info", 0, wproc_query_handler)) logit(NSLOG_INFO_MESSAGE, TRUE, "wproc: Successfully registered manager as @wproc with query handler\n"); else logit(NSLOG_RUNTIME_ERROR, TRUE, "wproc: Failed to register manager with query handler\n"); i = desired_workers; if (desired_workers <= 0) { int cpus = online_cpus(); if(desired_workers < 0) { desired_workers = cpus - desired_workers; } if(desired_workers <= 0) { desired_workers = cpus * 1.5; /* min 4 workers, as it's tested and known to work */ if(desired_workers < 4) desired_workers = 4; } } wproc_num_workers_desired = desired_workers; if (workers_alive() == desired_workers) return 0; /* can't shrink the number of workers (yet) */ if (desired_workers < (int)workers.len) return -1; for (i = 0; i < desired_workers; i++) spawn_core_worker(); return 0; }
int main(int argc, char **argv) { dkhash_table *tx, *t; unsigned int x; int ret, r2; struct test_data s; char *p1, *p2; char *strs[10]; char tmp[32]; t_set_colors(0); t_start("dkhash basic test"); t = dkhash_create(512); p1 = strdup("a not-so secret value"); dkhash_insert(t, "nisse", NULL, p1); ok_int(dkhash_num_entries_max(t), 1, "Added one entry, so that's max"); ok_int(dkhash_num_entries_added(t), 1, "Added one entry, so one added"); ok_int(dkhash_table_size(t), 512, "Table must be sized properly"); ok_int(dkhash_collisions(t), 0, "One entry, so zero collisions"); p2 = dkhash_get(t, "nisse", NULL); test(p1 == p2, "get should get what insert set"); dkhash_insert(t, "kalle", "bananas", p1); p2 = dkhash_get(t, "kalle", "bezinga"); test(p1 != p2, "we should never get the wrong key"); ok_int(2, dkhash_num_entries(t), "should be 2 entries after 2 inserts"); p2 = dkhash_remove(t, "kalle", "bezinga"); ok_int(2, dkhash_num_entries(t), "should be 2 entries after 2 inserts and 1 failed remove"); ok_int(0, dkhash_num_entries_removed(t), "should be 0 removed entries after failed remove"); p2 = dkhash_remove(t, "kalle", "bananas"); test(p1 == p2, "dkhash_remove() should return removed data"); ok_int(dkhash_num_entries(t), 1, "should be 1 entries after 2 inserts and 1 successful remove"); p2 = dkhash_remove(t, "nisse", NULL); test(p1 == p2, "dkhash_remove() should return removed data"); ret = t_end(); t_reset(); /* lots of tests below, so we shut up while they're running */ t_verbose = 0; t_start("dkhash_walk_data() test"); memset(&s, 0, sizeof(s)); /* first we set up the dkhash-tables */ tx = dkhash_create(16); for (x = 0; x < ARRAY_SIZE(keys); x++) { dkhash_insert(tx, keys[x].k1, NULL, ddup(x, 0, 0)); dkhash_insert(tx, keys[x].k2, NULL, ddup(x, 0, 0)); dkhash_insert(tx, keys[x].k1, keys[x].k2, ddup(x, 0, 0)); s.x += 3; ok_int(s.x, dkhash_num_entries(tx), "x table adding"); } ok_int(s.x, dkhash_num_entries(tx), "x table done adding"); for (x = 0; x < ARRAY_SIZE(keys); x++) { del.x = x; del.i = del.j = 0; ok_int(s.x, dkhash_num_entries(tx), "x table pre-delete"); s.x -= 3; dkhash_walk_data(tx, del_matching); ok_int(s.x, dkhash_num_entries(tx), "x table post-delete"); } test(0 == dkhash_num_entries(tx), "x table post all ops"); test(0 == dkhash_check_table(tx), "x table consistency post all ops"); dkhash_debug_table(tx, 0); r2 = t_end(); ret = r2 ? r2 : ret; t_reset(); for (x = 0; x < 10; x++) { sprintf(tmp, "string %d", x); strs[x] = strdup(tmp); } t_start("dkhash single bucket add remove forward"); t = dkhash_create(1); for (x = 0; x < 10; x++) { dkhash_insert(t, strs[x], NULL, strs[x]); } for (x = 0; x < 10; x++) { p1 = strs[x]; p2 = dkhash_remove(t, p1, NULL); test(p1 == p2, "remove should return a value"); } r2 = t_end(); ret = r2 ? r2 : ret; t_reset(); t_start("dkhash single bucket add remove backward"); t = dkhash_create(1); for (x = 0; x < 10; x++) { dkhash_insert(t, strs[x], NULL, strs[x]); } for (x = 9; x; x--) { p1 = strs[x]; p2 = dkhash_remove(t, p1, NULL); test(p1 == p2, "remove should return a value"); } dkhash_destroy(t); r2 = t_end(); return r2 ? r2 : ret; }