/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* Copyright by The HDF Group. *
* 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 COPYING file, which can be found at the root of the source code *
* distribution tree, or in https://www.hdfgroup.org/licenses. *
* If you do not have access to either file, you may request a copy from *
* help@hdfgroup.org. *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/*-------------------------------------------------------------------------
*
* Created: H5FAdblock.c
*
* Purpose: Data block routines for fixed arrays.
*
*-------------------------------------------------------------------------
*/
/**********************/
/* Module Declaration */
/**********************/
#include "H5FAmodule.h" /* This source code file is part of the H5FA module */
/***********************/
/* Other Packages Used */
/***********************/
/***********/
/* Headers */
/***********/
#include "H5private.h" /* Generic Functions */
#include "H5Eprivate.h" /* Error handling */
#include "H5FApkg.h" /* Fixed Arrays */
#include "H5FLprivate.h" /* Free Lists */
#include "H5MFprivate.h" /* File memory management */
/****************/
/* Local Macros */
/****************/
/******************/
/* Local Typedefs */
/******************/
/********************/
/* Package Typedefs */
/********************/
/********************/
/* Local Prototypes */
/********************/
/*********************/
/* Package Variables */
/*********************/
/*****************************/
/* Library Private Variables */
/*****************************/
/*******************/
/* Local Variables */
/*******************/
/* Declare a free list to manage the H5FA_dblock_t struct */
H5FL_DEFINE_STATIC(H5FA_dblock_t);
/* Declare a free list to manage the chunk elements */
H5FL_BLK_DEFINE(chunk_elmts);
/* Declare a free list to manage blocks of 'page init' bitmasks */
H5FL_BLK_DEFINE(fa_page_init);
/*-------------------------------------------------------------------------
* Function: H5FA__dblock_alloc
*
* Purpose: Allocate fixed array data block
*
* Return: Non-NULL pointer to data block on success/NULL on failure
*
* Programmer: Vailin Choi
* Thursday, April 30, 2009
*
*-------------------------------------------------------------------------
*/
H5FA_dblock_t *
H5FA__dblock_alloc(H5FA_hdr_t *hdr)
{
H5FA_dblock_t *dblock = NULL; /* fixed array data block */
H5FA_dblock_t *ret_value = NULL;
FUNC_ENTER_PACKAGE
/* Check arguments */
HDassert(hdr);
HDassert(hdr->cparam.nelmts > 0);
/* Allocate memory for the data block */
if (NULL == (dblock = H5FL_CALLOC(H5FA_dblock_t)))
HGOTO_ERROR(H5E_FARRAY, H5E_CANTALLOC, NULL, "memory allocation failed for fixed array data block")
/* Share common array information */
if (H5FA__hdr_incr(hdr) < 0)
HGOTO_ERROR(H5E_FARRAY, H5E_CANTINC, NULL, "can't increment reference count on shared array header")
dblock->hdr = hdr;
/* Set non-zero internal fields */
dblock->dblk_page_nelmts = (size_t)1 << hdr->cparam.max_dblk_page_nelmts_bits;
/* Check if this data block should be paged */
if (hdr->cparam.nelmts > dblock->dblk_page_nelmts) {
/* Compute number of pages */
hsize_t npages = ((hdr->cparam.nelmts + dblock->dblk_page_nelmts) - 1) / dblock->dblk_page_nelmts;
/* Safely assign the number of pages */
H5_CHECKED_ASSIGN(dblock->npages, size_t, npages, hsize_t);
/* Sanity check that we have at least 1 page */
HDassert(dblock->npages > 0);
/* Compute size of 'page init' flag array, in bytes */
dblock->dblk_page_init_size = (dblock->npages + 7) / 8;
HDassert(dblock->dblk_page_init_size > 0);
/* Allocate space for 'page init' flags */
if (NULL == (dblock->dblk_page_init = H5FL_BLK_CALLOC(fa_page_init, dblock->dblk_page_init_size)))
HGOTO_ERROR(H5E_FARRAY, H5E_CANTALLOC, NULL, "memory allocation failed for page init bitmask")
/* Compute data block page size */
dblock->dblk_page_size = (dblock->dblk_page_nelmts * hdr->cparam.raw_elmt_size) + H5FA_SIZEOF_CHKSUM;
/* Compute the # of elements on last page */
if (0 == hdr->cparam.nelmts % dblock->dblk_page_nelmts)
dblock->last_page_nelmts = dblock->dblk_page_nelmts;
else
dblock->last_page_nelmts = (size_t)(hdr->cparam.nelmts % dblock->dblk_page_nelmts);
} /* end if */
else {
hsize_t dblk_size = hdr->cparam.nelmts * hdr->cparam.cls->nat_elmt_size;
/* Allocate buffer for elements in data block */
H5_CHECK_OVERFLOW(dblk_size, /* From: */ hsize_t, /* To: */ size_t);
if (NULL == (dblock->elmts = H5FL_BLK_MALLOC(chunk_elmts, (size_t)dblk_size)))
HGOTO_ERROR(H5E_FARRAY, H5E_CANTALLOC, NULL,
"memory allocation failed for data block element buffer")
} /* end else */
/* Set the return value */
ret_value = dblock;
done:
if (!ret_value)
if (dblock && H5FA__dblock_dest(dblock) < 0)
HDONE_ERROR(H5E_FARRAY, H5E_CANTFREE, NULL, "unable to destroy fixed array data block")
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5FA__dblock_alloc() */
/*-------------------------------------------------------------------------
* Function: H5FA__dblock_create
*
* Purpose: Creates a fixed array data block in the file
*
* Return: Valid file address on success/HADDR_UNDEF on failure
*
* Programmer: Vailin Choi
* Thursday, April 30, 2009
*
*-------------------------------------------------------------------------
*/
haddr_t
H5FA__dblock_create(H5FA_hdr_t *hdr, hbool_t *hdr_dirty)
{
H5FA_dblock_t *dblock = NULL; /* Fixed array data block */
haddr_t dblock_addr; /* Fixed array data block address */
hbool_t inserted = FALSE; /* Whether the header was inserted into cache */
haddr_t ret_value = HADDR_UNDEF;
FUNC_ENTER_PACKAGE
/* Sanity check */
HDassert(hdr);
HDassert(hdr_dirty);
/* Allocate the data block */
if (NULL == (dblock = H5FA__dblock_alloc(hdr)))
HGOTO_ERROR(H5E_FARRAY, H5E_CANTALLOC, HADDR_UNDEF,
"memory allocation failed for fixed array data block")
/* Set size of data block on disk */
hdr->stats.dblk_size = dblock->size = H5FA_DBLOCK_SIZE(dblock);
/* Allocate space for the data block on disk */
if (HADDR_UNDEF == (dblock_addr = H5MF_alloc(hdr->f, H5FD_MEM_FARRAY_DBLOCK, (hsize_t)dblock->size)))
HGOTO_ERROR(H5E_FARRAY, H5E_CANTALLOC, HADDR_UNDEF,
"file allocation failed for fixed array data block")
dblock->addr = dblock_addr;
/* Don't initialize elements if paged */
if (!dblock->npages)
/* Clear any elements in data block to fill value */
if ((hdr->cparam.cls->fill)(dblock->elmts, (size_t)hdr->cparam.nelmts) < 0)
HGOTO_ERROR(H5E_FARRAY, H5E_CANTSET, HADDR_UNDEF,
"can't set fixed array data block elements to class's fill value")
/* Cache the new fixed array data block */
if (H5AC_insert_entry(hdr->f, H5AC_FARRAY_DBLOCK, dblock_addr, dblock, H5AC__NO_FLAGS_SET) < 0)
HGOTO_ERROR(H5E_FARRAY, H5E_CANTINSERT, HADDR_UNDEF, "can't add fixed array data block to cache")
inserted = TRUE;
/* Add data block as child of 'top' proxy */
if (hdr->top_proxy) {
if (H5AC_proxy_entry_add_child(hdr->top_proxy, hdr->f, dblock) < 0)
HGOTO_ERROR(H5E_FARRAY, H5E_CANTSET, HADDR_UNDEF,
"unable to add fixed array entry as child of array proxy")
dblock->top_proxy = hdr->top_proxy;
} /* end if */
/* Mark the header dirty (for updating statistics) */
*hdr_dirty = TRUE;
/* Set address of data block to return */
ret_value = dblock_addr;
done:
if (!H5F_addr_defined(ret_value))
if (dblock) {
/* Remove from cache, if inserted */
if (inserted)
if (H5AC_remove_entry(dblock) < 0)
HDONE_ERROR(H5E_FARRAY, H5E_CANTREMOVE, HADDR_UNDEF,
"unable to remove fixed array data block from cache")
/* Release data block's disk space */
if (H5F_addr_defined(dblock->addr) &&
H5MF_xfree(hdr->f, H5FD_MEM_FARRAY_DBLOCK, dblock->addr, (hsize_t)dblock->size) < 0)
HDONE_ERROR(H5E_FARRAY, H5E_CANTFREE, HADDR_UNDEF, "unable to release fixed array data block")
/* Destroy data block */
if (H5FA__dblock_dest(dblock) < 0)
HDONE_ERROR(H5E_FARRAY, H5E_CANTFREE, HADDR_UNDEF, "unable to destroy fixed array data block")
} /* end if */
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5FA__dblock_create() */
/*-------------------------------------------------------------------------
* Function: H5FA__dblock_protect
*
* Purpose: Convenience wrapper around protecting fixed array data block
*
* Return: Non-NULL pointer to data block on success/NULL on failure
*
* Programmer: Vailin Choi
* Thursday, April 30, 2009
*
*-------------------------------------------------------------------------
*/
H5FA_dblock_t *
H5FA__dblock_protect(H5FA_hdr_t *hdr, haddr_t dblk_addr, unsigned flags)
{
H5FA_dblock_t *dblock = NULL; /* Fixed array data block */
H5FA_dblock_cache_ud_t udata; /* Information needed for loading data block */
H5FA_dblock_t *ret_value = NULL;
FUNC_ENTER_PACKAGE
/* Sanity check */
HDassert(hdr);
HDassert(H5F_addr_defined(dblk_addr));
/* only the H5AC__READ_ONLY_FLAG flag is permitted */
HDassert((flags & (unsigned)(~H5AC__READ_ONLY_FLAG)) == 0);
/* Set up user data */
udata.hdr = hdr;
udata.dblk_addr = dblk_addr;
/* Protect the data block */
if (NULL ==
(dblock = (H5FA_dblock_t *)H5AC_protect(hdr->f, H5AC_FARRAY_DBLOCK, dblk_addr, &udata, flags)))
HGOTO_ERROR(H5E_FARRAY, H5E_CANTPROTECT, NULL,
"unable to protect fixed array data block, address = %llu", (unsigned long long)dblk_addr)
/* Create top proxy, if it doesn't exist */
if (hdr->top_proxy && NULL == dblock->top_proxy) {
/* Add data block as child of 'top' proxy */
if (H5AC_proxy_entry_add_child(hdr->top_proxy, hdr->f, dblock) < 0)
HGOTO_ERROR(H5E_FARRAY, H5E_CANTSET, NULL,
"unable to add fixed array entry as child of array proxy")
dblock->top_proxy = hdr->top_proxy;
} /* end if */
/* Set return value */
ret_value = dblock;
done:
/* Clean up on error */
if (!ret_value)
/* Release the data block, if it was protected */
if (dblock &&
H5AC_unprotect(hdr->f, H5AC_FARRAY_DBLOCK, dblock->addr, dblock, H5AC__NO_FLAGS_SET) < 0)
HDONE_ERROR(H5E_FARRAY, H5E_CANTUNPROTECT, NULL,
"unable to unprotect fixed array data block, address = %llu",
(unsigned long long)dblock->addr)
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5FA__dblock_protect() */
/*-------------------------------------------------------------------------
* Function: H5FA__dblock_unprotect
*
* Purpose: Convenience wrapper around unprotecting fixed array data block
*
* Return: SUCCEED/FAIL
*
* Programmer: Vailin Choi
* Thursday, April 30, 2009
*
*-------------------------------------------------------------------------
*/
herr_t
H5FA__dblock_unprotect(H5FA_dblock_t *dblock, unsigned cache_flags)
{
herr_t ret_value = SUCCEED;
FUNC_ENTER_PACKAGE
/* Sanity check */
HDassert(dblock);
/* Unprotect the data block */
if (H5AC_unprotect(dblock->hdr->f, H5AC_FARRAY_DBLOCK, dblock->addr, dblock, cache_flags) < 0)
HGOTO_ERROR(H5E_FARRAY, H5E_CANTUNPROTECT, FAIL,
"unable to unprotect fixed array data block, address = %llu",
(unsigned long long)dblock->addr)
done:
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5FA__dblock_unprotect() */
/*-------------------------------------------------------------------------
* Function: H5FA__dblock_delete
*
* Purpose: Delete a data block
*
* Return: SUCCEED/FAIL
*
* Programmer: Vailin Choi
* Thursday, April 30, 2009
*
*-------------------------------------------------------------------------
*/
herr_t
H5FA__dblock_delete(H5FA_hdr_t *hdr, haddr_t dblk_addr)
{
H5FA_dblock_t *dblock = NULL; /* Pointer to data block */
herr_t ret_value = SUCCEED;
FUNC_ENTER_PACKAGE
/* Sanity check */
HDassert(hdr);
HDassert(H5F_addr_defined(dblk_addr));
/* Protect data block */
if (NULL == (dblock = H5FA__dblock_protect(hdr, dblk_addr, H5AC__NO_FLAGS_SET)))
HGOTO_ERROR(H5E_FARRAY, H5E_CANTPROTECT, FAIL,
"unable to protect fixed array data block, address = %llu", (unsigned long long)dblk_addr)
/* Check if data block is paged */
if (dblock->npages) {
haddr_t dblk_page_addr; /* Address of each data block page */
size_t u; /* Local index variable */
/* Set up initial state */
dblk_page_addr = dblk_addr + H5FA_DBLOCK_PREFIX_SIZE(dblock);
/* Iterate over pages in data block */
for (u = 0; u < dblock->npages; u++) {
/* Evict the data block page from the metadata cache */
/* (OK to call if it doesn't exist in the cache) */
if (H5AC_expunge_entry(hdr->f, H5AC_FARRAY_DBLK_PAGE, dblk_page_addr, H5AC__NO_FLAGS_SET) < 0)
HGOTO_ERROR(H5E_FARRAY, H5E_CANTEXPUNGE, FAIL,
"unable to remove array data block page from metadata cache")
/* Advance to next page address */
dblk_page_addr += dblock->dblk_page_size;
} /* end for */
} /* end if */
done:
/* Finished deleting data block in metadata cache */
if (dblock && H5FA__dblock_unprotect(dblock, H5AC__DIRTIED_FLAG | H5AC__DELETED_FLAG |
H5AC__FREE_FILE_SPACE_FLAG) < 0)
HDONE_ERROR(H5E_FARRAY, H5E_CANTUNPROTECT, FAIL, "unable to release fixed array data block")
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5FA__dblock_delete() */
/*-------------------------------------------------------------------------
* Function: H5FA__dblock_dest
*
* Purpose: Destroys a fixed array data block in memory.
*
* Return: SUCCEED/FAIL
*
* Programmer: Vailin Choi
* Thursday, April 30, 2009
*
*-------------------------------------------------------------------------
*/
herr_t
H5FA__dblock_dest(H5FA_dblock_t *dblock)
{
herr_t ret_value = SUCCEED;
FUNC_ENTER_PACKAGE
/* Sanity check */
HDassert(dblock);
/* Check if shared header field has been initialized */
if (dblock->hdr) {
/* Check if we've got elements in the data block */
if (dblock->elmts && !dblock->npages) {
/* Free buffer for data block elements */
HDassert(dblock->hdr->cparam.nelmts > 0);
dblock->elmts = H5FL_BLK_FREE(chunk_elmts, dblock->elmts);
} /* end if */
/* Check if data block is paged */
if (dblock->npages) {
/* Free buffer for 'page init' bitmask, if there is one */
HDassert(dblock->dblk_page_init_size > 0);
if (dblock->dblk_page_init)
dblock->dblk_page_init = H5FL_BLK_FREE(fa_page_init, dblock->dblk_page_init);
} /* end if */
/* Decrement reference count on shared info */
if (H5FA__hdr_decr(dblock->hdr) < 0)
HGOTO_ERROR(H5E_FARRAY, H5E_CANTDEC, FAIL,
"can't decrement reference count on shared array header")
dblock->hdr = NULL;
} /* end if */
/* Sanity check */
HDassert(NULL == dblock->top_proxy);
/* Free the data block itself */
dblock = H5FL_FREE(H5FA_dblock_t, dblock);
done:
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5FA__dblock_dest() */
lue='dev_8_1_stubs_branch'>dev_8_1_stubs_branch
Tcl is a high-level, general-purpose, interpreted, dynamic programming language. It was designed with the goal of being very simple but powerful.
#include <tommath.h>#ifdef BN_MP_DIV_2D_C/* LibTomMath, multiple-precision integer library -- Tom St Denis * * LibTomMath is a library that provides multiple-precision * integer arithmetic as well as number theoretic functionality. * * The library was designed directly after the MPI library by * Michael Fromberger but has been written from scratch with * additional optimizations in place. * * The library is free for all purposes without any express * guarantee it works. * * Tom St Denis, tomstdenis@gmail.com, http://math.libtomcrypt.com *//* shift right by a certain bit count (store quotient in c, optional remainder in d) */intmp_div_2d(const mp_int * a,int b, mp_int * c, mp_int * d){
mp_digit D, r, rr;int x, res;
mp_int t;/* if the shift count is <= 0 then we do no work */if(b <=0) {
res =mp_copy(a, c);if(d != NULL) {mp_zero(d);}return res;}if((res =mp_init(&t)) != MP_OKAY) {return res;}/* get the remainder */if(d != NULL) {if((res =mp_mod_2d(a, b, &t)) != MP_OKAY) {mp_clear(&t);return res;}}/* copy */if((res =mp_copy(a, c)) != MP_OKAY) {mp_clear(&t);return res;}/* shift by as many digits in the bit count */if(b >= (int)DIGIT_BIT) {mp_rshd(c, b / DIGIT_BIT);}/* shift any bit count < DIGIT_BIT */
D = (mp_digit) (b % DIGIT_BIT);if(D !=0) {register mp_digit *tmpc, mask, shift;/* mask */
mask = (((mp_digit)1) << D) -1;/* shift for lsb */
shift = DIGIT_BIT - D;/* alias */
tmpc = c->dp + (c->used -1);/* carry */
r =0;for(x = c->used -1; x >=0; x--) {/* get the lower bits of this word in a temp */
rr = *tmpc & mask;/* shift the current word and mix in the carry bits from the previous word */*tmpc = (*tmpc >> D) | (r << shift);--tmpc;/* set the carry to the carry bits of the current word found above */
r = rr;}}mp_clamp(c);if(d != NULL) {mp_exch(&t, d);}mp_clear(&t);return MP_OKAY;}#endif