int direct_live_id(struct task *task,
struct sanlk_lockspace *ls,
uint64_t *timestamp,
uint64_t *owner_id,
uint64_t *owner_generation,
int *live)
{
struct leader_record leader_begin;
struct leader_record leader;
time_t start;
int rv;
rv = do_delta_action(ACT_READ_ID, task, ls, -1, NULL, &leader_begin);
if (rv < 0)
return rv;
start = monotime();
while (1) {
sleep(1);
rv = do_delta_action(ACT_READ_ID, task, ls, -1, NULL, &leader);
if (rv < 0)
return rv;
if (leader.timestamp != leader_begin.timestamp) {
*live = 1;
break;
}
if (leader.owner_id != leader_begin.owner_id) {
*live = 2;
break;
}
if (leader.owner_generation != leader_begin.owner_generation) {
*live = 3;
break;
}
if (monotime() - start > task->host_dead_seconds) {
*live = 0;
break;
}
}
*timestamp = leader.timestamp;
*owner_id = leader.owner_id;
*owner_generation = leader.owner_generation;
return 0;
}
void send_ping (struct ping_ctx *ctx)
{
struct timespec t0;
json_object *in = Jnew ();
flux_rpc_t *rpc;
struct ping_data *pdata = xzmalloc (sizeof (*pdata));
pdata->tstat = xzmalloc (sizeof (*(pdata->tstat)));
pdata->seq = 0;
pdata->route = NULL;
pdata->rpc_count = 0;
Jadd_int (in, "seq", ctx->send_count);
monotime (&t0);
Jadd_int64 (in, "time.tv_sec", t0.tv_sec);
Jadd_int64 (in, "time.tv_nsec", t0.tv_nsec);
Jadd_str (in, "pad", ctx->pad);
if (ctx->rank)
rpc = flux_rpc_multi (ctx->h, ctx->topic, Jtostr (in), ctx->rank, 0);
else
rpc = flux_rpc (ctx->h, ctx->topic, Jtostr (in), ctx->nodeid, 0);
if (!rpc)
log_err_exit ("flux_rpc");
flux_rpc_aux_set (rpc, pdata, ping_data_free);
if (flux_rpc_then (rpc, ping_continuation, ctx) < 0)
log_err_exit ("flux_rpc_then");
Jput (in);
ctx->send_count++;
}
int hello_start (hello_t *hello)
{
int rc = -1;
uint32_t rank;
if (flux_get_rank (hello->h, &rank) < 0)
goto done;
if (rank == 0) {
monotime (&hello->start);
if (!(hello->timer = flux_timer_watcher_create (hello->reactor,
hello->timeout,
hello->timeout,
timer_cb, hello)))
goto done;
flux_watcher_start (hello->timer);
if (hello_add_rank (hello, 0) < 0)
goto done;
} else {
if (hello_sendmsg (hello, rank) < 0)
goto done;
}
rc = 0;
done:
return rc;
}
static int route_notify_owner(ZAPI_CALLBACK_ARGS)
{
struct timeval r;
struct prefix p;
enum zapi_route_notify_owner note;
uint32_t table;
if (!zapi_route_notify_decode(zclient->ibuf, &p, &table, ¬e))
return -1;
switch (note) {
case ZAPI_ROUTE_INSTALLED:
sg.r.installed_routes++;
if (sg.r.total_routes == sg.r.installed_routes) {
monotime(&sg.r.t_end);
timersub(&sg.r.t_end, &sg.r.t_start, &r);
zlog_debug("Installed All Items %ld.%ld", r.tv_sec,
r.tv_usec);
handle_repeated(true);
}
break;
case ZAPI_ROUTE_FAIL_INSTALL:
zlog_debug("Failed install of route");
break;
case ZAPI_ROUTE_BETTER_ADMIN_WON:
zlog_debug("Better Admin Distance won over us");
break;
case ZAPI_ROUTE_REMOVED:
sg.r.removed_routes++;
if (sg.r.total_routes == sg.r.removed_routes) {
monotime(&sg.r.t_end);
timersub(&sg.r.t_end, &sg.r.t_start, &r);
zlog_debug("Removed all Items %ld.%ld", r.tv_sec,
r.tv_usec);
handle_repeated(false);
}
break;
case ZAPI_ROUTE_REMOVE_FAIL:
zlog_debug("Route removal Failure");
break;
}
return 0;
}
void *thread (void *arg)
{
thd_t *t = arg;
char *key, *fence_name = NULL;
int i, flags = 0;
struct timespec t0;
uint32_t rank;
flux_future_t *f;
flux_kvs_txn_t *txn;
if (!(t->h = flux_open (NULL, 0))) {
log_err ("%d: flux_open", t->n);
goto done;
}
if (flux_get_rank (t->h, &rank) < 0) {
log_err ("%d: flux_get_rank", t->n);
goto done;
}
for (i = 0; i < count; i++) {
if (!(txn = flux_kvs_txn_create ()))
log_err_exit ("flux_kvs_txn_create");
key = xasprintf ("%s.%"PRIu32".%d.%d", prefix, rank, t->n, i);
if (fopt)
fence_name = xasprintf ("%s-%d", prefix, i);
if (sopt)
monotime (&t0);
if (flux_kvs_txn_pack (txn, 0, key, "i", 42) < 0)
log_err_exit ("%s", key);
if (nopt && (i % nopt_divisor) == 0)
flags |= FLUX_KVS_NO_MERGE;
else
flags = 0;
if (fopt) {
if (!(f = flux_kvs_fence (t->h, flags, fence_name,
fence_nprocs, txn))
|| flux_future_get (f, NULL) < 0)
log_err_exit ("flux_kvs_fence");
flux_future_destroy (f);
} else {
if (!(f = flux_kvs_commit (t->h, flags, txn))
|| flux_future_get (f, NULL) < 0)
log_err_exit ("flux_kvs_commit");
flux_future_destroy (f);
}
if (sopt && zlist_append (t->perf, ddup (monotime_since (t0))) < 0)
oom ();
free (key);
free (fence_name);
flux_kvs_txn_destroy (txn);
}
done:
if (t->h)
flux_close (t->h);
return NULL;
}
static struct ospf6 *ospf6_create(void)
{
struct ospf6 *o;
o = XCALLOC(MTYPE_OSPF6_TOP, sizeof(struct ospf6));
/* initialize */
monotime(&o->starttime);
o->area_list = list_new();
o->area_list->cmp = ospf6_area_cmp;
o->lsdb = ospf6_lsdb_create(o);
o->lsdb_self = ospf6_lsdb_create(o);
o->lsdb->hook_add = ospf6_top_lsdb_hook_add;
o->lsdb->hook_remove = ospf6_top_lsdb_hook_remove;
o->spf_delay = OSPF_SPF_DELAY_DEFAULT;
o->spf_holdtime = OSPF_SPF_HOLDTIME_DEFAULT;
o->spf_max_holdtime = OSPF_SPF_MAX_HOLDTIME_DEFAULT;
o->spf_hold_multiplier = 1;
/* LSA timers value init */
o->lsa_minarrival = OSPF_MIN_LS_ARRIVAL;
o->route_table = OSPF6_ROUTE_TABLE_CREATE(GLOBAL, ROUTES);
o->route_table->scope = o;
o->route_table->hook_add = ospf6_top_route_hook_add;
o->route_table->hook_remove = ospf6_top_route_hook_remove;
o->brouter_table = OSPF6_ROUTE_TABLE_CREATE(GLOBAL, BORDER_ROUTERS);
o->brouter_table->scope = o;
o->brouter_table->hook_add = ospf6_top_brouter_hook_add;
o->brouter_table->hook_remove = ospf6_top_brouter_hook_remove;
o->external_table = OSPF6_ROUTE_TABLE_CREATE(GLOBAL, EXTERNAL_ROUTES);
o->external_table->scope = o;
o->external_id_table = route_table_init();
o->ref_bandwidth = OSPF6_REFERENCE_BANDWIDTH;
o->distance_table = route_table_init();
/* Enable "log-adjacency-changes" */
#if DFLT_OSPF6_LOG_ADJACENCY_CHANGES
SET_FLAG(o->config_flags, OSPF6_LOG_ADJACENCY_CHANGES);
#endif
QOBJ_REG(o, ospf6);
return o;
}
static int runlevel_start_subprocess (runlevel_t *r, int level)
{
flux_subprocess_t *p = NULL;
assert (r->h != NULL);
if (r->rc[level].cmd) {
flux_subprocess_ops_t ops = {
.on_completion = completion_cb,
.on_state_change = NULL,
.on_channel_out = NULL,
.on_stdout = NULL,
.on_stderr = NULL,
};
flux_reactor_t *reactor = flux_get_reactor (r->h);
int flags = 0;
/* set alternate io callback for levels 1 and 3 */
if (level == 1 || level == 3) {
ops.on_stdout = io_cb;
ops.on_stderr = io_cb;
}
else
flags |= FLUX_SUBPROCESS_FLAGS_STDIO_FALLTHROUGH;
if (!(p = flux_exec (r->h,
flags,
r->rc[level].cmd,
&ops)))
goto error;
if (flux_subprocess_aux_set (p, "runlevel", r, NULL) < 0)
goto error;
monotime (&r->rc[level].start);
if (r->rc[level].timeout > 0.) {
flux_watcher_t *w;
if (!(w = flux_timer_watcher_create (reactor,
r->rc[level].timeout, 0.,
runlevel_timeout, r)))
goto error;
flux_watcher_start (w);
r->rc[level].timer = w;
flux_log (r->h, LOG_INFO, "runlevel %d (%.1fs) timer started",
level, r->rc[level].timeout);
}
r->rc[level].p = p;
} else {
wait_t *wait_create (flux_t h, flux_msg_handler_t *wh, const flux_msg_t *msg,
flux_msg_handler_f cb, void *arg)
{
wait_t *w = xzmalloc (sizeof (*w));
w->magic = WAIT_MAGIC;
w->hand.cb = cb;
w->hand.arg = arg;
w->hand.h = h;
w->hand.w = wh;
if (!(w->hand.msg = flux_msg_copy (msg, true))) {
wait_destroy (w, NULL);
errno = ENOMEM;
return NULL;
}
monotime (&w->t0);
return w;
}
void
start_progress_meter(char *f, off_t filesize, off_t *ctr)
{
start = last_update = monotime();
file = f;
end_pos = filesize;
cur_pos = 0;
counter = ctr;
stalled = 0;
bytes_per_second = 0;
setscreensize();
if (can_output())
refresh_progress_meter();
signal(SIGALRM, update_progress_meter);
signal(SIGWINCH, sig_winch);
alarm(UPDATE_INTERVAL);
}
void sharp_remove_routes_helper(struct prefix *p, vrf_id_t vrf_id,
uint8_t instance, uint32_t routes)
{
uint32_t temp, i;
bool v4 = false;
zlog_debug("Removing %u routes", routes);
if (p->family == AF_INET) {
v4 = true;
temp = ntohl(p->u.prefix4.s_addr);
} else
temp = ntohl(p->u.val32[3]);
monotime(&sg.r.t_start);
for (i = 0; i < routes; i++) {
route_delete(p, vrf_id, (uint8_t)instance);
if (v4)
p->u.prefix4.s_addr = htonl(++temp);
else
p->u.val32[3] = htonl(++temp);
}
}
static void log_emit(int lev, const char *fmt, ...)
{
va_list va;
char *msg = 0;
va_start(va, fmt);
if( vasprintf(&msg, fmt, va) < 0 )
msg = 0;
va_end(va);
#if ENABLE_DEBUG_LOGGING
static struct timeval t0, t1;
struct timeval t2, d0, d1;
monotime(&t2);
if( !timerisset(&t0) )
t0 = t1 = t0;
timersub(&t2, &t1, &d1);
timersub(&t2, &t0, &d0);
if( d1.tv_sec >= 5 )
t0 = t1 = t2;
else
t1 = t2;
fprintf(stderr, "%ld.%03ld %ld.%03ld %s: %s\n",
(long)d0.tv_sec, (long)(d0.tv_usec / 1000),
(long)d1.tv_sec, (long)(d1.tv_usec / 1000),
log_level_repr(lev), msg ?: fmt);
#else
fprintf(stderr, "%s: %s\n", log_level_repr(lev), msg ?: fmt);
#endif
free(msg);
}
int main (int argc, char *argv[])
{
nodeset_t *n, *n2;
nodeset_iterator_t *itr;
int i;
struct timespec ts;
uint32_t bigset = 1E6;
char *tmp;
plan (NO_PLAN);
n = nodeset_create ();
ok (n != NULL);
nodeset_config_brackets (n, false);
/* obtain constants used in other tests */
uint32_t maxrank = nodeset_getattr (n, NODESET_ATTR_MAXRANK);
uint32_t minsize = nodeset_getattr (n, NODESET_ATTR_MINSIZE);
uint32_t maxsize = nodeset_getattr (n, NODESET_ATTR_MAXSIZE);
nodeset_add_rank (n, 8);
nodeset_add_rank (n, 7);
nodeset_add_rank (n, 9);
like (nodeset_string (n), "7-9", "consecutive adds become range");
ok (nodeset_count (n) == 3);
nodeset_add_rank (n, 1);
like (nodeset_string (n), "1,7-9", "singleton prepended to range");
ok (nodeset_count (n) == 4);
nodeset_add_rank (n, 16);
like (nodeset_string (n), "1,7-9,16", "singleton appended to range");
ok (nodeset_count (n) == 5);
nodeset_add_rank (n, 14);
like (nodeset_string (n), "1,7-9,14,16", "singleton embedded in range");
ok (nodeset_count (n) == 6);
nodeset_add_rank (n, 3);
like (nodeset_string (n), "1,3,7-9,14,16", "singleton embedded in range 2");
ok (nodeset_count (n) == 7);
nodeset_add_range (n, 1, 3);
like (nodeset_string (n), "1-3,7-9,14,16", "overlapping range");
ok (nodeset_count (n) == 8);
nodeset_add_range (n, 5, 8);
like (nodeset_string (n), "1-3,5-9,14,16", "overlapping range 2");
ok (nodeset_count (n) == 10);
nodeset_add_range (n, 8, 11);
like (nodeset_string (n), "1-3,5-11,14,16", "overlapping range 3");
ok (nodeset_count (n) == 12);
nodeset_add_range (n, 1, 16);
like (nodeset_string (n), "1-16", "add range that contains existing");
ok (nodeset_count (n) == 16);
nodeset_add_range (n, 4, 8);
like (nodeset_string (n), "1-16", "add range contained by existing");
ok (nodeset_count (n) == 16);
nodeset_destroy (n);
/********************************************/
n = nodeset_create ();
ok (n != NULL);
nodeset_add_rank (n, 0);
nodeset_add_rank (n, 1);
nodeset_add_rank (n, 2);
like (nodeset_string (n), "\\[0-2\\]", "edge case 1 merges with 0");
ok (nodeset_count (n) == 3);
nodeset_config_ranges (n, false);
like (nodeset_string (n), "\\[0,1,2\\]");
nodeset_destroy (n);
/********************************************/
n = nodeset_create ();
ok (n != NULL);
nodeset_add_rank (n, 2);
nodeset_add_rank (n, 1);
nodeset_add_rank (n, 0);
like (nodeset_string (n), "\\[0-2\\]", "reverse merge works");
ok (nodeset_count (n) == 3);
nodeset_destroy (n);
/********************************************/
n = nodeset_create_string ("[1,3,5,6-100]");
ok (n != NULL);
like (nodeset_string (n), "\\[1,3,5-100\\]", "mundane range string works");
ok (nodeset_count (n) == 98);
nodeset_destroy (n);
n = nodeset_create_string ("2-1");
ok (n != NULL);
like (nodeset_string (n), "\\[1-2\\]", "numerically reversed range handled");
ok (nodeset_count (n) == 2);
nodeset_destroy (n);
n = nodeset_create_string ("");
ok (n != NULL);
ok (nodeset_count (n) == 0);
like (nodeset_string (n), "", "empty string produces empty range");
nodeset_destroy (n);
n = nodeset_create_string (",");
ok (n == NULL, "comma by itself produces error");
n = nodeset_create_string ("-1");
ok (n == NULL, "range missing start produces error");
n = nodeset_create_string ("1-");
ok (n == NULL, "range missing end produces error");
n = nodeset_create_string ("foo1");
ok (n == NULL, "alpha with numerical suffix produces error");
n = nodeset_create_string ("[1-2]");
ok (n != NULL);
like (nodeset_string (n), "\\[1-2\\]", "bracketed range works");
ok (nodeset_count (n) == 2);
nodeset_destroy (n);
n = nodeset_create_string ("xyz");
ok (n == NULL, "alpha by itself produces error");
/********************************************/
n = nodeset_create_string ("0-2");
ok (n != NULL);
ok (nodeset_test_rank (n, 0));
ok (nodeset_test_rank (n, 1));
ok (nodeset_test_rank (n, 2));
ok (!nodeset_test_rank (n, 3));
ok (!nodeset_test_rank (n, nodeset_getattr (n, NODESET_ATTR_SIZE) - 1),
"nodeset_test_rank (internal size - 1) fails");
ok (!nodeset_test_rank (n, nodeset_getattr (n, NODESET_ATTR_SIZE)),
"nodeset_test_rank (internal size) fails");
ok (!nodeset_test_rank (n, nodeset_getattr (n, NODESET_ATTR_SIZE) + 1),
"nodeset_test_rank (internal size + 1) fails");
ok (!nodeset_test_range (n, 2, nodeset_getattr (n, NODESET_ATTR_SIZE) - 1),
"nodeset_test_range (2, internal size - 1) fails");
ok (!nodeset_test_range (n, 2, nodeset_getattr (n, NODESET_ATTR_SIZE)),
"nodeset_test_range (2, internal size) fails");
ok (!nodeset_test_range (n, 2, nodeset_getattr (n, NODESET_ATTR_SIZE) + 1),
"nodeset_test_range (2, internal size + 1) fails");
ok (!nodeset_test_range (n, nodeset_getattr (n, NODESET_ATTR_SIZE) - 1, 2),
"nodeset_test_range (internal size - 1, 2) fails");
ok (!nodeset_test_range (n, nodeset_getattr (n, NODESET_ATTR_SIZE), 2),
"nodeset_test_range (internal size, 2) fails");
ok (!nodeset_test_range (n, nodeset_getattr (n, NODESET_ATTR_SIZE) + 1, 2),
"nodeset_test_range (internal size + 1, 2) fails");
nodeset_config_brackets (n, false);
like (nodeset_string (n), "0-2");
ok (nodeset_test_range (n, 0, 2), "nodeset_test_range works");
nodeset_delete_rank (n, 0);
like (nodeset_string (n), "1-2", "nodeset_delete_rank works");
ok (!nodeset_test_rank (n, 0), "nodeset_test_rank works");
ok (nodeset_test_range (n, 1, 2));
nodeset_delete_rank (n, 1);
ok (!nodeset_test_rank (n, 0));
ok (!nodeset_test_rank (n, 1));
ok (nodeset_test_rank (n, 2));
ok (!strcmp (nodeset_string (n), "2"));
nodeset_delete_rank (n, 2);
ok (!nodeset_test_rank (n, 0));
ok (!nodeset_test_rank (n, 1));
ok (!nodeset_test_rank (n, 2));
like (nodeset_string (n), "");
nodeset_destroy (n);
/********************************************/
/* Exercise iteration
*/
n = nodeset_create_string ("0-2");
ok (n != NULL);
itr = nodeset_iterator_create (n);
ok (nodeset_next (itr) == 0, "iterator_next works on first element");
ok (nodeset_next (itr) == 1, "iterator_next works on next element");
ok (nodeset_next (itr) == 2, "iterator_next works on last element");
ok (nodeset_next (itr) == NODESET_EOF, "iterator_next returns EOF");
nodeset_iterator_rewind (itr);
ok (nodeset_next (itr) == 0, "iterator rewind works");
nodeset_iterator_destroy (itr);
nodeset_destroy (n);
/********************************************/
/* Exercise iteration with nodeset_next_rank
*/
n = nodeset_create_string ("0,2-3,7");
ok (n != NULL);
int r = nodeset_min (n);
ok (r == 0, "nodeset_min");
ok ((r = nodeset_next_rank (n, r)) == 2,
"nodeset_next_rank (n, min) returns second element");
ok ((r = nodeset_next_rank (n, r)) == 3,
"nodeset_next_rank works on third element");
ok ((r = nodeset_next_rank (n, r)) == 7,
"nodeset_next_rank works on fourth element");
ok ((r = nodeset_next_rank (n, r)) == NODESET_EOF,
"nodeset_next_rank detects end of nodeset");
ok ((r = nodeset_next_rank (n, 1)) == 2,
"nodeset_next_rank returns next rank even if arg not in set");
/********************************************/
/* Exercise nodeset_dup
*/
n = nodeset_create_string ("0-2");
ok (n != NULL);
nodeset_config_brackets (n, false);
like (nodeset_string (n), "0-2");
n2 = nodeset_dup (n);
ok (n2 != NULL, "nodeset_dup says it worked");
like (nodeset_string (n2), "0-2", "nodeset_dup returned identical nodeset");
nodeset_add_rank (n, 4);
nodeset_add_rank (n2, 5);
like (nodeset_string (n), "0-2,4", "orig unaffected by changes in dup");
like (nodeset_string (n2), "0-2,5", "dup unaffected by changes in orig");
nodeset_destroy (n);
nodeset_destroy (n2);
/********************************************/
/* Try zero padding.
*/
n = nodeset_create_string ("[1,3,5,6-100]");
ok (n != NULL);
nodeset_config_brackets (n, false);
like (nodeset_string (n), "1,3,5-100", "results not zero padded by default");
//nodeset_config_padding (n, log10 (nodeset_max (n)) + 1);
nodeset_config_padding (n, 3);
like (nodeset_string (n), "001,003,005-100", "padding 3 on all all works");
nodeset_config_padding (n, 2);
like (nodeset_string (n), "01,03,05-100", "padding 2 on subset works");
nodeset_config_padding (n, 4);
like (nodeset_string (n), "0001,0003,0005-0100", "padding 4 on all works");
nodeset_destroy (n);
/********************************************/
/* Add 'bigset' consecutive singletons.
*/
n = nodeset_create ();
ok (n != NULL);
nodeset_config_brackets (n, false);
ok (nodeset_resize (n, bigset), "explicitly resize to %u", bigset);
monotime (&ts);
for (i = 0; i < bigset; i++)
if (!nodeset_add_rank (n, i))
break;
ok (i == bigset, "added %u consecutive ranks [%.2fs %u Mbytes]", bigset,
monotime_since (ts)/1000, nodeset_getattr (n, NODESET_ATTR_BYTES)/1024);
monotime (&ts);
tmp = xasprintf ("0-%u", bigset - 1);
like (nodeset_string (n), tmp, "string conversion %s [%.2fs %u Mbytes]", tmp,
monotime_since (ts)/1000, nodeset_getattr (n, NODESET_ATTR_BYTES)/1024);
free (tmp);
ok (nodeset_count (n) == bigset, "large nodeset count is sane");
nodeset_destroy (n);
/********************************************/
/* Add 'bigset'/2 non-consecutive singletons.
*/
n = nodeset_create ();
ok (n != NULL);
nodeset_config_brackets (n, false);
ok (nodeset_resize (n, bigset), "explicitly resize to %u", bigset);
monotime (&ts);
for (i = 0; i < bigset; i += 2)
if (!nodeset_add_rank (n, i))
break;
ok (i == bigset,
"added %u non-consecutive ranks [%.2fs %u Mbytes]", bigset/2,
monotime_since (ts)/1000, nodeset_getattr (n, NODESET_ATTR_BYTES)/1024);
monotime (&ts);
ok (nodeset_string (n) != NULL, "string conversion [%.2fs %u Mbytes]",
monotime_since (ts)/1000, nodeset_getattr (n, NODESET_ATTR_BYTES)/1024);
ok (nodeset_count (n) == bigset/2, "large nodeset count is sane");
nodeset_destroy (n);
/********************************************/
/* Check edge cases with very big ranks and resize.
*/
bool skip_huge = true;
n = nodeset_create ();
nodeset_config_brackets (n, false);
ok (nodeset_getattr (n, NODESET_ATTR_SIZE) == minsize,
"veb size is the minimum %u", minsize);
monotime (&ts);
ok (!nodeset_add_rank (n, maxrank + 1),
"adding max+1 %u rank fails [%.2fs %u Mbytes]", maxrank + 1,
monotime_since (ts)/1000,
nodeset_getattr (n, NODESET_ATTR_BYTES)/(1024*1024));
ok (nodeset_getattr (n, NODESET_ATTR_SIZE) == minsize,
"veb size is the minimum %u", minsize);
skip (skip_huge, 16, "too slow");
monotime (&ts);
ok (nodeset_add_rank (n, maxrank),
"add max rank %u [%.2fs %u Mbytes]", maxrank,
monotime_since (ts)/1000,
nodeset_getattr (n, NODESET_ATTR_BYTES)/(1024*1024));
ok (nodeset_getattr (n, NODESET_ATTR_SIZE) == maxsize,
"veb size is the maximum %u", maxsize);
/* 2 */
monotime (&ts);
ok (nodeset_add_rank (n, maxrank - 1),
"add max-1 %u [%.2fs %u Mbytes]", maxrank - 1,
monotime_since (ts)/1000,
nodeset_getattr (n, NODESET_ATTR_BYTES)/(1024*1024));
ok (nodeset_test_rank (n, maxrank - 1), "test rank max - 1");
ok (nodeset_test_rank (n, maxrank), "test rank max");
ok (!nodeset_test_rank (n, maxrank + 1), "test rank max + 1");
ok (nodeset_count (n) == 2, "nodeset count is sane");
/* 7 */
tmp = xasprintf ("%u-%u", maxrank-1, maxrank);
monotime (&ts);
like (nodeset_string (n), tmp, "convert to string %s [%.2fs %u Mbytes]", tmp,
monotime_since (ts)/1000,
nodeset_getattr (n, NODESET_ATTR_BYTES)/(1024*1024));
free (tmp);
/* 8 */
ok (nodeset_resize (n, 0), "resize to 0 returns success");
ok (nodeset_getattr (n, NODESET_ATTR_SIZE) == maxsize,
"nodeset size remains max %u", maxsize);
/* 10 */
nodeset_delete_rank (n, maxrank - 1);
ok (!nodeset_test_rank (n, maxrank - 1), "nodeset_del max - 1 works");
ok (nodeset_test_rank (n, maxrank));
ok (!nodeset_test_rank (n, maxrank + 1));
/* 13 */
nodeset_delete_rank (n, maxrank + 1);
ok (!nodeset_test_rank (n, maxrank - 1), "nodeset_del max + 1 has no effect");
ok (nodeset_test_rank (n, maxrank));
ok (!nodeset_test_rank (n, maxrank + 1));
/* 16 */
end_skip;
nodeset_delete_rank (n, maxrank);
ok (!nodeset_test_rank (n, maxrank - 1), "nodeset_del max works");
ok (!nodeset_test_rank (n, maxrank));
ok (!nodeset_test_rank (n, maxrank + 1));
/* 19 */
ok (nodeset_resize (n, 0), "resize to zero returns success");
ok (nodeset_getattr (n, NODESET_ATTR_SIZE) == minsize,
"nodeset size is the minimum %u", minsize);
nodeset_destroy (n);
done_testing ();
}
void log_level(uint32_t space_id, uint32_t res_id, char *name_in, int level, const char *fmt, ...)
{
va_list ap;
char name[NAME_ID_SIZE + 1];
int ret, pos = 0;
int len = LOG_STR_LEN - 2; /* leave room for \n\0 */
struct timeval cur_time;
struct tm time_info;
pid_t tid;
memset(name, 0, sizeof(name));
if (space_id && !res_id)
snprintf(name, NAME_ID_SIZE, "s%u ", space_id);
else if (!space_id && res_id)
snprintf(name, NAME_ID_SIZE, "r%u ", res_id);
else if (space_id && res_id)
snprintf(name, NAME_ID_SIZE, "s%u:r%u ", space_id, res_id);
else if (name_in)
snprintf(name, NAME_ID_SIZE, "%.8s ", name_in);
pthread_mutex_lock(&log_mutex);
gettimeofday(&cur_time, NULL);
if (log_logfile_use_utc)
gmtime_r(&cur_time.tv_sec, &time_info);
else
localtime_r(&cur_time.tv_sec, &time_info);
ret = strftime(log_str + pos, len - pos,
"%Y-%m-%d %H:%M:%S ", &time_info);
pos += ret;
tid = syscall(SYS_gettid);
ret = snprintf(log_str + pos, len - pos, "%llu [%u]: %s",
(unsigned long long) monotime(), tid, name);
pos += ret;
va_start(ap, fmt);
ret = vsnprintf(log_str + pos, len - pos, fmt, ap);
va_end(ap);
if (ret >= len - pos)
pos = len - 1;
else
pos += ret;
log_str[pos++] = '\n';
log_str[pos++] = '\0';
/*
* save all messages in circular buffer "log_dump" that can be
* sent over unix socket
*/
_log_save_dump(level, pos - 1);
/*
* save some messages in circular array "log_ents" that a thread
* writes to logfile/syslog
*/
if (level <= log_logfile_priority || level <= log_syslog_priority)
_log_save_ent(level, pos);
if (level <= log_stderr_priority)
fprintf(stderr, "%s", log_str);
pthread_cond_signal(&log_cond);
pthread_mutex_unlock(&log_mutex);
}
int main (int argc, char *argv[])
{
flux_t h;
int ch;
struct timespec t0;
char *name = NULL;
int quiet = 0;
int nprocs = 1;
int iter = 1;
int i;
log_init ("tbarrier");
while ((ch = getopt_long (argc, argv, OPTIONS, longopts, NULL)) != -1) {
switch (ch) {
case 'h': /* --help */
usage ();
break;
case 'q': /* --quiet */
quiet = 1;
break;
case 'n': /* --nprocs N */
nprocs = strtoul (optarg, NULL, 10);
break;
case 't': /* --test-iterations N */
iter = strtoul (optarg, NULL, 10);
break;
default:
usage ();
break;
}
}
if (optind < argc - 1)
usage ();
if (optind < argc)
name = argv[optind++];
if (!(h = flux_open (NULL, 0)))
err_exit ("flux_open");
for (i = 0; i < iter; i++) {
char *tname = NULL;
monotime (&t0);
if (name)
tname = xasprintf ("%s.%d", name, i);
if (flux_barrier (h, tname, nprocs) < 0) {
if (errno == EINVAL && tname == NULL)
msg_exit ("%s", "provide barrier name if not running as LWJ");
else
err_exit ("flux_barrier");
}
if (!quiet)
printf ("barrier name=%s nprocs=%d time=%0.3f ms\n",
tname ? tname : "NULL", nprocs, monotime_since (t0));
if (tname)
free (tname);
}
flux_close (h);
log_fini ();
return 0;
}
void
refresh_progress_meter(void)
{
char buf[MAX_WINSIZE + 1];
time_t now;
off_t transferred;
double elapsed;
int percent;
off_t bytes_left;
int cur_speed;
int hours, minutes, seconds;
int i, len;
int file_len;
off_t delta_pos;
transferred = *counter - (cur_pos ? cur_pos : start_pos);
cur_pos = *counter;
now = monotime();
bytes_left = end_pos - cur_pos;
delta_pos = cur_pos - last_pos;
if (delta_pos > max_delta_pos)
max_delta_pos = delta_pos;
if (bytes_left > 0)
elapsed = now - last_update;
else {
elapsed = now - start;
/* Calculate true total speed when done */
transferred = end_pos - start_pos;
bytes_per_second = 0;
}
/* calculate speed */
if (elapsed != 0)
cur_speed = (transferred / elapsed);
else
cur_speed = transferred;
#define AGE_FACTOR 0.9
if (bytes_per_second != 0) {
bytes_per_second = (bytes_per_second * AGE_FACTOR) +
(cur_speed * (1.0 - AGE_FACTOR));
} else
bytes_per_second = cur_speed;
/* filename */
buf[0] = '\0';
file_len = win_size - 45;
if (file_len > 0) {
len = snprintf(buf, file_len + 1, "\r%s", file);
if (len < 0)
len = 0;
if (len >= file_len + 1)
len = file_len;
for (i = len; i < file_len; i++)
buf[i] = ' ';
buf[file_len] = '\0';
}
/* percent of transfer done */
if (end_pos != 0)
percent = ((float)cur_pos / end_pos) * 100;
else
percent = 100;
snprintf(buf + strlen(buf), win_size - strlen(buf-8),
" %3d%% ", percent);
/* amount transferred */
format_size(buf + strlen(buf), win_size - strlen(buf),
cur_pos);
strlcat(buf, " ", win_size);
/* bandwidth usage */
format_rate(buf + strlen(buf), win_size - strlen(buf),
(off_t)bytes_per_second);
strlcat(buf, "/s ", win_size);
/* instantaneous rate */
if (bytes_left > 0)
format_rate(buf + strlen(buf), win_size - strlen(buf),
delta_pos);
else
format_rate(buf + strlen(buf), win_size - strlen(buf),
max_delta_pos);
strlcat(buf, "/s ", win_size);
/* ETA */
if (!transferred)
stalled += elapsed;
else
stalled = 0;
if (stalled >= STALL_TIME)
strlcat(buf, "- stalled -", win_size);
else if (bytes_per_second == 0 && bytes_left)
strlcat(buf, " --:-- ETA", win_size);
else {
if (bytes_left > 0)
seconds = bytes_left / bytes_per_second;
else
seconds = elapsed;
hours = seconds / 3600;
seconds -= hours * 3600;
minutes = seconds / 60;
seconds -= minutes * 60;
if (hours != 0)
snprintf(buf + strlen(buf), win_size - strlen(buf),
"%d:%02d:%02d", hours, minutes, seconds);
else
snprintf(buf + strlen(buf), win_size - strlen(buf),
" %02d:%02d", minutes, seconds);
if (bytes_left > 0)
strlcat(buf, " ETA", win_size);
else
strlcat(buf, " ", win_size);
}
atomicio(vwrite, STDOUT_FILENO, buf, win_size - 1);
last_update = now;
last_pos = cur_pos;
}
int main (int argc, char *argv[])
{
thd_t *thd;
int i, rc;
int ch;
tstat_t ts;
struct timespec t0;
log_init (basename (argv[0]));
while ((ch = getopt_long (argc, argv, OPTIONS, longopts, NULL)) != -1) {
switch (ch) {
case 'f':
fopt = true;
fence_nprocs = strtoul (optarg, NULL, 10);
if (!fence_nprocs)
log_msg_exit ("fence value must be > 0");
break;
case 's':
sopt = true;
break;
case 'n':
nopt = true;
nopt_divisor = strtoul (optarg, NULL, 10);
if (!nopt_divisor)
log_msg_exit ("nopt value must be > 0");
break;
default:
usage ();
}
}
if (argc - optind != 3)
usage ();
nthreads = strtoul (argv[optind++], NULL, 10);
if (!nthreads)
log_msg_exit ("thread count must be > 0");
count = strtoul (argv[optind++], NULL, 10);
if (!count)
log_msg_exit ("commit count must be > 0");
prefix = argv[optind++];
memset (&ts, 0, sizeof (ts));
thd = xzmalloc (sizeof (*thd) * nthreads);
if (sopt)
monotime (&t0);
for (i = 0; i < nthreads; i++) {
thd[i].n = i;
if (!(thd[i].perf = zlist_new ()))
oom ();
if ((rc = pthread_attr_init (&thd[i].attr)))
log_errn (rc, "pthread_attr_init");
if ((rc = pthread_create (&thd[i].t, &thd[i].attr, thread, &thd[i])))
log_errn (rc, "pthread_create");
}
for (i = 0; i < nthreads; i++) {
if ((rc = pthread_join (thd[i].t, NULL)))
log_errn (rc, "pthread_join");
if (sopt) {
double *e;
while ((e = zlist_pop (thd[i].perf))) {
tstat_push (&ts, *e);
free (e);
}
}
zlist_destroy (&thd[i].perf);
}
if (sopt) {
json_t *o;
char *s;
if (!(o = json_pack ("{s:{s:i s:f s:f s:f s:f} s:f}",
"put+commit times (sec)",
"count", tstat_count (&ts),
"min", tstat_min (&ts)*1E-3,
"mean", tstat_mean (&ts)*1E-3,
"stddev", tstat_stddev (&ts)*1E-3,
"max", tstat_max (&ts)*1E-3,
"put+commit throughput (#/sec)",
(double)(count*nthreads)
/ (monotime_since (t0)*1E-3))))
log_err_exit ("json_pack");
if (!(s = json_dumps (o, JSON_INDENT(2))))
log_err_exit ("json_dumps");
printf ("%s\n", s);
json_decref (o);
free (s);
}
free (thd);
log_fini ();
return 0;
}
