void ADIOI_XFS_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, aio_errno = 0;
static char myname[] = "ADIOI_XFS_IREADCONTIG";
(*request) = ADIOI_Malloc_request();
(*request)->optype = ADIOI_READ;
(*request)->fd = fd;
(*request)->datatype = datatype;
MPI_Type_size(datatype, &typesize);
len = count * typesize;
if (file_ptr_type == ADIO_INDIVIDUAL) offset = fd->fp_ind;
aio_errno = ADIOI_XFS_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);
fd->fp_sys_posn = -1;
/* --BEGIN ERROR HANDLING-- */
if (aio_errno != 0) {
MPIO_ERR_CREATE_CODE_ERRNO(myname, aio_errno, error_code);
return;
}
/* --END ERROR HANDLING-- */
*error_code = MPI_SUCCESS;
fd->async_count++;
}
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_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_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_SVM_IreadContig(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, datatype_size;
MPI_Type_size(datatype, &datatype_size);
len = datatype_size * count;
(*request) = ADIOI_Malloc_request();
(*request)->optype = ADIOI_READ;
(*request)->fd = fd;
(*request)->next = ADIO_REQUEST_NULL;
#if 1
/* bugs in ADIOI_SVM_aio */
/* => use blocking version */
ADIOI_SVM_ReadContig(fd, buf, count, datatype, file_ptr_type, offset, &status,
error_code);
(*request)->queued = 0;
#else
/* MPI isn't thread-safe, but nonblocking versions use MPI-Routines... */
if ((fd->iomode == M_ASYNC) || (fd->iomode == M_UNIX)) {
if (file_ptr_type == ADIO_INDIVIDUAL) offset = fd->fp_ind;
err = ADIOI_SVM_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);
/* added by RAY */
if (err <= 0) {
/* => error */
printf("ADIOI_SVM_IwriteContig(): Error in aio.\n");
}
else {
/* => succesful */
/* create new entry in thread-list */
ADIOI_SVM_STRUCT_Create_thread((pthread_t *) &err,request);
/*printf("Created new thread: %x\n",err);*/
}
/* end RAY */
*error_code = (err == -1) ? MPI_ERR_UNKNOWN : MPI_SUCCESS;
/* added by RAY - 03.01.2000 */
#endif
fd->fp_sys_posn = -1; /* set it to null. */
fd->async_count++;
/* status info. must be linked to the request structure, so that it
can be accessed later from a wait */
}
void ADIOI_PFS_IwriteContig(ADIO_File fd, void *buf, int count,
MPI_Datatype datatype, int file_ptr_type,
ADIO_Offset offset, ADIO_Request *request, int *error_code)
{
long *id_sys;
ADIO_Offset off;
int len, typesize, err;
static char myname[] = "ADIOI_PFS_IWRITECONTIG";
*request = ADIOI_Malloc_request();
(*request)->optype = ADIOI_WRITE;
(*request)->fd = fd;
(*request)->datatype = datatype;
MPI_Type_size(datatype, &typesize);
len = count * typesize;
id_sys = (long *) ADIOI_Malloc(sizeof(long));
(*request)->handle = (void *) id_sys;
off = (file_ptr_type == ADIO_INDIVIDUAL) ? fd->fp_ind : offset;
lseek(fd->fd_sys, off, SEEK_SET);
*id_sys = _iwrite(fd->fd_sys, buf, len);
if ((*id_sys == -1) && (errno == EQNOMID)) {
/* the man pages say EMREQUEST, but in reality errno is set to EQNOMID! */
/* exceeded the max. no. of outstanding requests. */
/* complete all previous async. requests */
ADIOI_Complete_async(error_code);
if (error_code != MPI_SUCCESS) return;
/* try again */
*id_sys = _iwrite(fd->fd_sys, buf, len);
if ((*id_sys == -1) && (errno == EQNOMID)) {
*error_code = MPIO_Err_create_code(MPI_SUCCESS,
MPIR_ERR_RECOVERABLE, myname,
__LINE__, MPI_ERR_IO, "**io",
"**io %s", strerror(errno));
return;
}
}
else if (*id_sys == -1) {
*error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE,
myname, __LINE__, MPI_ERR_IO,
"**io",
"**io %s", strerror(errno));
return;
}
if (file_ptr_type == ADIO_INDIVIDUAL) fd->fp_ind += len;
(*request)->queued = 1;
(*request)->nbytes = len;
ADIOI_Add_req_to_list(request);
fd->async_count++;
fd->fp_sys_posn = -1; /* set it to null. */
if (*id_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_PFS_IwriteContig(ADIO_File fd, void *buf, int count,
MPI_Datatype datatype, int file_ptr_type,
ADIO_Offset offset, ADIO_Request *request, int *error_code)
{
long *id_sys;
ADIO_Offset off;
int len, typesize, err;
#ifndef PRINT_ERR_MSG
static char myname[] = "ADIOI_PFS_IWRITECONTIG";
#endif
*request = ADIOI_Malloc_request();
(*request)->optype = ADIOI_WRITE;
(*request)->fd = fd;
(*request)->datatype = datatype;
MPI_Type_size(datatype, &typesize);
len = count * typesize;
id_sys = (long *) ADIOI_Malloc(sizeof(long));
(*request)->handle = (void *) id_sys;
off = (file_ptr_type == ADIO_INDIVIDUAL) ? fd->fp_ind : offset;
lseek(fd->fd_sys, off, SEEK_SET);
*id_sys = _iwrite(fd->fd_sys, buf, len);
if ((*id_sys == -1) && (errno == EQNOMID)) {
/* the man pages say EMREQUEST, but in reality errno is set to EQNOMID! */
/* exceeded the max. no. of outstanding requests. */
/* complete all previous async. requests */
ADIOI_Complete_async(&err);
/* try again */
*id_sys = _iwrite(fd->fd_sys, buf, len);
if ((*id_sys == -1) && (errno == EQNOMID)) {
#ifdef PRINT_ERR_MSG
FPRINTF(stderr, "Error in asynchronous I/O\n");
MPI_Abort(MPI_COMM_WORLD, 1);
#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);
return;
#endif
}
}
else if (*id_sys == -1) {
#ifdef PRINT_ERR_MSG
FPRINTF(stderr, "Unknown errno %d in ADIOI_PFS_IwriteContig\n", errno);
MPI_Abort(MPI_COMM_WORLD, 1);
#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);
return;
#endif
}
if (file_ptr_type == ADIO_INDIVIDUAL) fd->fp_ind += len;
(*request)->queued = 1;
(*request)->nbytes = len;
ADIOI_Add_req_to_list(request);
fd->async_count++;
fd->fp_sys_posn = -1; /* set it to null. */
#ifdef PRINT_ERR_MSG
*error_code = (*id_sys == -1) ? MPI_ERR_UNKNOWN : MPI_SUCCESS;
#else
if (*id_sys == -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_UFS_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;
#ifdef NO_AIO
ADIO_Status status;
#else
int err=-1;
#if defined(MPICH2) || !defined(PRINT_ERR_MSG)
static char myname[] = "ADIOI_UFS_IWRITECONTIG";
#endif
#endif
*request = ADIOI_Malloc_request();
(*request)->optype = ADIOI_WRITE;
(*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_UFS_WriteContig(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_UFS_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);
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));
return;
#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;
#endif /* NO_AIO */
fd->fp_sys_posn = -1; /* set it to null. */
fd->async_count++;
}
