[mpich-commits] [mpich] MPICH primary repository branch, master, updated. v3.2-370-g0d64123
Service Account
noreply at mpich.org
Tue Jul 26 12:36:23 CDT 2016
This is an automated email from the git hooks/post-receive script. It was
generated because a ref change was pushed to the repository containing
the project "MPICH primary repository".
The branch, master has been updated
via 0d6412303488428c461986655a56639cbbdbf705 (commit)
from f43c017cea598e37088d75a58a87b714ce4e8921 (commit)
Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.
- Log -----------------------------------------------------------------
http://git.mpich.org/mpich.git/commitdiff/0d6412303488428c461986655a56639cbbdbf705
commit 0d6412303488428c461986655a56639cbbdbf705
Author: Sayantan Sur <sayantan.sur at intel.com>
Date: Thu Jan 7 18:24:53 2016 -0800
MPL: Provide uthash implementation
Provide a single, prefixed version of uthash in MPL. This way it can
easily be used by other components in the future, such as Hydra.
Signed-off-by: Ken Raffenetti <raffenet at mcs.anl.gov>
diff --git a/src/include/Makefile.mk b/src/include/Makefile.mk
index 7da2717..7e685fe 100644
--- a/src/include/Makefile.mk
+++ b/src/include/Makefile.mk
@@ -63,7 +63,6 @@ noinst_HEADERS += \
src/include/mpir_op.h \
src/include/mpir_process.h \
src/include/mpir_utarray.h \
- src/include/mpir_uthash.h \
src/include/mpir_misc.h \
src/include/mpir_tags.h \
src/include/mpir_datatype.h \
diff --git a/src/include/mpit.h b/src/include/mpit.h
index d2e2986..a8e7a08 100644
--- a/src/include/mpit.h
+++ b/src/include/mpit.h
@@ -44,7 +44,7 @@ static inline cvar_table_entry_t * LOOKUP_CVAR_BY_NAME(const char* cvar_name)
{
unsigned cvar_idx;
name2index_hash_t *hash_entry;
- HASH_FIND_STR(cvar_hash, cvar_name, hash_entry);
+ MPL_HASH_FIND_STR(cvar_hash, cvar_name, hash_entry);
MPIR_Assert(hash_entry != NULL);
cvar_idx = hash_entry->idx;
return (cvar_table_entry_t *)utarray_eltptr(cvar_table, cvar_idx);
diff --git a/src/include/mpitimpl.h b/src/include/mpitimpl.h
index c3a9d03..bacf7c0 100644
--- a/src/include/mpitimpl.h
+++ b/src/include/mpitimpl.h
@@ -16,7 +16,7 @@
#include "mpir_assert.h"
#include "mpir_pointers.h"
#include "mpir_utarray.h"
-#include "mpir_uthash.h"
+#include "mpl_uthash.h"
#include "mpir_objects.h"
#ifdef HAVE_ERROR_CHECKING
@@ -58,7 +58,7 @@ typedef struct {
typedef struct {
const char *name;
unsigned idx;
- UT_hash_handle hh; /* Makes this structure hashable */
+ MPL_UT_hash_handle hh; /* Makes this structure hashable */
} name2index_hash_t;
/* MPI_T control variable (cvar)
diff --git a/src/mpi/comm/commutil.c b/src/mpi/comm/commutil.c
index 3129d6a..c365612 100644
--- a/src/mpi/comm/commutil.c
+++ b/src/mpi/comm/commutil.c
@@ -9,7 +9,7 @@
#include "mpir_info.h" /* MPIR_Info_free */
#include "mpl_utlist.h"
-#include "mpir_uthash.h"
+#include "mpl_uthash.h"
/* This is the utility file for comm that contains the basic comm items
and storage management */
@@ -39,7 +39,7 @@ struct MPIR_Comm_hint_fn_elt {
char name[MPI_MAX_INFO_KEY];
MPIR_Comm_hint_fn_t fn;
void *state;
- UT_hash_handle hh;
+ MPL_UT_hash_handle hh;
};
static struct MPIR_Comm_hint_fn_elt *MPID_hint_fns = NULL;
@@ -1091,7 +1091,7 @@ int MPII_Comm_apply_hints(MPIR_Comm * comm_ptr, MPIR_Info * info_ptr)
strncpy(hint_name, hint->key, MPI_MAX_INFO_KEY);
- HASH_FIND_STR(MPID_hint_fns, hint_name, hint_fn);
+ MPL_HASH_FIND_STR(MPID_hint_fns, hint_name, hint_fn);
/* Skip hints that MPICH doesn't recognize. */
if (hint_fn) {
@@ -1121,8 +1121,8 @@ static int free_hint_handles(void *ignore)
MPIR_FUNC_TERSE_ENTER(MPID_STATE_MPIR_COMM_FREE_HINT_HANDLES);
if (MPID_hint_fns) {
- HASH_ITER(hh, MPID_hint_fns, curr_hint, tmp) {
- HASH_DEL(MPID_hint_fns, curr_hint);
+ MPL_HASH_ITER(hh, MPID_hint_fns, curr_hint, tmp) {
+ MPL_HASH_DEL(MPID_hint_fns, curr_hint);
MPL_free(curr_hint);
}
}
@@ -1154,7 +1154,7 @@ int MPIR_Comm_register_hint(const char *hint_key, MPIR_Comm_hint_fn_t fn, void *
hint_elt->state = state;
hint_elt->fn = fn;
- HASH_ADD_STR(MPID_hint_fns, name, hint_elt);
+ MPL_HASH_ADD_STR(MPID_hint_fns, name, hint_elt);
MPIR_FUNC_TERSE_EXIT(MPID_STATE_MPIR_COMM_REGISTER_HINT);
return mpi_errno;
diff --git a/src/mpi/comm/contextid.c b/src/mpi/comm/contextid.c
index bffb158..d43d677 100644
--- a/src/mpi/comm/contextid.c
+++ b/src/mpi/comm/contextid.c
@@ -9,7 +9,6 @@
#include "mpir_info.h" /* MPIR_Info_free */
#include "mpl_utlist.h"
-#include "mpir_uthash.h"
/*
=== BEGIN_MPI_T_CVAR_INFO_BLOCK ===
diff --git a/src/mpi_t/cat_get_index.c b/src/mpi_t/cat_get_index.c
index e50ced8..a9f3254 100644
--- a/src/mpi_t/cat_get_index.c
+++ b/src/mpi_t/cat_get_index.c
@@ -71,7 +71,7 @@ int MPI_T_category_get_index(const char *name, int *cat_index)
name2index_hash_t *hash_entry;
/* Do hash lookup by the name */
- HASH_FIND_STR(cat_hash, name, hash_entry);
+ MPL_HASH_FIND_STR(cat_hash, name, hash_entry);
if (hash_entry != NULL) {
*cat_index = hash_entry->idx;
} else {
diff --git a/src/mpi_t/cvar_get_index.c b/src/mpi_t/cvar_get_index.c
index f49cbc4..050b20c 100644
--- a/src/mpi_t/cvar_get_index.c
+++ b/src/mpi_t/cvar_get_index.c
@@ -71,7 +71,7 @@ int MPI_T_cvar_get_index(const char *name, int *cvar_index)
name2index_hash_t *hash_entry;
/* Do hash lookup by the name */
- HASH_FIND_STR(cvar_hash, name, hash_entry);
+ MPL_HASH_FIND_STR(cvar_hash, name, hash_entry);
if (hash_entry != NULL) {
*cvar_index = hash_entry->idx;
} else {
diff --git a/src/mpi_t/mpit.c b/src/mpi_t/mpit.c
index cb8c2dc..588d5be 100644
--- a/src/mpi_t/mpit.c
+++ b/src/mpi_t/mpit.c
@@ -94,7 +94,7 @@ static cat_table_entry_t *MPIR_T_cat_create(const char *cat_name)
/* Need not to Strdup cat_name, since cat_table and cat_hash co-exist */
hash_entry->name = cat_name;
hash_entry->idx = cat_idx;
- HASH_ADD_KEYPTR(hh, cat_hash, hash_entry->name,
+ MPL_HASH_ADD_KEYPTR(hh, cat_hash, hash_entry->name,
strlen(hash_entry->name), hash_entry);
return cat;
@@ -115,7 +115,7 @@ int MPIR_T_cat_add_pvar(const char *cat_name, int pvar_index)
if (cat_name == NULL || *cat_name == '\0')
goto fn_exit;
- HASH_FIND_STR(cat_hash, cat_name, hash_entry);
+ MPL_HASH_FIND_STR(cat_hash, cat_name, hash_entry);
if (hash_entry != NULL) {
/* Found it, i.e., category already exists */
@@ -149,7 +149,7 @@ int MPIR_T_cat_add_cvar(const char *cat_name, int cvar_index)
if (cat_name == NULL || *cat_name == '\0')
goto fn_exit;
- HASH_FIND_STR(cat_hash, cat_name, hash_entry);
+ MPL_HASH_FIND_STR(cat_hash, cat_name, hash_entry);
if (hash_entry != NULL) {
/* Found it, i.e., category already exists */
@@ -188,7 +188,7 @@ int MPIR_T_cat_add_subcat(const char *parent_name, const char *child_name)
}
/* Find or create parent */
- HASH_FIND_STR(cat_hash, parent_name, hash_entry);
+ MPL_HASH_FIND_STR(cat_hash, parent_name, hash_entry);
if (hash_entry != NULL) {
/* Found parent in cat_table */
parent_index = hash_entry->idx;
@@ -199,7 +199,7 @@ int MPIR_T_cat_add_subcat(const char *parent_name, const char *child_name)
}
/* Find or create child */
- HASH_FIND_STR(cat_hash, child_name, hash_entry);
+ MPL_HASH_FIND_STR(cat_hash, child_name, hash_entry);
if (hash_entry != NULL) {
/* Found child in cat_table */
child_index = hash_entry->idx;
@@ -235,7 +235,7 @@ int MPIR_T_cat_add_desc(const char *cat_name, const char *cat_desc)
MPIR_Assert(cat_name);
MPIR_Assert(cat_desc);
- HASH_FIND_STR(cat_hash, cat_name, hash_entry);
+ MPL_HASH_FIND_STR(cat_hash, cat_name, hash_entry);
if (hash_entry != NULL) {
/* Found it, i.e., category already exists */
@@ -284,7 +284,7 @@ void MPIR_T_CVAR_REGISTER_impl(
int cvar_idx;
/* Check whether this is a replicated cvar, whose name is unique. */
- HASH_FIND_STR(cvar_hash, name, hash_entry);
+ MPL_HASH_FIND_STR(cvar_hash, name, hash_entry);
if (hash_entry != NULL) {
/* Found it, the cvar already exists */
@@ -332,7 +332,7 @@ void MPIR_T_CVAR_REGISTER_impl(
/* Need not to Strdup name, since cvar_table and cvar_hash co-exist */
hash_entry->name =name;
hash_entry->idx = cvar_idx;
- HASH_ADD_KEYPTR(hh, cvar_hash, hash_entry->name,
+ MPL_HASH_ADD_KEYPTR(hh, cvar_hash, hash_entry->name,
strlen(hash_entry->name), hash_entry);
/* Add the cvar to a category */
@@ -370,7 +370,7 @@ void MPIR_T_PVAR_REGISTER_impl(
int seq = varclass - MPIR_T_PVAR_CLASS_FIRST;
/* Check whether this is a replicated pvar, whose name is unique per class */
- HASH_FIND_STR(pvar_hashs[seq], name, hash_entry);
+ MPL_HASH_FIND_STR(pvar_hashs[seq], name, hash_entry);
if (hash_entry != NULL) {
/* Found it, the pvar already exists */
@@ -407,7 +407,7 @@ void MPIR_T_PVAR_REGISTER_impl(
/* Need not to Strdup name, since pvar_table and pvar_hashs co-exist */
hash_entry->name = name;
hash_entry->idx = pvar_idx;
- HASH_ADD_KEYPTR(hh, pvar_hashs[seq], hash_entry->name,
+ MPL_HASH_ADD_KEYPTR(hh, pvar_hashs[seq], hash_entry->name,
strlen(hash_entry->name), hash_entry);
/* Add the pvar to a category */
diff --git a/src/mpi_t/mpit_finalize.c b/src/mpi_t/mpit_finalize.c
index 04da543..fb19042 100644
--- a/src/mpi_t/mpit_finalize.c
+++ b/src/mpi_t/mpit_finalize.c
@@ -77,13 +77,13 @@ static void MPIR_T_cat_env_finalize(void)
if (cat_hash) {
name2index_hash_t *current, *tmp;
/* Free all entries */
- HASH_ITER(hh, cat_hash, current, tmp) {
- HASH_DEL(cat_hash, current);
+ MPL_HASH_ITER(hh, cat_hash, current, tmp) {
+ MPL_HASH_DEL(cat_hash, current);
MPL_free(current);
}
/* Free cat_hash itself */
- HASH_CLEAR(hh, cat_hash);
+ MPL_HASH_CLEAR(hh, cat_hash);
cat_hash = NULL;
}
}
@@ -113,13 +113,13 @@ static void MPIR_T_cvar_env_finalize(void)
if (cvar_hash) {
name2index_hash_t *current, *tmp;
/* Free all entries */
- HASH_ITER(hh, cvar_hash, current, tmp) {
- HASH_DEL(cvar_hash, current);
+ MPL_HASH_ITER(hh, cvar_hash, current, tmp) {
+ MPL_HASH_DEL(cvar_hash, current);
MPL_free(current);
}
/* Free cvar_hash itself */
- HASH_CLEAR(hh, cvar_hash);
+ MPL_HASH_CLEAR(hh, cvar_hash);
cvar_hash = NULL;
}
}
@@ -146,13 +146,13 @@ static void MPIR_T_pvar_env_finalize(void)
if (pvar_hashs[i]) {
name2index_hash_t *current, *tmp;
/* Free all entries */
- HASH_ITER(hh, pvar_hashs[i], current, tmp) {
- HASH_DEL(pvar_hashs[i], current);
+ MPL_HASH_ITER(hh, pvar_hashs[i], current, tmp) {
+ MPL_HASH_DEL(pvar_hashs[i], current);
MPL_free(current);
}
/* Free pvar_hashs[i] itself */
- HASH_CLEAR(hh, pvar_hashs[i]);
+ MPL_HASH_CLEAR(hh, pvar_hashs[i]);
pvar_hashs[i] = NULL;
}
}
diff --git a/src/mpi_t/pvar_get_index.c b/src/mpi_t/pvar_get_index.c
index 6ca9e59..d528814 100644
--- a/src/mpi_t/pvar_get_index.c
+++ b/src/mpi_t/pvar_get_index.c
@@ -79,7 +79,7 @@ int MPI_T_pvar_get_index(const char *name, int var_class, int *pvar_index)
name2index_hash_t *hash_entry;
/* Do hash lookup by the name */
- HASH_FIND_STR(pvar_hashs[seq], name, hash_entry);
+ MPL_HASH_FIND_STR(pvar_hashs[seq], name, hash_entry);
if (hash_entry != NULL) {
*pvar_index = hash_entry->idx;
} else {
diff --git a/src/include/mpir_uthash.h b/src/mpl/include/mpl_uthash.h
old mode 100644
new mode 100755
similarity index 57%
rename from src/include/mpir_uthash.h
rename to src/mpl/include/mpl_uthash.h
index 8efbff9..ba46af1
--- a/src/include/mpir_uthash.h
+++ b/src/mpl/include/mpl_uthash.h
@@ -1,16 +1,13 @@
-/* MPICH-local modifications:
+/* MPICH changes:
*
- * 1) Rename header from "uthash.h" to "mpir_uthash.h" to avoid accidentally
- * pulling in a system-installed version of the header.
- *
- * 2) Use MPL_malloc/MPL_free instead of malloc/free
- *
- * The actual macros themselves have not been namespaced, so if a plain
- * "uthash.h" is included anywhere in the tree then there could be a conflict.
+ * - The file name has been changed to avoid conflicts with any system-installed
+ * "uthash.h" header files.
+ * - some configure-time checking for __typeof() support was added
+ * - intentionally omitted from "mpl.h" in order to require using code to opt-in
+ * - override malloc/free/realloc to call MPL routines
*/
-
/*
-Copyright (c) 2003-2013, Troy D. Hanson http://troydhanson.github.com/uthash/
+Copyright (c) 2003-2014, Troy D. Hanson http://troydhanson.github.com/uthash/
All rights reserved.
Redistribution and use in source and binary forms, with or without
@@ -32,183 +29,201 @@ NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
-#ifndef MPIR_UTHASH_H_INCLUDED
-#define MPIR_UTHASH_H_INCLUDED
+#ifndef MPL_UTHASH_H
+#define MPL_UTHASH_H
#include <string.h> /* memcmp,strlen */
#include <stddef.h> /* ptrdiff_t */
#include <stdlib.h> /* exit() */
+#ifdef MPL_HAVE___TYPEOF /* MPICH modification */
/* These macros use decltype or the earlier __typeof GNU extension.
As decltype is only available in newer compilers (VS2010 or gcc 4.3+
when compiling c++ source) this code uses whatever method is needed
or, for VS2008 where neither is available, uses casting workarounds. */
-#ifdef _MSC_VER /* MS compiler */
+#if defined(_MSC_VER) /* MS compiler */
#if _MSC_VER >= 1600 && defined(__cplusplus) /* VS2010 or newer in C++ mode */
-#define DECLTYPE(x) (decltype(x))
+#define MPL_DECLTYPE(x) (decltype(x))
#else /* VS2008 or older (or VS2010 in C mode) */
-#define NO_DECLTYPE
-#define DECLTYPE(x)
+#define MPL_NO_DECLTYPE
+#define MPL_DECLTYPE(x)
#endif
+#elif defined(__BORLANDC__) || defined(__LCC__) || defined(__WATCOMC__)
+#define MPL_NO_DECLTYPE
+#define MPL_DECLTYPE(x)
#else /* GNU, Sun and other compilers */
-#define DECLTYPE(x) (__typeof(x))
+#define MPL_DECLTYPE(x) (__typeof(x))
#endif
+#else /* !MPL_HAVE___TYPEOF */
+#define MPL_NO_DECLTYPE
+#define MPL_DECLTYPE(x)
+#endif /* !MPL_HAVE__TYPEOF */
-#ifdef NO_DECLTYPE
-#define DECLTYPE_ASSIGN(dst,src) \
+
+#ifdef MPL_NO_DECLTYPE
+#define MPL_DECLTYPE_ASSIGN(dst,src) \
do { \
char **_da_dst = (char**)(&(dst)); \
*_da_dst = (char*)(src); \
} while(0)
#else
-#define DECLTYPE_ASSIGN(dst,src) \
+#define MPL_DECLTYPE_ASSIGN(dst,src) \
do { \
- (dst) = DECLTYPE(dst)(src); \
+ (dst) = MPL_DECLTYPE(dst)(src); \
} while(0)
#endif
-/* a number of the hash function use uint32_t which isn't defined on win32 */
-#ifdef _MSC_VER
+/* a number of the hash function use uint32_t which isn't defined on Pre VS2010 */
+#if defined(_WIN32)
+#if defined(_MSC_VER) && _MSC_VER >= 1600
+#include <stdint.h>
+#elif defined(__WATCOMC__) || defined(__MINGW32__) || defined(__CYGWIN__)
+#include <stdint.h>
+#else
typedef unsigned int uint32_t;
typedef unsigned char uint8_t;
+#endif
+#elif defined(__GNUC__) && !defined(__VXWORKS__)
+#include <stdint.h>
#else
-#include <inttypes.h> /* uint32_t */
+typedef unsigned int uint32_t;
+typedef unsigned char uint8_t;
#endif
-#define UTHASH_VERSION 1.9.8
+#define MPL_UTHASH_VERSION 1.9.9
-#ifndef uthash_fatal
-#define uthash_fatal(msg) exit(-1) /* fatal error (out of memory,etc) */
+#ifndef MPL_uthash_fatal
+#define MPL_uthash_fatal(msg) exit(-1) /* fatal error (out of memory,etc) */
#endif
-#ifndef uthash_malloc
-#define uthash_malloc(sz) MPL_malloc(sz) /* malloc fcn */
+#ifndef MPL_uthash_malloc
+#define MPL_uthash_malloc(sz) MPL_malloc(sz) /* malloc fcn */
#endif
-#ifndef uthash_free
-#define uthash_free(ptr,sz) MPL_free(ptr) /* free fcn */
+#ifndef MPL_uthash_free
+#define MPL_uthash_free(ptr,sz) MPL_free(ptr) /* free fcn */
#endif
-#ifndef uthash_noexpand_fyi
-#define uthash_noexpand_fyi(tbl) /* can be defined to log noexpand */
+#ifndef MPL_uthash_noexpand_fyi
+#define MPL_uthash_noexpand_fyi(tbl) /* can be defined to log noexpand */
#endif
-#ifndef uthash_expand_fyi
-#define uthash_expand_fyi(tbl) /* can be defined to log expands */
+#ifndef MPL_uthash_expand_fyi
+#define MPL_uthash_expand_fyi(tbl) /* can be defined to log expands */
#endif
/* initial number of buckets */
-#define HASH_INITIAL_NUM_BUCKETS 32 /* initial number of buckets */
-#define HASH_INITIAL_NUM_BUCKETS_LOG2 5 /* lg2 of initial number of buckets */
-#define HASH_BKT_CAPACITY_THRESH 10 /* expand when bucket count reaches */
+#define MPL_HASH_INITIAL_NUM_BUCKETS 32U /* initial number of buckets */
+#define MPL_HASH_INITIAL_NUM_BUCKETS_LOG2 5U /* lg2 of initial number of buckets */
+#define MPL_HASH_BKT_CAPACITY_THRESH 10U /* expand when bucket count reaches */
/* calculate the element whose hash handle address is hhe */
-#define ELMT_FROM_HH(tbl,hhp) ((void*)(((char*)(hhp)) - ((tbl)->hho)))
+#define MPL_ELMT_FROM_HH(tbl,hhp) ((void*)(((char*)(hhp)) - ((tbl)->hho)))
-#define HASH_FIND(hh,head,keyptr,keylen,out) \
+#define MPL_HASH_FIND(hh,head,keyptr,keylen,out) \
do { \
- unsigned _hf_bkt,_hf_hashv; \
out=NULL; \
- if (head) { \
- HASH_FCN(keyptr,keylen, (head)->hh.tbl->num_buckets, _hf_hashv, _hf_bkt); \
- if (HASH_BLOOM_TEST((head)->hh.tbl, _hf_hashv)) { \
- HASH_FIND_IN_BKT((head)->hh.tbl, hh, (head)->hh.tbl->buckets[ _hf_bkt ], \
+ if (head != NULL) { \
+ unsigned _hf_bkt,_hf_hashv; \
+ MPL_HASH_FCN(keyptr,keylen, (head)->hh.tbl->num_buckets, _hf_hashv, _hf_bkt); \
+ if (MPL_HASH_BLOOM_TEST((head)->hh.tbl, _hf_hashv) != 0) { \
+ MPL_HASH_FIND_IN_BKT((head)->hh.tbl, hh, (head)->hh.tbl->buckets[ _hf_bkt ], \
keyptr,keylen,out); \
} \
} \
} while (0)
-#ifdef HASH_BLOOM
-#define HASH_BLOOM_BITLEN (1ULL << HASH_BLOOM)
-#define HASH_BLOOM_BYTELEN (HASH_BLOOM_BITLEN/8) + ((HASH_BLOOM_BITLEN%8) ? 1:0)
-#define HASH_BLOOM_MAKE(tbl) \
+#ifdef MPL_HASH_BLOOM
+#define MPL_HASH_BLOOM_BITLEN (1UL << MPL_HASH_BLOOM)
+#define MPL_HASH_BLOOM_BYTELEN (MPL_HASH_BLOOM_BITLEN/8UL) + (((MPL_HASH_BLOOM_BITLEN%8UL)!=0UL) ? 1UL : 0UL)
+#define MPL_HASH_BLOOM_MAKE(tbl) \
do { \
- (tbl)->bloom_nbits = HASH_BLOOM; \
- (tbl)->bloom_bv = (uint8_t*)uthash_malloc(HASH_BLOOM_BYTELEN); \
- if (!((tbl)->bloom_bv)) { uthash_fatal( "out of memory"); } \
- memset((tbl)->bloom_bv, 0, HASH_BLOOM_BYTELEN); \
- (tbl)->bloom_sig = HASH_BLOOM_SIGNATURE; \
+ (tbl)->bloom_nbits = MPL_HASH_BLOOM; \
+ (tbl)->bloom_bv = (uint8_t*)MPL_uthash_malloc(MPL_HASH_BLOOM_BYTELEN); \
+ if (!((tbl)->bloom_bv)) { MPL_uthash_fatal( "out of memory"); } \
+ memset((tbl)->bloom_bv, 0, MPL_HASH_BLOOM_BYTELEN); \
+ (tbl)->bloom_sig = MPL_HASH_BLOOM_SIGNATURE; \
} while (0)
-#define HASH_BLOOM_FREE(tbl) \
+#define MPL_HASH_BLOOM_FREE(tbl) \
do { \
- uthash_free((tbl)->bloom_bv, HASH_BLOOM_BYTELEN); \
+ MPL_uthash_free((tbl)->bloom_bv, MPL_HASH_BLOOM_BYTELEN); \
} while (0)
-#define HASH_BLOOM_BITSET(bv,idx) (bv[(idx)/8] |= (1U << ((idx)%8)))
-#define HASH_BLOOM_BITTEST(bv,idx) (bv[(idx)/8] & (1U << ((idx)%8)))
+#define MPL_HASH_BLOOM_BITSET(bv,idx) (bv[(idx)/8U] |= (1U << ((idx)%8U)))
+#define MPL_HASH_BLOOM_BITTEST(bv,idx) (bv[(idx)/8U] & (1U << ((idx)%8U)))
-#define HASH_BLOOM_ADD(tbl,hashv) \
- HASH_BLOOM_BITSET((tbl)->bloom_bv, (hashv & (uint32_t)((1ULL << (tbl)->bloom_nbits) - 1)))
+#define MPL_HASH_BLOOM_ADD(tbl,hashv) \
+ MPL_HASH_BLOOM_BITSET((tbl)->bloom_bv, (hashv & (uint32_t)((1ULL << (tbl)->bloom_nbits) - 1U)))
-#define HASH_BLOOM_TEST(tbl,hashv) \
- HASH_BLOOM_BITTEST((tbl)->bloom_bv, (hashv & (uint32_t)((1ULL << (tbl)->bloom_nbits) - 1)))
+#define MPL_HASH_BLOOM_TEST(tbl,hashv) \
+ MPL_HASH_BLOOM_BITTEST((tbl)->bloom_bv, (hashv & (uint32_t)((1ULL << (tbl)->bloom_nbits) - 1U)))
#else
-#define HASH_BLOOM_MAKE(tbl)
-#define HASH_BLOOM_FREE(tbl)
-#define HASH_BLOOM_ADD(tbl,hashv)
-#define HASH_BLOOM_TEST(tbl,hashv) (1)
-#define HASH_BLOOM_BYTELEN 0
+#define MPL_HASH_BLOOM_MAKE(tbl)
+#define MPL_HASH_BLOOM_FREE(tbl)
+#define MPL_HASH_BLOOM_ADD(tbl,hashv)
+#define MPL_HASH_BLOOM_TEST(tbl,hashv) (1)
+#define MPL_HASH_BLOOM_BYTELEN 0U
#endif
-#define HASH_MAKE_TABLE(hh,head) \
+#define MPL_HASH_MAKE_TABLE(hh,head) \
do { \
- (head)->hh.tbl = (UT_hash_table*)uthash_malloc( \
- sizeof(UT_hash_table)); \
- if (!((head)->hh.tbl)) { uthash_fatal( "out of memory"); } \
- memset((head)->hh.tbl, 0, sizeof(UT_hash_table)); \
+ (head)->hh.tbl = (MPL_UT_hash_table*)MPL_uthash_malloc( \
+ sizeof(MPL_UT_hash_table)); \
+ if (!((head)->hh.tbl)) { MPL_uthash_fatal( "out of memory"); } \
+ memset((head)->hh.tbl, 0, sizeof(MPL_UT_hash_table)); \
(head)->hh.tbl->tail = &((head)->hh); \
- (head)->hh.tbl->num_buckets = HASH_INITIAL_NUM_BUCKETS; \
- (head)->hh.tbl->log2_num_buckets = HASH_INITIAL_NUM_BUCKETS_LOG2; \
+ (head)->hh.tbl->num_buckets = MPL_HASH_INITIAL_NUM_BUCKETS; \
+ (head)->hh.tbl->log2_num_buckets = MPL_HASH_INITIAL_NUM_BUCKETS_LOG2; \
(head)->hh.tbl->hho = (char*)(&(head)->hh) - (char*)(head); \
- (head)->hh.tbl->buckets = (UT_hash_bucket*)uthash_malloc( \
- HASH_INITIAL_NUM_BUCKETS*sizeof(struct UT_hash_bucket)); \
- if (! (head)->hh.tbl->buckets) { uthash_fatal( "out of memory"); } \
+ (head)->hh.tbl->buckets = (MPL_UT_hash_bucket*)MPL_uthash_malloc( \
+ MPL_HASH_INITIAL_NUM_BUCKETS*sizeof(struct MPL_UT_hash_bucket)); \
+ if (! (head)->hh.tbl->buckets) { MPL_uthash_fatal( "out of memory"); } \
memset((head)->hh.tbl->buckets, 0, \
- HASH_INITIAL_NUM_BUCKETS*sizeof(struct UT_hash_bucket)); \
- HASH_BLOOM_MAKE((head)->hh.tbl); \
- (head)->hh.tbl->signature = HASH_SIGNATURE; \
+ MPL_HASH_INITIAL_NUM_BUCKETS*sizeof(struct MPL_UT_hash_bucket)); \
+ MPL_HASH_BLOOM_MAKE((head)->hh.tbl); \
+ (head)->hh.tbl->signature = MPL_HASH_SIGNATURE; \
} while(0)
-#define HASH_ADD(hh,head,fieldname,keylen_in,add) \
- HASH_ADD_KEYPTR(hh,head,&((add)->fieldname),keylen_in,add)
+#define MPL_HASH_ADD(hh,head,fieldname,keylen_in,add) \
+ MPL_HASH_ADD_KEYPTR(hh,head,&((add)->fieldname),keylen_in,add)
-#define HASH_REPLACE(hh,head,fieldname,keylen_in,add,replaced) \
+#define MPL_HASH_REPLACE(hh,head,fieldname,keylen_in,add,replaced) \
do { \
replaced=NULL; \
- HASH_FIND(hh,head,&((add)->fieldname),keylen_in,replaced); \
+ MPL_HASH_FIND(hh,head,&((add)->fieldname),keylen_in,replaced); \
if (replaced!=NULL) { \
- HASH_DELETE(hh,head,replaced); \
- }; \
- HASH_ADD(hh,head,fieldname,keylen_in,add); \
+ MPL_HASH_DELETE(hh,head,replaced); \
+ } \
+ MPL_HASH_ADD(hh,head,fieldname,keylen_in,add); \
} while(0)
-#define HASH_ADD_KEYPTR(hh,head,keyptr,keylen_in,add) \
+#define MPL_HASH_ADD_KEYPTR(hh,head,keyptr,keylen_in,add) \
do { \
unsigned _ha_bkt; \
(add)->hh.next = NULL; \
- (add)->hh.key = (char*)keyptr; \
- (add)->hh.keylen = (unsigned)keylen_in; \
+ (add)->hh.key = (char*)(keyptr); \
+ (add)->hh.keylen = (unsigned)(keylen_in); \
if (!(head)) { \
head = (add); \
(head)->hh.prev = NULL; \
- HASH_MAKE_TABLE(hh,head); \
+ MPL_HASH_MAKE_TABLE(hh,head); \
} else { \
(head)->hh.tbl->tail->next = (add); \
- (add)->hh.prev = ELMT_FROM_HH((head)->hh.tbl, (head)->hh.tbl->tail); \
+ (add)->hh.prev = MPL_ELMT_FROM_HH((head)->hh.tbl, (head)->hh.tbl->tail); \
(head)->hh.tbl->tail = &((add)->hh); \
} \
(head)->hh.tbl->num_items++; \
(add)->hh.tbl = (head)->hh.tbl; \
- HASH_FCN(keyptr,keylen_in, (head)->hh.tbl->num_buckets, \
+ MPL_HASH_FCN(keyptr,keylen_in, (head)->hh.tbl->num_buckets, \
(add)->hh.hashv, _ha_bkt); \
- HASH_ADD_TO_BKT((head)->hh.tbl->buckets[_ha_bkt],&(add)->hh); \
- HASH_BLOOM_ADD((head)->hh.tbl,(add)->hh.hashv); \
- HASH_EMIT_KEY(hh,head,keyptr,keylen_in); \
- HASH_FSCK(hh,head); \
+ MPL_HASH_ADD_TO_BKT((head)->hh.tbl->buckets[_ha_bkt],&(add)->hh); \
+ MPL_HASH_BLOOM_ADD((head)->hh.tbl,(add)->hh.hashv); \
+ MPL_HASH_EMIT_KEY(hh,head,keyptr,keylen_in); \
+ MPL_HASH_FSCK(hh,head); \
} while(0)
-#define HASH_TO_BKT( hashv, num_bkts, bkt ) \
+#define MPL_HASH_TO_BKT( hashv, num_bkts, bkt ) \
do { \
- bkt = ((hashv) & ((num_bkts) - 1)); \
+ bkt = ((hashv) & ((num_bkts) - 1U)); \
} while(0)
/* delete "delptr" from the hash table.
@@ -223,84 +238,84 @@ do {
* copy the deletee pointer, then the latter references are via that
* scratch pointer rather than through the repointed (users) symbol.
*/
-#define HASH_DELETE(hh,head,delptr) \
+#define MPL_HASH_DELETE(hh,head,delptr) \
do { \
- unsigned _hd_bkt; \
- struct UT_hash_handle *_hd_hh_del; \
+ struct MPL_UT_hash_handle *_hd_hh_del; \
if ( ((delptr)->hh.prev == NULL) && ((delptr)->hh.next == NULL) ) { \
- uthash_free((head)->hh.tbl->buckets, \
- (head)->hh.tbl->num_buckets*sizeof(struct UT_hash_bucket) ); \
- HASH_BLOOM_FREE((head)->hh.tbl); \
- uthash_free((head)->hh.tbl, sizeof(UT_hash_table)); \
+ MPL_uthash_free((head)->hh.tbl->buckets, \
+ (head)->hh.tbl->num_buckets*sizeof(struct MPL_UT_hash_bucket) ); \
+ MPL_HASH_BLOOM_FREE((head)->hh.tbl); \
+ MPL_uthash_free((head)->hh.tbl, sizeof(MPL_UT_hash_table)); \
head = NULL; \
} else { \
- _hd_hh_del = &((delptr)->hh); \
- if ((delptr) == ELMT_FROM_HH((head)->hh.tbl,(head)->hh.tbl->tail)) { \
+ unsigned _hd_bkt; \
+ _hd_hh_del = (MPL_UT_hash_handle*)&((delptr)->hh); \
+ if ((delptr) == MPL_ELMT_FROM_HH((head)->hh.tbl,(head)->hh.tbl->tail)) { \
(head)->hh.tbl->tail = \
- (UT_hash_handle*)((ptrdiff_t)((delptr)->hh.prev) + \
+ (MPL_UT_hash_handle*)((ptrdiff_t)((delptr)->hh.prev) + \
(head)->hh.tbl->hho); \
} \
- if ((delptr)->hh.prev) { \
- ((UT_hash_handle*)((ptrdiff_t)((delptr)->hh.prev) + \
+ if ((delptr)->hh.prev != NULL) { \
+ ((MPL_UT_hash_handle*)((ptrdiff_t)((delptr)->hh.prev) + \
(head)->hh.tbl->hho))->next = (delptr)->hh.next; \
} else { \
- DECLTYPE_ASSIGN(head,(delptr)->hh.next); \
+ MPL_DECLTYPE_ASSIGN(head,(delptr)->hh.next); \
} \
- if (_hd_hh_del->next) { \
- ((UT_hash_handle*)((ptrdiff_t)_hd_hh_del->next + \
+ if (_hd_hh_del->next != NULL) { \
+ ((MPL_UT_hash_handle*)((ptrdiff_t)_hd_hh_del->next + \
(head)->hh.tbl->hho))->prev = \
_hd_hh_del->prev; \
} \
- HASH_TO_BKT( _hd_hh_del->hashv, (head)->hh.tbl->num_buckets, _hd_bkt); \
- HASH_DEL_IN_BKT(hh,(head)->hh.tbl->buckets[_hd_bkt], _hd_hh_del); \
+ MPL_HASH_TO_BKT( _hd_hh_del->hashv, (head)->hh.tbl->num_buckets, _hd_bkt); \
+ MPL_HASH_DEL_IN_BKT(hh,(head)->hh.tbl->buckets[_hd_bkt], _hd_hh_del); \
(head)->hh.tbl->num_items--; \
} \
- HASH_FSCK(hh,head); \
+ MPL_HASH_FSCK(hh,head); \
} while (0)
/* convenience forms of HASH_FIND/HASH_ADD/HASH_DEL */
-#define HASH_FIND_STR(head,findstr,out) \
- HASH_FIND(hh,head,findstr,strlen(findstr),out)
-#define HASH_ADD_STR(head,strfield,add) \
- HASH_ADD(hh,head,strfield,strlen(add->strfield),add)
-#define HASH_REPLACE_STR(head,strfield,add,replaced) \
- HASH_REPLACE(hh,head,strfield,strlen(add->strfield),add,replaced)
-#define HASH_FIND_INT(head,findint,out) \
- HASH_FIND(hh,head,findint,sizeof(int),out)
-#define HASH_ADD_INT(head,intfield,add) \
- HASH_ADD(hh,head,intfield,sizeof(int),add)
-#define HASH_REPLACE_INT(head,intfield,add,replaced) \
- HASH_REPLACE(hh,head,intfield,sizeof(int),add,replaced)
-#define HASH_FIND_PTR(head,findptr,out) \
- HASH_FIND(hh,head,findptr,sizeof(void *),out)
-#define HASH_ADD_PTR(head,ptrfield,add) \
- HASH_ADD(hh,head,ptrfield,sizeof(void *),add)
-#define HASH_REPLACE_PTR(head,ptrfield,add) \
- HASH_REPLACE(hh,head,ptrfield,sizeof(void *),add,replaced)
-#define HASH_DEL(head,delptr) \
- HASH_DELETE(hh,head,delptr)
+#define MPL_HASH_FIND_STR(head,findstr,out) \
+ MPL_HASH_FIND(hh,head,findstr,(unsigned)strlen(findstr),out)
+#define MPL_HASH_ADD_STR(head,strfield,add) \
+ MPL_HASH_ADD(hh,head,strfield[0],(unsigned int)strlen(add->strfield),add)
+#define MPL_HASH_REPLACE_STR(head,strfield,add,replaced) \
+ MPL_HASH_REPLACE(hh,head,strfield[0],(unsigned)strlen(add->strfield),add,replaced)
+#define MPL_HASH_FIND_INT(head,findint,out) \
+ MPL_HASH_FIND(hh,head,findint,sizeof(int),out)
+#define MPL_HASH_ADD_INT(head,intfield,add) \
+ MPL_HASH_ADD(hh,head,intfield,sizeof(int),add)
+#define MPL_HASH_REPLACE_INT(head,intfield,add,replaced) \
+ MPL_HASH_REPLACE(hh,head,intfield,sizeof(int),add,replaced)
+#define MPL_HASH_FIND_PTR(head,findptr,out) \
+ MPL_HASH_FIND(hh,head,findptr,sizeof(void *),out)
+#define MPL_HASH_ADD_PTR(head,ptrfield,add) \
+ MPL_HASH_ADD(hh,head,ptrfield,sizeof(void *),add)
+#define MPL_HASH_REPLACE_PTR(head,ptrfield,add,replaced) \
+ MPL_HASH_REPLACE(hh,head,ptrfield,sizeof(void *),add,replaced)
+#define MPL_HASH_DEL(head,delptr) \
+ MPL_HASH_DELETE(hh,head,delptr)
/* HASH_FSCK checks hash integrity on every add/delete when HASH_DEBUG is defined.
* This is for uthash developer only; it compiles away if HASH_DEBUG isn't defined.
*/
-#ifdef HASH_DEBUG
-#define HASH_OOPS(...) do { fprintf(stderr,__VA_ARGS__); exit(-1); } while (0)
-#define HASH_FSCK(hh,head) \
+#ifdef MPL_HASH_DEBUG
+#define MPL_HASH_OOPS(...) do { fprintf(stderr,__VA_ARGS__); exit(-1); } while (0)
+#define MPL_HASH_FSCK(hh,head) \
do { \
- unsigned _bkt_i; \
- unsigned _count, _bkt_count; \
- char *_prev; \
- struct UT_hash_handle *_thh; \
+ struct MPL_UT_hash_handle *_thh; \
if (head) { \
+ unsigned _bkt_i; \
+ unsigned _count; \
+ char *_prev; \
_count = 0; \
for( _bkt_i = 0; _bkt_i < (head)->hh.tbl->num_buckets; _bkt_i++) { \
- _bkt_count = 0; \
+ unsigned _bkt_count = 0; \
_thh = (head)->hh.tbl->buckets[_bkt_i].hh_head; \
_prev = NULL; \
while (_thh) { \
if (_prev != (char*)(_thh->hh_prev)) { \
- HASH_OOPS("invalid hh_prev %p, actual %p\n", \
+ MPL_HASH_OOPS("invalid hh_prev %p, actual %p\n", \
_thh->hh_prev, _prev ); \
} \
_bkt_count++; \
@@ -309,12 +324,12 @@ do {
} \
_count += _bkt_count; \
if ((head)->hh.tbl->buckets[_bkt_i].count != _bkt_count) { \
- HASH_OOPS("invalid bucket count %d, actual %d\n", \
+ MPL_HASH_OOPS("invalid bucket count %u, actual %u\n", \
(head)->hh.tbl->buckets[_bkt_i].count, _bkt_count); \
} \
} \
if (_count != (head)->hh.tbl->num_items) { \
- HASH_OOPS("invalid hh item count %d, actual %d\n", \
+ MPL_HASH_OOPS("invalid hh item count %u, actual %u\n", \
(head)->hh.tbl->num_items, _count ); \
} \
/* traverse hh in app order; check next/prev integrity, count */ \
@@ -324,81 +339,86 @@ do {
while (_thh) { \
_count++; \
if (_prev !=(char*)(_thh->prev)) { \
- HASH_OOPS("invalid prev %p, actual %p\n", \
+ MPL_HASH_OOPS("invalid prev %p, actual %p\n", \
_thh->prev, _prev ); \
} \
- _prev = (char*)ELMT_FROM_HH((head)->hh.tbl, _thh); \
- _thh = ( _thh->next ? (UT_hash_handle*)((char*)(_thh->next) + \
+ _prev = (char*)MPL_ELMT_FROM_HH((head)->hh.tbl, _thh); \
+ _thh = ( _thh->next ? (MPL_UT_hash_handle*)((char*)(_thh->next) + \
(head)->hh.tbl->hho) : NULL ); \
} \
if (_count != (head)->hh.tbl->num_items) { \
- HASH_OOPS("invalid app item count %d, actual %d\n", \
+ MPL_HASH_OOPS("invalid app item count %u, actual %u\n", \
(head)->hh.tbl->num_items, _count ); \
} \
} \
} while (0)
#else
-#define HASH_FSCK(hh,head)
+#define MPL_HASH_FSCK(hh,head)
#endif
/* When compiled with -DHASH_EMIT_KEYS, length-prefixed keys are emitted to
* the descriptor to which this macro is defined for tuning the hash function.
* The app can #include <unistd.h> to get the prototype for write(2). */
-#ifdef HASH_EMIT_KEYS
-#define HASH_EMIT_KEY(hh,head,keyptr,fieldlen) \
+#ifdef MPL_HASH_EMIT_KEYS
+#define MPL_HASH_EMIT_KEY(hh,head,keyptr,fieldlen) \
do { \
unsigned _klen = fieldlen; \
- write(HASH_EMIT_KEYS, &_klen, sizeof(_klen)); \
- write(HASH_EMIT_KEYS, keyptr, fieldlen); \
+ write(MPL_HASH_EMIT_KEYS, &_klen, sizeof(_klen)); \
+ write(MPL_HASH_EMIT_KEYS, keyptr, (unsigned long)fieldlen); \
} while (0)
#else
-#define HASH_EMIT_KEY(hh,head,keyptr,fieldlen)
+#define MPL_HASH_EMIT_KEY(hh,head,keyptr,fieldlen)
#endif
/* default to Jenkin's hash unless overridden e.g. DHASH_FUNCTION=HASH_SAX */
-#ifdef HASH_FUNCTION
-#define HASH_FCN HASH_FUNCTION
+#ifdef MPL_HASH_FUNCTION
+#define MPL_HASH_FCN MPL_HASH_FUNCTION
#else
-#define HASH_FCN HASH_JEN
+#define MPL_HASH_FCN MPL_HASH_JEN
#endif
-/* The Bernstein hash function, used in Perl prior to v5.6 */
-#define HASH_BER(key,keylen,num_bkts,hashv,bkt) \
+/* The Bernstein hash function, used in Perl prior to v5.6. Note (x<<5+x)=x*33. */
+#define MPL_HASH_BER(key,keylen,num_bkts,hashv,bkt) \
do { \
- unsigned _hb_keylen=keylen; \
- char *_hb_key=(char*)(key); \
+ unsigned _hb_keylen=(unsigned)keylen; \
+ const unsigned char *_hb_key=(const unsigned char*)(key); \
(hashv) = 0; \
- while (_hb_keylen--) { (hashv) = ((hashv) * 33) + *_hb_key++; } \
- bkt = (hashv) & (num_bkts-1); \
+ while (_hb_keylen-- != 0U) { \
+ (hashv) = (((hashv) << 5) + (hashv)) + *_hb_key++; \
+ } \
+ bkt = (hashv) & (num_bkts-1U); \
} while (0)
/* SAX/FNV/OAT/JEN hash functions are macro variants of those listed at
* http://eternallyconfuzzled.com/tuts/algorithms/jsw_tut_hashing.aspx */
-#define HASH_SAX(key,keylen,num_bkts,hashv,bkt) \
+#define MPL_HASH_SAX(key,keylen,num_bkts,hashv,bkt) \
do { \
unsigned _sx_i; \
- char *_hs_key=(char*)(key); \
+ const unsigned char *_hs_key=(const unsigned char*)(key); \
hashv = 0; \
- for(_sx_i=0; _sx_i < keylen; _sx_i++) \
+ for(_sx_i=0; _sx_i < keylen; _sx_i++) { \
hashv ^= (hashv << 5) + (hashv >> 2) + _hs_key[_sx_i]; \
- bkt = hashv & (num_bkts-1); \
+ } \
+ bkt = hashv & (num_bkts-1U); \
} while (0)
-
-#define HASH_FNV(key,keylen,num_bkts,hashv,bkt) \
+/* FNV-1a variation */
+#define MPL_HASH_FNV(key,keylen,num_bkts,hashv,bkt) \
do { \
unsigned _fn_i; \
- char *_hf_key=(char*)(key); \
- hashv = 2166136261UL; \
- for(_fn_i=0; _fn_i < keylen; _fn_i++) \
- hashv = (hashv * 16777619) ^ _hf_key[_fn_i]; \
- bkt = hashv & (num_bkts-1); \
+ const unsigned char *_hf_key=(const unsigned char*)(key); \
+ hashv = 2166136261U; \
+ for(_fn_i=0; _fn_i < keylen; _fn_i++) { \
+ hashv = hashv ^ _hf_key[_fn_i]; \
+ hashv = hashv * 16777619U; \
+ } \
+ bkt = hashv & (num_bkts-1U); \
} while(0)
-#define HASH_OAT(key,keylen,num_bkts,hashv,bkt) \
+#define MPL_HASH_OAT(key,keylen,num_bkts,hashv,bkt) \
do { \
unsigned _ho_i; \
- char *_ho_key=(char*)(key); \
+ const unsigned char *_ho_key=(const unsigned char*)(key); \
hashv = 0; \
for(_ho_i=0; _ho_i < keylen; _ho_i++) { \
hashv += _ho_key[_ho_i]; \
@@ -408,10 +428,10 @@ do {
hashv += (hashv << 3); \
hashv ^= (hashv >> 11); \
hashv += (hashv << 15); \
- bkt = hashv & (num_bkts-1); \
+ bkt = hashv & (num_bkts-1U); \
} while(0)
-#define HASH_JEN_MIX(a,b,c) \
+#define MPL_HASH_JEN_MIX(a,b,c) \
do { \
a -= b; a -= c; a ^= ( c >> 13 ); \
b -= c; b -= a; b ^= ( a << 8 ); \
@@ -424,14 +444,14 @@ do {
c -= a; c -= b; c ^= ( b >> 15 ); \
} while (0)
-#define HASH_JEN(key,keylen,num_bkts,hashv,bkt) \
+#define MPL_HASH_JEN(key,keylen,num_bkts,hashv,bkt) \
do { \
unsigned _hj_i,_hj_j,_hj_k; \
- unsigned char *_hj_key=(unsigned char*)(key); \
- hashv = 0xfeedbeef; \
- _hj_i = _hj_j = 0x9e3779b9; \
- _hj_k = (unsigned)keylen; \
- while (_hj_k >= 12) { \
+ unsigned const char *_hj_key=(unsigned const char*)(key); \
+ hashv = 0xfeedbeefu; \
+ _hj_i = _hj_j = 0x9e3779b9u; \
+ _hj_k = (unsigned)(keylen); \
+ while (_hj_k >= 12U) { \
_hj_i += (_hj_key[0] + ( (unsigned)_hj_key[1] << 8 ) \
+ ( (unsigned)_hj_key[2] << 16 ) \
+ ( (unsigned)_hj_key[3] << 24 ) ); \
@@ -442,27 +462,27 @@ do {
+ ( (unsigned)_hj_key[10] << 16 ) \
+ ( (unsigned)_hj_key[11] << 24 ) ); \
\
- HASH_JEN_MIX(_hj_i, _hj_j, hashv); \
+ MPL_HASH_JEN_MIX(_hj_i, _hj_j, hashv); \
\
_hj_key += 12; \
- _hj_k -= 12; \
+ _hj_k -= 12U; \
} \
- hashv += keylen; \
+ hashv += (unsigned)(keylen); \
switch ( _hj_k ) { \
- case 11: hashv += ( (unsigned)_hj_key[10] << 24 ); \
- case 10: hashv += ( (unsigned)_hj_key[9] << 16 ); \
- case 9: hashv += ( (unsigned)_hj_key[8] << 8 ); \
- case 8: _hj_j += ( (unsigned)_hj_key[7] << 24 ); \
- case 7: _hj_j += ( (unsigned)_hj_key[6] << 16 ); \
- case 6: _hj_j += ( (unsigned)_hj_key[5] << 8 ); \
- case 5: _hj_j += _hj_key[4]; \
- case 4: _hj_i += ( (unsigned)_hj_key[3] << 24 ); \
- case 3: _hj_i += ( (unsigned)_hj_key[2] << 16 ); \
- case 2: _hj_i += ( (unsigned)_hj_key[1] << 8 ); \
+ case 11: hashv += ( (unsigned)_hj_key[10] << 24 ); /* FALLTHROUGH */ \
+ case 10: hashv += ( (unsigned)_hj_key[9] << 16 ); /* FALLTHROUGH */ \
+ case 9: hashv += ( (unsigned)_hj_key[8] << 8 ); /* FALLTHROUGH */ \
+ case 8: _hj_j += ( (unsigned)_hj_key[7] << 24 ); /* FALLTHROUGH */ \
+ case 7: _hj_j += ( (unsigned)_hj_key[6] << 16 ); /* FALLTHROUGH */ \
+ case 6: _hj_j += ( (unsigned)_hj_key[5] << 8 ); /* FALLTHROUGH */ \
+ case 5: _hj_j += _hj_key[4]; /* FALLTHROUGH */ \
+ case 4: _hj_i += ( (unsigned)_hj_key[3] << 24 ); /* FALLTHROUGH */ \
+ case 3: _hj_i += ( (unsigned)_hj_key[2] << 16 ); /* FALLTHROUGH */ \
+ case 2: _hj_i += ( (unsigned)_hj_key[1] << 8 ); /* FALLTHROUGH */ \
case 1: _hj_i += _hj_key[0]; \
} \
- HASH_JEN_MIX(_hj_i, _hj_j, hashv); \
- bkt = hashv & (num_bkts-1); \
+ MPL_HASH_JEN_MIX(_hj_i, _hj_j, hashv); \
+ bkt = hashv & (num_bkts-1U); \
} while(0)
/* The Paul Hsieh hash function */
@@ -476,21 +496,21 @@ do {
#define get16bits(d) ((((uint32_t)(((const uint8_t *)(d))[1])) << 8) \
+(uint32_t)(((const uint8_t *)(d))[0]) )
#endif
-#define HASH_SFH(key,keylen,num_bkts,hashv,bkt) \
+#define MPL_HASH_SFH(key,keylen,num_bkts,hashv,bkt) \
do { \
- unsigned char *_sfh_key=(unsigned char*)(key); \
- uint32_t _sfh_tmp, _sfh_len = keylen; \
+ unsigned const char *_sfh_key=(unsigned const char*)(key); \
+ uint32_t _sfh_tmp, _sfh_len = (uint32_t)keylen; \
\
- int _sfh_rem = _sfh_len & 3; \
+ unsigned _sfh_rem = _sfh_len & 3U; \
_sfh_len >>= 2; \
- hashv = 0xcafebabe; \
+ hashv = 0xcafebabeu; \
\
/* Main loop */ \
- for (;_sfh_len > 0; _sfh_len--) { \
+ for (;_sfh_len > 0U; _sfh_len--) { \
hashv += get16bits (_sfh_key); \
- _sfh_tmp = (uint32_t)(get16bits (_sfh_key+2)) << 11 ^ hashv; \
+ _sfh_tmp = ((uint32_t)(get16bits (_sfh_key+2)) << 11) ^ hashv; \
hashv = (hashv << 16) ^ _sfh_tmp; \
- _sfh_key += 2*sizeof (uint16_t); \
+ _sfh_key += 2U*sizeof (uint16_t); \
hashv += hashv >> 11; \
} \
\
@@ -498,7 +518,7 @@ do {
switch (_sfh_rem) { \
case 3: hashv += get16bits (_sfh_key); \
hashv ^= hashv << 16; \
- hashv ^= (uint32_t)(_sfh_key[sizeof (uint16_t)] << 18); \
+ hashv ^= (uint32_t)(_sfh_key[sizeof (uint16_t)]) << 18; \
hashv += hashv >> 11; \
break; \
case 2: hashv += get16bits (_sfh_key); \
@@ -517,10 +537,10 @@ do {
hashv += hashv >> 17; \
hashv ^= hashv << 25; \
hashv += hashv >> 6; \
- bkt = hashv & (num_bkts-1); \
+ bkt = hashv & (num_bkts-1U); \
} while(0)
-#ifdef HASH_USING_NO_STRICT_ALIASING
+#ifdef MPL_HASH_USING_NO_STRICT_ALIASING
/* The MurmurHash exploits some CPU's (x86,x86_64) tolerance for unaligned reads.
* For other types of CPU's (e.g. Sparc) an unaligned read causes a bus error.
* MurmurHash uses the faster approach only on CPU's where we know it's safe.
@@ -531,118 +551,118 @@ do {
* cc -## a.c (where a.c is a simple test file) (Sun Studio)
*/
#if (defined(__i386__) || defined(__x86_64__) || defined(_M_IX86))
-#define MUR_GETBLOCK(p,i) p[i]
+#define MPL_MUR_GETBLOCK(p,i) p[i]
#else /* non intel */
-#define MUR_PLUS0_ALIGNED(p) (((unsigned long)p & 0x3) == 0)
-#define MUR_PLUS1_ALIGNED(p) (((unsigned long)p & 0x3) == 1)
-#define MUR_PLUS2_ALIGNED(p) (((unsigned long)p & 0x3) == 2)
-#define MUR_PLUS3_ALIGNED(p) (((unsigned long)p & 0x3) == 3)
-#define WP(p) ((uint32_t*)((unsigned long)(p) & ~3UL))
+#define MPL_MUR_PLUS0_ALIGNED(p) (((unsigned long)p & 3UL) == 0UL)
+#define MPL_MUR_PLUS1_ALIGNED(p) (((unsigned long)p & 3UL) == 1UL)
+#define MPL_MUR_PLUS2_ALIGNED(p) (((unsigned long)p & 3UL) == 2UL)
+#define MPL_MUR_PLUS3_ALIGNED(p) (((unsigned long)p & 3UL) == 3UL)
+#define MPL_WP(p) ((uint32_t*)((unsigned long)(p) & ~3UL))
#if (defined(__BIG_ENDIAN__) || defined(SPARC) || defined(__ppc__) || defined(__ppc64__))
-#define MUR_THREE_ONE(p) ((((*WP(p))&0x00ffffff) << 8) | (((*(WP(p)+1))&0xff000000) >> 24))
-#define MUR_TWO_TWO(p) ((((*WP(p))&0x0000ffff) <<16) | (((*(WP(p)+1))&0xffff0000) >> 16))
-#define MUR_ONE_THREE(p) ((((*WP(p))&0x000000ff) <<24) | (((*(WP(p)+1))&0xffffff00) >> 8))
+#define MPL_MUR_THREE_ONE(p) ((((*WP(p))&0x00ffffff) << 8) | (((*(WP(p)+1))&0xff000000) >> 24))
+#define MPL_MUR_TWO_TWO(p) ((((*WP(p))&0x0000ffff) <<16) | (((*(WP(p)+1))&0xffff0000) >> 16))
+#define MPL_MUR_ONE_THREE(p) ((((*WP(p))&0x000000ff) <<24) | (((*(WP(p)+1))&0xffffff00) >> 8))
#else /* assume little endian non-intel */
-#define MUR_THREE_ONE(p) ((((*WP(p))&0xffffff00) >> 8) | (((*(WP(p)+1))&0x000000ff) << 24))
-#define MUR_TWO_TWO(p) ((((*WP(p))&0xffff0000) >>16) | (((*(WP(p)+1))&0x0000ffff) << 16))
-#define MUR_ONE_THREE(p) ((((*WP(p))&0xff000000) >>24) | (((*(WP(p)+1))&0x00ffffff) << 8))
+#define MPL_MUR_THREE_ONE(p) ((((*WP(p))&0xffffff00) >> 8) | (((*(WP(p)+1))&0x000000ff) << 24))
+#define MPL_MUR_TWO_TWO(p) ((((*WP(p))&0xffff0000) >>16) | (((*(WP(p)+1))&0x0000ffff) << 16))
+#define MPL_MUR_ONE_THREE(p) ((((*WP(p))&0xff000000) >>24) | (((*(WP(p)+1))&0x00ffffff) << 8))
#endif
-#define MUR_GETBLOCK(p,i) (MUR_PLUS0_ALIGNED(p) ? ((p)[i]) : \
- (MUR_PLUS1_ALIGNED(p) ? MUR_THREE_ONE(p) : \
- (MUR_PLUS2_ALIGNED(p) ? MUR_TWO_TWO(p) : \
- MUR_ONE_THREE(p))))
+#define MPL_MUR_GETBLOCK(p,i) (MPL_MUR_PLUS0_ALIGNED(p) ? ((p)[i]) : \
+ (MPL_MUR_PLUS1_ALIGNED(p) ? MPL_MUR_THREE_ONE(p) : \
+ (MPL_MUR_PLUS2_ALIGNED(p) ? MPL_MUR_TWO_TWO(p) : \
+ MPL_MUR_ONE_THREE(p))))
#endif
-#define MUR_ROTL32(x,r) (((x) << (r)) | ((x) >> (32 - (r))))
-#define MUR_FMIX(_h) \
+#define MPL_MUR_ROTL32(x,r) (((x) << (r)) | ((x) >> (32 - (r))))
+#define MPL_MUR_FMIX(_h) \
do { \
_h ^= _h >> 16; \
- _h *= 0x85ebca6b; \
+ _h *= 0x85ebca6bu; \
_h ^= _h >> 13; \
- _h *= 0xc2b2ae35l; \
+ _h *= 0xc2b2ae35u; \
_h ^= _h >> 16; \
} while(0)
-#define HASH_MUR(key,keylen,num_bkts,hashv,bkt) \
+#define MPL_HASH_MUR(key,keylen,num_bkts,hashv,bkt) \
do { \
const uint8_t *_mur_data = (const uint8_t*)(key); \
- const int _mur_nblocks = (keylen) / 4; \
- uint32_t _mur_h1 = 0xf88D5353; \
- uint32_t _mur_c1 = 0xcc9e2d51; \
- uint32_t _mur_c2 = 0x1b873593; \
+ const int _mur_nblocks = (int)(keylen) / 4; \
+ uint32_t _mur_h1 = 0xf88D5353u; \
+ uint32_t _mur_c1 = 0xcc9e2d51u; \
+ uint32_t _mur_c2 = 0x1b873593u; \
uint32_t _mur_k1 = 0; \
const uint8_t *_mur_tail; \
- const uint32_t *_mur_blocks = (const uint32_t*)(_mur_data+_mur_nblocks*4); \
+ const uint32_t *_mur_blocks = (const uint32_t*)(_mur_data+(_mur_nblocks*4)); \
int _mur_i; \
- for(_mur_i = -_mur_nblocks; _mur_i; _mur_i++) { \
- _mur_k1 = MUR_GETBLOCK(_mur_blocks,_mur_i); \
+ for(_mur_i = -_mur_nblocks; _mur_i!=0; _mur_i++) { \
+ _mur_k1 = MPL_MUR_GETBLOCK(_mur_blocks,_mur_i); \
_mur_k1 *= _mur_c1; \
- _mur_k1 = MUR_ROTL32(_mur_k1,15); \
+ _mur_k1 = MPL_MUR_ROTL32(_mur_k1,15); \
_mur_k1 *= _mur_c2; \
\
_mur_h1 ^= _mur_k1; \
- _mur_h1 = MUR_ROTL32(_mur_h1,13); \
- _mur_h1 = _mur_h1*5+0xe6546b64; \
+ _mur_h1 = MPL_MUR_ROTL32(_mur_h1,13); \
+ _mur_h1 = (_mur_h1*5U) + 0xe6546b64u; \
} \
- _mur_tail = (const uint8_t*)(_mur_data + _mur_nblocks*4); \
+ _mur_tail = (const uint8_t*)(_mur_data + (_mur_nblocks*4)); \
_mur_k1=0; \
- switch((keylen) & 3) { \
- case 3: _mur_k1 ^= _mur_tail[2] << 16; \
- case 2: _mur_k1 ^= _mur_tail[1] << 8; \
- case 1: _mur_k1 ^= _mur_tail[0]; \
+ switch((keylen) & 3U) { \
+ case 3: _mur_k1 ^= (uint32_t)_mur_tail[2] << 16; /* FALLTHROUGH */ \
+ case 2: _mur_k1 ^= (uint32_t)_mur_tail[1] << 8; /* FALLTHROUGH */ \
+ case 1: _mur_k1 ^= (uint32_t)_mur_tail[0]; \
_mur_k1 *= _mur_c1; \
- _mur_k1 = MUR_ROTL32(_mur_k1,15); \
+ _mur_k1 = MPL_MUR_ROTL32(_mur_k1,15); \
_mur_k1 *= _mur_c2; \
_mur_h1 ^= _mur_k1; \
} \
- _mur_h1 ^= (keylen); \
- MUR_FMIX(_mur_h1); \
+ _mur_h1 ^= (uint32_t)(keylen); \
+ MPL_MUR_FMIX(_mur_h1); \
hashv = _mur_h1; \
- bkt = hashv & (num_bkts-1); \
+ bkt = hashv & (num_bkts-1U); \
} while(0)
#endif /* HASH_USING_NO_STRICT_ALIASING */
/* key comparison function; return 0 if keys equal */
-#define HASH_KEYCMP(a,b,len) memcmp(a,b,len)
+#define MPL_HASH_KEYCMP(a,b,len) memcmp(a,b,(unsigned long)(len))
/* iterate over items in a known bucket to find desired item */
-#define HASH_FIND_IN_BKT(tbl,hh,head,keyptr,keylen_in,out) \
+#define MPL_HASH_FIND_IN_BKT(tbl,hh,head,keyptr,keylen_in,out) \
do { \
- if (head.hh_head) DECLTYPE_ASSIGN(out,ELMT_FROM_HH(tbl,head.hh_head)); \
- else out=NULL; \
- while (out) { \
- if ((out)->hh.keylen == keylen_in) { \
- if ((HASH_KEYCMP((out)->hh.key,keyptr,keylen_in)) == 0) break; \
+ if (head.hh_head != NULL) { MPL_DECLTYPE_ASSIGN(out,MPL_ELMT_FROM_HH(tbl,head.hh_head)); } \
+ else { out=NULL; } \
+ while (out != NULL) { \
+ if ((out)->hh.keylen == (keylen_in)) { \
+ if ((MPL_HASH_KEYCMP((out)->hh.key,keyptr,keylen_in)) == 0) { break; } \
} \
- if ((out)->hh.hh_next) DECLTYPE_ASSIGN(out,ELMT_FROM_HH(tbl,(out)->hh.hh_next)); \
- else out = NULL; \
+ if ((out)->hh.hh_next != NULL) { MPL_DECLTYPE_ASSIGN(out,MPL_ELMT_FROM_HH(tbl,(out)->hh.hh_next)); } \
+ else { out = NULL; } \
} \
} while(0)
/* add an item to a bucket */
-#define HASH_ADD_TO_BKT(head,addhh) \
+#define MPL_HASH_ADD_TO_BKT(head,addhh) \
do { \
head.count++; \
(addhh)->hh_next = head.hh_head; \
(addhh)->hh_prev = NULL; \
- if (head.hh_head) { (head).hh_head->hh_prev = (addhh); } \
+ if (head.hh_head != NULL) { (head).hh_head->hh_prev = (addhh); } \
(head).hh_head=addhh; \
- if (head.count >= ((head.expand_mult+1) * HASH_BKT_CAPACITY_THRESH) \
- && (addhh)->tbl->noexpand != 1) { \
- HASH_EXPAND_BUCKETS((addhh)->tbl); \
+ if ((head.count >= ((head.expand_mult+1U) * MPL_HASH_BKT_CAPACITY_THRESH)) \
+ && ((addhh)->tbl->noexpand != 1U)) { \
+ MPL_HASH_EXPAND_BUCKETS((addhh)->tbl); \
} \
} while(0)
/* remove an item from a given bucket */
-#define HASH_DEL_IN_BKT(hh,head,hh_del) \
+#define MPL_HASH_DEL_IN_BKT(hh,head,hh_del) \
(head).count--; \
- if ((head).hh_head == hh_del) { \
- (head).hh_head = hh_del->hh_next; \
+ if ((head).hh_head == (MPL_UT_hash_handle*)hh_del) { \
+ (head).hh_head = (MPL_UT_hash_handle*)hh_del->hh_next; \
} \
if (hh_del->hh_prev) { \
- hh_del->hh_prev->hh_next = hh_del->hh_next; \
+ hh_del->hh_prev->hh_next = hh_del->hh_next; \
} \
if (hh_del->hh_next) { \
- hh_del->hh_next->hh_prev = hh_del->hh_prev; \
+ hh_del->hh_next->hh_prev = hh_del->hh_prev; \
}
/* Bucket expansion has the effect of doubling the number of buckets
@@ -674,27 +694,27 @@ do {
* ceil(n/b) = (n>>lb) + ( (n & (b-1)) ? 1:0)
*
*/
-#define HASH_EXPAND_BUCKETS(tbl) \
+#define MPL_HASH_EXPAND_BUCKETS(tbl) \
do { \
unsigned _he_bkt; \
unsigned _he_bkt_i; \
- struct UT_hash_handle *_he_thh, *_he_hh_nxt; \
- UT_hash_bucket *_he_new_buckets, *_he_newbkt; \
- _he_new_buckets = (UT_hash_bucket*)uthash_malloc( \
- 2 * tbl->num_buckets * sizeof(struct UT_hash_bucket)); \
- if (!_he_new_buckets) { uthash_fatal( "out of memory"); } \
+ struct MPL_UT_hash_handle *_he_thh, *_he_hh_nxt; \
+ MPL_UT_hash_bucket *_he_new_buckets, *_he_newbkt; \
+ _he_new_buckets = (MPL_UT_hash_bucket*)MPL_uthash_malloc( \
+ 2UL * tbl->num_buckets * sizeof(struct MPL_UT_hash_bucket)); \
+ if (!_he_new_buckets) { MPL_uthash_fatal( "out of memory"); } \
memset(_he_new_buckets, 0, \
- 2 * tbl->num_buckets * sizeof(struct UT_hash_bucket)); \
+ 2UL * tbl->num_buckets * sizeof(struct MPL_UT_hash_bucket)); \
tbl->ideal_chain_maxlen = \
- (tbl->num_items >> (tbl->log2_num_buckets+1)) + \
- ((tbl->num_items & ((tbl->num_buckets*2)-1)) ? 1 : 0); \
+ (tbl->num_items >> (tbl->log2_num_buckets+1U)) + \
+ (((tbl->num_items & ((tbl->num_buckets*2U)-1U)) != 0U) ? 1U : 0U); \
tbl->nonideal_items = 0; \
for(_he_bkt_i = 0; _he_bkt_i < tbl->num_buckets; _he_bkt_i++) \
{ \
_he_thh = tbl->buckets[ _he_bkt_i ].hh_head; \
- while (_he_thh) { \
+ while (_he_thh != NULL) { \
_he_hh_nxt = _he_thh->hh_next; \
- HASH_TO_BKT( _he_thh->hashv, tbl->num_buckets*2, _he_bkt); \
+ MPL_HASH_TO_BKT( _he_thh->hashv, tbl->num_buckets*2U, _he_bkt); \
_he_newbkt = &(_he_new_buckets[ _he_bkt ]); \
if (++(_he_newbkt->count) > tbl->ideal_chain_maxlen) { \
tbl->nonideal_items++; \
@@ -703,106 +723,114 @@ do {
} \
_he_thh->hh_prev = NULL; \
_he_thh->hh_next = _he_newbkt->hh_head; \
- if (_he_newbkt->hh_head) _he_newbkt->hh_head->hh_prev = \
- _he_thh; \
+ if (_he_newbkt->hh_head != NULL) { _he_newbkt->hh_head->hh_prev = \
+ _he_thh; } \
_he_newbkt->hh_head = _he_thh; \
_he_thh = _he_hh_nxt; \
} \
} \
- uthash_free( tbl->buckets, tbl->num_buckets*sizeof(struct UT_hash_bucket) ); \
- tbl->num_buckets *= 2; \
+ MPL_uthash_free( tbl->buckets, tbl->num_buckets*sizeof(struct MPL_UT_hash_bucket) ); \
+ tbl->num_buckets *= 2U; \
tbl->log2_num_buckets++; \
tbl->buckets = _he_new_buckets; \
tbl->ineff_expands = (tbl->nonideal_items > (tbl->num_items >> 1)) ? \
- (tbl->ineff_expands+1) : 0; \
- if (tbl->ineff_expands > 1) { \
+ (tbl->ineff_expands+1U) : 0U; \
+ if (tbl->ineff_expands > 1U) { \
tbl->noexpand=1; \
- uthash_noexpand_fyi(tbl); \
+ MPL_uthash_noexpand_fyi(tbl); \
} \
- uthash_expand_fyi(tbl); \
+ MPL_uthash_expand_fyi(tbl); \
} while(0)
/* This is an adaptation of Simon Tatham's O(n log(n)) mergesort */
/* Note that HASH_SORT assumes the hash handle name to be hh.
* HASH_SRT was added to allow the hash handle name to be passed in. */
-#define HASH_SORT(head,cmpfcn) HASH_SRT(hh,head,cmpfcn)
-#define HASH_SRT(hh,head,cmpfcn) \
+#define MPL_HASH_SORT(head,cmpfcn) MPL_HASH_SRT(hh,head,cmpfcn)
+#define MPL_HASH_SRT(hh,head,cmpfcn) \
do { \
unsigned _hs_i; \
unsigned _hs_looping,_hs_nmerges,_hs_insize,_hs_psize,_hs_qsize; \
- struct UT_hash_handle *_hs_p, *_hs_q, *_hs_e, *_hs_list, *_hs_tail; \
- if (head) { \
+ struct MPL_UT_hash_handle *_hs_p, *_hs_q, *_hs_e, *_hs_list, *_hs_tail; \
+ if (head != NULL) { \
_hs_insize = 1; \
_hs_looping = 1; \
_hs_list = &((head)->hh); \
- while (_hs_looping) { \
+ while (_hs_looping != 0U) { \
_hs_p = _hs_list; \
_hs_list = NULL; \
_hs_tail = NULL; \
_hs_nmerges = 0; \
- while (_hs_p) { \
+ while (_hs_p != NULL) { \
_hs_nmerges++; \
_hs_q = _hs_p; \
_hs_psize = 0; \
for ( _hs_i = 0; _hs_i < _hs_insize; _hs_i++ ) { \
_hs_psize++; \
- _hs_q = (UT_hash_handle*)((_hs_q->next) ? \
+ _hs_q = (MPL_UT_hash_handle*)((_hs_q->next != NULL) ? \
((void*)((char*)(_hs_q->next) + \
(head)->hh.tbl->hho)) : NULL); \
- if (! (_hs_q) ) break; \
+ if (! (_hs_q) ) { break; } \
} \
_hs_qsize = _hs_insize; \
- while ((_hs_psize > 0) || ((_hs_qsize > 0) && _hs_q )) { \
- if (_hs_psize == 0) { \
+ while ((_hs_psize > 0U) || ((_hs_qsize > 0U) && (_hs_q != NULL))) {\
+ if (_hs_psize == 0U) { \
_hs_e = _hs_q; \
- _hs_q = (UT_hash_handle*)((_hs_q->next) ? \
+ _hs_q = (MPL_UT_hash_handle*)((_hs_q->next != NULL) ? \
((void*)((char*)(_hs_q->next) + \
(head)->hh.tbl->hho)) : NULL); \
_hs_qsize--; \
- } else if ( (_hs_qsize == 0) || !(_hs_q) ) { \
+ } else if ( (_hs_qsize == 0U) || (_hs_q == NULL) ) { \
_hs_e = _hs_p; \
- _hs_p = (UT_hash_handle*)((_hs_p->next) ? \
- ((void*)((char*)(_hs_p->next) + \
- (head)->hh.tbl->hho)) : NULL); \
+ if (_hs_p != NULL){ \
+ _hs_p = (MPL_UT_hash_handle*)((_hs_p->next != NULL) ? \
+ ((void*)((char*)(_hs_p->next) + \
+ (head)->hh.tbl->hho)) : NULL); \
+ } \
_hs_psize--; \
} else if (( \
- cmpfcn(DECLTYPE(head)(ELMT_FROM_HH((head)->hh.tbl,_hs_p)), \
- DECLTYPE(head)(ELMT_FROM_HH((head)->hh.tbl,_hs_q))) \
+ cmpfcn(MPL_DECLTYPE(head)(MPL_ELMT_FROM_HH((head)->hh.tbl,_hs_p)), \
+ MPL_DECLTYPE(head)(MPL_ELMT_FROM_HH((head)->hh.tbl,_hs_q))) \
) <= 0) { \
_hs_e = _hs_p; \
- _hs_p = (UT_hash_handle*)((_hs_p->next) ? \
- ((void*)((char*)(_hs_p->next) + \
- (head)->hh.tbl->hho)) : NULL); \
+ if (_hs_p != NULL){ \
+ _hs_p = (MPL_UT_hash_handle*)((_hs_p->next != NULL) ? \
+ ((void*)((char*)(_hs_p->next) + \
+ (head)->hh.tbl->hho)) : NULL); \
+ } \
_hs_psize--; \
} else { \
_hs_e = _hs_q; \
- _hs_q = (UT_hash_handle*)((_hs_q->next) ? \
+ _hs_q = (MPL_UT_hash_handle*)((_hs_q->next != NULL) ? \
((void*)((char*)(_hs_q->next) + \
(head)->hh.tbl->hho)) : NULL); \
_hs_qsize--; \
} \
- if ( _hs_tail ) { \
- _hs_tail->next = ((_hs_e) ? \
- ELMT_FROM_HH((head)->hh.tbl,_hs_e) : NULL); \
+ if ( _hs_tail != NULL ) { \
+ _hs_tail->next = ((_hs_e != NULL) ? \
+ MPL_ELMT_FROM_HH((head)->hh.tbl,_hs_e) : NULL); \
} else { \
_hs_list = _hs_e; \
} \
- _hs_e->prev = ((_hs_tail) ? \
- ELMT_FROM_HH((head)->hh.tbl,_hs_tail) : NULL); \
+ if (_hs_e != NULL) { \
+ _hs_e->prev = ((_hs_tail != NULL) ? \
+ MPL_ELMT_FROM_HH((head)->hh.tbl,_hs_tail) : NULL); \
+ } \
_hs_tail = _hs_e; \
} \
_hs_p = _hs_q; \
} \
- _hs_tail->next = NULL; \
- if ( _hs_nmerges <= 1 ) { \
+ if (_hs_tail != NULL){ \
+ _hs_tail->next = NULL; \
+ } \
+ if ( _hs_nmerges <= 1U ) { \
_hs_looping=0; \
(head)->hh.tbl->tail = _hs_tail; \
- DECLTYPE_ASSIGN(head,ELMT_FROM_HH((head)->hh.tbl, _hs_list)); \
+ MPL_DECLTYPE_ASSIGN(head,MPL_ELMT_FROM_HH((head)->hh.tbl, _hs_list)); \
} \
- _hs_insize *= 2; \
+ _hs_insize *= 2U; \
} \
- HASH_FSCK(hh,head); \
+ MPL_HASH_FSCK(hh,head); \
} \
} while (0)
@@ -811,34 +839,34 @@ do {
* in both hashes. There is no copy of the items made; rather
* they are added into the new hash through a secondary hash
* hash handle that must be present in the structure. */
-#define HASH_SELECT(hh_dst, dst, hh_src, src, cond) \
+#define MPL_HASH_SELECT(hh_dst, dst, hh_src, src, cond) \
do { \
unsigned _src_bkt, _dst_bkt; \
void *_last_elt=NULL, *_elt; \
- UT_hash_handle *_src_hh, *_dst_hh, *_last_elt_hh=NULL; \
+ MPL_UT_hash_handle *_src_hh, *_dst_hh, *_last_elt_hh=NULL; \
ptrdiff_t _dst_hho = ((char*)(&(dst)->hh_dst) - (char*)(dst)); \
- if (src) { \
+ if (src != NULL) { \
for(_src_bkt=0; _src_bkt < (src)->hh_src.tbl->num_buckets; _src_bkt++) { \
for(_src_hh = (src)->hh_src.tbl->buckets[_src_bkt].hh_head; \
- _src_hh; \
+ _src_hh != NULL; \
_src_hh = _src_hh->hh_next) { \
- _elt = ELMT_FROM_HH((src)->hh_src.tbl, _src_hh); \
+ _elt = MPL_ELMT_FROM_HH((src)->hh_src.tbl, _src_hh); \
if (cond(_elt)) { \
- _dst_hh = (UT_hash_handle*)(((char*)_elt) + _dst_hho); \
+ _dst_hh = (MPL_UT_hash_handle*)(((char*)_elt) + _dst_hho); \
_dst_hh->key = _src_hh->key; \
_dst_hh->keylen = _src_hh->keylen; \
_dst_hh->hashv = _src_hh->hashv; \
_dst_hh->prev = _last_elt; \
_dst_hh->next = NULL; \
- if (_last_elt_hh) { _last_elt_hh->next = _elt; } \
- if (!dst) { \
- DECLTYPE_ASSIGN(dst,_elt); \
- HASH_MAKE_TABLE(hh_dst,dst); \
+ if (_last_elt_hh != NULL) { _last_elt_hh->next = _elt; } \
+ if (dst == NULL) { \
+ MPL_DECLTYPE_ASSIGN(dst,_elt); \
+ MPL_HASH_MAKE_TABLE(hh_dst,dst); \
} else { \
_dst_hh->tbl = (dst)->hh_dst.tbl; \
} \
- HASH_TO_BKT(_dst_hh->hashv, _dst_hh->tbl->num_buckets, _dst_bkt); \
- HASH_ADD_TO_BKT(_dst_hh->tbl->buckets[_dst_bkt],_dst_hh); \
+ MPL_HASH_TO_BKT(_dst_hh->hashv, _dst_hh->tbl->num_buckets, _dst_bkt); \
+ MPL_HASH_ADD_TO_BKT(_dst_hh->tbl->buckets[_dst_bkt],_dst_hh); \
(dst)->hh_dst.tbl->num_items++; \
_last_elt = _elt; \
_last_elt_hh = _dst_hh; \
@@ -846,42 +874,43 @@ do {
} \
} \
} \
- HASH_FSCK(hh_dst,dst); \
+ MPL_HASH_FSCK(hh_dst,dst); \
} while (0)
-#define HASH_CLEAR(hh,head) \
+#define MPL_HASH_CLEAR(hh,head) \
do { \
- if (head) { \
- uthash_free((head)->hh.tbl->buckets, \
- (head)->hh.tbl->num_buckets*sizeof(struct UT_hash_bucket)); \
- HASH_BLOOM_FREE((head)->hh.tbl); \
- uthash_free((head)->hh.tbl, sizeof(UT_hash_table)); \
+ if (head != NULL) { \
+ MPL_uthash_free((head)->hh.tbl->buckets, \
+ (head)->hh.tbl->num_buckets*sizeof(struct MPL_UT_hash_bucket)); \
+ MPL_HASH_BLOOM_FREE((head)->hh.tbl); \
+ MPL_uthash_free((head)->hh.tbl, sizeof(MPL_UT_hash_table)); \
(head)=NULL; \
} \
} while(0)
-#define HASH_OVERHEAD(hh,head) \
- (size_t)((((head)->hh.tbl->num_items * sizeof(UT_hash_handle)) + \
- ((head)->hh.tbl->num_buckets * sizeof(UT_hash_bucket)) + \
- (sizeof(UT_hash_table)) + \
- (HASH_BLOOM_BYTELEN)))
-
-#ifdef NO_DECLTYPE
-#define HASH_ITER(hh,head,el,tmp) \
-for((el)=(head), (*(char**)(&(tmp)))=(char*)((head)?(head)->hh.next:NULL); \
- el; (el)=(tmp),(*(char**)(&(tmp)))=(char*)((tmp)?(tmp)->hh.next:NULL))
+#define MPL_HASH_OVERHEAD(hh,head) \
+ ((head != NULL) ? ( \
+ (size_t)(((head)->hh.tbl->num_items * sizeof(MPL_UT_hash_handle)) + \
+ ((head)->hh.tbl->num_buckets * sizeof(MPL_UT_hash_bucket)) + \
+ sizeof(MPL_UT_hash_table) + \
+ (MPL_HASH_BLOOM_BYTELEN))) : 0U)
+
+#ifdef MPL_NO_DECLTYPE
+#define MPL_HASH_ITER(hh,head,el,tmp) \
+for(((el)=(head)), ((*(char**)(&(tmp)))=(char*)((head!=NULL)?(head)->hh.next:NULL)); \
+ (el) != NULL; ((el)=(tmp)), ((*(char**)(&(tmp)))=(char*)((tmp!=NULL)?(tmp)->hh.next:NULL)))
#else
-#define HASH_ITER(hh,head,el,tmp) \
-for((el)=(head),(tmp)=DECLTYPE(el)((head)?(head)->hh.next:NULL); \
- el; (el)=(tmp),(tmp)=DECLTYPE(el)((tmp)?(tmp)->hh.next:NULL))
+#define MPL_HASH_ITER(hh,head,el,tmp) \
+for(((el)=(head)), ((tmp)=MPL_DECLTYPE(el)((head!=NULL)?(head)->hh.next:NULL)); \
+ (el) != NULL; ((el)=(tmp)), ((tmp)=MPL_DECLTYPE(el)((tmp!=NULL)?(tmp)->hh.next:NULL)))
#endif
/* obtain a count of items in the hash */
-#define HASH_COUNT(head) HASH_CNT(hh,head)
-#define HASH_CNT(hh,head) ((head)?((head)->hh.tbl->num_items):0)
+#define MPL_HASH_COUNT(head) MPL_HASH_CNT(hh,head)
+#define MPL_HASH_CNT(hh,head) ((head != NULL)?((head)->hh.tbl->num_items):0U)
-typedef struct UT_hash_bucket {
- struct UT_hash_handle *hh_head;
+typedef struct MPL_UT_hash_bucket {
+ struct MPL_UT_hash_handle *hh_head;
unsigned count;
/* expand_mult is normally set to 0. In this situation, the max chain length
@@ -898,17 +927,17 @@ typedef struct UT_hash_bucket {
*/
unsigned expand_mult;
-} UT_hash_bucket;
+} MPL_UT_hash_bucket;
/* random signature used only to find hash tables in external analysis */
-#define HASH_SIGNATURE 0xa0111fe1
-#define HASH_BLOOM_SIGNATURE 0xb12220f2
+#define MPL_HASH_SIGNATURE 0xa0111fe1u
+#define MPL_HASH_BLOOM_SIGNATURE 0xb12220f2u
-typedef struct UT_hash_table {
- UT_hash_bucket *buckets;
+typedef struct MPL_UT_hash_table {
+ MPL_UT_hash_bucket *buckets;
unsigned num_buckets, log2_num_buckets;
unsigned num_items;
- struct UT_hash_handle *tail; /* tail hh in app order, for fast append */
+ struct MPL_UT_hash_handle *tail; /* tail hh in app order, for fast append */
ptrdiff_t hho; /* hash handle offset (byte pos of hash handle in element */
/* in an ideal situation (all buckets used equally), no bucket would have
@@ -929,23 +958,23 @@ typedef struct UT_hash_table {
unsigned ineff_expands, noexpand;
uint32_t signature; /* used only to find hash tables in external analysis */
-#ifdef HASH_BLOOM
+#ifdef MPL_HASH_BLOOM
uint32_t bloom_sig; /* used only to test bloom exists in external analysis */
uint8_t *bloom_bv;
- char bloom_nbits;
+ uint8_t bloom_nbits;
#endif
-} UT_hash_table;
+} MPL_UT_hash_table;
-typedef struct UT_hash_handle {
- struct UT_hash_table *tbl;
+typedef struct MPL_UT_hash_handle {
+ struct MPL_UT_hash_table *tbl;
void *prev; /* prev element in app order */
void *next; /* next element in app order */
- struct UT_hash_handle *hh_prev; /* previous hh in bucket order */
- struct UT_hash_handle *hh_next; /* next hh in bucket order */
+ struct MPL_UT_hash_handle *hh_prev; /* previous hh in bucket order */
+ struct MPL_UT_hash_handle *hh_next; /* next hh in bucket order */
void *key; /* ptr to enclosing struct's key */
unsigned keylen; /* enclosing struct's key len */
unsigned hashv; /* result of hash-fcn(key) */
-} UT_hash_handle;
+} MPL_UT_hash_handle;
-#endif /* MPIR_UTHASH_H_INCLUDED */
+#endif /* MPL_UTHASH_H */
-----------------------------------------------------------------------
Summary of changes:
src/include/Makefile.mk | 1 -
src/include/mpit.h | 2 +-
src/include/mpitimpl.h | 4 +-
src/mpi/comm/commutil.c | 12 +-
src/mpi/comm/contextid.c | 1 -
src/mpi_t/cat_get_index.c | 2 +-
src/mpi_t/cvar_get_index.c | 2 +-
src/mpi_t/mpit.c | 20 +-
src/mpi_t/mpit_finalize.c | 18 +-
src/mpi_t/pvar_get_index.c | 2 +-
.../mpir_uthash.h => mpl/include/mpl_uthash.h} | 777 ++++++++++----------
11 files changed, 434 insertions(+), 407 deletions(-)
rename src/{include/mpir_uthash.h => mpl/include/mpl_uthash.h} (57%)
mode change 100644 => 100755
hooks/post-receive
--
MPICH primary repository
More information about the commits
mailing list