_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

Modules/hashtable.h

@@ -20,26 +20,31 @@ typedef struct {
     /* used by _Py_hashtable_t.buckets to link entries */
     _Py_slist_item_t _Py_slist_item;
 
-    const void *key;
     Py_uhash_t key_hash;
 
     /* data follows */
 } _Py_hashtable_entry_t;
 
-#define _Py_HASHTABLE_ENTRY_DATA(ENTRY) \
-        ((char *)(ENTRY) + sizeof(_Py_hashtable_entry_t))
+#define _Py_HASHTABLE_ENTRY_KEY(ENTRY) \
+        ((void *)((char *)(ENTRY) + sizeof(_Py_hashtable_entry_t)))
 
-#define _Py_HASHTABLE_ENTRY_DATA_AS_VOID_P(ENTRY) \
-        (*(void **)_Py_HASHTABLE_ENTRY_DATA(ENTRY))
+#define _Py_HASHTABLE_ENTRY_DATA(TABLE, ENTRY) \
+        ((char *)(ENTRY) + sizeof(_Py_hashtable_entry_t) + (TABLE)->key_size)
+
+#define _Py_HASHTABLE_ENTRY_DATA_AS_VOID_P(TABLE, ENTRY) \
+        (*(void **)_Py_HASHTABLE_ENTRY_DATA(TABLE, ENTRY))
 
 #define _Py_HASHTABLE_ENTRY_READ_DATA(TABLE, DATA, DATA_SIZE, ENTRY) \
     do { \
         assert((DATA_SIZE) == (TABLE)->data_size); \
-        memcpy(DATA, _Py_HASHTABLE_ENTRY_DATA(ENTRY), DATA_SIZE); \
+        memcpy(DATA, _Py_HASHTABLE_ENTRY_DATA(TABLE, ENTRY), DATA_SIZE); \
     } while (0)
 
-typedef Py_uhash_t (*_Py_hashtable_hash_func) (const void *key);
-typedef int (*_Py_hashtable_compare_func) (const void *key, const _Py_hashtable_entry_t *he);
+typedef Py_uhash_t (*_Py_hashtable_hash_func) (size_t key_size,
+                                               const void *pkey);
+typedef int (*_Py_hashtable_compare_func) (size_t key_size,
+                                           const void *pkey,
+                                           const _Py_hashtable_entry_t *he);
 typedef void* (*_Py_hashtable_copy_data_func)(void *data);
 typedef void (*_Py_hashtable_free_data_func)(void *data);
 typedef size_t (*_Py_hashtable_get_data_size_func)(void *data);
@@ -56,6 +61,7 @@ typedef struct {
     size_t num_buckets;
     size_t entries; /* Total number of entries in the table. */
     _Py_slist_t *buckets;
+    size_t key_size;
     size_t data_size;
 
     _Py_hashtable_hash_func hash_func;
@@ -67,15 +73,21 @@ typedef struct {
 } _Py_hashtable_t;
 
 /* hash and compare functions for integers and pointers */
-PyAPI_FUNC(Py_uhash_t) _Py_hashtable_hash_ptr(const void *key);
-PyAPI_FUNC(Py_uhash_t) _Py_hashtable_hash_int(const void *key);
-PyAPI_FUNC(int) _Py_hashtable_compare_direct(const void *key, const _Py_hashtable_entry_t *entry);
+PyAPI_FUNC(Py_uhash_t) _Py_hashtable_hash_ptr(
+    size_t key_size,
+    const void *pkey);
+PyAPI_FUNC(int) _Py_hashtable_compare_direct(
+    size_t key_size,
+    const void *pkey,
+    const _Py_hashtable_entry_t *entry);
 
 PyAPI_FUNC(_Py_hashtable_t *) _Py_hashtable_new(
+    size_t key_size,
     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 key_size,
     size_t data_size,
     size_t init_size,
     _Py_hashtable_hash_func hash_func,
@@ -88,40 +100,65 @@ PyAPI_FUNC(_Py_hashtable_t *) _Py_hashtable_copy(_Py_hashtable_t *src);
 PyAPI_FUNC(void) _Py_hashtable_clear(_Py_hashtable_t *ht);
 PyAPI_FUNC(void) _Py_hashtable_destroy(_Py_hashtable_t *ht);
 
-typedef int (*_Py_hashtable_foreach_func) (_Py_hashtable_entry_t *entry, void *arg);
+typedef int (*_Py_hashtable_foreach_func) (_Py_hashtable_t *ht,
+                                           _Py_hashtable_entry_t *entry,
+                                           void *arg);
 
 PyAPI_FUNC(int) _Py_hashtable_foreach(
     _Py_hashtable_t *ht,
-    _Py_hashtable_foreach_func func, void *arg);
+    _Py_hashtable_foreach_func func,
+    void *arg);
 PyAPI_FUNC(size_t) _Py_hashtable_size(_Py_hashtable_t *ht);
 
 PyAPI_FUNC(_Py_hashtable_entry_t*) _Py_hashtable_get_entry(
     _Py_hashtable_t *ht,
-    const void *key);
+    size_t key_size,
+    const void *pkey);
+
+/* Don't call directly this function,
+   but use _Py_HASHTABLE_SET() and _Py_HASHTABLE_SET_NODATA() macros */
 PyAPI_FUNC(int) _Py_hashtable_set(
     _Py_hashtable_t *ht,
-    const void *key,
-    void *data,
-    size_t data_size);
+    size_t key_size,
+    const void *pkey,
+    size_t data_size,
+    void *data);
+
+/* Don't call directly this function, but use _Py_HASHTABLE_GET() macro */
 PyAPI_FUNC(int) _Py_hashtable_get(
     _Py_hashtable_t *ht,
-    const void *key,
-    void *data,
-    size_t data_size);
+    size_t key_size,
+    const void *pkey,
+    size_t data_size,
+    void *data);
+
+/* Don't call directly this function, but use _Py_HASHTABLE_POP() macro */
 PyAPI_FUNC(int) _Py_hashtable_pop(
     _Py_hashtable_t *ht,
-    const void *key,
-    void *data,
-    size_t data_size);
+    size_t key_size,
+    const void *pkey,
+    size_t data_size,
+    void *data);
+
 PyAPI_FUNC(void) _Py_hashtable_delete(
     _Py_hashtable_t *ht,
-    const void *key);
+    size_t key_size,
+    const void *pkey);
 
 #define _Py_HASHTABLE_SET(TABLE, KEY, DATA) \
-    _Py_hashtable_set(TABLE, KEY, &(DATA), sizeof(DATA))
+    _Py_hashtable_set(TABLE, sizeof(KEY), &KEY, sizeof(DATA), &(DATA))
+
+#define _Py_HASHTABLE_SET_NODATA(TABLE, KEY) \
+    _Py_hashtable_set(TABLE, sizeof(KEY), &KEY, 0, NULL)
+
+#define _Py_HASHTABLE_GET_ENTRY(TABLE, KEY) \
+    _Py_hashtable_get_entry(TABLE, sizeof(KEY), &(KEY))
 
 #define _Py_HASHTABLE_GET(TABLE, KEY, DATA) \
-    _Py_hashtable_get(TABLE, KEY, &(DATA), sizeof(DATA))
+    _Py_hashtable_get(TABLE, sizeof(KEY), &(KEY), sizeof(DATA), &(DATA))
+
+#define _Py_HASHTABLE_POP(TABLE, KEY, DATA) \
+    _Py_hashtable_pop(TABLE, sizeof(KEY), &(KEY), sizeof(DATA), &(DATA))
 
 #endif   /* Py_LIMITED_API */
 

Python/marshal.c

@@ -263,7 +263,7 @@ 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, &w, sizeof(w), entry);
@@ -571,7 +571,8 @@ static int
 w_init_refs(WFILE *wf, int version)
 {
     if (version >= 3) {
-        wf->hashtable = _Py_hashtable_new(sizeof(int), _Py_hashtable_hash_ptr,
+        wf->hashtable = _Py_hashtable_new(sizeof(void *), sizeof(int),
+                                          _Py_hashtable_hash_ptr,
                                           _Py_hashtable_compare_direct);
         if (wf->hashtable == NULL) {
             PyErr_NoMemory();
@@ -582,9 +583,11 @@ w_init_refs(WFILE *wf, int version)
 }
 
 static int
-w_decref_entry(_Py_hashtable_entry_t *entry, void *Py_UNUSED(data))
+w_decref_entry(_Py_hashtable_t *ht, _Py_hashtable_entry_t *entry, void *Py_UNUSED(data))
 {
-    Py_XDECREF(entry->key);
+    void *entry_key = *(void **)_Py_HASHTABLE_ENTRY_KEY(entry);
+    assert(ht->key_size == sizeof(entry_key));
+    Py_XDECREF(entry_key);
     return 0;
 }