/* write 'count' bytes from 'buffer' into (unix or pvfs2) file 'dest' */ size_t generic_write(file_object *dest, char *buffer, int64_t offset, size_t count, PVFS_credentials *credentials) { PVFS_Request mem_req, file_req; PVFS_sysresp_io resp_io; int ret; if (dest->fs_type == UNIX_FILE) return(write(dest->u.ufs.fd, buffer, count)); else { file_req = PVFS_BYTE; ret = PVFS_Request_contiguous(count, PVFS_BYTE, &mem_req); if (ret < 0) { PVFS_perror("PVFS_Request_contiguous", ret); return(ret); } ret = PVFS_sys_write(dest->u.pvfs2.ref, file_req, offset, buffer, mem_req, credentials, &resp_io, hints); if (ret == 0) { PVFS_Request_free(&mem_req); return(resp_io.total_completed); } else PVFS_perror("PVFS_sys_write", ret); } return ret; }
/** * PVFSIOSHandle::Pwrite. positional write wrapper. * * @param buf the buffer to write from * @param count the number of bytes to write * @param offset the offset to write from * @param bytes_written return bytes that have been written(0, size count) * @return PLFS_SUCCESS or PLFS_E* */ plfs_error_t PVFSIOSHandle::Pwrite(const void* buf, size_t count, off_t offset, ssize_t *bytes_written) { PVFS_Request mem_req, file_req; PVFS_sysresp_io resp_io; int pev; file_req = PVFS_BYTE; /* reading bytes from the file ... */ /* ... into a contig buffer of size count */ pev = PVFS_Request_contiguous(count, PVFS_BYTE, &mem_req); if (pev < 0) { return errno_to_plfs_error(-get_err(pev)); } pev = PVFS_sys_write(this->ref, file_req, offset, (void*)buf, mem_req, &this->creds, &resp_io); PVFS_Request_free(&mem_req); /* XXX: see comment in Pread */ if (pev < 0) { /* XXX: don't need to free mem_req in this case? */ return errno_to_plfs_error(-get_err(pev)); } *bytes_written = resp_io.total_completed; return PLFS_SUCCESS; }
/* Preconditions: none * Parameters: testcase - the test case that is checked for this function * Postconditions: returns error code of readdir * Has 2 test cases */ static int test_write(void) { PVFS_credentials credentials; PVFS_sysresp_lookup resp_lk; PVFS_Request req_io; PVFS_sysresp_io resp_io; char *filename; char io_buffer[100]; int fs_id, ret; filename = (char *) malloc(sizeof(char) * 100); filename = strcpy(filename, "name"); memset(&req_io, 0, sizeof(PVFS_Request)); memset(&resp_io, 0, sizeof(PVFS_sysresp_io)); PVFS_util_gen_credentials(&credentials); memset(&resp_lk, 0, sizeof(PVFS_sysresp_lookup)); fs_id = 9; ret = PVFS_sys_lookup(fs_id, filename, &credentials, &resp_lk, PVFS2_LOOKUP_LINK_NO_FOLLOW); if (ret < 0) { debug_printf("test_pvfs_datatype_hvector: lookup failed " "on %s\n", filename); } ret = PVFS_sys_write(resp_lk.ref, req_io, 0, io_buffer, NULL, &credentials, &resp_io); return ret; }
static int test_write_beyond(void){ PVFS_sysresp_lookup resp_lk; PVFS_Request req_io; PVFS_Request req_mem; PVFS_sysresp_io resp_io; PVFS_credentials credentials; char *filename; char *io_buffer; int fs_id, ret, i; PVFS_size oldsize; PVFS_sysresp_getattr resp; PVFS_offset file_req_offset = 0; uint32_t attrmask; attrmask = PVFS_ATTR_SYS_ALL_NOSIZE; filename = (char *) malloc(sizeof(char) * 100); filename = strcpy(filename, "name"); memset(&req_io, 0, sizeof(PVFS_Request)); memset(&req_mem, 0, sizeof(PVFS_Request)); memset(&resp_io, 0, sizeof(PVFS_sysresp_io)); memset(&resp_lk, 0, sizeof(PVFS_sysresp_lookup)); PVFS_util_gen_credentials(&credentials); if (initialize_sysint() < 0) { debug_printf("UNABLE TO INIT THE SYSTEM INTERFACE\n"); return -1; } fs_id = pvfs_helper.fs_id; ret = PVFS_sys_lookup(fs_id, filename, &credentials, &resp_lk, PVFS2_LOOKUP_LINK_NO_FOLLOW); if (ret < 0) { debug_printf("test_pvfs_datatype_hvector: lookup failed " "on %s\n", filename); } if((ret = PVFS_sys_getattr(resp_lk.ref, attrmask, &credentials, &resp)) < 0) return ret; io_buffer = malloc(sizeof(char)*(size_t)resp.attr.size+100); /* req_io.size = resp_io.size + 100; */ oldsize = resp.attr.size +100; for(i = 0; i < oldsize; i++) { io_buffer[i] = 'a'; } ret = PVFS_sys_write(resp_lk.ref, req_io, file_req_offset, io_buffer, req_mem, &credentials, &resp_io); if(ret < 0){ debug_printf("write failed on %s\n", filename); } /* finalize_sysint(); */ return ret; }
static int test_io_on_dir(int testcase) { int fs_id, ret,i; PVFS_credentials credentials; PVFS_sysresp_lookup resp_lookup; PVFS_Request req_io; PVFS_Request req_mem; PVFS_sysresp_io resp_io; PVFS_offset file_req_offset = 0; char *name; char io_buffer[100]; ret = -2; name = (char *) malloc(sizeof(char) * 100); name = strcpy(name, "/"); if (initialize_sysint() < 0) { debug_printf("ERROR UNABLE TO INIT SYSTEM INTERFACE\n"); return -1; } fs_id = pvfs_helper.fs_id; PVFS_util_gen_credentials(&credentials); if((ret = PVFS_sys_lookup( fs_id, name, &credentials, &resp_lookup, PVFS2_LOOKUP_LINK_NO_FOLLOW)) < 0) { fprintf(stderr,"lookup failed\n"); return ret; } memset(&req_io, 0, sizeof(req_io)); memset(&req_mem, 0, sizeof(req_mem)); switch(testcase) { case 0: ret = PVFS_sys_read(resp_lookup.ref, req_io, file_req_offset, io_buffer, req_mem, &credentials, &resp_io); break; case 1: for(i = 0; i < 100; i++) { io_buffer[i] = 'a'; } ret = PVFS_sys_write(resp_lookup.ref, req_io, file_req_offset, io_buffer, req_mem, &credentials, &resp_io); break; } /* finalize_sysint(); */ return ret; }
int ADIOI_PVFS2_StridedDtypeIO(ADIO_File fd, void *buf, int count, MPI_Datatype datatype, int file_ptr_type, ADIO_Offset offset, ADIO_Status *status, int *error_code, int rw_type) { int ret = -1, filetype_is_contig = -1; MPI_Count filetype_size = -1; int num_filetypes = 0, cur_flat_file_reg_off = 0; PVFS_Request tmp_mem_req, mem_req, tmp_file_req, file_req; PVFS_sysresp_io resp_io; ADIO_Offset off = -1, bytes_into_filetype = 0; MPI_Aint filetype_extent = -1; int i = -1; MPI_Count etype_size; PVFS_size pvfs_disp = -1; ADIOI_Flatlist_node *flat_file_p = ADIOI_Flatlist; /* Use for offseting the PVFS2 filetype */ int pvfs_blk = 1; ADIOI_PVFS2_fs *pvfs_fs; static char myname[] = "ADIOI_PVFS2_STRIDED_DTYPE"; memset(&tmp_mem_req, 0, sizeof(PVFS_Request)); memset(&mem_req, 0, sizeof(PVFS_Request)); memset(&tmp_file_req, 0, sizeof(PVFS_Request)); memset(&file_req, 0, sizeof(PVFS_Request)); pvfs_fs = (ADIOI_PVFS2_fs*)fd->fs_ptr; ADIOI_Datatype_iscontig(fd->filetype, &filetype_is_contig); /* changed below if error */ *error_code = MPI_SUCCESS; /* datatype is the memory type * fd->filetype is the file type */ MPI_Type_size_x(fd->filetype, &filetype_size); if (filetype_size == 0) { *error_code = MPI_SUCCESS; return -1; } MPI_Type_extent(fd->filetype, &filetype_extent); MPI_Type_size_x(fd->etype, &etype_size); if (filetype_size == 0) { *error_code = MPI_SUCCESS; return -1; } /* offset is in units of etype relative to the filetype. We * convert this to off in terms of actual data bytes (the offset * minus the number of bytes that are not used). We are allowed * to do this since PVFS2 handles offsets with respect to a * file_req in bytes, otherwise we would have to convert into a * pure byte offset as is done in other methods. Explicit offset * case is handled by using fd->disp and byte-converted off. */ pvfs_disp = fd->disp; if (file_ptr_type == ADIO_INDIVIDUAL) { if (filetype_is_contig) { off = fd->fp_ind - fd->disp; } else { int flag = 0; /* Should have already been flattened in ADIO_Open*/ while (flat_file_p->type != fd->filetype) { flat_file_p = flat_file_p->next; } num_filetypes = -1; while (!flag) { num_filetypes++; for (i = 0; i < flat_file_p->count; i++) { /* Start on a non zero-length region */ if (flat_file_p->blocklens[i]) { if (fd->disp + flat_file_p->indices[i] + (num_filetypes * filetype_extent) + flat_file_p->blocklens[i] > fd->fp_ind && fd->disp + flat_file_p->indices[i] <= fd->fp_ind) { cur_flat_file_reg_off = fd->fp_ind - (fd->disp + flat_file_p->indices[i] + (num_filetypes * filetype_extent)); flag = 1; break; } else bytes_into_filetype += flat_file_p->blocklens[i]; } } } /* Impossible that we don't find it in this datatype */ assert(i != flat_file_p->count); off = bytes_into_filetype + cur_flat_file_reg_off; } } else /* ADIO_EXPLICIT */ { off = etype_size * offset; } #ifdef DEBUG_DTYPE fprintf(stderr, "ADIOI_PVFS2_StridedDtypeIO: (fd->fp_ind=%Ld,fd->disp=%Ld," " offset=%Ld),(pvfs_disp=%Ld,off=%Ld)\n", fd->fp_ind, fd->disp, offset, pvfs_disp, off); #endif /* Convert the MPI memory and file datatypes into * PVFS2 datatypes */ ret = convert_mpi_pvfs2_dtype(&datatype, &tmp_mem_req); if (ret < 0) { goto error_state; } ret = convert_mpi_pvfs2_dtype(&(fd->filetype), &tmp_file_req); if (ret < 0) { goto error_state; } ret = PVFS_Request_contiguous(count, tmp_mem_req, &mem_req); if (ret != 0) /* TODO: convert this to MPIO error handling */ fprintf(stderr, "ADIOI_PVFS2_stridedDtypeIO: error in final" " CONTIG memory type\n"); PVFS_Request_free(&tmp_mem_req); /* pvfs_disp is used to offset the filetype */ ret = PVFS_Request_hindexed(1, &pvfs_blk, &pvfs_disp, tmp_file_req, &file_req); if (ret != 0) fprintf(stderr, "ADIOI_PVFS2_StridedDtypeIO: error in final" " HINDEXED file type\n"); PVFS_Request_free(&tmp_file_req); if (rw_type == READ) ret = PVFS_sys_read(pvfs_fs->object_ref, file_req, off, buf, mem_req, &(pvfs_fs->credentials), &resp_io); else ret = PVFS_sys_write(pvfs_fs->object_ref, file_req, off, buf, mem_req, &(pvfs_fs->credentials), &resp_io); if (ret != 0) { fprintf(stderr, "ADIOI_PVFS2_StridedDtypeIO: Warning - PVFS_sys_" "read/write returned %d and completed %Ld bytes.\n", ret, (long long)resp_io.total_completed); *error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, myname, __LINE__, ADIOI_PVFS2_error_convert(ret), "Error in PVFS_sys_io \n", 0); goto error_state; } if (file_ptr_type == ADIO_INDIVIDUAL) { fd->fp_ind = off += resp_io.total_completed; } error_state: fd->fp_sys_posn = -1; /* set it to null. */ PVFS_Request_free(&mem_req); PVFS_Request_free(&file_req); #ifdef DEBUG_DTYPE fprintf(stderr, "ADIOI_PVFS2_StridedDtypeIO: " "resp_io.total_completed=%Ld,ret=%d\n", resp_io.total_completed, ret); #endif #ifdef HAVE_STATUS_SET_BYTES MPIR_Status_set_bytes(status, datatype, resp_io.total_completed); /* This is a temporary way of filling in status. The right way is to * keep track of how much data was actually acccessed by * ADIOI_BUFFERED operations */ #endif return ret; }
void ADIOI_PVFS2_WriteContig(ADIO_File fd, const void *buf, int count, MPI_Datatype datatype, int file_ptr_type, ADIO_Offset offset, ADIO_Status * status, int *error_code) { int ret; MPI_Count datatype_size, len; PVFS_Request file_req, mem_req; PVFS_sysresp_io resp_io; ADIOI_PVFS2_fs *pvfs_fs; static char myname[] = "ADIOI_PVFS2_WRITECONTIG"; pvfs_fs = (ADIOI_PVFS2_fs *) fd->fs_ptr; MPI_Type_size_x(datatype, &datatype_size); len = datatype_size * count; ret = PVFS_Request_contiguous(len, PVFS_BYTE, &mem_req); /* --BEGIN ERROR HANDLING-- */ if (ret != 0) { *error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, myname, __LINE__, ADIOI_PVFS2_error_convert(ret), "Error in PVFS_Request_contiguous (memory)", 0); return; } /* --END ERROR HANDLING-- */ ret = PVFS_Request_contiguous(len, PVFS_BYTE, &file_req); /* --BEGIN ERROR HANDLING-- */ if (ret != 0) { *error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, myname, __LINE__, ADIOI_PVFS2_error_convert(ret), "Error in PVFS_Request_contiguous (file)", 0); return; } /* --END ERROR HANDLING-- */ if (file_ptr_type == ADIO_EXPLICIT_OFFSET) { #ifdef ADIOI_MPE_LOGGING MPE_Log_event(ADIOI_MPE_write_a, 0, NULL); #endif ret = PVFS_sys_write(pvfs_fs->object_ref, file_req, offset, (void *) buf, mem_req, &(pvfs_fs->credentials), &resp_io); #ifdef ADIOI_MPE_LOGGING MPE_Log_event(ADIOI_MPE_write_b, 0, NULL); #endif /* --BEGIN ERROR HANDLING-- */ if (ret != 0) { *error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, myname, __LINE__, ADIOI_PVFS2_error_convert(ret), "Error in PVFS_sys_write", 0); goto fn_exit; } /* --END ERROR HANDLING-- */ fd->fp_sys_posn = offset + (int) resp_io.total_completed; } else { #ifdef ADIOI_MPE_LOGGING MPE_Log_event(ADIOI_MPE_write_a, 0, NULL); #endif ret = PVFS_sys_write(pvfs_fs->object_ref, file_req, fd->fp_ind, (void *) buf, mem_req, &(pvfs_fs->credentials), &resp_io); #ifdef ADIOI_MPE_LOGGING MPE_Log_event(ADIOI_MPE_write_b, 0, NULL); #endif /* --BEGIN ERROR HANDLING-- */ if (ret != 0) { *error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, myname, __LINE__, ADIOI_PVFS2_error_convert(ret), "Error in PVFS_sys_write", 0); goto fn_exit; } /* --END ERROR HANDLING-- */ fd->fp_ind += (int) resp_io.total_completed; fd->fp_sys_posn = fd->fp_ind; } #ifdef HAVE_STATUS_SET_BYTES MPIR_Status_set_bytes(status, datatype, resp_io.total_completed); #endif *error_code = MPI_SUCCESS; fn_exit: PVFS_Request_free(&file_req); PVFS_Request_free(&mem_req); return; }
void ADIOI_PVFS2_OldWriteStrided(ADIO_File fd, void *buf, int count, MPI_Datatype datatype, int file_ptr_type, ADIO_Offset offset, ADIO_Status *status, int *error_code) { /* as with all the other WriteStrided functions, offset is in units of * etype relative to the filetype */ /* Since PVFS2 does not support file locking, can't do buffered writes as on Unix */ ADIOI_Flatlist_node *flat_buf, *flat_file; int i, j, k, bwr_size, fwr_size=0, st_index=0; int bufsize, 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; MPI_Aint filetype_extent, buftype_extent; int buf_count, buftype_is_contig, filetype_is_contig; ADIO_Offset off, disp, start_off, initial_off; int flag, st_fwr_size, st_n_filetypes; int err_flag=0; int mem_list_count, file_list_count; PVFS_size * mem_offsets; int64_t *file_offsets; int *mem_lengths; int32_t *file_lengths; int total_blks_to_write; int max_mem_list, max_file_list; int b_blks_wrote; int f_data_wrote; int size_wrote=0, n_write_lists, extra_blks; int end_bwr_size, end_fwr_size; int start_k, start_j, new_file_write, new_buffer_write; int start_mem_offset; PVFS_Request mem_req, file_req; ADIOI_PVFS2_fs * pvfs_fs; PVFS_sysresp_io resp_io; MPI_Offset total_bytes_written=0; static char myname[] = "ADIOI_PVFS2_WRITESTRIDED"; /* note: don't increase this: several parts of PVFS2 now * assume this limit*/ #define MAX_ARRAY_SIZE 64 /* --BEGIN ERROR HANDLING-- */ if (fd->atomicity) { *error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, myname, __LINE__, MPI_ERR_ARG, "Atomic noncontiguous writes are not supported by PVFS2", 0); return; } /* --END ERROR HANDLING-- */ ADIOI_Datatype_iscontig(datatype, &buftype_is_contig); ADIOI_Datatype_iscontig(fd->filetype, &filetype_is_contig); /* the HDF5 tests showed a bug in this list processing code (see many many * lines down below). We added a workaround, but common HDF5 file types * are actually contiguous and do not need the expensive workarond */ if (!filetype_is_contig) { flat_file = ADIOI_Flatlist; while (flat_file->type != fd->filetype) flat_file = flat_file->next; if (flat_file->count == 1 && !buftype_is_contig) filetype_is_contig = 1; } MPI_Type_size(fd->filetype, &filetype_size); if ( ! filetype_size ) { #ifdef HAVE_STATUS_SET_BYTES MPIR_Status_set_bytes(status, datatype, 0); #endif *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; pvfs_fs = (ADIOI_PVFS2_fs*)fd->fs_ptr; if (!buftype_is_contig && filetype_is_contig) { /* noncontiguous in memory, contiguous in file. */ int64_t file_offsets; int32_t file_lengths; ADIOI_Flatten_datatype(datatype); flat_buf = ADIOI_Flatlist; while (flat_buf->type != datatype) flat_buf = flat_buf->next; if (file_ptr_type == ADIO_EXPLICIT_OFFSET) { off = fd->disp + etype_size * offset; } else off = fd->fp_ind; file_list_count = 1; file_offsets = off; file_lengths = 0; total_blks_to_write = count*flat_buf->count; b_blks_wrote = 0; /* allocate arrays according to max usage */ if (total_blks_to_write > MAX_ARRAY_SIZE) mem_list_count = MAX_ARRAY_SIZE; else mem_list_count = total_blks_to_write; mem_offsets = (PVFS_size*)ADIOI_Malloc(mem_list_count*sizeof(PVFS_size)); mem_lengths = (int*)ADIOI_Malloc(mem_list_count*sizeof(int)); j = 0; /* step through each block in memory, filling memory arrays */ while (b_blks_wrote < total_blks_to_write) { for (i=0; i<flat_buf->count; i++) { mem_offsets[b_blks_wrote % MAX_ARRAY_SIZE] = /* TODO: fix this warning by casting to an integer that's * the same size as a char * and /then/ casting to * PVFS_size */ ((PVFS_size)buf + j*buftype_extent + flat_buf->indices[i]); mem_lengths[b_blks_wrote % MAX_ARRAY_SIZE] = flat_buf->blocklens[i]; file_lengths += flat_buf->blocklens[i]; b_blks_wrote++; if (!(b_blks_wrote % MAX_ARRAY_SIZE) || (b_blks_wrote == total_blks_to_write)) { /* in the case of the last write list call, adjust mem_list_count */ if (b_blks_wrote == total_blks_to_write) { mem_list_count = total_blks_to_write % MAX_ARRAY_SIZE; /* in case last write list call fills max arrays */ if (!mem_list_count) mem_list_count = MAX_ARRAY_SIZE; } err_flag = PVFS_Request_hindexed(mem_list_count, mem_lengths, mem_offsets, PVFS_BYTE, &mem_req); /* --BEGIN ERROR HANDLING-- */ if (err_flag != 0) { *error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, myname, __LINE__, ADIOI_PVFS2_error_convert(err_flag), "Error in PVFS_Request_hindexed (memory)", 0); break; } /* --END ERROR HANDLING-- */ err_flag = PVFS_Request_contiguous(file_lengths, PVFS_BYTE, &file_req); /* --BEGIN ERROR HANDLING-- */ if (err_flag != 0) { *error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, myname, __LINE__, ADIOI_PVFS2_error_convert(err_flag), "Error in PVFS_Request_contiguous (file)", 0); break; } /* --END ERROR HANDLING-- */ #ifdef ADIOI_MPE_LOGGING MPE_Log_event( ADIOI_MPE_write_a, 0, NULL ); #endif err_flag = PVFS_sys_write(pvfs_fs->object_ref, file_req, file_offsets, PVFS_BOTTOM, mem_req, &(pvfs_fs->credentials), &resp_io); #ifdef ADIOI_MPE_LOGGING MPE_Log_event( ADIOI_MPE_write_b, 0, NULL ); #endif total_bytes_written += resp_io.total_completed; /* in the case of error or the last write list call, * leave here */ /* --BEGIN ERROR HANDLING-- */ if (err_flag) { *error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, myname, __LINE__, ADIOI_PVFS2_error_convert(err_flag), "Error in PVFS_sys_write", 0); break; } /* --END ERROR HANDLING-- */ if (b_blks_wrote == total_blks_to_write) break; file_offsets += file_lengths; file_lengths = 0; PVFS_Request_free(&mem_req); PVFS_Request_free(&file_req); } } /* for (i=0; i<flat_buf->count; i++) */ j++; } /* while (b_blks_wrote < total_blks_to_write) */ ADIOI_Free(mem_offsets); ADIOI_Free(mem_lengths); if (file_ptr_type == ADIO_INDIVIDUAL) fd->fp_ind += total_bytes_written; if (!err_flag) *error_code = MPI_SUCCESS; fd->fp_sys_posn = -1; /* clear this. */ #ifdef HAVE_STATUS_SET_BYTES MPIR_Status_set_bytes(status, datatype, bufsize); /* This is a temporary way of filling in status. The right way is to keep track of how much data was actually written by ADIOI_BUFFERED_WRITE. */ #endif ADIOI_Delete_flattened(datatype); return; } /* if (!buftype_is_contig && filetype_is_contig) */ /* already know that file is noncontiguous from above */ /* 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; initial_off = offset; /* for each case - ADIO_Individual pointer or explicit, find offset (file offset in bytes), n_filetypes (how many filetypes into file to start), fwr_size (remaining amount of data in present file block), and st_index (start point in terms of blocks in starting filetype) */ 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 = disp + flat_file->indices[i] + ((ADIO_Offset) n_filetypes)*filetype_extent + flat_file->blocklens[i] - offset; flag = 1; break; } } } /* while (!flag) */ } /* if (file_ptr_type == ADIO_INDIVIDUAL) */ 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; } /* else [file_ptr_type != ADIO_INDIVIDUAL] */ start_off = offset; st_fwr_size = fwr_size; st_n_filetypes = n_filetypes; if (buftype_is_contig && !filetype_is_contig) { /* contiguous in memory, noncontiguous in file. should be the most common case. */ int mem_lengths; char *mem_offsets; i = 0; j = st_index; off = offset; n_filetypes = st_n_filetypes; mem_list_count = 1; /* determine how many blocks in file to write */ f_data_wrote = ADIOI_MIN(st_fwr_size, bufsize); total_blks_to_write = 1; if (j < (flat_file->count -1)) j++; else { j = 0; n_filetypes++; } while (f_data_wrote < bufsize) { f_data_wrote += flat_file->blocklens[j]; total_blks_to_write++; if (j<(flat_file->count-1)) j++; else j = 0; } j = st_index; n_filetypes = st_n_filetypes; n_write_lists = total_blks_to_write/MAX_ARRAY_SIZE; extra_blks = total_blks_to_write%MAX_ARRAY_SIZE; mem_offsets = buf; mem_lengths = 0; /* if at least one full writelist, allocate file arrays at max array size and don't free until very end */ if (n_write_lists) { file_offsets = (int64_t*)ADIOI_Malloc(MAX_ARRAY_SIZE* sizeof(int64_t)); file_lengths = (int32_t*)ADIOI_Malloc(MAX_ARRAY_SIZE* sizeof(int32_t)); } /* if there's no full writelist allocate file arrays according to needed size (extra_blks) */ else { file_offsets = (int64_t*)ADIOI_Malloc(extra_blks* sizeof(int64_t)); file_lengths = (int32_t*)ADIOI_Malloc(extra_blks* sizeof(int32_t)); } /* for file arrays that are of MAX_ARRAY_SIZE, build arrays */ for (i=0; i<n_write_lists; i++) { file_list_count = MAX_ARRAY_SIZE; if(!i) { file_offsets[0] = offset; file_lengths[0] = st_fwr_size; mem_lengths = st_fwr_size; } for (k=0; k<MAX_ARRAY_SIZE; k++) { if (i || k) { file_offsets[k] = disp + ((ADIO_Offset)n_filetypes)*filetype_extent + flat_file->indices[j]; file_lengths[k] = flat_file->blocklens[j]; mem_lengths += file_lengths[k]; } if (j<(flat_file->count - 1)) j++; else { j = 0; n_filetypes++; } } /* for (k=0; k<MAX_ARRAY_SIZE; k++) */ err_flag = PVFS_Request_contiguous(mem_lengths, PVFS_BYTE, &mem_req); /* --BEGIN ERROR HANDLING-- */ if (err_flag != 0) { *error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, myname, __LINE__, ADIOI_PVFS2_error_convert(err_flag), "Error in PVFS_Request_contiguous (memory)", 0); goto error_state; } /* --END ERROR HANDLING-- */ err_flag = PVFS_Request_hindexed(file_list_count, file_lengths, file_offsets, PVFS_BYTE, &file_req); /* --BEGIN ERROR HANDLING-- */ if (err_flag != 0) { *error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, myname, __LINE__, ADIOI_PVFS2_error_convert(err_flag), "Error in PVFS_Request_hindexed (file)", 0); goto error_state; } /* --END ERROR HANDLING-- */ /* PVFS_Request_hindexed already expresses the offsets into the * file, so we should not pass in an offset if we are using * hindexed for the file type */ #ifdef ADIOI_MPE_LOGGING MPE_Log_event( ADIOI_MPE_write_a, 0, NULL ); #endif err_flag = PVFS_sys_write(pvfs_fs->object_ref, file_req, 0, mem_offsets, mem_req, &(pvfs_fs->credentials), &resp_io); #ifdef ADIOI_MPE_LOGGING MPE_Log_event( ADIOI_MPE_write_b, 0, NULL ); #endif /* --BEGIN ERROR HANDLING-- */ if (err_flag != 0) { *error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, myname, __LINE__, ADIOI_PVFS2_error_convert(err_flag), "Error in PVFS_sys_write", 0); goto error_state; } /* --END ERROR HANDLING-- */ total_bytes_written += resp_io.total_completed; mem_offsets += mem_lengths; mem_lengths = 0; PVFS_Request_free(&file_req); PVFS_Request_free(&mem_req); } /* for (i=0; i<n_write_lists; i++) */ /* for file arrays smaller than MAX_ARRAY_SIZE (last write_list call) */ if (extra_blks) { file_list_count = extra_blks; if(!i) { file_offsets[0] = offset; file_lengths[0] = ADIOI_MIN(st_fwr_size, bufsize); } for (k=0; k<extra_blks; k++) { if(i || k) { file_offsets[k] = disp + ((ADIO_Offset)n_filetypes)*filetype_extent + flat_file->indices[j]; if (k == (extra_blks - 1)) { file_lengths[k] = bufsize - (int32_t) mem_lengths - (int32_t) mem_offsets + (int32_t) buf; } else file_lengths[k] = flat_file->blocklens[j]; } /* if(i || k) */ mem_lengths += file_lengths[k]; if (j<(flat_file->count - 1)) j++; else { j = 0; n_filetypes++; } } /* for (k=0; k<extra_blks; k++) */ err_flag = PVFS_Request_contiguous(mem_lengths, PVFS_BYTE, &mem_req); /* --BEGIN ERROR HANDLING-- */ if (err_flag != 0) { *error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, myname, __LINE__, ADIOI_PVFS2_error_convert(err_flag), "Error in PVFS_Request_contiguous (memory)", 0); goto error_state; } /* --END ERROR HANDLING-- */ err_flag = PVFS_Request_hindexed(file_list_count, file_lengths, file_offsets, PVFS_BYTE, &file_req); /* --BEGIN ERROR HANDLING-- */ if (err_flag != 0) { *error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, myname, __LINE__, ADIOI_PVFS2_error_convert(err_flag), "Error in PVFS_Request_hindexed(file)", 0); goto error_state; } /* --END ERROR HANDLING-- */ /* as above, use 0 for 'offset' when using hindexed file type*/ #ifdef ADIOI_MPE_LOGGING MPE_Log_event( ADIOI_MPE_write_a, 0, NULL ); #endif err_flag = PVFS_sys_write(pvfs_fs->object_ref, file_req, 0, mem_offsets, mem_req, &(pvfs_fs->credentials), &resp_io); #ifdef ADIOI_MPE_LOGGING MPE_Log_event( ADIOI_MPE_write_b, 0, NULL ); #endif /* --BEGIN ERROR HANDLING-- */ if (err_flag != 0) { *error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, myname, __LINE__, ADIOI_PVFS2_error_convert(err_flag), "Error in PVFS_sys_write", 0); goto error_state; } /* --END ERROR HANDLING-- */ total_bytes_written += resp_io.total_completed; PVFS_Request_free(&mem_req); PVFS_Request_free(&file_req); } } else { /* noncontiguous in memory as well as in file */ ADIOI_Flatten_datatype(datatype); flat_buf = ADIOI_Flatlist; while (flat_buf->type != datatype) flat_buf = flat_buf->next; size_wrote = 0; n_filetypes = st_n_filetypes; fwr_size = st_fwr_size; bwr_size = flat_buf->blocklens[0]; buf_count = 0; start_mem_offset = 0; start_k = k = 0; start_j = st_index; max_mem_list = 0; max_file_list = 0; /* run through and file max_file_list and max_mem_list so that you can allocate the file and memory arrays less than MAX_ARRAY_SIZE if possible */ while (size_wrote < bufsize) { k = start_k; new_buffer_write = 0; mem_list_count = 0; while ((mem_list_count < MAX_ARRAY_SIZE) && (new_buffer_write < bufsize-size_wrote)) { /* find mem_list_count and file_list_count such that both are less than MAX_ARRAY_SIZE, the sum of their lengths are equal, and the sum of all the data written and data to be written in the next immediate write list is less than bufsize */ if(mem_list_count) { if((new_buffer_write + flat_buf->blocklens[k] + size_wrote) > bufsize) { end_bwr_size = new_buffer_write + flat_buf->blocklens[k] - (bufsize - size_wrote); new_buffer_write = bufsize - size_wrote; } else { new_buffer_write += flat_buf->blocklens[k]; end_bwr_size = flat_buf->blocklens[k]; } } else { if (bwr_size > (bufsize - size_wrote)) { new_buffer_write = bufsize - size_wrote; bwr_size = new_buffer_write; } else new_buffer_write = bwr_size; } mem_list_count++; k = (k + 1)%flat_buf->count; } /* while ((mem_list_count < MAX_ARRAY_SIZE) && (new_buffer_write < bufsize-size_wrote)) */ j = start_j; new_file_write = 0; file_list_count = 0; while ((file_list_count < MAX_ARRAY_SIZE) && (new_file_write < new_buffer_write)) { if(file_list_count) { if((new_file_write + flat_file->blocklens[j]) > new_buffer_write) { end_fwr_size = new_buffer_write - new_file_write; new_file_write = new_buffer_write; j--; } else { new_file_write += flat_file->blocklens[j]; end_fwr_size = flat_file->blocklens[j]; } } else { if (fwr_size > new_buffer_write) { new_file_write = new_buffer_write; fwr_size = new_file_write; } else new_file_write = fwr_size; } file_list_count++; if (j < (flat_file->count - 1)) j++; else j = 0; k = start_k; if ((new_file_write < new_buffer_write) && (file_list_count == MAX_ARRAY_SIZE)) { new_buffer_write = 0; mem_list_count = 0; while (new_buffer_write < new_file_write) { if(mem_list_count) { if((new_buffer_write + flat_buf->blocklens[k]) > new_file_write) { end_bwr_size = new_file_write - new_buffer_write; new_buffer_write = new_file_write; k--; } else { new_buffer_write += flat_buf->blocklens[k]; end_bwr_size = flat_buf->blocklens[k]; } } else { new_buffer_write = bwr_size; if (bwr_size > (bufsize - size_wrote)) { new_buffer_write = bufsize - size_wrote; bwr_size = new_buffer_write; } } mem_list_count++; k = (k + 1)%flat_buf->count; } /* while (new_buffer_write < new_file_write) */ } /* if ((new_file_write < new_buffer_write) && (file_list_count == MAX_ARRAY_SIZE)) */ } /* while ((mem_list_count < MAX_ARRAY_SIZE) && (new_buffer_write < bufsize-size_wrote)) */ /* fakes filling the writelist arrays of lengths found above */ k = start_k; j = start_j; for (i=0; i<mem_list_count; i++) { if(i) { if (i == (mem_list_count - 1)) { if (flat_buf->blocklens[k] == end_bwr_size) bwr_size = flat_buf->blocklens[(k+1)% flat_buf->count]; else { bwr_size = flat_buf->blocklens[k] - end_bwr_size; k--; buf_count--; } } } buf_count++; k = (k + 1)%flat_buf->count; } /* for (i=0; i<mem_list_count; i++) */ for (i=0; i<file_list_count; i++) { if (i) { if (i == (file_list_count - 1)) { if (flat_file->blocklens[j] == end_fwr_size) fwr_size = flat_file->blocklens[(j+1)% flat_file->count]; else { fwr_size = flat_file->blocklens[j] - end_fwr_size; j--; } } } if (j < flat_file->count - 1) j++; else { j = 0; n_filetypes++; } } /* for (i=0; i<file_list_count; i++) */ size_wrote += new_buffer_write; start_k = k; start_j = j; if (max_mem_list < mem_list_count) max_mem_list = mem_list_count; if (max_file_list < file_list_count) max_file_list = file_list_count; } /* while (size_wrote < bufsize) */ /* one last check before we actually carry out the operation: * this code has hard-to-fix bugs when a noncontiguous file type has * such large pieces that the sum of the lengths of the memory type is * not larger than one of those pieces (and vice versa for large memory * types and many pices of file types. In these cases, give up and * fall back to naive reads and writes. The testphdf5 test created a * type with two very large memory regions and 600 very small file * regions. The same test also created a type with one very large file * region and many (700) very small memory regions. both cases caused * problems for this code */ if ( ( (file_list_count == 1) && (new_file_write < flat_file->blocklens[0] ) ) || ((mem_list_count == 1) && (new_buffer_write < flat_buf->blocklens[0]) ) || ((file_list_count == MAX_ARRAY_SIZE) && (new_file_write < flat_buf->blocklens[0]) ) || ( (mem_list_count == MAX_ARRAY_SIZE) && (new_buffer_write < flat_file->blocklens[0])) ) { ADIOI_Delete_flattened(datatype); ADIOI_GEN_WriteStrided_naive(fd, buf, count, datatype, file_ptr_type, initial_off, status, error_code); return; } mem_offsets = (PVFS_size*)ADIOI_Malloc(max_mem_list*sizeof(PVFS_size)); mem_lengths = (int *)ADIOI_Malloc(max_mem_list*sizeof(int)); file_offsets = (int64_t *)ADIOI_Malloc(max_file_list*sizeof(int64_t)); file_lengths = (int32_t *)ADIOI_Malloc(max_file_list*sizeof(int32_t)); size_wrote = 0; n_filetypes = st_n_filetypes; fwr_size = st_fwr_size; bwr_size = flat_buf->blocklens[0]; buf_count = 0; start_mem_offset = 0; start_k = k = 0; start_j = st_index; /* this section calculates mem_list_count and file_list_count and also finds the possibly odd sized last array elements in new_fwr_size and new_bwr_size */ while (size_wrote < bufsize) { k = start_k; new_buffer_write = 0; mem_list_count = 0; while ((mem_list_count < MAX_ARRAY_SIZE) && (new_buffer_write < bufsize-size_wrote)) { /* find mem_list_count and file_list_count such that both are less than MAX_ARRAY_SIZE, the sum of their lengths are equal, and the sum of all the data written and data to be written in the next immediate write list is less than bufsize */ if(mem_list_count) { if((new_buffer_write + flat_buf->blocklens[k] + size_wrote) > bufsize) { end_bwr_size = new_buffer_write + flat_buf->blocklens[k] - (bufsize - size_wrote); new_buffer_write = bufsize - size_wrote; } else { new_buffer_write += flat_buf->blocklens[k]; end_bwr_size = flat_buf->blocklens[k]; } } else { if (bwr_size > (bufsize - size_wrote)) { new_buffer_write = bufsize - size_wrote; bwr_size = new_buffer_write; } else new_buffer_write = bwr_size; } mem_list_count++; k = (k + 1)%flat_buf->count; } /* while ((mem_list_count < MAX_ARRAY_SIZE) && (new_buffer_write < bufsize-size_wrote)) */ j = start_j; new_file_write = 0; file_list_count = 0; while ((file_list_count < MAX_ARRAY_SIZE) && (new_file_write < new_buffer_write)) { if(file_list_count) { if((new_file_write + flat_file->blocklens[j]) > new_buffer_write) { end_fwr_size = new_buffer_write - new_file_write; new_file_write = new_buffer_write; j--; } else { new_file_write += flat_file->blocklens[j]; end_fwr_size = flat_file->blocklens[j]; } } else { if (fwr_size > new_buffer_write) { new_file_write = new_buffer_write; fwr_size = new_file_write; } else new_file_write = fwr_size; } file_list_count++; if (j < (flat_file->count - 1)) j++; else j = 0; k = start_k; if ((new_file_write < new_buffer_write) && (file_list_count == MAX_ARRAY_SIZE)) { new_buffer_write = 0; mem_list_count = 0; while (new_buffer_write < new_file_write) { if(mem_list_count) { if((new_buffer_write + flat_buf->blocklens[k]) > new_file_write) { end_bwr_size = new_file_write - new_buffer_write; new_buffer_write = new_file_write; k--; } else { new_buffer_write += flat_buf->blocklens[k]; end_bwr_size = flat_buf->blocklens[k]; } } else { new_buffer_write = bwr_size; if (bwr_size > (bufsize - size_wrote)) { new_buffer_write = bufsize - size_wrote; bwr_size = new_buffer_write; } } mem_list_count++; k = (k + 1)%flat_buf->count; } /* while (new_buffer_write < new_file_write) */ } /* if ((new_file_write < new_buffer_write) && (file_list_count == MAX_ARRAY_SIZE)) */ } /* while ((mem_list_count < MAX_ARRAY_SIZE) && (new_buffer_write < bufsize-size_wrote)) */ /* fills the allocated writelist arrays */ k = start_k; j = start_j; for (i=0; i<mem_list_count; i++) { /* TODO: fix this warning by casting to an integer that's the * same size as a char * and /then/ casting to PVFS_size */ mem_offsets[i] = ((PVFS_size)buf + buftype_extent* (buf_count/flat_buf->count) + (int)flat_buf->indices[k]); if(!i) { mem_lengths[0] = bwr_size; mem_offsets[0] += flat_buf->blocklens[k] - bwr_size; } else { if (i == (mem_list_count - 1)) { mem_lengths[i] = end_bwr_size; if (flat_buf->blocklens[k] == end_bwr_size) bwr_size = flat_buf->blocklens[(k+1)% flat_buf->count]; else { bwr_size = flat_buf->blocklens[k] - end_bwr_size; k--; buf_count--; } } else { mem_lengths[i] = flat_buf->blocklens[k]; } } buf_count++; k = (k + 1)%flat_buf->count; } /* for (i=0; i<mem_list_count; i++) */ for (i=0; i<file_list_count; i++) { file_offsets[i] = disp + flat_file->indices[j] + ((ADIO_Offset)n_filetypes) * filetype_extent; if (!i) { file_lengths[0] = fwr_size; file_offsets[0] += flat_file->blocklens[j] - fwr_size; } else { if (i == (file_list_count - 1)) { file_lengths[i] = end_fwr_size; if (flat_file->blocklens[j] == end_fwr_size) fwr_size = flat_file->blocklens[(j+1)% flat_file->count]; else { fwr_size = flat_file->blocklens[j] - end_fwr_size; j--; } } else file_lengths[i] = flat_file->blocklens[j]; } if (j < flat_file->count - 1) j++; else { j = 0; n_filetypes++; } } /* for (i=0; i<file_list_count; i++) */ err_flag = PVFS_Request_hindexed(mem_list_count, mem_lengths, mem_offsets, PVFS_BYTE, &mem_req); /* --BEGIN ERROR HANDLING-- */ if (err_flag != 0 ) { *error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, myname, __LINE__, ADIOI_PVFS2_error_convert(err_flag), "Error in PVFS_Request_hindexed (memory)", 0); goto error_state; } /* --END ERROR HANDLING-- */ err_flag = PVFS_Request_hindexed(file_list_count, file_lengths, file_offsets, PVFS_BYTE, &file_req); /* --BEGIN ERROR HANDLING-- */ if (err_flag != 0) { *error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, myname, __LINE__, ADIOI_PVFS2_error_convert(err_flag), "Error in PVFS_Request_hindexed", 0); goto error_state; } /* --END ERROR HANDLING-- */ /* offset will be expressed in memory and file datatypes */ #ifdef ADIOI_MPE_LOGGING MPE_Log_event( ADIOI_MPE_write_a, 0, NULL ); #endif err_flag = PVFS_sys_write(pvfs_fs->object_ref, file_req, 0, PVFS_BOTTOM, mem_req, &(pvfs_fs->credentials), &resp_io); #ifdef ADIOI_MPE_LOGGING MPE_Log_event( ADIOI_MPE_write_b, 0, NULL ); #endif /* --BEGIN ERROR HANDLING-- */ if (err_flag != 0) { *error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, myname, __LINE__, ADIOI_PVFS2_error_convert(err_flag), "Error in PVFS_sys_write", 0); goto error_state; } /* --END ERROR HANDLING-- */ size_wrote += new_buffer_write; total_bytes_written += resp_io.total_completed; start_k = k; start_j = j; PVFS_Request_free(&mem_req); PVFS_Request_free(&file_req); } /* while (size_wrote < bufsize) */ ADIOI_Free(mem_offsets); ADIOI_Free(mem_lengths); } /* when incrementing fp_ind, need to also take into account the file type: * consider an N-element 1-d subarray with a lb and ub: ( |---xxxxx-----| * if we wrote N elements, offset needs to point at beginning of type, not * at empty region at offset N+1). * * As we discussed on mpich-discuss in may/june 2009, the code below might * look wierd, but by putting fp_ind at the last byte written, the next * time we run through the strided code we'll update the fp_ind to the * right location. */ if (file_ptr_type == ADIO_INDIVIDUAL) { fd->fp_ind = file_offsets[file_list_count-1]+ file_lengths[file_list_count-1]; } ADIOI_Free(file_offsets); ADIOI_Free(file_lengths); *error_code = MPI_SUCCESS; error_state: fd->fp_sys_posn = -1; /* set it to null. */ #ifdef HAVE_STATUS_SET_BYTES MPIR_Status_set_bytes(status, datatype, bufsize); /* This is a temporary way of filling in status. The right way is to keep track of how much data was actually written by ADIOI_BUFFERED_WRITE. */ #endif if (!buftype_is_contig) ADIOI_Delete_flattened(datatype); }
int main(int argc, char **argv) { PVFS_sysresp_lookup resp_lk; PVFS_sysresp_create resp_cr; PVFS_sysresp_io resp_io; char *filename = NULL; int ret = -1, io_size = DEFAULT_IO_SIZE; int *io_buffer = NULL; int i, errors, buffer_size; PVFS_fs_id fs_id; char name[512] = {0}; char *entry_name = NULL; PVFS_credentials credentials; PVFS_object_ref parent_refn; PVFS_sys_attr attr; PVFS_object_ref pinode_refn; PVFS_Request file_req; PVFS_Request mem_req; void *buffer = NULL; PVFS_sysresp_getattr resp_getattr; PVFS_handle *dfile_array = NULL; if (argc != 2) { fprintf(stderr, "Usage: %s <file name>\n", argv[0]); return (-1); } /* create a buffer for running I/O on */ io_buffer = (int *) malloc(io_size * sizeof(int)); if (!io_buffer) { return (-1); } /* put some data in the buffer so we can verify */ for (i = 0; i < io_size; i++) { io_buffer[i] = i; } ret = PVFS_util_init_defaults(); if (ret < 0) { PVFS_perror("PVFS_util_init_defaults", ret); return (-1); } ret = PVFS_util_get_default_fsid(&fs_id); if (ret < 0) { PVFS_perror("PVFS_util_get_default_fsid", ret); return (-1); } if (argv[1][0] == '/') { snprintf(name, 512, "%s", argv[1]); } else { snprintf(name, 512, "/%s", argv[1]); } PVFS_util_gen_credentials(&credentials); ret = PVFS_sys_lookup(fs_id, name, &credentials, &resp_lk, PVFS2_LOOKUP_LINK_FOLLOW, NULL); if (ret == -PVFS_ENOENT) { PVFS_sysresp_getparent gp_resp; printf("IO-TEST: lookup failed; creating new file.\n"); memset(&gp_resp, 0, sizeof(PVFS_sysresp_getparent)); ret = PVFS_sys_getparent(fs_id, name, &credentials, &gp_resp, NULL); if (ret < 0) { PVFS_perror("PVFS_sys_getparent failed", ret); return ret; } attr.owner = credentials.uid; attr.group = credentials.gid; attr.perms = PVFS_U_WRITE | PVFS_U_READ; attr.atime = attr.ctime = attr.mtime = time(NULL); attr.mask = PVFS_ATTR_SYS_ALL_SETABLE; parent_refn = gp_resp.parent_ref; entry_name = rindex(name, (int)'/'); assert(entry_name); entry_name++; assert(entry_name); ret = PVFS_sys_create(entry_name, parent_refn, attr, &credentials, NULL, &resp_cr, NULL, NULL); if (ret < 0) { PVFS_perror("PVFS_sys_create() failure", ret); return (-1); } pinode_refn.fs_id = fs_id; pinode_refn.handle = resp_cr.ref.handle; } else { printf("IO-TEST: lookup succeeded; performing I/O on " "existing file.\n"); pinode_refn.fs_id = fs_id; pinode_refn.handle = resp_lk.ref.handle; } /************************************************************** * carry out I/O operation */ printf("IO-TEST: performing write on handle: %ld, fs: %d\n", (long) pinode_refn.handle, (int) pinode_refn.fs_id); buffer = io_buffer; buffer_size = io_size * sizeof(int); /* file datatype is tiled, so we can get away with a trivial type here */ file_req = PVFS_BYTE; ret = PVFS_Request_contiguous(io_size * sizeof(int), PVFS_BYTE, &(mem_req)); if (ret < 0) { PVFS_perror("PVFS_request_contiguous failure", ret); return (-1); } ret = PVFS_sys_write(pinode_refn, file_req, 0, buffer, mem_req, &credentials, &resp_io, NULL); if (ret < 0) { PVFS_perror("PVFS_sys_write failure", ret); return (-1); } printf("IO-TEST: wrote %d bytes.\n", (int) resp_io.total_completed); /* uncomment and try out the readback-and-verify stuff that follows * once reading back actually works */ memset(io_buffer, 0, io_size * sizeof(int)); /* verify */ printf("IO-TEST: performing read on handle: %ld, fs: %d\n", (long) pinode_refn.handle, (int) pinode_refn.fs_id); ret = PVFS_sys_read(pinode_refn, file_req, 0, buffer, mem_req, &credentials, &resp_io, NULL); if (ret < 0) { PVFS_perror("PVFS_sys_read failure", ret); return (-1); } printf("IO-TEST: read %d bytes.\n", (int) resp_io.total_completed); if ((io_size * sizeof(int)) != resp_io.total_completed) { fprintf(stderr, "Error: SHORT READ! skipping verification...\n"); } else { errors = 0; for (i = 0; i < io_size; i++) { if (i != io_buffer[i]) { fprintf(stderr, "error: element %d differs: should be %d, is %d\n", i, i, io_buffer[i]); errors++; } } if (errors != 0) { fprintf(stderr, "ERROR: found %d errors\n", errors); } else { printf("IO-TEST: no errors found.\n"); } } /* test out some of the mgmt functionality */ ret = PVFS_sys_getattr(pinode_refn, PVFS_ATTR_SYS_ALL_NOSIZE, &credentials, &resp_getattr, NULL); if (ret < 0) { PVFS_perror("PVFS_sys_getattr", ret); return (-1); } printf("Target file had %d datafiles:\n", resp_getattr.attr.dfile_count); dfile_array = (PVFS_handle *) malloc(resp_getattr.attr.dfile_count * sizeof(PVFS_handle)); if (!dfile_array) { perror("malloc"); return (-1); } ret = PVFS_mgmt_get_dfile_array(pinode_refn, &credentials, dfile_array, resp_getattr.attr.dfile_count, NULL); if (ret < 0) { PVFS_perror("PVFS_mgmt_get_dfile_array", ret); return (-1); } for (i = 0; i < resp_getattr.attr.dfile_count; i++) { printf("%llu\n", llu(dfile_array[i])); } /************************************************************** * shut down pending interfaces */ ret = PVFS_sys_finalize(); if (ret < 0) { fprintf(stderr, "Error: PVFS_sys_finalize() failed with errcode = %d\n", ret); return (-1); } free(filename); free(io_buffer); return (0); }
static int test_read_sparse_files(void){ PVFS_credentials credentials; PVFS_sysresp_lookup resp_lk; PVFS_Request req_io; PVFS_Request req_mem; PVFS_sysresp_io resp_io; PVFS_sysresp_getattr resp; PVFS_offset file_req_offset = 0; uint32_t attrmask; char *filename; char io_buffer[100]; int fs_id, ret, i; attrmask = PVFS_ATTR_SYS_ALL_NOSIZE; filename = (char *) malloc(sizeof(char) * 100); filename = strcpy(filename, "sparse2"); memset(&req_io, 0, sizeof(PVFS_Request)); memset(&req_mem, 0, sizeof(PVFS_Request)); memset(&resp_io, 0, sizeof(PVFS_sysresp_io)); PVFS_util_gen_credentials(&credentials); memset(&resp_lk, 0, sizeof(PVFS_sysresp_lookup)); if (initialize_sysint() < 0) { debug_printf("UNABLE TO INIT THE SYSTEM INTERFACE\n"); return -1; } fs_id = pvfs_helper.fs_id; ret = PVFS_sys_lookup(fs_id, filename, &credentials, &resp_lk, PVFS2_LOOKUP_LINK_NO_FOLLOW); if (ret < 0) { debug_printf("test_pvfs_datatype_hvector: lookup failed " "on %s\n", filename); } if((ret = PVFS_sys_getattr(resp_lk.ref, attrmask, &credentials, &resp)) < 0) return ret; assert(0); /* TODO: what's this? we shouldn't edit these fields directly -Phil */ #if 0 switch(testcase) { case 0: req_io->offset = 78000; break; case 1: req_io->offset = 150000; break; case 2: req_io->offset = 330000; break; } #endif for(i = 0; i < 100; i++) { io_buffer[i] = 'a'; } ret = PVFS_sys_write(resp_lk.ref, req_io, file_req_offset, io_buffer, req_mem, &credentials, &resp_io); if(ret < 0){ debug_printf("write failed on %s\n", filename); } ret = PVFS_sys_read(resp_lk.ref, req_io, file_req_offset, io_buffer, req_mem, &credentials, &resp_io); if(ret < 0){ debug_printf("write failed on %s\n", filename); } /* finalize_sysint(); */ for(i = 0; i < 100; i++) { if(io_buffer[i] != 0){ return -1; } } /* check for whats in the buffer */ return 0; }