Local import is too slow

[serhiy-storchaka]

BPO	22557
Nosy	@brettcannon, @ncoghlan, @pitrou, @vstinner, @ericvsmith, @ericsnowcurrently, @serhiy-storchaka
Files	faster_import.patch faster_import_2.patch faster_import_3.patch faster_import_4.patch faster_import_4.patch faster_import_5.patch faster_import_pkg.patch faster_import_6.patch

^{Note: these values reflect the state of the issue at the time it was migrated and might not reflect the current state.}

Show more details

GitHub fields:

assignee = 'https://github.com/serhiy-storchaka'
closed_at = <Date 2016-08-06.20:35:40.208>
created_at = <Date 2014-10-05.12:29:01.710>
labels = ['interpreter-core', 'performance']
title = 'Local import is too slow'
updated_at = <Date 2016-08-06.20:35:40.195>
user = 'https://github.com/serhiy-storchaka'

bugs.python.org fields:

activity = <Date 2016-08-06.20:35:40.195>
actor = 'serhiy.storchaka'
assignee = 'serhiy.storchaka'
closed = True
closed_date = <Date 2016-08-06.20:35:40.208>
closer = 'serhiy.storchaka'
components = ['Interpreter Core']
creation = <Date 2014-10-05.12:29:01.710>
creator = 'serhiy.storchaka'
dependencies = []
files = ['36814', '36816', '36912', '43471', '43491', '43566', '43567', '43869']
hgrepos = []
issue_num = 22557
keywords = ['patch']
message_count = 18.0
messages = ['228561', '228562', '228565', '228570', '228573', '228574', '228575', '229013', '229286', '268850', '268934', '268936', '268937', '268938', '269400', '271173', '271846', '271847']
nosy_count = 8.0
nosy_names = ['brett.cannon', 'ncoghlan', 'pitrou', 'vstinner', 'eric.smith', 'python-dev', 'eric.snow', 'serhiy.storchaka']
pr_nums = []
priority = 'normal'
resolution = 'fixed'
stage = 'resolved'
status = 'closed'
superseder = None
type = 'performance'
url = 'https://bugs.python.org/issue22557'
versions = ['Python 3.6']

[serhiy-storchaka]

Locale import is too slow in comparison with caching module in a global or even in sys.modules.

>>> import timeit
>>> def f():
...     import locale
... 
>>> min(timeit.repeat(f, number=100000, repeat=10))
0.4501200000013341
>>> _locale = None
>>> def g():
...     global _locale
...     if _locale is None:
...         import _locale
... 
>>> min(timeit.repeat(g, number=100000, repeat=10))
0.07821200000034878
>>> import sys
>>> def h():
...     try:
...         locale = sys.modules['locale']
...     except KeyError:
...         import locale
... 
>>> min(timeit.repeat(h, number=100000, repeat=10))
0.12357599999813829

I think there is an overhead of look up __import__, packing arguments in a tuple and calling a function. This can be omitted by looking first in sys.module and calling __import__ only when nothing was found.

[pitrou]

This would sound reasonable to me, but I wonder if it may change behaviour with weird custom __import__ overrides.

[ncoghlan]

__import__ is intended as an absolute override (including of the sys.modules cache lookup), so we can't bypass it without breaking backwards compatibility.

It's possible there is room for other optimisations that don't break the import override semantics (such as a fast path for when __import__ is the standard import function).

[serhiy-storchaka]

I'm not experienced in import machinery. Here is preliminary patch which
implements my idea for particular case.

Performance effect is almost so good as manual caching in a global.

>>> import timeit
>>> def f():
...      import locale
... 
>>> min(timeit.repeat(f, number=100000, repeat=10))
0.09563599999819417

Of course it breaks tests.

It's possible there is room for other optimisations that don't break the
import override semantics (such as a fast path for when __import__ is the
standard import function).

Good idea.

[serhiy-storchaka]

Second version of the patch uses fast patch only when builtin __import__ is
not overridden. It is slightly slower (due to lookup of __import__).

>>> import timeit
>>> def f():
...     import locale
... 
>>> min(timeit.repeat(f, number=100000, repeat=10))
0.10502300000371179

The code is simpler, but still some cumbersome. It would be good to optimize
also "from locale import getlocale".

[pitrou]

I would suggest factoring out IMPORT_NAME into a separate import_name() function, like is already one for import_from().

[pitrou]

Some more general comments about this:

• Let's keep in mind the absolute numbers. 0.4501200000013341 for 100000 iterations is 4.5ms per iteration. This is not very slow by CPython's standards.

• I wonder if you ran your benchmark in debug mode or if your CPU is slow :-) I get around 0.5ms per iteration here.

[pitrou]

The issue is local imports, not imports of the locale module :-)

[serhiy-storchaka]

Yes, my CPU is slow.

Here is a patch which factors out IMPORT_NAME into a separate import_name() function and adds optimization for more general case when __import__ is not overloaded.

[serhiy-storchaka]

Fixed bugs making test_importlib failing.

Microbenchmark results on faster machine:

$ ./python -m timeit 'import locale'
Unpatched:  1000000 loops, best of 3: 0.839 usec per loop
Patched:    10000000 loops, best of 3: 0.176 usec per loop

$ ./python -m timeit 'import os.path'
Unpatched:  100000 loops, best of 3: 2.02 usec per loop
Patched:    1000000 loops, best of 3: 1.77 usec per loop

$ ./python -m timeit 'from locale import getlocale'
Unpatched:  100000 loops, best of 3: 3.69 usec per loop
Patched:    100000 loops, best of 3: 3.39 usec per loop

And it looks to me that there is a bug in existing code (opened separate bpo-27352).

0.839 usec is not very slow by CPython's standards, but is equal to about 50 assignments to local variable, 15 attribute revolvings or 5 simple function calls. If some module is optionally needed in fast function, the overhead of local import can be significant. We can lazily initialize global variable (the second example in msg228561), but this code looks more cumbersome.