void mpi_info_get_nthkey_(MPI_Fint *info, int *n, char *key, int *ierr, int keylen) { MPI_Info info_c; int i, tmpkeylen; char *tmpkey; if (key <= (char *) 0) { FPRINTF(stderr, "MPI_Info_get_nthkey: key is an invalid address\n"); MPI_Abort(MPI_COMM_WORLD, 1); } tmpkey = (char *) ADIOI_Malloc((MPI_MAX_INFO_KEY+1) * sizeof(char)); info_c = MPI_Info_f2c(*info); *ierr = MPI_Info_get_nthkey(info_c, *n, tmpkey); tmpkeylen = strlen(tmpkey); if (tmpkeylen <= keylen) { ADIOI_Strncpy(key, tmpkey, tmpkeylen); /* blank pad the remaining space */ for (i=tmpkeylen; i<keylen; i++) key[i] = ' '; } else { /* not enough space */ ADIOI_Strncpy(key, tmpkey, keylen); /* this should be flagged as an error. */ *ierr = MPI_ERR_UNKNOWN; } ADIOI_Free(tmpkey); }
void mpi_file_get_view_(MPI_Fint * fh, MPI_Offset * disp, MPI_Fint * etype, MPI_Fint * filetype, char *datarep, MPI_Fint * ierr, int str_len) { MPI_File fh_c; MPI_Datatype etype_c, filetype_c; int i, tmpreplen; char *tmprep; if (datarep <= (char *) 0) { FPRINTF(stderr, "MPI_File_get_view: datarep is an invalid address\n"); MPI_Abort(MPI_COMM_WORLD, 1); } tmprep = (char *) ADIOI_Malloc((MPI_MAX_DATAREP_STRING + 1) * sizeof(char)); fh_c = MPI_File_f2c(*fh); *ierr = MPI_File_get_view(fh_c, disp, &etype_c, &filetype_c, tmprep); tmpreplen = strlen(tmprep); if (tmpreplen <= str_len) { ADIOI_Strncpy(datarep, tmprep, tmpreplen); /* blank pad the remaining space */ for (i = tmpreplen; i < str_len; i++) datarep[i] = ' '; } else { /* not enough space */ ADIOI_Strncpy(datarep, tmprep, str_len); /* this should be flagged as an error. */ *ierr = MPI_ERR_UNKNOWN; } *etype = MPI_Type_c2f(etype_c); *filetype = MPI_Type_c2f(filetype_c); ADIOI_Free(tmprep); }
void mpi_info_set_(MPI_Fint *info, char *key, char *value, int *ierr, int keylen, int vallen) { MPI_Info info_c; char *newkey, *newvalue; int new_keylen, new_vallen, lead_blanks, i; if (key <= (char *) 0) { FPRINTF(stderr, "MPI_Info_set: key is an invalid address\n"); MPI_Abort(MPI_COMM_WORLD, 1); } if (value <= (char *) 0) { FPRINTF(stderr, "MPI_Info_set: value is an invalid address\n"); MPI_Abort(MPI_COMM_WORLD, 1); } /* strip leading and trailing blanks in key */ lead_blanks = 0; for (i=0; i<keylen; i++) if (key[i] == ' ') lead_blanks++; else break; for (i=keylen-1; i>=0; i--) if (key[i] != ' ') break; if (i < 0) { FPRINTF(stderr, "MPI_Info_set: key is a blank string\n"); MPI_Abort(MPI_COMM_WORLD, 1); } new_keylen = i + 1 - lead_blanks; key += lead_blanks; newkey = (char *) ADIOI_Malloc((new_keylen+1)*sizeof(char)); ADIOI_Strncpy(newkey, key, new_keylen); newkey[new_keylen] = '\0'; /* strip leading and trailing blanks in value */ lead_blanks = 0; for (i=0; i<vallen; i++) if (value[i] == ' ') lead_blanks++; else break; for (i=vallen-1; i>=0; i--) if (value[i] != ' ') break; if (i < 0) { FPRINTF(stderr, "MPI_Info_set: value is a blank string\n"); MPI_Abort(MPI_COMM_WORLD, 1); } new_vallen = i + 1 - lead_blanks; value += lead_blanks; newvalue = (char *) ADIOI_Malloc((new_vallen+1)*sizeof(char)); ADIOI_Strncpy(newvalue, value, new_vallen); newvalue[new_vallen] = '\0'; info_c = MPI_Info_f2c(*info); *ierr = MPI_Info_set(info_c, newkey, newvalue); ADIOI_Free(newkey); ADIOI_Free(newvalue); }
void ADIOI_Shfp_fname(ADIO_File fd, int rank, int *error_code) { int len; char *slash, *ptr, tmp[PATH_MAX]; fd->shared_fp_fname = (char *) ADIOI_Malloc(PATH_MAX); if (!rank) { MPL_create_pathname(tmp, NULL, ".shfp", 0); if (ADIOI_Strncpy(fd->shared_fp_fname, fd->filename, PATH_MAX)) { *error_code = ADIOI_Err_create_code("ADIOI_Shfp_fname", fd->filename, ENAMETOOLONG); return; } #ifdef ROMIO_NTFS slash = strrchr(fd->filename, '\\'); #else slash = strrchr(fd->filename, '/'); #endif if (!slash) { if (ADIOI_Strncpy(fd->shared_fp_fname, ".", 2)) { *error_code = ADIOI_Err_create_code("ADIOI_Shfp_fname", fd->filename, ENAMETOOLONG); return; } if (ADIOI_Strncpy(fd->shared_fp_fname + 1, fd->filename, PATH_MAX - 1)) { *error_code = ADIOI_Err_create_code("ADIOI_Shfp_fname", fd->filename, ENAMETOOLONG); return; } } else { ptr = slash; #ifdef ROMIO_NTFS slash = strrchr(fd->shared_fp_fname, '\\'); #else slash = strrchr(fd->shared_fp_fname, '/'); #endif if (ADIOI_Strncpy(slash + 1, ".", 2)) { *error_code = ADIOI_Err_create_code("ADIOI_Shfp_fname", fd->filename, ENAMETOOLONG); return; } /* ok to cast: file names bounded by PATH_MAX and NAME_MAX */ len = (int) (PATH_MAX - (slash + 2 - fd->shared_fp_fname)); if (ADIOI_Strncpy(slash + 2, ptr + 1, len)) { *error_code = ADIOI_Err_create_code("ADIOI_Shfp_fname", ptr + 1, ENAMETOOLONG); return; } } /* MPL_strnapp will return non-zero if truncated. That's ok */ MPL_strnapp(fd->shared_fp_fname, tmp, PATH_MAX); len = (int) strlen(fd->shared_fp_fname); MPI_Bcast(&len, 1, MPI_INT, 0, fd->comm); MPI_Bcast(fd->shared_fp_fname, len + 1, MPI_CHAR, 0, fd->comm); } else { MPI_Bcast(&len, 1, MPI_INT, 0, fd->comm); MPI_Bcast(fd->shared_fp_fname, len + 1, MPI_CHAR, 0, fd->comm); } }
void mpi_info_get_(MPI_Fint *info, char *key, int *valuelen, char *value, int *flag, int *ierr, int keylen, int valspace) { MPI_Info info_c; char *newkey, *tmpvalue; int new_keylen, lead_blanks, i, tmpvaluelen; if (key <= (char *) 0) { FPRINTF(stderr, "MPI_Info_get: key is an invalid address\n"); MPI_Abort(MPI_COMM_WORLD, 1); } /* strip leading and trailing blanks in key */ lead_blanks = 0; for (i=0; i<keylen; i++) if (key[i] == ' ') lead_blanks++; else break; for (i=keylen-1; i>=0; i--) if (key[i] != ' ') break; if (i < 0) { FPRINTF(stderr, "MPI_Info_get: key is a blank string\n"); MPI_Abort(MPI_COMM_WORLD, 1); } new_keylen = i + 1 - lead_blanks; key += lead_blanks; newkey = (char *) ADIOI_Malloc((new_keylen+1)*sizeof(char)); ADIOI_Strncpy(newkey, key, new_keylen); newkey[new_keylen] = '\0'; if (value <= (char *) 0) { FPRINTF(stderr, "MPI_Info_get: value is an invalid address\n"); MPI_Abort(MPI_COMM_WORLD, 1); } if (*valuelen <= 0) { FPRINTF(stderr, "MPI_Info_get: Invalid valuelen argument\n"); MPI_Abort(MPI_COMM_WORLD, 1); } if (*valuelen > valspace) { FPRINTF(stderr, "MPI_Info_get: valuelen is greater than the amount of memory available in value\n"); MPI_Abort(MPI_COMM_WORLD, 1); } tmpvalue = (char *) ADIOI_Malloc((*valuelen + 1)*sizeof(char)); info_c = MPI_Info_f2c(*info); *ierr = MPI_Info_get(info_c, newkey, *valuelen, tmpvalue, flag); if (*flag) { tmpvaluelen = strlen(tmpvalue); ADIOI_Strncpy(value, tmpvalue, tmpvaluelen); /* blank pad the remaining space */ for (i=tmpvaluelen; i<valspace; i++) value[i] = ' '; } ADIOI_Free(newkey); ADIOI_Free(tmpvalue); }
void mpi_file_get_view_(MPI_Fint * fh, MPI_Offset * disp, MPI_Fint * etype, MPI_Fint * filetype, _fcd datarep_fcd, MPI_Fint * ierr) { char *datarep = _fcdtocp(datarep_fcd); int str_len = _fcdlen(datarep_fcd); #else /* Prototype to keep compiler happy */ FORTRAN_API void FORT_CALL mpi_file_get_view_(MPI_Fint * fh, MPI_Offset * disp, MPI_Fint * etype, MPI_Fint * filetype, char *datarep FORT_MIXED_LEN_DECL, MPI_Fint * ierr FORT_END_LEN_DECL); FORTRAN_API void FORT_CALL mpi_file_get_view_(MPI_Fint * fh, MPI_Offset * disp, MPI_Fint * etype, MPI_Fint * filetype, char *datarep FORT_MIXED_LEN(str_len), MPI_Fint * ierr FORT_END_LEN(str_len)) { #endif MPI_File fh_c; int i, tmpreplen; MPI_Datatype etype_c, filetype_c; char *tmprep; /* Initialize the string to all blanks */ if (datarep <= (char *) 0) { FPRINTF(stderr, "MPI_File_get_view: datarep is an invalid address\n"); MPI_Abort(MPI_COMM_WORLD, 1); } tmprep = (char *) ADIOI_Malloc((MPI_MAX_DATAREP_STRING + 1) * sizeof(char)); fh_c = MPI_File_f2c(*fh); etype_c = MPI_Type_f2c(*etype); filetype_c = MPI_Type_f2c(*filetype); *ierr = MPI_File_get_view(fh_c, disp, &etype_c, &filetype_c, tmprep); tmpreplen = strlen(tmprep); if (tmpreplen <= str_len) { ADIOI_Strncpy(datarep, tmprep, tmpreplen); /* blank pad the remaining space */ for (i = tmpreplen; i < str_len; i++) datarep[i] = ' '; } else { /* not enough space */ ADIOI_Strncpy(datarep, tmprep, str_len); /* this should be flagged as an error. */ *ierr = MPI_ERR_UNKNOWN; } *etype = MPI_Type_c2f(etype_c); *filetype = MPI_Type_c2f(filetype_c); ADIOI_Free(tmprep); }
void ADIOI_Shfp_fname(ADIO_File fd, int rank) { double tm; int i, len; char *slash, *ptr, tmp[128]; fd->shared_fp_fname = (char *) ADIOI_Malloc(256); if (!rank) { tm = MPI_Wtime(); while (tm > 1000000000.0) tm -= 1000000000.0; i = (int) tm; tm = tm - (double) i; tm *= 1000000.0; i = (int) tm; ADIOI_Strncpy(fd->shared_fp_fname, fd->filename, 256); #ifdef ROMIO_NTFS slash = strrchr(fd->filename, '\\'); #else slash = strrchr(fd->filename, '/'); #endif if (!slash) { ADIOI_Strncpy(fd->shared_fp_fname, ".", 2); ADIOI_Strncpy(fd->shared_fp_fname + 1, fd->filename, 255); } else { ptr = slash; #ifdef ROMIO_NTFS slash = strrchr(fd->shared_fp_fname, '\\'); #else slash = strrchr(fd->shared_fp_fname, '/'); #endif ADIOI_Strncpy(slash + 1, ".", 2); len = 256 - (slash+2 - fd->shared_fp_fname); ADIOI_Strncpy(slash + 2, ptr + 1, len); } ADIOI_Snprintf(tmp, 128, ".shfp.%d", i); ADIOI_Strnapp(fd->shared_fp_fname, tmp, 256); len = (int)strlen(fd->shared_fp_fname); MPI_Bcast(&len, 1, MPI_INT, 0, fd->comm); MPI_Bcast(fd->shared_fp_fname, len+1, MPI_CHAR, 0, fd->comm); } else { MPI_Bcast(&len, 1, MPI_INT, 0, fd->comm); MPI_Bcast(fd->shared_fp_fname, len+1, MPI_CHAR, 0, fd->comm); } }
void mpi_file_open_(MPI_Fint *comm,char *filename,MPI_Fint *amode, MPI_Fint *info, MPI_Fint *fh, MPI_Fint *ierr, int str_len ) { char *newfname; MPI_File fh_c; int real_len, i; MPI_Comm comm_c; MPI_Info info_c; comm_c = MPI_Comm_f2c(*comm); info_c = MPI_Info_f2c(*info); /* strip trailing blanks */ if (filename <= (char *) 0) { FPRINTF(stderr, "MPI_File_open: filename is an invalid address\n"); MPI_Abort(MPI_COMM_WORLD, 1); } for (i=str_len-1; i>=0; i--) if (filename[i] != ' ') break; if (i < 0) { FPRINTF(stderr, "MPI_File_open: filename is a blank string\n"); MPI_Abort(MPI_COMM_WORLD, 1); } real_len = i + 1; newfname = (char *) ADIOI_Malloc((real_len+1)*sizeof(char)); ADIOI_Strncpy(newfname, filename, real_len); newfname[real_len] = '\0'; *ierr = MPI_File_open(comm_c, newfname, *amode, info_c, &fh_c); *fh = MPI_File_c2f(fh_c); ADIOI_Free(newfname); }
/*@ MPI_File_get_view - Returns the file view Input Parameters: . fh - file handle (handle) Output Parameters: . disp - displacement (nonnegative integer) . etype - elementary datatype (handle) . filetype - filetype (handle) . datarep - data representation (string) .N fortran @*/ int MPI_File_get_view(MPI_File fh, MPI_Offset * disp, MPI_Datatype * etype, MPI_Datatype * filetype, char *datarep) { int error_code; ADIO_File adio_fh; static char myname[] = "MPI_FILE_GET_VIEW"; int i, j, k, combiner; MPI_Datatype copy_etype, copy_filetype; ROMIO_THREAD_CS_ENTER(); adio_fh = MPIO_File_resolve(fh); /* --BEGIN ERROR HANDLING-- */ MPIO_CHECK_FILE_HANDLE(adio_fh, myname, error_code); if (datarep == NULL) { error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, myname, __LINE__, MPI_ERR_ARG, "**iodatarepnomem", 0); error_code = MPIO_Err_return_file(adio_fh, error_code); goto fn_exit; } /* --END ERROR HANDLING-- */ *disp = adio_fh->disp; ADIOI_Strncpy(datarep, (adio_fh->is_external32 ? "external32" : "native"), MPI_MAX_DATAREP_STRING); MPI_Type_get_envelope(adio_fh->etype, &i, &j, &k, &combiner); if (combiner == MPI_COMBINER_NAMED) *etype = adio_fh->etype; else { /* FIXME: It is wrong to use MPI_Type_contiguous; the user could choose to * re-implement MPI_Type_contiguous in an unexpected way. Either use * MPID_Barrier as in MPICH or PMPI_Type_contiguous */ MPI_Type_contiguous(1, adio_fh->etype, ©_etype); /* FIXME: Ditto for MPI_Type_commit - use NMPI or PMPI */ MPI_Type_commit(©_etype); *etype = copy_etype; } /* FIXME: Ditto for MPI_Type_xxx - use NMPI or PMPI */ MPI_Type_get_envelope(adio_fh->filetype, &i, &j, &k, &combiner); if (combiner == MPI_COMBINER_NAMED) *filetype = adio_fh->filetype; else { MPI_Type_contiguous(1, adio_fh->filetype, ©_filetype); MPI_Type_commit(©_filetype); *filetype = copy_filetype; } fn_exit: ROMIO_THREAD_CS_EXIT(); return MPI_SUCCESS; }
void mpi_file_open_(MPI_Fint *comm,_fcd filename_fcd,MPI_Fint *amode, MPI_Fint *info, MPI_Fint *fh, MPI_Fint *ierr) { char *filename = _fcdtocp(filename_fcd); int str_len = _fcdlen(filename_fcd); #else /* Prototype to keep compiler happy */ /* FORTRAN_API void FORT_CALL mpi_file_open_(MPI_Comm *comm,char *filename,MPI_Fint *amode, MPI_Fint *info, MPI_Fint *fh, MPI_Fint *ierr, int str_len ); FORTRAN_API void FORT_CALL mpi_file_open_(MPI_Comm *comm,char *filename,MPI_Fint *amode, MPI_Fint *info, MPI_Fint *fh, MPI_Fint *ierr, int str_len ) */ /* Prototype to keep compiler happy */ FORTRAN_API void FORT_CALL mpi_file_open_(MPI_Fint *comm,char *filename FORT_MIXED_LEN_DECL,MPI_Fint *amode, MPI_Fint *info, MPI_Fint *fh, MPI_Fint *ierr FORT_END_LEN_DECL); FORTRAN_API void FORT_CALL mpi_file_open_(MPI_Fint *comm,char *filename FORT_MIXED_LEN(str_len),MPI_Fint *amode, MPI_Fint *info, MPI_Fint *fh, MPI_Fint *ierr FORT_END_LEN(str_len)) { #endif char *newfname; MPI_File fh_c; int real_len, i; MPI_Info info_c; info_c = MPI_Info_f2c(*info); /* strip trailing blanks */ if (filename <= (char *) 0) { FPRINTF(stderr, "MPI_File_open: filename is an invalid address\n"); MPI_Abort(MPI_COMM_WORLD, 1); } for (i=str_len-1; i>=0; i--) if (filename[i] != ' ') break; if (i < 0) { FPRINTF(stderr, "MPI_File_open: filename is a blank string\n"); MPI_Abort(MPI_COMM_WORLD, 1); } real_len = i + 1; newfname = (char *) ADIOI_Malloc((real_len+1)*sizeof(char)); ADIOI_Strncpy(newfname, filename, real_len); newfname[real_len] = '\0'; *ierr = MPI_File_open((MPI_Comm)(*comm), newfname, *amode, info_c, &fh_c); *fh = MPI_File_c2f(fh_c); ADIOI_Free(newfname); }
/* ADIO_FileSysType_parentdir * * Returns pointer to string in dirnamep; that string is allocated with * strdup and must be free()'d. */ static void ADIO_FileSysType_parentdir(const char *filename, char **dirnamep) { int err; char *dir = NULL, *slash; struct stat statbuf; err = lstat(filename, &statbuf); if (err || (!S_ISLNK(statbuf.st_mode))) { /* no such file, or file is not a link; these are the "normal" * cases where we can just return the parent directory. */ dir = ADIOI_Strdup(filename); } else { /* filename is a symlink. we've presumably already tried * to stat it and found it to be missing (dangling link), * but this code doesn't care if the target is really there * or not. */ ssize_t namelen; char *linkbuf; linkbuf = ADIOI_Malloc(PATH_MAX+1); namelen = readlink(filename, linkbuf, PATH_MAX+1); if (namelen == -1) { /* something strange has happened between the time that * we determined that this was a link and the time that * we attempted to read it; punt and use the old name. */ dir = ADIOI_Strdup(filename); } else { /* successfully read the link */ linkbuf[namelen] = '\0'; /* readlink doesn't null terminate */ dir = ADIOI_Strdup(linkbuf); } ADIOI_Free(linkbuf); } slash = strrchr(dir, '/'); if (!slash) ADIOI_Strncpy(dir, ".", 2); else { if (slash == dir) *(dir + 1) = '\0'; else *slash = '\0'; } *dirnamep = dir; return; }
/*@ MPI_Info_get - Retrieves the value associated with a key Input Parameters: . info - info object (handle) . key - key (string) . valuelen - length of value argument (integer) Output Parameters: . value - value (string) . flag - true if key defined, false if not (boolean) .N fortran @*/ int MPI_Info_get(MPI_Info info, char *key, int valuelen, char *value, int *flag) { MPI_Info curr; if ((info <= (MPI_Info) 0) || (info->cookie != MPIR_INFO_COOKIE)) { FPRINTF(stderr, "MPI_Info_get: Invalid info object\n"); MPI_Abort(MPI_COMM_WORLD, 1); } if (key <= (char *) 0) { FPRINTF(stderr, "MPI_Info_get: key is an invalid address\n"); MPI_Abort(MPI_COMM_WORLD, 1); } if (strlen(key) > MPI_MAX_INFO_KEY) { FPRINTF(stderr, "MPI_Info_get: key is longer than MPI_MAX_INFO_KEY\n"); MPI_Abort(MPI_COMM_WORLD, 1); } if (!strlen(key)) { FPRINTF(stderr, "MPI_Info_get: key is a null string\n"); MPI_Abort(MPI_COMM_WORLD, 1); } if (valuelen <= 0) { FPRINTF(stderr, "MPI_Info_get: Invalid valuelen argument\n"); MPI_Abort(MPI_COMM_WORLD, 1); } if (value <= (char *) 0) { FPRINTF(stderr, "MPI_Info_get: value is an invalid address\n"); MPI_Abort(MPI_COMM_WORLD, 1); } curr = info->next; *flag = 0; while (curr) { if (!strcmp(curr->key, key)) { ADIOI_Strncpy(value, curr->value, valuelen); value[valuelen] = '\0'; *flag = 1; break; } curr = curr->next; } return MPI_SUCCESS; }
static int cb_config_list_lex(void) { int slen; if (*token_ptr == '\0') return AGG_EOS; slen = (int)strcspn(token_ptr, DELIMS); if (*token_ptr == COLON) { token_ptr++; return AGG_COLON; } if (*token_ptr == COMMA) { token_ptr++; return AGG_COMMA; } if (*token_ptr == '*') { /* make sure that we don't have characters after the '*' */ if (slen == 1) { token_ptr++; return AGG_WILDCARD; } else return AGG_ERROR; } /* last case: some kind of string. for now we copy the string. */ /* it would be a good idea to look at the string and make sure that * it doesn't have any illegal characters in it. in particular we * should ensure that no one tries to use wildcards with strings * (e.g. "ccn*"). */ ADIOI_Strncpy(yylval, token_ptr, slen); yylval[slen] = '\0'; token_ptr += slen; return AGG_STRING; }
/*@ MPI_Info_get_nthkey - Returns the nth defined key in info Input Parameters: . info - info object (handle) . n - key number (integer) Output Parameters: . keys - key (string) .N fortran @*/ int MPI_Info_get_nthkey(MPI_Info info, int n, char *key) { MPI_Info curr; int nkeys, i; if ((info <= (MPI_Info) 0) || (info->cookie != MPIR_INFO_COOKIE)) { FPRINTF(stderr, "MPI_Info_get_nthkey: Invalid info object\n"); MPI_Abort(MPI_COMM_WORLD, 1); } if (key <= (char *) 0) { FPRINTF(stderr, "MPI_Info_get: key is an invalid address\n"); MPI_Abort(MPI_COMM_WORLD, 1); } curr = info->next; nkeys = 0; while (curr) { curr = curr->next; nkeys++; } if ((n < 0) || (n >= nkeys)) { FPRINTF(stderr, "MPI_Info_get_nthkey: n is an invalid number\n"); MPI_Abort(MPI_COMM_WORLD, 1); } curr = info->next; i = 0; while (i < n) { curr = curr->next; i++; } ADIOI_Strncpy(key, curr->key, MPI_MAX_INFO_KEY); return MPI_SUCCESS; }
void ADIOI_GEN_SetInfo(ADIO_File fd, MPI_Info users_info, int *error_code) { /* if fd->info is null, create a new info object. Initialize fd->info to default values. Initialize fd->hints to default values. Examine the info object passed by the user. If it contains values that ROMIO understands, override the default. */ MPI_Info info; char *value; int flag, nprocs = 0, len; int ok_to_override_cb_nodes = 0; static char myname[] = "ADIOI_GEN_SETINFO"; /* if we've already set up default hints and the user has not asked us to * process any hints (MPI_INFO_NULL), then we can short-circuit hint * processing */ if (fd->hints->initialized && fd->info == MPI_INFO_NULL) { *error_code = MPI_SUCCESS; return; } ad_get_env_vars(); if (fd->info == MPI_INFO_NULL) MPI_Info_create(&(fd->info)); info = fd->info; MPI_Comm_size(fd->comm, &nprocs); /* Note that fd->hints is allocated at file open time; thus it is * not necessary to allocate it, or check for allocation, here. */ value = (char *) ADIOI_Malloc((MPI_MAX_INFO_VAL + 1) * sizeof(char)); if (value == NULL) { *error_code = MPIO_Err_create_code(*error_code, MPIR_ERR_RECOVERABLE, myname, __LINE__, MPI_ERR_OTHER, "**nomem2", 0); return; } /* initialize info and hints to default values if they haven't been * previously initialized */ if (!fd->hints->initialized) { /* buffer size for collective I/O */ ADIOI_Info_set(info, "cb_buffer_size", ADIOI_CB_BUFFER_SIZE_DFLT); fd->hints->cb_buffer_size = atoi(ADIOI_CB_BUFFER_SIZE_DFLT); /* default is to let romio automatically decide when to use * collective buffering */ ADIOI_Info_set(info, "romio_cb_read", "automatic"); fd->hints->cb_read = ADIOI_HINT_AUTO; ADIOI_Info_set(info, "romio_cb_write", "automatic"); fd->hints->cb_write = ADIOI_HINT_AUTO; fd->hints->cb_config_list = NULL; /* number of processes that perform I/O in collective I/O */ MPL_snprintf(value, MPI_MAX_INFO_VAL + 1, "%d", nprocs); ADIOI_Info_set(info, "cb_nodes", value); fd->hints->cb_nodes = nprocs; /* hint indicating that no indep. I/O will be performed on this file */ ADIOI_Info_set(info, "romio_no_indep_rw", "false"); fd->hints->no_indep_rw = 0; /* hint instructing the use of persistent file realms */ ADIOI_Info_set(info, "romio_cb_pfr", "disable"); fd->hints->cb_pfr = ADIOI_HINT_DISABLE; /* hint guiding the assignment of persistent file realms */ ADIOI_Info_set(info, "romio_cb_fr_types", "aar"); fd->hints->cb_fr_type = ADIOI_FR_AAR; /* hint to align file realms with a certain byte value */ ADIOI_Info_set(info, "romio_cb_fr_alignment", "1"); fd->hints->cb_fr_alignment = 1; /* hint to set a threshold percentage for a datatype's size/extent at * which data sieving should be done in collective I/O */ ADIOI_Info_set(info, "romio_cb_ds_threshold", "0"); fd->hints->cb_ds_threshold = 0; /* hint to switch between point-to-point or all-to-all for two-phase */ ADIOI_Info_set(info, "romio_cb_alltoall", "automatic"); fd->hints->cb_alltoall = ADIOI_HINT_AUTO; /* deferred_open derived from no_indep_rw and cb_{read,write} */ fd->hints->deferred_open = 0; /* buffer size for data sieving in independent reads */ ADIOI_Info_set(info, "ind_rd_buffer_size", ADIOI_IND_RD_BUFFER_SIZE_DFLT); fd->hints->ind_rd_buffer_size = atoi(ADIOI_IND_RD_BUFFER_SIZE_DFLT); /* buffer size for data sieving in independent writes */ ADIOI_Info_set(info, "ind_wr_buffer_size", ADIOI_IND_WR_BUFFER_SIZE_DFLT); fd->hints->ind_wr_buffer_size = atoi(ADIOI_IND_WR_BUFFER_SIZE_DFLT); /* default is to let romio automatically decide when to use data * sieving */ ADIOI_Info_set(info, "romio_ds_read", "automatic"); fd->hints->ds_read = ADIOI_HINT_AUTO; ADIOI_Info_set(info, "romio_ds_write", "automatic"); fd->hints->ds_write = ADIOI_HINT_AUTO; /* still to do: tune this a bit for a variety of file systems. there's * no good default value so just leave it unset */ fd->hints->min_fdomain_size = 0; fd->hints->striping_unit = 0; fd->hints->initialized = 1; /* ADIO_Open sets up collective buffering arrays. If we are in this * path from say set_file_view, then we've don't want to adjust the * array: we'll get a segfault during collective i/o. We only want to * look at the users cb_nodes if it's open time */ ok_to_override_cb_nodes = 1; } /* add in user's info if supplied */ if (users_info != MPI_INFO_NULL) { ADIOI_Info_check_and_install_int(fd, users_info, "cb_buffer_size", &(fd->hints->cb_buffer_size), myname, error_code); /* aligning file realms to certain sizes (e.g. stripe sizes) * may benefit I/O performance */ ADIOI_Info_check_and_install_int(fd, users_info, "romio_cb_fr_alignment", &(fd->hints->cb_fr_alignment), myname, error_code); /* for collective I/O, try to be smarter about when to do data sieving * using a specific threshold for the datatype size/extent * (percentage 0-100%) */ ADIOI_Info_check_and_install_int(fd, users_info, "romio_cb_ds_threshold", &(fd->hints->cb_ds_threshold), myname, error_code); ADIOI_Info_check_and_install_enabled(fd, users_info, "romio_cb_alltoall", &(fd->hints->cb_alltoall), myname, error_code); /* new hints for enabling/disabling coll. buffering on * reads/writes */ ADIOI_Info_check_and_install_enabled(fd, users_info, "romio_cb_read", &(fd->hints->cb_read), myname, error_code); if (fd->hints->cb_read == ADIOI_HINT_DISABLE) { /* romio_cb_read overrides no_indep_rw */ ADIOI_Info_set(info, "romio_no_indep_rw", "false"); fd->hints->no_indep_rw = ADIOI_HINT_DISABLE; } ADIOI_Info_check_and_install_enabled(fd, users_info, "romio_cb_write", &(fd->hints->cb_write), myname, error_code); if (fd->hints->cb_write == ADIOI_HINT_DISABLE) { /* romio_cb_write overrides no_indep_rw */ ADIOI_Info_set(info, "romio_no_indep_rw", "false"); fd->hints->no_indep_rw = ADIOI_HINT_DISABLE; } /* enable/disable persistent file realms for collective I/O */ /* may want to check for no_indep_rdwr hint as well */ ADIOI_Info_check_and_install_enabled(fd, users_info, "romio_cb_pfr", &(fd->hints->cb_pfr), myname, error_code); /* file realm assignment types ADIOI_FR_AAR(0), * ADIOI_FR_FSZ(-1), ADIOI_FR_USR_REALMS(-2), all others specify * a regular fr size in bytes. probably not the best way... */ ADIOI_Info_check_and_install_int(fd, users_info, "romio_cb_fr_type", &(fd->hints->cb_fr_type), myname, error_code); /* Has the user indicated all I/O will be done collectively? */ ADIOI_Info_check_and_install_true(fd, users_info, "romio_no_indep_rw", &(fd->hints->no_indep_rw), myname, error_code); if (fd->hints->no_indep_rw == 1) { /* if 'no_indep_rw' set, also hint that we will do * collective buffering: if we aren't doing independent io, * then we have to do collective */ ADIOI_Info_set(info, "romio_cb_write", "enable"); ADIOI_Info_set(info, "romio_cb_read", "enable"); fd->hints->cb_read = 1; fd->hints->cb_write = 1; } /* new hints for enabling/disabling data sieving on * reads/writes */ ADIOI_Info_check_and_install_enabled(fd, users_info, "romio_ds_read", &(fd->hints->ds_read), myname, error_code); ADIOI_Info_check_and_install_enabled(fd, users_info, "romio_ds_write", &(fd->hints->ds_write), myname, error_code); if (ok_to_override_cb_nodes) { /* MPI_File_open path sets up some data structrues that don't * get resized in the MPI_File_set_view path, so ignore * cb_nodes in the set_view case */ ADIOI_Info_check_and_install_int(fd, users_info, "cb_nodes", &(fd->hints->cb_nodes), myname, error_code); if ((fd->hints->cb_nodes <= 0) || (fd->hints->cb_nodes > nprocs)) { /* can't ask for more aggregators than mpi processes, though it * might be interesting to think what such oversubscription * might mean... someday */ MPL_snprintf(value, MPI_MAX_INFO_VAL + 1, "%d", nprocs); ADIOI_Info_set(info, "cb_nodes", value); fd->hints->cb_nodes = nprocs; } } /* if (ok_to_override_cb_nodes) */ ADIOI_Info_check_and_install_int(fd, users_info, "ind_wr_buffer_size", &(fd->hints->ind_wr_buffer_size), myname, error_code); ADIOI_Info_check_and_install_int(fd, users_info, "ind_rd_buffer_size", &(fd->hints->ind_rd_buffer_size), myname, error_code); if (fd->hints->cb_config_list == NULL) { /* only set cb_config_list if it isn't already set. Note that * since we set it below, this ensures that the cb_config_list hint * will be set at file open time either by the user or to the * default */ /* if it has been set already, we ignore it the second time. * otherwise we would get an error if someone used the same info * value with a cb_config_list value in it in a couple of calls, * which would be irritating. */ ADIOI_Info_check_and_install_str(fd, users_info, "cb_config_list", &(fd->hints->cb_config_list), myname, error_code); } ADIOI_Info_check_and_install_int(fd, users_info, "romio_min_fdomain_size", &(fd->hints->min_fdomain_size), myname, error_code); /* Now we use striping unit in common code so we should * process hints for it. */ ADIOI_Info_check_and_install_int(fd, users_info, "striping_unit", &(fd->hints->striping_unit), myname, error_code); } /* Begin hint post-processig: some hints take precidence over or conflict * with others, or aren't supported by some file systems */ /* handle cb_config_list default value here; avoids an extra * free/alloc and insures it is always set */ if (fd->hints->cb_config_list == NULL) { ADIOI_Info_set(info, "cb_config_list", ADIOI_CB_CONFIG_LIST_DFLT); len = (strlen(ADIOI_CB_CONFIG_LIST_DFLT) + 1) * sizeof(char); fd->hints->cb_config_list = ADIOI_Malloc(len); if (fd->hints->cb_config_list == NULL) { ADIOI_Free(value); *error_code = MPIO_Err_create_code(*error_code, MPIR_ERR_RECOVERABLE, myname, __LINE__, MPI_ERR_OTHER, "**nomem2", 0); return; } ADIOI_Strncpy(fd->hints->cb_config_list, ADIOI_CB_CONFIG_LIST_DFLT, len); } /* deferred_open won't be set by callers, but if the user doesn't * explicitly disable collecitve buffering (two-phase) and does hint that * io w/o independent io is going on, we'll set this internal hint as a * convenience */ if (((fd->hints->cb_read != ADIOI_HINT_DISABLE) && (fd->hints->cb_write != ADIOI_HINT_DISABLE) && fd->hints->no_indep_rw)) { fd->hints->deferred_open = 1; } else { /* setting romio_no_indep_rw enable and romio_cb_{read,write} * disable at the same time doesn't make sense. honor * romio_cb_{read,write} and force the no_indep_rw hint to * 'disable' */ ADIOI_Info_set(info, "romio_no_indep_rw", "false"); fd->hints->no_indep_rw = 0; fd->hints->deferred_open = 0; } if (ADIO_Feature(fd, ADIO_DATA_SIEVING_WRITES) == 0) { /* disable data sieving for fs that do not * support file locking */ ADIOI_Info_get(info, "ind_wr_buffer_size", MPI_MAX_INFO_VAL, value, &flag); if (flag) { /* get rid of this value if it is set */ ADIOI_Info_delete(info, "ind_wr_buffer_size"); } /* note: leave ind_wr_buffer_size alone; used for other cases * as well. -- Rob Ross, 04/22/2003 */ ADIOI_Info_set(info, "romio_ds_write", "disable"); fd->hints->ds_write = ADIOI_HINT_DISABLE; } ADIOI_Free(value); *error_code = MPI_SUCCESS; }
void ADIOI_GEN_SetInfo(ADIO_File fd, MPI_Info users_info, int *error_code) { /* if fd->info is null, create a new info object. Initialize fd->info to default values. Initialize fd->hints to default values. Examine the info object passed by the user. If it contains values that ROMIO understands, override the default. */ MPI_Info info; char *value; int flag, intval, tmp_val, nprocs=0, nprocs_is_valid = 0, len; static char myname[] = "ADIOI_GEN_SETINFO"; if (fd->info == MPI_INFO_NULL) MPI_Info_create(&(fd->info)); info = fd->info; /* Note that fd->hints is allocated at file open time; thus it is * not necessary to allocate it, or check for allocation, here. */ value = (char *) ADIOI_Malloc((MPI_MAX_INFO_VAL+1)*sizeof(char)); if (value == NULL) { /* NEED TO HANDLE ENOMEM */ } /* initialize info and hints to default values if they haven't been * previously initialized */ if (!fd->hints->initialized) { /* buffer size for collective I/O */ MPI_Info_set(info, "cb_buffer_size", ADIOI_CB_BUFFER_SIZE_DFLT); fd->hints->cb_buffer_size = atoi(ADIOI_CB_BUFFER_SIZE_DFLT); /* default is to let romio automatically decide when to use * collective buffering */ MPI_Info_set(info, "romio_cb_read", "automatic"); fd->hints->cb_read = ADIOI_HINT_AUTO; MPI_Info_set(info, "romio_cb_write", "automatic"); fd->hints->cb_write = ADIOI_HINT_AUTO; fd->hints->cb_config_list = NULL; /* number of processes that perform I/O in collective I/O */ MPI_Comm_size(fd->comm, &nprocs); nprocs_is_valid = 1; ADIOI_Snprintf(value, MPI_MAX_INFO_VAL+1, "%d", nprocs); MPI_Info_set(info, "cb_nodes", value); fd->hints->cb_nodes = nprocs; /* hint indicating that no indep. I/O will be performed on this file */ MPI_Info_set(info, "romio_no_indep_rw", "false"); fd->hints->no_indep_rw = 0; /* deferred_open derrived from no_indep_rw and cb_{read,write} */ fd->hints->deferred_open = 0; /* buffer size for data sieving in independent reads */ MPI_Info_set(info, "ind_rd_buffer_size", ADIOI_IND_RD_BUFFER_SIZE_DFLT); fd->hints->ind_rd_buffer_size = atoi(ADIOI_IND_RD_BUFFER_SIZE_DFLT); /* buffer size for data sieving in independent writes */ MPI_Info_set(info, "ind_wr_buffer_size", ADIOI_IND_WR_BUFFER_SIZE_DFLT); fd->hints->ind_wr_buffer_size = atoi(ADIOI_IND_WR_BUFFER_SIZE_DFLT); /* default is to let romio automatically decide when to use data * sieving */ MPI_Info_set(info, "romio_ds_read", "automatic"); fd->hints->ds_read = ADIOI_HINT_AUTO; MPI_Info_set(info, "romio_ds_write", "automatic"); fd->hints->ds_write = ADIOI_HINT_AUTO; fd->hints->initialized = 1; } /* add in user's info if supplied */ if (users_info != MPI_INFO_NULL) { MPI_Info_get(users_info, "cb_buffer_size", MPI_MAX_INFO_VAL, value, &flag); if (flag && ((intval=atoi(value)) > 0)) { tmp_val = intval; MPI_Bcast(&tmp_val, 1, MPI_INT, 0, fd->comm); /* --BEGIN ERROR HANDLING-- */ if (tmp_val != intval) { MPIO_ERR_CREATE_CODE_INFO_NOT_SAME(myname, "cb_buffer_size", error_code); return; } /* --END ERROR HANDLING-- */ MPI_Info_set(info, "cb_buffer_size", value); fd->hints->cb_buffer_size = intval; } /* new hints for enabling/disabling coll. buffering on * reads/writes */ MPI_Info_get(users_info, "romio_cb_read", MPI_MAX_INFO_VAL, value, &flag); if (flag) { if (!strcmp(value, "enable") || !strcmp(value, "ENABLE")) { MPI_Info_set(info, "romio_cb_read", value); fd->hints->cb_read = ADIOI_HINT_ENABLE; } else if (!strcmp(value, "disable") || !strcmp(value, "DISABLE")) { /* romio_cb_read overrides no_indep_rw */ MPI_Info_set(info, "romio_cb_read", value); MPI_Info_set(info, "romio_no_indep_rw", "false"); fd->hints->cb_read = ADIOI_HINT_DISABLE; fd->hints->no_indep_rw = ADIOI_HINT_DISABLE; } else if (!strcmp(value, "automatic") || !strcmp(value, "AUTOMATIC")) { MPI_Info_set(info, "romio_cb_read", value); fd->hints->cb_read = ADIOI_HINT_AUTO; } tmp_val = fd->hints->cb_read; MPI_Bcast(&tmp_val, 1, MPI_INT, 0, fd->comm); /* --BEGIN ERROR HANDLING-- */ if (tmp_val != fd->hints->cb_read) { MPIO_ERR_CREATE_CODE_INFO_NOT_SAME(myname, "romio_cb_read", error_code); return; } /* --END ERROR HANDLING-- */ } MPI_Info_get(users_info, "romio_cb_write", MPI_MAX_INFO_VAL, value, &flag); if (flag) { if (!strcmp(value, "enable") || !strcmp(value, "ENABLE")) { MPI_Info_set(info, "romio_cb_write", value); fd->hints->cb_write = ADIOI_HINT_ENABLE; } else if (!strcmp(value, "disable") || !strcmp(value, "DISABLE")) { /* romio_cb_write overrides no_indep_rw, too */ MPI_Info_set(info, "romio_cb_write", value); MPI_Info_set(info, "romio_no_indep_rw", "false"); fd->hints->cb_write = ADIOI_HINT_DISABLE; fd->hints->no_indep_rw = ADIOI_HINT_DISABLE; } else if (!strcmp(value, "automatic") || !strcmp(value, "AUTOMATIC")) { MPI_Info_set(info, "romio_cb_write", value); fd->hints->cb_write = ADIOI_HINT_AUTO; } tmp_val = fd->hints->cb_write; MPI_Bcast(&tmp_val, 1, MPI_INT, 0, fd->comm); /* --BEGIN ERROR HANDLING-- */ if (tmp_val != fd->hints->cb_write) { MPIO_ERR_CREATE_CODE_INFO_NOT_SAME(myname, "romio_cb_write", error_code); return; } /* --END ERROR HANDLING-- */ } /* new hint for specifying no indep. read/write will be performed */ MPI_Info_get(users_info, "romio_no_indep_rw", MPI_MAX_INFO_VAL, value, &flag); if (flag) { if (!strcmp(value, "true") || !strcmp(value, "TRUE")) { /* if 'no_indep_rw' set, also hint that we will do * collective buffering: if we aren't doing independent io, * then we have to do collective */ MPI_Info_set(info, "romio_no_indep_rw", value); MPI_Info_set(info, "romio_cb_write", "enable"); MPI_Info_set(info, "romio_cb_read", "enable"); fd->hints->no_indep_rw = 1; fd->hints->cb_read = 1; fd->hints->cb_write = 1; tmp_val = 1; } else if (!strcmp(value, "false") || !strcmp(value, "FALSE")) { MPI_Info_set(info, "romio_no_indep_rw", value); fd->hints->no_indep_rw = 0; tmp_val = 0; } else { /* default is above */ tmp_val = 0; } MPI_Bcast(&tmp_val, 1, MPI_INT, 0, fd->comm); /* --BEGIN ERROR HANDLING-- */ if (tmp_val != fd->hints->no_indep_rw) { MPIO_ERR_CREATE_CODE_INFO_NOT_SAME(myname, "romio_no_indep_rw", error_code); return; } /* --END ERROR HANDLING-- */ } /* new hints for enabling/disabling data sieving on * reads/writes */ MPI_Info_get(users_info, "romio_ds_read", MPI_MAX_INFO_VAL, value, &flag); if (flag) { if (!strcmp(value, "enable") || !strcmp(value, "ENABLE")) { MPI_Info_set(info, "romio_ds_read", value); fd->hints->ds_read = ADIOI_HINT_ENABLE; } else if (!strcmp(value, "disable") || !strcmp(value, "DISABLE")) { MPI_Info_set(info, "romio_ds_read", value); fd->hints->ds_read = ADIOI_HINT_DISABLE; } else if (!strcmp(value, "automatic") || !strcmp(value, "AUTOMATIC")) { MPI_Info_set(info, "romio_ds_read", value); fd->hints->ds_read = ADIOI_HINT_AUTO; } /* otherwise ignore */ } MPI_Info_get(users_info, "romio_ds_write", MPI_MAX_INFO_VAL, value, &flag); if (flag) { if (!strcmp(value, "enable") || !strcmp(value, "ENABLE")) { MPI_Info_set(info, "romio_ds_write", value); fd->hints->ds_write = ADIOI_HINT_ENABLE; } else if (!strcmp(value, "disable") || !strcmp(value, "DISABLE")) { MPI_Info_set(info, "romio_ds_write", value); fd->hints->ds_write = ADIOI_HINT_DISABLE; } else if (!strcmp(value, "automatic") || !strcmp(value, "AUTOMATIC")) { MPI_Info_set(info, "romio_ds_write", value); fd->hints->ds_write = ADIOI_HINT_AUTO; } /* otherwise ignore */ } MPI_Info_get(users_info, "cb_nodes", MPI_MAX_INFO_VAL, value, &flag); if (flag && ((intval=atoi(value)) > 0)) { tmp_val = intval; MPI_Bcast(&tmp_val, 1, MPI_INT, 0, fd->comm); /* --BEGIN ERROR HANDLING-- */ if (tmp_val != intval) { MPIO_ERR_CREATE_CODE_INFO_NOT_SAME(myname, "cb_nodes", error_code); return; } /* --END ERROR HANDLING-- */ if (!nprocs_is_valid) { /* if hints were already initialized, we might not * have already gotten this? */ MPI_Comm_size(fd->comm, &nprocs); nprocs_is_valid = 1; } if (intval <= nprocs) { MPI_Info_set(info, "cb_nodes", value); fd->hints->cb_nodes = intval; } } MPI_Info_get(users_info, "ind_wr_buffer_size", MPI_MAX_INFO_VAL, value, &flag); if (flag && ((intval = atoi(value)) > 0)) { MPI_Info_set(info, "ind_wr_buffer_size", value); fd->hints->ind_wr_buffer_size = intval; } MPI_Info_get(users_info, "ind_rd_buffer_size", MPI_MAX_INFO_VAL, value, &flag); if (flag && ((intval = atoi(value)) > 0)) { MPI_Info_set(info, "ind_rd_buffer_size", value); fd->hints->ind_rd_buffer_size = intval; } MPI_Info_get(users_info, "cb_config_list", MPI_MAX_INFO_VAL, value, &flag); if (flag) { if (fd->hints->cb_config_list == NULL) { /* only set cb_config_list if it isn't already set. * Note that since we set it below, this ensures that * the cb_config_list hint will be set at file open time * either by the user or to the default */ MPI_Info_set(info, "cb_config_list", value); len = (strlen(value)+1) * sizeof(char); fd->hints->cb_config_list = ADIOI_Malloc(len); if (fd->hints->cb_config_list == NULL) { /* NEED TO HANDLE ENOMEM */ } ADIOI_Strncpy(fd->hints->cb_config_list, value, len); } /* if it has been set already, we ignore it the second time. * otherwise we would get an error if someone used the same * info value with a cb_config_list value in it in a couple * of calls, which would be irritating. */ } } /* handle cb_config_list default value here; avoids an extra * free/alloc and insures it is always set */ if (fd->hints->cb_config_list == NULL) { MPI_Info_set(info, "cb_config_list", ADIOI_CB_CONFIG_LIST_DFLT); len = (strlen(ADIOI_CB_CONFIG_LIST_DFLT)+1) * sizeof(char); fd->hints->cb_config_list = ADIOI_Malloc(len); if (fd->hints->cb_config_list == NULL) { /* NEED TO HANDLE ENOMEM */ } ADIOI_Strncpy(fd->hints->cb_config_list, ADIOI_CB_CONFIG_LIST_DFLT, len); } /* deferred_open won't be set by callers, but if the user doesn't * explicitly disable collecitve buffering (two-phase) and does hint that * io w/o independent io is going on, we'll set this internal hint as a * convenience */ if ( ( (fd->hints->cb_read != ADIOI_HINT_DISABLE) \ && (fd->hints->cb_write != ADIOI_HINT_DISABLE)\ && fd->hints->no_indep_rw ) ) { fd->hints->deferred_open = 1; } else { /* setting romio_no_indep_rw enable and romio_cb_{read,write} * disable at the same time doesn't make sense. honor * romio_cb_{read,write} and force the no_indep_rw hint to * 'disable' */ MPI_Info_set(info, "romio_no_indep_rw", "false"); fd->hints->no_indep_rw = 0; fd->hints->deferred_open = 0; } if ((fd->file_system == ADIO_PIOFS) || (fd->file_system == ADIO_PVFS) || (fd->file_system == ADIO_PVFS2) ) { /* no data sieving for writes in PIOFS, PVFS and PVFS2, because they do not support file locking */ MPI_Info_get(info, "ind_wr_buffer_size", MPI_MAX_INFO_VAL, value, &flag); if (flag) { /* get rid of this value if it is set */ MPI_Info_delete(info, "ind_wr_buffer_size"); } /* note: leave ind_wr_buffer_size alone; used for other cases * as well. -- Rob Ross, 04/22/2003 */ MPI_Info_set(info, "romio_ds_write", "disable"); fd->hints->ds_write = ADIOI_HINT_DISABLE; } ADIOI_Free(value); *error_code = MPI_SUCCESS; }
/* ADIOI_cb_config_list_parse() - parse the cb_config_list and build the * ranklist * * Parameters: * (pretty self explanatory) * * Returns number of ranks allocated in parsing, -1 on error. */ int ADIOI_cb_config_list_parse(char *config_list, ADIO_cb_name_array array, int ranklist[], int cb_nodes) { int token, max_procs, cur_rank = 0, nr_procnames; char *cur_procname, *cur_procname_p, **procnames; char *used_procnames; nr_procnames = array->namect; procnames = array->names; /* nothing big goes on the stack */ /* we use info val here and for yylval because we know the string * cannot be any bigger than this. */ cur_procname = ADIOI_Malloc((MPI_MAX_INFO_VAL+1) * sizeof(char)); if (cur_procname == NULL) { return -1; } yylval = ADIOI_Malloc((MPI_MAX_INFO_VAL+1) * sizeof(char)); if (yylval == NULL) { ADIOI_Free(cur_procname); return -1; } token_ptr = config_list; /* right away let's make sure cb_nodes isn't too big */ if (cb_nodes > nr_procnames) cb_nodes = nr_procnames; /* used_procnames is used as a mask so that we don't have to destroy * our procnames array */ used_procnames = ADIOI_Malloc(array->namect * sizeof(char)); if (used_procnames == NULL) { ADIOI_Free(cur_procname); ADIOI_Free(yylval); yylval = NULL; return -1; } memset(used_procnames, 0, array->namect); /* optimization for "*:*"; arguably this could be done before we * build the list of processor names...but that would make things * messy. */ if (strcmp(config_list, "*:*") == 0) { for (cur_rank = 0; cur_rank < cb_nodes; cur_rank++) { ranklist[cur_rank] = cur_rank; } ADIOI_Free(cur_procname); ADIOI_Free(yylval); yylval = NULL; ADIOI_Free(used_procnames); return cb_nodes; } while (cur_rank < cb_nodes) { token = cb_config_list_lex(); if (token == AGG_EOS) { ADIOI_Free(cur_procname); ADIOI_Free(yylval); yylval = NULL; ADIOI_Free(used_procnames); return cur_rank; } if (token != AGG_WILDCARD && token != AGG_STRING) { /* maybe ignore and try to keep going? */ FPRINTF(stderr, "error parsing config list\n"); ADIOI_Free(cur_procname); ADIOI_Free(yylval); yylval = NULL; ADIOI_Free(used_procnames); return cur_rank; } if (token == AGG_WILDCARD) { cur_procname_p = NULL; } else { /* AGG_STRING is the only remaining case */ /* save procname (for now) */ ADIOI_Strncpy(cur_procname, yylval, MPI_MAX_INFO_VAL+1); cur_procname_p = cur_procname; } /* after we have saved the current procname, we can grab max_procs */ max_procs = get_max_procs(cb_nodes); #ifdef CB_CONFIG_LIST_DEBUG if (token == AGG_WILDCARD) { FPRINTF(stderr, "looking for *:%d\n", max_procs); } else { FPRINTF(stderr, "looking for %s:%d\n", cur_procname, max_procs); } #endif /* do the matching for this piece of the cb_config_list */ match_procs(cur_procname_p, max_procs, procnames, used_procnames, nr_procnames, ranklist, cb_nodes, &cur_rank); } ADIOI_Free(cur_procname); ADIOI_Free(yylval); yylval = NULL; ADIOI_Free(used_procnames); return cur_rank; }
/*@ MPI_File_get_view - Returns the file view Input Parameters: . fh - file handle (handle) Output Parameters: . disp - displacement (nonnegative integer) . etype - elementary datatype (handle) . filetype - filetype (handle) . datarep - data representation (string) .N fortran @*/ int MPI_File_get_view(MPI_File mpi_fh, MPI_Offset *disp, MPI_Datatype *etype, MPI_Datatype *filetype, char *datarep) { int error_code; ADIO_File fh; static char myname[] = "MPI_FILE_GET_VIEW"; int i, j, k, combiner; MPI_Datatype copy_etype, copy_filetype; MPIU_THREAD_SINGLE_CS_ENTER("io"); MPIR_Nest_incr(); fh = MPIO_File_resolve(mpi_fh); /* --BEGIN ERROR HANDLING-- */ MPIO_CHECK_FILE_HANDLE(fh, myname, error_code); if (datarep <= (char *) 0) { error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, myname, __LINE__, MPI_ERR_ARG, "**iodatarepnomem", 0); error_code = MPIO_Err_return_file(fh, error_code); goto fn_exit; } /* --END ERROR HANDLING-- */ *disp = fh->disp; ADIOI_Strncpy(datarep, "native", MPI_MAX_DATAREP_STRING); MPI_Type_get_envelope(fh->etype, &i, &j, &k, &combiner); if (combiner == MPI_COMBINER_NAMED) *etype = fh->etype; else { MPIR_Nest_incr(); MPI_Type_contiguous(1, fh->etype, ©_etype); MPIR_Nest_decr(); MPIR_Nest_incr(); MPI_Type_commit(©_etype); MPIR_Nest_decr(); *etype = copy_etype; } MPI_Type_get_envelope(fh->filetype, &i, &j, &k, &combiner); if (combiner == MPI_COMBINER_NAMED) *filetype = fh->filetype; else { MPI_Type_contiguous(1, fh->filetype, ©_filetype); MPI_Type_commit(©_filetype); *filetype = copy_filetype; } fn_exit: MPIR_Nest_decr(); MPIU_THREAD_SINGLE_CS_EXIT("io"); return MPI_SUCCESS; }
void ADIOI_PANFS_Open(ADIO_File fd, int *error_code) { char* value; int perm, old_mask, amode, flag; static char myname[] = "ADIOI_PANFS_OPEN"; if (fd->perm == ADIO_PERM_NULL) { old_mask = umask(022); umask(old_mask); perm = ~old_mask & 0666; } else perm = fd->perm; amode = 0; if (fd->access_mode & ADIO_CREATE) { pan_fs_client_layout_agg_type_t layout_type = PAN_FS_CLIENT_LAYOUT_TYPE__DEFAULT; unsigned long int layout_stripe_unit = 0; unsigned long int layout_parity_stripe_width = 0; unsigned long int layout_parity_stripe_depth = 0; unsigned long int layout_total_num_comps = 0; pan_fs_client_layout_visit_t layout_visit_policy = PAN_FS_CLIENT_LAYOUT_VISIT__ROUND_ROBIN; int myrank; MPI_Comm_rank(fd->comm, &myrank); *error_code = MPI_SUCCESS; value = (char *) ADIOI_Malloc((MPI_MAX_INFO_VAL+1)*sizeof(char)); ADIOI_Info_get(fd->info, "panfs_layout_type", MPI_MAX_INFO_VAL, value, &flag); if (flag) { layout_type = strtoul(value,NULL,10); } ADIOI_Info_get(fd->info, "panfs_layout_stripe_unit", MPI_MAX_INFO_VAL, value, &flag); if (flag) { layout_stripe_unit = strtoul(value,NULL,10); } ADIOI_Info_get(fd->info, "panfs_layout_total_num_comps", MPI_MAX_INFO_VAL, value, &flag); if (flag) { layout_total_num_comps = strtoul(value,NULL,10); } ADIOI_Info_get(fd->info, "panfs_layout_parity_stripe_width", MPI_MAX_INFO_VAL, value, &flag); if (flag) { layout_parity_stripe_width = strtoul(value,NULL,10); } ADIOI_Info_get(fd->info, "panfs_layout_parity_stripe_depth", MPI_MAX_INFO_VAL, value, &flag); if (flag) { layout_parity_stripe_depth = strtoul(value,NULL,10); } ADIOI_Info_get(fd->info, "panfs_layout_visit_policy", MPI_MAX_INFO_VAL, value, &flag); if (flag) { layout_visit_policy = strtoul(value,NULL,10); } ADIOI_Free(value); amode = amode | O_CREAT; /* Check for valid set of hints */ if ((layout_type < PAN_FS_CLIENT_LAYOUT_TYPE__DEFAULT) || (layout_type > PAN_FS_CLIENT_LAYOUT_TYPE__RAID10)) { FPRINTF(stderr, "%s: panfs_layout_type is not a valid value: %u.\n", myname, layout_type); MPI_Abort(MPI_COMM_WORLD, 1); } if ((layout_type == PAN_FS_CLIENT_LAYOUT_TYPE__RAID0) && ((layout_stripe_unit == 0) || (layout_total_num_comps == 0))) { if(layout_stripe_unit == 0) { FPRINTF(stderr, "%s: MPI_Info does not contain the panfs_layout_stripe_unit hint which is necessary to specify a valid RAID0 layout to the PAN_FS_CLIENT_LAYOUT_CREATE_FILE ioctl.\n", myname); } if(layout_total_num_comps == 0) { FPRINTF(stderr, "%s: MPI_Info does not contain the panfs_layout_total_num_comps hint which is necessary to specify a valid RAID0 layout to the PAN_FS_CLIENT_LAYOUT_CREATE_FILE ioctl.\n", myname); } MPI_Abort(MPI_COMM_WORLD, 1); } if (layout_type == PAN_FS_CLIENT_LAYOUT_TYPE__RAID1_5_PARITY_STRIPE) { if ((layout_stripe_unit == 0) || (layout_parity_stripe_width == 0) || (layout_parity_stripe_depth == 0) || (layout_total_num_comps == 0)) { if(layout_stripe_unit == 0) { FPRINTF(stderr, "%s: MPI_Info does not contain the panfs_layout_stripe_unit hint which is necessary to specify a valid RAID5 parity stripe layout to the PAN_FS_CLIENT_LAYOUT_CREATE_FILE ioctl.\n", myname); } if(layout_total_num_comps == 0) { FPRINTF(stderr, "%s: MPI_Info does not contain the panfs_layout_total_num_comps hint which is necessary to specify a valid RAID5 parity stripe layout to the PAN_FS_CLIENT_LAYOUT_CREATE_FILE ioctl.\n", myname); } if(layout_parity_stripe_width == 0) { FPRINTF(stderr, "%s: MPI_Info does not contain the panfs_layout_parity_stripe_width hint which is necessary to specify a valid RAID5 parity stripe layout to the PAN_FS_CLIENT_LAYOUT_CREATE_FILE ioctl.\n", myname); } if(layout_parity_stripe_depth == 0) { FPRINTF(stderr, "%s: MPI_Info does not contain the panfs_layout_parity_stripe_depth hint which is necessary to specify a valid RAID5 parity stripe layout to the PAN_FS_CLIENT_LAYOUT_CREATE_FILE ioctl.\n", myname); } MPI_Abort(MPI_COMM_WORLD, 1); } if ((layout_visit_policy < PAN_FS_CLIENT_LAYOUT_VISIT__ROUND_ROBIN) || (layout_visit_policy > PAN_FS_CLIENT_LAYOUT_VISIT__ROUND_ROBIN_WITH_HASHED_OFFSET)) { FPRINTF(stderr, "%s: panfs_layout_visit_policy is not a valid value: %u.\n", myname, layout_visit_policy); MPI_Abort(MPI_COMM_WORLD, 1); } } if (layout_type == PAN_FS_CLIENT_LAYOUT_TYPE__RAID10) { if ((layout_stripe_unit == 0) || (layout_total_num_comps == 0)) { if(layout_stripe_unit == 0) { FPRINTF(stderr, "%s: MPI_Info does not contain the panfs_layout_stripe_unit hint which is necessary to specify a valid RAID10 layout to the PAN_FS_CLIENT_LAYOUT_CREATE_FILE ioctl.\n", myname); } if(layout_total_num_comps == 0) { FPRINTF(stderr, "%s: MPI_Info does not contain the panfs_layout_total_num_comps hint which is necessary to specify a valid RAID10 layout to the PAN_FS_CLIENT_LAYOUT_CREATE_FILE ioctl.\n", myname); } MPI_Abort(MPI_COMM_WORLD, 1); } if ((layout_visit_policy < PAN_FS_CLIENT_LAYOUT_VISIT__ROUND_ROBIN) || (layout_visit_policy > PAN_FS_CLIENT_LAYOUT_VISIT__ROUND_ROBIN_WITH_HASHED_OFFSET)) { FPRINTF(stderr, "%s: panfs_layout_visit_policy is not a valid value: %u.\n", myname, layout_visit_policy); MPI_Abort(MPI_COMM_WORLD, 1); } } /* Create the file via ioctl() or open(). ADIOI_PANFS_Open's caller * already optimizes performance by only calling this function with * ADIO_CREATE on rank 0. Therefore, we don't need to worry about * implementing that optimization here. */ if((layout_type == PAN_FS_CLIENT_LAYOUT_TYPE__RAID0) || (layout_type == PAN_FS_CLIENT_LAYOUT_TYPE__RAID1_5_PARITY_STRIPE) || (layout_type == PAN_FS_CLIENT_LAYOUT_TYPE__RAID10)) { pan_fs_client_layout_create_args_t file_create_args; int fd_dir; char* slash; struct stat stat_buf; int err; char *path; /* Check that the file does not exist before * trying to create it. The ioctl itself should * be able to handle this condition. Currently, * the ioctl will return successfully if the file * has been previously created. Filed bug 33862 * to track the problem. */ err = stat(fd->filename,&stat_buf); if((err == -1) && (errno != ENOENT)) { FPRINTF(stderr,"%s: Unexpected I/O Error calling stat() on PanFS file: %s.\n", myname, strerror(errno)); MPI_Abort(MPI_COMM_WORLD, 1); } else if (err == 0) { FPRINTF(stderr,"%s: Cannot create PanFS file with ioctl when file already exists.\n", myname); MPI_Abort(MPI_COMM_WORLD, 1); } else { /* (err == -1) && (errno == ENOENT) */ /* File does not exist */ path = ADIOI_Strdup(fd->filename); slash = strrchr(path, '/'); if (!slash) ADIOI_Strncpy(path, ".", 2); else { if (slash == path) *(path + 1) = '\0'; else *slash = '\0'; } /* create PanFS object */ bzero(&file_create_args,sizeof(pan_fs_client_layout_create_args_t)); /* open directory */ fd_dir = open(path, O_RDONLY); if (fd_dir < 0) { FPRINTF(stderr, "%s: I/O Error opening parent directory to create PanFS file using ioctl: %s.\n", myname, strerror(errno)); MPI_Abort(MPI_COMM_WORLD, 1); } else { char *file_name_ptr = fd->filename; slash = strrchr(fd->filename, '/'); if (slash) { file_name_ptr = slash + 1; } /* create file in the directory */ file_create_args.mode = perm; file_create_args.version = PAN_FS_CLIENT_LAYOUT_VERSION; file_create_args.flags = PAN_FS_CLIENT_LAYOUT_CREATE_F__NONE; ADIOI_Strncpy(file_create_args.filename, file_name_ptr, strlen(fd->filename)+1); file_create_args.layout.agg_type = layout_type; file_create_args.layout.layout_is_valid = 1; if(layout_type == PAN_FS_CLIENT_LAYOUT_TYPE__RAID1_5_PARITY_STRIPE) { file_create_args.layout.u.raid1_5_parity_stripe.total_num_comps = layout_total_num_comps; file_create_args.layout.u.raid1_5_parity_stripe.parity_stripe_width = layout_parity_stripe_width; file_create_args.layout.u.raid1_5_parity_stripe.parity_stripe_depth = layout_parity_stripe_depth; file_create_args.layout.u.raid1_5_parity_stripe.stripe_unit = layout_stripe_unit; file_create_args.layout.u.raid1_5_parity_stripe.layout_visit_policy = layout_visit_policy; } else if(layout_type == PAN_FS_CLIENT_LAYOUT_TYPE__RAID0) { file_create_args.layout.u.raid0.total_num_comps = layout_total_num_comps; file_create_args.layout.u.raid0.stripe_unit = layout_stripe_unit; } else if(layout_type == PAN_FS_CLIENT_LAYOUT_TYPE__RAID10) { file_create_args.layout.u.raid10.total_num_comps = layout_total_num_comps; file_create_args.layout.u.raid10.stripe_unit = layout_stripe_unit; file_create_args.layout.u.raid10.layout_visit_policy = layout_visit_policy; } err = ioctl(fd_dir, PAN_FS_CLIENT_LAYOUT_CREATE_FILE, &file_create_args); if (err < 0) { FPRINTF(stderr, "%s: I/O Error doing ioctl on parent directory to create PanFS file using ioctl: %s.\n", myname, strerror(errno)); MPI_Abort(MPI_COMM_WORLD, 1); } err = close(fd_dir); } ADIOI_Free(path); } } else { int create_fd = open(fd->filename,amode,perm); if(create_fd != -1) { close(create_fd); } else { FPRINTF(stderr, "%s: I/O Error creating PanFS file using open: %s.\n", myname, strerror(errno)); MPI_Abort(MPI_COMM_WORLD, 1); } } } if (fd->access_mode & ADIO_RDONLY) amode = amode | O_RDONLY; if (fd->access_mode & ADIO_WRONLY) amode = amode | O_WRONLY; if (fd->access_mode & ADIO_RDWR) amode = amode | O_RDWR; if (fd->access_mode & ADIO_EXCL) amode = amode | O_EXCL; value = (char *) ADIOI_Malloc((MPI_MAX_INFO_VAL+1)*sizeof(char)); ADIOI_Info_get(fd->info, "panfs_concurrent_write", MPI_MAX_INFO_VAL, value, &flag); if (flag) { unsigned long int concurrent_write = strtoul(value,NULL,10); if(concurrent_write == 1) { amode = amode | O_CONCURRENT_WRITE; } } ADIOI_Free(value); fd->fd_sys = open(fd->filename, amode, perm); fd->fd_direct = -1; if (fd->fd_sys != -1) { int rc; char temp_buffer[TEMP_BUFFER_SIZE]; pan_fs_client_layout_query_args_t file_query_args; bzero(&file_query_args,sizeof(pan_fs_client_layout_query_args_t)); file_query_args.version = PAN_FS_CLIENT_LAYOUT_VERSION; rc = ioctl(fd->fd_sys, PAN_FS_CLIENT_LAYOUT_QUERY_FILE, &file_query_args); if (rc < 0) { /* Error - set layout type to unknown */ ADIOI_Info_set(fd->info, "panfs_layout_type", "PAN_FS_CLIENT_LAYOUT_TYPE__INVALID"); } else { ADIOI_Snprintf(temp_buffer,TEMP_BUFFER_SIZE,"%u",file_query_args.layout.agg_type); ADIOI_Info_set(fd->info, "panfs_layout_type", temp_buffer); if (file_query_args.layout.layout_is_valid == 1) { switch (file_query_args.layout.agg_type) { case PAN_FS_CLIENT_LAYOUT_TYPE__RAID0: ADIOI_Snprintf(temp_buffer,TEMP_BUFFER_SIZE,"%u",file_query_args.layout.u.raid0.stripe_unit); ADIOI_Info_set(fd->info, "panfs_layout_stripe_unit", temp_buffer); ADIOI_Snprintf(temp_buffer,TEMP_BUFFER_SIZE,"%u",file_query_args.layout.u.raid0.total_num_comps); ADIOI_Info_set(fd->info, "panfs_layout_total_num_comps", temp_buffer); break; case PAN_FS_CLIENT_LAYOUT_TYPE__RAID1_5_PARITY_STRIPE: ADIOI_Snprintf(temp_buffer,TEMP_BUFFER_SIZE,"%u",file_query_args.layout.u.raid1_5_parity_stripe.stripe_unit); ADIOI_Info_set(fd->info, "panfs_layout_stripe_unit", temp_buffer); ADIOI_Snprintf(temp_buffer,TEMP_BUFFER_SIZE,"%u",file_query_args.layout.u.raid1_5_parity_stripe.parity_stripe_width); ADIOI_Info_set(fd->info, "panfs_layout_parity_stripe_width", temp_buffer); ADIOI_Snprintf(temp_buffer,TEMP_BUFFER_SIZE,"%u",file_query_args.layout.u.raid1_5_parity_stripe.parity_stripe_depth); ADIOI_Info_set(fd->info, "panfs_layout_parity_stripe_depth", temp_buffer); ADIOI_Snprintf(temp_buffer,TEMP_BUFFER_SIZE,"%u",file_query_args.layout.u.raid1_5_parity_stripe.total_num_comps); ADIOI_Info_set(fd->info, "panfs_layout_total_num_comps", temp_buffer); ADIOI_Snprintf(temp_buffer,TEMP_BUFFER_SIZE,"%u",file_query_args.layout.u.raid1_5_parity_stripe.layout_visit_policy); ADIOI_Info_set(fd->info, "panfs_layout_visit_policy", temp_buffer); break; case PAN_FS_CLIENT_LAYOUT_TYPE__RAID10: ADIOI_Snprintf(temp_buffer,TEMP_BUFFER_SIZE,"%u",file_query_args.layout.u.raid10.stripe_unit); ADIOI_Info_set(fd->info, "panfs_layout_stripe_unit", temp_buffer); ADIOI_Snprintf(temp_buffer,TEMP_BUFFER_SIZE,"%u",file_query_args.layout.u.raid10.total_num_comps); ADIOI_Info_set(fd->info, "panfs_layout_total_num_comps", temp_buffer); ADIOI_Snprintf(temp_buffer,TEMP_BUFFER_SIZE,"%u",file_query_args.layout.u.raid10.layout_visit_policy); ADIOI_Info_set(fd->info, "panfs_layout_visit_policy", temp_buffer); break; default: break; } } } } if ((fd->fd_sys != -1) && (fd->access_mode & ADIO_APPEND)) fd->fp_ind = fd->fp_sys_posn = lseek(fd->fd_sys, 0, SEEK_END); if (fd->fd_sys == -1) { if (errno == ENAMETOOLONG) *error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, myname, __LINE__, MPI_ERR_BAD_FILE, "**filenamelong", "**filenamelong %s %d", fd->filename, strlen(fd->filename)); else if (errno == ENOENT) *error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, myname, __LINE__, MPI_ERR_NO_SUCH_FILE, "**filenoexist", "**filenoexist %s", fd->filename); else if (errno == ENOTDIR || errno == ELOOP) *error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, myname, __LINE__, MPI_ERR_BAD_FILE, "**filenamedir", "**filenamedir %s", fd->filename); else if (errno == EACCES) { *error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, myname, __LINE__, MPI_ERR_ACCESS, "**fileaccess", "**fileaccess %s", fd->filename ); } else if (errno == EROFS) { /* Read only file or file system and write access requested */ *error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, myname, __LINE__, MPI_ERR_READ_ONLY, "**ioneedrd", 0 ); } else { *error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, myname, __LINE__, MPI_ERR_IO, "**io", "**io %s", strerror(errno)); } } else *error_code = MPI_SUCCESS; }