cpython: c35d65c9ded3 (original) (raw)

Mercurial > cpython

changeset 99223:c35d65c9ded3

Issue #25557: Refactor _PyDict_LoadGlobal() Don't fallback to PyDict_GetItemWithError() if the hash is unknown: compute the hash instead. Add also comments to explain the optimization a little bit. [#25557]

Victor Stinner victor.stinner@gmail.com
date	Fri, 20 Nov 2015 09:24:02 +0100
parents	2d90f4b27743
children	14a3cfc477c6
files	Objects/dictobject.c Python/ceval.c
diffstat	2 files changed, 38 insertions(+), 28 deletions(-)[+] [-] Objects/dictobject.c 55 Python/ceval.c 11

line wrap: on

line diff

--- a/Objects/dictobject.c +++ b/Objects/dictobject.c @@ -1165,39 +1165,42 @@ PyObject return PyDict_GetItemWithError(dp, kv); } -/ Fast version of global value lookup. +/* Fast version of global value lookup (LOAD_GLOBAL).

Lookup in globals, then builtins.

*
- Raise an exception and return NULL if an error occurred (ex: computing the
- key hash failed, key comparison failed, ...). Return NULL if the key doesn't
- exist. Return the value if the key exists. */ PyObject * _PyDict_LoadGlobal(PyDictObject *globals, PyDictObject *builtins, PyObject *key) {

PyObject *x;
if (PyUnicode_CheckExact(key)) {
```
   PyObject **value_addr;[](#l1.20)
```

   Py_hash_t hash = ((PyASCIIObject *)key)->hash;[](#l1.21)

```
   if (hash != -1) {[](#l1.22)
```
```
       PyDictKeyEntry *e;[](#l1.23)
```

       e = globals->ma_keys->dk_lookup(globals, key, hash, &value_addr);[](#l1.24)

```
       if (e == NULL) {[](#l1.25)
```
```
           return NULL;[](#l1.26)
```
```
       }[](#l1.27)
```
```
       x = *value_addr;[](#l1.28)
```
```
       if (x != NULL)[](#l1.29)
```
```
           return x;[](#l1.30)
```

       e = builtins->ma_keys->dk_lookup(builtins, key, hash, &value_addr);[](#l1.31)

```
       if (e == NULL) {[](#l1.32)
```
```
           return NULL;[](#l1.33)
```
```
       }[](#l1.34)
```
```
       x = *value_addr;[](#l1.35)
```
```
       return x;[](#l1.36)
```
```
   }[](#l1.37)
```

Py_hash_t hash;
PyDictKeyEntry *entry;
PyObject **value_addr;
PyObject *value;

if (!PyUnicode_CheckExact(key) ||

   (hash = ((PyASCIIObject *) key)->hash) == -1)[](#l1.44)

{
```
   hash = PyObject_Hash(key);[](#l1.46)
```
```
   if (hash == -1)[](#l1.47)
```
```
       return NULL;[](#l1.48)
```
}

x = PyDict_GetItemWithError((PyObject *)globals, key);
if (x != NULL)
```
   return x;[](#l1.52)
```
if (PyErr_Occurred())

/* namespace 1: globals */
entry = globals->ma_keys->dk_lookup(globals, key, hash, &value_addr);
if (entry == NULL) return NULL;

return PyDict_GetItemWithError((PyObject *)builtins, key);

value = *value_addr;
if (value != NULL)
```
   return value;[](#l1.62)
```

/* namespace 2: builtins */
entry = builtins->ma_keys->dk_lookup(builtins, key, hash, &value_addr);
if (entry == NULL)
```
   return NULL;[](#l1.67)
```
return *value_addr;

} /* CAUTION: PyDict_SetItem() must guarantee that it won't resize the

--- a/Python/ceval.c +++ b/Python/ceval.c @@ -2347,26 +2347,33 @@ PyEval_EvalFrameEx(PyFrameObject *f, int PyObject *name = GETITEM(names, oparg); PyObject *v; if (PyDict_CheckExact(f->f_globals)

           && PyDict_CheckExact(f->f_builtins)) {[](#l2.7)

           && PyDict_CheckExact(f->f_builtins))[](#l2.8)

       {[](#l2.9)
           v = _PyDict_LoadGlobal((PyDictObject *)f->f_globals,[](#l2.10)
                                  (PyDictObject *)f->f_builtins,[](#l2.11)
                                  name);[](#l2.12)
           if (v == NULL) {[](#l2.13)

               if (!_PyErr_OCCURRED())[](#l2.14)

               if (!_PyErr_OCCURRED()) {[](#l2.15)

                   /* _PyDict_LoadGlobal() returns NULL without raising[](#l2.16)

                    * an exception if the key doesn't exist */[](#l2.17)
                   format_exc_check_arg(PyExc_NameError,[](#l2.18)
                                        NAME_ERROR_MSG, name);[](#l2.19)

               }[](#l2.20)
               goto error;[](#l2.21)
           }[](#l2.22)
           Py_INCREF(v);[](#l2.23)
       }[](#l2.24)
       else {[](#l2.25)
           /* Slow-path if globals or builtins is not a dict */[](#l2.26)

           /* namespace 1: globals */[](#l2.28)
           v = PyObject_GetItem(f->f_globals, name);[](#l2.29)
           if (v == NULL) {[](#l2.30)
               if (!PyErr_ExceptionMatches(PyExc_KeyError))[](#l2.31)
                   goto error;[](#l2.32)
               PyErr_Clear();[](#l2.33)

               /* namespace 2: builtins */[](#l2.35)
               v = PyObject_GetItem(f->f_builtins, name);[](#l2.36)
               if (v == NULL) {[](#l2.37)
                   if (PyErr_ExceptionMatches(PyExc_KeyError))[](#l2.38)