You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
431 lines
18 KiB
C
431 lines
18 KiB
C
3 weeks ago
|
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
|
||
|
|
* Copyright by The HDF Group. *
|
||
|
|
* Copyright by the Board of Trustees of the University of Illinois. *
|
||
|
|
* All rights reserved. *
|
||
|
|
* *
|
||
|
|
* This file is part of HDF5. The full HDF5 copyright notice, including *
|
||
|
|
* terms governing use, modification, and redistribution, is contained in *
|
||
|
|
* the files COPYING and Copyright.html. COPYING can be found at the root *
|
||
|
|
* of the source code distribution tree; Copyright.html can be found at the *
|
||
|
|
* root level of an installed copy of the electronic HDF5 document set and *
|
||
|
|
* is linked from the top-level documents page. It can also be found at *
|
||
|
|
* http://hdfgroup.org/HDF5/doc/Copyright.html. If you do not have *
|
||
|
|
* access to either file, you may request a copy from help@hdfgroup.org. *
|
||
|
|
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
|
||
|
|
|
||
|
|
/*-------------------------------------------------------------------------
|
||
|
|
*
|
||
|
|
* Created: H5FLprivate.h
|
||
|
|
* Mar 23 2000
|
||
|
|
* Quincey Koziol <koziol@ncsa.uiuc.edu>
|
||
|
|
*
|
||
|
|
* Purpose: Private non-prototype header.
|
||
|
|
*
|
||
|
|
* Modifications:
|
||
|
|
*
|
||
|
|
*-------------------------------------------------------------------------
|
||
|
|
*/
|
||
|
|
#ifndef _H5FLprivate_H
|
||
|
|
#define _H5FLprivate_H
|
||
|
|
|
||
|
|
/* Public headers needed by this file */
|
||
|
|
#ifdef LATER
|
||
|
|
#include "H5FLpublic.h" /*API prototypes */
|
||
|
|
#endif /* LATER */
|
||
|
|
|
||
|
|
/* Private headers needed by this file */
|
||
|
|
|
||
|
|
/* Macros for turning off free lists in the library */
|
||
|
|
/*#define H5_NO_FREE_LISTS*/
|
||
|
|
#if defined H5_NO_FREE_LISTS || defined H5_USING_MEMCHECKER
|
||
|
|
#define H5_NO_REG_FREE_LISTS
|
||
|
|
#define H5_NO_ARR_FREE_LISTS
|
||
|
|
#define H5_NO_SEQ_FREE_LISTS
|
||
|
|
#define H5_NO_BLK_FREE_LISTS
|
||
|
|
#define H5_NO_FAC_FREE_LISTS
|
||
|
|
#endif /* H5_NO_FREE_LISTS */
|
||
|
|
|
||
|
|
/* Macro to track location where block was allocated from */
|
||
|
|
/* Uncomment next line to turn on tracking, but don't leave it on after
|
||
|
|
* debugging is done because of the extra overhead it imposes.
|
||
|
|
*/
|
||
|
|
/* NOTE: This hasn't been extended to all the free-list allocation routines
|
||
|
|
* yet. -QAK
|
||
|
|
*/
|
||
|
|
/* #define H5FL_TRACK */
|
||
|
|
#ifdef H5FL_TRACK
|
||
|
|
/* Macro for inclusion in the free list allocation calls */
|
||
|
|
#define H5FL_TRACK_INFO ,__FILE__, FUNC, __LINE__
|
||
|
|
|
||
|
|
/* Macro for inclusion in internal free list allocation calls */
|
||
|
|
#define H5FL_TRACK_INFO_INT ,call_file, call_func, call_line
|
||
|
|
|
||
|
|
/* Macro for inclusion in the free list allocation parameters */
|
||
|
|
#define H5FL_TRACK_PARAMS ,const char *call_file, const char *call_func, int call_line
|
||
|
|
|
||
|
|
/* Forward declarations for structure fields */
|
||
|
|
struct H5CS_t;
|
||
|
|
|
||
|
|
/* Tracking information for each block */
|
||
|
|
typedef struct H5FL_track_t {
|
||
|
|
struct H5CS_t *stack; /* Function stack */
|
||
|
|
char *file; /* Name of file containing calling function */
|
||
|
|
char *func; /* Name of calling function */
|
||
|
|
int line; /* Line # within calling function */
|
||
|
|
struct H5FL_track_t *next; /* Pointer to next tracking block */
|
||
|
|
struct H5FL_track_t *prev; /* Pointer to previous tracking block */
|
||
|
|
} H5FL_track_t;
|
||
|
|
|
||
|
|
/* Macro for size of tracking information */
|
||
|
|
#define H5FL_TRACK_SIZE sizeof(H5FL_track_t)
|
||
|
|
|
||
|
|
#else /* H5FL_TRACK */
|
||
|
|
#define H5FL_TRACK_INFO
|
||
|
|
#define H5FL_TRACK_INFO_INT
|
||
|
|
#define H5FL_TRACK_PARAMS
|
||
|
|
#define H5FL_TRACK_SIZE 0
|
||
|
|
#endif /* H5FL_TRACK */
|
||
|
|
|
||
|
|
/*
|
||
|
|
* Private datatypes.
|
||
|
|
*/
|
||
|
|
|
||
|
|
/* Data structure to store each block in free list */
|
||
|
|
typedef struct H5FL_reg_node_t {
|
||
|
|
struct H5FL_reg_node_t *next; /* Pointer to next block in free list */
|
||
|
|
} H5FL_reg_node_t;
|
||
|
|
|
||
|
|
/* Data structure for free list of blocks */
|
||
|
|
typedef struct H5FL_reg_head_t {
|
||
|
|
unsigned init; /* Whether the free list has been initialized */
|
||
|
|
unsigned allocated; /* Number of blocks allocated */
|
||
|
|
unsigned onlist; /* Number of blocks on free list */
|
||
|
|
const char *name; /* Name of the type */
|
||
|
|
size_t size; /* Size of the blocks in the list */
|
||
|
|
H5FL_reg_node_t *list; /* List of free blocks */
|
||
|
|
} H5FL_reg_head_t;
|
||
|
|
|
||
|
|
/*
|
||
|
|
* Macros for defining & using free lists for a type
|
||
|
|
*/
|
||
|
|
#define H5FL_REG_NAME(t) H5_##t##_reg_free_list
|
||
|
|
#ifndef H5_NO_REG_FREE_LISTS
|
||
|
|
/* Common macros for H5FL_DEFINE & H5FL_DEFINE_STATIC */
|
||
|
|
#define H5FL_DEFINE_COMMON(t) H5FL_reg_head_t H5FL_REG_NAME(t)={0,0,0,#t,sizeof(t),NULL}
|
||
|
|
|
||
|
|
/* Declare a free list to manage objects of type 't' */
|
||
|
|
#define H5FL_DEFINE(t) H5_DLL H5FL_DEFINE_COMMON(t)
|
||
|
|
|
||
|
|
/* Reference a free list for type 't' defined in another file */
|
||
|
|
#define H5FL_EXTERN(t) H5_DLLVAR H5FL_reg_head_t H5FL_REG_NAME(t)
|
||
|
|
|
||
|
|
/* Declare a static free list to manage objects of type 't' */
|
||
|
|
#define H5FL_DEFINE_STATIC(t) static H5FL_DEFINE_COMMON(t)
|
||
|
|
|
||
|
|
/* Allocate an object of type 't' */
|
||
|
|
#define H5FL_MALLOC(t) (t *)H5FL_reg_malloc(&(H5FL_REG_NAME(t)) H5FL_TRACK_INFO)
|
||
|
|
|
||
|
|
/* Allocate an object of type 't' and clear it to all zeros */
|
||
|
|
#define H5FL_CALLOC(t) (t *)H5FL_reg_calloc(&(H5FL_REG_NAME(t)) H5FL_TRACK_INFO)
|
||
|
|
|
||
|
|
/* Free an object of type 't' */
|
||
|
|
#define H5FL_FREE(t,obj) (t *)H5FL_reg_free(&(H5FL_REG_NAME(t)),obj)
|
||
|
|
|
||
|
|
/* Re-allocating an object of type 't' is not defined, because these free-lists
|
||
|
|
* only support fixed sized types, like structs, etc..
|
||
|
|
*/
|
||
|
|
|
||
|
|
#else /* H5_NO_REG_FREE_LISTS */
|
||
|
|
#include "H5MMprivate.h"
|
||
|
|
/* Common macro for H5FL_DEFINE & H5FL_DEFINE_STATIC */
|
||
|
|
#define H5FL_DEFINE_COMMON(t) int UNUSED H5FL_REG_NAME(t)
|
||
|
|
|
||
|
|
#define H5FL_DEFINE(t) H5_DLL H5FL_DEFINE_COMMON(t)
|
||
|
|
#define H5FL_EXTERN(t) H5_DLLVAR H5FL_DEFINE_COMMON(t)
|
||
|
|
#define H5FL_DEFINE_STATIC(t) static H5FL_DEFINE_COMMON(t)
|
||
|
|
#define H5FL_MALLOC(t) (t *)H5MM_malloc(sizeof(t))
|
||
|
|
#define H5FL_CALLOC(t) (t *)H5MM_calloc(sizeof(t))
|
||
|
|
#define H5FL_FREE(t,obj) (t *)H5MM_xfree(obj)
|
||
|
|
#endif /* H5_NO_REG_FREE_LISTS */
|
||
|
|
|
||
|
|
/* Data structure to store information about each block allocated */
|
||
|
|
typedef union H5FL_blk_list_t {
|
||
|
|
size_t size; /* Size of the page */
|
||
|
|
union H5FL_blk_list_t *next; /* Pointer to next block in free list */
|
||
|
|
double unused1; /* Unused normally, just here for aligment */
|
||
|
|
haddr_t unused2; /* Unused normally, just here for aligment */
|
||
|
|
} H5FL_blk_list_t;
|
||
|
|
|
||
|
|
/* Data structure for priority queue node of block free lists */
|
||
|
|
typedef struct H5FL_blk_node_t {
|
||
|
|
size_t size; /* Size of the blocks in the list */
|
||
|
|
H5FL_blk_list_t *list; /* List of free blocks */
|
||
|
|
struct H5FL_blk_node_t *next; /* Pointer to next free list in queue */
|
||
|
|
struct H5FL_blk_node_t *prev; /* Pointer to previous free list in queue */
|
||
|
|
} H5FL_blk_node_t;
|
||
|
|
|
||
|
|
/* Data structure for priority queue of native block free lists */
|
||
|
|
typedef struct H5FL_blk_head_t {
|
||
|
|
unsigned init; /* Whether the free list has been initialized */
|
||
|
|
unsigned allocated; /* Number of blocks allocated */
|
||
|
|
unsigned onlist; /* Number of blocks on free list */
|
||
|
|
size_t list_mem; /* Amount of memory in block on free list */
|
||
|
|
const char *name; /* Name of the type */
|
||
|
|
H5FL_blk_node_t *head; /* Pointer to first free list in queue */
|
||
|
|
} H5FL_blk_head_t;
|
||
|
|
|
||
|
|
/*
|
||
|
|
* Macros for defining & using priority queues
|
||
|
|
*/
|
||
|
|
#define H5FL_BLK_NAME(t) H5_##t##_blk_free_list
|
||
|
|
#ifndef H5_NO_BLK_FREE_LISTS
|
||
|
|
/* Common macro for H5FL_BLK_DEFINE & H5FL_BLK_DEFINE_STATIC */
|
||
|
|
#define H5FL_BLK_DEFINE_COMMON(t) H5FL_blk_head_t H5FL_BLK_NAME(t)={0,0,0,0,#t"_blk",NULL}
|
||
|
|
|
||
|
|
/* Declare a free list to manage objects of type 't' */
|
||
|
|
#define H5FL_BLK_DEFINE(t) H5_DLL H5FL_BLK_DEFINE_COMMON(t)
|
||
|
|
|
||
|
|
/* Reference a free list for type 't' defined in another file */
|
||
|
|
#define H5FL_BLK_EXTERN(t) H5_DLLVAR H5FL_blk_head_t H5FL_BLK_NAME(t)
|
||
|
|
|
||
|
|
/* Declare a static free list to manage objects of type 't' */
|
||
|
|
#define H5FL_BLK_DEFINE_STATIC(t) static H5FL_BLK_DEFINE_COMMON(t)
|
||
|
|
|
||
|
|
/* Allocate an block of type 't' */
|
||
|
|
#define H5FL_BLK_MALLOC(t,size) (uint8_t *)H5FL_blk_malloc(&(H5FL_BLK_NAME(t)),size H5FL_TRACK_INFO)
|
||
|
|
|
||
|
|
/* Allocate an block of type 't' and clear it to zeros */
|
||
|
|
#define H5FL_BLK_CALLOC(t,size) (uint8_t *)H5FL_blk_calloc(&(H5FL_BLK_NAME(t)),size H5FL_TRACK_INFO)
|
||
|
|
|
||
|
|
/* Free a block of type 't' */
|
||
|
|
#define H5FL_BLK_FREE(t,blk) (uint8_t *)H5FL_blk_free(&(H5FL_BLK_NAME(t)),blk)
|
||
|
|
|
||
|
|
/* Re-allocate a block of type 't' */
|
||
|
|
#define H5FL_BLK_REALLOC(t,blk,new_size) (uint8_t *)H5FL_blk_realloc(&(H5FL_BLK_NAME(t)),blk,new_size H5FL_TRACK_INFO)
|
||
|
|
|
||
|
|
/* Check if there is a free block available to re-use */
|
||
|
|
#define H5FL_BLK_AVAIL(t,size) H5FL_blk_free_block_avail(&(H5FL_BLK_NAME(t)),size)
|
||
|
|
|
||
|
|
#else /* H5_NO_BLK_FREE_LISTS */
|
||
|
|
/* Common macro for H5FL_BLK_DEFINE & H5FL_BLK_DEFINE_STATIC */
|
||
|
|
#define H5FL_BLK_DEFINE_COMMON(t) int UNUSED H5FL_BLK_NAME(t)
|
||
|
|
|
||
|
|
#define H5FL_BLK_DEFINE(t) H5_DLL H5FL_BLK_DEFINE_COMMON(t)
|
||
|
|
#define H5FL_BLK_EXTERN(t) H5_DLLVAR H5FL_BLK_DEFINE_COMMON(t)
|
||
|
|
#define H5FL_BLK_DEFINE_STATIC(t) static H5FL_BLK_DEFINE_COMMON(t)
|
||
|
|
#define H5FL_BLK_MALLOC(t,size) (uint8_t *)H5MM_malloc(size)
|
||
|
|
#define H5FL_BLK_CALLOC(t,size) (uint8_t *)H5MM_calloc(size)
|
||
|
|
#define H5FL_BLK_FREE(t,blk) (uint8_t *)H5MM_xfree(blk)
|
||
|
|
#define H5FL_BLK_REALLOC(t,blk,new_size) (uint8_t *)H5MM_realloc(blk,new_size)
|
||
|
|
#define H5FL_BLK_AVAIL(t,size) (FALSE)
|
||
|
|
#endif /* H5_NO_BLK_FREE_LISTS */
|
||
|
|
|
||
|
|
/* Data structure to store each array in free list */
|
||
|
|
typedef union H5FL_arr_list_t {
|
||
|
|
union H5FL_arr_list_t *next; /* Pointer to next block in free list */
|
||
|
|
size_t nelem; /* Number of elements in this array */
|
||
|
|
double unused1; /* Unused normally, just here for aligment */
|
||
|
|
haddr_t unused2; /* Unused normally, just here for aligment */
|
||
|
|
} H5FL_arr_list_t;
|
||
|
|
|
||
|
|
/* Data structure for each size of array element */
|
||
|
|
typedef struct H5FL_arr_node_t {
|
||
|
|
size_t size; /* Size of the blocks in the list */
|
||
|
|
unsigned onlist; /* Number of blocks on free list */
|
||
|
|
H5FL_arr_list_t *list; /* List of free blocks */
|
||
|
|
} H5FL_arr_node_t;
|
||
|
|
|
||
|
|
/* Data structure for free list of array blocks */
|
||
|
|
typedef struct H5FL_arr_head_t {
|
||
|
|
unsigned init; /* Whether the free list has been initialized */
|
||
|
|
unsigned allocated; /* Number of blocks allocated */
|
||
|
|
size_t list_mem; /* Amount of memory in block on free list */
|
||
|
|
const char *name; /* Name of the type */
|
||
|
|
int maxelem; /* Maximum number of elements in an array */
|
||
|
|
size_t base_size; /* Size of the "base" object in the list */
|
||
|
|
size_t elem_size; /* Size of the array elements in the list */
|
||
|
|
H5FL_arr_node_t *list_arr; /* Array of lists of free blocks */
|
||
|
|
} H5FL_arr_head_t;
|
||
|
|
|
||
|
|
/*
|
||
|
|
* Macros for defining & using free lists for an array of a type
|
||
|
|
*/
|
||
|
|
#define H5FL_ARR_NAME(t) H5_##t##_arr_free_list
|
||
|
|
#ifndef H5_NO_ARR_FREE_LISTS
|
||
|
|
/* Common macro for H5FL_ARR_DEFINE & H5FL_ARR_DEFINE_STATIC (and H5FL_BARR variants) */
|
||
|
|
#define H5FL_ARR_DEFINE_COMMON(b,t,m) H5FL_arr_head_t H5FL_ARR_NAME(t)={0,0,0,#t"_arr",m+1,b,sizeof(t),NULL}
|
||
|
|
|
||
|
|
/* Declare a free list to manage arrays of type 't' */
|
||
|
|
#define H5FL_ARR_DEFINE(t,m) H5_DLL H5FL_ARR_DEFINE_COMMON(0,t,m)
|
||
|
|
|
||
|
|
/* Declare a free list to manage base 'b' + arrays of type 't' */
|
||
|
|
#define H5FL_BARR_DEFINE(b,t,m) H5_DLL H5FL_ARR_DEFINE_COMMON(sizeof(b),t,m)
|
||
|
|
|
||
|
|
/* Reference a free list for arrays of type 't' defined in another file */
|
||
|
|
#define H5FL_ARR_EXTERN(t) H5_DLLVAR H5FL_arr_head_t H5FL_ARR_NAME(t)
|
||
|
|
|
||
|
|
/* Declare a static free list to manage arrays of type 't' */
|
||
|
|
#define H5FL_ARR_DEFINE_STATIC(t,m) static H5FL_ARR_DEFINE_COMMON(0,t,m)
|
||
|
|
|
||
|
|
/* Declare a static free list to manage base 'b' + arrays of type 't' */
|
||
|
|
#define H5FL_BARR_DEFINE_STATIC(b,t,m) static H5FL_ARR_DEFINE_COMMON(sizeof(b),t,m)
|
||
|
|
|
||
|
|
/* Allocate an array of type 't' */
|
||
|
|
#define H5FL_ARR_MALLOC(t,elem) H5FL_arr_malloc(&(H5FL_ARR_NAME(t)),elem)
|
||
|
|
|
||
|
|
/* Allocate an array of type 't' and clear it to all zeros */
|
||
|
|
#define H5FL_ARR_CALLOC(t,elem) H5FL_arr_calloc(&(H5FL_ARR_NAME(t)),elem)
|
||
|
|
|
||
|
|
/* Free an array of type 't' */
|
||
|
|
#define H5FL_ARR_FREE(t,obj) (t *)H5FL_arr_free(&(H5FL_ARR_NAME(t)),obj)
|
||
|
|
|
||
|
|
/* Re-allocate an array of type 't' */
|
||
|
|
#define H5FL_ARR_REALLOC(t,obj,new_elem) H5FL_arr_realloc(&(H5FL_ARR_NAME(t)),obj,new_elem)
|
||
|
|
|
||
|
|
#else /* H5_NO_ARR_FREE_LISTS */
|
||
|
|
/* Common macro for H5FL_ARR_DEFINE & H5FL_ARR_DEFINE_STATIC (and H5FL_BARR variants) */
|
||
|
|
#define H5FL_ARR_DEFINE_COMMON(t,m) size_t H5FL_ARR_NAME(t)
|
||
|
|
|
||
|
|
#define H5FL_ARR_DEFINE(t,m) H5_DLL H5FL_ARR_DEFINE_COMMON(t,m) = 0
|
||
|
|
#define H5FL_BARR_DEFINE(b,t,m) H5_DLL H5FL_ARR_DEFINE_COMMON(t,m) = sizeof(b)
|
||
|
|
#define H5FL_ARR_EXTERN(t) H5_DLLVAR H5FL_ARR_DEFINE_COMMON(t,m)
|
||
|
|
#define H5FL_ARR_DEFINE_STATIC(t,m) static H5FL_ARR_DEFINE_COMMON(t,m) = 0
|
||
|
|
#define H5FL_BARR_DEFINE_STATIC(b,t,m) static H5FL_ARR_DEFINE_COMMON(t,m) = sizeof(b)
|
||
|
|
#define H5FL_ARR_MALLOC(t,elem) H5MM_malloc(H5FL_ARR_NAME(t) + ((elem)*sizeof(t)))
|
||
|
|
#define H5FL_ARR_CALLOC(t,elem) H5MM_calloc(H5FL_ARR_NAME(t) + ((elem)*sizeof(t)))
|
||
|
|
#define H5FL_ARR_FREE(t,obj) (t *)H5MM_xfree(obj)
|
||
|
|
#define H5FL_ARR_REALLOC(t,obj,new_elem) H5MM_realloc(obj,H5FL_ARR_NAME(t) + ((new_elem)*sizeof(t)))
|
||
|
|
#endif /* H5_NO_ARR_FREE_LISTS */
|
||
|
|
|
||
|
|
/* Data structure for free list of sequence blocks */
|
||
|
|
typedef struct H5FL_seq_head_t {
|
||
|
|
H5FL_blk_head_t queue; /* Priority queue of sequence blocks */
|
||
|
|
size_t size; /* Size of the sequence elements in the list */
|
||
|
|
} H5FL_seq_head_t;
|
||
|
|
|
||
|
|
/*
|
||
|
|
* Macros for defining & using free lists for a sequence of a type
|
||
|
|
*
|
||
|
|
* Sequences are like arrays, except they have no upper limit.
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
#define H5FL_SEQ_NAME(t) H5_##t##_seq_free_list
|
||
|
|
#ifndef H5_NO_SEQ_FREE_LISTS
|
||
|
|
/* Common macro for H5FL_SEQ_DEFINE & H5FL_SEQ_DEFINE_STATIC */
|
||
|
|
#define H5FL_SEQ_DEFINE_COMMON(t) H5FL_seq_head_t H5FL_SEQ_NAME(t)={{0,0,0,0,#t"_seq",NULL},sizeof(t)}
|
||
|
|
|
||
|
|
/* Declare a free list to manage sequences of type 't' */
|
||
|
|
#define H5FL_SEQ_DEFINE(t) H5_DLL H5FL_SEQ_DEFINE_COMMON(t)
|
||
|
|
|
||
|
|
/* Reference a free list for sequences of type 't' defined in another file */
|
||
|
|
#define H5FL_SEQ_EXTERN(t) H5_DLLVAR H5FL_seq_head_t H5FL_SEQ_NAME(t)
|
||
|
|
|
||
|
|
/* Declare a static free list to manage sequences of type 't' */
|
||
|
|
#define H5FL_SEQ_DEFINE_STATIC(t) static H5FL_SEQ_DEFINE_COMMON(t)
|
||
|
|
|
||
|
|
/* Allocate a sequence of type 't' */
|
||
|
|
#define H5FL_SEQ_MALLOC(t,elem) (t *)H5FL_seq_malloc(&(H5FL_SEQ_NAME(t)),elem H5FL_TRACK_INFO)
|
||
|
|
|
||
|
|
/* Allocate a sequence of type 't' and clear it to all zeros */
|
||
|
|
#define H5FL_SEQ_CALLOC(t,elem) (t *)H5FL_seq_calloc(&(H5FL_SEQ_NAME(t)),elem H5FL_TRACK_INFO)
|
||
|
|
|
||
|
|
/* Free a sequence of type 't' */
|
||
|
|
#define H5FL_SEQ_FREE(t,obj) H5FL_seq_free(&(H5FL_SEQ_NAME(t)),obj)
|
||
|
|
|
||
|
|
/* Re-allocate a sequence of type 't' */
|
||
|
|
#define H5FL_SEQ_REALLOC(t,obj,new_elem) (t *)H5FL_seq_realloc(&(H5FL_SEQ_NAME(t)),obj,new_elem H5FL_TRACK_INFO)
|
||
|
|
|
||
|
|
#else /* H5_NO_SEQ_FREE_LISTS */
|
||
|
|
/* Common macro for H5FL_SEQ_DEFINE & H5FL_SEQ_DEFINE_STATIC */
|
||
|
|
#define H5FL_SEQ_DEFINE_COMMON(t) int UNUSED H5FL_SEQ_NAME(t)
|
||
|
|
|
||
|
|
#define H5FL_SEQ_DEFINE(t) H5_DLL H5FL_SEQ_DEFINE_COMMON(t)
|
||
|
|
#define H5FL_SEQ_EXTERN(t) H5_DLLVAR H5FL_SEQ_DEFINE_COMMON(t)
|
||
|
|
#define H5FL_SEQ_DEFINE_STATIC(t) static H5FL_SEQ_DEFINE_COMMON(t)
|
||
|
|
#define H5FL_SEQ_MALLOC(t,elem) (t *)H5MM_malloc((elem)*sizeof(t))
|
||
|
|
#define H5FL_SEQ_CALLOC(t,elem) (t *)H5MM_calloc((elem)*sizeof(t))
|
||
|
|
#define H5FL_SEQ_FREE(t,obj) (t *)H5MM_xfree(obj)
|
||
|
|
#define H5FL_SEQ_REALLOC(t,obj,new_elem) (t *)H5MM_realloc(obj,(new_elem)*sizeof(t))
|
||
|
|
#endif /* H5_NO_SEQ_FREE_LISTS */
|
||
|
|
|
||
|
|
/* Forward declarations of the data structures for free list block factory */
|
||
|
|
typedef struct H5FL_fac_gc_node_t H5FL_fac_gc_node_t;
|
||
|
|
typedef struct H5FL_fac_node_t H5FL_fac_node_t;
|
||
|
|
|
||
|
|
/* Data structure for free list block factory */
|
||
|
|
typedef struct H5FL_fac_head_t {
|
||
|
|
unsigned init; /* Whether the free list has been initialized */
|
||
|
|
unsigned allocated; /* Number of blocks allocated */
|
||
|
|
unsigned onlist; /* Number of blocks on free list */
|
||
|
|
size_t size; /* Size of the blocks in the list */
|
||
|
|
H5FL_fac_node_t *list; /* List of free blocks */
|
||
|
|
H5FL_fac_gc_node_t *prev_gc; /* Previous garbage collection node in list */
|
||
|
|
} H5FL_fac_head_t;
|
||
|
|
|
||
|
|
|
||
|
|
/*
|
||
|
|
* Macros for defining & using free list factories
|
||
|
|
*
|
||
|
|
* Factories are dynamically created free list managers for blocks of
|
||
|
|
* a particular size.
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
#ifndef H5_NO_FAC_FREE_LISTS
|
||
|
|
/* Allocate a block from a factory */
|
||
|
|
#define H5FL_FAC_MALLOC(f) H5FL_fac_malloc(f H5FL_TRACK_INFO)
|
||
|
|
|
||
|
|
/* Allocate a block from a factory and clear it to all zeros */
|
||
|
|
#define H5FL_FAC_CALLOC(f) H5FL_fac_calloc(f H5FL_TRACK_INFO)
|
||
|
|
|
||
|
|
/* Return a block to a factory */
|
||
|
|
#define H5FL_FAC_FREE(f, obj) H5FL_fac_free(f, obj)
|
||
|
|
|
||
|
|
#else /* H5_NO_FAC_FREE_LISTS */
|
||
|
|
#define H5FL_FAC_MALLOC(f) H5MM_malloc(f->size)
|
||
|
|
#define H5FL_FAC_CALLOC(f) H5MM_calloc(f->size)
|
||
|
|
#define H5FL_FAC_FREE(f, obj) H5MM_xfree(obj)
|
||
|
|
#endif /* H5_NO_FAC_FREE_LISTS */
|
||
|
|
|
||
|
|
/*
|
||
|
|
* Library prototypes.
|
||
|
|
*/
|
||
|
|
/* Block free lists */
|
||
|
|
H5_DLL void * H5FL_blk_malloc(H5FL_blk_head_t *head, size_t size H5FL_TRACK_PARAMS);
|
||
|
|
H5_DLL void * H5FL_blk_calloc(H5FL_blk_head_t *head, size_t size H5FL_TRACK_PARAMS);
|
||
|
|
H5_DLL void * H5FL_blk_free(H5FL_blk_head_t *head, void *block);
|
||
|
|
H5_DLL void * H5FL_blk_realloc(H5FL_blk_head_t *head, void *block, size_t new_size H5FL_TRACK_PARAMS);
|
||
|
|
H5_DLL htri_t H5FL_blk_free_block_avail(H5FL_blk_head_t *head, size_t size);
|
||
|
|
|
||
|
|
/* Regular free lists */
|
||
|
|
H5_DLL void * H5FL_reg_malloc(H5FL_reg_head_t *head H5FL_TRACK_PARAMS);
|
||
|
|
H5_DLL void * H5FL_reg_calloc(H5FL_reg_head_t *head H5FL_TRACK_PARAMS);
|
||
|
|
H5_DLL void * H5FL_reg_free(H5FL_reg_head_t *head, void *obj);
|
||
|
|
|
||
|
|
/* Array free lists */
|
||
|
|
H5_DLL void * H5FL_arr_malloc(H5FL_arr_head_t *head, size_t elem);
|
||
|
|
H5_DLL void * H5FL_arr_calloc(H5FL_arr_head_t *head, size_t elem);
|
||
|
|
H5_DLL void * H5FL_arr_free(H5FL_arr_head_t *head, void *obj);
|
||
|
|
H5_DLL void * H5FL_arr_realloc(H5FL_arr_head_t *head, void *obj, size_t new_elem);
|
||
|
|
|
||
|
|
/* Sequence free lists */
|
||
|
|
H5_DLL void * H5FL_seq_malloc(H5FL_seq_head_t *head, size_t elem H5FL_TRACK_PARAMS);
|
||
|
|
H5_DLL void * H5FL_seq_calloc(H5FL_seq_head_t *head, size_t elem H5FL_TRACK_PARAMS);
|
||
|
|
H5_DLL void * H5FL_seq_free(H5FL_seq_head_t *head, void *obj);
|
||
|
|
H5_DLL void * H5FL_seq_realloc(H5FL_seq_head_t *head, void *obj, size_t new_elem H5FL_TRACK_PARAMS);
|
||
|
|
|
||
|
|
/* Factory free lists */
|
||
|
|
H5_DLL H5FL_fac_head_t *H5FL_fac_init(size_t size);
|
||
|
|
H5_DLL void * H5FL_fac_malloc(H5FL_fac_head_t *head H5FL_TRACK_PARAMS);
|
||
|
|
H5_DLL void * H5FL_fac_calloc(H5FL_fac_head_t *head H5FL_TRACK_PARAMS);
|
||
|
|
H5_DLL void * H5FL_fac_free(H5FL_fac_head_t *head, void *obj);
|
||
|
|
H5_DLL herr_t H5FL_fac_term(H5FL_fac_head_t *head);
|
||
|
|
|
||
|
|
/* General free list routines */
|
||
|
|
H5_DLL herr_t H5FL_garbage_coll(void);
|
||
|
|
H5_DLL herr_t H5FL_set_free_list_limits(int reg_global_lim, int reg_list_lim,
|
||
|
|
int arr_global_lim, int arr_list_lim, int blk_global_lim, int blk_list_lim,
|
||
|
|
int fac_global_lim, int fac_list_lim);
|
||
|
|
H5_DLL int H5FL_term_interface(void);
|
||
|
|
|
||
|
|
#endif
|