[Python-checkins] bpo-40609: _Py_hashtable_t values become void* (GH-20065)
Victor Stinner
webhook-mailer at python.org
Tue May 12 22:40:40 EDT 2020
https://github.com/python/cpython/commit/5b0a30354d8a8bb39a05ce10ca4f5c78b729f25b
commit: 5b0a30354d8a8bb39a05ce10ca4f5c78b729f25b
branch: master
author: Victor Stinner <vstinner at python.org>
committer: GitHub <noreply at github.com>
date: 2020-05-13T04:40:30+02:00
summary:
bpo-40609: _Py_hashtable_t values become void* (GH-20065)
_Py_hashtable_t values become regular "void *" pointers.
* Add _Py_hashtable_entry_t.data member
* Remove _Py_hashtable_t.data_size member
* Remove _Py_hashtable_t.get_func member. It is no longer needed
to specialize _Py_hashtable_get() for a specific value size, since
all entries now have the same size (void*).
* Remove the following macros:
* _Py_HASHTABLE_GET()
* _Py_HASHTABLE_SET()
* _Py_HASHTABLE_SET_NODATA()
* _Py_HASHTABLE_POP()
* Rename _Py_hashtable_pop() to _Py_hashtable_steal()
* _Py_hashtable_foreach() callback now gets key and value rather than
entry.
* Remove _Py_hashtable_value_destroy_func type. value_destroy_func
callback now only has a single parameter: data (void*).
files:
M Include/internal/pycore_hashtable.h
M Modules/_tracemalloc.c
M Python/hashtable.c
M Python/marshal.c
diff --git a/Include/internal/pycore_hashtable.h b/Include/internal/pycore_hashtable.h
index 0da2ffdb389e5..2990f9e0c1cc6 100644
--- a/Include/internal/pycore_hashtable.h
+++ b/Include/internal/pycore_hashtable.h
@@ -31,20 +31,9 @@ typedef struct {
Py_uhash_t key_hash;
void *key;
- /* data (data_size bytes) follows */
+ void *value;
} _Py_hashtable_entry_t;
-#define _Py_HASHTABLE_ENTRY_PDATA(ENTRY) \
- ((const void *)((char *)(ENTRY) \
- + sizeof(_Py_hashtable_entry_t)))
-
-#define _Py_HASHTABLE_ENTRY_READ_DATA(TABLE, ENTRY, DATA) \
- do { \
- assert(sizeof(DATA) == (TABLE)->data_size); \
- memcpy(&(DATA), _Py_HASHTABLE_ENTRY_PDATA((ENTRY)), \
- sizeof(DATA)); \
- } while (0)
-
/* _Py_hashtable: prototypes */
@@ -55,12 +44,8 @@ typedef struct _Py_hashtable_t _Py_hashtable_t;
typedef Py_uhash_t (*_Py_hashtable_hash_func) (const void *key);
typedef int (*_Py_hashtable_compare_func) (const void *key1, const void *key2);
typedef void (*_Py_hashtable_destroy_func) (void *key);
-typedef void (*_Py_hashtable_value_destroy_func) (_Py_hashtable_t *ht,
- _Py_hashtable_entry_t *entry);
typedef _Py_hashtable_entry_t* (*_Py_hashtable_get_entry_func)(_Py_hashtable_t *ht,
const void *key);
-typedef int (*_Py_hashtable_get_func) (_Py_hashtable_t *ht,
- const void *key, void *data);
typedef struct {
/* allocate a memory block */
@@ -76,14 +61,12 @@ struct _Py_hashtable_t {
size_t num_buckets;
size_t entries; /* Total number of entries in the table. */
_Py_slist_t *buckets;
- size_t data_size;
- _Py_hashtable_get_func get_func;
_Py_hashtable_get_entry_func get_entry_func;
_Py_hashtable_hash_func hash_func;
_Py_hashtable_compare_func compare_func;
_Py_hashtable_destroy_func key_destroy_func;
- _Py_hashtable_value_destroy_func value_destroy_func;
+ _Py_hashtable_destroy_func value_destroy_func;
_Py_hashtable_allocator_t alloc;
};
@@ -96,17 +79,14 @@ PyAPI_FUNC(int) _Py_hashtable_compare_direct(
const void *key2);
PyAPI_FUNC(_Py_hashtable_t *) _Py_hashtable_new(
- size_t data_size,
_Py_hashtable_hash_func hash_func,
_Py_hashtable_compare_func compare_func);
PyAPI_FUNC(_Py_hashtable_t *) _Py_hashtable_new_full(
- size_t data_size,
- size_t init_size,
_Py_hashtable_hash_func hash_func,
_Py_hashtable_compare_func compare_func,
_Py_hashtable_destroy_func key_destroy_func,
- _Py_hashtable_value_destroy_func value_destroy_func,
+ _Py_hashtable_destroy_func value_destroy_func,
_Py_hashtable_allocator_t *allocator);
PyAPI_FUNC(void) _Py_hashtable_destroy(_Py_hashtable_t *ht);
@@ -114,8 +94,8 @@ PyAPI_FUNC(void) _Py_hashtable_destroy(_Py_hashtable_t *ht);
PyAPI_FUNC(void) _Py_hashtable_clear(_Py_hashtable_t *ht);
typedef int (*_Py_hashtable_foreach_func) (_Py_hashtable_t *ht,
- _Py_hashtable_entry_t *entry,
- void *arg);
+ const void *key, const void *value,
+ void *user_data);
/* Call func() on each entry of the hashtable.
Iteration stops if func() result is non-zero, in this case it's the result
@@ -123,68 +103,42 @@ typedef int (*_Py_hashtable_foreach_func) (_Py_hashtable_t *ht,
PyAPI_FUNC(int) _Py_hashtable_foreach(
_Py_hashtable_t *ht,
_Py_hashtable_foreach_func func,
- void *arg);
+ void *user_data);
-PyAPI_FUNC(size_t) _Py_hashtable_size(_Py_hashtable_t *ht);
+PyAPI_FUNC(size_t) _Py_hashtable_size(const _Py_hashtable_t *ht);
/* Add a new entry to the hash. The key must not be present in the hash table.
- Return 0 on success, -1 on memory error.
-
- Don't call directly this function,
- but use _Py_HASHTABLE_SET() and _Py_HASHTABLE_SET_NODATA() macros */
+ Return 0 on success, -1 on memory error. */
PyAPI_FUNC(int) _Py_hashtable_set(
_Py_hashtable_t *ht,
const void *key,
- size_t data_size,
- const void *data);
-
-#define _Py_HASHTABLE_SET(TABLE, KEY, DATA) \
- _Py_hashtable_set(TABLE, (KEY), sizeof(DATA), &(DATA))
-
-#define _Py_HASHTABLE_SET_NODATA(TABLE, KEY) \
- _Py_hashtable_set(TABLE, (KEY), 0, NULL)
+ void *value);
/* Get an entry.
- Return NULL if the key does not exist.
-
- Don't call directly this function, but use _Py_HASHTABLE_GET_ENTRY()
- macro */
+ Return NULL if the key does not exist. */
static inline _Py_hashtable_entry_t *
_Py_hashtable_get_entry(_Py_hashtable_t *ht, const void *key)
{
return ht->get_entry_func(ht, key);
}
-#define _Py_HASHTABLE_GET_ENTRY(TABLE, KEY) \
- _Py_hashtable_get_entry(TABLE, (const void *)(KEY))
+/* Get value from an entry.
+ Return NULL if the entry is not found.
-/* Get data from an entry. Copy entry data into data and return 1 if the entry
- exists, return 0 if the entry does not exist.
+ Use _Py_hashtable_get_entry() to distinguish entry value equal to NULL
+ and entry not found. */
+extern void *_Py_hashtable_get(_Py_hashtable_t *ht, const void *key);
- Don't call directly this function, but use _Py_HASHTABLE_GET() macro */
-static inline int
-_Py_hashtable_get(_Py_hashtable_t *ht, const void *key,
- size_t data_size, void *data)
-{
- assert(data_size == ht->data_size);
- return ht->get_func(ht, key, data);
-}
-
-#define _Py_HASHTABLE_GET(TABLE, KEY, DATA) \
- _Py_hashtable_get(TABLE, (KEY), sizeof(DATA), &(DATA))
-
-/* Don't call directly this function, but use _Py_HASHTABLE_POP() macro */
-PyAPI_FUNC(int) _Py_hashtable_pop(
+// Remove a key and its associated value without calling key and value destroy
+// functions.
+// Return the removed value if the key was found.
+// Return NULL if the key was not found.
+PyAPI_FUNC(void*) _Py_hashtable_steal(
_Py_hashtable_t *ht,
- const void *key,
- size_t data_size,
- void *data);
-
-#define _Py_HASHTABLE_POP(TABLE, KEY, DATA) \
- _Py_hashtable_pop(TABLE, (KEY), sizeof(DATA), &(DATA))
+ const void *key);
#ifdef __cplusplus
diff --git a/Modules/_tracemalloc.c b/Modules/_tracemalloc.c
index a42349a8e4719..4522d1afde908 100644
--- a/Modules/_tracemalloc.c
+++ b/Modules/_tracemalloc.c
@@ -23,8 +23,8 @@ static void raw_free(void *ptr);
# define TRACE_DEBUG
#endif
-#define TO_PTR(key) ((const void *)(uintptr_t)key)
-#define FROM_PTR(key) ((uintptr_t)key)
+#define TO_PTR(key) ((const void *)(uintptr_t)(key))
+#define FROM_PTR(key) ((uintptr_t)(key))
/* Protected by the GIL */
static struct {
@@ -236,15 +236,15 @@ hashtable_hash_uint(const void *key_raw)
static _Py_hashtable_t *
-hashtable_new(size_t data_size,
- _Py_hashtable_hash_func hash_func,
+hashtable_new(_Py_hashtable_hash_func hash_func,
_Py_hashtable_compare_func compare_func,
- _Py_hashtable_value_destroy_func value_destroy_fun)
+ _Py_hashtable_destroy_func key_destroy_func,
+ _Py_hashtable_destroy_func value_destroy_func)
{
_Py_hashtable_allocator_t hashtable_alloc = {malloc, free};
- return _Py_hashtable_new_full(data_size, 0,
- hash_func, compare_func,
- NULL, value_destroy_fun, &hashtable_alloc);
+ return _Py_hashtable_new_full(hash_func, compare_func,
+ key_destroy_func, value_destroy_func,
+ &hashtable_alloc);
}
@@ -340,7 +340,7 @@ tracemalloc_get_frame(PyFrameObject *pyframe, frame_t *frame)
/* intern the filename */
_Py_hashtable_entry_t *entry;
- entry = _Py_HASHTABLE_GET_ENTRY(tracemalloc_filenames, filename);
+ entry = _Py_hashtable_get_entry(tracemalloc_filenames, filename);
if (entry != NULL) {
filename = (PyObject *)entry->key;
}
@@ -348,7 +348,7 @@ tracemalloc_get_frame(PyFrameObject *pyframe, frame_t *frame)
/* tracemalloc_filenames is responsible to keep a reference
to the filename */
Py_INCREF(filename);
- if (_Py_HASHTABLE_SET_NODATA(tracemalloc_filenames, filename) < 0) {
+ if (_Py_hashtable_set(tracemalloc_filenames, filename, NULL) < 0) {
Py_DECREF(filename);
#ifdef TRACE_DEBUG
tracemalloc_error("failed to intern the filename");
@@ -435,7 +435,7 @@ traceback_new(void)
traceback->hash = traceback_hash(traceback);
/* intern the traceback */
- entry = _Py_HASHTABLE_GET_ENTRY(tracemalloc_tracebacks, traceback);
+ entry = _Py_hashtable_get_entry(tracemalloc_tracebacks, traceback);
if (entry != NULL) {
traceback = (traceback_t *)entry->key;
}
@@ -454,7 +454,7 @@ traceback_new(void)
}
memcpy(copy, traceback, traceback_size);
- if (_Py_HASHTABLE_SET_NODATA(tracemalloc_tracebacks, copy) < 0) {
+ if (_Py_hashtable_set(tracemalloc_tracebacks, copy, NULL) < 0) {
raw_free(copy);
#ifdef TRACE_DEBUG
tracemalloc_error("failed to intern the traceback: putdata failed");
@@ -467,50 +467,22 @@ traceback_new(void)
}
-static void
-tracemalloc_destroy_trace_cb(_Py_hashtable_t *traces,
- _Py_hashtable_entry_t *entry)
-{
- trace_t *trace;
- _Py_HASHTABLE_ENTRY_READ_DATA(traces, entry, trace);
- raw_free(trace);
-}
-
-
static _Py_hashtable_t*
tracemalloc_create_traces_table(void)
{
- return hashtable_new(sizeof(trace_t*),
- _Py_hashtable_hash_ptr,
+ return hashtable_new(_Py_hashtable_hash_ptr,
_Py_hashtable_compare_direct,
- tracemalloc_destroy_trace_cb);
-}
-
-
-static void
-tracemalloc_destroy_domain_table(_Py_hashtable_t *domains,
- _Py_hashtable_entry_t *entry)
-{
- _Py_hashtable_t *traces;
- _Py_HASHTABLE_ENTRY_READ_DATA(domains, entry, traces);
- _Py_hashtable_destroy(traces);
+ NULL, raw_free);
}
static _Py_hashtable_t*
tracemalloc_create_domains_table(void)
{
- return hashtable_new(sizeof(_Py_hashtable_t *),
- hashtable_hash_uint,
+ return hashtable_new(hashtable_hash_uint,
_Py_hashtable_compare_direct,
- tracemalloc_destroy_domain_table);
-}
-
-
-static void
-tracemalloc_destroy_domains(_Py_hashtable_t *domains)
-{
- _Py_hashtable_destroy(domains);
+ NULL,
+ (_Py_hashtable_destroy_func)_Py_hashtable_destroy);
}
@@ -521,9 +493,7 @@ tracemalloc_get_traces_table(unsigned int domain)
return tracemalloc_traces;
}
else {
- _Py_hashtable_t *traces = NULL;
- (void)_Py_HASHTABLE_GET(tracemalloc_domains, TO_PTR(domain), traces);
- return traces;
+ return _Py_hashtable_get(tracemalloc_domains, TO_PTR(domain));
}
}
@@ -538,8 +508,8 @@ tracemalloc_remove_trace(unsigned int domain, uintptr_t ptr)
return;
}
- trace_t *trace;
- if (!_Py_HASHTABLE_POP(traces, TO_PTR(ptr), trace)) {
+ trace_t *trace = _Py_hashtable_steal(traces, TO_PTR(ptr));
+ if (!trace) {
return;
}
assert(tracemalloc_traced_memory >= trace->size);
@@ -569,17 +539,15 @@ tracemalloc_add_trace(unsigned int domain, uintptr_t ptr,
return -1;
}
- if (_Py_HASHTABLE_SET(tracemalloc_domains, TO_PTR(domain), traces) < 0) {
+ if (_Py_hashtable_set(tracemalloc_domains, TO_PTR(domain), traces) < 0) {
_Py_hashtable_destroy(traces);
return -1;
}
}
- _Py_hashtable_entry_t* entry = _Py_HASHTABLE_GET_ENTRY(traces, ptr);
- if (entry != NULL) {
+ trace_t *trace = _Py_hashtable_get(traces, TO_PTR(ptr));
+ if (trace != NULL) {
/* the memory block is already tracked */
- trace_t *trace;
- _Py_HASHTABLE_ENTRY_READ_DATA(traces, entry, trace);
assert(tracemalloc_traced_memory >= trace->size);
tracemalloc_traced_memory -= trace->size;
@@ -587,14 +555,14 @@ tracemalloc_add_trace(unsigned int domain, uintptr_t ptr,
trace->traceback = traceback;
}
else {
- trace_t *trace = raw_malloc(sizeof(trace_t));
+ trace = raw_malloc(sizeof(trace_t));
if (trace == NULL) {
return -1;
}
trace->size = size;
trace->traceback = traceback;
- int res = _Py_HASHTABLE_SET(traces, TO_PTR(ptr), trace);
+ int res = _Py_hashtable_set(traces, TO_PTR(ptr), trace);
if (res != 0) {
raw_free(trace);
return res;
@@ -860,23 +828,11 @@ tracemalloc_raw_realloc(void *ctx, void *ptr, size_t new_size)
#endif /* TRACE_RAW_MALLOC */
-static int
-tracemalloc_clear_filename(_Py_hashtable_t *ht, _Py_hashtable_entry_t *entry,
- void *user_data)
+static void
+tracemalloc_clear_filename(void *value)
{
- PyObject *filename = (PyObject *)entry->key;
+ PyObject *filename = (PyObject *)value;
Py_DECREF(filename);
- return 0;
-}
-
-
-static int
-traceback_free_traceback(_Py_hashtable_t *ht, _Py_hashtable_entry_t *entry,
- void *user_data)
-{
- traceback_t *traceback = (traceback_t *)entry->key;
- raw_free(traceback);
- return 0;
}
@@ -894,10 +850,8 @@ tracemalloc_clear_traces(void)
tracemalloc_peak_traced_memory = 0;
TABLES_UNLOCK();
- _Py_hashtable_foreach(tracemalloc_tracebacks, traceback_free_traceback, NULL);
_Py_hashtable_clear(tracemalloc_tracebacks);
- _Py_hashtable_foreach(tracemalloc_filenames, tracemalloc_clear_filename, NULL);
_Py_hashtable_clear(tracemalloc_filenames);
}
@@ -937,15 +891,13 @@ tracemalloc_init(void)
}
#endif
- tracemalloc_filenames = hashtable_new(0,
- hashtable_hash_pyobject,
+ tracemalloc_filenames = hashtable_new(hashtable_hash_pyobject,
hashtable_compare_unicode,
- NULL);
+ tracemalloc_clear_filename, NULL);
- tracemalloc_tracebacks = hashtable_new(0,
- hashtable_hash_traceback,
+ tracemalloc_tracebacks = hashtable_new(hashtable_hash_traceback,
hashtable_compare_traceback,
- NULL);
+ NULL, raw_free);
tracemalloc_traces = tracemalloc_create_traces_table();
tracemalloc_domains = tracemalloc_create_domains_table();
@@ -983,7 +935,7 @@ tracemalloc_deinit(void)
tracemalloc_stop();
/* destroy hash tables */
- tracemalloc_destroy_domains(tracemalloc_domains);
+ _Py_hashtable_destroy(tracemalloc_domains);
_Py_hashtable_destroy(tracemalloc_traces);
_Py_hashtable_destroy(tracemalloc_tracebacks);
_Py_hashtable_destroy(tracemalloc_filenames);
@@ -1153,11 +1105,11 @@ frame_to_pyobject(frame_t *frame)
static PyObject*
traceback_to_pyobject(traceback_t *traceback, _Py_hashtable_t *intern_table)
{
- int i;
- PyObject *frames, *frame;
+ PyObject *frames;
if (intern_table != NULL) {
- if (_Py_HASHTABLE_GET(intern_table, (const void *)traceback, frames)) {
+ frames = _Py_hashtable_get(intern_table, (const void *)traceback);
+ if (frames) {
Py_INCREF(frames);
return frames;
}
@@ -1167,8 +1119,8 @@ traceback_to_pyobject(traceback_t *traceback, _Py_hashtable_t *intern_table)
if (frames == NULL)
return NULL;
- for (i=0; i < traceback->nframe; i++) {
- frame = frame_to_pyobject(&traceback->frames[i]);
+ for (int i=0; i < traceback->nframe; i++) {
+ PyObject *frame = frame_to_pyobject(&traceback->frames[i]);
if (frame == NULL) {
Py_DECREF(frames);
return NULL;
@@ -1177,7 +1129,7 @@ traceback_to_pyobject(traceback_t *traceback, _Py_hashtable_t *intern_table)
}
if (intern_table != NULL) {
- if (_Py_HASHTABLE_SET(intern_table, traceback, frames) < 0) {
+ if (_Py_hashtable_set(intern_table, traceback, frames) < 0) {
Py_DECREF(frames);
PyErr_NoMemory();
return NULL;
@@ -1190,7 +1142,7 @@ traceback_to_pyobject(traceback_t *traceback, _Py_hashtable_t *intern_table)
static PyObject*
-trace_to_pyobject(unsigned int domain, trace_t *trace,
+trace_to_pyobject(unsigned int domain, const trace_t *trace,
_Py_hashtable_t *intern_tracebacks)
{
PyObject *trace_obj = NULL;
@@ -1243,20 +1195,19 @@ typedef struct {
static int
tracemalloc_copy_trace(_Py_hashtable_t *traces,
- _Py_hashtable_entry_t *entry,
- void *traces2_raw)
+ const void *key, const void *value,
+ void *user_data)
{
- _Py_hashtable_t *traces2 = (_Py_hashtable_t *)traces2_raw;
+ _Py_hashtable_t *traces2 = (_Py_hashtable_t *)user_data;
- trace_t *trace;
- _Py_HASHTABLE_ENTRY_READ_DATA(traces, entry, trace);
+ trace_t *trace = (trace_t *)value;
trace_t *trace2 = raw_malloc(sizeof(trace_t));
if (traces2 == NULL) {
return -1;
}
*trace2 = *trace;
- if (_Py_HASHTABLE_SET(traces2, entry->key, trace2) < 0) {
+ if (_Py_hashtable_set(traces2, key, trace2) < 0) {
raw_free(trace2);
return -1;
}
@@ -1285,17 +1236,16 @@ tracemalloc_copy_traces(_Py_hashtable_t *traces)
static int
tracemalloc_copy_domain(_Py_hashtable_t *domains,
- _Py_hashtable_entry_t *entry,
- void *domains2_raw)
+ const void *key, const void *value,
+ void *user_data)
{
- _Py_hashtable_t *domains2 = (_Py_hashtable_t *)domains2_raw;
+ _Py_hashtable_t *domains2 = (_Py_hashtable_t *)user_data;
- unsigned int domain = (unsigned int)FROM_PTR(entry->key);
- _Py_hashtable_t *traces;
- _Py_HASHTABLE_ENTRY_READ_DATA(domains, entry, traces);
+ unsigned int domain = (unsigned int)FROM_PTR(key);
+ _Py_hashtable_t *traces = (_Py_hashtable_t *)value;
_Py_hashtable_t *traces2 = tracemalloc_copy_traces(traces);
- if (_Py_HASHTABLE_SET(domains2, TO_PTR(domain), traces2) < 0) {
+ if (_Py_hashtable_set(domains2, TO_PTR(domain), traces2) < 0) {
_Py_hashtable_destroy(traces2);
return -1;
}
@@ -1323,24 +1273,25 @@ tracemalloc_copy_domains(_Py_hashtable_t *domains)
static int
-tracemalloc_get_traces_fill(_Py_hashtable_t *traces, _Py_hashtable_entry_t *entry,
+tracemalloc_get_traces_fill(_Py_hashtable_t *traces,
+ const void *key, const void *value,
void *user_data)
{
get_traces_t *get_traces = user_data;
- trace_t *trace;
- PyObject *tracemalloc_obj;
- int res;
- _Py_HASHTABLE_ENTRY_READ_DATA(traces, entry, trace);
+ const trace_t *trace = (const trace_t *)value;
- tracemalloc_obj = trace_to_pyobject(get_traces->domain, trace, get_traces->tracebacks);
- if (tracemalloc_obj == NULL)
+ PyObject *tuple = trace_to_pyobject(get_traces->domain, trace,
+ get_traces->tracebacks);
+ if (tuple == NULL) {
return 1;
+ }
- res = PyList_Append(get_traces->list, tracemalloc_obj);
- Py_DECREF(tracemalloc_obj);
- if (res < 0)
+ int res = PyList_Append(get_traces->list, tuple);
+ Py_DECREF(tuple);
+ if (res < 0) {
return 1;
+ }
return 0;
}
@@ -1348,14 +1299,13 @@ tracemalloc_get_traces_fill(_Py_hashtable_t *traces, _Py_hashtable_entry_t *entr
static int
tracemalloc_get_traces_domain(_Py_hashtable_t *domains,
- _Py_hashtable_entry_t *entry,
+ const void *key, const void *value,
void *user_data)
{
get_traces_t *get_traces = user_data;
- unsigned int domain = (unsigned int)FROM_PTR(entry->key);
- _Py_hashtable_t *traces;
- _Py_HASHTABLE_ENTRY_READ_DATA(domains, entry, traces);
+ unsigned int domain = (unsigned int)FROM_PTR(key);
+ _Py_hashtable_t *traces = (_Py_hashtable_t *)value;
get_traces->domain = domain;
return _Py_hashtable_foreach(traces,
@@ -1365,11 +1315,9 @@ tracemalloc_get_traces_domain(_Py_hashtable_t *domains,
static void
-tracemalloc_pyobject_decref_cb(_Py_hashtable_t *tracebacks,
- _Py_hashtable_entry_t *entry)
+tracemalloc_pyobject_decref(void *value)
{
- PyObject *obj;
- _Py_HASHTABLE_ENTRY_READ_DATA(tracebacks, entry, obj);
+ PyObject *obj = (PyObject *)value;
Py_DECREF(obj);
}
@@ -1404,10 +1352,9 @@ _tracemalloc__get_traces_impl(PyObject *module)
/* the traceback hash table is used temporarily to intern traceback tuple
of (filename, lineno) tuples */
- get_traces.tracebacks = hashtable_new(sizeof(PyObject *),
- _Py_hashtable_hash_ptr,
+ get_traces.tracebacks = hashtable_new(_Py_hashtable_hash_ptr,
_Py_hashtable_compare_direct,
- tracemalloc_pyobject_decref_cb);
+ NULL, tracemalloc_pyobject_decref);
if (get_traces.tracebacks == NULL) {
goto no_memory;
}
@@ -1462,7 +1409,7 @@ _tracemalloc__get_traces_impl(PyObject *module)
_Py_hashtable_destroy(get_traces.traces);
}
if (get_traces.domains != NULL) {
- tracemalloc_destroy_domains(get_traces.domains);
+ _Py_hashtable_destroy(get_traces.domains);
}
return get_traces.list;
@@ -1472,23 +1419,22 @@ _tracemalloc__get_traces_impl(PyObject *module)
static traceback_t*
tracemalloc_get_traceback(unsigned int domain, uintptr_t ptr)
{
- trace_t *trace;
- int found;
if (!_Py_tracemalloc_config.tracing)
return NULL;
+ trace_t *trace;
TABLES_LOCK();
_Py_hashtable_t *traces = tracemalloc_get_traces_table(domain);
if (traces) {
- found = _Py_HASHTABLE_GET(traces, TO_PTR(ptr), trace);
+ trace = _Py_hashtable_get(traces, TO_PTR(ptr));
}
else {
- found = 0;
+ trace = NULL;
}
TABLES_UNLOCK();
- if (!found) {
+ if (!trace) {
return NULL;
}
@@ -1634,12 +1580,10 @@ _tracemalloc_get_traceback_limit_impl(PyObject *module)
static int
tracemalloc_get_tracemalloc_memory_cb(_Py_hashtable_t *domains,
- _Py_hashtable_entry_t *entry,
+ const void *key, const void *value,
void *user_data)
{
- _Py_hashtable_t *traces;
- _Py_HASHTABLE_ENTRY_READ_DATA(domains, entry, traces);
-
+ const _Py_hashtable_t *traces = value;
size_t *size = (size_t*)user_data;
*size += _Py_hashtable_size(traces);
return 0;
@@ -1827,14 +1771,11 @@ _PyTraceMalloc_NewReference(PyObject *op)
int res = -1;
TABLES_LOCK();
- _Py_hashtable_entry_t* entry;
- entry = _Py_HASHTABLE_GET_ENTRY(tracemalloc_traces, ptr);
- if (entry != NULL) {
+ trace_t *trace = _Py_hashtable_get(tracemalloc_traces, TO_PTR(ptr));
+ if (trace != NULL) {
/* update the traceback of the memory block */
traceback_t *traceback = traceback_new();
if (traceback != NULL) {
- trace_t *trace;
- _Py_HASHTABLE_ENTRY_READ_DATA(tracemalloc_traces, entry, trace);
trace->traceback = traceback;
res = 0;
}
diff --git a/Python/hashtable.c b/Python/hashtable.c
index e7681fb156519..dc4af3395181c 100644
--- a/Python/hashtable.c
+++ b/Python/hashtable.c
@@ -58,22 +58,6 @@
((_Py_hashtable_entry_t *)_Py_SLIST_HEAD(&(HT)->buckets[BUCKET]))
#define ENTRY_NEXT(ENTRY) \
((_Py_hashtable_entry_t *)_Py_SLIST_ITEM_NEXT(ENTRY))
-#define HASHTABLE_ITEM_SIZE(HT) \
- (sizeof(_Py_hashtable_entry_t) + (HT)->data_size)
-
-#define ENTRY_READ_PDATA(TABLE, ENTRY, DATA_SIZE, PDATA) \
- do { \
- assert((DATA_SIZE) == (TABLE)->data_size); \
- memcpy((PDATA), _Py_HASHTABLE_ENTRY_PDATA(ENTRY), \
- (DATA_SIZE)); \
- } while (0)
-
-#define ENTRY_WRITE_PDATA(TABLE, ENTRY, DATA_SIZE, PDATA) \
- do { \
- assert((DATA_SIZE) == (TABLE)->data_size); \
- memcpy((void *)_Py_HASHTABLE_ENTRY_PDATA(ENTRY), \
- (PDATA), (DATA_SIZE)); \
- } while (0)
/* Forward declaration */
static void hashtable_rehash(_Py_hashtable_t *ht);
@@ -133,7 +117,7 @@ round_size(size_t s)
size_t
-_Py_hashtable_size(_Py_hashtable_t *ht)
+_Py_hashtable_size(const _Py_hashtable_t *ht)
{
size_t size;
@@ -143,7 +127,7 @@ _Py_hashtable_size(_Py_hashtable_t *ht)
size += ht->num_buckets * sizeof(_Py_hashtable_entry_t *);
/* entries */
- size += ht->entries * HASHTABLE_ITEM_SIZE(ht);
+ size += ht->entries * sizeof(_Py_hashtable_entry_t);
return size;
}
@@ -209,11 +193,9 @@ _Py_hashtable_get_entry_generic(_Py_hashtable_t *ht, const void *key)
}
-static int
-_Py_hashtable_pop_entry(_Py_hashtable_t *ht, const void *key,
- void *data, size_t data_size)
+void*
+_Py_hashtable_steal(_Py_hashtable_t *ht, const void *key)
{
-
Py_uhash_t key_hash = ht->hash_func(key);
size_t index = key_hash & (ht->num_buckets - 1);
@@ -222,7 +204,7 @@ _Py_hashtable_pop_entry(_Py_hashtable_t *ht, const void *key,
while (1) {
if (entry == NULL) {
// not found
- return 0;
+ return NULL;
}
if (entry->key_hash == key_hash && ht->compare_func(key, entry->key)) {
break;
@@ -235,23 +217,21 @@ _Py_hashtable_pop_entry(_Py_hashtable_t *ht, const void *key,
(_Py_slist_item_t *)entry);
ht->entries--;
- if (data != NULL)
- ENTRY_READ_PDATA(ht, entry, data_size, data);
+ void *value = entry->value;
ht->alloc.free(entry);
- if ((float)ht->entries / (float)ht->num_buckets < HASHTABLE_LOW)
+ if ((float)ht->entries / (float)ht->num_buckets < HASHTABLE_LOW) {
hashtable_rehash(ht);
- return 1;
+ }
+ return value;
}
int
-_Py_hashtable_set(_Py_hashtable_t *ht, const void *key,
- size_t data_size, const void *data)
+_Py_hashtable_set(_Py_hashtable_t *ht, const void *key, void *value)
{
_Py_hashtable_entry_t *entry;
- assert(data != NULL || data_size == 0);
#ifndef NDEBUG
/* Don't write the assertion on a single line because it is interesting
to know the duplicated entry if the assertion failed. The entry can
@@ -263,7 +243,7 @@ _Py_hashtable_set(_Py_hashtable_t *ht, const void *key,
Py_uhash_t key_hash = ht->hash_func(key);
size_t index = key_hash & (ht->num_buckets - 1);
- entry = ht->alloc.malloc(HASHTABLE_ITEM_SIZE(ht));
+ entry = ht->alloc.malloc(sizeof(_Py_hashtable_entry_t));
if (entry == NULL) {
/* memory allocation failed */
return -1;
@@ -271,9 +251,7 @@ _Py_hashtable_set(_Py_hashtable_t *ht, const void *key,
entry->key_hash = key_hash;
entry->key = (void *)key;
- if (data) {
- ENTRY_WRITE_PDATA(ht, entry, data_size, data);
- }
+ entry->value = value;
_Py_slist_prepend(&ht->buckets[index], (_Py_slist_item_t*)entry);
ht->entries++;
@@ -284,17 +262,15 @@ _Py_hashtable_set(_Py_hashtable_t *ht, const void *key,
}
-int
-_Py_hashtable_get_generic(_Py_hashtable_t *ht, const void *key, void *data)
+void*
+_Py_hashtable_get(_Py_hashtable_t *ht, const void *key)
{
- assert(data != NULL);
_Py_hashtable_entry_t *entry = ht->get_entry_func(ht, key);
if (entry != NULL) {
- ENTRY_READ_PDATA(ht, entry, ht->data_size, data);
- return 1;
+ return entry->value;
}
else {
- return 0;
+ return NULL;
}
}
@@ -323,44 +299,17 @@ _Py_hashtable_get_entry_ptr(_Py_hashtable_t *ht, const void *key)
}
-// Specialized for:
-// hash_func == _Py_hashtable_hash_ptr
-// compare_func == _Py_hashtable_compare_direct
-int
-_Py_hashtable_get_ptr(_Py_hashtable_t *ht, const void *key, void *data)
-{
- assert(data != NULL);
- _Py_hashtable_entry_t *entry = _Py_hashtable_get_entry_ptr(ht, key);
- if (entry != NULL) {
- ENTRY_READ_PDATA(ht, entry, ht->data_size, data);
- return 1;
- }
- else {
- return 0;
- }
-}
-
-
-int
-_Py_hashtable_pop(_Py_hashtable_t *ht, const void *key,
- size_t data_size, void *data)
-{
- assert(data != NULL);
- return _Py_hashtable_pop_entry(ht, key, data, data_size);
-}
-
-
int
_Py_hashtable_foreach(_Py_hashtable_t *ht,
_Py_hashtable_foreach_func func,
- void *arg)
+ void *user_data)
{
_Py_hashtable_entry_t *entry;
size_t hv;
for (hv = 0; hv < ht->num_buckets; hv++) {
for (entry = TABLE_HEAD(ht, hv); entry; entry = ENTRY_NEXT(entry)) {
- int res = func(ht, entry, arg);
+ int res = func(ht, entry->key, entry->value, user_data);
if (res)
return res;
}
@@ -414,11 +363,10 @@ hashtable_rehash(_Py_hashtable_t *ht)
_Py_hashtable_t *
-_Py_hashtable_new_full(size_t data_size, size_t init_size,
- _Py_hashtable_hash_func hash_func,
+_Py_hashtable_new_full(_Py_hashtable_hash_func hash_func,
_Py_hashtable_compare_func compare_func,
_Py_hashtable_destroy_func key_destroy_func,
- _Py_hashtable_value_destroy_func value_destroy_func,
+ _Py_hashtable_destroy_func value_destroy_func,
_Py_hashtable_allocator_t *allocator)
{
_Py_hashtable_t *ht;
@@ -437,9 +385,8 @@ _Py_hashtable_new_full(size_t data_size, size_t init_size,
if (ht == NULL)
return ht;
- ht->num_buckets = round_size(init_size);
+ ht->num_buckets = HASHTABLE_MIN_SIZE;
ht->entries = 0;
- ht->data_size = data_size;
buckets_size = ht->num_buckets * sizeof(ht->buckets[0]);
ht->buckets = alloc.malloc(buckets_size);
@@ -449,7 +396,6 @@ _Py_hashtable_new_full(size_t data_size, size_t init_size,
}
memset(ht->buckets, 0, buckets_size);
- ht->get_func = _Py_hashtable_get_generic;
ht->get_entry_func = _Py_hashtable_get_entry_generic;
ht->hash_func = hash_func;
ht->compare_func = compare_func;
@@ -459,7 +405,6 @@ _Py_hashtable_new_full(size_t data_size, size_t init_size,
if (ht->hash_func == _Py_hashtable_hash_ptr
&& ht->compare_func == _Py_hashtable_compare_direct)
{
- ht->get_func = _Py_hashtable_get_ptr;
ht->get_entry_func = _Py_hashtable_get_entry_ptr;
}
return ht;
@@ -467,16 +412,27 @@ _Py_hashtable_new_full(size_t data_size, size_t init_size,
_Py_hashtable_t *
-_Py_hashtable_new(size_t data_size,
- _Py_hashtable_hash_func hash_func,
+_Py_hashtable_new(_Py_hashtable_hash_func hash_func,
_Py_hashtable_compare_func compare_func)
{
- return _Py_hashtable_new_full(data_size, HASHTABLE_MIN_SIZE,
- hash_func, compare_func,
+ return _Py_hashtable_new_full(hash_func, compare_func,
NULL, NULL, NULL);
}
+static void
+_Py_hashtable_destroy_entry(_Py_hashtable_t *ht, _Py_hashtable_entry_t *entry)
+{
+ if (ht->key_destroy_func) {
+ ht->key_destroy_func(entry->key);
+ }
+ if (ht->value_destroy_func) {
+ ht->value_destroy_func(entry->value);
+ }
+ ht->alloc.free(entry);
+}
+
+
void
_Py_hashtable_clear(_Py_hashtable_t *ht)
{
@@ -486,7 +442,7 @@ _Py_hashtable_clear(_Py_hashtable_t *ht)
for (i=0; i < ht->num_buckets; i++) {
for (entry = TABLE_HEAD(ht, i); entry != NULL; entry = next) {
next = ENTRY_NEXT(entry);
- ht->alloc.free(entry);
+ _Py_hashtable_destroy_entry(ht, entry);
}
_Py_slist_init(&ht->buckets[i]);
}
@@ -495,19 +451,6 @@ _Py_hashtable_clear(_Py_hashtable_t *ht)
}
-static void
-_Py_hashtable_destroy_entry(_Py_hashtable_t *ht, _Py_hashtable_entry_t *entry)
-{
- if (ht->key_destroy_func) {
- ht->key_destroy_func(entry->key);
- }
- if (ht->value_destroy_func) {
- ht->value_destroy_func(ht, entry);
- }
- ht->alloc.free(entry);
-}
-
-
void
_Py_hashtable_destroy(_Py_hashtable_t *ht)
{
diff --git a/Python/marshal.c b/Python/marshal.c
index 7c99c1ee13c0e..b096ff8932220 100644
--- a/Python/marshal.c
+++ b/Python/marshal.c
@@ -302,10 +302,10 @@ w_ref(PyObject *v, char *flag, WFILE *p)
if (Py_REFCNT(v) == 1)
return 0;
- entry = _Py_HASHTABLE_GET_ENTRY(p->hashtable, v);
+ entry = _Py_hashtable_get_entry(p->hashtable, v);
if (entry != NULL) {
/* write the reference index to the stream */
- _Py_HASHTABLE_ENTRY_READ_DATA(p->hashtable, entry, w);
+ w = (int)(uintptr_t)entry->value;
/* we don't store "long" indices in the dict */
assert(0 <= w && w <= 0x7fffffff);
w_byte(TYPE_REF, p);
@@ -320,7 +320,7 @@ w_ref(PyObject *v, char *flag, WFILE *p)
}
w = (int)s;
Py_INCREF(v);
- if (_Py_HASHTABLE_SET(p->hashtable, v, w) < 0) {
+ if (_Py_hashtable_set(p->hashtable, v, (void *)(uintptr_t)w) < 0) {
Py_DECREF(v);
goto err;
}
@@ -556,8 +556,7 @@ static int
w_init_refs(WFILE *wf, int version)
{
if (version >= 3) {
- wf->hashtable = _Py_hashtable_new_full(sizeof(int), 0,
- _Py_hashtable_hash_ptr,
+ wf->hashtable = _Py_hashtable_new_full(_Py_hashtable_hash_ptr,
_Py_hashtable_compare_direct,
w_decref_entry, NULL, NULL);
if (wf->hashtable == NULL) {
More information about the Python-checkins
mailing list