/****************************************************************************
* 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. *
* *
****************************************************************************/
/*
* Created: H5TB.c
* Jun 11 1998
* Quincey Koziol <koziol@ncsa.uiuc.edu>
*
* Purpose: Temporary buffer management functions
*
* Library Public API Functions:
* H5TB_get_buf - Get an ID for a temporary buffer
* H5TB_buf_ptr - Get a pointer to the temporary buffer's memory
* H5TB_resize_buf - Resize a temporary buffer
* H5TB_garbage_coll- Free all unused temporary buffers
* H5TB_release_buf - Release temporary buffer
*
* Modifications:
*
*/
#ifdef RCSID
static char RcsId[] = "@(#)$Revision$";
#endif
/* $Id$ */
#include <H5private.h> /* Generic Functions */
#include <H5Iprivate.h> /* ID Functions */
#include <H5Eprivate.h> /* Error handling */
#include <H5MMprivate.h> /* Memory Management functions */
#include <H5TBprivate.h> /* Temporary buffer info */
/* Interface init/term information */
#define PABLO_MASK H5TB_mask
#define INTERFACE_INIT H5TB_init_interface
static intn interface_initialize_g = 0;
static herr_t H5TB_init_interface(void);
/* Local information for managing buffers */
#define H5TB_RESERVED_ATOMS 0
typedef struct tag_H5TB_t {
hbool_t inuse; /* Flag to indicate whether the buffer is in use or not */
hsize_t size; /* Current size of the buffer */
struct tag_H5TB_t *next; /* Pointer to next buffer in list */
struct tag_H5TB_t *prev; /* Pointer to previous buffer in list */
void *buf; /* Pointer to actual temporary buffer */
} H5TB_t;
static H5TB_t * H5TB_list_head=NULL; /* pointer to beginning of temp. buffer list (list is in order of increasing size) */
static H5TB_t * H5TB_list_tail=NULL; /* pointer to end of temp. buffer list */
/* Local functions */
herr_t H5TB_close(H5TB_t *tb);
/*--------------------------------------------------------------------------
NAME
H5TB_init_interface -- Initialize interface-specific information
USAGE
herr_t H5TB_init_interface()
RETURNS
Non-negative on success/Negative on failure
DESCRIPTION
Initializes any interface-specific data or routines.
--------------------------------------------------------------------------*/
static herr_t
H5TB_init_interface(void)
{
FUNC_ENTER(H5TB_init_interface, FAIL);
/* Initialize the atom group for the file IDs */
if (H5I_init_group(H5I_TEMPBUF, H5I_TEMPBUFID_HASHSIZE,
H5TB_RESERVED_ATOMS, NULL)<0) {
HRETURN_ERROR (H5E_INTERNAL, H5E_CANTINIT, FAIL,
"unable to initialize interface");
}
FUNC_LEAVE(SUCCEED);
}
/*--------------------------------------------------------------------------
NAME
H5TB_term_interface
PURPOSE
Terminate various H5TB objects
USAGE
void H5TB_term_interface()
RETURNS
Non-negative on success/Negative on failure
DESCRIPTION
Release the atom group and any other resources allocated.
GLOBAL VARIABLES
COMMENTS, BUGS, ASSUMPTIONS
Can't report errors...
EXAMPLES
REVISION LOG
--------------------------------------------------------------------------*/
intn
H5TB_term_interface(void)
{
H5TB_t *curr=H5TB_list_head, /* pointer to current temp. buffer */
*next; /* pointer to next temp. buffer */
intn n=0;
if (interface_initialize_g) {
if ((n=H5I_nmembers(H5I_TEMPBUF))) {
H5I_clear_group(H5I_TEMPBUF, FALSE);
} else {
/* Free group and buffers */
H5I_destroy_group(H5I_TEMPBUF);
while(curr!=NULL) {
next=curr->next;
if(curr->buf!=NULL)
H5MM_xfree(curr->buf);
H5MM_xfree(curr);
curr=next;
}
H5TB_list_head=H5TB_list_tail=NULL;
interface_initialize_g = 0;
n = 1; /*H5I*/
}
}
return n;
}
/*-------------------------------------------------------------------------
* Function: H5TB_close
*
* Purpose: Releases all memory associated with a temporary buffer.
*
* Return: Non-negative on success/Negative on failure
*
* Programmer: Quincey Koziol
* Thursday, June 11, 1998
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
herr_t H5TB_close(H5TB_t *tb)
{
FUNC_ENTER(H5TB_close, FAIL);
assert(tb);
/* Release the main structure */
H5MM_xfree(tb);
FUNC_LEAVE(SUCCEED);
}
/*--------------------------------------------------------------------------
NAME
H5TB_get_buf
PURPOSE
Get an ID for a temporary buffer
USAGE
hid_t H5TB_get_buf(size,resize,ptr)
hsize_t size; IN: Minimum size of buffer requested
hbool_t resize; IN: Whether to resize an existing buffer or get a
new buffer if one doesn't match the correct size
void **ptr; OUT: Pointer to a pointer to set to the buffer
address, if not NULL
RETURNS
Valid buffer ID on success, negative on failure
DESCRIPTION
Checks for an available temporary buffer of at least the size requested and
returns an ID for an appropriate one. If a buffer of the minimum size
requested is not available and the resize flag is set, the smallest buffer
available is resized to be the correct size and returned, otherwise a new
buffer of the correct size is allocated and returned.
GLOBAL VARIABLES
COMMENTS, BUGS, ASSUMPTIONS
EXAMPLES
REVISION LOG
--------------------------------------------------------------------------*/
hid_t
H5TB_get_buf(hsize_t size, hbool_t resize, void **ptr)
{
hid_t ret_value = FAIL;
H5TB_t *curr=H5TB_list_head, /* pointer to current temp. buffer */
*new; /* pointer to a newly created temp. buffer */
FUNC_ENTER (H5TB_get_buf, FAIL);
while(curr!=NULL) {
if(!curr->inuse && size<=curr->size)
break;
curr=curr->next;
} /* end while */
/* Check if we found a block or not */
if(curr!=NULL) {
curr->inuse=TRUE;
} else {
if(resize) {
curr=H5TB_list_head; /* start at beginning again */
/* Search for first node which isn't in use */
while(curr!=NULL) {
if(!curr->inuse)
break;
curr=curr->next;
} /* end while */
/* Mark the buffer in use and resize the buffer */
if(curr!=NULL) {
void * old_ptr=curr->buf;
if((curr->buf = H5MM_realloc(curr->buf, size))==NULL) {
curr->buf=old_ptr; /* restore pointer if no memory available */
HRETURN_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL,
"unable to allocate space for temporary buffer");
}
curr->inuse=TRUE;
}
} /* end if */
} /* end else */
/* No blocks in the list are acceptable */
/* (either too small or not able to be resized) */
if(curr==NULL) {
if((new=H5MM_calloc(sizeof(H5TB_t)))==NULL)
HRETURN_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL,
"unable to allocate space for temporary buffer struct");
new->inuse=TRUE;
new->size=size;
if((new->buf=H5MM_malloc(size))==NULL) {
H5MM_xfree(new); /* free structure */
HRETURN_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL,
"unable to allocate space for temporary buffer");
}
/* Check if this is the first node in the list */
if(H5TB_list_head==NULL) {
H5TB_list_head=H5TB_list_tail=curr=new;
} else {
/* Find correct place to insert in list */
for(curr=H5TB_list_head; curr!=NULL; curr=curr->next) {
/* Found node to insert before */
if(curr->size > new->size) {
H5TB_t *tmp=curr->prev; /* temporary pointer */
/* Inserting at head of list */
if(tmp==NULL) {
H5TB_list_head=new;
new->next=curr;
curr->prev=new;
} else {
tmp->next=new;
new->prev=tmp;
curr->prev=new;
new->next=curr;
} /* end else */
/* set this so we can fall through to getting the ID */
curr=new;
break;
} /* end if */
} /* end for */
/* Add to end of list */
if(curr==NULL) {
curr=H5TB_list_tail;
H5TB_list_tail=curr->next=new;
new->prev=curr;
} /* end if */
/* set this so we can fall through to getting the ID */
curr=new;
} /* end else */
} /* end if */
/* Atomize */
if ((ret_value=H5I_register (H5I_TEMPBUF, curr))<0) {
HGOTO_ERROR (H5E_ATOM, H5E_CANTREGISTER, FAIL, "unable to register temp. buffer atom");
}
/* Assign the pointer to the buffer, if requested */
if(ptr!=NULL)
*ptr=curr->buf;
done:
if (ret_value < 0) {
}
FUNC_LEAVE(ret_value);
} /* H5TB_get_buf() */
/*--------------------------------------------------------------------------
NAME
H5TB_buf_ptr
PURPOSE
Get the pointer to a temp. buffer memory
USAGE
void *H5TB_buf_ptr(tbuf_id)
hid_t tbuf_id; IN: Temp. buffer ID
RETURNS
Non-NULL pointer to buffer memory on success, NULL on failure
DESCRIPTION
Gets the pointer to a temp. buffer's memory.
GLOBAL VARIABLES
COMMENTS, BUGS, ASSUMPTIONS
EXAMPLES
REVISION LOG
--------------------------------------------------------------------------*/
void *
H5TB_buf_ptr(hid_t tbuf_id)
{
void *ret_value = NULL;
H5TB_t *tbuf; /* Pointer to temporary buffer */
FUNC_ENTER (H5TB_buf_ptr, NULL);
if (H5I_TEMPBUF != H5I_get_type(tbuf_id) ||
NULL == (tbuf = H5I_object(tbuf_id))) {
HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, NULL, "not a temp. buffer");
}
ret_value=tbuf->buf;
#ifdef LATER
done:
#endif
if (ret_value == NULL) {
}
FUNC_LEAVE(ret_value);
} /* H5TB_buf_ptr() */
/*--------------------------------------------------------------------------
NAME
H5TB_resize_buf
PURPOSE
Resize a temp. buffer to a new size
USAGE
herr_t H5TB_resize_buf(tbid, size)
hid_t tbid; IN: Temp. buffer ID to resize
hsize_t size; IN: New size of temp. buffer
RETURNS
non-negative on success, negative on failure
DESCRIPTION
Resizes a temporary buffer to a new size.
GLOBAL VARIABLES
COMMENTS, BUGS, ASSUMPTIONS
EXAMPLES
REVISION LOG
--------------------------------------------------------------------------*/
herr_t
H5TB_resize_buf(hid_t tbuf_id, hsize_t size)
{
herr_t ret_value = FAIL;
H5TB_t *tbuf, /* Pointer to temporary buffer */
*curr; /* Pointer to temp. buffer node */
void * old_ptr; /* Pointer to the previous buffer */
FUNC_ENTER (H5TB_resize_buf, FAIL);
if (H5I_TEMPBUF != H5I_get_type(tbuf_id) ||
NULL == (tbuf = H5I_object(tbuf_id))) {
HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a temp. buffer");
}
/* Save old pointer for later */
old_ptr=tbuf->buf;
/* Try to resize buffer to new size */
if((tbuf->buf = H5MM_realloc(tbuf->buf, size))==NULL) {
tbuf->buf=old_ptr; /* restore pointer if no memory available */
HRETURN_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL,
"unable to allocate space for temporary buffer");
}
/* Change the size of the buffer */
tbuf->size=size;
/*
* Check if we need to move the buffer in the sorted list
*/
/* Check if this is not the last node and it need's to move */
if(tbuf->next!=NULL && tbuf->next->size < tbuf->size) {
/* Remove this node from the list */
if(tbuf->prev==NULL) { /* remove from head of list */
H5TB_list_head=tbuf->next;
tbuf->next->prev=NULL;
} else { /* remove from middle of list */
tbuf->prev->next=tbuf->next;
tbuf->next->prev=tbuf->prev;
} /* end if */
/* Find correct position in list */
curr=H5TB_list_head;
while(curr!=NULL) {
if(!curr->inuse && size<curr->size)
break;
curr=curr->next;
} /* end while */
/* Insert into correct position in list */
if(curr!=NULL) {
/*
* Can't be adding to the beginning of list, so this is in the
* middle somewhere.
*/
curr->prev->next=tbuf;
tbuf->prev=curr->prev;
curr->prev=tbuf;
tbuf->next=curr;
} else { /* append to end of list */
H5TB_list_tail->next=tbuf;
tbuf->prev=H5TB_list_tail;
tbuf->next=NULL;
H5TB_list_tail=tbuf;
} /* end else */
} /* end if */
FUNC_LEAVE(ret_value);
} /* H5TB_resize_buf() */
/*--------------------------------------------------------------------------
NAME
H5TB_garbage_coll
PURPOSE
Release all unused temporary buffers
USAGE
herr_t H5TB_garbase_coll()
RETURNS
non-negative on success, negative on failure
DESCRIPTION
Steps through the list of temporary buffers, removing unused nodes from the
list and freeing their memory
GLOBAL VARIABLES
COMMENTS, BUGS, ASSUMPTIONS
EXAMPLES
REVISION LOG
--------------------------------------------------------------------------*/
herr_t
H5TB_garbage_coll(void)
{
herr_t ret_value = FAIL;
H5TB_t *curr,*next; /* Current temp. buffer node */
FUNC_ENTER (H5TB_garbage_coll, FAIL);
/*
* Step through the list, remove each unused node, repair the list and
* free the node.
*/
curr=H5TB_list_head;
while(curr!=NULL) {
next=curr->next;
if(!curr->inuse) {
/* maintain list head & tail */
if(H5TB_list_head==curr)
H5TB_list_head=curr->next;
if(H5TB_list_tail==curr)
H5TB_list_tail=curr->prev;
/* Delete node from list */
if(curr->prev!=NULL)
curr->prev->next=curr->next;
if(curr->next!=NULL)
curr->next->prev=curr->prev;
/* Free memory for node */
if(curr->buf!=NULL)
H5MM_xfree(curr->buf);
H5MM_xfree(curr);
} /* end if */
curr=next;
} /* end while */
ret_value=SUCCEED;
FUNC_LEAVE(ret_value);
} /* H5TB_garbage_coll() */
/*--------------------------------------------------------------------------
NAME
H5TB_release_buf
PURPOSE
Release a temp. buffer back to the list of unused ones.
USAGE
herr_t H5TB_release_buf(tbuf_id)
hid_t tbuf_id; IN: Temp. buffer ID to release
RETURNS
non-negative on success, negative on failure
DESCRIPTION
Releases a temporary buffer.
GLOBAL VARIABLES
COMMENTS, BUGS, ASSUMPTIONS
EXAMPLES
REVISION LOG
--------------------------------------------------------------------------*/
herr_t
H5TB_release_buf(hid_t tbuf_id)
{
herr_t ret_value = FAIL;
H5TB_t *tbuf; /* Pointer to temporary buffer */
FUNC_ENTER (H5TB_release_buf, FAIL);
if (H5I_TEMPBUF != H5I_get_type(tbuf_id) ||
NULL == (tbuf = H5I_remove(tbuf_id))) {
HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a temp. buffer");
}
/* Release the buffer */
tbuf->inuse=FALSE;
ret_value=SUCCEED;
FUNC_LEAVE(ret_value);
} /* H5TB_release_buf() */