/*
* This is the client side of the PMIserver setup. It communicates to the
* client the information needed to connect to the server (currently the
* FD of a pre-existing socket).
*
* The env_pmi_fd and port must be static because putenv doesn't make a copy
* of them. It is ok to use static variable since this is called only within
* the client; this routine will be called only once (in the forked process,
* before the exec).
*
* Another wrinkle is that in order to support -(g)envnone (no environment
* variables in context of created process), we need to add the environment
* variables to the ones set *after* environment variables are removed, rather
* than using putenv.
*/
int PMISetupInClient( int usePort, PMISetup *pmiinfo )
{
static char env_pmi_fd[100];
static char env_pmi_port[1024];
if (usePort == 0) {
close( pmiinfo->fdpair[0] );
MPIU_Snprintf( env_pmi_fd, sizeof(env_pmi_fd), "PMI_FD=%d" ,
pmiinfo->fdpair[1] );
if (MPIE_Putenv( pmiinfo->pWorld, env_pmi_fd )) {
MPIU_Internal_error_printf( "Could not set environment PMI_FD" );
return 1;
}
}
else {
/* We must communicate the port name to the process */
if (pmiinfo->portName) {
MPIU_Snprintf( env_pmi_port, sizeof(env_pmi_port), "PMI_PORT=%s",
pmiinfo->portName );
if (MPIE_Putenv( pmiinfo->pWorld, env_pmi_port )) {
MPIU_Internal_error_printf( "Could not set environment PMI_PORT" );
perror( "Reason: " );
return 1;
}
}
else {
MPIU_Internal_error_printf( "Required portname was not defined\n" );
return 1;
}
}
/* Indicate that this is a spawned process */
/* MPIE_Putenv( pmiinfo->pWorld, "PMI_SPAWNED=1" ); */
return 0;
}
static int getConnInfoKVS( int rank, char *buf, int bufsize, MPIDI_PG_t *pg )
{
#ifdef USE_PMI2_API
char key[MPIDI_MAX_KVS_KEY_LEN];
int mpi_errno = MPI_SUCCESS, rc;
int vallen;
rc = MPIU_Snprintf(key, MPIDI_MAX_KVS_KEY_LEN, "P%d-businesscard", rank );
if (rc < 0 || rc > MPIDI_MAX_KVS_KEY_LEN) {
MPIU_ERR_SETANDJUMP(mpi_errno,MPI_ERR_OTHER,"**nomem");
}
mpi_errno = PMI2_KVS_Get(pg->connData, PMI2_ID_NULL, key, buf, bufsize, &vallen);
if (mpi_errno) {
MPIDI_PG_CheckForSingleton();
mpi_errno = PMI2_KVS_Get(pg->connData, PMI2_ID_NULL, key, buf, bufsize, &vallen);
if (mpi_errno) MPIU_ERR_POP(mpi_errno);
}
fn_exit:
return mpi_errno;
fn_fail:
goto fn_exit;
#else
char key[MPIDI_MAX_KVS_KEY_LEN];
int mpi_errno = MPI_SUCCESS, rc, pmi_errno;
rc = MPIU_Snprintf(key, MPIDI_MAX_KVS_KEY_LEN, "P%d-businesscard", rank );
if (rc < 0 || rc > MPIDI_MAX_KVS_KEY_LEN) {
MPIU_ERR_SETANDJUMP(mpi_errno,MPI_ERR_OTHER,"**nomem");
}
MPIU_THREAD_CS_ENTER(PMI,);
pmi_errno = PMI_KVS_Get(pg->connData, key, buf, bufsize );
if (pmi_errno) {
MPIDI_PG_CheckForSingleton();
pmi_errno = PMI_KVS_Get(pg->connData, key, buf, bufsize );
}
MPIU_THREAD_CS_EXIT(PMI,);
if (pmi_errno) {
MPIU_ERR_SETANDJUMP(mpi_errno,MPI_ERR_OTHER,"**pmi_kvs_get");
}
fn_exit:
return mpi_errno;
fn_fail:
goto fn_exit;
#endif
}
int main( int argc, char *argv[] )
{
char buf[1000];
int n;
n = MPIU_Snprintf( buf, 100, "This is a test\n" );
printf( "%d:%s", n, buf );
n = MPIU_Snprintf( buf, 100, "This is a test %d\n", 3000000 );
printf( "%d:%s", n, buf );
n = MPIU_Snprintf( buf, 100, "This %s %% %d\n", "is a test for ", -3000 );
printf( "%d:%s", n, buf );
return 0;
}
static int restore_env(pid_t parent_pid, int rank)
{
FILE *f;
char env_filename[MAX_STR_LEN];
char var_val[MAX_STR_LEN];
int ret;
MPIU_Snprintf(env_filename, MAX_STR_LEN, "/tmp/hydra-env-file-%d:%d", parent_pid, rank);
f = fopen(env_filename, "r");
CHECK_ERR(!f, MPIU_Strerror (errno));
ret = unlink(env_filename);
CHECK_ERR(ret, MPIU_Strerror (errno));
while (fgets(var_val, MAX_STR_LEN, f)) {
size_t len = strlen(var_val);
/* remove newline */
if (var_val[len-1] == '\n')
var_val[len-1] = '\0';
ret = MPL_putenv(MPIU_Strdup(var_val));
CHECK_ERR(ret != 0, MPIU_Strerror (errno));
}
ret = fclose(f);
CHECK_ERR(ret, MPIU_Strerror (errno));
return 0;
}
/* This function formats the environment strings of the form,
* foo1=bar1 foo2=bar2 foo3=bar3
* TO
* "foo1=bar1" "foo2=bar2" "foo3=bar3"
* and returns the length of the formatted string
* Note: The formatted string contains a space in the front
*/
static int FmtEnvVarsForSSH(char *bEnv, char *fmtEnv, int fmtEnvLen)
{
char name[SMPD_MAX_ENV_LENGTH], equals[3], value[SMPD_MAX_ENV_LENGTH];
int curLen = 0, totLen = 0;
smpd_enter_fn(FCNAME);
if(fmtEnv && bEnv){
for (;;)
{
name[0] = '\0';
equals[0] = '\0';
value[0] = '\0';
if(fmtEnvLen <= 0)
break;
if (MPIU_Str_get_string(&bEnv, name, SMPD_MAX_ENV_LENGTH) != MPIU_STR_SUCCESS)
break;
if (name[0] == '\0')
break;
if (MPIU_Str_get_string(&bEnv, equals, 3) != MPIU_STR_SUCCESS)
break;
if (equals[0] == '\0')
break;
if (MPIU_Str_get_string(&bEnv, value, SMPD_MAX_ENV_LENGTH) != MPIU_STR_SUCCESS)
break;
MPIU_Snprintf(fmtEnv, fmtEnvLen, " \"%s=%s\"", name, value);
curLen = strlen(fmtEnv);
totLen += curLen;
fmtEnv += curLen;
fmtEnvLen -= curLen;
}
}
smpd_exit_fn(FCNAME);
return totLen;
}
char * get_sock_error_string(int error)
{
static char str[1024];
if (error == SMPD_SUCCESS){
return "operation completed successfully";
}
else{
/* FIXME : For now ... translate correctly later */
MPIU_Snprintf(str, 1024, "Error = %d\n", error);
return str;
}
/* str[0] = '\0'; */
/*
SMPDR_Err_get_string(error, str, 1024, SMPDU_Sock_get_error_class_string);
*/
/* smpd_translate_win_error(error, str, 1024, "(error =", error, ") "); */
/*
SMPDR_Err_get_string_ext(error, str, 1024, SMPDU_Sock_get_error_class_string);
if (SMPDR_Err_print_stack_flag)
{
char *str2;
int len;
strcat(str, "\n");
len = (int)strlen(str);
str2 = str + len;
SMPDR_Err_print_stack_string_ext(error, str2, 1024-len, SMPDU_Sock_get_error_class_string);
}
*/
/* return str; */
}
void MPIDU_Ftb_publish_me(const char *event_name)
{
char payload[FTB_MAX_PAYLOAD_DATA] = "";
MPIU_Snprintf(payload, sizeof(payload), "[id: {%s:{%d}}]", (char *)MPIDI_Process.my_pg->id, MPIDI_Process.my_pg_rank);
MPIDU_Ftb_publish(event_name, payload);
return;
}
void MPIDU_Ftb_publish_vc(const char *event_name, struct MPIDI_VC *vc)
{
char payload[FTB_MAX_PAYLOAD_DATA] = "";
if (vc && vc->pg) /* pg can be null for temp VCs (dynamic processes) */
MPIU_Snprintf(payload, sizeof(payload), "[id: {%s:{%d}}]", (char*)vc->pg->id, vc->pg_rank);
MPIDU_Ftb_publish(event_name, payload);
return;
}
/*
* Handle incoming "getbyidx" command
*/
static int fPMI_Handle_getbyidx( PMIProcess *pentry )
{
int j, jNext, rc=0;
PMIKVSpace *kvs;
char kvsname[MAXKVSNAME], j_char[8], outbuf[PMIU_MAXLINE];
PMIKVPair *p;
PMIU_getval( "kvsname", kvsname, MAXKVSNAME );
kvs = fPMIKVSFindSpace( kvsname );
if (kvs) {
PMIU_getval( "idx", j_char, sizeof(j_char) );
j = atoi( j_char );
jNext = j+1;
if (kvs->lastIdx >= 0 && j >= kvs->lastIdx) {
for (p = kvs->lastByIdx, j-= kvs->lastIdx; j-- > 0 && p;
p = p->nextPair );
}
else {
for (p = kvs->pairs; j-- > 0 && p; p = p->nextPair) ;
}
if (p) {
MPIU_Snprintf( outbuf, PMIU_MAXLINE, "cmd=getbyidx_results "
"rc=0 nextidx=%d key=%s val=%s\n",
jNext, p->key, p->val );
kvs->lastIdx = jNext-1;
kvs->lastByIdx = p;
}
else {
MPIU_Snprintf( outbuf, PMIU_MAXLINE, "cmd=getbyidx_results rc=-1 "
"reason=no_more_keyvals\n" );
kvs->lastIdx = -1;
kvs->lastByIdx = 0;
}
}
else {
rc = -1;
MPIU_Snprintf( outbuf, PMIU_MAXLINE, "cmd=getbyidx_results rc=-1 "
"reason=kvs_%s_not_found\n", kvsname );
}
PMIWriteLine( pentry->fd, outbuf );
DBG_PRINTFCOND(pmidebug,( "%s", outbuf ));
return rc;
}
/* Handle an incoming get_universe_size command */
static int fPMI_Handle_get_universe_size( PMIProcess *pentry )
{
char outbuf[PMIU_MAXLINE];
/* Import the universe size from the process structures */
MPIU_Snprintf( outbuf, PMIU_MAXLINE, "cmd=universe_size size=%d\n",
pUniv.size );
PMIWriteLine( pentry->fd, outbuf );
DBG_PRINTFCOND(pmidebug,( "%s", outbuf ));
return 0;
}
/* pretty prints tag, returns out for calling convenience */
static char *tag_val_to_str(int tag, char *out, int max)
{
if (tag == MPI_ANY_TAG) {
MPIU_Strncpy(out, "MPI_ANY_TAG", max);
}
else {
MPIU_Snprintf(out, max, "%d", tag);
}
return out;
}
/* Handle an incoming "get_maxes" command */
static int fPMI_Handle_get_maxes( PMIProcess *pentry )
{
char outbuf[PMIU_MAXLINE];
MPIU_Snprintf( outbuf, PMIU_MAXLINE,
"cmd=maxes kvsname_max=%d keylen_max=%d vallen_max=%d\n",
MAXKVSNAME, MAXKEYLEN, MAXVALLEN );
PMIWriteLine( pentry->fd, outbuf );
DBG_PRINTFCOND(pmidebug,( "%s", outbuf ));
return 0;
}
/* Handle an incoming get_appnum command */
static int fPMI_Handle_get_appnum( PMIProcess *pentry )
{
ProcessApp *app = pentry->pState->app;
char outbuf[PMIU_MAXLINE];
MPIU_Snprintf( outbuf, PMIU_MAXLINE, "cmd=appnum appnum=%d\n",
app->myAppNum );
PMIWriteLine( pentry->fd, outbuf );
DBG_PRINTFCOND(pmidebug,( "%s", outbuf ));
return 0;
}
/* pretty prints rank, returns out for calling convenience */
static char *rank_val_to_str(int rank, char *out, int max)
{
if (rank == MPI_ANY_SOURCE) {
MPIU_Strncpy(out, "MPI_ANY_SOURCE", max);
}
else {
MPIU_Snprintf(out, max, "%d", rank);
}
return out;
}
/*
* These routines are called when communication is established through
* a port instead of an fd, and no information is communicated
* through environment variables.
*/
static int fPMI_Handle_init_port( PMIProcess *pentry )
{
char outbuf[PMIU_MAXLINE];
DBG_PRINTFCOND(pmidebug,
( "Entering fPMI_Handle_init_port to start connection\n" ));
/* simple_pmi wants to see cmd=initack after the initack request before
the other data */
PMIWriteLine( pentry->fd, "cmd=initack\n" );
MPIU_Snprintf( outbuf, PMIU_MAXLINE, "cmd=set size=%d\n",
pentry->group->nProcess );
PMIWriteLine( pentry->fd, outbuf );
MPIU_Snprintf( outbuf, PMIU_MAXLINE, "cmd=set rank=%d\n",
pentry->pState->wRank );
PMIWriteLine( pentry->fd, outbuf );
MPIU_Snprintf( outbuf, PMIU_MAXLINE, "cmd=set debug=%d\n", pmidebug );
PMIWriteLine( pentry->fd, outbuf );
return 0;
}
/* ------------------------------------------------------------------------- */
static int fPMI_Handle_finalize( PMIProcess *pentry )
{
char outbuf[PMIU_MAXLINE];
pentry->pState->status = PROCESS_FINALIZED;
/* send back an acknowledgement to release the process */
MPIU_Snprintf(outbuf, PMIU_MAXLINE, "cmd=finalize_ack\n");
PMIWriteLine(pentry->fd, outbuf);
return 0;
}
/*
* Handle an incoming "put" command
*/
static int fPMI_Handle_put( PMIProcess *pentry )
{
int rc=0;
PMIKVSpace *kvs;
char kvsname[MAXKVSNAME];
char message[PMIU_MAXLINE], outbuf[PMIU_MAXLINE];
char key[MAXKEYLEN], val[MAXVALLEN];
PMIU_getval( "kvsname", kvsname, MAXKVSNAME );
DBG_PRINTFCOND(pmidebug,( "Put: Finding kvs %s\n", kvsname ) );
kvs = fPMIKVSFindSpace( kvsname );
if (kvs) {
/* should check here for duplicate key and raise error */
PMIU_getval( "key", key, MAXKEYLEN );
PMIU_getval( "value", val, MAXVALLEN );
rc = fPMIKVSAddPair( kvs, key, val );
if (rc == 1) {
rc = -1; /* no duplicate keys allowed */
MPIU_Snprintf( message, PMIU_MAXLINE, "duplicate_key %s", key );
}
else if (rc == -1) {
rc = -1;
MPIU_Snprintf( message, PMIU_MAXLINE, "no_room_in_kvs_%s",
kvsname );
}
else {
rc = 0;
MPIU_Strncpy( message, "success", PMIU_MAXLINE );
}
}
else {
rc = -1;
MPIU_Snprintf( message, PMIU_MAXLINE, "kvs_%s_not_found", kvsname );
}
MPIU_Snprintf( outbuf, PMIU_MAXLINE, "cmd=put_result rc=%d msg=%s\n",
rc, message );
PMIWriteLine( pentry->fd, outbuf );
return 0;
}
/*
* Handle incoming "get" command
*/
static int fPMI_Handle_get( PMIProcess *pentry )
{
PMIKVSpace *kvs;
int rc=0;
char kvsname[MAXKVSNAME];
char message[PMIU_MAXLINE], key[PMIU_MAXLINE], value[PMIU_MAXLINE];
char outbuf[PMIU_MAXLINE];
PMIU_getval( "kvsname", kvsname, MAXKVSNAME );
DBG_PRINTFCOND(pmidebug,( "Get: Finding kvs %s\n", kvsname ) );
kvs = fPMIKVSFindSpace( kvsname );
if (kvs) {
PMIU_getval( "key", key, PMIU_MAXLINE );
/* Here we could intercept internal keys, e.g.,
pmiPrivate keys. */
rc = fPMIKVSFindKey( kvs, key, value, sizeof(value) );
if (rc == 0) {
rc = 0;
MPIU_Strncpy( message, "success", PMIU_MAXLINE );
}
else if (rc) {
rc = -1;
MPIU_Strncpy( value, "unknown", PMIU_MAXLINE );
MPIU_Snprintf( message, PMIU_MAXLINE, "key_%s_not_found",
kvsname );
}
}
else {
rc = -1;
MPIU_Strncpy( value, "unknown", PMIU_MAXLINE );
MPIU_Snprintf( message, PMIU_MAXLINE, "kvs_%s_not_found", kvsname );
}
MPIU_Snprintf( outbuf, PMIU_MAXLINE,
"cmd=get_result rc=%d msg=%s value=%s\n",
rc, message, value );
PMIWriteLine( pentry->fd, outbuf );
DBG_PRINTFCOND( pmidebug, ("%s", outbuf ));
return rc;
}
/*
* Handle an incoming "destroy_kvs" command
*/
static int fPMI_Handle_destroy_kvs( PMIProcess *pentry )
{
int rc=0;
PMIKVSpace *kvs;
char kvsname[MAXKVSNAME];
char message[PMIU_MAXLINE], outbuf[PMIU_MAXLINE];
PMIU_getval( "kvsname", kvsname, MAXKVSNAME );
kvs = fPMIKVSFindSpace( kvsname );
if (kvs) {
PMIKVSFree( kvs );
MPIU_Snprintf( message, PMIU_MAXLINE,
"KVS_%s_successfully_destroyed", kvsname );
}
else {
MPIU_Snprintf( message, PMIU_MAXLINE, "KVS %s not found", kvsname );
rc = -1;
}
MPIU_Snprintf( outbuf, PMIU_MAXLINE, "cmd=kvs_destroyed rc=%d msg=%s\n",
rc, message );
PMIWriteLine( pentry->fd, outbuf );
return 0;
}
/*
* Handle an incoming "create_kvs" command
*/
static int fPMI_Handle_create_kvs( PMIProcess *pentry )
{
char kvsname[MAXKVSNAME], outbuf[PMIU_MAXLINE];
int rc;
rc = fPMIKVSGetNewSpace( kvsname, sizeof(kvsname) );
if (rc) {
/* PANIC - allocation failed */
return 1;
}
MPIU_Snprintf( outbuf, PMIU_MAXLINE, "cmd=newkvs kvsname=%s\n", kvsname );
PMIWriteLine( pentry->fd, outbuf );
DBG_PRINTFCOND(pmidebug, ("Handle_create_kvs new name %s\n", kvsname ) );
return 0;
}
/* Implement the singleton init handshake. See the discussion in
simplepmi.c for the protocol */
int PMI_InitSingletonConnection( int fd, PMIProcess *pmiprocess )
{
char buf[PMIU_MAXLINE], cmd[PMIU_MAXLINE];
int rc;
char version[PMIU_MAXLINE], subversion[PMIU_MAXLINE];
/* We start with the singinit command, wait for the singinit from
the client, and then send the singinit_info */
MPIU_Snprintf( buf, PMIU_MAXLINE,
"cmd=singinit pmi_version=%d pmi_subversion=%d stdio=no authtype=none\n",
PMI_VERSION, PMI_SUBVERSION );
PMIWriteLine( fd, buf );
PMIReadLine( fd, buf, PMIU_MAXLINE );
PMIU_parse_keyvals( buf );
PMIU_getval( "cmd", cmd, MAXPMICMD );
if (strcmp(cmd,"singinit")) {
PMIU_printf( 1, "Unexpected cmd %s\n", cmd );
return -1;
}
/* Could look at authtype */
/* check version compatibility with PMI client library */
PMIU_getval( "pmi_version", version, PMIU_MAXLINE );
PMIU_getval( "pmi_subversion", subversion, PMIU_MAXLINE );
if (PMI_VERSION == atoi(version) && PMI_SUBVERSION >= atoi(subversion))
rc = 0;
else
rc = -1;
MPIU_Snprintf( buf, PMIU_MAXLINE,
"cmd=singinit_info versionok=%s stdio=no kvsname=%s\n",
(rc == 0) ? "yes" : "no",
(char *)(pmiprocess->group->kvs->kvsname) );
PMIWriteLine( fd, buf );
return 0;
}
/* FIXME: My name should be cached rather than re-acquired, as it is
unchanging (after singleton init) */
int PMI_KVS_Get_my_name( char kvsname[], int length )
{
int err;
if (PMI_initialized == SINGLETON_INIT_BUT_NO_PM) {
/* Return a dummy name */
/* FIXME: We need to support a distinct kvsname for each
process group */
MPIU_Snprintf( kvsname, length, "singinit_kvs_%d_0", (int)getpid() );
return 0;
}
err = GetResponse( "cmd=get_my_kvsname\n", "my_kvsname", 0 );
if (err == PMI_SUCCESS) {
PMIU_getval( "kvsname", kvsname, length );
}
return err;
}
/* Handle an incoming get_my_kvsname command */
static int fPMI_Handle_get_my_kvsname( PMIProcess *pentry )
{
char outbuf[PMIU_MAXLINE];
PMIKVSpace *kvs;
kvs = pentry->group->kvs;
if (kvs && kvs->kvsname) {
MPIU_Snprintf( outbuf, PMIU_MAXLINE, "cmd=my_kvsname kvsname=%s\n",
kvs->kvsname );
}
else {
MPIU_Internal_error_printf( "Group has no associated KVS" );
return -1;
}
PMIWriteLine( pentry->fd, outbuf );
DBG_PRINTFCOND(pmidebug,( "%s", outbuf ));
return 0;
}
/* Create a kvs and return a pointer to it */
static PMIKVSpace *fPMIKVSAllocate( void )
{
PMIKVSpace *kvs, **kPrev, *k;
int rc;
static int kvsnum = 0; /* Used to generate names */
/* Create the space */
kvs = (PMIKVSpace *)MPIU_Malloc( sizeof(PMIKVSpace) );
if (!kvs) {
MPIU_Internal_error_printf( "too many kvs's\n" );
return 0;
}
/* We include the pid of the PMI server as a way to allow multiple
PMI servers to coexist. This is needed to support connect/accept
operations when multiple mpiexec's are used, and the KVS space
is served directly by mpiexec (it should really have the
hostname as well, just to avoid getting the same pid on two
different hosts, but this is probably good enough for most
uses) */
MPIU_Snprintf( (char *)(kvs->kvsname), MAXNAMELEN, "kvs_%d_%d",
(int)getpid(), kvsnum++ );
kvs->pairs = 0;
kvs->lastByIdx = 0;
kvs->lastIdx = -1;
/* Insert into the list of KV spaces */
kPrev = &pmimaster.kvSpaces;
k = pmimaster.kvSpaces;
while (k) {
rc = strcmp( k->kvsname, kvs->kvsname );
if (rc > 0) break;
kPrev = &k->nextKVS;
k = k->nextKVS;
}
kvs->nextKVS = k;
*kPrev = kvs;
return kvs;
}
int PMI_KVS_Put( const char kvsname[], const char key[], const char value[] )
{
char buf[PMIU_MAXLINE];
int err = PMI_SUCCESS;
int rc;
/* This is a special hack to support singleton initialization */
if (PMI_initialized == SINGLETON_INIT_BUT_NO_PM) {
rc = MPIU_Strncpy(cached_singinit_key,key,PMI_keylen_max);
if (rc != 0) return PMI_FAIL;
rc = MPIU_Strncpy(cached_singinit_val,value,PMI_vallen_max);
if (rc != 0) return PMI_FAIL;
return 0;
}
rc = MPIU_Snprintf( buf, PMIU_MAXLINE,
"cmd=put kvsname=%s key=%s value=%s\n",
kvsname, key, value);
if (rc < 0) return PMI_FAIL;
err = GetResponse( buf, "put_result", 1 );
return err;
}
/* Handle an incoming "init" command */
static int fPMI_Handle_init( PMIProcess *pentry )
{
char version[PMIU_MAXLINE];
char subversion[PMIU_MAXLINE];
char outbuf[PMIU_MAXLINE];
int rc;
/* check version compatibility with PMI client library */
PMIU_getval( "pmi_version", version, PMIU_MAXLINE );
PMIU_getval( "pmi_subversion", subversion, PMIU_MAXLINE );
if (PMI_VERSION == atoi(version) && PMI_SUBVERSION >= atoi(subversion))
rc = 0;
else
rc = -1;
pentry->pState->status = PROCESS_COMMUNICATING;
MPIU_Snprintf( outbuf, PMIU_MAXLINE,
"cmd=response_to_init pmi_version=%d pmi_subversion=%d rc=%d\n",
PMI_VERSION, PMI_SUBVERSION, rc);
PMIWriteLine( pentry->fd, outbuf );
DBG_PRINTFCOND(pmidebug,( "%s", outbuf ));
return 0;
}
RecursionStruct *GetLevel(int rank, int recursion)
{
RecursionStruct *pLevel;
pLevel = g_pLevel;
while (pLevel)
{
if (pLevel->level == recursion && pLevel->rank == rank)
return pLevel;
pLevel = pLevel->next;
}
pLevel = (RecursionStruct*)MPIU_Malloc(sizeof(RecursionStruct));
MPIU_Snprintf(pLevel->filename, 1024, "irlog.%d.%d.tmp", rank, recursion);
pLevel->fout = fopen(pLevel->filename, "w+b");
pLevel->rank = rank;
pLevel->level = recursion;
pLevel->num_events = 0;
pLevel->next = g_pLevel;
g_pLevel = pLevel;
return pLevel;
}
static int smpd_build_spn_list()
{
HRESULT hr;
IDirectoryObject *pSCP = NULL;
ADS_ATTR_INFO *pPropEntries = NULL;
IDirectorySearch *pSearch = NULL;
ADS_SEARCH_HANDLE hSearch = NULL;
LPWSTR pszDN; /* distinguished name of SCP. */
LPWSTR pszServiceDNSName; /* service DNS name. */
LPWSTR pszClass; /* name of service class. */
USHORT usPort; /* service port. */
WCHAR pszSearchString[SMPD_MAX_NAME_LENGTH];
char temp_str[SMPD_MAX_NAME_LENGTH];
char temp_str2[SMPD_MAX_NAME_LENGTH];
smpd_host_spn_node_t *iter;
/* double t1, t2; */
static int initialized = 0;
if (initialized)
{
return SMPD_SUCCESS;
}
initialized = 1;
/* t1 = PMPI_Wtime(); */
CoInitialize(NULL);
/* Get an IDirectorySearch pointer for the Global Catalog. */
hr = GetGCSearch(&pSearch);
if (FAILED(hr) || pSearch == NULL)
{
smpd_err_printf("GetGC failed 0x%x\n", hr);
goto Cleanup;
}
/* Set up a deep search.
Thousands of objects are not expected in this example, therefore
query for 1000 rows per page.*/
ADS_SEARCHPREF_INFO SearchPref[2];
DWORD dwPref = sizeof(SearchPref)/sizeof(ADS_SEARCHPREF_INFO);
SearchPref[0].dwSearchPref = ADS_SEARCHPREF_SEARCH_SCOPE;
SearchPref[0].vValue.dwType = ADSTYPE_INTEGER;
SearchPref[0].vValue.Integer = ADS_SCOPE_SUBTREE;
SearchPref[1].dwSearchPref = ADS_SEARCHPREF_PAGESIZE;
SearchPref[1].vValue.dwType = ADSTYPE_INTEGER;
SearchPref[1].vValue.Integer = 1000;
hr = pSearch->SetSearchPreference(SearchPref, dwPref);
if (FAILED(hr))
{
smpd_err_printf("Failed to set search prefs: hr:0x%x\n", hr);
goto Cleanup;
}
/* Execute the search. From the GC get the distinguished name
of the SCP. Use the DN to bind to the SCP and get the other
properties. */
LPWSTR rgszDN[] = {L"distinguishedName"};
/* Search for a match of the product GUID. */
swprintf(pszSearchString, L"keywords=%s", SMPD_SERVICE_VENDOR_GUIDW);
hr = pSearch->ExecuteSearch(pszSearchString, rgszDN, 1, &hSearch);
/*hr = pSearch->ExecuteSearch(L"keywords=5722fe5f-cf46-4594-af7c-0997ca2e9d72", rgszDN, 1, &hSearch);*/
if (FAILED(hr))
{
smpd_err_printf("ExecuteSearch failed: hr:0x%x\n", hr);
goto Cleanup;
}
/* Loop through the results. Each row should be an instance of the
service identified by the product GUID.
Add logic to select from multiple service instances. */
while (SUCCEEDED(hr = pSearch->GetNextRow(hSearch)))
{
if (hr == S_ADS_NOMORE_ROWS)
{
DWORD dwError = ERROR_SUCCESS;
WCHAR szError[512];
WCHAR szProvider[512];
ADsGetLastError(&dwError, szError, 512, szProvider, 512);
if (ERROR_MORE_DATA == dwError)
{
continue;
}
goto Cleanup;
}
ADS_SEARCH_COLUMN Col;
hr = pSearch->GetColumn(hSearch, L"distinguishedName", &Col);
pszDN = AllocADsStr(Col.pADsValues->CaseIgnoreString);
pSearch->FreeColumn(&Col);
/* Bind to the DN to get the other properties. */
LPWSTR lpszLDAPPrefix = L"LDAP://";
DWORD dwSCPPathLength = (DWORD)(wcslen(lpszLDAPPrefix) + wcslen(pszDN) + 1);
LPWSTR pwszSCPPath = (LPWSTR)malloc(sizeof(WCHAR) * dwSCPPathLength);
if (pwszSCPPath)
{
wcscpy(pwszSCPPath, lpszLDAPPrefix);
wcscat(pwszSCPPath, pszDN);
}
else
{
smpd_err_printf("Failed to allocate a buffer\n");
goto Cleanup;
}
/*wprintf(L"pszDN = %s\n", pszDN);*/
/*FreeADsStr(pszDN);*/
hr = ADsGetObject(pwszSCPPath, IID_IDirectoryObject, (void**)&pSCP);
free(pwszSCPPath);
if (SUCCEEDED(hr))
{
/* Properties to retrieve from the SCP object. */
LPWSTR rgszAttribs[]=
{
{L"serviceClassName"},
{L"serviceDNSName"},
/*{L"serviceDNSNameType"},*/
{L"serviceBindingInformation"}
};
DWORD dwAttrs = sizeof(rgszAttribs)/sizeof(LPWSTR);
DWORD dwNumAttrGot;
hr = pSCP->GetObjectAttributes(rgszAttribs, dwAttrs, &pPropEntries, &dwNumAttrGot);
if (FAILED(hr))
{
smpd_err_printf("GetObjectAttributes Failed. hr:0x%x\n", hr);
goto Cleanup;
}
pszServiceDNSName = NULL;
pszClass = NULL;
iter = (smpd_host_spn_node_t*)malloc(sizeof(smpd_host_spn_node_t));
if (iter == NULL)
{
smpd_err_printf("Unable to allocate memory to store an SPN entry.\n");
goto Cleanup;
}
iter->next = NULL;
iter->host[0] = '\0';
iter->spn[0] = '\0';
iter->dnshost[0] = '\0';
/* Loop through the entries returned by GetObjectAttributes
and save the values in the appropriate buffers. */
for (int i = 0; i < (LONG)dwAttrs; i++)
{
if ((wcscmp(L"serviceDNSName", pPropEntries[i].pszAttrName) == 0) &&
(pPropEntries[i].dwADsType == ADSTYPE_CASE_IGNORE_STRING))
{
pszServiceDNSName = AllocADsStr(pPropEntries[i].pADsValues->CaseIgnoreString);
/*wprintf(L"pszServiceDNSName = %s\n", pszServiceDNSName);*/
}
/*
if ((wcscmp(L"serviceDNSNameType", pPropEntries[i].pszAttrName) == 0) &&
(pPropEntries[i].dwADsType == ADSTYPE_CASE_IGNORE_STRING))
{
pszServiceDNSNameType = AllocADsStr(pPropEntries[i].pADsValues->CaseIgnoreString);
wprintf(L"pszServiceDNSNameType = %s\n", pszServiceDNSNameType);
}
*/
if ((wcscmp(L"serviceClassName", pPropEntries[i].pszAttrName) == 0) &&
(pPropEntries[i].dwADsType == ADSTYPE_CASE_IGNORE_STRING))
{
pszClass = AllocADsStr(pPropEntries[i].pADsValues->CaseIgnoreString);
/*wprintf(L"pszClass = %s\n", pszClass);*/
}
if ((wcscmp(L"serviceBindingInformation", pPropEntries[i].pszAttrName) == 0) &&
(pPropEntries[i].dwADsType == ADSTYPE_CASE_IGNORE_STRING))
{
usPort=(USHORT)_wtoi(pPropEntries[i].pADsValues->CaseIgnoreString);
/*wprintf(L"usPort = %d\n", usPort);*/
}
}
wcstombs(iter->dnshost, pszServiceDNSName, SMPD_MAX_NAME_LENGTH);
wcstombs(temp_str, pszClass, SMPD_MAX_NAME_LENGTH);
/*MPIU_Snprintf(iter->spn, SMPD_MAX_NAME_LENGTH, "%s/%s:%d", temp_str, iter->dnshost, usPort);*/
wcstombs(temp_str2, pszDN, SMPD_MAX_NAME_LENGTH);
MPIU_Snprintf(iter->spn, SMPD_MAX_NAME_LENGTH, "%s/%s/%s", temp_str, iter->dnshost, temp_str2);
MPIU_Strncpy(iter->host, iter->dnshost, SMPD_MAX_NAME_LENGTH);
strtok(iter->host, ".");
iter->next = spn_list;
spn_list = iter;
if (pszServiceDNSName != NULL)
{
FreeADsStr(pszServiceDNSName);
}
if (pszClass != NULL)
{
FreeADsStr(pszClass);
}
}
FreeADsStr(pszDN);
}
Cleanup:
/*
iter = spn_list;
while (iter != NULL)
{
printf("host : %s\n", iter->host);
printf("dnshost: %s\n", iter->dnshost);
printf("spn : %s\n", iter->spn);
iter = iter->next;
}
fflush(stdout);
*/
if (pSCP)
{
pSCP->Release();
pSCP = NULL;
}
if (pPropEntries)
{
FreeADsMem(pPropEntries);
pPropEntries = NULL;
}
if (pSearch)
{
if (hSearch)
{
pSearch->CloseSearchHandle(hSearch);
hSearch = NULL;
}
pSearch->Release();
pSearch = NULL;
}
CoUninitialize();
/* t2 = PMPI_Wtime();
smpd_dbg_printf("build_spn_list took %0.6f seconds\n", t2-t1);
*/
return SMPD_SUCCESS;
}
int mpiexec_rsh()
{
int i;
smpd_launch_node_t *launch_node_ptr;
smpd_process_t *process, **processes;
int result;
char *iter1, *iter2;
char exe[SMPD_MAX_EXE_LENGTH];
char *p;
char ssh_cmd[100] = "ssh -x";
SMPDU_Sock_set_t set;
SMPD_BOOL escape_escape = SMPD_TRUE;
char *env_str;
int maxlen;
SMPDU_Sock_t abort_sock;
smpd_context_t *abort_context = NULL;
smpd_command_t *cmd_ptr;
PROCESS_HANDLE_TYPE hnd;
smpd_enter_fn("mpiexec_rsh");
#ifdef HAVE_WINDOWS_H
SetConsoleCtrlHandler(mpiexec_rsh_handler, TRUE);
#else
/* setup a signall hander? */
#endif
p = getenv("MPIEXEC_RSH");
if (p != NULL && strlen(p) > 0){
strncpy(ssh_cmd, p, 100);
}
p = getenv("MPIEXEC_RSH_NO_ESCAPE");
if (p != NULL){
if (smpd_is_affirmative(p) || strcmp(p, "1") == 0){
escape_escape = SMPD_FALSE;
}
}
result = SMPDU_Sock_create_set(&set);
if (result != SMPD_SUCCESS){
smpd_err_printf("unable to create a set for the mpiexec_rsh.\n");
smpd_exit_fn("mpiexec_rsh");
return SMPD_FAIL;
}
smpd_process.nproc = smpd_process.launch_list->nproc;
if (smpd_process.use_pmi_server){
result = start_pmi_server(smpd_process.launch_list->nproc, root_host, 100, &root_port);
if (result != SMPD_SUCCESS){
smpd_err_printf("mpiexec_rsh is unable to start the local pmi server.\n");
smpd_exit_fn("mpiexec_rsh");
return SMPD_FAIL;
}
smpd_dbg_printf("the pmi server is listening on %s:%d\n", root_host, root_port);
}
else{
/* start the root smpd */
result = start_root_smpd(root_host, SMPD_MAX_HOST_LENGTH, &root_port, &hnd);
if (result != SMPD_SUCCESS){
smpd_err_printf("mpiexec_rsh is unable to start the root smpd.\n");
smpd_exit_fn("mpiexec_rsh");
return SMPD_FAIL;
}
smpd_dbg_printf("the root smpd is listening on %s:%d\n", root_host, root_port);
/* create a connection to the root smpd used to abort the job */
result = ConnectToHost(root_host, root_port, SMPD_CONNECTING_RPMI, set, &abort_sock, &abort_context);
if (result != SMPD_SUCCESS){
smpd_exit_fn("mpiexec_rsh");
return SMPD_FAIL;
}
}
processes = (smpd_process_t**)MPIU_Malloc(sizeof(smpd_process_t*) * smpd_process.launch_list->nproc);
if (processes == NULL){
smpd_err_printf("unable to allocate process array.\n");
smpd_exit_fn("mpiexec_rsh");
return SMPD_FAIL;
}
launch_node_ptr = smpd_process.launch_list;
for (i=0; i<smpd_process.launch_list->nproc; i++){
if (launch_node_ptr == NULL){
smpd_err_printf("Error: not enough launch nodes.\n");
smpd_exit_fn("mpiexec_rsh");
return SMPD_FAIL;
}
/* initialize process structure */
result = smpd_create_process_struct(i, &process);
if (result != SMPD_SUCCESS){
smpd_err_printf("unable to create a process structure.\n");
smpd_exit_fn("mpiexec_rsh");
return SMPD_FAIL;
}
/* no need for a pmi context */
if (process->pmi){
smpd_free_context(process->pmi);
}
process->pmi = NULL;
/* change stdout and stderr to rsh behavior:
* write stdout/err directly to stdout/err instead of creating
* an smpd stdout/err command
*/
if (process->out != NULL){
process->out->type = SMPD_CONTEXT_STDOUT_RSH;
}
if (process->err != NULL){
process->err->type = SMPD_CONTEXT_STDERR_RSH;
}
MPIU_Strncpy(process->clique, launch_node_ptr->clique, SMPD_MAX_CLIQUE_LENGTH);
MPIU_Strncpy(process->dir, launch_node_ptr->dir, SMPD_MAX_DIR_LENGTH);
MPIU_Strncpy(process->domain_name, smpd_process.kvs_name, SMPD_MAX_DBS_NAME_LEN);
MPIU_Strncpy(process->env, launch_node_ptr->env, SMPD_MAX_ENV_LENGTH);
if (escape_escape == SMPD_TRUE && smpd_process.mpiexec_run_local != SMPD_TRUE){
/* convert \ to \\ to make cygwin ssh happy */
iter1 = launch_node_ptr->exe;
iter2 = exe;
while (*iter1){
if (*iter1 == '\\'){
*iter2 = *iter1;
iter2++;
*iter2 = *iter1;
}
else{
*iter2 = *iter1;
}
iter1++;
iter2++;
}
*iter2 = '\0';
/*printf("[%s] -> [%s]\n", launch_node_ptr->exe, exe);*/
}
else{
MPIU_Strncpy(exe, launch_node_ptr->exe, SMPD_MAX_EXE_LENGTH);
}
/* Two samples for testing on the local machine */
/* static rPMI initialization */
/*sprintf(process->exe, "env PMI_RANK=%d PMI_SIZE=%d PMI_KVS=%s PMI_ROOT_HOST=%s PMI_ROOT_PORT=8888 PMI_ROOT_LOCAL=1 PMI_APPNUM=%d %s",
launch_node_ptr->iproc, launch_node_ptr->nproc, smpd_process.kvs_name, root_host, launch_node_ptr->appnum, exe);*/
/* dynamic rPMI initialization */
/*sprintf(process->exe, "env PMI_RANK=%d PMI_SIZE=%d PMI_KVS=%s PMI_ROOT_HOST=%s PMI_ROOT_PORT=%d PMI_ROOT_LOCAL=0 PMI_APPNUM=%d %s",
launch_node_ptr->iproc, launch_node_ptr->nproc, smpd_process.kvs_name, root_host, root_port, launch_node_ptr->appnum, exe);*/
if (smpd_process.mpiexec_run_local == SMPD_TRUE){
/* -localonly option and dynamic rPMI initialization */
env_str = &process->env[strlen(process->env)];
maxlen = (int)(SMPD_MAX_ENV_LENGTH - strlen(process->env));
MPIU_Str_add_int_arg(&env_str, &maxlen, "PMI_RANK", launch_node_ptr->iproc);
MPIU_Str_add_int_arg(&env_str, &maxlen, "PMI_SIZE", launch_node_ptr->nproc);
MPIU_Str_add_string_arg(&env_str, &maxlen, "PMI_KVS", smpd_process.kvs_name);
MPIU_Str_add_string_arg(&env_str, &maxlen, "PMI_ROOT_HOST", root_host);
MPIU_Str_add_int_arg(&env_str, &maxlen, "PMI_ROOT_PORT", root_port);
MPIU_Str_add_string_arg(&env_str, &maxlen, "PMI_ROOT_LOCAL", "0");
MPIU_Str_add_int_arg(&env_str, &maxlen, "PMI_APPNUM", launch_node_ptr->appnum);
MPIU_Strncpy(process->exe, exe, SMPD_MAX_EXE_LENGTH);
}
else{
/* ssh and dynamic rPMI initialization */
char fmtEnv[SMPD_MAX_ENV_LENGTH];
int fmtEnvLen = SMPD_MAX_ENV_LENGTH;
char *pExe = process->exe;
int curLen = 0;
MPIU_Snprintf(pExe, SMPD_MAX_EXE_LENGTH, "%s %s env", ssh_cmd, launch_node_ptr->hostname);
curLen = strlen(process->exe);
pExe = process->exe + curLen;
if(FmtEnvVarsForSSH(launch_node_ptr->env, fmtEnv, fmtEnvLen)){
/* Add user specified env vars */
MPIU_Snprintf(pExe, SMPD_MAX_EXE_LENGTH - curLen, "%s", fmtEnv);
curLen = strlen(process->exe);
pExe = process->exe + curLen;
}
MPIU_Snprintf(pExe, SMPD_MAX_EXE_LENGTH - curLen, " \"PMI_RANK=%d\" \"PMI_SIZE=%d\" \"PMI_KVS=%s\" \"PMI_ROOT_HOST=%s\" \"PMI_ROOT_PORT=%d\" \"PMI_ROOT_LOCAL=0\" \"PMI_APPNUM=%d\" %s",
launch_node_ptr->iproc, launch_node_ptr->nproc, smpd_process.kvs_name, root_host, root_port, launch_node_ptr->appnum, exe);
}
MPIU_Strncpy(process->kvs_name, smpd_process.kvs_name, SMPD_MAX_DBS_NAME_LEN);
process->nproc = launch_node_ptr->nproc;
MPIU_Strncpy(process->path, launch_node_ptr->path, SMPD_MAX_PATH_LENGTH);
/* call smpd_launch_process */
smpd_dbg_printf("launching: %s\n", process->exe);
result = smpd_launch_process(process, SMPD_DEFAULT_PRIORITY_CLASS, SMPD_DEFAULT_PRIORITY, SMPD_FALSE, set);
if (result != SMPD_SUCCESS){
smpd_err_printf("unable to launch process %d <%s>.\n", i, process->exe);
smpd_exit_fn("mpiexec_rsh");
return SMPD_FAIL;
}
/* save the new process in the list */
process->next = smpd_process.process_list;
smpd_process.process_list = process;
if (i == 0){
/* start the stdin redirection thread to the first process */
setup_stdin_redirection(process, set);
}
smpd_process.nproc_launched++;
processes[i] = process;
launch_node_ptr = launch_node_ptr->next;
} /* for (i=0; i<smpd_process.launch_list->nproc; i++) */
if (launch_node_ptr != NULL){
smpd_err_printf("Error: too many launch nodes.\n");
smpd_exit_fn("mpiexec_rsh");
return SMPD_FAIL;
}
/* Start the timeout mechanism if specified */
if (smpd_process.timeout > 0){
smpd_context_t *reader_context;
SMPDU_Sock_t sock_reader;
SMPDU_SOCK_NATIVE_FD reader, writer;
#ifdef HAVE_WINDOWS_H
/*SOCKET reader, writer;*/
smpd_make_socket_loop((SOCKET*)&reader, (SOCKET*)&writer);
#else
/*int reader, writer;*/
int pair[2];
socketpair(AF_UNIX, SOCK_STREAM, 0, pair);
reader = pair[0];
writer = pair[1];
#endif
result = SMPDU_Sock_native_to_sock(set, reader, NULL, &sock_reader);
result = SMPDU_Sock_native_to_sock(set, writer, NULL, &smpd_process.timeout_sock);
result = smpd_create_context(SMPD_CONTEXT_TIMEOUT, set, sock_reader, -1, &reader_context);
reader_context->read_state = SMPD_READING_TIMEOUT;
result = SMPDU_Sock_post_read(sock_reader, &reader_context->read_cmd.cmd, 1, 1, NULL);
#ifdef HAVE_WINDOWS_H
/* create a Windows thread to sleep until the timeout expires */
smpd_process.timeout_thread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)timeout_thread, NULL, 0, NULL);
if (smpd_process.timeout_thread == NULL){
printf("Error: unable to create a timeout thread, errno %d.\n", GetLastError());
smpd_exit_fn("mp_parse_command_args");
return SMPD_FAIL;
}
#else /* HAVE_WINDOWS_H */
#ifdef SIGALRM
/* create an alarm to signal mpiexec when the timeout expires */
smpd_signal(SIGALRM, timeout_function);
alarm(smpd_process.timeout);
#else /* SIGALARM */
#ifdef HAVE_PTHREAD_H
/* create a pthread to sleep until the timeout expires */
result = pthread_create(&smpd_process.timeout_thread, NULL, timeout_thread, NULL);
if (result != 0){
printf("Error: unable to create a timeout thread, errno %d.\n", result);
smpd_exit_fn("mp_parse_command_args");
return SMPD_FAIL;
}
#else /* HAVE_PTHREAD_H */
/* no timeout mechanism available */
#endif /* HAVE_PTHREAD_H */
#endif /* SIGALARM */
#endif /* HAVE_WINDOWS_H */
} /* if (smpd_process.timeout > 0) */
result = smpd_enter_at_state(set, SMPD_IDLE);
if (result != SMPD_SUCCESS){
smpd_err_printf("mpiexec_rsh state machine failed.\n");
smpd_exit_fn("mpiexec_rsh");
return SMPD_FAIL;
}
if (smpd_process.use_pmi_server){
result = stop_pmi_server();
if (result != SMPD_SUCCESS){
smpd_err_printf("mpiexec_rsh unable to stop the pmi server.\n");
smpd_exit_fn("mpiexec_rsh");
return SMPD_FAIL;
}
}
else{
/* Send an abort command to the root_smpd thread/process to insure that it exits.
* This only needs to be sent when there is an error or failed process of some sort
* but it is safe to send it in all cases.
*/
result = smpd_create_command("abort", 0, 0, SMPD_FALSE, &cmd_ptr);
if (result != SMPD_SUCCESS){
smpd_err_printf("unable to create an abort command.\n");
smpd_exit_fn("mpiexec_rsh");
return SMPD_FAIL;
}
result = smpd_post_write_command(abort_context, cmd_ptr);
if (result != SMPD_SUCCESS){
/* Only print this as a debug message instead of an error because the root_smpd thread/process may have already exited. */
smpd_dbg_printf("unable to post a write of the abort command to the %s context.\n", smpd_get_context_str(abort_context));
smpd_exit_fn("mpiexec_rsh");
return SMPD_FAIL;
}
result = stop_root_smpd(hnd);
if (result != PMI_SUCCESS){
smpd_err_printf("mpiexec_rsh unable to stop the root smpd.\n");
smpd_exit_fn("mpiexec_rsh");
return SMPD_FAIL;
}
}
smpd_exit_fn("mpiexec_rsh");
return 0;
}
/* *slen is the length of the string, including the null terminator. So if the
resulting string is |foo\0bar\0|, then *slen == 8. */
static int connToStringKVS( char **buf_p, int *slen, MPIDI_PG_t *pg )
{
char *string = 0;
char *pg_idStr = (char *)pg->id; /* In the PMI/KVS space,
the pg id is a string */
char buf[MPIDI_MAX_KVS_VALUE_LEN];
int i, j, vallen, rc, mpi_errno = MPI_SUCCESS, len;
int curSlen;
/* Make an initial allocation of a string with an estimate of the
needed space */
len = 0;
curSlen = 10 + pg->size * 128;
string = (char *)MPIU_Malloc( curSlen );
/* Start with the id of the pg */
while (*pg_idStr && len < curSlen)
string[len++] = *pg_idStr++;
string[len++] = 0;
/* Add the size of the pg */
MPIU_Snprintf( &string[len], curSlen - len, "%d", pg->size );
while (string[len]) len++;
len++;
for (i=0; i<pg->size; i++) {
rc = getConnInfoKVS( i, buf, MPIDI_MAX_KVS_VALUE_LEN, pg );
if (rc) {
MPIU_Internal_error_printf(
"Panic: getConnInfoKVS failed for %s (rc=%d)\n",
(char *)pg->id, rc );
}
#ifndef USE_PERSISTENT_SHARED_MEMORY
/* FIXME: This is a hack to avoid including shared-memory
queue names in the business card that may be used
by processes that were not part of the same COMM_WORLD.
To fix this, the shared memory channels should look at the
returned connection info and decide whether to use
sockets or shared memory by determining whether the
process is in the same MPI_COMM_WORLD. */
/* FIXME: The more general problem is that the connection information
needs to include some information on the range of validity (e.g.,
all processes, same comm world, particular ranks), and that
representation needs to be scalable */
/* printf( "Adding key %s value %s\n", key, val ); */
{
char *p = strstr( buf, "$shm_host" );
if (p) p[1] = 0;
/* printf( "(fixed) Adding key %s value %s\n", key, val ); */
}
#endif
/* Add the information to the output buffer */
vallen = strlen(buf);
/* Check that this will fix in the remaining space */
if (len + vallen + 1 >= curSlen) {
char *nstring = 0;
curSlen += (pg->size - i) * (vallen + 1 );
nstring = MPIU_Realloc( string, curSlen);
if (!nstring) {
MPIU_ERR_SETANDJUMP(mpi_errno,MPI_ERR_OTHER,"**nomem");
}
string = nstring;
}
/* Append to string */
for (j=0; j<vallen+1; j++) {
string[len++] = buf[j];
}
}
MPIU_Assert(len <= curSlen);
*buf_p = string;
*slen = len;
fn_exit:
return mpi_errno;
fn_fail:
if (string) MPIU_Free(string);
goto fn_exit;
}
