Ooops, revert changeset ea9efa06c137

Change pushed by mistake, the patch is still under review :-/

"""
_tracemalloc: add domain to trace keys

* hashtable.h: key has now a variable size
* _tracemalloc uses (pointer: void*, domain: unsigned int) as key for traces
"""

1 files changed, 43 insertions, 62 deletions

diff --git a/Modules/hashtable.c b/Modules/hashtable.c
index 002c0a9342..7de154b70a 100644
--- a/Modules/hashtable.c
+++ b/Modules/hashtable.c
@@ -59,7 +59,7 @@
 #define ENTRY_NEXT(ENTRY) \
         ((_Py_hashtable_entry_t *)_Py_SLIST_ITEM_NEXT(ENTRY))
 #define HASHTABLE_ITEM_SIZE(HT) \
-        (sizeof(_Py_hashtable_entry_t) + (HT)->key_size + (HT)->data_size)
+        (sizeof(_Py_hashtable_entry_t) + (HT)->data_size)
 
 /* Forward declaration */
 static void hashtable_rehash(_Py_hashtable_t *ht);
@@ -88,21 +88,21 @@ _Py_slist_remove(_Py_slist_t *list, _Py_slist_item_t *previous,
 }
 
 Py_uhash_t
-_Py_hashtable_hash_ptr(size_t key_size, const void *pkey)
+_Py_hashtable_hash_int(const void *key)
 {
-    void *key;
-
-    assert(key_size == sizeof(void *));
-    key = *(void**)pkey;
+    return (Py_uhash_t)key;
+}
 
+Py_uhash_t
+_Py_hashtable_hash_ptr(const void *key)
+{
     return (Py_uhash_t)_Py_HashPointer((void *)key);
 }
 
 int
-_Py_hashtable_compare_direct(size_t key_size, const void *pkey,
-                             const _Py_hashtable_entry_t *entry)
+_Py_hashtable_compare_direct(const void *key, const _Py_hashtable_entry_t *entry)
 {
-    return (memcmp(pkey, _Py_HASHTABLE_ENTRY_KEY(entry), key_size) == 0);
+    return entry->key == key;
 }
 
 /* makes sure the real size of the buckets array is a power of 2 */
@@ -119,8 +119,7 @@ round_size(size_t s)
 }
 
 _Py_hashtable_t *
-_Py_hashtable_new_full(size_t key_size, size_t data_size,
-                       size_t init_size,
+_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_copy_data_func copy_data_func,
@@ -145,7 +144,6 @@ _Py_hashtable_new_full(size_t key_size, size_t data_size,
 
     ht->num_buckets = round_size(init_size);
     ht->entries = 0;
-    ht->key_size = key_size;
     ht->data_size = data_size;
 
     buckets_size = ht->num_buckets * sizeof(ht->buckets[0]);
@@ -166,12 +164,11 @@ _Py_hashtable_new_full(size_t key_size, size_t data_size,
 }
 
 _Py_hashtable_t *
-_Py_hashtable_new(size_t key_size, size_t data_size,
+_Py_hashtable_new(size_t data_size,
                   _Py_hashtable_hash_func hash_func,
                   _Py_hashtable_compare_func compare_func)
 {
-    return _Py_hashtable_new_full(key_size, data_size,
-                                  HASHTABLE_MIN_SIZE,
+    return _Py_hashtable_new_full(data_size, HASHTABLE_MIN_SIZE,
                                   hash_func, compare_func,
                                   NULL, NULL, NULL, NULL);
 }
@@ -198,7 +195,7 @@ _Py_hashtable_size(_Py_hashtable_t *ht)
             for (entry = TABLE_HEAD(ht, hv); entry; entry = ENTRY_NEXT(entry)) {
                 void *data;
 
-                data = _Py_HASHTABLE_ENTRY_DATA_AS_VOID_P(ht, entry);
+                data = _Py_HASHTABLE_ENTRY_DATA_AS_VOID_P(entry);
                 size += ht->get_data_size_func(data);
             }
         }
@@ -248,21 +245,17 @@ _Py_hashtable_print_stats(_Py_hashtable_t *ht)
 
 /* Get an entry. Return NULL if the key does not exist. */
 _Py_hashtable_entry_t *
-_Py_hashtable_get_entry(_Py_hashtable_t *ht,
-                        size_t key_size, const void *pkey)
+_Py_hashtable_get_entry(_Py_hashtable_t *ht, const void *key)
 {
     Py_uhash_t key_hash;
     size_t index;
     _Py_hashtable_entry_t *entry;
 
-    assert(key_size == ht->key_size);
-
-    key_hash = ht->hash_func(key_size, pkey);
+    key_hash = ht->hash_func(key);
     index = key_hash & (ht->num_buckets - 1);
 
     for (entry = TABLE_HEAD(ht, index); entry != NULL; entry = ENTRY_NEXT(entry)) {
-        if (entry->key_hash == key_hash
-           && ht->compare_func(key_size, pkey, entry))
+        if (entry->key_hash == key_hash && ht->compare_func(key, entry))
             break;
     }
 
@@ -270,20 +263,18 @@ _Py_hashtable_get_entry(_Py_hashtable_t *ht,
 }
 
 static int
-_hashtable_pop_entry(_Py_hashtable_t *ht, size_t key_size, const void *pkey,
-                     void *data, size_t data_size)
+_hashtable_pop_entry(_Py_hashtable_t *ht, const void *key, void *data, size_t data_size)
 {
     Py_uhash_t key_hash;
     size_t index;
     _Py_hashtable_entry_t *entry, *previous;
 
-    key_hash = ht->hash_func(key_size, pkey);
+    key_hash = ht->hash_func(key);
     index = key_hash & (ht->num_buckets - 1);
 
     previous = NULL;
     for (entry = TABLE_HEAD(ht, index); entry != NULL; entry = ENTRY_NEXT(entry)) {
-        if (entry->key_hash == key_hash
-           && ht->compare_func(key_size, pkey, entry))
+        if (entry->key_hash == key_hash && ht->compare_func(key, entry))
             break;
         previous = entry;
     }
@@ -307,8 +298,8 @@ _hashtable_pop_entry(_Py_hashtable_t *ht, size_t key_size, const void *pkey,
 /* 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. */
 int
-_Py_hashtable_set(_Py_hashtable_t *ht, size_t key_size, const void *pkey,
-                  size_t data_size, void *data)
+_Py_hashtable_set(_Py_hashtable_t *ht, const void *key,
+                  void *data, size_t data_size)
 {
     Py_uhash_t key_hash;
     size_t index;
@@ -319,11 +310,11 @@ _Py_hashtable_set(_Py_hashtable_t *ht, size_t key_size, const void *pkey,
     /* 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
        be read using a debugger. */
-    entry = _Py_hashtable_get_entry(ht, key_size, pkey);
+    entry = _Py_hashtable_get_entry(ht, key);
     assert(entry == NULL);
 #endif
 
-    key_hash = ht->hash_func(key_size, pkey);
+    key_hash = ht->hash_func(key);
     index = key_hash & (ht->num_buckets - 1);
 
     entry = ht->alloc.malloc(HASHTABLE_ITEM_SIZE(ht));
@@ -332,11 +323,11 @@ _Py_hashtable_set(_Py_hashtable_t *ht, size_t key_size, const void *pkey,
         return -1;
     }
 
+    entry->key = (void *)key;
     entry->key_hash = key_hash;
-    memcpy(_Py_HASHTABLE_ENTRY_KEY(entry), pkey, key_size);
 
     assert(data_size == ht->data_size);
-    memcpy(_Py_HASHTABLE_ENTRY_DATA(ht, entry), data, data_size);
+    memcpy(_Py_HASHTABLE_ENTRY_DATA(entry), data, data_size);
 
     _Py_slist_prepend(&ht->buckets[index], (_Py_slist_item_t*)entry);
     ht->entries++;
@@ -349,14 +340,13 @@ _Py_hashtable_set(_Py_hashtable_t *ht, size_t key_size, const void *pkey,
 /* 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. */
 int
-_Py_hashtable_get(_Py_hashtable_t *ht, size_t key_size,const void *pkey,
-                  size_t data_size, void *data)
+_Py_hashtable_get(_Py_hashtable_t *ht, const void *key, void *data, size_t data_size)
 {
     _Py_hashtable_entry_t *entry;
 
     assert(data != NULL);
 
-    entry = _Py_hashtable_get_entry(ht, key_size, pkey);
+    entry = _Py_hashtable_get_entry(ht, key);
     if (entry == NULL)
         return 0;
     _Py_HASHTABLE_ENTRY_READ_DATA(ht, data, data_size, entry);
@@ -364,23 +354,22 @@ _Py_hashtable_get(_Py_hashtable_t *ht, size_t key_size,const void *pkey,
 }
 
 int
-_Py_hashtable_pop(_Py_hashtable_t *ht, size_t key_size, const void *pkey,
-                  size_t data_size, void *data)
+_Py_hashtable_pop(_Py_hashtable_t *ht, const void *key, void *data, size_t data_size)
 {
     assert(data != NULL);
     assert(ht->free_data_func == NULL);
-    return _hashtable_pop_entry(ht, key_size, pkey, data, data_size);
+    return _hashtable_pop_entry(ht, key, data, data_size);
 }
 
 /* Delete an entry. The entry must exist. */
 void
-_Py_hashtable_delete(_Py_hashtable_t *ht, size_t key_size, const void *pkey)
+_Py_hashtable_delete(_Py_hashtable_t *ht, const void *key)
 {
 #ifndef NDEBUG
-    int found = _hashtable_pop_entry(ht, key_size, pkey, NULL, 0);
+    int found = _hashtable_pop_entry(ht, key, NULL, 0);
     assert(found);
 #else
-    (void)_hashtable_pop_entry(ht, key_size, pkey, NULL, 0);
+    (void)_hashtable_pop_entry(ht, key, NULL, 0);
 #endif
 }
 
@@ -389,7 +378,7 @@ _Py_hashtable_delete(_Py_hashtable_t *ht, size_t key_size, const void *pkey)
    stops if a non-zero value is returned. */
 int
 _Py_hashtable_foreach(_Py_hashtable_t *ht,
-                      _Py_hashtable_foreach_func func,
+                      int (*func) (_Py_hashtable_entry_t *entry, void *arg),
                       void *arg)
 {
     _Py_hashtable_entry_t *entry;
@@ -397,7 +386,7 @@ _Py_hashtable_foreach(_Py_hashtable_t *ht,
 
     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(entry, arg);
             if (res)
                 return res;
         }
@@ -408,7 +397,6 @@ _Py_hashtable_foreach(_Py_hashtable_t *ht,
 static void
 hashtable_rehash(_Py_hashtable_t *ht)
 {
-    const size_t key_size = ht->key_size;
     size_t buckets_size, new_size, bucket;
     _Py_slist_t *old_buckets = NULL;
     size_t old_num_buckets;
@@ -437,8 +425,7 @@ hashtable_rehash(_Py_hashtable_t *ht)
         for (entry = BUCKETS_HEAD(old_buckets[bucket]); entry != NULL; entry = next) {
             size_t entry_index;
 
-
-            assert(ht->hash_func(key_size, _Py_HASHTABLE_ENTRY_KEY(entry)) == entry->key_hash);
+            assert(ht->hash_func(entry->key) == entry->key_hash);
             next = ENTRY_NEXT(entry);
             entry_index = entry->key_hash & (new_size - 1);
 
@@ -459,7 +446,7 @@ _Py_hashtable_clear(_Py_hashtable_t *ht)
         for (entry = TABLE_HEAD(ht, i); entry != NULL; entry = next) {
             next = ENTRY_NEXT(entry);
             if (ht->free_data_func)
-                ht->free_data_func(_Py_HASHTABLE_ENTRY_DATA_AS_VOID_P(ht, entry));
+                ht->free_data_func(_Py_HASHTABLE_ENTRY_DATA_AS_VOID_P(entry));
             ht->alloc.free(entry);
         }
         _Py_slist_init(&ht->buckets[i]);
@@ -478,7 +465,7 @@ _Py_hashtable_destroy(_Py_hashtable_t *ht)
         while (entry) {
             _Py_slist_item_t *entry_next = entry->next;
             if (ht->free_data_func)
-                ht->free_data_func(_Py_HASHTABLE_ENTRY_DATA_AS_VOID_P(ht, entry));
+                ht->free_data_func(_Py_HASHTABLE_ENTRY_DATA_AS_VOID_P(entry));
             ht->alloc.free(entry);
             entry = entry_next;
         }
@@ -492,16 +479,13 @@ _Py_hashtable_destroy(_Py_hashtable_t *ht)
 _Py_hashtable_t *
 _Py_hashtable_copy(_Py_hashtable_t *src)
 {
-    const size_t key_size = src->key_size;
-    const size_t data_size = src->data_size;
     _Py_hashtable_t *dst;
     _Py_hashtable_entry_t *entry;
     size_t bucket;
     int err;
     void *data, *new_data;
 
-    dst = _Py_hashtable_new_full(key_size, data_size,
-                                 src->num_buckets,
+    dst = _Py_hashtable_new_full(src->data_size, src->num_buckets,
                                  src->hash_func, src->compare_func,
                                  src->copy_data_func, src->free_data_func,
                                  src->get_data_size_func, &src->alloc);
@@ -512,20 +496,17 @@ _Py_hashtable_copy(_Py_hashtable_t *src)
         entry = TABLE_HEAD(src, bucket);
         for (; entry; entry = ENTRY_NEXT(entry)) {
             if (src->copy_data_func) {
-                data = _Py_HASHTABLE_ENTRY_DATA_AS_VOID_P(src, entry);
+                data = _Py_HASHTABLE_ENTRY_DATA_AS_VOID_P(entry);
                 new_data = src->copy_data_func(data);
                 if (new_data != NULL)
-                    err = _Py_hashtable_set(dst, key_size,
-                                            _Py_HASHTABLE_ENTRY_KEY(entry),
-                                            data_size, &new_data);
+                    err = _Py_hashtable_set(dst, entry->key,
+                                        &new_data, src->data_size);
                 else
                     err = 1;
             }
             else {
-                data = _Py_HASHTABLE_ENTRY_DATA(src, entry);
-                err = _Py_hashtable_set(dst, key_size,
-                                        _Py_HASHTABLE_ENTRY_KEY(entry),
-                                        data_size, data);
+                data = _Py_HASHTABLE_ENTRY_DATA(entry);
+                err = _Py_hashtable_set(dst, entry->key, data, src->data_size);
             }
             if (err) {
                 _Py_hashtable_destroy(dst);