mirror/hdf5
2
0
Fork 0
mirror of https://github.com/HDFGroup/hdf5.git synced 2025-01-24 15:25:00 +08:00
Code Issues Packages Projects Releases Wiki Activity
3d6d039b86
hdf5/src/H5Fprivate.h
Patrick Lu 3d6d039b86 [svn-r1051] changed the HDF5DLL and HDF5GLOBAL to __DLL__ and __DLLVAR__ 
also exported all globals and non static functions to the dll
1999-02-02 10:52:59 -05:00

667 lines
24 KiB
C
Raw Blame History

/****************************************************************************
* NCSA HDF *
* Software Development Group *
* National Center for Supercomputing Applications *
* University of Illinois at Urbana-Champaign *
* 605 E. Springfield, Champaign IL 61820 *
* *
* For conditions of distribution and use, see the accompanying *
* hdf/COPYING file. *
* *
****************************************************************************/
/* $Id$ */
/*
* This file contains macros & information for file access
*/
#ifndef _H5Fprivate_H
#define _H5Fprivate_H
#include <H5Fpublic.h>
/* This is a near top-level header! Try not to include much! */
#include <H5private.h>
#include <H5Dpublic.h> /*for the H5D_transfer_t type */
/*
* Feature: Define this constant to be non-zero if you want to enable code
* that minimizes the number of calls to lseek(). This has a huge
* performance benefit on some systems. Set this constant to zero
* on the compiler command line to disable that optimization.
*/
#ifndef H5F_OPT_SEEK
# define H5F_OPT_SEEK 1
#endif
/*
* Feature: Define this constant on the compiler command-line if you want to
* see some debugging messages on the debug stream.
*/
#ifdef NDEBUG
# undef H5F_DEBUG
#endif
/* Maximum size of boot-block buffer */
#define H5F_BOOTBLOCK_SIZE 1024
/* Define the HDF5 file signature */
#define H5F_SIGNATURE "\211HDF\r\n\032\n"
#define H5F_SIGNATURE_LEN 8
/* size of size_t and off_t as they exist on disk */
#define H5F_SIZEOF_ADDR(F) ((F)->shared->create_parms->sizeof_addr)
#define H5F_SIZEOF_SIZE(F) ((F)->shared->create_parms->sizeof_size)
/*
* Private file open flags.
*/
#define H5F_ACC_PUBLIC_FLAGS 0x00ffu
#define H5F_ACC_CREAT 0x0100u /* Create non-existing files */
/*
* Encode and decode macros for file meta-data.
* Currently, all file meta-data is little-endian.
*/
/* For non-little-endian platforms, encode each byte by itself */
#ifdef WORDS_BIGENDIAN
# define INT16ENCODE(p, i) { \
*(p) = (uint8_t)( (uintn)(i) & 0xff); (p)++; \
*(p) = (uint8_t)(((uintn)(i) >> 8) & 0xff); (p)++; \
}
# define UINT16ENCODE(p, i) { \
*(p) = (uint8_t)( (i) & 0xff); (p)++; \
*(p) = (uint8_t)(((uintn)(i) >> 8) & 0xff); (p)++; \
}
# define INT32ENCODE(p, i) { \
*(p) = (uint8_t)( (uint32_t)(i) & 0xff); (p)++; \
*(p) = (uint8_t)(((uint32_t)(i) >> 8) & 0xff); (p)++; \
*(p) = (uint8_t)(((uint32_t)(i) >> 16) & 0xff); (p)++; \
*(p) = (uint8_t)(((uint32_t)(i) >> 24) & 0xff); (p)++; \
}
# define UINT32ENCODE(p, i) { \
*(p) = (uint8_t)( (i) & 0xff); (p)++; \
*(p) = (uint8_t)(((i) >> 8) & 0xff); (p)++; \
*(p) = (uint8_t)(((i) >> 16) & 0xff); (p)++; \
*(p) = (uint8_t)(((i) >> 24) & 0xff); (p)++; \
}
# define INT64ENCODE(p, n) { \
int64_t _n = (n); \
size_t _i; \
uint8_t *_p = (uint8_t*)(p); \
for (_i=0; _i<sizeof(int64_t); _i++, _n>>=8) { \
*_p++ = (uint8_t)(_n & 0xff); \
} \
for (/*void*/; _i<8; _i++) { \
*_p++ = (n)<0 ? 0xff : 0; \
} \
(p) = (uint8_t*)(p)+8; \
}
# define UINT64ENCODE(p, n) { \
uint64_t _n = (n); \
size_t _i; \
uint8_t *_p = (uint8_t*)(p); \
for (_i=0; _i<sizeof(uint64_t); _i++, _n>>=8) { \
*_p++ = (uint8_t)(_n & 0xff); \
} \
for (/*void*/; _i<8; _i++) { \
*_p++ = 0; \
} \
(p) = (uint8_t*)(p)+8; \
}
# define INT16DECODE(p, i) { \
(i) = (int16_t)((*(p) & 0xff)); (p)++; \
(i) |= (int16_t)((*(p) & 0xff) << 8); (p)++; \
}
# define UINT16DECODE(p, i) { \
(i) = (uint16_t) (*(p) & 0xff); (p)++; \
(i) |= (uint16_t)((*(p) & 0xff) << 8); (p)++; \
}
# define INT32DECODE(p, i) { \
(i) = ( *(p) & 0xff); (p)++; \
(i) |= ((int32_t)(*(p) & 0xff) << 8); (p)++; \
(i) |= ((int32_t)(*(p) & 0xff) << 16); (p)++; \
(i) |= ((int32_t)(*(p) & 0xff) << 24); (p)++; \
}
# define UINT32DECODE(p, i) { \
(i) = (uint32_t)(*(p) & 0xff); (p)++; \
(i) |= ((uint32_t)(*(p) & 0xff) << 8); (p)++; \
(i) |= ((uint32_t)(*(p) & 0xff) << 16); (p)++; \
(i) |= ((uint32_t)(*(p) & 0xff) << 24); (p)++; \
}
# define INT64DECODE(p, n) { \
/* WE DON'T CHECK FOR OVERFLOW! */ \
size_t _i; \
n = 0; \
(p) += 8; \
for (_i=0; _i<sizeof(int64_t); _i++) { \
n = (n<<8) | *(--p); \
} \
(p) += 8; \
}
# define UINT64DECODE(p, n) { \
/* WE DON'T CHECK FOR OVERFLOW! */ \
size_t _i; \
n = 0; \
(p) += 8; \
for (_i=0; _i<sizeof(uint64_t); _i++) { \
n = (n<<8) | *(--p); \
} \
(p) += 8; \
}
#else
/* For little-endian platforms, make the compiler do the work */
# define INT16ENCODE(p, i) {*((int16_t*)(p))=(int16_t)(i);(p)+=2;}
# define UINT16ENCODE(p, i) {*((uint16_t*)(p))=(uint16_t)(i);(p)+=2;}
# define INT32ENCODE(p, i) {*((int32_t*)(p))=(int32_t)(i);(p)+=4;}
# define UINT32ENCODE(p, i) {*((uint32_t*)(p))=(uint32_t)(i);(p)+=4;}
# define INT64ENCODE(p, i) { \
*((int64_t *)(p)) = (int64_t)(i); \
(p) += sizeof(int64_t); \
if (4==sizeof(int64_t)) { \
*(p)++ = (i)<0?0xff:0x00; \
*(p)++ = (i)<0?0xff:0x00; \
*(p)++ = (i)<0?0xff:0x00; \
*(p)++ = (i)<0?0xff:0x00; \
} \
}
# define UINT64ENCODE(p, i) { \
*((uint64_t *)(p)) = (uint64_t)(i); \
(p) += sizeof(uint64_t); \
if (4==sizeof(uint64_t)) { \
*(p)++ = 0x00; \
*(p)++ = 0x00; \
*(p)++ = 0x00; \
*(p)++ = 0x00; \
} \
}
# define INT16DECODE(p, i) {(i)=(int16_t)(*(const int16_t*)(p));(p)+=2;}
# define UINT16DECODE(p, i) {(i)=(uint16_t)(*(const uint16_t*)(p));(p)+=2;}
# define INT32DECODE(p, i) {(i)=(int32_t)(*(const int32_t*)(p));(p)+=4;}
# define UINT32DECODE(p, i) {(i)=(uint32_t)(*(const uint32_t*)(p));(p)+=4;}
# define INT64DECODE(p, i) {(i)=(int64_t)(*(const int64_t*)(p));(p)+=8;}
# define UINT64DECODE(p, i) {(i)=(uint64_t)(*(const uint64_t*)(p));(p)+=8;}
#endif
#define NBYTEENCODE(d, s, n) { HDmemcpy(d,s,n); p+=n }
/*
* Note: the NBYTEDECODE macro is backwards from the memcpy() routine, in
* the spirit of the other DECODE macros.
*/
#define NBYTEDECODE(s, d, n) { HDmemcpy(d,s,n); p+=n }
/*
* Macros that check for overflows. These are somewhat dangerous to fiddle
* with.
*/
#if (SIZEOF_SIZE_T >= SIZEOF_OFF_T)
# define H5F_OVERFLOW_SIZET2OFFT(X) \
((size_t)(X)>=(size_t)((size_t)1<<(8*sizeof(off_t)-1)))
#else
# define H5F_OVERFLOW_SIZET2OFFT(X) 0
#endif
/*
* File-creation property list.
*/
typedef struct H5F_create_t {
hsize_t userblock_size; /* Size of the file user block in bytes */
intn sym_leaf_k; /* 1/2 rank for symbol table leaf nodes */
intn btree_k[8]; /* 1/2 rank for btree internal nodes */
size_t sizeof_addr; /* Number of bytes in an address */
size_t sizeof_size; /* Number of bytes for obj sizes */
intn bootblock_ver; /* Version # of the bootblock */
intn freespace_ver; /* Version # of the free-space information*/
intn objectdir_ver; /* Version # of the object directory format*/
intn sharedheader_ver;/* Version # of the shared header format */
} H5F_create_t;
/*
* File-access property list.
*/
typedef struct H5F_access_t {
intn mdc_nelmts; /* Size of meta data cache (elements) */
intn rdcc_nelmts; /* Size of raw data chunk cache (elmts) */
size_t rdcc_nbytes; /* Size of raw data chunk cache (bytes) */
double rdcc_w0; /* Preempt read chunks first? [0.0..1.0]*/
hsize_t threshold; /* Threshold for alignment */
hsize_t alignment; /* Alignment */
uintn gc_ref; /* Garbage-collect references? */
H5F_driver_t driver; /* Low level file driver */
union {
/* Properties for in-core files */
struct {
size_t increment; /*amount by which to increment size*/
} core;
/* Properties for file families */
struct {
struct H5F_access_t *memb_access; /*plist for the members */
haddr_t memb_size; /*number of bits in offset */
} fam;
/* Properties for the split driver */
struct {
char *meta_ext; /*name extension for meta file */
char *raw_ext; /*name extension for raw file */
struct H5F_access_t *meta_access; /*plist for meta file */
struct H5F_access_t *raw_access; /*plist for raw data file */
} split;
#ifdef HAVE_PARALLEL
/* Properties for parallel I/O */
struct {
MPI_Comm comm; /* communicator for file access */
MPI_Info info; /* optional info for MPI-IO */
MPI_Datatype btype; /* buffer type for xfers */
MPI_Datatype ftype; /* file type for xfers */
haddr_t disp; /* displacement for set_view in xfers */
int use_types; /* if !0, use btype, ftype, disp. */
/* otherwise do simple byteblk xfer */
int old_use_types; /* remember value of use_types */
/* from last xfer */
} mpio;
#endif
} u;
} H5F_access_t;
/*
* These things make a file unique.
*/
typedef struct H5F_search_t {
dev_t dev; /* Device number containing file */
ino_t ino; /* Unique file number on device */
} H5F_search_t;
/* For determining what the last file operation was */
typedef enum {
H5F_OP_UNKNOWN, /* Don't know what the last operation was*/
H5F_OP_SEEK, /* Last operation was a seek */
H5F_OP_WRITE, /* Last operation was a write */
H5F_OP_READ /* Last operation was a read */
} H5F_fileop_t;
/* A free-list entry */
#define H5MF_NFREE 32 /*size of free block array */
typedef struct H5MF_free_t {
haddr_t addr; /*file address */
hsize_t size; /*size of free area */
} H5MF_free_t;
/*
* Define the low-level file interface.
*/
typedef struct H5F_low_class_t {
htri_t (*access)(const char *name, const H5F_access_t *access_parms,
int mode, H5F_search_t *key/*out*/);
struct H5F_low_t *(*open)(const char *name,
const H5F_access_t *access_parms, uintn flags,
H5F_search_t *key/*out*/);
herr_t (*close)(struct H5F_low_t *lf,
const H5F_access_t *access_parms);
herr_t (*read)(struct H5F_low_t *lf, const H5F_access_t *access_parms,
const H5D_transfer_t xfer_mode,
const haddr_t *addr, size_t size, uint8_t *buf);
herr_t (*write)(struct H5F_low_t *lf, const H5F_access_t *access_parms,
const H5D_transfer_t xfer_mode,
const haddr_t *addr, size_t size, const uint8_t *buf);
herr_t (*flush)(struct H5F_low_t *lf,
const H5F_access_t *access_parms);
herr_t (*extend)(struct H5F_low_t *lf,
const H5F_access_t *access_parms,
intn op, hsize_t size, haddr_t *addr/*out*/);
intn (*alloc)(struct H5F_low_t *lf, intn op, hsize_t alignment,
hsize_t threshold, hsize_t size, H5MF_free_t *blk,
haddr_t *addr/*out*/);
} H5F_low_class_t;
typedef struct H5F_low_t {
const H5F_low_class_t *type;/* What type of file is this? */
haddr_t eof; /* Address of logical end-of-file */
union {
/* File families */
struct {
char *name; /* Family name */
uintn flags; /* Flags for opening member files */
intn nmemb; /* Number of family members */
intn nalloc; /* Size of member table in elements */
struct H5F_low_t **memb; /* An array of family members */
haddr_t memb_size; /*Size of each family member */
} fam;
/* Split meta/raw data */
struct {
char *name; /* Base name w/o extension */
uint64_t mask; /* Bit that determines which file to use*/
struct H5F_low_t *meta; /* Meta data file */
struct H5F_low_t *raw; /* Raw data file */
} split;
/* Posix section 2 I/O */
struct {
int fd; /* The unix file descriptor */
H5F_fileop_t op; /* Previous file operation */
#ifdef HAVE_LSEEK64
off64_t cur; /* Current file position */
#else
off_t cur; /* Current file position */
#endif
} sec2;
/* Posix stdio */
struct {
FILE *f; /* Posix stdio file */
H5F_fileop_t op; /* Previous file operation */
#ifdef HAVE_FSEEK64
int64_t cur; /* Current file position */
#else
long cur; /* Current file position */
#endif
} stdio;
/* In-core temp file */
struct {
uint8_t *mem; /* Mem image of the file */
size_t size; /* Current file size */
size_t alloc; /* Current size of MEM buffer */
} core;
#ifdef HAVE_PARALLEL
/* MPI-IO */
struct {
MPI_File f; /* MPI-IO file handle */
hbool_t allsame;/* all procs should write same data, *
* so only p0 will do the actual write */
} mpio;
#endif
} u;
} H5F_low_t;
/* What types of low-level files are there? */
#ifndef H5F_LOW_DFLT
# define H5F_LOW_DFLT H5F_LOW_SEC2 /* The default type */
#endif
__DLLVAR__ const H5F_low_class_t H5F_LOW_SEC2_g[]; /* Posix section 2 */
__DLLVAR__ const H5F_low_class_t H5F_LOW_STDIO_g[]; /* Posix stdio */
__DLLVAR__ const H5F_low_class_t H5F_LOW_CORE_g[]; /* In-core temp file */
__DLLVAR__ const H5F_low_class_t H5F_LOW_FAMILY_g[];/* File family */
__DLLVAR__ const H5F_low_class_t H5F_LOW_SPLIT_g[]; /* Split meta/raw data */
#ifdef HAVE_PARALLEL
__DLLVAR__ const H5F_low_class_t H5F_LOW_MPIO_g[]; /* MPI-IO */
#endif
/* The raw data chunk cache */
typedef struct H5F_rdcc_t {
uintn ninits; /* Number of chunk creations */
uintn nhits; /* Number of cache hits */
uintn nmisses;/* Number of cache misses */
uintn nflushes;/* Number of cache flushes */
size_t nbytes; /* Current cached raw data in bytes */
intn nslots; /* Number of chunk slots allocated */
struct H5F_rdcc_ent_t *head; /* Head of doubly linked list */
struct H5F_rdcc_ent_t *tail; /* Tail of doubly linked list */
intn nused; /* Number of chunk slots in use */
struct H5F_rdcc_ent_t **slot; /* Chunk slots, each points to a chunk*/
} H5F_rdcc_t;
/* Mount property list */
typedef struct H5F_mprop_t {
hbool_t local; /* Are absolute symlinks local to file? */
} H5F_mprop_t;
/* A record of the mount table */
typedef struct H5F_mount_t {
struct H5G_t *group; /* Mount point group held open */
struct H5F_t *file; /* File mounted at that point */
} H5F_mount_t;
/* The mount table */
typedef struct H5F_mtab_t {
struct H5F_t *parent;/* Parent file */
uintn nmounts;/* Number of children which are mounted */
uintn nalloc; /* Number of mount slots allocated */
H5F_mount_t *child; /* An array of mount records */
} H5F_mtab_t;
/*
* Define the structure to store the file information for HDF5 files. One of
* these structures is allocated per file, not per H5Fopen().
*/
typedef struct H5F_file_t {
H5F_search_t key; /* The key for looking up files */
uintn flags; /* Access Permissions for file */
H5F_low_t *lf; /* Lower level file handle for I/O */
uintn nrefs; /* Ref count for times file is opened */
uint32_t consist_flags; /* File Consistency Flags */
haddr_t boot_addr; /* Absolute address of boot block */
haddr_t base_addr; /* Absolute base address for rel.addrs. */
haddr_t freespace_addr; /* Relative address of free-space info */
haddr_t hdf5_eof; /* Relative addr of end of all hdf5 data*/
struct H5AC_t *cache; /* The object cache */
H5F_create_t *create_parms; /* File-creation property list */
H5F_access_t *access_parms; /* File-access property list */
struct H5G_t *root_grp; /* Open root group */
intn ncwfs; /* Num entries on cwfs list */
struct H5HG_heap_t **cwfs; /* Global heap cache */
H5F_rdcc_t rdcc; /* Raw data chunk cache */
intn fl_nfree; /*number of free blocks in array */
H5MF_free_t fl_free[H5MF_NFREE]; /*free block array */
} H5F_file_t;
/*
* This is the top-level file descriptor. One of these structures is
* allocated every time H5Fopen() is called although they may contain
* pointers to shared H5F_file_t structs.
*/
typedef struct H5F_t {
uintn nrefs; /* Reference count */
uintn intent; /* The flags passed to H5F_open()*/
char *name; /* Name used to open file */
H5F_file_t *shared; /* The shared file info */
uintn nopen_objs; /* Number of open object headers*/
hbool_t close_pending; /* File close is pending */
H5F_mtab_t mtab; /* File mount table */
} H5F_t;
#ifdef NOT_YET
#define H5F_ENCODE_OFFSET(f,p,o) (H5F_SIZEOF_ADDR(f)==4 ? UINT32ENCODE(p,o) \
: H5F_SIZEOF_ADDR(f)==8 ? UINT64ENCODE(p,o) \
: H5F_SIZEOF_ADDR(f)==2 ? UINT16ENCODE(p,o) \
: H5FPencode_unusual_offset(f,&(p),(uint8_t*)&(o)))
#else /* NOT_YET */
#define H5F_ENCODE_OFFSET(f,p,o) switch(H5F_SIZEOF_ADDR(f)) { \
case 4: UINT32ENCODE(p,o); break; \
case 8: UINT64ENCODE(p,o); break; \
case 2: UINT16ENCODE(p,o); break; \
}
#endif /* NOT_YET */
#define H5F_DECODE_OFFSET(f,p,o) \
switch (H5F_SIZEOF_ADDR (f)) { \
case 4: \
UINT32DECODE (p, o); \
break; \
case 8: \
UINT64DECODE (p, o); \
break; \
case 2: \
UINT16DECODE (p, o); \
break; \
}
#define H5F_encode_length(f,p,l) \
switch(H5F_SIZEOF_SIZE(f)) { \
case 4: UINT32ENCODE(p,l); break; \
case 8: UINT64ENCODE(p,l); break; \
case 2: UINT16ENCODE(p,l); break; \
}
#define H5F_decode_length(f,p,l) \
switch(H5F_SIZEOF_SIZE(f)) { \
case 4: UINT32DECODE(p,l); break; \
case 8: UINT64DECODE(p,l); break; \
case 2: UINT16DECODE(p,l); break; \
}
/* Forward declarations for prototypes arguments */
struct H5O_layout_t;
struct H5O_efl_t;
struct H5O_pline_t;
struct H5D_xfer_t;
struct H5O_fill_t;
struct H5G_entry_t;
/* library variables */
__DLLVAR__ const H5F_create_t H5F_create_dflt;
__DLLVAR__ H5F_access_t H5F_access_dflt;
__DLLVAR__ const H5F_mprop_t H5F_mount_dflt;
#ifdef HAVE_PARALLEL
__DLLVAR__ hbool_t H5_mpi_1_metawrite_g;
#endif /* HAVE_PARALLEL */
/* Private functions, not part of the publicly documented API */
__DLL__ herr_t H5F_init(void);
__DLL__ void H5F_encode_length_unusual(const H5F_t *f, uint8_t **p, uint8_t *l);
__DLL__ H5F_t *H5F_open(const char *name, uintn flags,
const H5F_create_t *create_parms,
const H5F_access_t *access_parms);
__DLL__ herr_t H5F_close(H5F_t *f);
__DLL__ herr_t H5F_debug(H5F_t *f, const haddr_t *addr, FILE * stream,
intn indent, intn fwidth);
__DLL__ herr_t H5F_istore_debug(H5F_t *f, const haddr_t *addr, FILE * stream,
intn indent, intn fwidth, int ndims);
__DLL__ herr_t H5F_mountpoint(struct H5G_entry_t *find/*in,out*/);
/* Functions that operate on array storage */
__DLL__ herr_t H5F_arr_create(H5F_t *f,
struct H5O_layout_t *layout /*in,out*/);
__DLL__ herr_t H5F_arr_read (H5F_t *f, const struct H5D_xfer_t *xfer,
const struct H5O_layout_t *layout,
const struct H5O_pline_t *pline,
const struct H5O_fill_t *fill,
const struct H5O_efl_t *efl,
const hsize_t _hslab_size[],
const hsize_t mem_size[],
const hssize_t mem_offset[],
const hssize_t file_offset[], void *_buf/*out*/);
__DLL__ herr_t H5F_arr_write (H5F_t *f, const struct H5D_xfer_t *xfer,
const struct H5O_layout_t *layout,
const struct H5O_pline_t *pline,
const struct H5O_fill_t *fill,
const struct H5O_efl_t *efl,
const hsize_t _hslab_size[],
const hsize_t mem_size[],
const hssize_t mem_offset[],
const hssize_t file_offset[], const void *_buf);
/* Functions that operate on indexed storage */
__DLL__ herr_t H5F_istore_init (H5F_t *f);
__DLL__ herr_t H5F_istore_flush (H5F_t *f, hbool_t preempt);
__DLL__ herr_t H5F_istore_dest (H5F_t *f);
__DLL__ herr_t H5F_istore_stats (H5F_t *f, hbool_t headers);
__DLL__ herr_t H5F_istore_create(H5F_t *f, struct H5O_layout_t *layout /*in,out*/);
__DLL__ herr_t H5F_istore_read(H5F_t *f, const struct H5D_xfer_t *xfer,
const struct H5O_layout_t *layout,
const struct H5O_pline_t *pline,
const struct H5O_fill_t *fill,
const hssize_t offset[], const hsize_t size[],
void *buf /*out */ );
__DLL__ herr_t H5F_istore_write(H5F_t *f, const struct H5D_xfer_t *xfer,
const struct H5O_layout_t *layout,
const struct H5O_pline_t *pline,
const struct H5O_fill_t *fill,
const hssize_t offset[], const hsize_t size[],
const void *buf);
__DLL__ herr_t H5F_istore_allocate (H5F_t *f,
const struct H5O_layout_t *layout,
const hsize_t *space_dim,
const double split_ratios[],
const struct H5O_pline_t *pline,
const struct H5O_fill_t *fill);
/* Functions that operate on contiguous storage wrt boot block */
__DLL__ herr_t H5F_block_read(H5F_t *f, const haddr_t *addr, hsize_t size,
const H5D_transfer_t xfer_mode, void *buf);
__DLL__ herr_t H5F_block_write(H5F_t *f, const haddr_t *addr, hsize_t size,
const H5D_transfer_t xfer_mode, const void *buf);
/* Functions that operate directly on low-level files */
__DLL__ const H5F_low_class_t *H5F_low_class (H5F_driver_t driver);
__DLL__ herr_t H5F_low_extend(H5F_low_t *lf, const H5F_access_t *access_parms,
intn op, hsize_t size, haddr_t *addr/*out*/);
__DLL__ herr_t H5F_low_seteof(H5F_low_t *lf, const haddr_t *addr);
__DLL__ intn H5F_low_alloc (H5F_low_t *lf, intn op, hsize_t alignment,
hsize_t threshold, hsize_t size, H5MF_free_t *blk,
haddr_t *addr/*out*/);
__DLL__ htri_t H5F_low_access(const H5F_low_class_t *type, const char *name,
const H5F_access_t *access_parms, int mode,
H5F_search_t *key);
__DLL__ H5F_low_t *H5F_low_open(const H5F_low_class_t *type, const char *name,
const H5F_access_t *access_parms, uintn flags,
H5F_search_t *key);
__DLL__ H5F_low_t *H5F_low_close(H5F_low_t *lf, const H5F_access_t *access_parms);
__DLL__ hsize_t H5F_low_size(H5F_low_t *lf, haddr_t *addr);
__DLL__ herr_t H5F_low_read(H5F_low_t *lf, const H5F_access_t *access_parms,
const H5D_transfer_t xfer_mode,
const haddr_t *addr, size_t size, uint8_t *buf);
__DLL__ herr_t H5F_low_write(H5F_low_t *lf, const H5F_access_t *access_parms,
const H5D_transfer_t xfer_mode,
const haddr_t *addr, size_t size, const uint8_t *buf);
__DLL__ herr_t H5F_low_flush(H5F_low_t *lf, const H5F_access_t *access_parms);
/* Functions that operate on addresses */
#define H5F_addr_eq(A1,A2) (H5F_addr_cmp(A1,A2)==0)
#define H5F_addr_ne(A1,A2) (H5F_addr_cmp(A1,A2)!=0)
#define H5F_addr_lt(A1,A2) (H5F_addr_cmp(A1,A2)<0)
#define H5F_addr_le(A1,A2) (H5F_addr_cmp(A1,A2)<=0)
#define H5F_addr_gt(A1,A2) (H5F_addr_cmp(A1,A2)>0)
#define H5F_addr_ge(A1,A2) (H5F_addr_cmp(A1,A2)>=0)
__DLL__ intn H5F_addr_cmp(const haddr_t *, const haddr_t *);
__DLL__ htri_t H5F_addr_defined(const haddr_t *);
__DLL__ void H5F_addr_undef(haddr_t *);
__DLL__ void H5F_addr_reset(haddr_t *);
__DLL__ htri_t H5F_addr_zerop(const haddr_t *);
__DLL__ void H5F_addr_encode(H5F_t *, uint8_t **, const haddr_t *);
__DLL__ void H5F_addr_decode(H5F_t *, const uint8_t **, haddr_t *);
__DLL__ void H5F_addr_print(FILE *, const haddr_t *);
__DLL__ void H5F_addr_pow2(uintn, haddr_t *);
__DLL__ void H5F_addr_inc(haddr_t *addr/*in,out*/, hsize_t inc);
__DLL__ void H5F_addr_adj(haddr_t *addr/*in,out*/, hssize_t adj);
__DLL__ void H5F_addr_add(haddr_t *, const haddr_t *);
__DLL__ uintn H5F_addr_hash(const haddr_t *, uintn mod);
__DLL__ herr_t H5F_addr_pack(H5F_t *f, haddr_t *addr, const long objno[2]);
/* Functions for MPI-IO */
#ifdef HAVE_PARALLEL
__DLL__ htri_t H5F_mpio_tas_allsame(H5F_low_t *lf, hbool_t newval );
__DLL__ herr_t H5PC_Wait_for_left_neighbor( MPI_Comm comm );
__DLL__ herr_t H5PC_Signal_right_neighbor( MPI_Comm comm );
#endif /* HAVE_PARALLEL */
#endif
Reference in New Issue View Git Blame Copy Permalink