int main(int argc, char *argv[])
{
MPI_Info i1, i2;
int errs = 0;
char value[64];
int flag;
MTest_Init(&argc, &argv);
MPI_Info_create(&i1);
MPI_Info_create(&i2);
MPI_Info_set(i1, (char *) "key1", (char *) "value1");
MPI_Info_set(i2, (char *) "key2", (char *) "value2");
MPI_Info_get(i1, (char *) "key2", 64, value, &flag);
if (flag) {
printf("Found key2 in info1\n");
errs++;
}
MPI_Info_get(i1, (char *) "key1", 64, value, &flag);
if (!flag) {
errs++;
printf("Did not find key1 in info1\n");
} else if (strcmp(value, "value1")) {
errs++;
printf("Found wrong value (%s), expected value1\n", value);
}
MPI_Info_free(&i1);
MPI_Info_free(&i2);
MTest_Finalize(errs);
return MTestReturnValue(errs);
}
static void dump_mpi_info( MPI_Info info, const char * prefix = NULL ) {
int nkeys;
std::stringstream ss;
ss << "MPI Info";
if( prefix ) {
ss << " for " << prefix;
}
ss << ":\n";
MPI_Info_get_nkeys(info, &nkeys);
for( int i=0; i<nkeys; i++ ) {
char key[MPI_MAX_INFO_KEY], value[MPI_MAX_INFO_VAL];
int valuelen, flag;
MPI_Info_get_nthkey(info, i, key);
MPI_Info_get_valuelen(info, key, &valuelen, &flag);
CHECK( flag ) << "somehow key not defined?";
MPI_Info_get(info, key, valuelen+1, value, &flag);
CHECK( flag ) << "somehow key not defined?";
ss << " key " << i << ": " << key << " => " << value;
}
LOG(INFO) << ss.str();
}
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 ADIOI_XFS_SetInfo(ADIO_File fd, MPI_Info users_info, int *error_code)
{
char *value;
int flag;
if (fd->info == MPI_INFO_NULL) MPI_Info_create(&(fd->info));
/* the nightly builds say somthing is calling MPI_Info_set w/ a null info,
* so protect the calls to MPI_Info_set */
if (fd->info != MPI_INFO_NULL ) {
MPI_Info_set(fd->info, "direct_read", "false");
MPI_Info_set(fd->info, "direct_write", "false");
fd->direct_read = fd->direct_write = 0;
}
/* has user specified values for keys "direct_read" and "direct wirte"? */
if (users_info != MPI_INFO_NULL) {
value = (char *) ADIOI_Malloc((MPI_MAX_INFO_VAL+1)*sizeof(char));
MPI_Info_get(users_info, "direct_read", MPI_MAX_INFO_VAL,
value, &flag);
if (flag && !strcmp(value, "true")) {
MPI_Info_set(fd->info, "direct_read", "true");
fd->direct_read = 1;
}
MPI_Info_get(users_info, "direct_write", MPI_MAX_INFO_VAL,
value, &flag);
if (flag && !strcmp(value, "true")) {
MPI_Info_set(fd->info, "direct_write", "true");
fd->direct_write = 1;
}
ADIOI_Free(value);
}
/* set the values for collective I/O and data sieving parameters */
ADIOI_GEN_SetInfo(fd, users_info, error_code);
if (ADIOI_Direct_read) fd->direct_read = 1;
if (ADIOI_Direct_write) fd->direct_write = 1;
/* environment variables checked in ADIO_Init */
*error_code = MPI_SUCCESS;
}
MPI_Fint c2finfo_ ( MPI_Fint *info )
{
MPI_Info cInfo = MPI_Info_f2c( *info );
int flag;
char value[100];
MPI_Fint errs = 0;
MPI_Info_get( cInfo, (char*)"host", sizeof(value), value, &flag );
if (!flag || strcmp(value,"myname") != 0) {
fprintf( stderr, "Info: Wrong value or no value for host\n" );
errs++;
}
MPI_Info_get( cInfo, (char*)"wdir", sizeof(value), value, &flag );
if (!flag || strcmp( value, "/rdir/foo" ) != 0) {
fprintf( stderr, "Info: Wrong value of no value for wdir\n" );
errs++;
}
return errs;
}
/* debug function: a routine I want in the library to make my life easier when
* using a source debugger. please ignore any "defined but not used" warnings
*/
static void dump_keys(MPI_Info info) {
int i, nkeys, flag;
char key[MPI_MAX_INFO_KEY];
char value[MPI_MAX_INFO_VAL];
MPI_Info_get_nkeys(info, &nkeys);
for (i=0; i<nkeys; i++) {
MPI_Info_get_nthkey(info, i, key);
MPI_Info_get(info, key, MPI_MAX_INFO_VAL-1, value, &flag);
printf("key = %s, value = %s\n", key, value);
}
return;
}
void IMB_print_info()
/*
Prints MPI_Info selections (MPI-2 only)
*/
{
int nkeys,ikey,vlen,exists;
MPI_Info tmp_info;
char key[MPI_MAX_INFO_KEY], *value;
IMB_user_set_info(&tmp_info);
/* July 2002 fix V2.2.1: handle NULL case */
if( tmp_info!=MPI_INFO_NULL )
{
/* end change */
MPI_Info_get_nkeys(tmp_info, &nkeys);
if( nkeys > 0) fprintf(unit,"# Got %d Info-keys:\n\n",nkeys);
for( ikey=0; ikey<nkeys; ikey++ )
{
MPI_Info_get_nthkey(tmp_info, ikey, key);
MPI_Info_get_valuelen(tmp_info, key, &vlen, &exists);
value = (char*)IMB_v_alloc((vlen+1)* sizeof(char), "Print_Info");
MPI_Info_get(tmp_info, key, vlen, value, &exists);
printf("# %s = \"%s\"\n",key,value);
IMB_v_free ((void**)&value);
}
MPI_Info_free(&tmp_info);
/* July 2002 fix V2.2.1: end if */
}
/* end change */
}
/*----< print_info() >------------------------------------------------------*/
static
void print_info(MPI_Info *info_used)
{
int i, nkeys;
MPI_Info_get_nkeys(*info_used, &nkeys);
printf("MPI File Info: nkeys = %d\n",nkeys);
for (i=0; i<nkeys; i++) {
char key[MPI_MAX_INFO_KEY], value[MPI_MAX_INFO_VAL];
int valuelen, flag;
MPI_Info_get_nthkey(*info_used, i, key);
MPI_Info_get_valuelen(*info_used, key, &valuelen, &flag);
MPI_Info_get(*info_used, key, valuelen+1, value, &flag);
printf("MPI File Info: [%2d] key = %25s, value = %s\n",i,key,value);
}
}
int main(int argc, char **argv)
{
int rank;
MPI_Info info_in, info_out;
int errors = 0, all_errors = 0;
MPI_Comm comm;
char __attribute__((unused)) invalid_key[] = "invalid_test_key";
char buf[MPI_MAX_INFO_VAL];
int flag;
MPI_Init(&argc, &argv);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
MPI_Info_create(&info_in);
MPI_Info_set(info_in, invalid_key, (char *) "true");
MPI_Comm_dup(MPI_COMM_WORLD, &comm);
MPI_Comm_set_info(comm, info_in);
MPI_Comm_get_info(comm, &info_out);
MPI_Info_get(info_out, invalid_key, MPI_MAX_INFO_VAL, buf, &flag);
#ifndef USE_STRICT_MPI
/* Check if our invalid key was ignored. Note, this check's MPICH's
* behavior, but this behavior may not be required for a standard
* conforming MPI implementation. */
if (flag) {
printf("%d: %s was not ignored\n", rank, invalid_key);
errors++;
}
#endif
MPI_Info_free(&info_in);
MPI_Info_free(&info_out);
MPI_Comm_free(&comm);
MPI_Reduce(&errors, &all_errors, 1, MPI_INT, MPI_SUM, 0, MPI_COMM_WORLD);
if (rank == 0 && all_errors == 0)
printf(" No Errors\n");
MPI_Finalize();
return 0;
}
/*
* Show all hints (key/value pairs) in an MPI_Info object.
*/
void ShowHints(MPI_Info * mpiHints)
{
char key[MPI_MAX_INFO_VAL];
char value[MPI_MAX_INFO_VAL];
int flag, i, nkeys;
MPI_CHECK(MPI_Info_get_nkeys(*mpiHints, &nkeys),
"cannot get info object keys");
for (i = 0; i < nkeys; i++) {
MPI_CHECK(MPI_Info_get_nthkey(*mpiHints, i, key),
"cannot get info object key");
MPI_CHECK(MPI_Info_get(*mpiHints, key, MPI_MAX_INFO_VAL - 1,
value, &flag),
"cannot get info object value");
fprintf(stdout, "\t%s = %s\n", key, value);
}
}
/* parse the file-of-hints. Format is zero or more lines of "<key> <value>\n".
* A # in collumn zero is a comment and the line will be ignored. Do our best
* to ignore badly formed lines too.
*
* The caller provides an 'info' object. Each key-value pair found by the
* parser will get added to the info object. any keys already set will be left
* alone on the assumption that the caller knows best.
*
* because MPI-IO hints are optional, we can get away with limited error
* reporting. */
static int file_to_info(int fd, MPI_Info info)
{
char *buffer, *token, *key, *val, *garbage;
char *pos1, *pos2;
int flag, ret;
char dummy;
struct stat statbuf;
/* assumption: config files will be small (less than 1MB) */
fstat(fd, &statbuf);
/* add 1 to size to make room for NULL termination */
buffer = (char *)calloc(statbuf.st_size + 1, sizeof (char));
if (buffer == NULL) return -1;
ret = read(fd, buffer, statbuf.st_size);
if (ret < 0) return -1;
token = strtok_r(buffer, "\n", &pos1);
do {
if ( (key = strtok_r(token, " \t", &pos2)) == NULL)
/* malformed line: found no items */
continue;
if (token[0] == '#')
/* ignore '#'-delimited comments */
continue;
if ( (val = strtok_r(NULL, " \t", &pos2)) == NULL)
/* malformed line: found key without value */
continue;
if ( (garbage = strtok_r(NULL, " \t", &pos2)) != NULL)
/* malformed line: more than two items */
continue;
#ifdef SYSHINT_DEBUG
printf("found: key=%s val=%s\n", key, val);
#endif
/* don't actually care what the value is. only want to know if key
* exists: we leave it alone if so*/
MPI_Info_get(info, key, 0, &dummy, &flag);
if (flag == 1) continue;
MPI_Info_set(info, key, val);
} while ((token = strtok_r(NULL, "\n", &pos1)) != NULL);
free(buffer);
return 0;
}
void mpi_info_get_f(MPI_Fint *info, char *key, MPI_Fint *valuelen,
char *value, ompi_fortran_logical_t *flag, MPI_Fint *ierr,
int key_len, int value_len)
{
int c_err, ret;
MPI_Info c_info;
char *c_key = NULL, c_value[MPI_MAX_INFO_VAL + 1];
OMPI_LOGICAL_NAME_DECL(flag);
if (OMPI_SUCCESS != (ret = ompi_fortran_string_f2c(key, key_len, &c_key))) {
c_err = OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, ret, FUNC_NAME);
*ierr = OMPI_INT_2_FINT(c_err);
return;
}
c_info = MPI_Info_f2c(*info);
*ierr = OMPI_INT_2_FINT(MPI_Info_get(c_info, c_key,
OMPI_FINT_2_INT(*valuelen),
c_value,
OMPI_LOGICAL_SINGLE_NAME_CONVERT(flag)));
if (MPI_SUCCESS == OMPI_FINT_2_INT(*ierr)) {
OMPI_SINGLE_INT_2_LOGICAL(flag);
/* If we found the info key, copy the value back to the
Fortran string (note: all Fortran compilers have FALSE ==
0, so just check for any nonzero value, because not all
Fortran compilers have TRUE == 1). Note: use the full
length of the Fortran string, not *valuelen. See comment
in ompi/mpi/fortran/base/strings.c. */
if (*flag && OMPI_SUCCESS !=
(ret = ompi_fortran_string_c2f(c_value, value, value_len))) {
c_err = OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, ret, FUNC_NAME);
*ierr = OMPI_INT_2_FINT(c_err);
free(c_key);
return;
}
}
free(c_key);
}
/**
* Get the hint information from the MPI_Info variable stored in the
* test_params and print it out.
*
* @param test_params_p Pointer to test_params.
* @return 0 on success.
*/
static int print_hints(struct test_params_s *test_params_p)
{
int i, hint_key_len, hint_val_len, hint_nkeys, flag;
char hint_key[MPI_MAX_INFO_KEY], *hint_val;
MPI_Info_get_nkeys(*(test_params_p->info_p), &hint_nkeys);
for (i = 0; i < hint_nkeys; i++)
{
MPI_Info_get_nthkey(*(test_params_p->info_p), i, hint_key);
hint_key_len = strlen(hint_key);
MPI_Info_get_valuelen(*(test_params_p->info_p), hint_key,
&hint_val_len, &flag);
assert(flag);
hint_val = malloc((hint_val_len + 1)*sizeof(char));
if (!hint_val)
{
fprintf(stderr, "hint_val malloc of size %d failed.\n",
hint_val_len);
return -1;
}
MPI_Info_get(*(test_params_p->info_p), hint_key,
hint_val_len + 1, hint_val, &flag);
assert(flag);
fprintf(
stdout,
"hint %d \"%30s\" = %s\n",
i, hint_key, hint_val);
free(hint_val);
}
if (!hint_nkeys)
fprintf(
stdout,
"hints = N/A\n");
return 0;
}
static int check_win_info_get(MPI_Win win, const char *key, const char *exp_val)
{
int flag = 0;
MPI_Info info_out = MPI_INFO_NULL;
char buf[MPI_MAX_INFO_VAL];
int errors = 0;
MPI_Win_get_info(win, &info_out);
MPI_Info_get(info_out, key, MPI_MAX_INFO_VAL, buf, &flag);
if (!flag || strncmp(buf, exp_val, strlen(exp_val)) != 0) {
if (flag)
printf("%d: %s: expected \"%s\" but got %s\n", rank, key, exp_val, buf);
else
printf("%d: %s not defined\n", rank, key);
errors++;
}
else if (flag && VERBOSE)
printf("%d: %s = %s\n", rank, key, buf);
MPI_Info_free(&info_out);
return errors;
}
static void
print_hints( int rank, MPI_File *mfh ) {
MPI_Info info;
int nkeys;
int i, dummy_int;
char key[1024];
char value[1024];
MPI_Barrier( MPI_COMM_WORLD );
if ( rank == 0 ) {
MPI_File_get_info( *mfh, &info );
MPI_Info_get_nkeys( info, &nkeys );
printf( "HINTS:\n" );
for( i = 0; i < nkeys; i++ ) {
MPI_Info_get_nthkey( info, i, key );
printf( "%35s -> ", key );
MPI_Info_get( info, key, 1024, value, &dummy_int );
printf( "%s\n", value );
}
MPI_Info_free(&info);
}
MPI_Barrier( MPI_COMM_WORLD );
}
/*
* Function: h5_dump_info_object
* Purpose: Display content of an MPI Info object
* Return: void
* Programmer: Albert Cheng 2002/05/21
* Modifications:
*/
void
h5_dump_info_object(MPI_Info info)
{
char key[MPI_MAX_INFO_KEY+1];
char value[MPI_MAX_INFO_VAL+1];
int flag;
int i, nkeys;
printf("Dumping MPI Info Object(%d) (up to %d bytes per item):\n", (int)info,
MPI_MAX_INFO_VAL);
if (info==MPI_INFO_NULL){
printf("object is MPI_INFO_NULL\n");
}
else {
MPI_Info_get_nkeys(info, &nkeys);
printf("object has %d items\n", nkeys);
for (i=0; i<nkeys; i++){
MPI_Info_get_nthkey(info, i, key);
MPI_Info_get(info, key, MPI_MAX_INFO_VAL, value, &flag);
printf("%s=%s\n", key, value);
}
}
}
/**
This function just shows how optimizations to hints or other global optimization values should be requested from SIOX.
The return type and signature depend on the relation of the optimization to real objects / storage systems and so on.
*/
static void hint_user( MPI_Info info, ... )
{
int exists;
char value[8];
MPI_Info_get( info, "cbSize", 8, value, & exists );
int setValue = 0;
// For the start_, stop_ and end_activity functions, NULL will prompt SIOX to draw a current time stamp.
siox_aid aid = siox_start_activity( unid, NULL, "hint_user" );
if( exists ) { // cbSize is set by the user, just use it...
setValue = value;
// SIOX could verify this value, but we skip this for now.
} else {
// NORMALLY: use default values, probably set by environment variables or by a global variable within MPI...
// setValue = MPI_DEFAULT_CB_SIZE;
// this code is replaced with code that uses SIOX for a better analysis:
// Ask for suggestion, stating the parameter to be used.
siox_suggest_optimization( unid, oid_cbsize, & setValue );
}
// get the current system status
// uint64_t currentNICUtilization;
// siox_get_counter_value(unid, counterID, &value);
if( setValue > 0 ) {
// do optimization xy, i.e., send additional stuff to server, modify local variables...
// report the optimization level to SIOX:
siox_report_attribute( aid, dt_cbsize, & cbSize );
}
siox_stop_activity( aid, NULL );
siox_end_activity( aid, NULL );
}
void mpi_info_get_f(MPI_Fint *info, char *key, MPI_Fint *valuelen,
char *value, ompi_fortran_logical_t *flag, MPI_Fint *ierr,
int key_len, int value_len)
{
int c_err, ret;
MPI_Info c_info;
char *c_key = NULL, c_value[MPI_MAX_INFO_VAL + 1];
OMPI_LOGICAL_NAME_DECL(flag);
if (OMPI_SUCCESS != (ret = ompi_fortran_string_f2c(key, key_len, &c_key))) {
c_err = OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, ret, FUNC_NAME);
*ierr = OMPI_INT_2_FINT(c_err);
return;
}
c_info = MPI_Info_f2c(*info);
*ierr = OMPI_INT_2_FINT(MPI_Info_get(c_info, c_key,
OMPI_FINT_2_INT(*valuelen),
c_value,
OMPI_LOGICAL_SINGLE_NAME_CONVERT(flag)));
if (MPI_SUCCESS == OMPI_FINT_2_INT(*ierr)) {
OMPI_SINGLE_INT_2_LOGICAL(flag);
/* Use the full length of the Fortran string, not *valuelen.
See comment in ompi/mpi/f77/strings.c. */
if (OMPI_SUCCESS != (ret = ompi_fortran_string_c2f(c_value, value,
value_len))) {
c_err = OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, ret, FUNC_NAME);
*ierr = OMPI_INT_2_FINT(c_err);
free(c_key);
return;
}
}
free(c_key);
}
void ADIOI_PVFS_Open(ADIO_File fd, int *error_code)
{
int perm, amode, old_mask, flag;
char *value;
struct pvfs_filestat pstat = {-1,-1,-1,0,0};
#ifndef PRINT_ERR_MSG
static char myname[] = "ADIOI_PVFS_OPEN";
#endif
if (fd->perm == ADIO_PERM_NULL) {
old_mask = umask(022);
umask(old_mask);
perm = old_mask ^ 0666;
}
else perm = fd->perm;
amode = O_META;
if (fd->access_mode & ADIO_CREATE)
amode = amode | O_CREAT;
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));
MPI_Info_get(fd->info, "striping_factor", MPI_MAX_INFO_VAL,
value, &flag);
if (flag && (atoi(value) > 0)) pstat.pcount = atoi(value);
MPI_Info_get(fd->info, "striping_unit", MPI_MAX_INFO_VAL,
value, &flag);
if (flag && (atoi(value) > 0)) pstat.ssize = atoi(value);
MPI_Info_get(fd->info, "start_iodevice", MPI_MAX_INFO_VAL,
value, &flag);
if (flag && (atoi(value) >= 0)) pstat.base = atoi(value);
fd->fd_sys = pvfs_open64(fd->filename, amode, perm, &pstat, NULL);
if ((fd->fd_sys != -1) && (fd->access_mode & ADIO_APPEND))
fd->fp_ind = fd->fp_sys_posn = pvfs_lseek64(fd->fd_sys, 0, SEEK_END);
if (fd->fd_sys != -1) {
pvfs_ioctl(fd->fd_sys, GETMETA, &pstat);
sprintf(value, "%d", pstat.pcount);
MPI_Info_set(fd->info, "striping_factor", value);
sprintf(value, "%d", pstat.ssize);
MPI_Info_set(fd->info, "striping_unit", value);
sprintf(value, "%d", pstat.base);
MPI_Info_set(fd->info, "start_iodevice", value);
}
ADIOI_Free(value);
#ifdef PRINT_ERR_MSG
*error_code = (fd->fd_sys == -1) ? MPI_ERR_UNKNOWN : MPI_SUCCESS;
#else
if (fd->fd_sys == -1) {
*error_code = MPIR_Err_setmsg(MPI_ERR_IO, MPIR_ADIO_ERROR,
myname, "I/O Error", "%s", strerror(errno));
ADIOI_Error(ADIO_FILE_NULL, *error_code, myname);
}
else *error_code = MPI_SUCCESS;
#endif
}
void SID_init(int *argc,
char **argv[],
SID_args args[],
void *mpi_comm_as_void){
int status;
int i_level;
int i_char;
int flag_continue;
int flag_passed_comm;
// MPI-specific things
#if USE_MPI
int n_keys;
int i_key;
char key[256];
char key_value[256];
int key_exists;
char nodes_string[256];
SID_fp fp_tmp;
FILE *fp_hack;
int node_name_length;
MPI_Comm mpi_comm;
#if USE_MPI_IO
MPI_Info info_disp;
#endif
if (mpi_comm_as_void == NULL)
{
flag_passed_comm = 0;
MPI_Init(argc,argv);
MPI_Comm_dup(MPI_COMM_WORLD, &mpi_comm);
}
else
{
mpi_comm = *((MPI_Comm *) mpi_comm_as_void);
flag_passed_comm = 1;
}
MPI_Comm_size(mpi_comm, &(SID.n_proc));
MPI_Comm_rank(mpi_comm, &(SID.My_rank));
SID.My_node =(char *)SID_malloc(SID_MAXLENGTH_PROCESSOR_NAME * sizeof(char));
#if USE_MPI
MPI_Get_processor_name(SID.My_node, &node_name_length);
#else
sprintf(SID.My_node,"localhost");
node_name_length=strlen(SID.My_node);
#endif
if (node_name_length >= SID_MAXLENGTH_PROCESSOR_NAME-1)
SID_trap_error("SID_MAXLENGTH_PROCESSOR_NAME needs to be increased",ERROR_LOGIC);
// Make my_rank=MASTER_RANK the master
if(SID.My_rank==MASTER_RANK)
SID.I_am_Master=TRUE;
else
SID.I_am_Master=FALSE;
// Identify the last rank
if(SID.My_rank==SID.n_proc-1)
SID.I_am_last_rank=TRUE;
else
SID.I_am_last_rank=FALSE;
#if USE_MPI_IO
// Fetch collective buffering defaults
MPI_Info_create(&(SID.file_info));
if(SID.I_am_Master){
fp_hack=fopen(".tmp.SID","w+");
fclose(fp_hack);
}
MPI_Barrier(mpi_comm);
MPI_File_open(mpi_comm,
".tmp.SID",
MPI_MODE_WRONLY,
MPI_INFO_NULL,
&(fp_tmp.fp));
MPI_File_get_info(fp_tmp.fp,&info_disp);
MPI_Info_get_nkeys(info_disp,&n_keys);
for(i_key=0;i_key<n_keys;i_key++){
MPI_Info_get_nthkey(info_disp,i_key,key);
MPI_Info_get(info_disp,key,MPI_MAX_INFO_VAL,key_value,&key_exists);
if(key_exists)
MPI_Info_set((SID.file_info),key,key_value);
}
MPI_File_close(&(fp_tmp.fp));
if(SID.I_am_Master)
remove(".tmp.SID");
// Set user-defined colective buffering optimizations
sprintf(nodes_string,"%d",MIN(SID.n_proc,N_IO_FILES_MAX));
MPI_Info_set((SID.file_info),"cb_nodes", nodes_string);
MPI_Info_set((SID.file_info),"cb_config_list", "*:1");
#endif
#else
SID.My_rank=MASTER_RANK;
SID.n_proc =1;
#endif
/*
#if !USE_MPI_IO
SID.n_groups=SID.n_proc/N_IO_FILES_MAX;
if(SID.n_proc%N_IO_FILES_MAX) SID.n_groups++;
SID.My_group=SID.My_rank/N_IO_FILES_MAX;
#endif
*/
// Set ranks to the left and right
SID.rank_to_right =(SID.My_rank+1)%SID.n_proc;
SID.rank_to_left = SID.My_rank-1;
if(SID.rank_to_left<0)
SID.rank_to_left = SID.n_proc-1;
// Intitialize log timing information
SID.time_start_level=(time_t *)SID_malloc(sizeof(time_t)*SID_LOG_MAX_LEVELS);
SID.time_stop_level =(time_t *)SID_malloc(sizeof(time_t)*SID_LOG_MAX_LEVELS);
SID.time_total_level=(int *)SID_malloc(sizeof(int) *SID_LOG_MAX_LEVELS);
SID.IO_size =(double *)SID_malloc(sizeof(double)*SID_LOG_MAX_LEVELS);
SID.flag_use_timer =(int *)SID_malloc(sizeof(int) *SID_LOG_MAX_LEVELS);
for(i_level=0;i_level<SID_LOG_MAX_LEVELS;i_level++){
SID.time_start_level[i_level]=0;
SID.time_stop_level[i_level] =0;
SID.time_total_level[i_level]=0;
SID.IO_size[i_level] =0.;
SID.flag_use_timer[i_level] =FALSE;
}
// Initialize other log information
#if USE_MPI
if(*argc>1)
SID.fp_in =fopen((*argv)[1],"r");
else
SID.fp_in =NULL;
#else
SID.fp_in =stdin;
#endif
if (flag_passed_comm)
SID.fp_log = NULL;
else
SID.fp_log = stderr;
SID.level =0;
SID.indent =TRUE;
SID.awake =TRUE;
SID.flag_results_on=FALSE;
SID.verbosity =SID_LOG_MAX_LEVELS;
// Store the name of the binary executable that brought us here
strcpy(SID.My_binary,(*argv)[0]);
strip_path(SID.My_binary);
// Initialize argument information
if(args!=NULL){
if((status=SID_parse_args(*argc,*argv,args))>0){
SID_print_syntax(*argc,*argv,args);
SID_exit(status);
}
}
else
SID.args=NULL;
#if USE_MPI_IO
if(SID.I_am_Master){
fp_hack=fopen(".tmp.SID","w+");
fclose(fp_hack);
}
MPI_Barrier(mpi_comm);
SID_fopen(".tmp.SID","w",&fp_tmp);
MPI_File_get_info(fp_tmp.fp,&info_disp);
if(SID.I_am_Master){
fprintf(stdout,"\n");
fprintf(stdout,"MPI-I/O Configuration:\n");
fprintf(stdout,"---------------------\n");
MPI_Info_get_nkeys(info_disp,&n_keys);
for(i_key=0;i_key<n_keys;i_key++){
MPI_Info_get_nthkey(info_disp,i_key,key);
MPI_Info_get(info_disp,key,MPI_MAX_INFO_VAL,key_value,&key_exists);
if(key_exists)
fprintf(stdout,"key %2d of %d: {%s}={%s}\n",i_key+1,n_keys,key,key_value);
}
fprintf(stdout,"\n");
}
SID_fclose(&fp_tmp);
if(SID.I_am_Master)
remove(".tmp.SID");
#else
#if USE_MPI
if(SID.I_am_Master)
fprintf(stdout,"MPI-I/O switched off.\n\n");
#endif
#endif
// Create private COMM_WORLD
SID_Comm_init(&(SID.COMM_WORLD));
#if USE_MPI
MPI_Comm_dup(mpi_comm, &((SID.COMM_WORLD)->comm));
MPI_Comm_group((SID.COMM_WORLD)->comm,&((SID.COMM_WORLD)->group));
MPI_Comm_size(SID.COMM_WORLD->comm, &((SID.COMM_WORLD)->n_proc));
MPI_Comm_rank(SID.COMM_WORLD->comm, &((SID.COMM_WORLD)->My_rank));
// We have duplicated our duplicate mpi communicator - now we can free the
// original duplicate
MPI_Comm_free(&mpi_comm);
#else
SID.COMM_WORLD->comm =NULL;
SID.COMM_WORLD->group =NULL;
SID.COMM_WORLD->n_proc =1;
SID.COMM_WORLD->My_rank=MASTER_RANK;
#endif
// Start total-run-ime timer
(void)time(&(SID.time_start));
// Default max wallclock
SID.max_wallclock=DEFAULT_MAX_WALLCLOCK_TIME;
}
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;
}
int main( int argc, char *argv[] )
{
MPI_Info infos[MAX_INFOS];
char key[64], value[64];
int errs = 0;
int i, j;
MTest_Init( &argc, &argv );
/* We create max_info items, then delete the middle third of them,
then recreate them, then check them, then
delete them all. This checks that the MPICH algorithm for
handling large numbers of items works correctly; other MPI
implementations should also be able to handle this */
/* Create them all */
for (i=0; i<MAX_INFOS; i++) {
MPI_Info_create( &infos[i] );
DBGPRINTF( ( "Info handle is %x\n", infos[i] ) );
for (j=0; j<info_list; j++) {
sprintf( key, "key%d-%d", i, j );
sprintf( value, "value%d-%d", i, j );
DBGPRINTF( ( "Creating key/value %s=%s\n", key, value ));
MPI_Info_set( infos[i], key, value );
}
#ifdef DBG
{ int nkeys;
MPI_Info_get_nkeys( infos[0], &nkeys );
if (nkeys != info_list) {
printf( "infos[0] changed at %d info\n", i );}
}
#endif
}
/* Delete the middle set */
for (i=MAX_INFOS/3; i<(2*MAX_INFOS/3); i++) {
MPI_Info_free( &infos[i] );
}
/* Recreate the middle set */
for (i=MAX_INFOS/3; i<(2*MAX_INFOS/3); i++) {
MPI_Info_create( &infos[i] );
DBGPRINTF( ( "Info handle is %x\n", infos[i] ) );
for (j=0; j<info_list; j++) {
sprintf( key, "key%d-%d", i, j );
sprintf( value, "value%d-%d", i, j );
DBGPRINTF( ( "Creating key/value %s=%s\n", key, value ));
MPI_Info_set( infos[i], key, value );
}
}
/* Now, check that they are still valid */
for (i=0; i<MAX_INFOS; i++) {
int nkeys;
/*printf( "info = %x\n", infos[i] );
print_handle( infos[i] ); printf( "\n" );*/
MPI_Info_get_nkeys( infos[i], &nkeys );
if (nkeys != info_list) {
errs++;
if (errs < MAX_ERRORS) {
printf( "Wrong number of keys for info %d; got %d, should be %d\n",
i, nkeys, info_list );
}
}
for (j=0; j<nkeys; j++) {
char keystr[64];
char valstr[64];
int flag;
MPI_Info_get_nthkey( infos[i], j, key );
sprintf( keystr, "key%d-%d", i, j );
if (strcmp( keystr, key ) != 0) {
errs++;
if (errs < MAX_ERRORS) {
printf( "Wrong key for info %d; got %s expected %s\n",
i, key, keystr );
}
continue;
}
MPI_Info_get( infos[i], key, 64, value, &flag );
if (!flag) {
errs++;
if (errs < MAX_ERRORS) {
printf( "Get failed to return value for info %d\n", i );
}
continue;
}
sprintf( valstr, "value%d-%d", i, j );
if (strcmp( valstr, value ) != 0) {
errs++;
if (errs < MAX_ERRORS) {
printf( "Wrong value for info %d; got %s expected %s\n",
i, value, valstr );
}
}
}
}
for (i=0; i<MAX_INFOS; i++) {
MPI_Info_free( &infos[i] );
}
MTest_Finalize( errs );
MPI_Finalize( );
return 0;
}
void
phdf5writeAll(char *filename)
{
hid_t fid1; /* HDF5 file IDs */
hid_t acc_tpl1; /* File access templates */
hid_t xfer_plist; /* Dataset transfer properties list */
hid_t sid1; /* Dataspace ID */
hid_t file_dataspace; /* File dataspace ID */
hid_t mem_dataspace; /* memory dataspace ID */
hid_t dataset1, dataset2; /* Dataset ID */
hsize_t dims1[SPACE1_RANK] =
{SPACE1_DIM1,SPACE1_DIM2}; /* dataspace dim sizes */
DATATYPE data_array1[SPACE1_DIM1][SPACE1_DIM2]; /* data buffer */
hsize_t start[SPACE1_RANK]; /* for hyperslab setting */
hsize_t count[SPACE1_RANK], stride[SPACE1_RANK]; /* for hyperslab setting */
herr_t ret; /* Generic return value */
MPI_Comm comm = MPI_COMM_WORLD;
MPI_Info info = MPI_INFO_NULL;
/* in support of H5Tuner Test */
MPI_Comm comm_test = MPI_COMM_WORLD;
MPI_Info info_test ;
int i_test, nkeys_test, flag_test;
char key[MPI_MAX_INFO_KEY], value[MPI_MAX_INFO_VAL+1];
char *libtuner_file = getenv("LD_PRELOAD");
/* in support of H5Tuner Test */
if (verbose)
printf("Collective write test on file %s\n", filename);
/* -------------------
* START AN HDF5 FILE
* -------------------*/
/* setup file access template with parallel IO access. */
acc_tpl1 = H5Pcreate (H5P_FILE_ACCESS);
assert(acc_tpl1 != FAIL);
MESG("H5Pcreate access succeed");
/* set Parallel access with communicator */
ret = H5Pset_fapl_mpio(acc_tpl1, comm, info);
assert(ret != FAIL);
MESG("H5Pset_fapl_mpio succeed");
/* create the file collectively */
fid1=H5Fcreate(filename,H5F_ACC_TRUNC,H5P_DEFAULT,acc_tpl1);
assert(fid1 != FAIL);
MESG("H5Fcreate succeed");
// ------------------------------------------------
// H5Tuner tests
// ------------------------------------------------
// Retrieve MPI parameters set via the H5Tuner
printf("\n\n--------------------------------------------------\n");
if ( (libtuner_file != NULL) && (strlen(libtuner_file) > 1) ){
printf("Version of the H5Tuner loaded: \n%s\n", libtuner_file);
}
else {
printf("No H5Tuner currently loaded.\n");
}
printf("--------------------------------------------------\n");
// Retrieve HDF5 Threshold and Alignment
hsize_t alignment[2];
size_t sieve_buf_size;
alignment[0]= 0; // threshold value
alignment[1]= 0; // alignment value
int ierr = H5Pget_alignment(acc_tpl1, &alignment[0], &alignment[1]);
printf("\n\n--------------------------------------------------\n");
printf("Testing values for Threshold and Alignment\n");
printf("--------------------------------------------------\n");
printf("Test value set to:88 \nRetrieved Threshold=%lu\n", alignment[0]);
printf("Test value set to:44 \nRetrieved Alignment=%lu\n", alignment[1]);
// Check Threshold
if ( alignment[0] == 88 ) {
printf("PASSED: Threshold Test\n");
}
else {
printf("FAILED: Threshold Test\n");
}
// Check Alignment
if ( alignment[1] == 44 ) {
printf("PASSED: Alignment Test\n");
}
else {
printf("FAILED: Alignment Test\n");
}
printf("--------------------------------------------------\n\n");
// Retrieve HDF5 sieve buffer size
ierr = H5Pget_sieve_buf_size(acc_tpl1, &sieve_buf_size);
printf("\n\n--------------------------------------------------\n");
printf("Testing values for Sieve Buffer Size\n");
printf("--------------------------------------------------\n");
printf("Test value set to:77 \nRetrieved Sieve Buffer Size=%lu\n", sieve_buf_size);
// Check sieve buffer size
if ( (int) sieve_buf_size == 77 ) {
printf("PASSED: Sieve Buffer Size Test\n");
}
else {
printf("FAILED: Sieve Buffer Size Test\n");
}
printf("--------------------------------------------------\n\n");
// Retrieve MPI parameters set via the H5Tuner
MPI_Info_create(&info_test);
ret = H5Pget_fapl_mpio(acc_tpl1, &comm_test, &info_test);
assert(ret != FAIL);
MESG("H5Pget_fapl_mpio succeed");
printf("-------------------------------------------------\n" );
printf("Testing parameters values via MPI_Info\n" );
printf("-------------------------------------------------\n" );
if(info_test == MPI_INFO_NULL) {
printf("MPI info object is null. No keys are available.\n");
}
else {
MPI_Info_get_nkeys(info_test, &nkeys_test);
//printf("MPI info has %d keys\n", nkeys_test);
if (nkeys_test <= 0) {
printf("MPI info has no keys\n");
}
else {
printf("MPI info has %d keys\n", nkeys_test);
for ( i_test=0; i_test < nkeys_test; i_test++) {
MPI_Info_get_nthkey( info_test, i_test, key );
MPI_Info_get( info_test, key, MPI_MAX_INFO_VAL, value, &flag_test );
printf( "Retrieved value for key %s is %s\n", key, value );
//fflush(stdout);
}
}
printf("-------------------------------------------------\n" );
MPI_Info_free(&info_test);
}
// end of H5Tuner tests
// ---------------------------------------
/* Release file-access template */
ret=H5Pclose(acc_tpl1);
assert(ret != FAIL);
/* --------------------------
* Define the dimensions of the overall datasets
* and create the dataset
* ------------------------- */
/* setup dimensionality object */
sid1 = H5Screate_simple (SPACE1_RANK, dims1, NULL);
assert (sid1 != FAIL);
MESG("H5Screate_simple succeed");
/* create a dataset collectively */
dataset1 = H5Dcreate2(fid1, DATASETNAME1, H5T_NATIVE_INT, sid1, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
assert(dataset1 != FAIL);
MESG("H5Dcreate2 succeed");
/* create another dataset collectively */
dataset2 = H5Dcreate2(fid1, DATASETNAME2, H5T_NATIVE_INT, sid1, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
assert(dataset2 != FAIL);
MESG("H5Dcreate2 2 succeed");
/*
* Set up dimensions of the slab this process accesses.
*/
/* Dataset1: each process takes a block of rows. */
slab_set(start, count, stride, BYROW);
if (verbose)
printf("start[]=(%lu,%lu), count[]=(%lu,%lu), total datapoints=%lu\n",
(unsigned long)start[0], (unsigned long)start[1],
(unsigned long)count[0], (unsigned long)count[1],
(unsigned long)(count[0]*count[1]));
/* create a file dataspace independently */
file_dataspace = H5Dget_space (dataset1);
assert(file_dataspace != FAIL);
MESG("H5Dget_space succeed");
ret=H5Sselect_hyperslab(file_dataspace, H5S_SELECT_SET, start, stride,
count, NULL);
assert(ret != FAIL);
MESG("H5Sset_hyperslab succeed");
/* create a memory dataspace independently */
mem_dataspace = H5Screate_simple (SPACE1_RANK, count, NULL);
assert (mem_dataspace != FAIL);
/* fill the local slab with some trivial data */
dataset_fill(start, count, stride, &data_array1[0][0]);
MESG("data_array initialized");
if (verbose){
MESG("data_array created");
dataset_print(start, count, stride, &data_array1[0][0]);
}
/* set up the collective transfer properties list */
xfer_plist = H5Pcreate (H5P_DATASET_XFER);
assert(xfer_plist != FAIL);
ret=H5Pset_dxpl_mpio(xfer_plist, H5FD_MPIO_COLLECTIVE);
assert(ret != FAIL);
MESG("H5Pcreate xfer succeed");
/* write data collectively */
ret = H5Dwrite(dataset1, H5T_NATIVE_INT, mem_dataspace, file_dataspace,
xfer_plist, data_array1);
assert(ret != FAIL);
MESG("H5Dwrite succeed");
/* release all temporary handles. */
/* Could have used them for dataset2 but it is cleaner */
/* to create them again.*/
H5Sclose(file_dataspace);
H5Sclose(mem_dataspace);
H5Pclose(xfer_plist);
/* Dataset2: each process takes a block of columns. */
slab_set(start, count, stride, BYCOL);
if (verbose)
printf("start[]=(%lu,%lu), count[]=(%lu,%lu), total datapoints=%lu\n",
(unsigned long)start[0], (unsigned long)start[1],
(unsigned long)count[0], (unsigned long)count[1],
(unsigned long)(count[0]*count[1]));
/* put some trivial data in the data_array */
dataset_fill(start, count, stride, &data_array1[0][0]);
MESG("data_array initialized");
if (verbose){
MESG("data_array created");
dataset_print(start, count, stride, &data_array1[0][0]);
}
/* create a file dataspace independently */
file_dataspace = H5Dget_space (dataset1);
assert(file_dataspace != FAIL);
MESG("H5Dget_space succeed");
ret=H5Sselect_hyperslab(file_dataspace, H5S_SELECT_SET, start, stride,
count, NULL);
assert(ret != FAIL);
MESG("H5Sset_hyperslab succeed");
/* create a memory dataspace independently */
mem_dataspace = H5Screate_simple (SPACE1_RANK, count, NULL);
assert (mem_dataspace != FAIL);
/* fill the local slab with some trivial data */
dataset_fill(start, count, stride, &data_array1[0][0]);
MESG("data_array initialized");
if (verbose){
MESG("data_array created");
dataset_print(start, count, stride, &data_array1[0][0]);
}
/* set up the collective transfer properties list */
xfer_plist = H5Pcreate (H5P_DATASET_XFER);
assert(xfer_plist != FAIL);
ret=H5Pset_dxpl_mpio(xfer_plist, H5FD_MPIO_COLLECTIVE);
assert(ret != FAIL);
MESG("H5Pcreate xfer succeed");
/* write data independently */
ret = H5Dwrite(dataset2, H5T_NATIVE_INT, mem_dataspace, file_dataspace,
xfer_plist, data_array1);
assert(ret != FAIL);
MESG("H5Dwrite succeed");
/* release all temporary handles. */
H5Sclose(file_dataspace);
H5Sclose(mem_dataspace);
H5Pclose(xfer_plist);
/*
* All writes completed. Close datasets collectively
*/
ret=H5Dclose(dataset1);
assert(ret != FAIL);
MESG("H5Dclose1 succeed");
ret=H5Dclose(dataset2);
assert(ret != FAIL);
MESG("H5Dclose2 succeed");
/* release all IDs created */
H5Sclose(sid1);
/* close the file collectively */
H5Fclose(fid1);
}
int main(int argc, char **argv)
{
int i, len, nkeys, flag, mynod, default_striping_factor, nprocs;
MPI_File fh;
MPI_Info info, info_used;
char *filename, key[MPI_MAX_INFO_KEY], value[MPI_MAX_INFO_VAL];
MPI_Init(&argc,&argv);
MPI_Comm_rank(MPI_COMM_WORLD, &mynod);
MPI_Comm_size(MPI_COMM_WORLD, &nprocs);
/* process 0 takes the file name as a command-line argument and
broadcasts it to other processes */
if (!mynod) {
i = 1;
while ((i < argc) && strcmp("-fname", *argv)) {
i++;
argv++;
}
if (i >= argc) {
printf("\n*# Usage: file_info -fname filename\n\n");
MPI_Abort(MPI_COMM_WORLD, 1);
}
argv++;
len = strlen(*argv);
filename = (char *) malloc(len+1);
strcpy(filename, *argv);
MPI_Bcast(&len, 1, MPI_INT, 0, MPI_COMM_WORLD);
MPI_Bcast(filename, len+1, MPI_CHAR, 0, MPI_COMM_WORLD);
}
else {
MPI_Bcast(&len, 1, MPI_INT, 0, MPI_COMM_WORLD);
filename = (char *) malloc(len+1);
MPI_Bcast(filename, len+1, MPI_CHAR, 0, MPI_COMM_WORLD);
}
/* open the file with MPI_INFO_NULL */
MPI_File_open(MPI_COMM_WORLD, filename, MPI_MODE_CREATE | MPI_MODE_RDWR,
MPI_INFO_NULL, &fh);
/* check the default values set by ROMIO */
MPI_File_get_info(fh, &info_used);
MPI_Info_get_nkeys(info_used, &nkeys);
for (i=0; i<nkeys; i++) {
MPI_Info_get_nthkey(info_used, i, key);
MPI_Info_get(info_used, key, MPI_MAX_INFO_VAL-1, value, &flag);
if (!mynod)
printf("Process %d, Default: key = %s, value = %s\n", mynod,
key, value);
if (!strcmp("striping_factor", key))
default_striping_factor = atoi(value);
}
MPI_File_close(&fh);
/* delete the file */
if (!mynod) MPI_File_delete(filename, MPI_INFO_NULL);
MPI_Barrier(MPI_COMM_WORLD);
/* set new info values. */
MPI_Info_create(&info);
/* The following four hints are accepted on all machines. They can
be specified at file-open time or later (any number of times). */
/* buffer size for collective I/O */
MPI_Info_set(info, "cb_buffer_size", "8388608");
/* number of processes that actually perform I/O in collective I/O */
sprintf(value, "%d", nprocs/2);
MPI_Info_set(info, "cb_nodes", value);
/* buffer size for data sieving in independent reads */
MPI_Info_set(info, "ind_rd_buffer_size", "2097152");
/* buffer size for data sieving in independent writes */
MPI_Info_set(info, "ind_wr_buffer_size", "1048576");
/* The following three hints related to file striping are accepted only
on Intel PFS and IBM PIOFS file systems and are ignored elsewhere.
They can be specified only at file-creation time; if specified later
they will be ignored. */
/* number of I/O devices across which the file will be striped.
accepted only if 0 < value < default_striping_factor;
ignored otherwise */
sprintf(value, "%d", default_striping_factor-1);
MPI_Info_set(info, "striping_factor", value);
/* the striping unit in bytes */
MPI_Info_set(info, "striping_unit", "131072");
/* the I/O device number from which to start striping the file.
accepted only if 0 <= value < default_striping_factor;
ignored otherwise */
sprintf(value, "%d", default_striping_factor-2);
MPI_Info_set(info, "start_iodevice", value);
/* The following hint about PFS server buffering is accepted only on
Intel PFS. It can be specified anytime. */
MPI_Info_set(info, "pfs_svr_buf", "true");
/* open the file and set new info */
MPI_File_open(MPI_COMM_WORLD, filename, MPI_MODE_CREATE | MPI_MODE_RDWR,
info, &fh);
/* check the values set */
MPI_File_get_info(fh, &info_used);
MPI_Info_get_nkeys(info_used, &nkeys);
if (!mynod) printf("\n New values\n\n");
for (i=0; i<nkeys; i++) {
MPI_Info_get_nthkey(info_used, i, key);
MPI_Info_get(info_used, key, MPI_MAX_INFO_VAL-1, value, &flag);
if (!mynod) printf("Process %d, key = %s, value = %s\n", mynod,
key, value);
}
MPI_File_close(&fh);
free(filename);
MPI_Info_free(&info_used);
MPI_Info_free(&info);
MPI_Finalize();
return 0;
}
void ADIOI_PFS_Open(ADIO_File fd, int *error_code)
{
int perm, amode, old_mask, np_comm, np_total, err, flag;
char *value;
struct sattr attr;
static char myname[] = "ADIOI_PFS_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)
amode = amode | O_CREAT;
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;
MPI_Comm_size(MPI_COMM_WORLD, &np_total);
MPI_Comm_size(fd->comm, &np_comm);
if (np_total == np_comm)
fd->fd_sys = _gopen(fd->filename, amode, M_ASYNC, perm);
else fd->fd_sys = open(fd->filename, amode, perm);
fd->fd_direct = -1;
if (fd->fd_sys != -1) {
value = (char *) ADIOI_Malloc((MPI_MAX_INFO_VAL+1)*sizeof(char));
/* if user has asked for pfs server buffering to be turned on,
it will be set to true in fd->info in the earlier call
to ADIOI_PFS_SetInfo. Turn it on now, since we now have a
valid file descriptor. */
MPI_Info_get(fd->info, "pfs_svr_buf", MPI_MAX_INFO_VAL,
value, &flag);
if (flag && (!strcmp(value, "true"))) {
err = fcntl(fd->fd_sys, F_PFS_SVR_BUF, TRUE);
if (err) MPI_Info_set(fd->info, "pfs_svr_buf", "false");
}
/* get file striping information and set it in info */
err = fcntl(fd->fd_sys, F_GETSATTR, &attr);
if (!err) {
ADIOI_Snprintf(value, MPI_MAX_INFO_VAL+1, "%d", attr.s_sunitsize);
MPI_Info_set(fd->info, "striping_unit", value);
ADIOI_Snprintf(value, MPI_MAX_INFO_VAL+1, "%d", attr.s_sfactor);
MPI_Info_set(fd->info, "striping_factor", value);
ADIOI_Snprintf(value, MPI_MAX_INFO_VAL+1, "%d", attr.s_start_sdir);
MPI_Info_set(fd->info, "start_iodevice", value);
}
ADIOI_Free(value);
if (fd->access_mode & ADIO_APPEND)
fd->fp_ind = fd->fp_sys_posn = lseek(fd->fd_sys, 0, SEEK_END);
}
if (fd->fd_sys == -1) {
*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;
}
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;
*error_code = MPI_SUCCESS;
value = (char *) ADIOI_Malloc((MPI_MAX_INFO_VAL+1)*sizeof(char));
MPI_Info_get(fd->info, "panfs_layout_type", MPI_MAX_INFO_VAL,
value, &flag);
if (flag) {
layout_type = strtoul(value,NULL,10);
}
MPI_Info_get(fd->info, "panfs_layout_stripe_unit", MPI_MAX_INFO_VAL,
value, &flag);
if (flag) {
layout_stripe_unit = strtoul(value,NULL,10);
}
MPI_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);
}
MPI_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);
}
MPI_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);
}
MPI_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__RAID1_5_PARITY_STRIPE))
{
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__RAID0) ||
(layout_type == PAN_FS_CLIENT_LAYOUT_TYPE__RAID1_5_PARITY_STRIPE))
{
int myrank;
MPI_Comm_rank(fd->comm, &myrank);
if (myrank == 0) {
pan_fs_client_layout_create_args_t file_create_args;
int fd_dir;
char* slash;
struct stat stat_buf;
int err;
char *value, *path, *file_name_ptr;
/* 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 = strdup(fd->filename);
slash = strrchr(path, '/');
if (!slash)
strcpy(path, ".");
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;
strcpy(file_create_args.filename, file_name_ptr);
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;
}
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);
}
free(path);
}
}
MPI_Barrier(fd->comm);
}
}
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));
MPI_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 */
MPI_Info_set(fd->info, "panfs_layout_type", "PAN_FS_CLIENT_LAYOUT_TYPE__INVALID");
}
else
{
snprintf(temp_buffer,TEMP_BUFFER_SIZE,"%u",file_query_args.layout.agg_type);
MPI_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:
snprintf(temp_buffer,TEMP_BUFFER_SIZE,"%u",file_query_args.layout.u.raid0.stripe_unit);
MPI_Info_set(fd->info, "panfs_layout_stripe_unit", temp_buffer);
snprintf(temp_buffer,TEMP_BUFFER_SIZE,"%u",file_query_args.layout.u.raid0.total_num_comps);
MPI_Info_set(fd->info, "panfs_layout_total_num_comps", temp_buffer);
break;
case PAN_FS_CLIENT_LAYOUT_TYPE__RAID1_5_PARITY_STRIPE:
snprintf(temp_buffer,TEMP_BUFFER_SIZE,"%u",file_query_args.layout.u.raid1_5_parity_stripe.stripe_unit);
MPI_Info_set(fd->info, "panfs_layout_stripe_unit", temp_buffer);
snprintf(temp_buffer,TEMP_BUFFER_SIZE,"%u",file_query_args.layout.u.raid1_5_parity_stripe.parity_stripe_width);
MPI_Info_set(fd->info, "panfs_layout_parity_stripe_width", temp_buffer);
snprintf(temp_buffer,TEMP_BUFFER_SIZE,"%u",file_query_args.layout.u.raid1_5_parity_stripe.parity_stripe_depth);
MPI_Info_set(fd->info, "panfs_layout_parity_stripe_depth", temp_buffer);
snprintf(temp_buffer,TEMP_BUFFER_SIZE,"%u",file_query_args.layout.u.raid1_5_parity_stripe.total_num_comps);
MPI_Info_set(fd->info, "panfs_layout_total_num_comps", temp_buffer);
snprintf(temp_buffer,TEMP_BUFFER_SIZE,"%u",file_query_args.layout.u.raid1_5_parity_stripe.layout_visit_policy);
MPI_Info_set(fd->info, "panfs_layout_visit_policy", temp_buffer);
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;
}
int main(int argc, char** argv) {
char filename[256];
int rank, nprocs, err, flag, nerrs=0;
int log_enabled;
int ncid;
MPI_Info info, infoused;
char hint[MPI_MAX_INFO_VAL];
MPI_Init(&argc, &argv);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
MPI_Comm_size(MPI_COMM_WORLD, &nprocs);
if (argc > 2) {
if (!rank) printf("Usage: %s [filename]\n",argv[0]);
MPI_Finalize();
return 1;
}
if (argc == 2) snprintf(filename, 256, "%s", argv[1]);
else strcpy(filename, "testfile.nc");
MPI_Bcast(filename, 256, MPI_CHAR, 0, MPI_COMM_WORLD);
if (rank == 0) {
char *cmd_str = (char*)malloc(strlen(argv[0]) + 256);
sprintf(cmd_str, "*** TESTING C %s for checking offsets of new variables ", basename(argv[0]));
printf("%-66s ------ ", cmd_str); fflush(stdout);
free(cmd_str);
}
MPI_Info_create(&info);
MPI_Info_set(info, "nc_dw_overwrite", "enable");
MPI_Info_set(info, "nc_dw_del_on_close", "disable");
MPI_Info_set(info, "nc_dw_flush_buffer_size", "256");
/* MPI_Info_set(info, "nc_dw_dirname", "()@^$@!(_&$)@(#%%&)(*#$"); */
err = ncmpi_create(MPI_COMM_WORLD, filename, NC_CLOBBER, info, &ncid); CHECK_ERR
err = ncmpi_inq_file_info(ncid, &infoused); CHECK_ERR
MPI_Info_get(infoused, "nc_dw", MPI_MAX_INFO_VAL - 1, hint, &flag);
if (flag && strcasecmp(hint, "enable") == 0)
log_enabled = 1;
else
log_enabled = 0;
if (log_enabled) {
MPI_Info_get(infoused, "nc_dw_overwrite", MPI_MAX_INFO_VAL - 1, hint, &flag);
if (flag) {
if (strcmp(hint, "enable") != 0) {
printf("Error at line %d: unexpected nc_dw_overwrite = %s, but got %s\n", __LINE__, "enable", hint);
nerrs++;
}
}
else{
printf("Error at line %d: nc_dw_overwrite is not set\n", __LINE__);
nerrs++;
}
MPI_Info_get(infoused, "nc_dw_del_on_close", MPI_MAX_INFO_VAL - 1, hint, &flag);
if (flag) {
if (strcmp(hint, "disable") != 0) {
printf("Error at line %d: unexpected nc_dw_del_on_close = %s, but got %s\n", __LINE__, "disable", hint);
nerrs++;
}
}
else{
printf("Error at line %d: nc_dw_del_on_close is not set\n", __LINE__);
nerrs++;
}
MPI_Info_get(infoused, "nc_dw_flush_buffer_size", MPI_MAX_INFO_VAL - 1, hint, &flag);
if (flag) {
if (strcmp(hint, "256") != 0) {
printf("Error at line %d: unexpected nc_dw_flush_buffer_size = %s, but got %s\n", __LINE__, "256", hint);
nerrs++;
}
}
else{
printf("Error at line %d: nc_dw_flush_buffer_size is not set\n", __LINE__);
nerrs++;
}
}
err = ncmpi_enddef(ncid); CHECK_ERR
err = ncmpi_close(ncid); CHECK_ERR
MPI_Info_free(&info);
MPI_Info_free(&infoused);
/* check if PnetCDF freed all internal malloc */
MPI_Offset malloc_size, sum_size;
err = ncmpi_inq_malloc_size(&malloc_size);
if (err == NC_NOERR) {
MPI_Reduce(&malloc_size, &sum_size, 1, MPI_OFFSET, MPI_SUM, 0, MPI_COMM_WORLD);
if (rank == 0 && sum_size > 0)
printf("heap memory allocated by PnetCDF internally has %lld bytes yet to be freed\n",
sum_size);
}
MPI_Allreduce(MPI_IN_PLACE, &nerrs, 1, MPI_INT, MPI_SUM, MPI_COMM_WORLD);
if (rank == 0) {
if (nerrs) printf(FAIL_STR,nerrs);
else printf(PASS_STR);
}
MPI_Finalize();
return (nerrs > 0);
}
int main(int argc, char **argv)
{
MPI_Info info_in, info_out;
int errors = 0, all_errors = 0;
MPI_Win win;
void *base;
char invalid_key[] = "invalid_test_key";
char buf[MPI_MAX_INFO_VAL];
int flag;
MPI_Comm shm_comm = MPI_COMM_NULL;
MPI_Init(&argc, &argv);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
MPI_Comm_size(MPI_COMM_WORLD, &nproc);
/* Test#1: setting a valid key at window-create time */
MPI_Info_create(&info_in);
MPI_Info_set(info_in, "no_locks", "true");
MPI_Win_allocate(sizeof(int), sizeof(int), info_in, MPI_COMM_WORLD, &base, &win);
errors += check_win_info_get(win, "no_locks", "true");
MPI_Info_free(&info_in);
/* We create a new window with no info argument for the next text to ensure that we have the
* default settings */
MPI_Win_free(&win);
MPI_Win_allocate(sizeof(int), sizeof(int), MPI_INFO_NULL, MPI_COMM_WORLD, &base, &win);
/* Test#2: setting and getting invalid key */
win_info_set(win, invalid_key, "true");
MPI_Win_get_info(win, &info_out);
MPI_Info_get(info_out, invalid_key, MPI_MAX_INFO_VAL, buf, &flag);
#ifndef USE_STRICT_MPI
/* Check if our invalid key was ignored. Note, this check's MPICH's
* behavior, but this behavior may not be required for a standard
* conforming MPI implementation. */
if (flag) {
printf("%d: %s was not ignored\n", rank, invalid_key);
errors++;
}
#endif
MPI_Info_free(&info_out);
/* Test#3: setting info key "no_lock" (no default value) */
win_info_set(win, "no_locks", "false");
errors += check_win_info_get(win, "no_locks", "false");
win_info_set(win, "no_locks", "true");
errors += check_win_info_get(win, "no_locks", "true");
/* Test#4: getting/setting "accumulate_ordering" */
/* #4.1: is the default "rar,raw,war,waw" as stated in the standard? */
errors += check_win_info_get(win, "accumulate_ordering", "rar,raw,war,waw");
/* #4.2: setting "accumulate_ordering" to "none" */
win_info_set(win, "accumulate_ordering", "none");
errors += check_win_info_get(win, "accumulate_ordering", "none");
/* #4.3: setting "accumulate_ordering" to "rar,waw" */
win_info_set(win, "accumulate_ordering", "rar,waw");
errors += check_win_info_get(win, "accumulate_ordering", "rar,waw");
/* Test#5: getting/setting "accumulate_ops" */
/* #5.1: is the default "same_op_no_op" as stated in the standard? */
errors += check_win_info_get(win, "accumulate_ops", "same_op_no_op");
/* #5.2: setting "accumulate_ops" to "same_op" */
win_info_set(win, "accumulate_ops", "same_op");
errors += check_win_info_get(win, "accumulate_ops", "same_op");
/* Test#6: setting "same_size" (no default value) */
win_info_set(win, "same_size", "false");
errors += check_win_info_get(win, "same_size", "false");
win_info_set(win, "same_size", "true");
errors += check_win_info_get(win, "same_size", "true");
/* Test#7: setting "same_disp_unit" (no default value) */
win_info_set(win, "same_disp_unit", "false");
errors += check_win_info_get(win, "same_disp_unit", "false");
win_info_set(win, "same_disp_unit", "true");
errors += check_win_info_get(win, "same_disp_unit", "true");
/* TODO: check alloc_shm as implementation-specific test */
/* Test#8: setting "alloc_shared_noncontig" (no default value) in shared window. */
MPI_Win_free(&win);
/* #8.1: setting at window allocation */
MPI_Comm_split_type(MPI_COMM_WORLD, MPI_COMM_TYPE_SHARED, rank, MPI_INFO_NULL, &shm_comm);
MPI_Info_create(&info_in);
MPI_Info_set(info_in, "alloc_shared_noncontig", "true");
MPI_Win_allocate_shared(sizeof(int), sizeof(int), info_in, shm_comm, &base, &win);
errors += check_win_info_get(win, "alloc_shared_noncontig", "true");
MPI_Info_free(&info_in);
/* #8.2: setting info */
win_info_set(win, "alloc_shared_noncontig", "false");
errors += check_win_info_get(win, "alloc_shared_noncontig", "false");
MPI_Comm_free(&shm_comm);
MPI_Win_free(&win);
MPI_Reduce(&errors, &all_errors, 1, MPI_INT, MPI_SUM, 0, MPI_COMM_WORLD);
if (rank == 0 && all_errors == 0)
printf(" No Errors\n");
MPI_Finalize();
return 0;
}
void ADIOI_NFS_WriteStrided(ADIO_File fd, void *buf, int count,
MPI_Datatype datatype, int file_ptr_type,
ADIO_Offset offset, ADIO_Status *status, int
*error_code)
{
/* offset is in units of etype relative to the filetype. */
ADIOI_Flatlist_node *flat_buf, *flat_file;
int i, j, k, err=-1, bwr_size, fwr_size=0, st_index=0;
int bufsize, num, size, sum, n_etypes_in_filetype, size_in_filetype;
int n_filetypes, etype_in_filetype;
ADIO_Offset abs_off_in_filetype=0;
int filetype_size, etype_size, buftype_size, req_len;
MPI_Aint filetype_extent, buftype_extent;
int buf_count, buftype_is_contig, filetype_is_contig;
ADIO_Offset userbuf_off;
ADIO_Offset off, req_off, disp, end_offset=0, writebuf_off, start_off;
char *writebuf, *value;
int flag, st_fwr_size, st_n_filetypes, writebuf_len, write_sz;
int new_bwr_size, new_fwr_size, err_flag=0, info_flag, max_bufsize;
static char myname[] = "ADIOI_NFS_WRITESTRIDED";
ADIOI_Datatype_iscontig(datatype, &buftype_is_contig);
ADIOI_Datatype_iscontig(fd->filetype, &filetype_is_contig);
MPI_Type_size(fd->filetype, &filetype_size);
if ( ! filetype_size ) {
*error_code = MPI_SUCCESS;
return;
}
MPI_Type_extent(fd->filetype, &filetype_extent);
MPI_Type_size(datatype, &buftype_size);
MPI_Type_extent(datatype, &buftype_extent);
etype_size = fd->etype_size;
bufsize = buftype_size * count;
/* get max_bufsize from the info object. */
value = (char *) ADIOI_Malloc((MPI_MAX_INFO_VAL+1)*sizeof(char));
MPI_Info_get(fd->info, "ind_wr_buffer_size", MPI_MAX_INFO_VAL, value,
&info_flag);
max_bufsize = atoi(value);
ADIOI_Free(value);
if (!buftype_is_contig && filetype_is_contig) {
/* noncontiguous in memory, contiguous in file. */
ADIOI_Flatten_datatype(datatype);
flat_buf = ADIOI_Flatlist;
while (flat_buf->type != datatype) flat_buf = flat_buf->next;
off = (file_ptr_type == ADIO_INDIVIDUAL) ? fd->fp_ind :
fd->disp + etype_size * offset;
start_off = off;
end_offset = off + bufsize - 1;
writebuf_off = off;
writebuf = (char *) ADIOI_Malloc(max_bufsize);
writebuf_len = (int) (ADIOI_MIN(max_bufsize,end_offset-writebuf_off+1));
/* if atomicity is true, lock the region to be accessed */
if (fd->atomicity)
ADIOI_WRITE_LOCK(fd, start_off, SEEK_SET, end_offset-start_off+1);
for (j=0; j<count; j++)
for (i=0; i<flat_buf->count; i++) {
userbuf_off = j*buftype_extent + flat_buf->indices[i];
req_off = off;
req_len = flat_buf->blocklens[i];
ADIOI_BUFFERED_WRITE_WITHOUT_READ
off += flat_buf->blocklens[i];
}
/* write the buffer out finally */
lseek(fd->fd_sys, writebuf_off, SEEK_SET);
if (!(fd->atomicity)) ADIOI_WRITE_LOCK(fd, writebuf_off, SEEK_SET, writebuf_len);
err = write(fd->fd_sys, writebuf, writebuf_len);
if (!(fd->atomicity)) ADIOI_UNLOCK(fd, writebuf_off, SEEK_SET, writebuf_len);
if (err == -1) err_flag = 1;
if (fd->atomicity)
ADIOI_UNLOCK(fd, start_off, SEEK_SET, end_offset-start_off+1);
ADIOI_Free(writebuf); /* malloced in the buffered_write macro */
if (file_ptr_type == ADIO_INDIVIDUAL) fd->fp_ind = off;
if (err_flag) {
*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;
}
else { /* noncontiguous in file */
/* filetype already flattened in ADIO_Open */
flat_file = ADIOI_Flatlist;
while (flat_file->type != fd->filetype) flat_file = flat_file->next;
disp = fd->disp;
if (file_ptr_type == ADIO_INDIVIDUAL) {
offset = fd->fp_ind; /* in bytes */
n_filetypes = -1;
flag = 0;
while (!flag) {
n_filetypes++;
for (i=0; i<flat_file->count; i++) {
if (disp + flat_file->indices[i] +
(ADIO_Offset) n_filetypes*filetype_extent + flat_file->blocklens[i]
>= offset) {
st_index = i;
fwr_size = (int) (disp + flat_file->indices[i] +
(ADIO_Offset) n_filetypes*filetype_extent
+ flat_file->blocklens[i] - offset);
flag = 1;
break;
}
}
}
}
else {
n_etypes_in_filetype = filetype_size/etype_size;
n_filetypes = (int) (offset / n_etypes_in_filetype);
etype_in_filetype = (int) (offset % n_etypes_in_filetype);
size_in_filetype = etype_in_filetype * etype_size;
sum = 0;
for (i=0; i<flat_file->count; i++) {
sum += flat_file->blocklens[i];
if (sum > size_in_filetype) {
st_index = i;
fwr_size = sum - size_in_filetype;
abs_off_in_filetype = flat_file->indices[i] +
size_in_filetype - (sum - flat_file->blocklens[i]);
break;
}
}
/* abs. offset in bytes in the file */
offset = disp + (ADIO_Offset) n_filetypes*filetype_extent + abs_off_in_filetype;
}
start_off = offset;
/* Calculate end_offset, the last byte-offset that will be accessed.
e.g., if start_offset=0 and 100 bytes to be write, end_offset=99*/
st_fwr_size = fwr_size;
st_n_filetypes = n_filetypes;
i = 0;
j = st_index;
off = offset;
fwr_size = ADIOI_MIN(st_fwr_size, bufsize);
while (i < bufsize) {
i += fwr_size;
end_offset = off + fwr_size - 1;
if (j < (flat_file->count - 1)) j++;
else {
j = 0;
n_filetypes++;
}
off = disp + flat_file->indices[j] + (ADIO_Offset) n_filetypes*filetype_extent;
fwr_size = ADIOI_MIN(flat_file->blocklens[j], bufsize-i);
}
/* if atomicity is true, lock the region to be accessed */
if (fd->atomicity)
ADIOI_WRITE_LOCK(fd, start_off, SEEK_SET, end_offset-start_off+1);
/* initial read for the read-modify-write */
writebuf_off = offset;
writebuf = (char *) ADIOI_Malloc(max_bufsize);
writebuf_len = (int)(ADIOI_MIN(max_bufsize,end_offset-writebuf_off+1));
if (!(fd->atomicity)) ADIOI_WRITE_LOCK(fd, writebuf_off, SEEK_SET, writebuf_len);
lseek(fd->fd_sys, writebuf_off, SEEK_SET);
err = read(fd->fd_sys, writebuf, writebuf_len);
if (err == -1) {
*error_code = MPIO_Err_create_code(MPI_SUCCESS,
MPIR_ERR_RECOVERABLE,
myname, __LINE__,
MPI_ERR_IO,
"ADIOI_NFS_WriteStrided: ROMIO tries to optimize this access by doing a read-modify-write, but is unable to read the file. Please give the file read permission and open it with MPI_MODE_RDWR.", 0);
return;
}
if (buftype_is_contig && !filetype_is_contig) {
/* contiguous in memory, noncontiguous in file. should be the most
common case. */
i = 0;
j = st_index;
off = offset;
n_filetypes = st_n_filetypes;
fwr_size = ADIOI_MIN(st_fwr_size, bufsize);
while (i < bufsize) {
if (fwr_size) {
/* TYPE_UB and TYPE_LB can result in
fwr_size = 0. save system call in such cases */
/* lseek(fd->fd_sys, off, SEEK_SET);
err = write(fd->fd_sys, ((char *) buf) + i, fwr_size);*/
req_off = off;
req_len = fwr_size;
userbuf_off = i;
ADIOI_BUFFERED_WRITE
}
i += fwr_size;
if (off + fwr_size < disp + flat_file->indices[j] +
flat_file->blocklens[j] + (ADIO_Offset) n_filetypes*filetype_extent)
off += fwr_size;
/* did not reach end of contiguous block in filetype.
no more I/O needed. off is incremented by fwr_size. */
else {
if (j < (flat_file->count - 1)) j++;
else {
j = 0;
n_filetypes++;
}
off = disp + flat_file->indices[j] +
(ADIO_Offset) n_filetypes*filetype_extent;
fwr_size = ADIOI_MIN(flat_file->blocklens[j], bufsize-i);
}
}
}
else {
int main( int argc, char *argv[] )
{
int errs = 0;
MPI_Info info;
char *keys1[NKEYS] = { (char*)"file", (char*)"soft", (char*)"host" };
char *values1[NKEYS] = { (char*)"runfile.txt", (char*)"2:1000:4,3:1000:7",
(char*)"myhost.myorg.org" };
char value[MPI_MAX_INFO_VAL];
int i, flag;
MTest_Init( &argc, &argv );
/* 1,2,3 */
MPI_Info_create( &info );
/* Use only named keys incase the info implementation only supports
the predefined keys (e.g., IBM) */
for (i=0; i<NKEYS; i++) {
MPI_Info_set( info, keys1[i], values1[i] );
}
/* Check that all values are present */
for (i=0; i<NKEYS; i++) {
MPI_Info_get( info, keys1[i], MPI_MAX_INFO_VAL, value, &flag );
if (!flag) {
errs++;
printf( "No value for key %s\n", keys1[i] );
}
if (strcmp( value, values1[i] )) {
errs++;
printf( "Incorrect value for key %s\n", keys1[i] );
}
}
MPI_Info_free( &info );
/* 3,2,1 */
MPI_Info_create( &info );
/* Use only named keys incase the info implementation only supports
the predefined keys (e.g., IBM) */
for (i=NKEYS-1; i>=0; i--) {
MPI_Info_set( info, keys1[i], values1[i] );
}
/* Check that all values are present */
for (i=0; i<NKEYS; i++) {
MPI_Info_get( info, keys1[i], MPI_MAX_INFO_VAL, value, &flag );
if (!flag) {
errs++;
printf( "No value for key %s\n", keys1[i] );
}
if (strcmp( value, values1[i] )) {
errs++;
printf( "Incorrect value for key %s\n", keys1[i] );
}
}
MPI_Info_free( &info );
/* 1,3,2 */
MPI_Info_create( &info );
/* Use only named keys incase the info implementation only supports
the predefined keys (e.g., IBM) */
MPI_Info_set( info, keys1[0], values1[0] );
MPI_Info_set( info, keys1[2], values1[2] );
MPI_Info_set( info, keys1[1], values1[1] );
/* Check that all values are present */
for (i=0; i<NKEYS; i++) {
MPI_Info_get( info, keys1[i], MPI_MAX_INFO_VAL, value, &flag );
if (!flag) {
errs++;
printf( "No value for key %s\n", keys1[i] );
}
if (strcmp( value, values1[i] )) {
errs++;
printf( "Incorrect value for key %s\n", keys1[i] );
}
}
MPI_Info_free( &info );
/* 2,1,3 */
MPI_Info_create( &info );
/* Use only named keys incase the info implementation only supports
the predefined keys (e.g., IBM) */
MPI_Info_set( info, keys1[1], values1[1] );
MPI_Info_set( info, keys1[0], values1[0] );
MPI_Info_set( info, keys1[2], values1[2] );
/* Check that all values are present */
for (i=0; i<NKEYS; i++) {
MPI_Info_get( info, keys1[i], MPI_MAX_INFO_VAL, value, &flag );
if (!flag) {
errs++;
printf( "No value for key %s\n", keys1[i] );
}
if (strcmp( value, values1[i] )) {
errs++;
printf( "Incorrect value for key %s\n", keys1[i] );
}
}
MPI_Info_free( &info );
/* 2,3,1 */
MPI_Info_create( &info );
/* Use only named keys incase the info implementation only supports
the predefined keys (e.g., IBM) */
MPI_Info_set( info, keys1[1], values1[1] );
MPI_Info_set( info, keys1[2], values1[2] );
MPI_Info_set( info, keys1[0], values1[0] );
/* Check that all values are present */
for (i=0; i<NKEYS; i++) {
MPI_Info_get( info, keys1[i], MPI_MAX_INFO_VAL, value, &flag );
if (!flag) {
errs++;
printf( "No value for key %s\n", keys1[i] );
}
if (strcmp( value, values1[i] )) {
errs++;
printf( "Incorrect value for key %s\n", keys1[i] );
}
}
MPI_Info_free( &info );
/* 3,1,2 */
MPI_Info_create( &info );
/* Use only named keys incase the info implementation only supports
the predefined keys (e.g., IBM) */
MPI_Info_set( info, keys1[2], values1[2] );
MPI_Info_set( info, keys1[0], values1[0] );
MPI_Info_set( info, keys1[1], values1[1] );
/* Check that all values are present */
for (i=0; i<NKEYS; i++) {
MPI_Info_get( info, keys1[i], MPI_MAX_INFO_VAL, value, &flag );
if (!flag) {
errs++;
printf( "No value for key %s\n", keys1[i] );
}
if (strcmp( value, values1[i] )) {
errs++;
printf( "Incorrect value for key %s\n", keys1[i] );
}
}
MPI_Info_free( &info );
MTest_Finalize( errs );
MPI_Finalize();
return 0;
}
