/*------------------------------------------------------------------------- * Function: H5O_ginfo_debug * * Purpose: Prints debugging info for a message. * * Return: Non-negative on success/Negative on failure * * Programmer: Quincey Koziol * [email protected] * Aug 30 2005 * *------------------------------------------------------------------------- */ static herr_t H5O_ginfo_debug(H5F_t UNUSED *f, hid_t UNUSED dxpl_id, const void *_mesg, FILE * stream, int indent, int fwidth) { const H5O_ginfo_t *ginfo = (const H5O_ginfo_t *) _mesg; FUNC_ENTER_NOAPI_NOINIT_NOERR /* check args */ HDassert(f); HDassert(ginfo); HDassert(stream); HDassert(indent >= 0); HDassert(fwidth >= 0); HDfprintf(stream, "%*s%-*s %u\n", indent, "", fwidth, "Max. compact links:", ginfo->max_compact); HDfprintf(stream, "%*s%-*s %u\n", indent, "", fwidth, "Min. dense links:", ginfo->min_dense); HDfprintf(stream, "%*s%-*s %u\n", indent, "", fwidth, "Estimated # of objects in group:", ginfo->est_num_entries); HDfprintf(stream, "%*s%-*s %u\n", indent, "", fwidth, "Estimated length of object in group's name:", ginfo->est_name_len); FUNC_LEAVE_NOAPI(SUCCEED) } /* end H5O_ginfo_debug() */
/*------------------------------------------------------------------------- * Function: print_metadata_retries_info * * Purpose: To retrieve and print the collection of metadata retries for the file. * * Parameters: fid: the currently opened file identifier * * Return: Success: 0 * Failure: negative * *------------------------------------------------------------------------- */ int print_metadata_retries_info(hid_t fid) { H5F_retry_info_t info; unsigned i; /* Retrieve the collection of retries */ if(H5Fget_metadata_read_retry_info(fid, &info) < 0) return (-1); /* Print information for each non-NULL retries[i] */ for(i = 0; i < H5F_NUM_METADATA_READ_RETRY_TYPES; i++) { unsigned power; unsigned j; if(NULL == info.retries[i]) continue; HDfprintf(stderr, "Metadata read retries for item %u:\n", i); power = 1; for(j = 0; j < info.nbins; j++) { if(info.retries[i][j]) HDfprintf(stderr, "\t# of retries for %u - %u retries: %u\n", power, (power * 10) - 1, info.retries[i][j]); power *= 10; } /* end for */ } /* end for */ /* Free memory for each non-NULL retries[i] */ for(i = 0; i < H5F_NUM_METADATA_READ_RETRY_TYPES; i++) if(info.retries[i] != NULL) HDfree(info.retries[i]); return 0; } /* print_metadata_retries_info() */
/*------------------------------------------------------------------------- * Function: H5HF_man_dblock_destroy * * Purpose: Destroy a managed direct block * * Note: This routine does _not_ insert a range section for the * destroyed direct block, that must be handled by the * caller. * * Return: SUCCEED/FAIL * * Programmer: Quincey Koziol * [email protected] * May 17 2006 * *------------------------------------------------------------------------- */ herr_t H5HF_man_dblock_destroy(H5HF_hdr_t *hdr, hid_t dxpl_id, H5HF_direct_t *dblock, haddr_t dblock_addr) { hsize_t dblock_size; /* Size of direct block on disk */ herr_t ret_value = SUCCEED; /* Return value */ FUNC_ENTER_NOAPI_NOINIT(H5HF_man_dblock_destroy) #ifdef QAK HDfprintf(stderr, "%s: dblock->block_off = %Hu\n", FUNC, dblock->block_off); HDfprintf(stderr, "%s: dblock->size = %Zu\n", FUNC, dblock->size); HDfprintf(stderr, "%s: dblock_addr = %a\n", FUNC, dblock_addr); #endif /* QAK */ /* * Check arguments. */ HDassert(hdr); HDassert(dblock); /* Check for I/O filters on this heap */ if(hdr->filter_len > 0) { /* Check for root direct block */ if(dblock->parent == NULL) /* Get direct block's actual size */ dblock_size = (hsize_t)hdr->pline_root_direct_size; else { H5HF_indirect_t *par_iblock; /* Parent indirect block */ unsigned par_entry; /* Entry in parent indirect block */ /* Get parent information */ par_iblock = dblock->parent; par_entry = dblock->par_entry; /* Get direct block's actual size */ dblock_size = (hsize_t)par_iblock->filt_ents[par_entry].size; } /* end else */ } /* end if */ else dblock_size = (hsize_t)dblock->size; /* Check for root direct block */ if(hdr->man_dtable.curr_root_rows == 0) { #ifdef QAK HDfprintf(stderr, "%s: root direct block\n", FUNC); #endif /* QAK */ /* Sanity check */ HDassert(hdr->man_dtable.table_addr == dblock_addr); HDassert(hdr->man_dtable.cparam.start_block_size == dblock->size); /* Sanity check block iterator */ HDassert(!H5HF_man_iter_ready(&hdr->next_block)); /* Reset root pointer information */ hdr->man_dtable.table_addr = HADDR_UNDEF; /* Reset header information back to "empty heap" state */ if(H5HF_hdr_empty(hdr) < 0) HGOTO_ERROR(H5E_HEAP, H5E_CANTSHRINK, FAIL, "can't make heap empty") } /* end if */
/*------------------------------------------------------------------------- * Function: custom_print_cb * * Purpose: Callback function to print error stack in customized way. * * Return: Success: 0 * * Failure: -1 * * Programmer: Raymond Lu * July 17, 2003 * *------------------------------------------------------------------------- */ static herr_t custom_print_cb(unsigned n, const H5E_error2_t *err_desc, void* client_data) { FILE *stream = (FILE *)client_data; char maj[MSG_SIZE]; char min[MSG_SIZE]; char cls[MSG_SIZE]; const int indent = 4; /* Get descriptions for the major and minor error numbers */ if(H5Eget_class_name(err_desc->cls_id, cls, MSG_SIZE) < 0) TEST_ERROR; if(H5Eget_msg(err_desc->maj_num, NULL, maj, MSG_SIZE) < 0) TEST_ERROR; if(H5Eget_msg(err_desc->min_num, NULL, min, MSG_SIZE) < 0) TEST_ERROR; HDfprintf(stream, "%*serror #%03d: %s in %s(): line %u\n", indent, "", n, err_desc->file_name, err_desc->func_name, err_desc->line); HDfprintf(stream, "%*sclass: %s\n", indent * 2, "", cls); HDfprintf(stream, "%*smajor: %s\n", indent * 2, "", maj); HDfprintf(stream, "%*sminor: %s\n", indent * 2, "", min); return 0; error: return -1; } /* end custom_print_cb() */
/*------------------------------------------------------------------------- * Function: send_signal * * Purpose: Sends the specified signal. * * In terms of this test framework, a signal consists of a file * on disk. Since there are multiple processes that need to * communicate with each other, they do so by writing and * reading signal files on disk, the names and contents of * which are used to inform a process about when it can * proceed and what it should do next. * * This function writes a signal file. The first argument is * the name of the signal file, and the second and third * arguments are the contents of the first two lines of the * signal file. The last two arguments may be NULL. * * Return: void * * Programmer: Mike McGreevy * August 18, 2010 * * Modifications: * *------------------------------------------------------------------------- */ void send_signal(const char * send, const char * arg1, const char * arg2) { FILE *signalfile = NULL; /* Create signal file (which will send signal to some other process) */ signalfile = fopen(send, "w+"); /* Write messages to signal file, if provided */ if (arg2 != NULL) { HDassert(arg1); HDfprintf(signalfile, "%s\n%s\n", arg1, arg2); } /* end if */ else if (arg1 != NULL) { HDassert(arg2 == NULL); HDfprintf(signalfile, "%s\n", arg1); } /* end if */ else { HDassert(arg1 == NULL); HDassert(arg2 == NULL); }/* end else */ HDfflush(signalfile); HDfclose(signalfile); } /* send_signal */
static void print_io_api(long io_types) { if (io_types & SIO_POSIX) HDfprintf(output, "posix "); if (io_types & SIO_HDF5) HDfprintf(output, "hdf5 "); HDfprintf(output, "\n"); }
/*------------------------------------------------------------------------- * Function: check_dataset * * Purpose: For a given dataset, checks to make sure that the stated * and actual sizes are the same. If they are not, then * we have an inconsistent dataset due to a SWMR error. * * Parameters: hid_t fid * The SWMR test file's ID. * * unsigned verbose * Whether verbose console output is desired. * * const symbol_info_t *symbol * The dataset from which to read (the ID is in the struct). * Must be pre-allocated. * * symbol_t *record * Memory for the record. Must be pre-allocated. * * hid_t rec_sid * The memory dataspace for access. It's always the same so * there is no need to re-create it every time this function * is called. * * Return: Success: 0 * Failure: -1 * *------------------------------------------------------------------------- */ static int check_dataset(hid_t fid, unsigned verbose, const symbol_info_t *symbol, symbol_t *record, hid_t rec_sid) { hid_t dsid; /* Dataset ID */ hid_t file_sid; /* Dataset's space ID */ hsize_t start[2] = {0, 0}; /* Hyperslab selection values */ hsize_t count[2] = {1, 1}; /* Hyperslab selection values */ HDassert(fid >= 0); HDassert(symbol); HDassert(record); HDassert(rec_sid >= 0); /* Open dataset for symbol */ if((dsid = H5Dopen2(fid, symbol->name, H5P_DEFAULT)) < 0) return -1; /* Get the dataset's dataspace */ if((file_sid = H5Dget_space(dsid)) < 0) return -1; /* Choose the random record in the dataset (will be the same as chosen by * the writer) */ start[1] = (hsize_t)HDrandom() % symbol->nrecords; if(H5Sselect_hyperslab(file_sid, H5S_SELECT_SET, start, NULL, count, NULL) < 0) return -1; /* Emit informational message */ if(verbose) HDfprintf(stderr, "Symbol = '%s', location = %lld\n", symbol->name, (long long)start); /* Read record from dataset */ record->rec_id = (uint64_t)ULLONG_MAX; if(H5Dread(dsid, symbol_tid, rec_sid, file_sid, H5P_DEFAULT, record) < 0) return -1; /* Verify record value */ if(record->rec_id != start[1]) { HDfprintf(stderr, "*** ERROR ***\n"); HDfprintf(stderr, "Incorrect record value!\n"); HDfprintf(stderr, "Symbol = '%s', location = %lld, record->rec_id = %llu\n", symbol->name, (long long)start, (unsigned long long)record->rec_id); return -1; } /* end if */ /* Close the dataset's dataspace */ if(H5Sclose(file_sid) < 0) return -1; /* Close dataset for symbol */ if(H5Dclose(dsid) < 0) return -1; return 0; } /* end check_dataset() */
/*------------------------------------------------------------------------- * Function: dump_table * * Purpose: display the contents of tables for debugging purposes * * Return: void * * Programmer: Ruey-Hsia Li * * Modifications: * *------------------------------------------------------------------------- */ static void dump_table(char* tablename, table_t *table) { unsigned u; HDfprintf(rawoutstream,"%s: # of entries = %d\n", tablename,table->nobjs); for (u = 0; u < table->nobjs; u++) HDfprintf(rawoutstream,"%a %s %d %d\n", table->objs[u].objno, table->objs[u].objname, table->objs[u].displayed, table->objs[u].recorded); }
/* * Function: error * Purpose: Display error message and exit. * Programmer: Bill Wendling, 05. June 2002 * Modifications: */ static void error(const char *fmt, ...) { va_list ap; va_start(ap, fmt); HDfprintf(stderr, "%s: error: ", prog); HDvfprintf(stderr, fmt, ap); HDfprintf(stderr, "\n"); va_end(ap); HDexit(EXIT_FAILURE); }
/*------------------------------------------------------------------------- * Function: indentation * * Purpose: Print spaces for indentation * * Return: void * * Programmer: Ruey-Hsia Li * * Modifications: * *------------------------------------------------------------------------- */ void indentation(int x) { if (x < h5tools_nCols) { while (x-- > 0) HDfprintf(rawoutstream, " "); } else { HDfprintf(rawerrorstream, "error: the indentation exceeds the number of cols.\n"); HDexit(1); } }
/* * Function: do_fopen * Purpose: Open the specified file. * Return: SUCCESS or FAIL * Programmer: Albert Cheng, Bill Wendling, 2001/12/13 * Modifications: Support for file drivers, Christian Chilan, April, 2008 */ static herr_t do_fopen(parameters *param, char *fname, file_descr *fd /*out*/, int flags) { int ret_code = SUCCESS; switch (param->io_type) { case POSIXIO: if (flags & (SIO_CREATE | SIO_WRITE)) fd->posixfd = POSIXCREATE(fname); else fd->posixfd = POSIXOPEN(fname, O_RDONLY); if (fd->posixfd < 0 ) { HDfprintf(stderr, "POSIX File Open failed(%s)\n", fname); GOTOERROR(FAIL); } break; case HDF5: fapl = set_vfd(param); if (fapl < 0) { fprintf(stderr, "HDF5 Property List Create failed\n"); GOTOERROR(FAIL); } /* create the parallel file */ if (flags & (SIO_CREATE | SIO_WRITE)) { fd->h5fd = H5Fcreate(fname, H5F_ACC_TRUNC, H5P_DEFAULT, fapl); } else { fd->h5fd = H5Fopen(fname, H5F_ACC_RDONLY, fapl); } if (fd->h5fd < 0) { fprintf(stderr, "HDF5 File Create failed(%s)\n", fname); GOTOERROR(FAIL); } break; default: /* unknown request */ HDfprintf(stderr, "Unknown IO type request (%d)\n", (int)param->io_type); GOTOERROR(FAIL); break; } done: return ret_code; }
/*------------------------------------------------------------------------- * Function: print_group_metadata * * Purpose: Prints file space information for groups' metadata * * Return: Success: 0 * * Failure: Never fails * * Programmer: Vailin Choi; October 2009 * *------------------------------------------------------------------------- */ static herr_t print_group_metadata(const iter_t *iter) { printf("File space information for groups' metadata (in bytes):\n"); HDfprintf(stdout, "\tObject headers (total/unused): %Hu/%Hu\n", iter->group_ohdr_info.total_size, iter->group_ohdr_info.free_size); HDfprintf(stdout, "\tB-tree/List: %Hu\n", iter->groups_btree_storage_size); HDfprintf(stdout, "\tHeap: %Hu\n", iter->groups_heap_storage_size); return 0; } /* print_group_metadata() */
/*------------------------------------------------------------------------- * Function: H5HF_man_insert * * Purpose: Insert an object in a managed direct block * * Return: SUCCEED/FAIL * * Programmer: Quincey Koziol * [email protected] * Mar 13 2006 * *------------------------------------------------------------------------- */ herr_t H5HF_man_insert(H5HF_hdr_t *hdr, hid_t dxpl_id, size_t obj_size, const void *obj, void *_id) { H5HF_free_section_t *sec_node; /* Pointer to free space section */ H5HF_direct_t *dblock = NULL; /* Pointer to direct block to modify */ haddr_t dblock_addr = HADDR_UNDEF; /* Direct block address */ size_t dblock_size; /* Direct block size */ uint8_t *id = (uint8_t *)_id; /* Pointer to ID buffer */ size_t blk_off; /* Offset of object within block */ htri_t node_found; /* Whether an existing free list node was found */ herr_t ret_value = SUCCEED; /* Return value */ FUNC_ENTER_NOAPI_NOINIT(H5HF_man_insert) #ifdef QAK HDfprintf(stderr, "%s: obj_size = %Zu\n", FUNC, obj_size); #endif /* QAK */ /* * Check arguments. */ HDassert(hdr); HDassert(obj_size > 0); HDassert(obj); HDassert(id); /* Look for free space */ if((node_found = H5HF_space_find(hdr, dxpl_id, (hsize_t)obj_size, &sec_node)) < 0) HGOTO_ERROR(H5E_HEAP, H5E_CANTALLOC, FAIL, "can't locate free space in fractal heap") #ifdef QAK HDfprintf(stderr, "%s: After H5HF_space_find(), node_found = %t\n", FUNC, node_found); #endif /* QAK */ /* If we didn't find a node, go create a direct block big enough to hold the requested block */ if(!node_found) /* Allocate direct block big enough to hold requested size */ if(H5HF_man_dblock_new(hdr, dxpl_id, obj_size, &sec_node) < 0) HGOTO_ERROR(H5E_HEAP, H5E_CANTCREATE, FAIL, "can't create fractal heap direct block") /* Check for row section */ if(sec_node->sect_info.type == H5HF_FSPACE_SECT_FIRST_ROW || sec_node->sect_info.type == H5HF_FSPACE_SECT_NORMAL_ROW) { #ifdef QAK HDfprintf(stderr, "%s: sec_node->sect_info.addr = %a\n", FUNC, sec_node->sect_info.addr); HDfprintf(stderr, "%s: sec_node->sect_info.size = %Hu\n", FUNC, sec_node->sect_info.size); HDfprintf(stderr, "%s: sec_node->sect_info.type = %s\n", FUNC, (sec_node->sect_info.type == H5HF_FSPACE_SECT_FIRST_ROW ? "H5HF_FSPACE_SECT_FIRST_ROW" : "H5HF_FSPACE_SECT_NORMAL_ROW")); HDfprintf(stderr, "%s: sec_node->u.row.under = %p\n", FUNC, sec_node->u.row.under); HDfprintf(stderr, "%s: sec_node->u.row.row = %u\n", FUNC, sec_node->u.row.row); HDfprintf(stderr, "%s: sec_node->u.row.col = %u\n", FUNC, sec_node->u.row.col); HDfprintf(stderr, "%s: sec_node->u.row.num_entries = %u\n", FUNC, sec_node->u.row.num_entries); #endif /* QAK */ /* Allocate 'single' selection out of 'row' selection */ if(H5HF_man_iblock_alloc_row(hdr, dxpl_id, &sec_node) < 0) HGOTO_ERROR(H5E_HEAP, H5E_CANTALLOC, FAIL, "can't break up row section") } /* end if */
/*------------------------------------------------------------------------- * Function: print_dataset_metadata * * Purpose: Prints file space information for datasets' metadata * * Return: Success: 0 * * Failure: Never fails * * Programmer: Vailin Choi; October 2009 * *------------------------------------------------------------------------- */ static herr_t print_dset_metadata(const iter_t *iter) { printf("File space information for datasets' metadata (in bytes):\n"); HDfprintf(stdout, "\tObject headers (total/unused): %Hu/%Hu\n", iter->dset_ohdr_info.total_size, iter->dset_ohdr_info.free_size); HDfprintf(stdout, "\tIndex for Chunked datasets: %Hu\n", iter->datasets_index_storage_size); HDfprintf(stdout, "\tHeap: %Hu\n", iter->datasets_heap_storage_size); return 0; } /* print_dset_metadata() */
/*------------------------------------------------------------------------- * Function: H5FS_close * * Purpose: Destroy & deallocate free list structure, serializing sections * in the bins * * Return: Success: non-negative * * Failure: negative * * Programmer: Quincey Koziol * Tuesday, March 7, 2006 * *------------------------------------------------------------------------- */ herr_t H5FS_close(H5F_t *f, hid_t dxpl_id, H5FS_t *fspace) { herr_t ret_value = SUCCEED; /* Return value */ FUNC_ENTER_NOAPI_TAG(dxpl_id, H5AC__FREESPACE_TAG, FAIL) /* Check arguments. */ HDassert(f); HDassert(fspace); #ifdef H5FS_DEBUG HDfprintf(stderr, "%s: Entering, fspace = %p, fspace->addr = %a, fspace->sinfo = %p\n", FUNC, fspace, fspace->addr, fspace->sinfo); #endif /* H5FS_DEBUG */ /* Check if section info is valid */ /* (i.e. the header "owns" the section info and it's not in the cache) */ if(fspace->sinfo) { #ifdef H5FS_DEBUG HDfprintf(stderr, "%s: fspace->tot_sect_count = %Hu, fspace->serial_sect_count = %Hu, fspace->sect_addr = %a, fspace->rc = %u\n", FUNC, fspace->tot_sect_count, fspace->serial_sect_count, fspace->sect_addr, fspace->rc); HDfprintf(stderr, "%s: fspace->alloc_sect_size = %Hu, fspace->sect_size = %Hu\n", FUNC, fspace->alloc_sect_size, fspace->sect_size); #endif /* H5FS_DEBUG */ /* If there are sections to serialize, update them */ /* (if the free space manager is persistant) */ if(fspace->serial_sect_count > 0 && H5F_addr_defined(fspace->addr)) { #ifdef H5FS_DEBUG HDfprintf(stderr, "%s: Real sections to store in file\n", FUNC); #endif /* H5FS_DEBUG */ if(fspace->sinfo->dirty) { /* Check if the section info is "floating" */ if(!H5F_addr_defined(fspace->sect_addr)) { /* Sanity check */ HDassert(fspace->sect_size > 0); /* Allocate space for the section info in file */ if(H5F_USE_TMP_SPACE(f)) { if(HADDR_UNDEF == (fspace->sect_addr = H5MF_alloc_tmp(f, fspace->sect_size))) HGOTO_ERROR(H5E_FSPACE, H5E_NOSPACE, FAIL, "file allocation failed for free space sections") } /* end if */ else { if(HADDR_UNDEF == (fspace->sect_addr = H5MF_alloc(f, H5FD_MEM_FSPACE_SINFO, dxpl_id, fspace->sect_size))) HGOTO_ERROR(H5E_FSPACE, H5E_NOSPACE, FAIL, "file allocation failed for free space sections") } /* end if */ fspace->alloc_sect_size = (size_t)fspace->sect_size; /* Mark free space header as dirty */ if(H5AC_mark_entry_dirty(fspace) < 0) HGOTO_ERROR(H5E_FSPACE, H5E_CANTMARKDIRTY, FAIL, "unable to mark free space header as dirty") } /* end if */
/*------------------------------------------------------------------------- * Function: wait_for_signal * * Purpose: Waits for the specified signal. * * In terms of this test framework, a signal consists of a file * on disk. Since there are multiple processes that need to * communicate with each other, they do so by writing and * reading signal files on disk, the names and contents of * which are used to inform a process about when it can * proceed and what it should do next. * * This function continuously attempts to read the specified * signal file from disk, and only continues once it has * successfully done so (i.e., only after another process has * called the "send_signal" function to write the signal file). * This functon will then immediately remove the file (i.e., * to indicate that it has been received and can be reused), * and then exits, allowing the calling function to continue. * * Return: void * * Programmer: Mike McGreevy * August 18, 2010 * * Modifications: * *------------------------------------------------------------------------- */ herr_t wait_for_signal(const char * waitfor) { FILE *returnfile; time_t t0,t1; /* Start timer. If this function runs for too long (i.e., expected signal is never received), it will return failure */ time(&t0); /* Wait for return signal from some other process */ while ((returnfile = fopen(waitfor, "r")) == NULL) { /* make note of current time. */ time(&t1); /* If we've been waiting for a signal for too long, then it was likely never sent and we should fail rather than loop infinitely */ if (difftime(t1,t0) > SIGNAL_TIMEOUT) { HDfprintf(stdout, "Error communicating between processes. Make sure test script is running.\n"); TEST_ERROR; } /* end if */ } /* end while */ HDfclose(returnfile); HDunlink(waitfor); return SUCCEED; error: return FAIL; } /* wait_for_signal */
/*------------------------------------------------------------------------- * Function: H5O_mtime_debug * * Purpose: Prints debugging info for the message. * * Return: Non-negative on success/Negative on failure * * Programmer: Robb Matzke * [email protected] * Jul 24 1998 * * Modifications: * *------------------------------------------------------------------------- */ static herr_t H5O_mtime_debug(H5F_t H5_ATTR_UNUSED *f, hid_t H5_ATTR_UNUSED dxpl_id, const void *_mesg, FILE *stream, int indent, int fwidth) { const time_t *mesg = (const time_t *)_mesg; struct tm *tm; char buf[128]; FUNC_ENTER_NOAPI_NOINIT_NOERR /* check args */ HDassert(f); HDassert(mesg); HDassert(stream); HDassert(indent >= 0); HDassert(fwidth >= 0); /* debug */ tm = HDlocaltime(mesg); HDstrftime(buf, sizeof(buf), "%Y-%m-%d %H:%M:%S %Z", tm); HDfprintf(stream, "%*s%-*s %s\n", indent, "", fwidth, "Time:", buf); FUNC_LEAVE_NOAPI(SUCCEED) }
/*------------------------------------------------------------------------- * Function: test_filter_error * * Purpose: Make sure the error message prints out the filter name * when the existent file is opened but the filter isn't * registered. The existent file was created with * gen_filters.c. * * Return: Success: 0 * * Failure: -1 * * Programmer: Raymond Lu * 2 June 2011 * *------------------------------------------------------------------------- */ static herr_t test_filter_error(const char *fname) { const char *pathname = H5_get_srcdir_filename(fname); /* Corrected test file name */ hid_t file, dataset; /* handles */ int buf[20]; HDfprintf(stderr, "\nTesting error message during data reading when filter isn't registered\n"); /* Open the file */ if((file = H5Fopen(pathname, H5F_ACC_RDONLY, H5P_DEFAULT)) < 0) TEST_ERROR; /* Open the regular dataset */ if((dataset = H5Dopen2(file, DSET_FILTER_NAME, H5P_DEFAULT)) < 0) TEST_ERROR; if(H5Dread(dataset, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf) >= 0) TEST_ERROR; /* Close/release resources */ if(H5Dclose(dataset) < 0) TEST_ERROR if(H5Fclose(file) < 0) TEST_ERROR return 0; error: return -1; }
/*------------------------------------------------------------------------- * Function: H5MF_aggr_vfd_alloc * * Purpose: Allocate SIZE bytes of file memory via H5MF_aggr_alloc() * and return the relative address where that contiguous chunk * of file memory exists. * The TYPE argument describes the purpose for which the storage * is being requested. * * Return: Success: The file address of new chunk. * Failure: HADDR_UNDEF * * Programmer: Vailin Choi; July 1st, 2009 * (The coding is from H5MF_alloc().) * *------------------------------------------------------------------------- */ haddr_t H5MF_aggr_vfd_alloc(H5F_t *f, H5FD_mem_t alloc_type, hid_t dxpl_id, hsize_t size) { haddr_t ret_value; /* Return value */ FUNC_ENTER_NOAPI(HADDR_UNDEF) #ifdef H5MF_ALLOC_DEBUG HDfprintf(stderr, "%s: alloc_type = %u, size = %Hu\n", FUNC, (unsigned)alloc_type, size); #endif /* H5MF_ALLOC_DEBUG */ /* check arguments */ HDassert(f); HDassert(f->shared); HDassert(f->shared->lf); HDassert(size > 0); /* Couldn't find anything from the free space manager, go allocate some */ if(alloc_type != H5FD_MEM_DRAW && alloc_type != H5FD_MEM_GHEAP) { /* Handle metadata differently from "raw" data */ if(HADDR_UNDEF == (ret_value = H5MF_aggr_alloc(f, dxpl_id, &(f->shared->meta_aggr), &(f->shared->sdata_aggr), alloc_type, size))) HGOTO_ERROR(H5E_RESOURCE, H5E_CANTALLOC, HADDR_UNDEF, "can't allocate metadata") } /* end if */ else { /* Allocate "raw" data: H5FD_MEM_DRAW and H5FD_MEM_GHEAP */ if(HADDR_UNDEF == (ret_value = H5MF_aggr_alloc(f, dxpl_id, &(f->shared->sdata_aggr), &(f->shared->meta_aggr), H5FD_MEM_DRAW, size)))
/*------------------------------------------------------------------------- * Function: print_found * * Purpose: print number of differences found * *------------------------------------------------------------------------- */ void print_found(hsize_t nfound) { if(g_Parallel) parallel_print("%"H5_PRINTF_LL_WIDTH"u differences found\n", (unsigned long long)nfound); else HDfprintf(stdout,"%Hu differences found\n",nfound); }
static void recover_size_and_print(long long val, const char *end) { if (val >= ONE_KB && (val % ONE_KB) == 0) { if (val >= ONE_MB && (val % ONE_MB) == 0) { if (val >= ONE_GB && (val % ONE_GB) == 0) HDfprintf(output, "%" H5_PRINTF_LL_WIDTH "d""GB%s", val / ONE_GB, end); else HDfprintf(output, "%" H5_PRINTF_LL_WIDTH "d""MB%s", val / ONE_MB, end); } else { HDfprintf(output, "%" H5_PRINTF_LL_WIDTH "d""KB%s", val / ONE_KB, end); } } else { HDfprintf(output, "%" H5_PRINTF_LL_WIDTH "d""%s", val, end); } }
static int test_sec2(hid_t fapl) { char filename[1024]; fsizes_t testsize; testsize = supports_big(); if(testsize == NOFILE) { HDfprintf(stdout, "Test for sec2 is skipped because file system does not support big files.\n"); goto quit; } /* Test big file with the SEC2 driver */ HDputs("Testing big file with the SEC2 Driver "); h5_fixname(FILENAME[1], fapl, filename, sizeof filename); if(writer(filename, fapl, testsize, WRT_N)) goto error; if(reader(filename, fapl)) goto error; HDputs("Test passed with the SEC2 Driver."); quit: /* End with normal return code */ /* Clean up the test file */ if(h5_cleanup(FILENAME, fapl)) HDremove(DNAME); return 0; error: HDputs("*** TEST FAILED ***"); return 1; } /* end test_sec2() */
/*------------------------------------------------------------------------- * Function: get_H5FA_class * * Purpose: Determine the fixed array class from the buffer read in. * Extensible arrays are debugged through the array subclass. * The subclass identifier is two bytes after the signature. * * Return: Non-NULL on success/NULL on failure * * Programmer: Quincey Koziol * [email protected] * Sep 11 2008 * *------------------------------------------------------------------------- */ static const H5FA_class_t * get_H5FA_class(const uint8_t *sig) { H5FA_cls_id_t clsid = (H5FA_cls_id_t)sig[H5_SIZEOF_MAGIC + 1]; const H5FA_class_t *cls; switch(clsid) { case H5FA_CLS_TEST_ID: cls = H5FA_CLS_TEST; break; case H5FA_CLS_CHUNK_ID: cls = H5FA_CLS_CHUNK; break; case H5FA_CLS_FILT_CHUNK_ID: cls = H5FA_CLS_FILT_CHUNK; break; case H5FA_NUM_CLS_ID: default: HDfprintf(stderr, "Unknown fixed array class %u\n", (unsigned)(clsid)); HDexit(4); } /* end switch */ return(cls); } /* end get_H5FA_class() */
/*------------------------------------------------------------------------- * Function: print_version * * Purpose: Print the program name and the version information which is * defined the same as the HDF5 library version. * * Return: void * * Programmer: unknown * * Modifications: * *------------------------------------------------------------------------- */ void print_version(const char *progname) { HDfprintf(rawoutstream, "%s: Version %u.%u.%u%s%s\n", progname, H5_VERS_MAJOR, H5_VERS_MINOR, H5_VERS_RELEASE, ((char *)H5_VERS_SUBRELEASE)[0] ? "-" : "", H5_VERS_SUBRELEASE); }
/*------------------------------------------------------------------------- * Function: H5O_ainfo_debug * * Purpose: Prints debugging info for a message. * * Return: Non-negative on success/Negative on failure * * Programmer: Quincey Koziol * [email protected] * Mar 6 2007 * *------------------------------------------------------------------------- */ static herr_t H5O_ainfo_debug(H5F_t H5_ATTR_UNUSED *f, hid_t H5_ATTR_UNUSED dxpl_id, const void *_mesg, FILE * stream, int indent, int fwidth) { const H5O_ainfo_t *ainfo = (const H5O_ainfo_t *) _mesg; FUNC_ENTER_NOAPI_NOINIT_NOERR /* check args */ HDassert(f); HDassert(ainfo); HDassert(stream); HDassert(indent >= 0); HDassert(fwidth >= 0); HDfprintf(stream, "%*s%-*s %Hu\n", indent, "", fwidth, "Number of attributes:", ainfo->nattrs); HDfprintf(stream, "%*s%-*s %t\n", indent, "", fwidth, "Track creation order of attributes:", ainfo->track_corder); HDfprintf(stream, "%*s%-*s %t\n", indent, "", fwidth, "Index creation order of attributes:", ainfo->index_corder); HDfprintf(stream, "%*s%-*s %u\n", indent, "", fwidth, "Max. creation index value:", (unsigned)ainfo->max_crt_idx); HDfprintf(stream, "%*s%-*s %a\n", indent, "", fwidth, "'Dense' attribute storage fractal heap address:", ainfo->fheap_addr); HDfprintf(stream, "%*s%-*s %a\n", indent, "", fwidth, "'Dense' attribute storage name index v2 B-tree address:", ainfo->name_bt2_addr); HDfprintf(stream, "%*s%-*s %a\n", indent, "", fwidth, "'Dense' attribute storage creation order index v2 B-tree address:", ainfo->corder_bt2_addr); FUNC_LEAVE_NOAPI(SUCCEED) } /* end H5O_ainfo_debug() */
/*------------------------------------------------------------------------- * Function: dump_error * * Purpose: Prints error stack in default and customized ways. * * Return: Success: 0 * * Failure: -1 * * Programmer: Raymond Lu * July 17, 2003 * *------------------------------------------------------------------------- */ static herr_t dump_error(hid_t estack) { /* Print errors in library default way */ HDfprintf(stderr, "********* Print error stack in HDF5 default way *********\n"); if(H5Eprint2(estack, stderr) < 0) TEST_ERROR; /* Customized way to print errors */ HDfprintf(stderr, "\n********* Print error stack in customized way *********\n"); if(H5Ewalk2(estack, H5E_WALK_UPWARD, custom_print_cb, stderr) < 0) TEST_ERROR; return 0; error: return -1; } /* end dump_error() */
/*-------------------------------------------------------------------------- NAME H5O_sdspace_debug PURPOSE Prints debugging information for a simple dimensionality message USAGE void *H5O_sdspace_debug(f, mesg, stream, indent, fwidth) H5F_t *f; IN: pointer to the HDF5 file struct const void *mesg; IN: Pointer to the source extent dimensionality struct FILE *stream; IN: Pointer to the stream for output data int indent; IN: Amount to indent information by int fwidth; IN: Field width (?) RETURNS Non-negative on success/Negative on failure DESCRIPTION This function prints debugging output to the stream passed as a parameter. --------------------------------------------------------------------------*/ static herr_t H5O_sdspace_debug(H5F_t UNUSED *f, hid_t UNUSED dxpl_id, const void *mesg, FILE * stream, int indent, int fwidth) { const H5S_extent_t *sdim = (const H5S_extent_t *)mesg; FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5O_sdspace_debug) /* check args */ HDassert(f); HDassert(sdim); HDassert(stream); HDassert(indent >= 0); HDassert(fwidth >= 0); HDfprintf(stream, "%*s%-*s %lu\n", indent, "", fwidth, "Rank:", (unsigned long) (sdim->rank)); if(sdim->rank > 0) { unsigned u; /* local counting variable */ HDfprintf(stream, "%*s%-*s {", indent, "", fwidth, "Dim Size:"); for(u = 0; u < sdim->rank; u++) HDfprintf (stream, "%s%Hu", u?", ":"", sdim->size[u]); HDfprintf (stream, "}\n"); HDfprintf(stream, "%*s%-*s ", indent, "", fwidth, "Dim Max:"); if(sdim->max) { HDfprintf (stream, "{"); for(u = 0; u < sdim->rank; u++) { if(H5S_UNLIMITED==sdim->max[u]) HDfprintf (stream, "%sINF", u?", ":""); else HDfprintf (stream, "%s%Hu", u?", ":"", sdim->max[u]); } /* end for */ HDfprintf (stream, "}\n"); } /* end if */ else HDfprintf (stream, "CONSTANT\n"); } /* end if */ FUNC_LEAVE_NOAPI(SUCCEED) } /* end H5O_sdspace_debug() */
/*------------------------------------------------------------------------- * Function: H5T__print_stats * * Purpose: Print statistics about a conversion path. Statistics are * printed only if all the following conditions are true: * * 1. The library was compiled with H5T_DEBUG defined. * 2. Data type debugging is turned on at run time. * 3. The path was called at least one time. * * The optional NPRINT argument keeps track of the number of * conversions paths for which statistics have been shown. If * its value is zero then table headers are printed before the * first line of output. * * Return: Success: non-negative * * Failure: negative * * Programmer: Robb Matzke * Monday, December 14, 1998 * * Modifications: * *------------------------------------------------------------------------- */ herr_t H5T__print_stats(H5T_path_t H5_ATTR_UNUSED * path, int H5_ATTR_UNUSED * nprint/*in,out*/) { #ifdef H5T_DEBUG hsize_t nbytes; char bandwidth[32]; #endif FUNC_ENTER_PACKAGE_NOERR #ifdef H5T_DEBUG if(H5DEBUG(T) && path->stats.ncalls > 0) { if(nprint && 0 == (*nprint)++) { HDfprintf(H5DEBUG(T), "H5T: type conversion statistics:\n"); HDfprintf(H5DEBUG(T), " %-16s %10s %10s %8s %8s %8s %10s\n", "Conversion", "Elmts", "Calls", "User", "System", "Elapsed", "Bandwidth"); HDfprintf(H5DEBUG(T), " %-16s %10s %10s %8s %8s %8s %10s\n", "----------", "-----", "-----", "----", "------", "-------", "---------"); } if(path->src && path->dst) nbytes = MAX(H5T_get_size(path->src), H5T_get_size(path->dst)); else if(path->src) nbytes = H5T_get_size(path->src); else if(path->dst) nbytes = H5T_get_size(path->dst); else nbytes = 0; nbytes *= path->stats.nelmts; H5_bandwidth(bandwidth, (double)nbytes, path->stats.timer.etime); HDfprintf(H5DEBUG(T), " %-16s %10Hd %10d %8.2f %8.2f %8.2f %10s\n", path->name, path->stats.nelmts, path->stats.ncalls, path->stats.timer.utime, path->stats.timer.stime, path->stats.timer.etime, bandwidth); } #endif FUNC_LEAVE_NOAPI(SUCCEED) } /* end H5T__print_stats() */
/*------------------------------------------------------------------------- * Function: H5MP_new_page * * Purpose: Allocate new page for a memory pool * * Return: Pointer to the page allocated on success/NULL on failure * * Programmer: Quincey Koziol * [email protected] * May 4 2005 * *------------------------------------------------------------------------- */ static H5MP_page_t * H5MP_new_page(H5MP_pool_t *mp, size_t page_size) { H5MP_page_t *new_page; /* New page created */ H5MP_page_blk_t *first_blk; /* Pointer to first block in page */ H5MP_page_t *ret_value; /* Return value */ FUNC_ENTER_NOAPI_NOINIT(H5MP_new_page) /* Sanity check */ HDassert(mp); HDassert(page_size >= mp->page_size); /* Allocate page */ if(page_size > mp->page_size) { if(NULL == (new_page = H5MM_malloc(page_size))) HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed for page") new_page->free_size = page_size - H5MP_BLOCK_ALIGN(sizeof(H5MP_page_t)); new_page->fac_alloc = FALSE; } /* end if */ else { if((new_page = H5FL_FAC_MALLOC(mp->page_fac)) == NULL) HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed for page") new_page->free_size = mp->max_size; new_page->fac_alloc = TRUE; } /* end else */ #ifdef QAK HDfprintf(stderr,"%s: Allocating new page = %p\n", FUNC, new_page); #endif /* QAK */ /* Initialize page information */ first_blk = H5MP_PAGE_FIRST_BLOCK(new_page); first_blk->size = new_page->free_size; first_blk->page = new_page; first_blk->is_free = TRUE; first_blk->prev = NULL; first_blk->next = NULL; /* Insert into page list */ new_page->prev = NULL; new_page->next = mp->first; if(mp->first) mp->first->prev = new_page; mp->first = new_page; /* Account for new free space */ new_page->free_blk = first_blk; mp->free_size += new_page->free_size; /* Assign return value */ ret_value = new_page; done: FUNC_LEAVE_NOAPI(ret_value) } /* end H5MP_new_page() */
static herr_t dset_read(int local_dim, file_descr *fd, parameters *parms, void *buffer, const char *buffer2) { int cur_dim = order[local_dim]-1; hsize_t i; int j; herr_t hrc; int ret_code = SUCCESS; /* iterate on the current dimension */ for (i=0; i < parms->dset_size[cur_dim]; i += parms->buf_size[cur_dim]){ h5offset[cur_dim] = (hssize_t)i; offset[cur_dim] = (HDoff_t)i; /* if traverse in order array is incomplete, recurse */ if (local_dim > 0){ ret_code = dset_read(local_dim-1, fd, parms, buffer, buffer2); /* otherwise, write buffer into dataset */ }else{ switch (parms->io_type) { case POSIXIO: for (j=0; j<parms->rank; j++) { buf_offset[j] = 0; } buf_p = (unsigned char*)buffer; posix_buffer_read(0, fd, parms, buffer); break; case HDF5: hrc = H5Soffset_simple(h5dset_space_id, h5offset); VRFY((hrc >= 0), "H5Soffset_simple"); /* Read the buffer out */ hrc = H5Dread(h5ds_id, ELMT_H5_TYPE, h5mem_space_id, h5dset_space_id, h5dxpl, buffer); VRFY((hrc >= 0), "H5Dread"); break; default: /* unknown request */ HDfprintf(stderr, "Unknown IO type request (%d)\n", (int)parms->io_type); HDassert(0 && "Unknown IO type"); break; } /* switch (parms->io_type) */ } } done: return ret_code; }