/* Check the environment for label control
If either prefix is set, the labels are enabled. If only one prefix
is set, the default prefix is used for the other label */
int IOLabelCheckEnv( void )
{
char *envval;
envval = getenv( "MPIEXEC_PREFIX_STDOUT" );
if (envval) {
if (strlen(envval) < MAX_LABEL) {
MPIU_Strncpy( outLabelPattern, envval, MAX_LABEL );
useLabels = 1;
}
else {
MPIU_Error_printf( "Pattern for stdout label specified by MPIEXEC_PREFIX_STROUT is too long" );
}
}
envval = getenv( "MPIEXEC_PREFIX_STDERR" );
if (envval) {
if (strlen(envval) < MAX_LABEL) {
MPIU_Strncpy( errLabelPattern, envval, MAX_LABEL );
useLabels = 1;
}
else {
MPIU_Error_printf( "Pattern for stderr label specified by MPIEXEC_PREFIX_STRERR is too long" );
}
}
return 0;
}
int MPIDU_Ftb_init(void)
{
int mpi_errno = MPI_SUCCESS;
int ret;
FTB_client_t ci;
MPIDI_STATE_DECL(MPID_STATE_MPIDU_FTB_INIT);
MPIDI_FUNC_ENTER(MPID_STATE_MPIDU_FTB_INIT);
MPIU_Strncpy(ci.event_space, "ftb.mpi.mpich", sizeof(ci.event_space));
MPIU_Strncpy(ci.client_name, "mpich " MPICH_VERSION, sizeof(ci.client_name));
MPIU_Strncpy(ci.client_subscription_style, "FTB_SUBSCRIPTION_NONE", sizeof(ci.client_subscription_style));
ci.client_polling_queue_len = -1;
#ifdef USE_PMI2_API
ret = PMI2_Job_GetId(ci.client_jobid, sizeof(ci.client_jobid));
MPIR_ERR_CHKANDJUMP(ret, mpi_errno, MPI_ERR_OTHER, "**pmi_jobgetid");
#else
ret = PMI_KVS_Get_my_name(ci.client_jobid, sizeof(ci.client_jobid));
MPIR_ERR_CHKANDJUMP(ret, mpi_errno, MPI_ERR_OTHER, "**pmi_get_id");
#endif
ret = FTB_Connect(&ci, &client_handle);
MPIR_ERR_CHKANDJUMP(ret, mpi_errno, MPI_ERR_OTHER, "**ftb_connect");
ret = FTB_Declare_publishable_events(client_handle, NULL, event_info, sizeof(event_info) / sizeof(event_info[0]));
MPIR_ERR_CHKANDJUMP(ret, mpi_errno, MPI_ERR_OTHER, "**ftb_declare_publishable_events");
fn_exit:
MPIDI_FUNC_EXIT(MPID_STATE_MPIDU_FTB_INIT);
return mpi_errno;
fn_fail:
goto fn_exit;
}
int smpd_lookup_spn(char *target, int length, const char *host, int port)
{
int result;
char err_msg[256];
ULONG len = length/*SMPD_MAX_NAME_LENGTH*/;
char *env;
smpd_host_spn_node_t *iter;
env = getenv("MPICH_SPN");
if (env)
{
MPIU_Strncpy(target, env, SMPD_MAX_NAME_LENGTH);
return SMPD_SUCCESS;
}
smpd_build_spn_list();
iter = spn_list;
while (iter != NULL)
{
if (stricmp(iter->host, host) == 0)
{
MPIU_Strncpy(target, iter->spn, SMPD_MAX_NAME_LENGTH);
return SMPD_SUCCESS;
}
if (stricmp(iter->dnshost, host) == 0)
{
MPIU_Strncpy(target, iter->spn, SMPD_MAX_NAME_LENGTH);
return SMPD_SUCCESS;
}
iter = iter->next;
}
result = DsMakeSpn(SMPD_SERVICE_NAME, NULL, host, (USHORT)port, NULL, &len, target);
if (result != ERROR_SUCCESS)
{
smpd_translate_win_error(result, err_msg, 255, NULL);
smpd_err_printf("DsMakeSpn(%s, %s, %d) failed: %s\n", SMPD_SERVICE_NAME, host, port, err_msg);
return SMPD_FAIL;
}
/*result = DsMakeSpn(SMPD_SERVICE_NAME, SMPD_SERVICE_NAME, NULL, 0, NULL, &len, target);*/
/*
char **spns;
result = DsGetSpn(DS_SPN_DNS_HOST, SMPD_SERVICE_NAME, NULL, port, 1, &host, NULL, &len, &spns);
if (result != ERROR_SUCCESS)
{
smpd_translate_win_error(result, err_msg, 255, NULL);
smpd_err_printf("DsGetSpn failed: %s\n", err_msg);
return SMPD_FAIL;
}
MPIU_Strncpy(target, spns[0], SMPD_MAX_NAME_LENGTH);
DsFreeSpnArray(1, spns);
*/
/*MPIU_Snprintf(target, SMPD_MAX_NAME_LENGTH, "%s/%s:%d", SMPD_SERVICE_NAME, host, port);*/
return SMPD_SUCCESS;
}
/*
* Given an input string st, parse it into internal storage that can be
* queried by routines such as PMIU_getval.
*/
int PMIU_parse_keyvals( char *st )
{
char *p, *keystart, *valstart;
int offset;
if ( !st )
return( -1 );
PMIU_keyval_tab_idx = 0;
p = st;
while ( 1 ) {
while ( *p == ' ' )
p++;
/* got non-blank */
if ( *p == '=' ) {
PMIU_printf( 1, "PMIU_parse_keyvals: unexpected = at character %d in %s\n",
p - st, st );
return( -1 );
}
if ( *p == '\n' || *p == '\0' )
return( 0 ); /* normal exit */
/* got normal character */
keystart = p; /* remember where key started */
while ( *p != ' ' && *p != '=' && *p != '\n' && *p != '\0' )
p++;
if ( *p == ' ' || *p == '\n' || *p == '\0' ) {
PMIU_printf( 1,
"PMIU_parse_keyvals: unexpected key delimiter at character %d in %s\n",
p - st, st );
return( -1 );
}
/* Null terminate the key */
*p = 0;
/* store key */
MPIU_Strncpy( PMIU_keyval_tab[PMIU_keyval_tab_idx].key, keystart,
MAXKEYLEN );
valstart = ++p; /* start of value */
while ( *p != ' ' && *p != '\n' && *p != '\0' )
p++;
/* store value */
MPIU_Strncpy( PMIU_keyval_tab[PMIU_keyval_tab_idx].value, valstart,
MAXVALLEN );
offset = (int)(p - valstart);
/* When compiled with -fPIC, the pgcc compiler generates incorrect
code if "p - valstart" is used instead of using the
intermediate offset */
PMIU_keyval_tab[PMIU_keyval_tab_idx].value[offset] = '\0';
PMIU_keyval_tab_idx++;
if ( *p == ' ' )
continue;
if ( *p == '\n' || *p == '\0' )
return( 0 ); /* value has been set to empty */
}
}
int smpd_dbs_getNextKeyVal(smpd_dbsIter_t *pIter, char *key, char *value){
smpd_enter_fn(FCNAME);
if(!pIter || !(*pIter) || !key || !value){
/* FIXME: Desc error msgs ?*/
smpd_err_printf("Invalid args to smpd_dbs_getNextKeyVal()\n");
return SMPD_DBS_FAIL;
}
MPIU_Strncpy(key, (*pIter)->pszKey, SMPD_MAX_DBS_KEY_LEN);
MPIU_Strncpy(value, (*pIter)->pszValue, SMPD_MAX_DBS_VALUE_LEN);
(*pIter) = (*pIter)->pNext;
smpd_exit_fn(FCNAME);
return SMPD_DBS_SUCCESS;
}
static int create_r_cookie (char *hostname, int port, int data_sz, char **cookie, int *len)
{
int mpi_errno = MPI_SUCCESS;
int hostname_len;
int cookie_len;
r_cookie_t *c;
hostname_len = strnlen (hostname, MAX_HOSTNAME_LEN) + 1;
cookie_len = sizeof (r_cookie_t) - 1 + hostname_len;
c = MPIU_Malloc (cookie_len);
MPIU_ERR_CHKANDJUMP (c == NULL, mpi_errno, MPI_ERR_OTHER, "**nomem");
c->port = port;
c->data_sz = data_sz;
MPIU_Strncpy (c->hostname, hostname, hostname_len);
*cookie = (char *)c;
*len = sizeof (r_cookie_t) - 1 + hostname_len;
fn_exit:
return mpi_errno;
fn_fail:
goto fn_exit;
}
int MPIR_Info_get_nthkey_impl(MPID_Info *info_ptr, int n, char *key)
{
int mpi_errno = MPI_SUCCESS;
MPID_Info *curr_ptr;
int nkeys;
curr_ptr = info_ptr->next;
nkeys = 0;
while (curr_ptr && nkeys != n) {
curr_ptr = curr_ptr->next;
nkeys++;
}
/* verify that n is valid */
MPIU_ERR_CHKANDJUMP2((!curr_ptr), mpi_errno, MPI_ERR_ARG, "**infonkey", "**infonkey %d %d", n, nkeys);
MPIU_Strncpy( key, curr_ptr->key, MPI_MAX_INFO_KEY+1 );
/* Eventually, we could remember the location of this key in
the head using the key/value locations (and a union datatype?) */
fn_exit:
return mpi_errno;
fn_fail:
goto fn_exit;
}
/* Create a kvs and generate its name; return that name as the argument */
static int fPMIKVSGetNewSpace( char kvsname[], int maxlen )
{
PMIKVSpace *kvs;
kvs = fPMIKVSAllocate( );
MPIU_Strncpy( kvsname, kvs->kvsname, maxlen );
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;
}
/* 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;
}
void PMIU_chgval( const char *keystr, char *valstr )
{
int i;
for ( i = 0; i < PMIU_keyval_tab_idx; i++ ) {
if ( strcmp( keystr, PMIU_keyval_tab[i].key ) == 0 ) {
MPIU_Strncpy( PMIU_keyval_tab[i].value, valstr, MAXVALLEN - 1 );
PMIU_keyval_tab[i].value[MAXVALLEN - 1] = '\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;
}
static int fPMIKVSAddPair( PMIKVSpace *kvs,
const char key[], const char val[] )
{
PMIKVPair *pair, *p, **pprev;
int rc;
/* Find the location in which to insert the pair (if the
same key already exists, that is an error) */
p = kvs->pairs;
pprev = &(kvs->pairs);
while (p) {
rc = strcmp( p->key, key );
if (rc == 0) {
/* Duplicate. Indicate an error */
return 1;
}
if (rc > 0) {
/* We've found the location (after pprev, before p) */
break;
}
pprev = &(p->nextPair);
p = p->nextPair;
}
pair = (PMIKVPair *)MPIU_Malloc( sizeof(PMIKVPair) );
if (!pair) {
return -1;
}
MPIU_Strncpy( pair->key, key, sizeof(pair->key) );
MPIU_Strncpy( pair->val, val, sizeof(pair->val) );
/* Insert into the list */
pair->nextPair = p;
*pprev = pair;
/* Since the list has been modified, clear the index helpers */
kvs->lastByIdx = 0;
kvs->lastIdx = -1;
return 0;
}
int MPID_NS_Create( const MPID_Info *info_ptr, MPID_NS_Handle *handle_ptr )
{
static const char FCNAME[] = "MPID_NS_Create";
int err;
int length;
char *pmi_namepub_kvs;
*handle_ptr = (MPID_NS_Handle)MPIU_Malloc( sizeof(struct MPID_NS_Handle) );
/* --BEGIN ERROR HANDLING-- */
if (!*handle_ptr)
{
err = MPIR_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, FCNAME, __LINE__, MPI_ERR_OTHER, "**nomem", 0);
return err;
}
/* --END ERROR HANDLING-- */
err = PMI_KVS_Get_name_length_max(&length);
/* --BEGIN ERROR HANDLING-- */
if (err != PMI_SUCCESS)
{
err = MPIR_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, FCNAME, __LINE__, MPI_ERR_OTHER, "**fail", 0);
}
/* --END ERROR HANDLING-- */
(*handle_ptr)->kvsname = (char*)MPIU_Malloc(length);
/* --BEGIN ERROR HANDLING-- */
if (!(*handle_ptr)->kvsname)
{
err = MPIR_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, FCNAME, __LINE__, MPI_ERR_OTHER, "**nomem", 0);
return err;
}
/* --END ERROR HANDLING-- */
pmi_namepub_kvs = getenv("PMI_NAMEPUB_KVS");
if (pmi_namepub_kvs)
{
MPIU_Strncpy((*handle_ptr)->kvsname, pmi_namepub_kvs, length);
}
else
{
err = PMI_KVS_Get_my_name((*handle_ptr)->kvsname, length);
/* --BEGIN ERROR HANDLING-- */
if (err != PMI_SUCCESS)
{
err = MPIR_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, FCNAME, __LINE__, MPI_ERR_OTHER, "**fail", 0);
}
/* --END ERROR HANDLING-- */
}
/*printf("namepub kvs: <%s>\n", (*handle_ptr)->kvsname);fflush(stdout);*/
return 0;
}
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;
}
int smpd_lookup_spn_list(smpd_spn_list_hnd_t hnd, char *target, int length, const char *fq_name, int port)
{
int result = SMPD_SUCCESS;
char err_msg[256];
ULONG len = length/*SMPD_MAX_NAME_LENGTH*/;
char *env;
smpd_host_spn_node_t *iter;
smpd_enter_fn(FCNAME);
if(!SMPD_SPN_LIST_HND_IS_INIT(hnd)){
smpd_err_printf("Invalid handle to spn list \n");
smpd_exit_fn(FCNAME);
return SMPD_FAIL;
}
smpd_spn_list_dbg_print(hnd); fflush(stdout);
env = getenv("MPICH_SPN");
if (env){
MPIU_Strncpy(target, env, SMPD_MAX_NAME_LENGTH);
smpd_exit_fn(FCNAME);
return SMPD_SUCCESS;
}
/* smpd_build_spn_list(); */
iter = (smpd_host_spn_node_t *) (*hnd);
while (iter != NULL){
if (stricmp(iter->fq_service_name, fq_name) == 0){
MPIU_Strncpy(target, iter->spn, length);
smpd_exit_fn(FCNAME);
return SMPD_SUCCESS;
}
iter = iter->next;
}
smpd_exit_fn(FCNAME);
return SMPD_FAIL;
}
void MPIDU_Ftb_publish(const char *event_name, const char *event_payload)
{
FTB_event_properties_t event_prop;
FTB_event_handle_t event_handle;
MPIDI_STATE_DECL(MPID_STATE_MPIDU_FTB_PUBLISH);
MPIDI_FUNC_ENTER(MPID_STATE_MPIDU_FTB_PUBLISH);
event_prop.event_type = 1;
MPIU_Strncpy(event_prop.event_payload, event_payload, sizeof(event_prop.event_payload));
CHECK_FTB_ERROR(FTB_Publish(client_handle, event_name, &event_prop, &event_handle));
MPIDI_FUNC_EXIT(MPID_STATE_MPIDU_FTB_PUBLISH);
return;
}
int MPIR_T_cvar_read_impl(MPI_T_cvar_handle handle, void *buf)
{
int mpi_errno = MPI_SUCCESS;
struct MPIR_Param_t *p = handle->p;
switch (p->default_val.type) {
case MPIR_PARAM_TYPE_INT:
{
int *i_buf = buf;
*i_buf = *(int *)p->val_p;
}
break;
case MPIR_PARAM_TYPE_DOUBLE:
{
double *d_buf = buf;
*d_buf = *(double *)p->val_p;
}
break;
case MPIR_PARAM_TYPE_BOOLEAN:
{
int *i_buf = buf;
*i_buf = *(int *)p->val_p;
}
break;
case MPIR_PARAM_TYPE_STRING:
if (*(char **)p->val_p == NULL) {
char *c_buf = buf;
c_buf[0] = '\0';
}
else {
MPIU_Strncpy(buf, *(char **)p->val_p, MPIR_PARAM_MAX_STRLEN);
}
break;
case MPIR_PARAM_TYPE_RANGE:
MPIU_Memcpy(buf, p->val_p, 2*sizeof(int));
break;
default:
/* FIXME the error handling code may not have been setup yet */
MPIU_ERR_SETANDJUMP1(mpi_errno, MPI_ERR_INTERN, "**intern", "**intern %s", "unexpected parameter type");
break;
}
fn_exit:
return mpi_errno;
fn_fail:
goto fn_exit;
}
char *PMIU_getval( const char *keystr, char *valstr, int vallen )
{
int i, rc;
for (i = 0; i < PMIU_keyval_tab_idx; i++) {
if ( strcmp( keystr, PMIU_keyval_tab[i].key ) == 0 ) {
rc = MPIU_Strncpy( valstr, PMIU_keyval_tab[i].value, vallen );
if (rc != 0) {
PMIU_printf( 1, "MPIU_Strncpy failed in PMIU_getval\n" );
return NULL;
}
return valstr;
}
}
valstr[0] = '\0';
return NULL;
}
int MPIR_T_cvar_read_impl(MPI_T_cvar_handle handle, void *buf)
{
int mpi_errno = MPI_SUCCESS;
int i, count;
void *addr;
MPIR_T_cvar_handle_t *hnd = handle;
count = hnd->count;
addr = hnd->addr;
MPIU_Assert(addr != NULL);
switch (hnd->datatype) {
case MPI_INT:
for (i = 0; i < count; i++)
((int *)buf)[i] = ((int *)addr)[i];
break;
case MPI_UNSIGNED:
for (i = 0; i < count; i++)
((unsigned *)buf)[i] = ((unsigned *)addr)[i];
break;
case MPI_UNSIGNED_LONG:
for (i = 0; i < count; i++)
((unsigned long *)buf)[i] = ((unsigned long *)addr)[i];
break;
case MPI_UNSIGNED_LONG_LONG:
for (i = 0; i < count; i++)
((unsigned long long *)buf)[i] = ((unsigned long long *)addr)[i];
break;
case MPI_DOUBLE:
for (i = 0; i < count; i++)
((double *)buf)[i] = ((double *)addr)[i];
break;
case MPI_CHAR:
MPIU_Strncpy(buf, addr, count);
break;
default:
/* FIXME the error handling code may not have been setup yet */
MPIR_ERR_SETANDJUMP1(mpi_errno, MPI_ERR_INTERN, "**intern", "**intern %s", "unexpected parameter type");
break;
}
fn_exit:
return mpi_errno;
fn_fail:
goto fn_exit;
}
/*
* 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;
}
/*
Initialize the environment data
Builds the envvalue version of the data, using the given data.
if getValue is true, get the value for the name with getenv .
*/
int MPIE_EnvInitData( EnvData *elist, int getValue )
{
const char *value;
char *str;
int rc;
size_t slen;
while (elist) {
/* Skip variables that already have value strings */
if (!elist->envvalue) {
if (getValue) {
value = (const char *)getenv( elist->name );
}
else {
value = elist->value;
}
if (!value) {
/* Special case for an empty value */
value = "";
}
slen = strlen( elist->name ) + strlen(value) + 2;
str = (char *)MPIU_Malloc( slen );
if (!str) {
return 1;
}
MPIU_Strncpy( str, elist->name, slen );
if (value && *value) {
rc = MPIU_Strnapp( str, "=", slen );
rc += MPIU_Strnapp( str, value, slen );
if (rc) {
return 1;
}
}
elist->envvalue = (const char *)str;
}
elist = elist->nextData;
}
return 0;
}
static int fPMIKVSFindKey( PMIKVSpace *kvs,
const char key[], char val[], int maxval )
{
PMIKVPair *p;
int rc;
p = kvs->pairs;
while (p) {
rc = strcmp( p->key, key );
if (rc == 0) {
/* Found it. Get the value and return success */
MPIU_Strncpy( val, p->val, maxval );
return 0;
}
if (rc > 0) {
/* We're past the point in the sorted list where the
key could be found */
return 1;
}
p = p->nextPair;
}
return 1;
}
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;
}
int MPIR_Init_thread(int * argc, char ***argv, int required, int * provided)
{
int mpi_errno = MPI_SUCCESS;
int has_args;
int has_env;
int thread_provided;
int exit_init_cs_on_failure = 0;
/* For any code in the device that wants to check for runtime
decisions on the value of isThreaded, set a provisional
value here. We could let the MPID_Init routine override this */
#ifdef HAVE_RUNTIME_THREADCHECK
MPIR_ThreadInfo.isThreaded = required == MPI_THREAD_MULTIPLE;
#endif
MPIU_THREAD_CS_INIT;
/* FIXME: Move to os-dependent interface? */
#ifdef HAVE_WINDOWS_H
/* prevent the process from bringing up an error message window if mpich
asserts */
_CrtSetReportMode( _CRT_ASSERT, _CRTDBG_MODE_FILE );
_CrtSetReportFile( _CRT_ASSERT, _CRTDBG_FILE_STDERR );
_CrtSetReportHook2(_CRT_RPTHOOK_INSTALL, assert_hook);
#ifdef _WIN64
{
/* FIXME: (Windows) This severly degrades performance but fixes alignment
issues with the datatype code. */
/* Prevent misaligned faults on Win64 machines */
UINT mode, old_mode;
old_mode = SetErrorMode(SEM_NOALIGNMENTFAULTEXCEPT);
mode = old_mode | SEM_NOALIGNMENTFAULTEXCEPT;
SetErrorMode(mode);
}
#endif
#endif
/* We need this inorder to implement IS_THREAD_MAIN */
# if (MPICH_THREAD_LEVEL >= MPI_THREAD_SERIALIZED) && defined(MPICH_IS_THREADED)
{
MPID_Thread_self(&MPIR_ThreadInfo.master_thread);
}
# endif
#ifdef HAVE_ERROR_CHECKING
/* Because the PARAM system has not been initialized, temporarily
uncondtionally enable error checks. Once the PARAM system is
initialized, this may be reset */
MPIR_Process.do_error_checks = 1;
#else
MPIR_Process.do_error_checks = 0;
#endif
/* Initialize necessary subsystems and setup the predefined attribute
values. Subsystems may change these values. */
MPIR_Process.attrs.appnum = -1;
MPIR_Process.attrs.host = 0;
MPIR_Process.attrs.io = 0;
MPIR_Process.attrs.lastusedcode = MPI_ERR_LASTCODE;
MPIR_Process.attrs.tag_ub = 0;
MPIR_Process.attrs.universe = MPIR_UNIVERSE_SIZE_NOT_SET;
MPIR_Process.attrs.wtime_is_global = 0;
/* Set the functions used to duplicate attributes. These are
when the first corresponding keyval is created */
MPIR_Process.attr_dup = 0;
MPIR_Process.attr_free = 0;
#ifdef HAVE_CXX_BINDING
/* Set the functions used to call functions in the C++ binding
for reductions and attribute operations. These are null
until a C++ operation is defined. This allows the C code
that implements these operations to not invoke a C++ code
directly, which may force the inclusion of symbols known only
to the C++ compiler (e.g., under more non-GNU compilers, including
Solaris and IRIX). */
MPIR_Process.cxx_call_op_fn = 0;
#endif
/* This allows the device to select an alternative function for
dimsCreate */
MPIR_Process.dimsCreate = 0;
/* "Allocate" from the reserved space for builtin communicators and
(partially) initialize predefined communicators. comm_parent is
intially NULL and will be allocated by the device if the process group
was started using one of the MPI_Comm_spawn functions. */
MPIR_Process.comm_world = MPID_Comm_builtin + 0;
MPIR_Comm_init(MPIR_Process.comm_world);
MPIR_Process.comm_world->handle = MPI_COMM_WORLD;
MPIR_Process.comm_world->context_id = 0 << MPID_CONTEXT_PREFIX_SHIFT;
MPIR_Process.comm_world->recvcontext_id = 0 << MPID_CONTEXT_PREFIX_SHIFT;
MPIR_Process.comm_world->comm_kind = MPID_INTRACOMM;
/* This initialization of the comm name could be done only when
comm_get_name is called */
MPIU_Strncpy(MPIR_Process.comm_world->name, "MPI_COMM_WORLD",
MPI_MAX_OBJECT_NAME);
MPIR_Process.comm_self = MPID_Comm_builtin + 1;
MPIR_Comm_init(MPIR_Process.comm_self);
MPIR_Process.comm_self->handle = MPI_COMM_SELF;
MPIR_Process.comm_self->context_id = 1 << MPID_CONTEXT_PREFIX_SHIFT;
MPIR_Process.comm_self->recvcontext_id = 1 << MPID_CONTEXT_PREFIX_SHIFT;
MPIR_Process.comm_self->comm_kind = MPID_INTRACOMM;
MPIU_Strncpy(MPIR_Process.comm_self->name, "MPI_COMM_SELF",
MPI_MAX_OBJECT_NAME);
#ifdef MPID_NEEDS_ICOMM_WORLD
MPIR_Process.icomm_world = MPID_Comm_builtin + 2;
MPIR_Comm_init(MPIR_Process.icomm_world);
MPIR_Process.icomm_world->handle = MPIR_ICOMM_WORLD;
MPIR_Process.icomm_world->context_id = 2 << MPID_CONTEXT_PREFIX_SHIFT;
MPIR_Process.icomm_world->recvcontext_id= 2 << MPID_CONTEXT_PREFIX_SHIFT;
MPIR_Process.icomm_world->comm_kind = MPID_INTRACOMM;
MPIU_Strncpy(MPIR_Process.icomm_world->name, "MPI_ICOMM_WORLD",
MPI_MAX_OBJECT_NAME);
/* Note that these communicators are not ready for use - MPID_Init
will setup self and world, and icomm_world if it desires it. */
#endif
MPIR_Process.comm_parent = NULL;
/* Setup the initial communicator list in case we have
enabled the debugger message-queue interface */
MPIR_COMML_REMEMBER( MPIR_Process.comm_world );
MPIR_COMML_REMEMBER( MPIR_Process.comm_self );
/* Call any and all MPID_Init type functions */
MPIR_Err_init();
MPIR_Datatype_init();
MPIR_Group_init();
/* MPIU_Timer_pre_init(); */
mpi_errno = MPIR_Param_init_params();
if (mpi_errno) MPIU_ERR_POP(mpi_errno);
/* Wait for debugger to attach if requested. */
if (MPIR_PARAM_DEBUG_HOLD) {
volatile int hold = 1;
while (hold)
#ifdef HAVE_USLEEP
usleep(100);
#endif
;
}
#if HAVE_ERROR_CHECKING == MPID_ERROR_LEVEL_RUNTIME
MPIR_Process.do_error_checks = MPIR_PARAM_ERROR_CHECKING;
#endif
/* define MPI as initialized so that we can use MPI functions within
MPID_Init if necessary */
MPIR_Process.initialized = MPICH_WITHIN_MPI;
/* We can't acquire any critical sections until this point. Any
* earlier the basic data structures haven't been initialized */
MPIU_THREAD_CS_ENTER(INIT,required);
exit_init_cs_on_failure = 1;
mpi_errno = MPID_Init(argc, argv, required, &thread_provided,
&has_args, &has_env);
if (mpi_errno) MPIU_ERR_POP(mpi_errno);
/* Capture the level of thread support provided */
MPIR_ThreadInfo.thread_provided = thread_provided;
if (provided) *provided = thread_provided;
#ifdef HAVE_RUNTIME_THREADCHECK
MPIR_ThreadInfo.isThreaded = (thread_provided == MPI_THREAD_MULTIPLE);
#endif
/* FIXME: Define these in the interface. Does Timer init belong here? */
MPIU_dbg_init(MPIR_Process.comm_world->rank);
MPIU_Timer_init(MPIR_Process.comm_world->rank,
MPIR_Process.comm_world->local_size);
#ifdef USE_MEMORY_TRACING
MPIU_trinit( MPIR_Process.comm_world->rank );
/* Indicate that we are near the end of the init step; memory
allocated already will have an id of zero; this helps
separate memory leaks in the initialization code from
leaks in the "active" code */
/* Uncomment this code to leave out any of the MPID_Init/etc
memory allocations from the memory leak testing */
/* MPIU_trid( 1 ); */
#endif
#ifdef USE_DBG_LOGGING
MPIU_DBG_Init( argc, argv, has_args, has_env,
MPIR_Process.comm_world->rank );
#endif
/* Initialize the C versions of the Fortran link-time constants.
We now initialize the Fortran symbols from within the Fortran
interface in the routine that first needs the symbols.
This fixes a problem with symbols added by a Fortran compiler that
are not part of the C runtime environment (the Portland group
compilers would do this)
*/
#if defined(HAVE_FORTRAN_BINDING) && defined(HAVE_MPI_F_INIT_WORKS_WITH_C)
mpirinitf_();
#endif
/* FIXME: Does this need to come before the call to MPID_InitComplete?
For some debugger support, MPIR_WaitForDebugger may want to use
MPI communication routines to collect information for the debugger */
#ifdef HAVE_DEBUGGER_SUPPORT
MPIR_WaitForDebugger();
#endif
/* Let the device know that the rest of the init process is completed */
if (mpi_errno == MPI_SUCCESS)
mpi_errno = MPID_InitCompleted();
#if defined(_OSU_MVAPICH_) || defined(_OSU_PSM_)
if (is_shmem_collectives_enabled()){
if (check_split_comm(pthread_self())){
int my_id, size;
PMPI_Comm_rank(MPI_COMM_WORLD, &my_id);
PMPI_Comm_size(MPI_COMM_WORLD, &size);
disable_split_comm(pthread_self());
create_2level_comm(MPI_COMM_WORLD, size, my_id);
enable_split_comm(pthread_self());
}
}
#endif /* defined(_OSU_MVAPICH_) || defined(_OSU_PSM_) */
fn_exit:
MPIU_THREAD_CS_EXIT(INIT,required);
return mpi_errno;
fn_fail:
/* --BEGIN ERROR HANDLING-- */
/* signal to error handling routines that core services are unavailable */
MPIR_Process.initialized = MPICH_PRE_INIT;
if (exit_init_cs_on_failure) {
MPIU_THREAD_CS_EXIT(INIT,required);
}
MPIU_THREAD_CS_FINALIZE;
return mpi_errno;
/* --END ERROR HANDLING-- */
}
void SaveArrow(RLOG_IARROW *pArrow)
{
ArrowNode *pNode;
StartArrowStruct *pStart, *pStartIter;
EndArrowStruct *pEnd, *pEndIter;
RLOG_ARROW arrow;
if (g_fArrow == NULL)
{
MPIU_Strncpy(g_pszArrowFilename, "ArrowFile.tmp", 1024);
g_fArrow = fopen(g_pszArrowFilename, "w+b");
if (g_fArrow == NULL)
{
MPIU_Error_printf("unable to open ArrowFile.tmp\n");
return;
}
}
if (pArrow->sendrecv == RLOG_SENDER)
{
pNode = GetArrowNode(pArrow->remote);
pEnd = ExtractEndNode(pNode, pArrow->rank, pArrow->tag);
if (pEnd == NULL)
{
pStart = (StartArrowStruct *)MPIU_Malloc(sizeof(StartArrowStruct));
pStart->src = pArrow->rank;
pStart->tag = pArrow->tag;
pStart->length = pArrow->length;
pStart->start_time = pArrow->timestamp;
pStart->next = NULL;
if (pNode->pStartList == NULL)
{
pNode->pStartList = pStart;
}
else
{
pStartIter = pNode->pStartList;
while (pStartIter->next != NULL)
pStartIter = pStartIter->next;
pStartIter->next = pStart;
}
return;
}
arrow.src = pArrow->rank;
arrow.dest = pArrow->remote;
arrow.length = pArrow->length;
arrow.start_time = pEnd->timestamp;
arrow.end_time = pArrow->timestamp;
arrow.tag = pArrow->tag;
arrow.leftright = RLOG_ARROW_LEFT;
/* fwrite(&arrow, sizeof(RLOG_ARROW), 1, g_fArrow); */
WriteFileData(&arrow, sizeof(RLOG_ARROW), g_fArrow);
MPIU_Free(pEnd);
}
else
{
arrow.dest = pArrow->rank;
arrow.end_time = pArrow->timestamp;
arrow.tag = pArrow->tag;
arrow.length = pArrow->length;
pNode = GetArrowNode(pArrow->rank);
pStart = ExtractStartNode(pNode, pArrow->remote, pArrow->tag);
if (pStart != NULL)
{
arrow.src = pStart->src;
arrow.start_time = pStart->start_time;
arrow.length = pStart->length; /* the sender length is more accurate than the receiver length */
arrow.leftright = RLOG_ARROW_RIGHT;
MPIU_Free(pStart);
/* fwrite(&arrow, sizeof(RLOG_ARROW), 1, g_fArrow); */
WriteFileData(&arrow, sizeof(RLOG_ARROW), g_fArrow);
}
else
{
pEnd = (EndArrowStruct *)MPIU_Malloc(sizeof(EndArrowStruct));
pEnd->src = pArrow->remote;
pEnd->tag = pArrow->tag;
pEnd->timestamp = pArrow->timestamp;
pEnd->next = NULL;
if (pNode->pEndList == NULL)
{
pNode->pEndList = pEnd;
}
else
{
pEndIter = pNode->pEndList;
while (pEndIter->next != NULL)
pEndIter = pEndIter->next;
pEndIter->next = pEnd;
}
}
}
/* fwrite(pArrow, sizeof(RLOG_IARROW), 1, g_fArrow); */
}
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 MPIDU_CH3U_GetSockInterfaceAddr( int myRank, char *ifname, int maxIfname,
MPIDU_Sock_ifaddr_t *ifaddr )
{
char *ifname_string;
int mpi_errno = MPI_SUCCESS;
int ifaddrFound = 0;
if (dbg_ifname < 0) {
int rc;
rc = MPL_env2bool( "MPICH_DBG_IFNAME", &dbg_ifname );
if (rc != 1) dbg_ifname = 0;
}
/* Set "not found" for ifaddr */
ifaddr->len = 0;
/* Check for the name supplied through an environment variable */
ifname_string = getenv("MPICH_INTERFACE_HOSTNAME");
if (!ifname_string) {
/* See if there is a per-process name for the interfaces (e.g.,
the process manager only delievers the same values for the
environment to each process */
char namebuf[1024];
MPL_snprintf( namebuf, sizeof(namebuf),
"MPICH_INTERFACE_HOSTNAME_R%d", myRank );
ifname_string = getenv( namebuf );
if (dbg_ifname && ifname_string) {
fprintf( stdout, "Found interface name %s from %s\n",
ifname_string, namebuf );
fflush( stdout );
}
}
else if (dbg_ifname) {
fprintf( stdout,
"Found interface name %s from MPICH_INTERFACE_HOSTNAME\n",
ifname_string );
fflush( stdout );
}
if (!ifname_string) {
int len;
/* If we have nothing, then use the host name */
mpi_errno = MPID_Get_processor_name(ifname, maxIfname, &len );
if (mpi_errno) MPIR_ERR_POP(mpi_errno);
ifname_string = ifname;
/* If we didn't find a specific name, then try to get an IP address
directly from the available interfaces, if that is supported on
this platform. Otherwise, we'll drop into the next step that uses
the ifname */
mpi_errno = MPIDI_CH3U_GetIPInterface( ifaddr, &ifaddrFound );
if (mpi_errno) MPIR_ERR_POP(mpi_errno);
}
else {
/* Copy this name into the output name */
MPIU_Strncpy( ifname, ifname_string, maxIfname );
}
/* If we don't have an IP address, try to get it from the name */
if (!ifaddrFound) {
struct hostent *info;
/* printf( "Name to check is %s\n", ifname_string ); fflush(stdout); */
info = gethostbyname( ifname_string );
if (info && info->h_addr_list) {
/* Use the primary address */
ifaddr->len = info->h_length;
ifaddr->type = info->h_addrtype;
if (ifaddr->len > sizeof(ifaddr->ifaddr)) {
/* If the address won't fit in the field, reset to
no address */
ifaddr->len = 0;
ifaddr->type = -1;
}
else {
MPIU_Memcpy( ifaddr->ifaddr, info->h_addr_list[0], ifaddr->len );
}
}
}
fn_exit:
return mpi_errno;
fn_fail:
goto fn_exit;
}
int smpd_get_ccp_nodes(int *np, smpd_host_node_t **host_node_ptr_p)
{
smpd_host_node_t *host_node_ptr=NULL, **host_list_tail_p=NULL;
int smpd_node_cnt = 0, np_total, i;
char *p=NULL, *tok=NULL, *next_tok=NULL;
char seps[] = " ,\t\n";
smpd_enter_fn(FCNAME);
if(np == NULL){
smpd_err_printf("Error: Pointer to num procs is NULL\n");
smpd_exit_fn(FCNAME);
return SMPD_FAIL;
}
if(host_node_ptr_p == NULL){
smpd_err_printf("Error: Invalid pointer to host node ptr\n");
smpd_exit_fn(FCNAME);
return SMPD_FAIL;
}
host_list_tail_p = host_node_ptr_p;
*np = -1;
np_total = 0;
/* Get the CCP nodes list
* CCP_NODES = <NUM_OF_HOSTS> <HOST1> <NP_HOST1> <HOST2> <NP_HOST2> ...
*/
p = MPIU_Strdup(getenv("CCP_NODES"));
if(p == NULL){
smpd_err_printf("Error: Unable to get the list of CCP nodes\n");
smpd_exit_fn(FCNAME);
return SMPD_FAIL;
}
smpd_dbg_printf("CCP_NODES = %s\n", p);
tok = strtok_s(p, seps, &next_tok);
if(tok == NULL){
smpd_err_printf("Error: Unable to parse th list of CCP nodes\n");
MPIU_Free(p);
smpd_exit_fn(FCNAME);
return SMPD_FAIL;
}
smpd_node_cnt = atoi(tok);
for(i=0; i<smpd_node_cnt; i++){
char *host;
int np_host;
host = strtok_s(NULL, seps, &next_tok);
if(host == NULL){
smpd_err_printf("Error: Unable to parse the list of CCP nodes\n");
MPIU_Free(p);
smpd_exit_fn(FCNAME);
return SMPD_FAIL;
}
tok = strtok_s(NULL, seps, &next_tok);
if(tok == NULL){
smpd_err_printf("Error: Unable to parse the list of CCP nodes\n");
MPIU_Free(p);
smpd_exit_fn(FCNAME);
return SMPD_FAIL;
}
np_host = atoi(tok);
np_total += np_host;
/* Allocate memory & set node name */
host_node_ptr = (smpd_host_node_t *)MPIU_Malloc(sizeof(smpd_host_node_t));
if(host_node_ptr == NULL){
smpd_err_printf("Unable to allocate memory for smpd host node \n");
MPIU_Free(p);
smpd_exit_fn(FCNAME);
return SMPD_FAIL;
}
host_node_ptr->next = NULL;
host_node_ptr->left = NULL;
host_node_ptr->right = NULL;
host_node_ptr->connected = SMPD_FALSE;
host_node_ptr->connect_cmd_tag = -1;
host_node_ptr->nproc = np_host;
host_node_ptr->alt_host[0] = '\0';
MPIU_Strncpy(host_node_ptr->host, host, SMPD_MAX_HOST_LENGTH);
/* Add the node to the tail of the list */
*host_list_tail_p = host_node_ptr;
host_list_tail_p = &(host_node_ptr->next);
}
*np = np_total;
MPIU_Free(p);
smpd_exit_fn(FCNAME);
return SMPD_SUCCESS;
}
static int GetSockInterfaceAddr(int myRank, char *ifname, int maxIfname,
MPIDU_Sock_ifaddr_t *ifaddr)
{
const char *ifname_string;
int mpi_errno = MPI_SUCCESS;
int ifaddrFound = 0;
MPIU_Assert(maxIfname);
ifname[0] = '\0';
MPIR_ERR_CHKANDJUMP(MPIR_CVAR_CH3_INTERFACE_HOSTNAME && MPIR_CVAR_NEMESIS_TCP_NETWORK_IFACE, mpi_errno, MPI_ERR_OTHER, "**ifname_and_hostname");
/* Set "not found" for ifaddr */
ifaddr->len = 0;
/* Check if user specified ethernet interface name, e.g., ib0, eth1 */
if (MPIR_CVAR_NEMESIS_TCP_NETWORK_IFACE) {
int len;
mpi_errno = MPIDI_Get_IP_for_iface(MPIR_CVAR_NEMESIS_TCP_NETWORK_IFACE, ifaddr, &ifaddrFound);
MPIR_ERR_CHKANDJUMP1(mpi_errno || !ifaddrFound, mpi_errno, MPI_ERR_OTHER, "**iface_notfound", "**iface_notfound %s", MPIR_CVAR_NEMESIS_TCP_NETWORK_IFACE);
MPIU_DBG_MSG_FMT(CH3_CONNECT, VERBOSE, (MPIU_DBG_FDEST,
"ifaddrFound=TRUE ifaddr->type=%d ifaddr->len=%d ifaddr->ifaddr[0-3]=%d.%d.%d.%d",
ifaddr->type, ifaddr->len, ifaddr->ifaddr[0], ifaddr->ifaddr[1], ifaddr->ifaddr[2],
ifaddr->ifaddr[3]));
/* In this case, ifname is only used for debugging purposes */
mpi_errno = MPID_Get_processor_name(ifname, maxIfname, &len );
if (mpi_errno) MPIR_ERR_POP(mpi_errno);
goto fn_exit;
}
/* Check for a host name supplied through an environment variable */
ifname_string = MPIR_CVAR_CH3_INTERFACE_HOSTNAME;
if (!ifname_string) {
/* See if there is a per-process name for the interfaces (e.g.,
the process manager only delievers the same values for the
environment to each process. There's no way to do this with
the param interface, so we need to use getenv() here. */
char namebuf[1024];
MPL_snprintf( namebuf, sizeof(namebuf),
"MPICH_INTERFACE_HOSTNAME_R%d", myRank );
ifname_string = getenv( namebuf );
if (DBG_IFNAME && ifname_string) {
fprintf( stdout, "Found interface name %s from %s\n",
ifname_string, namebuf );
fflush( stdout );
}
}
else if (DBG_IFNAME) {
fprintf( stdout,
"Found interface name %s from MPICH_INTERFACE_HOSTNAME\n",
ifname_string );
fflush( stdout );
}
if (!ifname_string) {
int len;
/* User did not specify a hostname. Look it up. */
mpi_errno = MPID_Get_processor_name(ifname, maxIfname, &len );
if (mpi_errno) MPIR_ERR_POP(mpi_errno);
ifname_string = ifname;
/* If we didn't find a specific name, then try to get an IP address
directly from the available interfaces, if that is supported on
this platform. Otherwise, we'll drop into the next step that uses
the ifname */
mpi_errno = MPIDI_GetIPInterface( ifaddr, &ifaddrFound );
if (mpi_errno) MPIR_ERR_POP(mpi_errno);
}
else {
/* Copy this name into the output name */
MPIU_Strncpy( ifname, ifname_string, maxIfname );
}
/* If we don't have an IP address, try to get it from the name */
if (!ifaddrFound) {
int i;
struct hostent *info = NULL;
for (i = 0; i < MPIR_CVAR_NEMESIS_TCP_HOST_LOOKUP_RETRIES; ++i) {
info = gethostbyname( ifname_string );
if (info || h_errno != TRY_AGAIN)
break;
}
MPIR_ERR_CHKANDJUMP2(!info || !info->h_addr_list, mpi_errno, MPI_ERR_OTHER, "**gethostbyname", "**gethostbyname %s %d", ifname_string, h_errno);
/* Use the primary address */
ifaddr->len = info->h_length;
ifaddr->type = info->h_addrtype;
if (ifaddr->len > sizeof(ifaddr->ifaddr)) {
/* If the address won't fit in the field, reset to
no address */
ifaddr->len = 0;
ifaddr->type = -1;
MPIR_ERR_INTERNAL(mpi_errno, "Address too long to fit in field");
} else {
MPIU_Memcpy( ifaddr->ifaddr, info->h_addr_list[0], ifaddr->len );
}
}
fn_exit:
return mpi_errno;
fn_fail:
goto fn_exit;
}