/*@ MPI_File_get_position - Returns the current position of the individual file pointer in etype units relative to the current view Input Parameters: . fh - file handle (handle) Output Parameters: . offset - offset of individual file pointer (nonnegative integer) .N fortran @*/ int MPI_File_get_position(MPI_File fh, MPI_Offset *offset) { #ifndef PRINT_ERR_MSG int error_code; static char myname[] = "MPI_FILE_GET_POSITION"; #endif #ifdef PRINT_ERR_MSG if ((fh <= (MPI_File) 0) || (fh->cookie != ADIOI_FILE_COOKIE)) { FPRINTF(stderr, "MPI_File_get_position: Invalid file handle\n"); MPI_Abort(MPI_COMM_WORLD, 1); } #else ADIOI_TEST_FILE_HANDLE(fh, myname); #endif if (fh->access_mode & MPI_MODE_SEQUENTIAL) { #ifdef PRINT_ERR_MSG FPRINTF(stderr, "MPI_File_get_position: Can't use this function because file was opened with MPI_MODE_SEQUENTIAL\n"); MPI_Abort(MPI_COMM_WORLD, 1); #else error_code = MPIR_Err_setmsg(MPI_ERR_UNSUPPORTED_OPERATION, MPIR_ERR_AMODE_SEQ, myname, (char *) 0, (char *) 0); return ADIOI_Error(fh, error_code, myname); #endif } ADIOI_Get_position(fh, offset); return MPI_SUCCESS; }
void ADIOI_PFS_Close(ADIO_File fd, int *error_code) { int err; #ifndef PRINT_ERR_MSG static char myname[] = "ADIOI_PFS_CLOSE"; #endif #ifdef PROFILE MPE_Log_event(9, 0, "start close"); #endif err = close(fd->fd_sys); #ifdef PROFILE MPE_Log_event(10, 0, "end close"); #endif #ifdef PRINT_ERR_MSG *error_code = (err == 0) ? MPI_SUCCESS : MPI_ERR_UNKNOWN; #else if (err == -1) { *error_code = MPIR_Err_setmsg(MPI_ERR_IO, MPIR_ADIO_ERROR, myname, "I/O Error", "%s", strerror(errno)); ADIOI_Error(fd, *error_code, myname); } else *error_code = MPI_SUCCESS; #endif }
void ADIOI_PIOFS_Close(ADIO_File fd, int *error_code) { int err; #ifndef PRINT_ERR_MSG static char myname[] = "ADIOI_PIOFS_CLOSE"; #endif #ifdef PROFILE MPE_Log_event(9, 0, "start close"); #endif err = close(fd->fd_sys); #ifdef PROFILE MPE_Log_event(10, 0, "end close"); #endif if (err == -1) { #ifdef MPICH2 *error_code = MPIR_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, myname, __LINE__, MPI_ERR_IO, "**io", "**io %s", strerror(errno)); #elif defined(PRINT_ERR_MSG) *error_code = MPI_ERR_UNKNOWN; #else /* MPICH-1 */ *error_code = MPIR_Err_setmsg(MPI_ERR_IO, MPIR_ADIO_ERROR, myname, "I/O Error", "%s", strerror(errno)); ADIOI_Error(fd, *error_code, myname); #endif } else *error_code = MPI_SUCCESS; }
/*@ MPI_File_get_type_extent - Returns the extent of datatype in the file Input Parameters: . fh - file handle (handle) . datatype - datatype (handle) Output Parameters: . extent - extent of the datatype (nonnegative integer) .N fortran @*/ int MPI_File_get_type_extent(MPI_File fh, MPI_Datatype datatype, MPI_Aint *extent) { #ifndef PRINT_ERR_MSG int error_code; static char myname[] = "MPI_FILE_GET_TYPE_EXTENT"; #endif #ifdef PRINT_ERR_MSG if ((fh <= (MPI_File) 0) || (fh->cookie != ADIOI_FILE_COOKIE)) { FPRINTF(stderr, "MPI_File_get_type_extent: Invalid file handle\n"); MPI_Abort(MPI_COMM_WORLD, 1); } #else ADIOI_TEST_FILE_HANDLE(fh, myname); #endif if (datatype == MPI_DATATYPE_NULL) { #ifdef PRINT_ERR_MSG FPRINTF(stderr, "MPI_File_get_type_extent: Invalid datatype\n"); MPI_Abort(MPI_COMM_WORLD, 1); #else error_code = MPIR_Err_setmsg(MPI_ERR_TYPE, MPIR_ERR_TYPE_NULL, myname, (char *) 0, (char *) 0); return ADIOI_Error(fh, error_code, myname); #endif } return MPI_Type_extent(datatype, extent); }
/*@ MPI_File_write_at_all_end - Complete a split collective write using explict offset Input Parameters: . fh - file handle (handle) . buf - initial address of buffer (choice) Output Parameters: . status - status object (Status) .N fortran @*/ int MPI_File_write_at_all_end(MPI_File fh, void *buf, MPI_Status *status) { #ifndef PRINT_ERR_MSG int error_code; static char myname[] = "MPI_FILE_WRITE_AT_ALL_END"; #endif #ifdef PRINT_ERR_MSG if ((fh <= (MPI_File) 0) || (fh->cookie != ADIOI_FILE_COOKIE)) { FPRINTF(stderr, "MPI_File_write_at_all_end: Invalid file handle\n"); MPI_Abort(MPI_COMM_WORLD, 1); } #else ADIOI_TEST_FILE_HANDLE(fh, myname); #endif if (!(fh->split_coll_count)) { #ifdef PRINT_ERR_MSG FPRINTF(stderr, "MPI_File_write_at_all_end: Does not match a previous MPI_File_write_at_all_begin\n"); MPI_Abort(MPI_COMM_WORLD, 1); #else error_code = MPIR_Err_setmsg(MPI_ERR_IO, MPIR_ERR_NO_SPLIT_COLL, myname, (char *) 0, (char *) 0); return ADIOI_Error(fh, error_code, myname); #endif } fh->split_coll_count = 0; return MPI_SUCCESS; }
void ADIOI_NFS_Set_shared_fp(ADIO_File fd, ADIO_Offset offset, int *error_code) { int err; MPI_Comm dupcommself; #ifndef PRINT_ERR_MSG static char myname[] = "ADIOI_NFS_SET_SHARED_FP"; #endif if (fd->shared_fp_fd == ADIO_FILE_NULL) { MPI_Comm_dup(MPI_COMM_SELF, &dupcommself); fd->shared_fp_fd = ADIO_Open(MPI_COMM_SELF, dupcommself, fd->shared_fp_fname, fd->file_system, ADIO_CREATE | ADIO_RDWR | ADIO_DELETE_ON_CLOSE, 0, MPI_BYTE, MPI_BYTE, M_ASYNC, MPI_INFO_NULL, ADIO_PERM_NULL, error_code); } if (*error_code != MPI_SUCCESS) return; ADIOI_WRITE_LOCK(fd->shared_fp_fd, 0, SEEK_SET, sizeof(ADIO_Offset)); lseek(fd->shared_fp_fd->fd_sys, 0, SEEK_SET); err = write(fd->shared_fp_fd->fd_sys, &offset, sizeof(ADIO_Offset)); ADIOI_UNLOCK(fd->shared_fp_fd, 0, SEEK_SET, sizeof(ADIO_Offset)); #ifdef PRINT_ERR_MSG *error_code = (err == -1) ? MPI_ERR_UNKNOWN : MPI_SUCCESS; #else if (err == -1) { *error_code = MPIR_Err_setmsg(MPI_ERR_IO, MPIR_ADIO_ERROR, myname, "I/O Error", "%s", strerror(errno)); ADIOI_Error(fd, *error_code, myname); } else *error_code = MPI_SUCCESS; #endif }
void ADIOI_SCI_IreadContig(ADIO_File fd, void *buf, int count, MPI_Datatype datatype, int file_ptr_type, ADIO_Offset offset, ADIO_Request *request, int *error_code) { int len, typesize; #ifdef NO_AIO ADIO_Status status; #else int err=-1; #ifndef PRINT_ERR_MSG static char myname[] = "ADIOI_SCI_IREADCONTIG"; #endif #endif (*request) = ADIOI_Malloc_request(); (*request)->optype = ADIOI_READ; (*request)->fd = fd; (*request)->datatype = datatype; MPI_Type_size(datatype, &typesize); len = count * typesize; #ifdef NO_AIO /* HP, FreeBSD, Linux */ /* no support for nonblocking I/O. Use blocking I/O. */ ADIOI_SCI_ReadContig(fd, buf, len, MPI_BYTE, file_ptr_type, offset, &status, error_code); (*request)->queued = 0; #ifdef HAVE_STATUS_SET_BYTES if (*error_code == MPI_SUCCESS) { MPI_Get_elements(&status, MPI_BYTE, &len); (*request)->nbytes = len; } #endif #else if (file_ptr_type == ADIO_INDIVIDUAL) offset = fd->fp_ind; err = ADIOI_SCI_aio(fd, buf, len, offset, 0, &((*request)->handle)); if (file_ptr_type == ADIO_INDIVIDUAL) fd->fp_ind += len; (*request)->queued = 1; ADIOI_Add_req_to_list(request); #ifdef PRINT_ERR_MSG *error_code = (err == -1) ? MPI_ERR_UNKNOWN : MPI_SUCCESS; #else if (err == -1) { *error_code = MPIR_Err_setmsg(MPI_ERR_IO, MPIR_ADIO_ERROR, myname, "I/O Error", "%s", strerror(errno)); ADIOI_Error(fd, *error_code, myname); } else *error_code = MPI_SUCCESS; #endif #endif fd->fp_sys_posn = -1; /* set it to null. */ fd->async_count++; }
void ADIOI_HFS_ReadContig(ADIO_File fd, void *buf, int count, MPI_Datatype datatype, int file_ptr_type, ADIO_Offset offset, ADIO_Status *status, int *error_code) { MPI_Count err=-1, datatype_size, len; #ifndef PRINT_ERR_MSG static char myname[] = "ADIOI_HFS_READCONTIG"; #endif MPI_Type_size_x(datatype, &datatype_size); len = datatype_size * count; #ifdef SPPUX fd->fp_sys_posn = -1; /* set it to null, since we are using pread */ if (file_ptr_type == ADIO_EXPLICIT_OFFSET) err = pread64(fd->fd_sys, buf, len, offset); else { /* read from curr. location of ind. file pointer */ err = pread64(fd->fd_sys, buf, len, fd->fp_ind); fd->fp_ind += err; } #endif #ifdef HPUX if (file_ptr_type == ADIO_EXPLICIT_OFFSET) { if (fd->fp_sys_posn != offset) lseek64(fd->fd_sys, offset, SEEK_SET); err = read(fd->fd_sys, buf, len); fd->fp_sys_posn = offset + err; /* individual file pointer not updated */ } else { /* read from curr. location of ind. file pointer */ if (fd->fp_sys_posn != fd->fp_ind) lseek64(fd->fd_sys, fd->fp_ind, SEEK_SET); err = read(fd->fd_sys, buf, len); fd->fp_ind += err; fd->fp_sys_posn = fd->fp_ind; } #endif #ifdef HAVE_STATUS_SET_BYTES if (err != -1) MPIR_Status_set_bytes(status, datatype, err); #endif if (err == -1 ) { #ifdef MPICH *error_code = MPIR_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, myname, __LINE__, MPI_ERR_IO, "**io", "**io %s", strerror(errno)); #elif defined(PRINT_ERR_MSG) *error_code = (err == -1) ? MPI_ERR_UNKNOWN : MPI_SUCCESS; #else /* MPICH-1 */ *error_code = MPIR_Err_setmsg(MPI_ERR_IO, MPIR_ADIO_ERROR, myname, "I/O Error", "%s", strerror(errno)); ADIOI_Error(fd, *error_code, myname); #endif } else *error_code = MPI_SUCCESS; }
void ADIOI_NTFS_WriteContig(ADIO_File fd, void *buf, int count, MPI_Datatype datatype, int file_ptr_type, ADIO_Offset offset, ADIO_Status *status, int *error_code) { //int rank; DWORD dwTemp; DWORD dwNumWritten = 0; int err=-1, datatype_size, len; #ifndef PRINT_ERR_MSG static char myname[] = "ADIOI_NTFS_WRITECONTIG"; #endif MPI_Type_size(datatype, &datatype_size); len = datatype_size * count; if (file_ptr_type == ADIO_EXPLICIT_OFFSET) { if (fd->fp_sys_posn != offset) { dwTemp = DWORDHIGH(offset); SetFilePointer(fd->fd_sys, DWORDLOW(offset), &dwTemp, FILE_BEGIN); } err = WriteFile(fd->fd_sys, buf, len, &dwNumWritten, NULL); //MPI_Comm_rank(MPI_COMM_WORLD, &rank); //printf("[%d]W(%d,%d)\n", rank, DWORDLOW(offset), dwNumWritten); fd->fp_sys_posn = offset + dwNumWritten; /* individual file pointer not updated */ } else { /* write from curr. location of ind. file pointer */ if (fd->fp_sys_posn != fd->fp_ind) { dwTemp = DWORDHIGH(fd->fp_ind); SetFilePointer(fd->fd_sys, DWORDLOW(fd->fp_ind), &dwTemp, FILE_BEGIN); } err = WriteFile(fd->fd_sys, buf, len, &dwNumWritten, NULL); //MPI_Comm_rank(MPI_COMM_WORLD, &rank); //printf("[%d]w(%d,%d)\n", rank, DWORDLOW(offset), dwNumWritten); fd->fp_ind = fd->fp_ind + dwNumWritten; fd->fp_sys_posn = fd->fp_ind; } #ifdef HAVE_STATUS_SET_BYTES if (err != FALSE) MPIR_Status_set_bytes(status, datatype, dwNumWritten); #endif #ifdef PRINT_ERR_MSG *error_code = (err == FALSE) ? MPI_ERR_UNKNOWN : MPI_SUCCESS; #else if (err == FALSE) { *error_code = MPIR_Err_setmsg(MPI_ERR_IO, MPIR_ADIO_ERROR, myname, "I/O Error", "%s", strerror(errno)); ADIOI_Error(fd, *error_code, myname); } else *error_code = MPI_SUCCESS; #endif }
void ADIOI_SFS_Fcntl(ADIO_File fd, int flag, ADIO_Fcntl_t *fcntl_struct, int *error_code) { int i, ntimes, len; ADIO_Offset curr_fsize, alloc_size, size, done; ADIO_Status status; char *buf; #ifndef PRINT_ERR_MSG static char myname[] = "ADIOI_SFS_FCNTL"; #endif switch(flag) { case ADIO_FCNTL_GET_FSIZE: /* On SFS, I find that a write from one process, which changes the file size, does not automatically make the new file size visible to other processes. Therefore, a sync-barrier-sync is needed. (Other processes are able to read the data written though; only file size is returned incorrectly.) */ fsync(fd->fd_sys); MPI_Barrier(fd->comm); fsync(fd->fd_sys); fcntl_struct->fsize = llseek(fd->fd_sys, 0, SEEK_END); if (fd->fp_sys_posn != -1) llseek(fd->fd_sys, fd->fp_sys_posn, SEEK_SET); if (fcntl_struct->fsize == -1) { #ifdef MPICH2 *error_code = MPIR_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, myname, __LINE__, MPI_ERR_IO, "**io", "**io %s", strerror(errno)); #elif defined(PRINT_ERR_MSG) *error_code = MPI_ERR_UNKNOWN; #else /* MPICH-1 */ *error_code = MPIR_Err_setmsg(MPI_ERR_IO, MPIR_ADIO_ERROR, myname, "I/O Error", "%s", strerror(errno)); ADIOI_Error(fd, *error_code, myname); #endif } else *error_code = MPI_SUCCESS; break; case ADIO_FCNTL_SET_DISKSPACE: ADIOI_GEN_Prealloc(fd, fcntl_struct->diskspace, error_code); break; case ADIO_FCNTL_SET_ATOMICITY: fd->atomicity = (fcntl_struct->atomicity == 0) ? 0 : 1; *error_code = MPI_SUCCESS; break; default: FPRINTF(stderr, "Unknown flag passed to ADIOI_SFS_Fcntl\n"); MPI_Abort(MPI_COMM_WORLD, 1); } }
void ADIOI_HFS_Open(ADIO_File fd, int *error_code) { int perm, old_mask, amode; #ifndef PRINT_ERR_MSG static char myname[] = "ADIOI_HFS_OPEN"; #endif 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; fd->fd_sys = open64(fd->filename, amode, perm); fd->fd_direct = -1; if ((fd->fd_sys != -1) && (fd->access_mode & ADIO_APPEND)) { fd->fp_ind = lseek64(fd->fd_sys, 0, SEEK_END); #ifdef HPUX fd->fp_sys_posn = fd->fp_ind; #endif } #ifdef SPPUX fd->fp_sys_posn = -1; /* set it to null bec. we use pread, pwrite*/ #endif if (fd->fd_sys == -1 ) { #ifdef MPICH2 *error_code = MPIR_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, myname, __LINE__, MPI_ERR_IO, "**io", "**io %s", strerror(errno)); #elif defined(PRINT_ERR_MSG) *error_code = MPI_ERR_UNKNOWN; #else /* MPICH-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); #endif } else *error_code = MPI_SUCCESS; }
void ADIOI_NFS_ReadContig(ADIO_File fd, void *buf, int count, MPI_Datatype datatype, int file_ptr_type, ADIO_Offset offset, ADIO_Status *status, int *error_code) { int err=-1, datatype_size, len; #ifndef PRINT_ERR_MSG static char myname[] = "ADIOI_NFS_READCONTIG"; #endif MPI_Type_size(datatype, &datatype_size); len = datatype_size * count; if (file_ptr_type == ADIO_EXPLICIT_OFFSET) { if (fd->fp_sys_posn != offset) lseek(fd->fd_sys, offset, SEEK_SET); if (fd->atomicity) ADIOI_WRITE_LOCK(fd, offset, SEEK_SET, len); else ADIOI_READ_LOCK(fd, offset, SEEK_SET, len); err = read(fd->fd_sys, buf, len); ADIOI_UNLOCK(fd, offset, SEEK_SET, len); fd->fp_sys_posn = offset + err; /* individual file pointer not updated */ } else { /* read from curr. location of ind. file pointer */ offset = fd->fp_ind; if (fd->fp_sys_posn != fd->fp_ind) lseek(fd->fd_sys, fd->fp_ind, SEEK_SET); if (fd->atomicity) ADIOI_WRITE_LOCK(fd, offset, SEEK_SET, len); else ADIOI_READ_LOCK(fd, offset, SEEK_SET, len); err = read(fd->fd_sys, buf, len); ADIOI_UNLOCK(fd, offset, SEEK_SET, len); fd->fp_ind += err; fd->fp_sys_posn = fd->fp_ind; } #ifdef HAVE_STATUS_SET_BYTES if (err != -1) MPIR_Status_set_bytes(status, datatype, err); #endif #ifdef PRINT_ERR_MSG *error_code = (err == -1) ? MPI_ERR_UNKNOWN : MPI_SUCCESS; #else if (err == -1) { *error_code = MPIR_Err_setmsg(MPI_ERR_IO, MPIR_ADIO_ERROR, myname, "I/O Error", "%s", strerror(errno)); ADIOI_Error(fd, *error_code, myname); } else *error_code = MPI_SUCCESS; #endif }
void ADIOI_NTFS_IwriteContig(ADIO_File fd, void *buf, int count, MPI_Datatype datatype,int file_ptr_type, ADIO_Offset offset, ADIO_Request *request, int *error_code) { ADIO_Status status; int err=-1; int len,typesize; DWORD error; #ifndef PRINT_ERR_MSG static char myname[] = "ADIOI_NTFS_IWRITECONTIG"; #endif *request = ADIOI_Malloc_request(); (*request)->optype = ADIOI_WRITE; (*request)->fd = fd; (*request)->datatype = datatype; MPI_Type_size(datatype, &typesize); len = count * typesize; (*request)->nbytes = (*request)->totransfer = len; (*request)->buf = buf; if (file_ptr_type == ADIO_INDIVIDUAL) offset = fd->fp_ind; (*request)->offset = offset; err = ADIOI_NTFS_aio(fd, 1, *request,0,&error); if (file_ptr_type == ADIO_INDIVIDUAL) fd->fp_ind += len; if(error == ERROR_IO_PENDING) { (*request)->queued = 1; ADIOI_Add_req_to_list(request); } else { (*request)->queued = 0; } #ifdef PRINT_ERR_MSG *error_code = (err == -1) ? MPI_ERR_UNKNOWN : MPI_SUCCESS; #else if (err == -1) { *error_code = MPIR_Err_setmsg(MPI_ERR_IO, MPIR_ADIO_ERROR, myname, "I/O Error", "I/O Error: %s", ad_ntfs_error(error)); ADIOI_Error(fd, *error_code, myname); } else *error_code = MPI_SUCCESS; #endif fd->fp_sys_posn = -1; /* set it to null. */ fd->async_count++; }
void ADIOI_PIOFS_WriteContig(ADIO_File fd, void *buf, int count, MPI_Datatype datatype, int file_ptr_type, ADIO_Offset offset, ADIO_Status *status, int *error_code) { MPI_Count err=-1, datatype_size, len; #ifndef PRINT_ERR_MSG static char myname[] = "ADIOI_PIOFS_WRITECONTIG"; #endif MPI_Type_size_x(datatype, &datatype_size); len = datatype_size * count; if (file_ptr_type == ADIO_EXPLICIT_OFFSET) { if (fd->fp_sys_posn != offset) { llseek(fd->fd_sys, offset, SEEK_SET); } err = write(fd->fd_sys, buf, len); fd->fp_sys_posn = offset + err; /* individual file pointer not updated */ } else { /* write from curr. location of ind. file pointer */ if (fd->fp_sys_posn != fd->fp_ind) { llseek(fd->fd_sys, fd->fp_ind, SEEK_SET); } err = write(fd->fd_sys, buf, len); fd->fp_ind += err; fd->fp_sys_posn = fd->fp_ind; } #ifdef HAVE_STATUS_SET_BYTES if (err != -1) MPIR_Status_set_bytes(status, datatype, err); #endif if (err == -1) { #ifdef MPICH *error_code = MPIR_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, myname, __LINE__, MPI_ERR_IO, "**io", "**io %s", strerror(errno)); #elif defined(PRINT_ERR_MSG) *error_code = MPI_ERR_UNKNOWN; #else *error_code = MPIR_Err_setmsg(MPI_ERR_IO, MPIR_ADIO_ERROR, myname, "I/O Error", "%s", strerror(errno)); ADIOI_Error(fd, *error_code, myname); #endif } else *error_code = MPI_SUCCESS; }
void ADIOI_PVFS_Resize(ADIO_File fd, ADIO_Offset size, int *error_code) { int err; #ifndef PRINT_ERR_MSG static char myname[] = "ADIOI_PVFS_RESIZE"; #endif err = pvfs_ftruncate(fd->fd_sys, size); #ifdef PRINT_ERR_MSG *error_code = (err == 0) ? MPI_SUCCESS : MPI_ERR_UNKNOWN; #else if (err == -1) { *error_code = MPIR_Err_setmsg(MPI_ERR_IO, MPIR_ADIO_ERROR, myname, "I/O Error", "%s", strerror(errno)); ADIOI_Error(fd, *error_code, myname); } else *error_code = MPI_SUCCESS; #endif }
void ADIO_Delete(char *filename, int *error_code) { BOOL err; #ifndef PRINT_ERR_MSG static char myname[] = "ADIO_DELETE"; #endif err = DeleteFile(filename); #ifdef PRINT_ERR_MSG *error_code = (err) ? MPI_SUCCESS : MPI_ERR_UNKNOWN; #else if (!err) { *error_code = MPIR_Err_setmsg(MPI_ERR_IO, MPIR_ADIO_ERROR, myname, "I/O Error", "I/O Error: %s", ad_ntfs_error(GetLastError())); ADIOI_Error(MPI_FILE_NULL, *error_code, myname); } else *error_code = MPI_SUCCESS; #endif }
void ADIO_Delete(char *filename, int *error_code) { int err; #ifndef PRINT_ERR_MSG static char myname[] = "ADIO_DELETE"; #endif err = unlink(filename); #ifdef PRINT_ERR_MSG *error_code = (err == 0) ? MPI_SUCCESS : MPI_ERR_UNKNOWN; #else if (err == -1) { *error_code = MPIR_Err_setmsg(MPI_ERR_IO, MPIR_ADIO_ERROR, myname, "I/O Error", "%s", strerror(errno)); ADIOI_Error(MPI_FILE_NULL, *error_code, myname); } else *error_code = MPI_SUCCESS; #endif }
/*@ MPIO_Test - Test the completion of a nonblocking read or write Input Parameters: . request - request object (handle) Output Parameters: . flag - true if operation completed (logical) . status - status object (Status) .N fortran @*/ int MPIO_Test(MPIO_Request *request, int *flag, MPI_Status *status) { int error_code; #ifndef PRINT_ERR_MSG static char myname[] = "MPIO_TEST"; #endif #ifdef MPI_hpux int fl_xmpi; if (*request != MPIO_REQUEST_NULL) { HPMP_IO_WSTART(fl_xmpi, BLKMPIOTEST, TRDTSYSTEM, (*request)->fd); } #endif /* MPI_hpux */ if (*request == MPIO_REQUEST_NULL) return MPI_SUCCESS; if ((*request < (MPIO_Request) 0) || ((*request)->cookie != ADIOI_REQ_COOKIE)) { #ifdef PRINT_ERR_MSG FPRINTF(stderr, "MPIO_Test: Invalid request object\n"); MPI_Abort(MPI_COMM_WORLD, 1); #else error_code = MPIR_Err_setmsg(MPI_ERR_REQUEST, MPIR_ERR_REQUEST_NULL, myname, (char *) 0, (char *) 0); return ADIOI_Error(MPI_FILE_NULL, error_code, myname); #endif } switch ((*request)->optype) { case ADIOI_READ: *flag = ADIO_ReadDone(request, status, &error_code); break; case ADIOI_WRITE: *flag = ADIO_WriteDone(request, status, &error_code); break; } #ifdef MPI_hpux HPMP_IO_WEND(fl_xmpi); #endif /* MPI_hpux */ return error_code; }
void ADIOI_GEN_Flush(ADIO_File fd, int *error_code) { int err; #ifndef PRINT_ERR_MSG static char myname[] = "ADIOI_GEN_FLUSH"; #endif err = fsync(fd->fd_sys); #ifdef PRINT_ERR_MSG *error_code = (err == 0) ? MPI_SUCCESS : MPI_ERR_UNKNOWN; #else if (err == -1) { *error_code = MPIR_Err_setmsg(MPI_ERR_IO, MPIR_ADIO_ERROR, myname, "I/O Error", "%s", strerror(errno)); ADIOI_Error(MPI_FILE_NULL, *error_code, myname); } else *error_code = MPI_SUCCESS; #endif }
void ADIOI_PIOFS_Resize(ADIO_File fd, ADIO_Offset size, int *error_code) { int err; #ifndef PRINT_ERR_MSG static char myname[] = "ADIOI_PIOFS_RESIZE"; #endif err = ftruncate(fd->fd_sys, size); if (err == -1) { #ifdef MPICH2 *error_code = MPIR_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, myname, __LINE__, MPI_ERR_IO, "**io", "**io %s", strerror(errno)); #elif defined(PRINT_ERR_MSG) *error_code = MPI_ERR_UNKNOWN; #else /* MPICH-1 */ *error_code = MPIR_Err_setmsg(MPI_ERR_IO, MPIR_ADIO_ERROR, myname, "I/O Error", "%s", strerror(errno)); ADIOI_Error(fd, *error_code, myname); #endif } else *error_code = MPI_SUCCESS; }
void ADIOI_NFS_Close(ADIO_File fd, int *error_code) { int err; #if defined(MPICH2) || !defined(PRINT_ERR_MSG) static char myname[] = "ADIOI_NFS_CLOSE"; #endif err = close(fd->fd_sys); if (err == -1) { #ifdef MPICH2 *error_code = MPIR_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, myname, __LINE__, MPI_ERR_IO, "**io", "**io %s", strerror(errno)); #elif defined(PRINT_ERR_MSG) *error_code = MPI_ERR_UNKNOWN; #else *error_code = MPIR_Err_setmsg(MPI_ERR_IO, MPIR_ADIO_ERROR, myname, "I/O Error", "%s", strerror(errno)); ADIOI_Error(fd, *error_code, myname); #endif } else *error_code = MPI_SUCCESS; }
void ADIOI_NTFS_IwriteContig(ADIO_File fd, void *buf, int count, MPI_Datatype datatype, int file_ptr_type, ADIO_Offset offset, ADIO_Request *request, int *error_code) { int len, typesize; int err=FALSE; #ifndef PRINT_ERR_MSG static char myname[] = "ADIOI_NTFS_IWRITECONTIG"; #endif *request = ADIOI_Malloc_request(); (*request)->optype = ADIOI_WRITE; (*request)->fd = fd; (*request)->datatype = datatype; MPI_Type_size(datatype, &typesize); len = count * typesize; if (file_ptr_type == ADIO_INDIVIDUAL) offset = fd->fp_ind; err = ADIOI_NTFS_aio(fd, buf, len, offset, 1, &((*request)->handle)); if (file_ptr_type == ADIO_INDIVIDUAL) fd->fp_ind += len; (*request)->queued = 1; ADIOI_Add_req_to_list(request); #ifdef PRINT_ERR_MSG *error_code = (err == FALSE) ? MPI_ERR_UNKNOWN : MPI_SUCCESS; #else if (err == FALSE) { *error_code = MPIR_Err_setmsg(MPI_ERR_IO, MPIR_ADIO_ERROR, myname, "I/O Error", "%s", strerror(errno)); ADIOI_Error(fd, *error_code, myname); } else *error_code = MPI_SUCCESS; #endif fd->fp_sys_posn = -1; /* set it to null. */ fd->async_count++; }
void ADIOI_PIOFS_Fcntl(ADIO_File fd, int flag, ADIO_Fcntl_t *fcntl_struct, int *error_code) { MPI_Datatype copy_etype, copy_filetype; int i, ntimes, err; ADIO_Offset curr_fsize, alloc_size, size, len, done; ADIO_Status status; char *buf; piofs_change_view_t *piofs_change_view; #ifndef PRINT_ERR_MSG static char myname[] = "ADIOI_PIOFS_FCNTL"; #endif switch(flag) { case ADIO_FCNTL_GET_FSIZE: fcntl_struct->fsize = llseek(fd->fd_sys, 0, SEEK_END); if (fd->fp_sys_posn != -1) llseek(fd->fd_sys, fd->fp_sys_posn, SEEK_SET); if (fcntl_struct->fsize == -1) { #ifdef MPICH *error_code = MPIR_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, myname, __LINE__, MPI_ERR_IO, "**io", "**io %s", strerror(errno)); #elif defined(PRINT_ERR_MSG) *error_code = MPI_ERR_UNKNOWN; #else /* MPICH-1 */ *error_code = MPIR_Err_setmsg(MPI_ERR_IO, MPIR_ADIO_ERROR, myname, "I/O Error", "%s", strerror(errno)); ADIOI_Error(fd, *error_code, myname); #endif } else *error_code = MPI_SUCCESS; break; case ADIO_FCNTL_SET_DISKSPACE: ADIOI_GEN_Prealloc(fd, fcntl_struct->diskspace, error_code); break; case ADIO_FCNTL_SET_ATOMICITY: piofs_change_view = (piofs_change_view_t *) ADIOI_Malloc(sizeof(piofs_change_view_t)); piofs_change_view->Vbs = piofs_change_view->Vn = piofs_change_view->Hbs = piofs_change_view->Hn = 1; piofs_change_view->subfile = 0; piofs_change_view->flags = (fcntl_struct->atomicity == 0) ? (ACTIVE | NORMAL) : (ACTIVE | CAUTIOUS); err = piofsioctl(fd->fd_sys, PIOFS_CHANGE_VIEW, piofs_change_view); ADIOI_Free(piofs_change_view); fd->atomicity = (fcntl_struct->atomicity == 0) ? 0 : 1; if (err == -1) { #ifdef MPICH *error_code = MPIR_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, myname, __LINE__, MPI_ERR_IO, "**io", "**io %s", strerror(errno)); #elif defined(PRINT_ERR_MSG) *error_code = MPI_ERR_UNKNOWN; #else /* MPICH-1 */ *error_code = MPIR_Err_setmsg(MPI_ERR_IO, MPIR_ADIO_ERROR, myname, "I/O Error", "%s", strerror(errno)); ADIOI_Error(fd, *error_code, myname); #endif } else *error_code = MPI_SUCCESS; break; default: FPRINTF(stderr, "Unknown flag passed to ADIOI_PIOFS_Fcntl\n"); MPI_Abort(MPI_COMM_WORLD, 1); } }
void ADIOI_PVFS_Fcntl(ADIO_File fd, int flag, ADIO_Fcntl_t *fcntl_struct, int *error_code) { MPI_Datatype copy_etype, copy_filetype; int combiner, i, j, k, filetype_is_contig, ntimes, err; ADIOI_Flatlist_node *flat_file; ADIO_Offset curr_fsize, alloc_size, size, len, done; ADIO_Status status; char *buf; #ifndef PRINT_ERR_MSG static char myname[] = "ADIOI_PVFS_FCNTL"; #endif switch(flag) { case ADIO_FCNTL_SET_VIEW: /* free copies of old etypes and filetypes and delete flattened version of filetype if necessary */ MPI_Type_get_envelope(fd->etype, &i, &j, &k, &combiner); if (combiner != MPI_COMBINER_NAMED) MPI_Type_free(&(fd->etype)); ADIOI_Datatype_iscontig(fd->filetype, &filetype_is_contig); if (!filetype_is_contig) ADIOI_Delete_flattened(fd->filetype); MPI_Type_get_envelope(fd->filetype, &i, &j, &k, &combiner); if (combiner != MPI_COMBINER_NAMED) MPI_Type_free(&(fd->filetype)); /* set new info */ ADIO_SetInfo(fd, fcntl_struct->info, &err); /* set new etypes and filetypes */ MPI_Type_get_envelope(fcntl_struct->etype, &i, &j, &k, &combiner); if (combiner == MPI_COMBINER_NAMED) fd->etype = fcntl_struct->etype; else { MPI_Type_contiguous(1, fcntl_struct->etype, ©_etype); MPI_Type_commit(©_etype); fd->etype = copy_etype; } MPI_Type_get_envelope(fcntl_struct->filetype, &i, &j, &k, &combiner); if (combiner == MPI_COMBINER_NAMED) fd->filetype = fcntl_struct->filetype; else { MPI_Type_contiguous(1, fcntl_struct->filetype, ©_filetype); MPI_Type_commit(©_filetype); fd->filetype = copy_filetype; ADIOI_Flatten_datatype(fd->filetype); /* this function will not flatten the filetype if it turns out to be all contiguous. */ } MPI_Type_size(fd->etype, &(fd->etype_size)); fd->disp = fcntl_struct->disp; /* reset MPI-IO file pointer to point to the first byte that can be accessed in this view. */ ADIOI_Datatype_iscontig(fd->filetype, &filetype_is_contig); if (filetype_is_contig) fd->fp_ind = fcntl_struct->disp; else { flat_file = ADIOI_Flatlist; while (flat_file->type != fd->filetype) flat_file = flat_file->next; for (i=0; i<flat_file->count; i++) { if (flat_file->blocklens[i]) { fd->fp_ind = fcntl_struct->disp + flat_file->indices[i]; break; } } } *error_code = MPI_SUCCESS; break; case ADIO_FCNTL_GET_FSIZE: fcntl_struct->fsize = pvfs_lseek(fd->fd_sys, 0, SEEK_END); if (fd->fp_sys_posn != -1) pvfs_lseek(fd->fd_sys, fd->fp_sys_posn, SEEK_SET); #ifdef PRINT_ERR_MSG *error_code = (fcntl_struct->fsize == -1) ? MPI_ERR_UNKNOWN : MPI_SUCCESS; #else if (fcntl_struct->fsize == -1) { *error_code = MPIR_Err_setmsg(MPI_ERR_IO, MPIR_ADIO_ERROR, myname, "I/O Error", "%s", strerror(errno)); ADIOI_Error(fd, *error_code, myname); } else *error_code = MPI_SUCCESS; #endif break; case ADIO_FCNTL_SET_DISKSPACE: /* will be called by one process only */ /* On file systems with no preallocation function, I have to explicitly write to allocate space. Since there could be holes in the file, I need to read up to the current file size, write it back, and then write beyond that depending on how much preallocation is needed. read/write in sizes of no more than ADIOI_PREALLOC_BUFSZ */ curr_fsize = pvfs_lseek(fd->fd_sys, 0, SEEK_END); alloc_size = fcntl_struct->diskspace; size = ADIOI_MIN(curr_fsize, alloc_size); ntimes = (size + ADIOI_PREALLOC_BUFSZ - 1)/ADIOI_PREALLOC_BUFSZ; buf = (char *) ADIOI_Malloc(ADIOI_PREALLOC_BUFSZ); done = 0; for (i=0; i<ntimes; i++) { len = ADIOI_MIN(size-done, ADIOI_PREALLOC_BUFSZ); ADIO_ReadContig(fd, buf, len, MPI_BYTE, ADIO_EXPLICIT_OFFSET, done, &status, error_code); if (*error_code != MPI_SUCCESS) { #ifdef PRINT_ERR_MSG FPRINTF(stderr, "ADIOI_PVFS_Fcntl: To preallocate disk space, ROMIO needs to read the file and write it back, but is unable to read the file. Please give the file read permission and open it with MPI_MODE_RDWR.\n"); MPI_Abort(MPI_COMM_WORLD, 1); #else *error_code = MPIR_Err_setmsg(MPI_ERR_IO, MPIR_PREALLOC_PERM, myname, (char *) 0, (char *) 0); ADIOI_Error(fd, *error_code, myname); return; #endif } ADIO_WriteContig(fd, buf, len, MPI_BYTE, ADIO_EXPLICIT_OFFSET, done, &status, error_code); if (*error_code != MPI_SUCCESS) return; done += len; } if (alloc_size > curr_fsize) { memset(buf, 0, ADIOI_PREALLOC_BUFSZ); size = alloc_size - curr_fsize; ntimes = (size + ADIOI_PREALLOC_BUFSZ - 1)/ADIOI_PREALLOC_BUFSZ; for (i=0; i<ntimes; i++) { len = ADIOI_MIN(alloc_size-done, ADIOI_PREALLOC_BUFSZ); ADIO_WriteContig(fd, buf, len, MPI_BYTE, ADIO_EXPLICIT_OFFSET, done, &status, error_code); if (*error_code != MPI_SUCCESS) return; done += len; } } ADIOI_Free(buf); if (fd->fp_sys_posn != -1) pvfs_lseek(fd->fd_sys, fd->fp_sys_posn, SEEK_SET); *error_code = MPI_SUCCESS; break; case ADIO_FCNTL_SET_IOMODE: /* for implementing PFS I/O modes. will not occur in MPI-IO implementation.*/ if (fd->iomode != fcntl_struct->iomode) { fd->iomode = fcntl_struct->iomode; MPI_Barrier(MPI_COMM_WORLD); } *error_code = MPI_SUCCESS; break; case ADIO_FCNTL_SET_ATOMICITY: *error_code = MPI_ERR_UNKNOWN; break; default: FPRINTF(stderr, "Unknown flag passed to ADIOI_PVFS_Fcntl\n"); MPI_Abort(MPI_COMM_WORLD, 1); } }
/*@ MPI_File_read_shared - Read using shared file pointer Input Parameters: . fh - file handle (handle) . count - number of elements in buffer (nonnegative integer) . datatype - datatype of each buffer element (handle) Output Parameters: . buf - initial address of buffer (choice) . status - status object (Status) .N fortran @*/ int MPI_File_read_shared(MPI_File fh, void *buf, int count, MPI_Datatype datatype, MPI_Status *status) { int error_code, bufsize, buftype_is_contig, filetype_is_contig; #ifndef PRINT_ERR_MSG static char myname[] = "MPI_FILE_READ_SHARED"; #endif int datatype_size, incr; ADIO_Offset off, shared_fp; #ifdef PRINT_ERR_MSG if ((fh <= (MPI_File) 0) || (fh->cookie != ADIOI_FILE_COOKIE)) { FPRINTF(stderr, "MPI_File_read_shared: Invalid file handle\n"); MPI_Abort(MPI_COMM_WORLD, 1); } #else ADIOI_TEST_FILE_HANDLE(fh, myname); #endif if (count < 0) { #ifdef PRINT_ERR_MSG FPRINTF(stderr, "MPI_File_read_shared: Invalid count argument\n"); MPI_Abort(MPI_COMM_WORLD, 1); #else error_code = MPIR_Err_setmsg(MPI_ERR_ARG, MPIR_ERR_COUNT_ARG, myname, (char *) 0, (char *) 0); return ADIOI_Error(fh, error_code, myname); #endif } if (datatype == MPI_DATATYPE_NULL) { #ifdef PRINT_ERR_MSG FPRINTF(stderr, "MPI_File_read_shared: Invalid datatype\n"); MPI_Abort(MPI_COMM_WORLD, 1); #else error_code = MPIR_Err_setmsg(MPI_ERR_TYPE, MPIR_ERR_TYPE_NULL, myname, (char *) 0, (char *) 0); return ADIOI_Error(fh, error_code, myname); #endif } MPI_Type_size(datatype, &datatype_size); if (count*datatype_size == 0) return MPI_SUCCESS; if ((count*datatype_size) % fh->etype_size != 0) { #ifdef PRINT_ERR_MSG FPRINTF(stderr, "MPI_File_read_shared: Only an integral number of etypes can be accessed\n"); MPI_Abort(MPI_COMM_WORLD, 1); #else error_code = MPIR_Err_setmsg(MPI_ERR_IO, MPIR_ERR_ETYPE_FRACTIONAL, myname, (char *) 0, (char *) 0); return ADIOI_Error(fh, error_code, myname); #endif } if ((fh->file_system == ADIO_PIOFS) || (fh->file_system == ADIO_PVFS)) { #ifdef PRINT_ERR_MSG FPRINTF(stderr, "MPI_File_read_shared: Shared file pointer not supported on PIOFS and PVFS\n"); MPI_Abort(MPI_COMM_WORLD, 1); #else error_code = MPIR_Err_setmsg(MPI_ERR_UNSUPPORTED_OPERATION, MPIR_ERR_NO_SHARED_FP, myname, (char *) 0, (char *) 0); return ADIOI_Error(fh, error_code, myname); #endif } ADIOI_Datatype_iscontig(datatype, &buftype_is_contig); ADIOI_Datatype_iscontig(fh->filetype, &filetype_is_contig); incr = (count*datatype_size)/fh->etype_size; ADIO_Get_shared_fp(fh, incr, &shared_fp, &error_code); if (error_code != MPI_SUCCESS) { FPRINTF(stderr, "MPI_File_read_shared: Error! Could not access shared file pointer.\n"); MPI_Abort(MPI_COMM_WORLD, 1); } /* contiguous or strided? */ if (buftype_is_contig && filetype_is_contig) { /* convert count and shared_fp to bytes */ bufsize = datatype_size * count; off = fh->disp + fh->etype_size * shared_fp; /* if atomic mode requested, lock (exclusive) the region, because there could be a concurrent noncontiguous request. On NFS, locking is done in the ADIO_ReadContig.*/ if ((fh->atomicity) && (fh->file_system != ADIO_NFS)) ADIOI_WRITE_LOCK(fh, off, SEEK_SET, bufsize); ADIO_ReadContig(fh, buf, count, datatype, ADIO_EXPLICIT_OFFSET, off, status, &error_code); if ((fh->atomicity) && (fh->file_system != ADIO_NFS)) ADIOI_UNLOCK(fh, off, SEEK_SET, bufsize); } else ADIO_ReadStrided(fh, buf, count, datatype, ADIO_EXPLICIT_OFFSET, shared_fp, status, &error_code); /* For strided and atomic mode, locking is done in ADIO_ReadStrided */ return error_code; }
/*@ ADIO_ResolveFileType - determines file system type and operations from file name string; this is a collective call Input Parameters: . comm - communicator across which collective open is performed . filename - name of file (string) Output Parameters: . fstype - (pointer to) int holding file system type . ops - (address of) pointer to table of valid file operations . error_code - (pointer to) int holding error code Notes: This code used to be in MPI_File_open(), but it has been moved into here in order to clean things up. The goal is to separate all this "did we compile for this fs type" code from the MPI layer and also to introduce the ADIOI_Fns tables in a reasonable way. -- Rob, 06/06/2001 @*/ void ADIO_ResolveFileType(MPI_Comm comm, char *filename, int *fstype, ADIOI_Fns **ops, int *error_code) { #ifndef PRINT_ERR_MSG static char myname[] = "ADIO_RESOLVEFILETYPE"; #endif int myerrcode, file_system, min_code; char *tmp; file_system = -1; tmp = strchr(filename, ':'); if (!tmp) { /* no prefix; use system-dependent function call to determine type */ ADIO_FileSysType_fncall(filename, &file_system, &myerrcode); if (myerrcode != MPI_SUCCESS) { #ifdef PRINT_ERR_MSG FPRINTF(stderr, "ADIO_ResolveFileType: Can't determine the file-system type. Check the filename/path you provided and try again. Otherwise, prefix the filename with a string to indicate the type of file sytem (piofs:, pfs:, nfs:, ufs:, hfs:, xfs:, sfs:, pvfs:).\n"); MPI_Abort(MPI_COMM_WORLD, 1); #else myerrcode = MPIR_Err_setmsg(MPI_ERR_IO, MPIR_ERR_NO_FSTYPE, myname, (char *) 0, (char *) 0); *error_code = ADIOI_Error(MPI_FILE_NULL, myerrcode, myname); return; #endif } /* ensure that everyone came up with the same file system type */ MPI_Allreduce(&file_system, &min_code, 1, MPI_INT, MPI_MIN, comm); if (min_code == ADIO_NFS) file_system = ADIO_NFS; } else { /* prefix specified; just match via prefix and assume everyone got * the same thing. * * perhaps we should have this code go through the allreduce as well? */ ADIO_FileSysType_prefix(filename, &file_system, &myerrcode); if (myerrcode != MPI_SUCCESS) { #ifdef PRINT_ERR_MSG FPRINTF(stderr, "ADIO_ResolveFileType: Can't determine the file-system type from the specified prefix. Check the filename/path and prefix you provided and try again.\n"); MPI_Abort(MPI_COMM_WORLD, 1); #else myerrcode = MPIR_Err_setmsg(MPI_ERR_IO, MPIR_ERR_NO_FSTYPE, myname, (char *) 0, (char *) 0); *error_code = ADIOI_Error(MPI_FILE_NULL, myerrcode, myname); return; #endif } } /* verify that we support this file system type and set ops pointer */ if (file_system == ADIO_PFS) { #ifndef PFS # ifdef PRINT_ERR_MSG FPRINTF(stderr, "ADIO_ResolveFileType: ROMIO has not been configured to use the PFS file system\n"); MPI_Abort(MPI_COMM_WORLD, 1); # else myerrcode = MPIR_Err_setmsg(MPI_ERR_IO, MPIR_ERR_NO_PFS, myname, (char *) 0, (char *) 0); *error_code = ADIOI_Error(MPI_FILE_NULL, myerrcode, myname); return; # endif #else *ops = &ADIO_PFS_operations; #endif } if (file_system == ADIO_PIOFS) { #ifndef PIOFS # ifdef PRINT_ERR_MSG FPRINTF(stderr, "ADIO_ResolveFileType: ROMIO has not been configured to use the PIOFS file system\n"); MPI_Abort(MPI_COMM_WORLD, 1); # else myerrcode = MPIR_Err_setmsg(MPI_ERR_IO, MPIR_ERR_NO_PIOFS, myname, (char *) 0, (char *) 0); *error_code = ADIOI_Error(MPI_FILE_NULL, myerrcode, myname); return; # endif #else *ops = &ADIO_PIOFS_operations; #endif } if (file_system == ADIO_UFS) { #ifndef UFS # ifdef PRINT_ERR_MSG FPRINTF(stderr, "ADIO_ResolveFileType: ROMIO has not been configured to use the UFS file system\n"); MPI_Abort(MPI_COMM_WORLD, 1); # else myerrcode = MPIR_Err_setmsg(MPI_ERR_IO, MPIR_ERR_NO_UFS, myname, (char *) 0, (char *) 0); *error_code = ADIOI_Error(MPI_FILE_NULL, myerrcode, myname); return; # endif #else *ops = &ADIO_UFS_operations; #endif } if (file_system == ADIO_NFS) { #ifndef NFS # ifdef PRINT_ERR_MSG FPRINTF(stderr, "ADIO_ResolveFileType: ROMIO has not been configured to use the NFS file system\n"); MPI_Abort(MPI_COMM_WORLD, 1); # else myerrcode = MPIR_Err_setmsg(MPI_ERR_IO, MPIR_ERR_NO_NFS, myname, (char *) 0, (char *) 0); *error_code = ADIOI_Error(MPI_FILE_NULL, myerrcode, myname); return; # endif #else *ops = &ADIO_NFS_operations; #endif } if (file_system == ADIO_HFS) { #ifndef HFS # ifdef PRINT_ERR_MSG FPRINTF(stderr, "ADIO_ResolveFileType: ROMIO has not been configured to use the HFS file system\n"); MPI_Abort(MPI_COMM_WORLD, 1); # else myerrcode = MPIR_Err_setmsg(MPI_ERR_IO, MPIR_ERR_NO_HFS, myname, (char *) 0, (char *) 0); *error_code = ADIOI_Error(MPI_FILE_NULL, myerrcode, myname); return; # endif #else *ops = &ADIO_HFS_operations; #endif } if (file_system == ADIO_XFS) { #ifndef XFS # ifdef PRINT_ERR_MSG FPRINTF(stderr, "ADIO_ResolveFileType: ROMIO has not been configured to use the XFS file system\n"); MPI_Abort(MPI_COMM_WORLD, 1); # else myerrcode = MPIR_Err_setmsg(MPI_ERR_IO, MPIR_ERR_NO_XFS, myname, (char *) 0, (char *) 0); *error_code = ADIOI_Error(MPI_FILE_NULL, myerrcode, myname); return; # endif #else *ops = &ADIO_XFS_operations; #endif } if (file_system == ADIO_SFS) { #ifndef SFS # ifdef PRINT_ERR_MSG FPRINTF(stderr, "ADIO_ResolveFileType: ROMIO has not been configured to use the SFS file system\n"); MPI_Abort(MPI_COMM_WORLD, 1); # else myerrcode = MPIR_Err_setmsg(MPI_ERR_IO, MPIR_ERR_NO_SFS, myname, (char *) 0, (char *) 0); *error_code = ADIOI_Error(MPI_FILE_NULL, myerrcode, myname); return; # endif #else *ops = &ADIO_SFS_operations; #endif } if (file_system == ADIO_PVFS) { #ifndef ROMIO_PVFS # ifdef PRINT_ERR_MSG FPRINTF(stderr, "ADIO_ResolveFileType: ROMIO has not been configured to use the PVFS file system\n"); MPI_Abort(MPI_COMM_WORLD, 1); # else myerrcode = MPIR_Err_setmsg(MPI_ERR_IO, MPIR_ERR_NO_PVFS, myname, (char *) 0, (char *) 0); *error_code = ADIOI_Error(MPI_FILE_NULL, myerrcode, myname); return; # endif #else *ops = &ADIO_PVFS_operations; #endif } if (file_system == ADIO_NTFS) { #ifndef ROMIO_NTFS # ifdef PRINT_ERR_MSG FPRINTF(stderr, "ADIO_ResolveFileType: ROMIO has not been configured to use the NTFS file system\n"); MPI_Abort(MPI_COMM_WORLD, 1); # else myerrcode = MPIR_Err_setmsg(MPI_ERR_IO, MPIR_ERR_NO_NTFS, myname, (char *) 0, (char *) 0); *error_code = ADIOI_Error(MPI_FILE_NULL, myerrcode, myname); return; # endif #else *ops = &ADIO_NTFS_operations; #endif } if (file_system == ADIO_TESTFS) { #ifndef ROMIO_TESTFS # ifdef PRINT_ERR_MSG FPRINTF(stderr, "ADIO_ResolveFileType: ROMIO has not been configured to use the TESTFS file system\n"); MPI_Abort(MPI_COMM_WORLD, 1); # else myerrcode = MPIR_Err_setmsg(MPI_ERR_IO, MPIR_ERR_NO_TESTFS, myname, (char *) 0, (char *) 0); *error_code = ADIOI_Error(MPI_FILE_NULL, myerrcode, myname); return; # endif #else *ops = &ADIO_TESTFS_operations; #endif } *error_code = MPI_SUCCESS; *fstype = file_system; return; }
/*@ MPI_File_write_all_begin - Begin a split collective write using individual file pointer Input Parameters: . fh - file handle (handle) . buf - initial address of buffer (choice) . count - number of elements in buffer (nonnegative integer) . datatype - datatype of each buffer element (handle) .N fortran @*/ int MPI_File_write_all_begin(MPI_File fh, void *buf, int count, MPI_Datatype datatype) { int error_code, datatype_size; MPI_Status status; #ifndef PRINT_ERR_MSG static char myname[] = "MPI_FILE_WRITE_ALL_BEGIN"; #endif #ifdef PRINT_ERR_MSG if ((fh <= (MPI_File) 0) || (fh->cookie != ADIOI_FILE_COOKIE)) { FPRINTF(stderr, "MPI_File_write_all_begin: Invalid file handle\n"); MPI_Abort(MPI_COMM_WORLD, 1); } #else ADIOI_TEST_FILE_HANDLE(fh, myname); #endif if (count < 0) { #ifdef PRINT_ERR_MSG FPRINTF(stderr, "MPI_File_write_all_begin: Invalid count argument\n"); MPI_Abort(MPI_COMM_WORLD, 1); #else error_code = MPIR_Err_setmsg(MPI_ERR_ARG, MPIR_ERR_COUNT_ARG, myname, (char *) 0, (char *) 0); return ADIOI_Error(fh, error_code, myname); #endif } if (datatype == MPI_DATATYPE_NULL) { #ifdef PRINT_ERR_MSG FPRINTF(stderr, "MPI_File_write_all_begin: Invalid datatype\n"); MPI_Abort(MPI_COMM_WORLD, 1); #else error_code = MPIR_Err_setmsg(MPI_ERR_TYPE, MPIR_ERR_TYPE_NULL, myname, (char *) 0, (char *) 0); return ADIOI_Error(fh, error_code, myname); #endif } if (fh->access_mode & MPI_MODE_SEQUENTIAL) { #ifdef PRINT_ERR_MSG FPRINTF(stderr, "MPI_File_write_all_begin: Can't use this function because file was opened with MPI_MODE_SEQUENTIAL\n"); MPI_Abort(MPI_COMM_WORLD, 1); #else error_code = MPIR_Err_setmsg(MPI_ERR_UNSUPPORTED_OPERATION, MPIR_ERR_AMODE_SEQ, myname, (char *) 0, (char *) 0); return ADIOI_Error(fh, error_code, myname); #endif } if (fh->split_coll_count) { #ifdef PRINT_ERR_MSG FPRINTF(stderr, "MPI_File_write_all_begin: Only one active split collective I/O operation allowed per file handle\n"); MPI_Abort(MPI_COMM_WORLD, 1); #else error_code = MPIR_Err_setmsg(MPI_ERR_IO, MPIR_ERR_MULTIPLE_SPLIT_COLL, myname, (char *) 0, (char *) 0); return ADIOI_Error(fh, error_code, myname); #endif } fh->split_coll_count = 1; MPI_Type_size(datatype, &datatype_size); if ((count*datatype_size) % fh->etype_size != 0) { #ifdef PRINT_ERR_MSG FPRINTF(stderr, "MPI_File_write_all_begin: Only an integral number of etypes can be accessed\n"); MPI_Abort(MPI_COMM_WORLD, 1); #else error_code = MPIR_Err_setmsg(MPI_ERR_IO, MPIR_ERR_ETYPE_FRACTIONAL, myname, (char *) 0, (char *) 0); return ADIOI_Error(fh, error_code, myname); #endif } ADIO_WriteStridedColl(fh, buf, count, datatype, ADIO_INDIVIDUAL, 0, &status, &error_code); return error_code; }
void ADIOI_XFS_ReadComplete(ADIO_Request *request, ADIO_Status *status, int *error_code) { int err; #ifndef PRINT_ERR_MSG static char myname[] = "ADIOI_XFS_READCOMPLETE"; #endif if (*request == ADIO_REQUEST_NULL) { *error_code = MPI_SUCCESS; return; } if ((*request)->queued) { do { err = aio_suspend64((const aiocb64_t **) &((*request)->handle), 1, 0); } while ((err == -1) && (errno == EINTR)); if (err != -1) { err = aio_return64((aiocb64_t *) (*request)->handle); (*request)->nbytes = err; errno = aio_error64((aiocb64_t *) (*request)->handle); } else (*request)->nbytes = -1; #ifdef PRINT_ERR_MSG *error_code = (err == -1) ? MPI_ERR_UNKNOWN : MPI_SUCCESS; #else if (err == -1) { *error_code = MPIR_Err_setmsg(MPI_ERR_IO, MPIR_ADIO_ERROR, myname, "I/O Error", "%s", strerror(errno)); ADIOI_Error((*request)->fd, *error_code, myname); } else *error_code = MPI_SUCCESS; #endif } else *error_code = MPI_SUCCESS; #ifdef HAVE_STATUS_SET_BYTES if ((*request)->nbytes != -1) MPIR_Status_set_bytes(status, (*request)->datatype, (*request)->nbytes); #endif if ((*request)->queued != -1) { /* queued = -1 is an internal hack used when the request must be completed, but the request object should not be freed. This is used in ADIOI_Complete_async, because the user will call MPI_Wait later, which would require status to be filled. Ugly but works. queued = -1 should be used only in ADIOI_Complete_async. This should not affect the user in any way. */ /* if request is still queued in the system, it is also there on ADIOI_Async_list. Delete it from there. */ if ((*request)->queued) ADIOI_Del_req_from_list(request); (*request)->fd->async_count--; if ((*request)->handle) ADIOI_Free((*request)->handle); ADIOI_Free_request((ADIOI_Req_node *) (*request)); *request = ADIO_REQUEST_NULL; } }
void ADIOI_PIOFS_Open(ADIO_File fd, int *error_code) { int amode, perm, old_mask, err; piofs_fstat_t piofs_fstat; char *value; #ifndef PRINT_ERR_MSG static char myname[] = "ADIOI_PIOFS_OPEN"; #endif 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; #ifdef PROFILE MPE_Log_event(1, 0, "start open"); #endif fd->fd_sys = open(fd->filename, amode, perm); #ifdef PROFILE MPE_Log_event(2, 0, "end open"); #endif llseek(fd->fd_sys, 0, SEEK_SET); /* required to initiate use of 64-bit offset */ if (fd->fd_sys != -1) { value = (char *) ADIOI_Malloc((MPI_MAX_INFO_VAL+1)*sizeof(char)); /* get file striping information and set it in info */ err = piofsioctl(fd->fd_sys, PIOFS_FSTAT, &piofs_fstat); if (!err) { sprintf(value, "%d", piofs_fstat.st_bsu); MPI_Info_set(fd->info, "striping_unit", value); sprintf(value, "%d", piofs_fstat.st_cells); MPI_Info_set(fd->info, "striping_factor", value); sprintf(value, "%d", piofs_fstat.st_base_node); MPI_Info_set(fd->info, "start_iodevice", value); } ADIOI_Free(value); if (fd->access_mode & ADIO_APPEND) fd->fp_ind = fd->fp_sys_posn = llseek(fd->fd_sys, 0, SEEK_END); } #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 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, 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; #ifndef PRINT_ERR_MSG static char myname[] = "ADIOI_NFS_WRITESTRIDED"; #endif ADIOI_Datatype_iscontig(datatype, &buftype_is_contig); ADIOI_Datatype_iscontig(fd->filetype, &filetype_is_contig); MPI_Type_size(fd->filetype, &filetype_size); 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; #ifdef PRINT_ERR_MSG *error_code = (err_flag) ? MPI_ERR_UNKNOWN : MPI_SUCCESS; #else if (err_flag) { *error_code = MPIR_Err_setmsg(MPI_ERR_IO, MPIR_ADIO_ERROR, myname, "I/O Error", "%s", strerror(errno)); ADIOI_Error(fd, *error_code, myname); } else *error_code = MPI_SUCCESS; #endif } 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) { FPRINTF(stderr, "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.\n"); MPI_Abort(MPI_COMM_WORLD, 1); } 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 {