static int s1_init(void)
{
PMI_BOOL initialized;
int spawned;
int rc, ret = OPAL_ERROR;
int i, rank, lrank, nrank;
char *pmix_id, tmp[64];
opal_value_t kv;
char *str;
uint32_t ui32;
opal_process_name_t ldr;
char **localranks=NULL;
if (PMI_SUCCESS != (rc = PMI_Initialized(&initialized))) {
OPAL_PMI_ERROR(rc, "PMI_Initialized");
return OPAL_ERROR;
}
if (PMI_TRUE != initialized && PMI_SUCCESS != (rc = PMI_Init(&spawned))) {
OPAL_PMI_ERROR(rc, "PMI_Init");
return OPAL_ERROR;
}
// setup hash table
opal_pmix_base_hash_init();
// Initialize space demands
rc = PMI_KVS_Get_value_length_max(&pmix_vallen_max);
if (PMI_SUCCESS != rc) {
OPAL_PMI_ERROR(rc, "PMI_KVS_Get_value_length_max");
goto err_exit;
}
pmix_vallen_threshold = pmix_vallen_max * 3;
pmix_vallen_threshold >>= 2;
rc = PMI_KVS_Get_name_length_max(&pmix_kvslen_max);
if (PMI_SUCCESS != rc) {
OPAL_PMI_ERROR(rc, "PMI_KVS_Get_name_length_max");
goto err_exit;
}
rc = PMI_KVS_Get_key_length_max(&pmix_keylen_max);
if (PMI_SUCCESS != rc) {
OPAL_PMI_ERROR(rc, "PMI_KVS_Get_key_length_max");
goto err_exit;
}
// Initialize job environment information
pmix_id = (char*)malloc(pmix_vallen_max);
if (pmix_id == NULL) {
ret = OPAL_ERR_OUT_OF_RESOURCE;
goto err_exit;
}
/* Get domain id */
if (PMI_SUCCESS != (rc = PMI_Get_kvs_domain_id(pmix_id, pmix_vallen_max))) {
free(pmix_id);
goto err_exit;
}
/* get our rank */
ret = PMI_Get_rank(&rank);
if( PMI_SUCCESS != ret ) {
OPAL_PMI_ERROR(ret, "PMI_Get_rank");
free(pmix_id);
goto err_exit;
}
/* Slurm PMI provides the job id as an integer followed
* by a '.', followed by essentially a stepid. The first integer
* defines an overall job number. The second integer is the number of
* individual jobs we have run within that allocation. */
s1_pname.jobid = strtoul(pmix_id, &str, 10);
s1_pname.jobid = (s1_pname.jobid << 16) & 0xffff0000;
if (NULL != str) {
ui32 = strtoul(str, NULL, 10);
s1_pname.jobid |= (ui32 & 0x0000ffff);
}
ldr.jobid = s1_pname.jobid;
s1_pname.vpid = rank;
/* store our name in the opal_proc_t so that
* debug messages will make sense - an upper
* layer will eventually overwrite it, but that
* won't do any harm */
opal_proc_set_name(&s1_pname);
opal_output_verbose(2, opal_pmix_base_framework.framework_output,
"%s pmix:s1: assigned tmp name",
OPAL_NAME_PRINT(s1_pname));
OBJ_CONSTRUCT(&kv, opal_value_t);
kv.key = strdup(OPAL_PMIX_JOBID);
kv.type = OPAL_UINT32;
kv.data.uint32 = s1_pname.jobid;
if (OPAL_SUCCESS != (ret = opal_pmix_base_store(&OPAL_PROC_MY_NAME, &kv))) {
OPAL_ERROR_LOG(ret);
OBJ_DESTRUCT(&kv);
goto err_exit;
}
OBJ_DESTRUCT(&kv);
/* save it */
OBJ_CONSTRUCT(&kv, opal_value_t);
kv.key = strdup(OPAL_PMIX_RANK);
kv.type = OPAL_UINT32;
kv.data.uint32 = rank;
if (OPAL_SUCCESS != (ret = opal_pmix_base_store(&OPAL_PROC_MY_NAME, &kv))) {
OPAL_ERROR_LOG(ret);
OBJ_DESTRUCT(&kv);
goto err_exit;
}
OBJ_DESTRUCT(&kv);
pmix_kvs_name = (char*)malloc(pmix_kvslen_max);
if (pmix_kvs_name == NULL) {
ret = OPAL_ERR_OUT_OF_RESOURCE;
goto err_exit;
}
rc = PMI_KVS_Get_my_name(pmix_kvs_name, pmix_kvslen_max);
if (PMI_SUCCESS != rc) {
OPAL_PMI_ERROR(rc, "PMI_KVS_Get_my_name");
goto err_exit;
}
/* get our local proc info to find our local rank */
if (PMI_SUCCESS != (rc = PMI_Get_clique_size(&nlranks))) {
OPAL_PMI_ERROR(rc, "PMI_Get_clique_size");
return rc;
}
/* save the local size */
OBJ_CONSTRUCT(&kv, opal_value_t);
kv.key = strdup(OPAL_PMIX_LOCAL_SIZE);
kv.type = OPAL_UINT32;
kv.data.uint32 = nlranks;
if (OPAL_SUCCESS != (ret = opal_pmix_base_store(&OPAL_PROC_MY_NAME, &kv))) {
OPAL_ERROR_LOG(ret);
OBJ_DESTRUCT(&kv);
goto err_exit;
}
OBJ_DESTRUCT(&kv);
lrank = 0;
nrank = 0;
ldr.vpid = rank;
if (0 < nlranks) {
/* now get the specific ranks */
lranks = (int*)calloc(nlranks, sizeof(int));
if (NULL == lranks) {
rc = OPAL_ERR_OUT_OF_RESOURCE;
OPAL_ERROR_LOG(rc);
return rc;
}
if (PMI_SUCCESS != (rc = PMI_Get_clique_ranks(lranks, nlranks))) {
OPAL_PMI_ERROR(rc, "PMI_Get_clique_ranks");
free(lranks);
return rc;
}
/* note the local ldr */
ldr.vpid = lranks[0];
/* save this */
memset(tmp, 0, 64);
for (i=0; i < nlranks; i++) {
(void)snprintf(tmp, 64, "%d", lranks[i]);
opal_argv_append_nosize(&localranks, tmp);
if (rank == lranks[i]) {
lrank = i;
nrank = i;
}
}
str = opal_argv_join(localranks, ',');
opal_argv_free(localranks);
OBJ_CONSTRUCT(&kv, opal_value_t);
kv.key = strdup(OPAL_PMIX_LOCAL_PEERS);
kv.type = OPAL_STRING;
kv.data.string = str;
if (OPAL_SUCCESS != (ret = opal_pmix_base_store(&OPAL_PROC_MY_NAME, &kv))) {
OPAL_ERROR_LOG(ret);
OBJ_DESTRUCT(&kv);
goto err_exit;
}
OBJ_DESTRUCT(&kv);
}
/* save the local leader */
OBJ_CONSTRUCT(&kv, opal_value_t);
kv.key = strdup(OPAL_PMIX_LOCALLDR);
kv.type = OPAL_UINT64;
kv.data.uint64 = *(uint64_t*)&ldr;
if (OPAL_SUCCESS != (ret = opal_pmix_base_store(&OPAL_PROC_MY_NAME, &kv))) {
OPAL_ERROR_LOG(ret);
OBJ_DESTRUCT(&kv);
goto err_exit;
}
OBJ_DESTRUCT(&kv);
/* save our local rank */
OBJ_CONSTRUCT(&kv, opal_value_t);
kv.key = strdup(OPAL_PMIX_LOCAL_RANK);
kv.type = OPAL_UINT16;
kv.data.uint16 = lrank;
if (OPAL_SUCCESS != (ret = opal_pmix_base_store(&OPAL_PROC_MY_NAME, &kv))) {
OPAL_ERROR_LOG(ret);
OBJ_DESTRUCT(&kv);
goto err_exit;
}
OBJ_DESTRUCT(&kv);
/* and our node rank */
OBJ_CONSTRUCT(&kv, opal_value_t);
kv.key = strdup(OPAL_PMIX_NODE_RANK);
kv.type = OPAL_UINT16;
kv.data.uint16 = nrank;
if (OPAL_SUCCESS != (ret = opal_pmix_base_store(&OPAL_PROC_MY_NAME, &kv))) {
OPAL_ERROR_LOG(ret);
OBJ_DESTRUCT(&kv);
goto err_exit;
}
OBJ_DESTRUCT(&kv);
/* get universe size */
ret = PMI_Get_universe_size(&i);
if (PMI_SUCCESS != ret) {
OPAL_PMI_ERROR(ret, "PMI_Get_universe_size");
goto err_exit;
}
/* push this into the dstore for subsequent fetches */
OBJ_CONSTRUCT(&kv, opal_value_t);
kv.key = strdup(OPAL_PMIX_UNIV_SIZE);
kv.type = OPAL_UINT32;
kv.data.uint32 = i;
if (OPAL_SUCCESS != (ret = opal_pmix_base_store(&OPAL_PROC_MY_NAME, &kv))) {
OPAL_ERROR_LOG(ret);
OBJ_DESTRUCT(&kv);
goto err_exit;
}
OBJ_DESTRUCT(&kv);
/* get job size */
ret = PMI_Get_size(&i);
if (PMI_SUCCESS != ret) {
OPAL_PMI_ERROR(ret, "PMI_Get_size");
goto err_exit;
}
OBJ_CONSTRUCT(&kv, opal_value_t);
kv.key = strdup(OPAL_PMIX_JOB_SIZE);
kv.type = OPAL_UINT32;
kv.data.uint32 = i;
if (OPAL_SUCCESS != (ret = opal_pmix_base_store(&OPAL_PROC_MY_NAME, &kv))) {
OPAL_ERROR_LOG(ret);
OBJ_DESTRUCT(&kv);
goto err_exit;
}
OBJ_DESTRUCT(&kv);
/* get appnum */
ret = PMI_Get_appnum(&i);
if (PMI_SUCCESS != ret) {
OPAL_PMI_ERROR(ret, "PMI_Get_appnum");
goto err_exit;
}
OBJ_CONSTRUCT(&kv, opal_value_t);
kv.key = strdup(OPAL_PMIX_APPNUM);
kv.type = OPAL_UINT32;
kv.data.uint32 = i;
if (OPAL_SUCCESS != (ret = opal_pmix_base_store(&OPAL_PROC_MY_NAME, &kv))) {
OPAL_ERROR_LOG(ret);
OBJ_DESTRUCT(&kv);
goto err_exit;
}
OBJ_DESTRUCT(&kv);
/* increment the init count */
++pmix_init_count;
return OPAL_SUCCESS;
err_exit:
PMI_Finalize();
return ret;
}
int MPID_Init(int *argc, char ***argv,
int threadlevel_requested, int *threadlevel_provided,
int *has_args, int *has_env)
{
int mpi_errno = MPI_SUCCESS;
int pg_rank, pg_size, pg_id_sz;
int appnum = -1;
/* int universe_size; */
int has_parent;
pscom_socket_t *socket;
pscom_err_t rc;
char *pg_id_name;
char *parent_port;
/* Call any and all MPID_Init type functions */
MPIR_Err_init();
MPIR_Datatype_init();
MPIR_Group_init();
mpid_debug_init();
assert(PSCOM_ANYPORT == -1); /* all codeplaces which depends on it are marked with: "assert(PSP_ANYPORT == -1);" */
MPIR_FUNC_VERBOSE_STATE_DECL(MPID_STATE_MPID_INIT);
MPIR_FUNC_VERBOSE_ENTER(MPID_STATE_MPID_INIT);
PMICALL(PMI_Init(&has_parent));
PMICALL(PMI_Get_rank(&pg_rank));
PMICALL(PMI_Get_size(&pg_size));
PMICALL(PMI_Get_appnum(&appnum));
*has_args = 1;
*has_env = 1;
/* without PMI_Get_universe_size() we see pmi error:
'[unset]: write_line error; fd=-1' in PMI_KVS_Get()! */
/* PMICALL(PMI_Get_universe_size(&universe_size)); */
if (pg_rank < 0) pg_rank = 0;
if (pg_size <= 0) pg_size = 1;
if (
#ifndef MPICH_IS_THREADED
1
#else
threadlevel_requested < MPI_THREAD_MULTIPLE
#endif
) {
rc = pscom_init(PSCOM_VERSION);
if (rc != PSCOM_SUCCESS) {
fprintf(stderr, "pscom_init(0x%04x) failed : %s\n",
PSCOM_VERSION,
pscom_err_str(rc));
exit(1);
}
} else {
rc = pscom_init_thread(PSCOM_VERSION);
if (rc != PSCOM_SUCCESS) {
fprintf(stderr, "pscom_init_thread(0x%04x) failed : %s\n",
PSCOM_VERSION,
pscom_err_str(rc));
exit(1);
}
}
/* Initialize the switches */
pscom_env_get_uint(&MPIDI_Process.env.enable_collectives, "PSP_COLLECTIVES");
#ifdef PSCOM_HAS_ON_DEMAND_CONNECTIONS
/* if (pg_size > 32) MPIDI_Process.env.enable_ondemand = 1; */
pscom_env_get_uint(&MPIDI_Process.env.enable_ondemand, "PSP_ONDEMAND");
#else
MPIDI_Process.env.enable_ondemand = 0;
#endif
/* enable_ondemand_spawn defaults to enable_ondemand */
MPIDI_Process.env.enable_ondemand_spawn = MPIDI_Process.env.enable_ondemand;
pscom_env_get_uint(&MPIDI_Process.env.enable_ondemand_spawn, "PSP_ONDEMAND_SPAWN");
/* take SMP-related locality information into account (e.g., for MPI_Win_allocate_shared) */
pscom_env_get_uint(&MPIDI_Process.env.enable_smp_awareness, "PSP_SMP_AWARENESS");
/* take MSA-related topology information into account */
pscom_env_get_uint(&MPIDI_Process.env.enable_msa_awareness, "PSP_MSA_AWARENESS");
if(MPIDI_Process.env.enable_msa_awareness) {
pscom_env_get_uint(&MPIDI_Process.msa_module_id, "PSP_MSA_MODULE_ID");
}
#ifdef MPID_PSP_TOPOLOGY_AWARE_COLLOPS
/* use hierarchy-aware collectives on SMP level */
pscom_env_get_uint(&MPIDI_Process.env.enable_smp_aware_collops, "PSP_SMP_AWARE_COLLOPS");
/* use hierarchy-aware collectives on MSA level (disables SMP-aware collops / FIX ME!) */
pscom_env_get_uint(&MPIDI_Process.env.enable_msa_aware_collops, "PSP_MSA_AWARE_COLLOPS");
if(MPIDI_Process.env.enable_msa_aware_collops) MPIDI_Process.env.enable_smp_aware_collops = 0;
#endif
#ifdef MPID_PSP_CREATE_HISTOGRAM
/* collect statistics information and print them at the end of a run */
pscom_env_get_uint(&MPIDI_Process.env.enable_histogram, "PSP_HISTOGRAM");
pscom_env_get_uint(&MPIDI_Process.histo.max_size, "PSP_HISTOGRAM_MAX");
pscom_env_get_uint(&MPIDI_Process.histo.min_size, "PSP_HISTOGRAM_MIN");
pscom_env_get_uint(&MPIDI_Process.histo.step_width, "PSP_HISTOGRAM_SHIFT");
#endif
/*
pscom_env_get_uint(&mpir_allgather_short_msg, "PSP_ALLGATHER_SHORT_MSG");
pscom_env_get_uint(&mpir_allgather_long_msg, "PSP_ALLGATHER_LONG_MSG");
pscom_env_get_uint(&mpir_allreduce_short_msg, "PSP_ALLREDUCE_SHORT_MSG");
pscom_env_get_uint(&mpir_alltoall_short_msg, "PSP_ALLTOALL_SHORT_MSG");
pscom_env_get_uint(&mpir_alltoall_medium_msg, "PSP_ALLTOALL_MEDIUM_MSG");
pscom_env_get_uint(&mpir_alltoall_throttle, "PSP_ALLTOALL_THROTTLE");
pscom_env_get_uint(&mpir_bcast_short_msg, "PSP_BCAST_SHORT_MSG");
pscom_env_get_uint(&mpir_bcast_long_msg, "PSP_BCAST_LONG_MSG");
pscom_env_get_uint(&mpir_bcast_min_procs, "PSP_BCAST_MIN_PROCS");
pscom_env_get_uint(&mpir_gather_short_msg, "PSP_GATHER_SHORT_MSG");
pscom_env_get_uint(&mpir_gather_vsmall_msg, "PSP_GATHER_VSMALL_MSG");
pscom_env_get_uint(&mpir_redscat_commutative_long_msg, "PSP_REDSCAT_COMMUTATIVE_LONG_MSG");
pscom_env_get_uint(&mpir_redscat_noncommutative_short_msg, "PSP_REDSCAT_NONCOMMUTATIVE_SHORT_MSG");
pscom_env_get_uint(&mpir_reduce_short_msg, "PSP_REDUCE_SHORT_MSG");
pscom_env_get_uint(&mpir_scatter_short_msg, "PSP_SCATTER_SHORT_MSG");
*/
socket = pscom_open_socket(0, 0);
if (!MPIDI_Process.env.enable_ondemand) {
socket->ops.con_accept = mpid_con_accept;
}
{
char name[10];
snprintf(name, sizeof(name), "r%07u", (unsigned)pg_rank);
pscom_socket_set_name(socket, name);
}
rc = pscom_listen(socket, PSCOM_ANYPORT);
if (rc != PSCOM_SUCCESS) { PRINTERROR("pscom_listen(PSCOM_ANYPORT)"); goto fn_fail; }
/* Note that if pmi is not availble, the value of MPI_APPNUM is not set */
/* if (appnum != -1) {*/
MPIR_Process.attrs.appnum = appnum;
/* }*/
#if 0
// see mpiimpl.h:
// typedef struct PreDefined_attrs {
// int appnum; /* Application number provided by mpiexec (MPI-2) */
// int host; /* host */
// int io; /* standard io allowed */
// int lastusedcode; /* last used error code (MPI-2) */
// int tag_ub; /* Maximum message tag */
// int universe; /* Universe size from mpiexec (MPI-2) */
// int wtime_is_global; /* Wtime is global over processes in COMM_WORLD */
// } PreDefined_attrs;
#endif
MPIR_Process.attrs.tag_ub = MPIDI_TAG_UB;
/* obtain the id of the process group */
PMICALL(PMI_KVS_Get_name_length_max(&pg_id_sz));
pg_id_name = MPL_malloc(pg_id_sz + 1, MPL_MEM_STRINGS);
if (!pg_id_name) { PRINTERROR("MPL_malloc()"); goto fn_fail; }
PMICALL(PMI_KVS_Get_my_name(pg_id_name, pg_id_sz));
/* safe */
/* MPIDI_Process.socket = socket; */
MPIDI_Process.my_pg_rank = pg_rank;
MPIDI_Process.my_pg_size = pg_size;
MPIDI_Process.pg_id_name = pg_id_name;
if (!MPIDI_Process.env.enable_ondemand) {
/* Create and establish all connections */
if (InitPortConnections(socket) != MPI_SUCCESS) goto fn_fail;
} else {
/* Create all connections as "on demand" connections. */
if (InitPscomConnections(socket) != MPI_SUCCESS) goto fn_fail;
}
#ifdef MPID_PSP_TOPOLOGY_AWARE_COLLOPS
{
int grank;
int my_node_id = -1;
int remote_node_id = -1;
int* node_id_table;
if(MPIDI_Process.env.enable_msa_awareness && MPIDI_Process.env.enable_msa_aware_collops) {
my_node_id = MPIDI_Process.msa_module_id;
assert(my_node_id > -1);
} else if(MPIDI_Process.env.enable_smp_awareness && MPIDI_Process.env.enable_smp_aware_collops) {
if (!MPIDI_Process.env.enable_ondemand) {
/* In the PSP_ONDEMAND=0 case, we can just check the pscom connection types: */
for (grank = 0; grank < pg_size; grank++) {
pscom_connection_t *con = grank2con_get(grank);
if( (con->type == PSCOM_CON_TYPE_SHM) || (pg_rank == grank) ) {
my_node_id = grank;
break;
}
}
} else {
/* In the PSP_ONDEMAND=1 case, we have to use a hash of the host name: */
my_node_id = MPID_PSP_get_host_hash();
if(my_node_id < 0) my_node_id *= -1;
}
assert(my_node_id > -1);
} else {
/* No hierarchy-awareness requested */
assert(my_node_id == -1);
}
if(my_node_id > -1) {
node_id_table = MPL_malloc(pg_size * sizeof(int), MPL_MEM_OBJECT);
if(pg_rank != 0) {
/* gather: */
pscom_connection_t *con = grank2con_get(0);
assert(con);
pscom_send(con, NULL, 0, &my_node_id, sizeof(int));
/* bcast: */
rc = pscom_recv_from(con, NULL, 0, node_id_table, pg_size*sizeof(int));
assert(rc == PSCOM_SUCCESS);
} else {
/* gather: */
node_id_table[0] = my_node_id;
for(grank=1; grank < pg_size; grank++) {
pscom_connection_t *con = grank2con_get(grank);
assert(con);
rc = pscom_recv_from(con, NULL, 0, &remote_node_id, sizeof(int));
assert(rc == PSCOM_SUCCESS);
node_id_table[grank] = remote_node_id;
}
/* bcast: */
for(grank=1; grank < pg_size; grank++) {
pscom_connection_t *con = grank2con_get(grank);
pscom_send(con, NULL, 0, node_id_table, pg_size*sizeof(int));
}
}
MPIDI_Process.node_id_table = node_id_table;
} else {
/* No hierarchy-awareness requested */
assert(MPIDI_Process.node_id_table == NULL);
}
}
#endif
/*
* Initialize the MPI_COMM_WORLD object
*/
{
MPIR_Comm * comm;
int grank;
MPIDI_PG_t * pg_ptr;
int pg_id_num;
MPIDI_VCRT_t * vcrt;
comm = MPIR_Process.comm_world;
comm->rank = pg_rank;
comm->remote_size = pg_size;
comm->local_size = pg_size;
comm->pscom_socket = socket;
vcrt = MPIDI_VCRT_Create(comm->remote_size);
assert(vcrt);
MPID_PSP_comm_set_vcrt(comm, vcrt);
MPIDI_PG_Convert_id(pg_id_name, &pg_id_num);
MPIDI_PG_Create(pg_size, pg_id_num, &pg_ptr);
assert(pg_ptr == MPIDI_Process.my_pg);
for (grank = 0; grank < pg_size; grank++) {
/* MPIR_CheckDisjointLpids() in mpi/comm/intercomm_create.c expect
lpid to be smaller than 4096!!!
Else you will see an "Fatal error in MPI_Intercomm_create"
*/
pscom_connection_t *con = grank2con_get(grank);
pg_ptr->vcr[grank] = MPIDI_VC_Create(pg_ptr, grank, con, grank);
comm->vcr[grank] = MPIDI_VC_Dup(pg_ptr->vcr[grank]);
}
mpi_errno = MPIR_Comm_commit(comm);
assert(mpi_errno == MPI_SUCCESS);
}
/*
* Initialize the MPI_COMM_SELF object
*/
{
MPIR_Comm * comm;
MPIDI_VCRT_t * vcrt;
comm = MPIR_Process.comm_self;
comm->rank = 0;
comm->remote_size = 1;
comm->local_size = 1;
comm->pscom_socket = socket;
vcrt = MPIDI_VCRT_Create(comm->remote_size);
assert(vcrt);
MPID_PSP_comm_set_vcrt(comm, vcrt);
comm->vcr[0] = MPIDI_VC_Dup(MPIR_Process.comm_world->vcr[pg_rank]);
mpi_errno = MPIR_Comm_commit(comm);
assert(mpi_errno == MPI_SUCCESS);
}
/* ToDo: move MPID_enable_receive_dispach to bg thread */
MPID_enable_receive_dispach(socket);
if (threadlevel_provided) {
*threadlevel_provided = (MPICH_THREAD_LEVEL < threadlevel_requested) ?
MPICH_THREAD_LEVEL : threadlevel_requested;
}
if (has_parent) {
MPIR_Comm * comm;
mpi_errno = MPID_PSP_GetParentPort(&parent_port);
assert(mpi_errno == MPI_SUCCESS);
/*
printf("%s:%u:%s Child with Parent: %s\n", __FILE__, __LINE__, __func__, parent_port);
*/
mpi_errno = MPID_Comm_connect(parent_port, NULL, 0,
MPIR_Process.comm_world, &comm);
if (mpi_errno != MPI_SUCCESS) {
fprintf(stderr, "MPI_Comm_connect(parent) failed!\n");
goto fn_fail;
}
assert(comm != NULL);
MPL_strncpy(comm->name, "MPI_COMM_PARENT", MPI_MAX_OBJECT_NAME);
MPIR_Process.comm_parent = comm;
}
MPID_PSP_shm_rma_init();
fn_exit:
MPIR_FUNC_VERBOSE_EXIT(MPID_STATE_MPID_INIT);
return mpi_errno;
/* --- */
fn_fail:
/* A failing MPI_Init() did'nt call the MPI error handler, which
mostly calls abort(). This cause MPI_Init() to return the mpi_errno,
which nobody check, causing segfaultm double frees and so on. To
prevent strange error messages, we now call _exit(1) here.
*/
_exit(1);
}
static bool cray_get_attr(const char *attr, opal_value_t **kv)
{
int rc, i;
opal_value_t *kp;
if (0 == strcmp(PMIX_JOBID, attr)) {
kp = OBJ_NEW(opal_value_t);
kp->key = strdup(attr);
kp->type = OPAL_UINT32;
kp->data.uint32 = pmix_jobid;
*kv = kp;
return true;
}
if (0 == strcmp(PMIX_RANK, attr)) {
rc = PMI_Get_rank(&i);
if( PMI_SUCCESS != rc ) {
OPAL_PMI_ERROR(rc, "PMI_Get_rank");
return false;
}
kp = OBJ_NEW(opal_value_t);
kp->key = strdup(attr);
kp->type = OPAL_UINT32;
kp->data.uint32 = i;
*kv = kp;
return true;
}
if (0 == strcmp(PMIX_UNIV_SIZE, attr)) {
rc = PMI_Get_universe_size(&i);
if( PMI_SUCCESS != rc ) {
OPAL_PMI_ERROR(rc, "PMI_Get_universe_size");
return false;
}
kp = OBJ_NEW(opal_value_t);
kp->key = strdup(attr);
kp->type = OPAL_UINT32;
kp->data.uint32 = i;
*kv = kp;
return true;
}
if (0 == strcmp(PMIX_JOB_SIZE, attr)) {
rc = PMI_Get_size(&i);
if( PMI_SUCCESS != rc ) {
OPAL_PMI_ERROR(rc, "PMI_Get_size");
return false;
}
kp = OBJ_NEW(opal_value_t);
kp->key = strdup(attr);
kp->type = OPAL_UINT32;
kp->data.uint32 = i;
*kv = kp;
return true;
}
if (0 == strcmp(PMIX_APPNUM, attr)) {
rc = PMI_Get_appnum(&i);
if( PMI_SUCCESS != rc ) {
OPAL_PMI_ERROR(rc, "PMI_Get_appnum");
return false;
}
kp = OBJ_NEW(opal_value_t);
kp->key = strdup(attr);
kp->type = OPAL_UINT32;
kp->data.uint32 = i;
*kv = kp;
return true;
}
if (0 == strcmp(PMIX_LOCAL_RANK, attr)) {
kp = OBJ_NEW(opal_value_t);
kp->key = strdup(attr);
kp->type = OPAL_UINT32;
kp->data.uint32 = pmix_lrank;
*kv = kp;
return true;
}
if (0 == strcmp(PMIX_NODE_RANK, attr)) {
kp = OBJ_NEW(opal_value_t);
kp->key = strdup(attr);
kp->type = OPAL_UINT32;
kp->data.uint32 = pmix_nrank;
*kv = kp;
return true;
}
if (0 == strcmp(PMIX_LOCAL_SIZE, attr)) {
kp = OBJ_NEW(opal_value_t);
kp->key = strdup(attr);
kp->type = OPAL_UINT32;
kp->data.uint32 = pmix_nlranks;
*kv = kp;
return true;
}
return OPAL_ERR_NOT_IMPLEMENTED;
}
static int test_item1(void)
{
int rc = 0;
int val = 0;
log_assert(spawned == PMI_FALSE || spawned == PMI_TRUE, "");
if (PMI_SUCCESS != (rc = PMI_Get_size(&size))) {
log_fatal("PMI_Get_Size failed: %d\n", rc);
return rc;
}
log_assert(size >= 0, "");
if (PMI_SUCCESS != (rc = PMI_Get_rank(&rank))) {
log_fatal("PMI_Get_Rank failed: %d\n", rc);
return rc;
}
log_assert(rank >= 0, "");
log_assert(rank < size, "");
if (PMI_SUCCESS != (rc = PMI_Get_appnum(&appnum))) {
log_fatal("PMI_Get_appnum failed: %d\n", rc);
return rc;
}
log_info("spawned=%d size=%d rank=%d appnum=%d\n", spawned, size, rank, appnum);
val = random_value(10, 100);
if (PMI_SUCCESS != (rc = PMI_Get_universe_size(&val))) {
log_fatal("PMI_Get_universe_size failed: %d\n", rc);
return rc;
}
log_assert(size == val, "");
val = random_value(10, 100);
if (PMI_SUCCESS != (rc = PMI_Get_id_length_max(&val))) {
log_fatal("PMI_Get_id_length_max failed: %d\n", rc);
return rc;
}
log_info("PMI_Get_id_length_max=%d\n", val);
if (!_legacy) {
log_assert(sizeof(jobid) == val, "Check PMIX_MAX_NSLEN value in pmix_common.h");
}
sprintf(jobid, "%s", __func__);
if (PMI_SUCCESS != (rc = PMI_Get_id(jobid, sizeof(jobid)))) {
log_fatal("PMI_Get_id failed: %d\n", rc);
return rc;
}
log_info("jobid=%s\n", jobid);
log_assert(memcmp(jobid, __func__, sizeof(__func__)), "");
sprintf(jobid, "%s", __func__);
if (PMI_SUCCESS != (rc = PMI_Get_kvs_domain_id(jobid, sizeof(jobid)))) {
log_fatal("PMI_Get_kvs_domain_id failed: %d\n", rc);
return rc;
}
log_info("PMI_Get_kvs_domain_id=%s\n", jobid);
log_assert(memcmp(jobid, __func__, sizeof(__func__)), "");
sprintf(jobid, "%s", __func__);
if (PMI_SUCCESS != (rc = PMI_KVS_Get_my_name(jobid, sizeof(jobid)))) {
log_fatal("PMI_KVS_Get_my_name failed: %d\n", rc);
return rc;
}
log_info("PMI_KVS_Get_my_name=%s\n", jobid);
log_assert(memcmp(jobid, __func__, sizeof(__func__)), "");
return rc;
}
int pmgr_init(int *argc_p, char ***argv_p, int *np_p, int *me_p, int *id_p)
{
setvbuf(stdout, NULL, _IONBF, 0);
char *value;
struct timeval start, end;
pmgr_gettimeofday(&start);
pmgr_echo_debug = 0;
pmgr_tree_init_null(&pmgr_tree_all);
/* =======================================================
* Until told otherwise, assume we are rank 0 of a 1-task MPI job
* this enables serial launching, e.g., "./mpiHello" vs "mpirun -np 1 ./mpiHello"
* TODO: may want to protect this usage via a compile flag and/or env var
* ======================================================= */
/* Take a stab at something unique for the id (timestamp.secs | pid)
* TODO: !!NOTE!!
* Using a pid in the jobid *ONLY* works for a single process job
* Obviously, multiple tasks will have different pids */
pmgr_id = 0x7FFFFFFF & ((start.tv_sec << 16) | (0x0000FFFF & getpid()));
pmgr_me = 0;
pmgr_nprocs = 1;
mpirun_hostname = NULL;
mpirun_port = 1;
/* =======================================================
* Get information from environment, not from the argument list
* ======================================================= */
/* if MPIRUN_RANK is set, require RANK, NPROCS, ID, HOST, and PORT to all be set */
/* this ensures that if one process aborts in a multitask job,
* then something is there to abort the others, namely the mpirun process */
if ((value = pmgr_getenv("MPIRUN_RANK", ENV_OPTIONAL)) != NULL) {
/* MPI rank of current process */
pmgr_me = atoi(pmgr_getenv("MPIRUN_RANK", ENV_REQUIRED));
/* number of MPI processes in job */
pmgr_nprocs = atoi(pmgr_getenv("MPIRUN_NPROCS", ENV_REQUIRED));
/* unique jobid of current application */
pmgr_id = atoi(pmgr_getenv("MPIRUN_ID", ENV_REQUIRED));
/* mpirun host IP string in dotted decimal notation */
mpirun_hostname = strdup(pmgr_getenv("MPIRUN_HOST", ENV_REQUIRED));
/* mpirun port number */
mpirun_port = atoi(pmgr_getenv("MPIRUN_PORT", ENV_REQUIRED));
}
if ((value = pmgr_getenv("MPIRUN_OPEN_TIMEOUT", ENV_OPTIONAL))) {
mpirun_open_timeout = atoi(value);
}
if ((value = pmgr_getenv("MPIRUN_CONNECT_TRIES", ENV_OPTIONAL))) {
mpirun_connect_tries = atoi(value);
}
/* seconds */
if ((value = pmgr_getenv("MPIRUN_CONNECT_TIMEOUT", ENV_OPTIONAL))) {
mpirun_connect_timeout = atoi(value);
}
/* seconds */
if ((value = pmgr_getenv("MPIRUN_CONNECT_BACKOFF", ENV_OPTIONAL))) {
mpirun_connect_backoff = atoi(value);
}
/* enable/disable radomized option in backoff */
if ((value = pmgr_getenv("MPIRUN_CONNECT_RANDOM", ENV_OPTIONAL))) {
mpirun_connect_random = atoi(value);
}
/* whether to connect tree from parent to children (down) or children to parent (up) */
if ((value = pmgr_getenv("MPIRUN_CONNECT_DOWN", ENV_OPTIONAL))) {
mpirun_connect_down = atoi(value);
}
/* MPIRUN_USE_TREES={0,1} disables/enables tree algorithms */
if ((value = pmgr_getenv("MPIRUN_USE_TREES", ENV_OPTIONAL))) {
mpirun_use_trees = atoi(value);
}
/* use pmi instead of socket connections to mpirun */
if ((value = pmgr_getenv("MPIRUN_PMI_ENABLE", ENV_OPTIONAL))) {
#ifdef HAVE_PMI
mpirun_pmi_enable = atoi(value);
#else /* ifdef HAVE_PMI */
/* PMI was not compiled in, warn user that we're ignoring this value */
if (pmgr_me == 0) {
pmgr_error("Not built with PMI support, ignoring MPIRUN_USE_PMI @ %s:%d",
__FILE__, __LINE__
);
}
#endif /* ifdef HAVE_PMI */
}
/* whether to use /dev/shm to start jobs */
if ((value = pmgr_getenv("MPIRUN_SHM_ENABLE", ENV_OPTIONAL))) {
mpirun_shm_enable = atoi(value);
}
/* minimum number of tasks to switch to /dev/shm */
if ((value = pmgr_getenv("MPIRUN_SHM_THRESHOLD", ENV_OPTIONAL))) {
mpirun_shm_threshold = atoi(value);
}
/* whether to authenticate connections */
if ((value = pmgr_getenv("MPIRUN_AUTHENTICATE_ENABLE", ENV_OPTIONAL))) {
mpirun_authenticate_enable = atoi(value);
}
/* time to wait for a reply when authenticating a new connection (miilisecs) */
if ((value = pmgr_getenv("MPIRUN_AUTHENTICATE_TIMEOUT", ENV_OPTIONAL))) {
mpirun_authenticate_timeout = atoi(value);
}
/* total time to attempt to connect to a host before aborting (seconds) */
if ((value = pmgr_getenv("MPIRUN_PORT_SCAN_TIMEOUT", ENV_OPTIONAL))) {
mpirun_port_scan_timeout = atoi(value);
}
/* time to wait on connect call before giving up (millisecs) */
if ((value = pmgr_getenv("MPIRUN_PORT_SCAN_CONNECT_TIMEOUT", ENV_OPTIONAL))) {
mpirun_port_scan_connect_timeout = atoi(value);
}
/* number of times to attempt connect call to given IP:port */
if ((value = pmgr_getenv("MPIRUN_PORT_SCAN_CONNECT_ATTEMPTS", ENV_OPTIONAL))) {
mpirun_port_scan_connect_attempts = atoi(value);
}
/* time to wait between making consecutive connect attempts to a given IP:port (millisecs) */
if ((value = pmgr_getenv("MPIRUN_PORT_SCAN_CONNECT_SLEEP", ENV_OPTIONAL))) {
mpirun_port_scan_connect_sleep = atoi(value);
}
/* initialize PMI library if we're using it, and get rank, ranks, and jobid from PMI */
if (mpirun_pmi_enable) {
#ifdef HAVE_PMI
/* initialize the PMI library */
int spawned = 0;
if (PMI_Init(&spawned) != PMI_SUCCESS) {
pmgr_error("Failed to initialize PMI library @ file %s:%d",
__FILE__, __LINE__
);
PMI_Abort(1, "Failed to initialize PMI library");
}
if (spawned) {
pmgr_error("Spawned processes not supported @ file %s:%d",
__FILE__, __LINE__
);
PMI_Abort(1, "Spawned processes not supported");
}
/* get my rank */
if (PMI_Get_rank(&pmgr_me) != PMI_SUCCESS) {
pmgr_error("Getting rank @ file %s:%d",
__FILE__, __LINE__
);
PMI_Abort(1, "Failed to get rank from PMI");
}
/* get the number of ranks in this job */
if (PMI_Get_size(&pmgr_nprocs) != PMI_SUCCESS) {
pmgr_error("Getting number of ranks in job @ file %s:%d",
__FILE__, __LINE__
);
PMI_Abort(1, "Failed to get number of ranks in job");
}
/* get jobid */
if (PMI_Get_appnum(&pmgr_id) != PMI_SUCCESS) {
pmgr_error("Getting job id @ file %s:%d",
__FILE__, __LINE__
);
PMI_Abort(1, "Failed to get job id from PMI");
}
#endif /* ifdef HAVE_PMI */
}
/* =======================================================
* Check that we have valid values
* ======================================================= */
/* MPIRUN_CLIENT_DEBUG={0,1} disables/enables debug statements */
/* this comes *after* MPIRUN_RANK and MPIRUN_NPROCS since those are used to print debug messages */
if ((value = pmgr_getenv("MPIRUN_CLIENT_DEBUG", ENV_OPTIONAL)) != NULL) {
pmgr_echo_debug = atoi(value);
int print_rank = 0;
if (pmgr_echo_debug > 0) {
if (pmgr_echo_debug <= 1*PMGR_DEBUG_LEVELS) {
print_rank = (pmgr_me == 0); /* just rank 0 prints */
} else if (pmgr_echo_debug <= 2*PMGR_DEBUG_LEVELS) {
print_rank = (pmgr_me == 0 || pmgr_me == pmgr_nprocs-1); /* just rank 0 and rank N-1 print */
} else {
print_rank = 1; /* all ranks print */
}
if (print_rank) {
pmgr_echo_debug = 1 + (pmgr_echo_debug-1) % PMGR_DEBUG_LEVELS;
} else {
pmgr_echo_debug = 0;
}
}
}
/* check that we have a valid number of processes */
if (pmgr_nprocs <= 0) {
pmgr_error("Invalid NPROCS %s @ file %s:%d",
pmgr_nprocs, __FILE__, __LINE__
);
exit(1);
}
/* check that our rank is valid */
if (pmgr_me < 0 || pmgr_me >= pmgr_nprocs) {
pmgr_error("Invalid RANK %s @ file %s:%d",
pmgr_me, __FILE__, __LINE__
);
exit(1);
}
/* check that we have a valid jobid */
if (pmgr_id == 0) {
pmgr_error("Invalid JOBID %s @ file %s:%d",
pmgr_id, __FILE__, __LINE__
);
exit(1);
}
/* set parameters */
*np_p = pmgr_nprocs;
*me_p = pmgr_me;
*id_p = pmgr_id;
pmgr_gettimeofday(&end);
pmgr_debug(2, "Exiting pmgr_init(), took %f seconds for %d procs", pmgr_getsecs(&end,&start), pmgr_nprocs);
return PMGR_SUCCESS;
}
static int s1_init(void)
{
PMI_BOOL initialized;
int spawned;
int rc, ret = OPAL_ERROR;
int i;
char *pmix_id, *tmp;
uint32_t jobfam, stepid;
opal_value_t kv;
if (PMI_SUCCESS != (rc = PMI_Initialized(&initialized))) {
OPAL_PMI_ERROR(rc, "PMI_Initialized");
return OPAL_ERROR;
}
if( PMI_TRUE != initialized && PMI_SUCCESS != (rc = PMI_Init(&spawned)) ) {
OPAL_PMI_ERROR(rc, "PMI_Init");
return OPAL_ERROR;
}
// Initialize space demands
rc = PMI_KVS_Get_value_length_max(&pmix_vallen_max);
if( PMI_SUCCESS != rc ) {
OPAL_PMI_ERROR(rc, "PMI_KVS_Get_value_length_max");
goto err_exit;
}
rc = PMI_KVS_Get_name_length_max(&pmix_kvslen_max);
if (PMI_SUCCESS != rc ) {
OPAL_PMI_ERROR(rc, "PMI_KVS_Get_name_length_max");
goto err_exit;
}
rc = PMI_KVS_Get_key_length_max(&pmix_keylen_max);
if( PMI_SUCCESS != rc ) {
OPAL_PMI_ERROR(rc, "PMI_KVS_Get_key_length_max");
goto err_exit;
}
// Initialize job environment information
pmix_id = (char*)malloc(pmix_vallen_max);
if( pmix_id == NULL ){
ret = OPAL_ERR_OUT_OF_RESOURCE;
goto err_exit;
}
/* Get domain id */
if (PMI_SUCCESS != (rc = PMI_Get_kvs_domain_id(pmix_id, pmix_vallen_max))) {
free(pmix_id);
goto err_exit;
}
/* Slurm PMI provides the job id as an integer followed
* by a '.', followed by essentially a stepid. The first integer
* defines an overall job number. The second integer is the number of
* individual jobs we have run within that allocation. So we translate
* this as the overall job number equating to our job family, and
* the individual number equating to our local jobid
*/
jobfam = strtoul(pmix_id, &tmp, 10);
if (NULL == tmp) {
/* hmmm - no '.', so let's just use zero */
stepid = 0;
} else {
tmp++; /* step over the '.' */
stepid = strtoul(tmp, NULL, 10);
}
/* now build the jobid */
s1_jobid = (jobfam << 16) | stepid;
free(pmix_id);
/* get our rank */
ret = PMI_Get_rank(&s1_rank);
if( PMI_SUCCESS != ret ) {
OPAL_PMI_ERROR(ret, "PMI_Get_rank");
goto err_exit;
}
/* store our name in the opal_proc_t so that
* debug messages will make sense - an upper
* layer will eventually overwrite it, but that
* won't do any harm */
s1_pname.jid = s1_jobid;
s1_pname.vid = s1_rank;
opal_proc_set_name((opal_process_name_t*)&s1_pname);
opal_output_verbose(2, opal_pmix_base_framework.framework_output,
"%s pmix:s1: assigned tmp name",
OPAL_NAME_PRINT(*(opal_process_name_t*)&s1_pname));
pmix_kvs_name = (char*)malloc(pmix_kvslen_max);
if( pmix_kvs_name == NULL ){
ret = OPAL_ERR_OUT_OF_RESOURCE;
goto err_exit;
}
rc = PMI_KVS_Get_my_name(pmix_kvs_name, pmix_kvslen_max);
if( PMI_SUCCESS != rc ) {
OPAL_PMI_ERROR(rc, "PMI_KVS_Get_my_name");
goto err_exit;
}
/* get our local proc info to find our local rank */
if (PMI_SUCCESS != (rc = PMI_Get_clique_size(&s1_nlranks))) {
OPAL_PMI_ERROR(rc, "PMI_Get_clique_size");
return rc;
}
/* now get the specific ranks */
s1_lranks = (int*)calloc(s1_nlranks, sizeof(int));
if (NULL == s1_lranks) {
rc = OPAL_ERR_OUT_OF_RESOURCE;
OPAL_ERROR_LOG(rc);
return rc;
}
if (PMI_SUCCESS != (rc = PMI_Get_clique_ranks(s1_lranks, s1_nlranks))) {
OPAL_PMI_ERROR(rc, "PMI_Get_clique_ranks");
free(s1_lranks);
return rc;
}
/* find ourselves */
for (i=0; i < s1_nlranks; i++) {
if (s1_rank == s1_lranks[i]) {
s1_lrank = i;
s1_nrank = i;
break;
}
}
/* get universe size */
ret = PMI_Get_universe_size(&s1_usize);
if (PMI_SUCCESS != ret) {
OPAL_PMI_ERROR(ret, "PMI_Get_universe_size");
goto err_exit;
}
/* push this into the dstore for subsequent fetches */
OBJ_CONSTRUCT(&kv, opal_value_t);
kv.key = strdup(OPAL_DSTORE_UNIV_SIZE);
kv.type = OPAL_UINT32;
kv.data.uint32 = s1_usize;
if (OPAL_SUCCESS != (ret = opal_dstore.store(opal_dstore_internal, &OPAL_PROC_MY_NAME, &kv))) {
OPAL_ERROR_LOG(ret);
OBJ_DESTRUCT(&kv);
goto err_exit;
}
OBJ_DESTRUCT(&kv);
/* get job size */
ret = PMI_Get_size(&s1_jsize);
if (PMI_SUCCESS != ret) {
OPAL_PMI_ERROR(ret, "PMI_Get_size");
goto err_exit;
}
/* get appnum */
ret = PMI_Get_appnum(&s1_appnum);
if (PMI_SUCCESS != ret) {
OPAL_PMI_ERROR(ret, "PMI_Get_appnum");
goto err_exit;
}
return OPAL_SUCCESS;
err_exit:
PMI_Finalize();
return ret;
}
static int mca_initialize_pmi_v1(void)
{
PMI_BOOL initialized;
int spawned;
int rc, ret = OPAL_ERROR;
if (PMI_SUCCESS != (rc = PMI_Initialized(&initialized))) {
OPAL_PMI_ERROR(rc, "PMI_Initialized");
return OPAL_ERROR;
}
if( PMI_TRUE != initialized && PMI_SUCCESS != (rc = PMI_Init(&spawned)) ) {
OPAL_PMI_ERROR(rc, "PMI_Init");
return OPAL_ERROR;
}
// Initialize space demands
rc = PMI_KVS_Get_value_length_max(&pmi_vallen_max);
if( PMI_SUCCESS != rc ) {
OPAL_PMI_ERROR(rc, "PMI_KVS_Get_value_length_max");
goto err_exit;
}
rc = PMI_KVS_Get_name_length_max(&pmi_kvslen_max);
if (PMI_SUCCESS != rc ) {
OPAL_PMI_ERROR(rc, "PMI_KVS_Get_name_length_max");
goto err_exit;
}
rc = PMI_KVS_Get_key_length_max(&pmi_keylen_max);
if( PMI_SUCCESS != rc ) {
OPAL_PMI_ERROR(rc, "PMI_KVS_Get_key_length_max");
goto err_exit;
}
// Initialize job environment information
rc = PMI_Get_rank(&pmi_rank);
if( PMI_SUCCESS != rc ) {
OPAL_PMI_ERROR(rc, "PMI_Get_rank");
return OPAL_ERROR;
}
rc = PMI_Get_universe_size(&pmi_usize);
if( PMI_SUCCESS != rc ) {
OPAL_PMI_ERROR(rc, "PMI_Get_universe_size");
goto err_exit;
}
rc = PMI_Get_size(&pmi_size);
if( PMI_SUCCESS != rc ) {
OPAL_PMI_ERROR(rc, "PMI_Get_size");
goto err_exit;
}
rc = PMI_Get_appnum(&pmi_appnum);
if( PMI_SUCCESS != rc ) {
OPAL_PMI_ERROR(rc, "PMI_Get_appnum");
goto err_exit;
}
pmi_kvs_name = (char*)malloc(pmi_kvslen_max);
if( pmi_kvs_name == NULL ){
ret = OPAL_ERR_OUT_OF_RESOURCE;
goto err_exit;
}
rc = PMI_KVS_Get_my_name(pmi_kvs_name,pmi_kvslen_max);
if( PMI_SUCCESS != rc ) {
OPAL_PMI_ERROR(rc, "PMI2_Job_GetId");
goto err_exit;
}
return OPAL_SUCCESS;
err_exit:
PMI_Finalize();
return ret;
}
