Thanks to visit codestin.com
Credit goes to github.com

Skip to content

Commit 5dacbd4

Browse files
vstinnervstinner
committed
Cleanup hashtable.h
Issue #26588: * Pass the hash table rather than the key size to hash and compare functions * _Py_HASHTABLE_READ_KEY() and _Py_HASHTABLE_ENTRY_READ_KEY() macros now expect the hash table as the first parameter, rather than the key size * tracemalloc_get_traces_fill(): use _Py_HASHTABLE_ENTRY_READ_DATA() rather than pointer dereference * Remove the _Py_HASHTABLE_ENTRY_WRITE_PKEY() macro * Move "PKEY" and "PDATA" macros inside hashtable.c
1 parent ca79ccd commit 5dacbd4

4 files changed

Lines changed: 82 additions & 81 deletions

File tree

‎Modules/_tracemalloc.c‎

Lines changed: 24 additions & 26 deletions
Original file line numberDiff line numberDiff line change
@@ -223,23 +223,23 @@ set_reentrant(int reentrant)
223223

224224

225225
static Py_uhash_t
226-
hashtable_hash_pyobject(size_t key_size, const void *pkey)
226+
hashtable_hash_pyobject(_Py_hashtable_t *ht, const void *pkey)
227227
{
228228
PyObject *obj;
229229

230-
_Py_HASHTABLE_READ_KEY(key_size, pkey, obj);
230+
_Py_HASHTABLE_READ_KEY(ht, pkey, obj);
231231
return PyObject_Hash(obj);
232232
}
233233

234234

235235
static int
236-
hashtable_compare_unicode(size_t key_size, const void *pkey,
236+
hashtable_compare_unicode(_Py_hashtable_t *ht, const void *pkey,
237237
const _Py_hashtable_entry_t *entry)
238238
{
239239
PyObject *key1, *key2;
240240

241-
_Py_HASHTABLE_READ_KEY(key_size, pkey, key1);
242-
_Py_HASHTABLE_ENTRY_READ_KEY(key_size, entry, key2);
241+
_Py_HASHTABLE_READ_KEY(ht, pkey, key1);
242+
_Py_HASHTABLE_ENTRY_READ_KEY(ht, entry, key2);
243243

244244
if (key1 != NULL && key2 != NULL)
245245
return (PyUnicode_Compare(key1, key2) == 0);
@@ -249,12 +249,12 @@ hashtable_compare_unicode(size_t key_size, const void *pkey,
249249

250250

251251
static Py_uhash_t
252-
hashtable_hash_pointer_t(size_t key_size, const void *pkey)
252+
hashtable_hash_pointer_t(_Py_hashtable_t *ht, const void *pkey)
253253
{
254254
pointer_t ptr;
255255
Py_uhash_t hash;
256256

257-
_Py_HASHTABLE_READ_KEY(key_size, pkey, ptr);
257+
_Py_HASHTABLE_READ_KEY(ht, pkey, ptr);
258258

259259
hash = (Py_uhash_t)_Py_HashPointer((void*)ptr.ptr);
260260
hash ^= ptr.domain;
@@ -263,13 +263,13 @@ hashtable_hash_pointer_t(size_t key_size, const void *pkey)
263263

264264

265265
int
266-
hashtable_compare_pointer_t(size_t key_size, const void *pkey,
266+
hashtable_compare_pointer_t(_Py_hashtable_t *ht, const void *pkey,
267267
const _Py_hashtable_entry_t *entry)
268268
{
269269
pointer_t ptr1, ptr2;
270270

271-
_Py_HASHTABLE_READ_KEY(key_size, pkey, ptr1);
272-
_Py_HASHTABLE_ENTRY_READ_KEY(key_size, entry, ptr2);
271+
_Py_HASHTABLE_READ_KEY(ht, pkey, ptr1);
272+
_Py_HASHTABLE_ENTRY_READ_KEY(ht, entry, ptr2);
273273

274274
/* compare pointer before domain, because pointer is more likely to be
275275
different */
@@ -304,25 +304,25 @@ raw_free(void *ptr)
304304

305305

306306
static Py_uhash_t
307-
hashtable_hash_traceback(size_t key_size, const void *pkey)
307+
hashtable_hash_traceback(_Py_hashtable_t *ht, const void *pkey)
308308
{
309309
traceback_t *traceback;
310310

311-
_Py_HASHTABLE_READ_KEY(key_size, pkey, traceback);
311+
_Py_HASHTABLE_READ_KEY(ht, pkey, traceback);
312312
return traceback->hash;
313313
}
314314

315315

316316
static int
317-
hashtable_compare_traceback(size_t key_size, const void *pkey,
318-
const _Py_hashtable_entry_t *he)
317+
hashtable_compare_traceback(_Py_hashtable_t *ht, const void *pkey,
318+
const _Py_hashtable_entry_t *entry)
319319
{
320320
traceback_t *traceback1, *traceback2;
321321
const frame_t *frame1, *frame2;
322322
int i;
323323

324-
_Py_HASHTABLE_READ_KEY(key_size, pkey, traceback1);
325-
_Py_HASHTABLE_ENTRY_READ_KEY(key_size, he, traceback2);
324+
_Py_HASHTABLE_READ_KEY(ht, pkey, traceback1);
325+
_Py_HASHTABLE_ENTRY_READ_KEY(ht, entry, traceback2);
326326

327327
if (traceback1->nframe != traceback2->nframe)
328328
return 0;
@@ -395,8 +395,7 @@ tracemalloc_get_frame(PyFrameObject *pyframe, frame_t *frame)
395395
/* intern the filename */
396396
entry = _Py_HASHTABLE_GET_ENTRY(tracemalloc_filenames, filename);
397397
if (entry != NULL) {
398-
_Py_HASHTABLE_ENTRY_READ_KEY(tracemalloc_filenames->key_size, entry,
399-
filename);
398+
_Py_HASHTABLE_ENTRY_READ_KEY(tracemalloc_filenames, entry, filename);
400399
}
401400
else {
402401
/* tracemalloc_filenames is responsible to keep a reference
@@ -490,8 +489,7 @@ traceback_new(void)
490489
/* intern the traceback */
491490
entry = _Py_HASHTABLE_GET_ENTRY(tracemalloc_tracebacks, traceback);
492491
if (entry != NULL) {
493-
_Py_HASHTABLE_ENTRY_READ_KEY(tracemalloc_tracebacks->key_size, entry,
494-
traceback);
492+
_Py_HASHTABLE_ENTRY_READ_KEY(tracemalloc_tracebacks, entry, traceback);
495493
}
496494
else {
497495
traceback_t *copy;
@@ -873,7 +871,7 @@ tracemalloc_clear_filename(_Py_hashtable_t *ht, _Py_hashtable_entry_t *entry,
873871
{
874872
PyObject *filename;
875873

876-
_Py_HASHTABLE_ENTRY_READ_KEY(ht->key_size, entry, filename);
874+
_Py_HASHTABLE_ENTRY_READ_KEY(ht, entry, filename);
877875
Py_DECREF(filename);
878876
return 0;
879877
}
@@ -885,7 +883,7 @@ traceback_free_traceback(_Py_hashtable_t *ht, _Py_hashtable_entry_t *entry,
885883
{
886884
traceback_t *traceback;
887885

888-
_Py_HASHTABLE_ENTRY_READ_KEY(ht->key_size, entry, traceback);
886+
_Py_HASHTABLE_ENTRY_READ_KEY(ht, entry, traceback);
889887
raw_free(traceback);
890888
return 0;
891889
}
@@ -1246,21 +1244,21 @@ tracemalloc_get_traces_fill(_Py_hashtable_t *traces, _Py_hashtable_entry_t *entr
12461244
{
12471245
get_traces_t *get_traces = user_data;
12481246
_PyTraceMalloc_domain_t domain;
1249-
trace_t *trace;
1247+
trace_t trace;
12501248
PyObject *tracemalloc_obj;
12511249
int res;
12521250

12531251
if (tracemalloc_config.use_domain) {
12541252
pointer_t key;
1255-
_Py_HASHTABLE_ENTRY_READ_KEY(traces->key_size, entry, key);
1253+
_Py_HASHTABLE_ENTRY_READ_KEY(traces, entry, key);
12561254
domain = key.domain;
12571255
}
12581256
else {
12591257
domain = DEFAULT_DOMAIN;
12601258
}
1261-
trace = (trace_t *)_Py_HASHTABLE_ENTRY_DATA(traces, entry);
1259+
_Py_HASHTABLE_ENTRY_READ_DATA(traces, entry, trace);
12621260

1263-
tracemalloc_obj = trace_to_pyobject(domain, trace, get_traces->tracebacks);
1261+
tracemalloc_obj = trace_to_pyobject(domain, &trace, get_traces->tracebacks);
12641262
if (tracemalloc_obj == NULL)
12651263
return 1;
12661264

‎Modules/hashtable.c‎

Lines changed: 33 additions & 22 deletions
Original file line numberDiff line numberDiff line change
@@ -61,6 +61,20 @@
6161
#define HASHTABLE_ITEM_SIZE(HT) \
6262
(sizeof(_Py_hashtable_entry_t) + (HT)->key_size + (HT)->data_size)
6363

64+
#define ENTRY_READ_PDATA(TABLE, ENTRY, DATA_SIZE, PDATA) \
65+
do { \
66+
assert((DATA_SIZE) == (TABLE)->data_size); \
67+
Py_MEMCPY((PDATA), _Py_HASHTABLE_ENTRY_PDATA(TABLE, (ENTRY)), \
68+
(DATA_SIZE)); \
69+
} while (0)
70+
71+
#define ENTRY_WRITE_PDATA(TABLE, ENTRY, DATA_SIZE, PDATA) \
72+
do { \
73+
assert((DATA_SIZE) == (TABLE)->data_size); \
74+
Py_MEMCPY((void *)_Py_HASHTABLE_ENTRY_PDATA((TABLE), (ENTRY)), \
75+
(PDATA), (DATA_SIZE)); \
76+
} while (0)
77+
6478
/* Forward declaration */
6579
static void hashtable_rehash(_Py_hashtable_t *ht);
6680

@@ -91,21 +105,21 @@ _Py_slist_remove(_Py_slist_t *list, _Py_slist_item_t *previous,
91105

92106

93107
Py_uhash_t
94-
_Py_hashtable_hash_ptr(size_t key_size, const void *pkey)
108+
_Py_hashtable_hash_ptr(struct _Py_hashtable_t *ht, const void *pkey)
95109
{
96110
void *key;
97111

98-
_Py_HASHTABLE_READ_KEY(key_size, pkey, key);
99-
return (Py_uhash_t)_Py_HashPointer((void *)key);
112+
_Py_HASHTABLE_READ_KEY(ht, pkey, key);
113+
return (Py_uhash_t)_Py_HashPointer(key);
100114
}
101115

102116

103117
int
104-
_Py_hashtable_compare_direct(size_t key_size, const void *pkey,
118+
_Py_hashtable_compare_direct(_Py_hashtable_t *ht, const void *pkey,
105119
const _Py_hashtable_entry_t *entry)
106120
{
107-
const void *pkey2 = _Py_HASHTABLE_ENTRY_KEY(entry);
108-
return (memcmp(pkey, pkey2, key_size) == 0);
121+
const void *pkey2 = _Py_HASHTABLE_ENTRY_PKEY(entry);
122+
return (memcmp(pkey, pkey2, ht->key_size) == 0);
109123
}
110124

111125

@@ -245,12 +259,11 @@ _Py_hashtable_get_entry(_Py_hashtable_t *ht,
245259

246260
assert(key_size == ht->key_size);
247261

248-
key_hash = ht->hash_func(key_size, pkey);
262+
key_hash = ht->hash_func(ht, pkey);
249263
index = key_hash & (ht->num_buckets - 1);
250264

251265
for (entry = TABLE_HEAD(ht, index); entry != NULL; entry = ENTRY_NEXT(entry)) {
252-
if (entry->key_hash == key_hash
253-
&& ht->compare_func(key_size, pkey, entry))
266+
if (entry->key_hash == key_hash && ht->compare_func(ht, pkey, entry))
254267
break;
255268
}
256269

@@ -268,13 +281,12 @@ _Py_hashtable_pop_entry(_Py_hashtable_t *ht, size_t key_size, const void *pkey,
268281

269282
assert(key_size == ht->key_size);
270283

271-
key_hash = ht->hash_func(key_size, pkey);
284+
key_hash = ht->hash_func(ht, pkey);
272285
index = key_hash & (ht->num_buckets - 1);
273286

274287
previous = NULL;
275288
for (entry = TABLE_HEAD(ht, index); entry != NULL; entry = ENTRY_NEXT(entry)) {
276-
if (entry->key_hash == key_hash
277-
&& ht->compare_func(key_size, pkey, entry))
289+
if (entry->key_hash == key_hash && ht->compare_func(ht, pkey, entry))
278290
break;
279291
previous = entry;
280292
}
@@ -287,7 +299,7 @@ _Py_hashtable_pop_entry(_Py_hashtable_t *ht, size_t key_size, const void *pkey,
287299
ht->entries--;
288300

289301
if (data != NULL)
290-
_Py_HASHTABLE_ENTRY_READ_PDATA(ht, entry, data_size, data);
302+
ENTRY_READ_PDATA(ht, entry, data_size, data);
291303
ht->alloc.free(entry);
292304

293305
if ((float)ht->entries / (float)ht->num_buckets < HASHTABLE_LOW)
@@ -315,7 +327,7 @@ _Py_hashtable_set(_Py_hashtable_t *ht, size_t key_size, const void *pkey,
315327
assert(entry == NULL);
316328
#endif
317329

318-
key_hash = ht->hash_func(key_size, pkey);
330+
key_hash = ht->hash_func(ht, pkey);
319331
index = key_hash & (ht->num_buckets - 1);
320332

321333
entry = ht->alloc.malloc(HASHTABLE_ITEM_SIZE(ht));
@@ -325,8 +337,8 @@ _Py_hashtable_set(_Py_hashtable_t *ht, size_t key_size, const void *pkey,
325337
}
326338

327339
entry->key_hash = key_hash;
328-
_Py_HASHTABLE_ENTRY_WRITE_PKEY(key_size, entry, pkey);
329-
_Py_HASHTABLE_ENTRY_WRITE_PDATA(ht, entry, data_size, data);
340+
Py_MEMCPY((void *)_Py_HASHTABLE_ENTRY_PKEY(entry), pkey, ht->key_size);
341+
ENTRY_WRITE_PDATA(ht, entry, data_size, data);
330342

331343
_Py_slist_prepend(&ht->buckets[index], (_Py_slist_item_t*)entry);
332344
ht->entries++;
@@ -348,7 +360,7 @@ _Py_hashtable_get(_Py_hashtable_t *ht, size_t key_size,const void *pkey,
348360
entry = _Py_hashtable_get_entry(ht, key_size, pkey);
349361
if (entry == NULL)
350362
return 0;
351-
_Py_HASHTABLE_ENTRY_READ_PDATA(ht, entry, data_size, data);
363+
ENTRY_READ_PDATA(ht, entry, data_size, data);
352364
return 1;
353365
}
354366

@@ -399,7 +411,6 @@ _Py_hashtable_foreach(_Py_hashtable_t *ht,
399411
static void
400412
hashtable_rehash(_Py_hashtable_t *ht)
401413
{
402-
const size_t key_size = ht->key_size;
403414
size_t buckets_size, new_size, bucket;
404415
_Py_slist_t *old_buckets = NULL;
405416
size_t old_num_buckets;
@@ -429,7 +440,7 @@ hashtable_rehash(_Py_hashtable_t *ht)
429440
size_t entry_index;
430441

431442

432-
assert(ht->hash_func(key_size, _Py_HASHTABLE_ENTRY_KEY(entry)) == entry->key_hash);
443+
assert(ht->hash_func(ht, _Py_HASHTABLE_ENTRY_PKEY(entry)) == entry->key_hash);
433444
next = ENTRY_NEXT(entry);
434445
entry_index = entry->key_hash & (new_size - 1);
435446

@@ -499,9 +510,9 @@ _Py_hashtable_copy(_Py_hashtable_t *src)
499510
for (bucket=0; bucket < src->num_buckets; bucket++) {
500511
entry = TABLE_HEAD(src, bucket);
501512
for (; entry; entry = ENTRY_NEXT(entry)) {
502-
const void *pkey = _Py_HASHTABLE_ENTRY_KEY(entry);
503-
const void *data = _Py_HASHTABLE_ENTRY_DATA(src, entry);
504-
err = _Py_hashtable_set(dst, key_size, pkey, data_size, data);
513+
const void *pkey = _Py_HASHTABLE_ENTRY_PKEY(entry);
514+
const void *pdata = _Py_HASHTABLE_ENTRY_PDATA(src, entry);
515+
err = _Py_hashtable_set(dst, key_size, pkey, data_size, pdata);
505516
if (err) {
506517
_Py_hashtable_destroy(dst);
507518
return NULL;

0 commit comments

Comments
 (0)