Move the flag to the dict keys object.

Author: serhiy-storchaka

Include/dictobject.h

@@ -26,9 +26,6 @@ typedef struct {
     /* Number of items in the dictionary */
     Py_ssize_t ma_used;
 
-    /* Whether OrderedDict's cache is synchronized with dict table */
-    unsigned int ma_clean: 1;
-
     /* Dictionary version: globally unique, value change each time
        the dictionary is modified */
     uint64_t ma_version_tag;

Lib/test/test_ordered_dict.py

@@ -676,7 +676,7 @@ def test_sizeof_exact(self):
         size = support.calcobjsize
         check = self.check_sizeof
 
-        basicsize = size('niQ2P' + '3Pn2P') + calcsize('2nP2n')
+        basicsize = size('nQ2P' + '3Pn2P') + calcsize('2nP2ni0P')
 
         entrysize = calcsize('n2P')
         p = calcsize('P')

Lib/test/test_sys.py

@@ -965,9 +965,9 @@ def inner():
         # method-wrapper (descriptor object)
         check({}.__iter__, size('2P'))
         # dict
-        check({}, size('niQ2P') + calcsize('2nP2n') + 8 + (8*2//3)*calcsize('n2P'))
+        check({}, size('nQ2P') + calcsize('2nP2ni0P') + 8 + (8*2//3)*calcsize('n2P'))
         longdict = {1:1, 2:2, 3:3, 4:4, 5:5, 6:6, 7:7, 8:8}
-        check(longdict, size('niQ2P') + calcsize('2nP2n') + 16 + (16*2//3)*calcsize('n2P'))
+        check(longdict, size('nQ2P') + calcsize('2nP2ni0P') + 16 + (16*2//3)*calcsize('n2P'))
         # dictionary-keyview
         check({}.keys(), size('P'))
         # dictionary-valueview
@@ -1128,15 +1128,15 @@ def delx(self): del self.__x
                   '4P')
         class newstyleclass(object): pass
         # Separate block for PyDictKeysObject with 8 keys and 5 entries
-        check(newstyleclass, s + calcsize("2nP2n0P") + 8 + 5*calcsize("n2P"))
+        check(newstyleclass, s + calcsize("2nP2ni0P") + 8 + 5*calcsize("n2P"))
         # dict with shared keys
-        check(newstyleclass().__dict__, size('niQ2P') + 5*self.P)
+        check(newstyleclass().__dict__, size('nQ2P') + 5*self.P)
         o = newstyleclass()
         o.a = o.b = o.c = o.d = o.e = o.f = o.g = o.h = 1
         # Separate block for PyDictKeysObject with 16 keys and 10 entries
-        check(newstyleclass, s + calcsize("2nP2n0P") + 16 + 10*calcsize("n2P"))
+        check(newstyleclass, s + calcsize("2nP2ni0P") + 16 + 10*calcsize("n2P"))
         # dict with shared keys
-        check(newstyleclass().__dict__, size('niQ2P') + 10*self.P)
+        check(newstyleclass().__dict__, size('nQ2P') + 10*self.P)
         # unicode
         # each tuple contains a string and its expected character size
         # don't put any static strings here, as they may contain

Objects/dict-common.h

@@ -46,6 +46,9 @@ struct _dictkeysobject {
     /* Number of used entries in dk_entries. */
     Py_ssize_t dk_nentries;
 
+    /* Whether OrderedDict's cache is synchronized with dict table */
+    unsigned int dk_clean;
+
     /* Actual hash table of dk_size entries. It holds indices in dk_entries,
        or DKIX_EMPTY(-1) or DKIX_DUMMY(-2).
 

Objects/dictobject.c

@@ -544,6 +544,7 @@ static PyDictKeysObject *new_keys_object(Py_ssize_t size)
     dk->dk_usable = usable;
     dk->dk_lookup = lookdict_unicode_nodummy;
     dk->dk_nentries = 0;
+    dk->dk_clean = 0;
     memset(&dk->dk_indices.as_1[0], 0xff, es * size);
     memset(DK_ENTRIES(dk), 0, sizeof(PyDictKeyEntry) * usable);
     return dk;
@@ -591,7 +592,6 @@ new_dict(PyDictKeysObject *keys, PyObject **values)
     mp->ma_keys = keys;
     mp->ma_values = values;
     mp->ma_used = 0;
-    mp->ma_clean = 0;
     mp->ma_version_tag = DICT_NEXT_VERSION();
     assert(_PyDict_CheckConsistency(mp));
     return (PyObject *)mp;
@@ -1087,13 +1087,12 @@ dictresize(PyDictObject *mp, Py_ssize_t minsize)
             mp->ma_keys = oldkeys;
             return -1;
         }
-        mp->ma_clean = 0;
         // New table must be large enough.
         assert(mp->ma_keys->dk_usable >= mp->ma_used);
         if (oldkeys->dk_lookup == lookdict)
             mp->ma_keys->dk_lookup = lookdict;
     }
-    mp->ma_clean = 0;
+    mp->ma_keys->dk_clean = 0;
 
     numentries = mp->ma_used;
     oldentries = DK_ENTRIES(oldkeys);
@@ -1587,7 +1586,6 @@ PyDict_Clear(PyObject *op)
     mp->ma_keys = Py_EMPTY_KEYS;
     mp->ma_values = empty_values;
     mp->ma_used = 0;
-    mp->ma_clean = 0;
     mp->ma_version_tag = DICT_NEXT_VERSION();
     /* ...then clear the keys and values */
     if (oldvalues != NULL) {
@@ -2511,7 +2509,6 @@ PyDict_Copy(PyObject *o)
         split_copy->ma_values = newvalues;
         split_copy->ma_keys = mp->ma_keys;
         split_copy->ma_used = mp->ma_used;
-        split_copy->ma_clean = 0;
         DK_INCREF(mp->ma_keys);
         for (i = 0, n = size; i < n; i++) {
             PyObject *value = mp->ma_values[i];
@@ -3099,7 +3096,6 @@ dict_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
         _PyObject_GC_UNTRACK(d);
 
     d->ma_used = 0;
-    d->ma_clean = 0;
     d->ma_version_tag = DICT_NEXT_VERSION();
     d->ma_keys = new_keys_object(PyDict_MINSIZE);
     if (d->ma_keys == NULL) {

Objects/odictobject.c

@@ -584,7 +584,7 @@ _odict_resize(PyODictObject *od) {
     /* Replace the old fast nodes table. */
     _odict_free_fast_nodes(od);
     od->od_fast_nodes = fast_nodes;
-    ((PyDictObject *)od)->ma_clean = 1;
+    ((PyDictObject *)od)->ma_keys->dk_clean = 1;
     return 0;
 }
 
@@ -593,7 +593,7 @@ static Py_ssize_t
 _odict_get_index(PyODictObject *od, PyObject *key, Py_hash_t hash)
 {
     /* Ensure od_fast_nodes and dk_entries are in sync. */
-    if (!((PyDictObject *)od)->ma_clean) {
+    if (!((PyDictObject *)od)->ma_keys->dk_clean) {
         int resize_res = _odict_resize(od);
         if (resize_res < 0)
             return -1;