int pmixp_server_pp_send(int nodeid, int size)
{
Buf buf = pmixp_server_buf_new();
int rc;
pmixp_ep_t ep;
struct pp_cbdata *cbdata = xmalloc(sizeof(*cbdata));
grow_buf(buf, size);
ep.type = PMIXP_EP_NOIDEID;
ep.ep.nodeid = nodeid;
cbdata->buf = buf;
cbdata->size = size;
set_buf_offset(buf,get_buf_offset(buf) + size);
rc = pmixp_server_send_nb(&ep, PMIXP_MSG_PINGPONG,
_pmixp_pp_count, buf, pingpong_complete,
(void*)cbdata);
if (SLURM_SUCCESS != rc) {
char *nodename = pmixp_info_job_host(nodeid);
PMIXP_ERROR("Was unable to wait for the parent %s to "
"become alive",
nodename);
xfree(nodename);
}
return rc;
}
int pmixp_server_health_chk(char *hostlist, const char *addr)
{
send_header_t hdr;
char nhdr[sizeof(send_header_t)];
size_t hsize;
Buf buf = pmixp_server_new_buf();
char *data = get_buf_data(buf);
int rc;
hdr.magic = PMIX_SERVER_MSG_MAGIC;
hdr.type = PMIXP_MSG_HEALTH_CHK;
hdr.msgsize = 1;
hdr.seq = 0;
/* Store global nodeid that is
* independent from exact collective */
hdr.nodeid = pmixp_info_nodeid_job();
hsize = _send_pack_hdr(&hdr, nhdr);
memcpy(data, nhdr, hsize);
grow_buf(buf, sizeof(char));
pack8('\n', buf);
rc = pmixp_stepd_send(hostlist, addr, data, get_buf_offset(buf), 4, 14, 1);
if (SLURM_SUCCESS != rc) {
PMIXP_ERROR("Was unable to wait for the parent %s to become alive on addr %s",
hostlist, addr);
}
return rc;
}
/*
* add an arc from node s1 to node s2 in the graph. If s1 or s2 are not in
* the graph, then add them.
*/
static void
add_arc(char *s1, char *s2)
{
NODE *n1;
NODE *n2;
int bsize, i;
n1 = get_node(s1);
if (!strcmp(s1, s2))
return;
n2 = get_node(s2);
/*
* Check if this arc is already here.
*/
for (i = 0; i < n1->n_narcs; i++)
if (n1->n_arcs[i] == n2)
return;
/*
* Add it.
*/
if (n1->n_narcs == n1->n_arcsize) {
if (!n1->n_arcsize)
n1->n_arcsize = 10;
bsize = n1->n_arcsize * sizeof(*n1->n_arcs) * 2;
n1->n_arcs = grow_buf(n1->n_arcs, bsize);
n1->n_arcsize = bsize / sizeof(*n1->n_arcs);
}
n1->n_arcs[n1->n_narcs++] = n2;
++n2->n_refcnt;
}
inline static int _pmixp_coll_contrib(pmixp_coll_ring_ctx_t *coll_ctx,
int contrib_id,
uint32_t hop, char *data, size_t size)
{
pmixp_coll_t *coll = _ctx_get_coll(coll_ctx);
char *data_ptr = NULL;
int ret;
/* change the state */
coll->ts = time(NULL);
/* save contribution */
if (!size_buf(coll_ctx->ring_buf)) {
grow_buf(coll_ctx->ring_buf, size * coll->peers_cnt);
} else if(remaining_buf(coll_ctx->ring_buf) < size) {
uint32_t new_size = size_buf(coll_ctx->ring_buf) + size *
_ring_remain_contrib(coll_ctx);
grow_buf(coll_ctx->ring_buf, new_size);
}
grow_buf(coll_ctx->ring_buf, size);
data_ptr = get_buf_data(coll_ctx->ring_buf) +
get_buf_offset(coll_ctx->ring_buf);
memcpy(data_ptr, data, size);
set_buf_offset(coll_ctx->ring_buf,
get_buf_offset(coll_ctx->ring_buf) + size);
/* check for ring is complete */
if (contrib_id != _ring_next_id(coll)) {
/* forward data to the next node */
ret = _ring_forward_data(coll_ctx, contrib_id, hop,
data_ptr, size);
if (ret) {
PMIXP_ERROR("Cannot forward ring data");
return SLURM_ERROR;
}
}
return SLURM_SUCCESS;
}
static __isl_give isl_printer *str_print_indent(__isl_take isl_printer *p,
int indent)
{
int i;
if (p->buf_n + indent + 1 >= p->buf_size && grow_buf(p, indent))
goto error;
for (i = 0; i < indent; ++i)
p->buf[p->buf_n++] = ' ';
return p;
error:
isl_printer_free(p);
return NULL;
}
static __isl_give isl_printer *str_print(__isl_take isl_printer *p,
const char *s, int len)
{
if (p->buf_n + len + 1 >= p->buf_size && grow_buf(p, len))
goto error;
memcpy(p->buf + p->buf_n, s, len);
p->buf_n += len;
p->buf[p->buf_n] = '\0';
return p;
error:
isl_printer_free(p);
return NULL;
}
static void _setup_header(Buf buf, dmdx_type_t t,
const char *nspace, int rank, int status)
{
char *str;
/* 1. pack message type */
unsigned char type = (char)t;
grow_buf(buf, sizeof(char));
pack8(type, buf);
/* 2. pack namespace _with_ '\0' (strlen(nspace) + 1)! */
packmem((char *)nspace, strlen(nspace) + 1, buf);
/* 3. pack rank */
grow_buf(buf, sizeof(int));
pack32((uint32_t)rank, buf);
/* 4. pack my rendezvous point - local namespace
* ! _with_ '\0' (strlen(nspace) + 1) ! */
str = pmixp_info_namespace();
packmem(str, strlen(str) + 1, buf);
/* 5. pack the status */
pack32((uint32_t)status, buf);
}
static __isl_give isl_printer *str_print_int(__isl_take isl_printer *p, int i)
{
int left = p->buf_size - p->buf_n;
int need = snprintf(p->buf + p->buf_n, left, "%d", i);
if (need >= left) {
if (grow_buf(p, need))
goto error;
left = p->buf_size - p->buf_n;
need = snprintf(p->buf + p->buf_n, left, "%d", i);
}
p->buf_n += need;
return p;
error:
isl_printer_free(p);
return NULL;
}
int pmixp_coll_contrib_local(pmixp_coll_t *coll, char *data, size_t size)
{
PMIXP_DEBUG("%s:%d: get local contribution", pmixp_info_namespace(),
pmixp_info_nodeid());
/* sanity check */
pmixp_coll_sanity_check(coll);
/* lock the structure */
slurm_mutex_lock(&coll->lock);
/* change the collective state if need */
if (PMIXP_COLL_SYNC == coll->state) {
PMIXP_DEBUG(
"%s:%d: get local contribution: switch to PMIXP_COLL_FAN_IN",
pmixp_info_namespace(), pmixp_info_nodeid());
coll->state = PMIXP_COLL_FAN_IN;
coll->ts = time(NULL);
}
xassert(PMIXP_COLL_FAN_IN == coll->state);
/* save & mark local contribution */
coll->contrib_local = true;
grow_buf(coll->buf, size);
memcpy(get_buf_data(coll->buf) + get_buf_offset(coll->buf), data, size);
set_buf_offset(coll->buf, get_buf_offset(coll->buf) + size);
/* unlock the structure */
slurm_mutex_unlock(&coll->lock);
/* check if the collective is ready to progress */
_progress_fan_in(coll);
PMIXP_DEBUG("%s:%d: get local contribution: finish",
pmixp_info_namespace(), pmixp_info_nodeid());
return SLURM_SUCCESS;
}
char *LICE_GetImageExtensionList(bool wantAllSup, bool wantAllFiles)
{
_LICE_ImageLoader_rec *hdr = LICE_ImageLoader_list;
int bufsz=4096;
int wrpos=0;
char *buf=(char *)malloc(bufsz);
buf[0]=buf[1]=buf[2]=0;
if (wantAllSup)
{
static const char af[]="All supported images";
if (grow_buf(&buf,&bufsz,&wrpos,af,sizeof(af))) { free(buf); return "\0\0"; } // fail
int cnt=0;
while (hdr)
{
const char *rd = hdr->get_extlist();
if (rd && *rd)
{
bool st=false;
const char *p=rd;
while (*p)
{
if (st)
{
if (cnt++)
if (grow_buf(&buf,&bufsz,&wrpos,";",1)) { free(buf); return "\0\0"; } // fail
if (grow_buf(&buf,&bufsz,&wrpos,p,strlen(p)+1)) { free(buf); return "\0\0"; } // fail
wrpos--;
}
while (*p) p++;
p++;
st=!st;
}
}
hdr=hdr->_next;
}
if (!cnt)
{
wrpos=0; // reset if nothing meaningful added
buf[0]=buf[1]=buf[2]=0;
}
else wrpos++;
hdr = LICE_ImageLoader_list;
}
while (hdr)
{
const char *rd = hdr->get_extlist();
if (rd && *rd)
{
const char *p=rd;
while (p[0] || p[1]) p++; // doublenull terminated list
int len = p + 2 - rd;
if (len>2)
{
if (grow_buf(&buf,&bufsz,&wrpos,rd,len)) return buf; // fail
wrpos--; // remove doublenull on next round
}
}
hdr=hdr->_next;
}
if (wantAllFiles)
{
static const char af[]="All files (*.*)\0*.*\0";
if (grow_buf(&buf,&bufsz,&wrpos,af,sizeof(af))) return buf; // fail
wrpos--;
}
return buf;
}
int
main(int argc, char *argv[])
{
BUF *b;
int c, n;
FILE *fp;
int bsize, ch, nused;
BUF bufs[2];
setprogname(argv[0]);
fp = NULL;
while ((ch = getopt(argc, argv, "dlq")) != -1)
switch (ch) {
case 'd':
debug = 1;
break;
case 'l':
longest = 1;
break;
case 'q':
quiet = 1;
break;
case '?':
default:
usage();
}
argc -= optind;
argv += optind;
switch (argc) {
case 0:
fp = stdin;
break;
case 1:
if ((fp = fopen(*argv, "r")) == NULL)
err(1, "%s", *argv);
break;
default:
usage();
}
for (b = bufs, n = 2; --n >= 0; b++)
b->b_buf = grow_buf(NULL, b->b_bsize = 1024);
/* parse input and build the graph */
for (n = 0, c = getc(fp);;) {
while (c != EOF && isspace(c))
c = getc(fp);
if (c == EOF)
break;
nused = 0;
b = &bufs[n];
bsize = b->b_bsize;
do {
b->b_buf[nused++] = c;
if (nused == bsize)
b->b_buf = grow_buf(b->b_buf, bsize *= 2);
c = getc(fp);
} while (c != EOF && !isspace(c));
b->b_buf[nused] = '\0';
b->b_bsize = bsize;
if (n)
add_arc(bufs[0].b_buf, bufs[1].b_buf);
n = !n;
}
(void)fclose(fp);
if (n)
errx(1, "odd data count");
/* do the sort */
tsort();
return(0);
}
int pmixp_coll_contrib_node(pmixp_coll_t *coll, char *nodename, Buf buf)
{
int nodeid;
char *data = NULL;
uint32_t size;
char *state = NULL;
PMIXP_DEBUG("%s:%d: get contribution from node %s",
pmixp_info_namespace(), pmixp_info_nodeid(), nodename);
/* lock the structure */
slurm_mutex_lock(&coll->lock);
pmixp_coll_sanity_check(coll);
/* fix the collective status if need */
if (PMIXP_COLL_SYNC == coll->state) {
PMIXP_DEBUG("%s:%d: get contribution from node %s: switch to PMIXP_COLL_FAN_IN",
pmixp_info_namespace(), pmixp_info_nodeid(),
nodename);
coll->state = PMIXP_COLL_FAN_IN;
coll->ts = time(NULL);
} else if( PMIXP_COLL_FAN_OUT == coll->state) {
PMIXP_DEBUG("%s:%d: get contribution from node %s: switch to PMIXP_COLL_FAN_OUT_IN"
" (next collective!)",
pmixp_info_namespace(), pmixp_info_nodeid(),
nodename);
coll->state = PMIXP_COLL_FAN_OUT_IN;
coll->ts_next = time(NULL);
}
xassert(PMIXP_COLL_FAN_IN == coll->state || PMIXP_COLL_FAN_OUT_IN == coll->state);
/* Because of possible timeouts/delays in transmission we
* can receive a contribution second time. Avoid duplications
* by checking our records. */
nodeid = hostlist_find(coll->ch_hosts, nodename);
xassert(0 <= nodeid);
if (0 > nodeid) {
/* protect ourselfs if we are running with no asserts */
goto proceed;
}
if (0 < coll->ch_contribs[nodeid]) {
/* May be 0 or 1. If grater - transmission skew, ignore. */
PMIXP_DEBUG("Multiple contributions from child_id=%d, hostname=%s",
nodeid, nodename);
/* this is duplication, skip. */
goto proceed;
}
data = get_buf_data(buf) + get_buf_offset(buf);
size = remaining_buf(buf);
grow_buf(coll->buf, size);
memcpy(get_buf_data(coll->buf) + get_buf_offset(coll->buf), data, size);
set_buf_offset(coll->buf, get_buf_offset(coll->buf) + size);
/* increase number of individual contributions */
coll->ch_contribs[nodeid]++;
/* increase number of total contributions */
coll->contrib_cntr++;
proceed:
/* unlock the structure */
slurm_mutex_unlock(&coll->lock);
if( PMIXP_COLL_FAN_IN == coll->state ){
/* make a progress if we are in fan-in state */
_progress_fan_in(coll);
}
switch( coll->state ){
case PMIXP_COLL_SYNC:
state = "sync";
break;
case PMIXP_COLL_FAN_IN:
state = "fan-in";
break;
case PMIXP_COLL_FAN_OUT:
state = "fan-out";
break;
case PMIXP_COLL_FAN_OUT_IN:
state = "fan-out-in";
break;
}
PMIXP_DEBUG("%s:%d: get contribution from node %s: finish. State = %s",
pmixp_info_namespace(), pmixp_info_nodeid(), nodename,
state);
return SLURM_SUCCESS;
}