delta/python-packages/zope-interface.git/benchmarks, branch issue3

More micro benchmarks.

2020-04-02T15:35:51+00:00

Comparing to current master, there is no substantial difference.

+-------------------------------------------------------------+----------------+------------------------------+
| Benchmark                                                   | bench_master38 | bench_issue200               |
+=============================================================+================+==============================+
| call interface (alternate, no conform, not provided)        | 395 ns         | 414 ns: 1.05x slower (+5%)   |
+-------------------------------------------------------------+----------------+------------------------------+
| call interface (no alternate, valid conform, not provided)  | 250 ns         | 240 ns: 1.04x faster (-4%)   |
+-------------------------------------------------------------+----------------+------------------------------+
| read __module__                                             | 45.3 ns        | 43.4 ns: 1.04x faster (-4%)  |
+-------------------------------------------------------------+----------------+------------------------------+
| query adapter (no registrations)                            | 3.23 ms        | 3.31 ms: 1.02x slower (+2%)  |
+-------------------------------------------------------------+----------------+------------------------------+
| query adapter (all trivial registrations)                   | 3.93 ms        | 4.40 ms: 1.12x slower (+12%) |
+-------------------------------------------------------------+----------------+------------------------------+
| query adapter (all trivial registrations, wide inheritance) | 43.3 us        | 45.5 us: 1.05x slower (+5%)  |
+-------------------------------------------------------------+----------------+------------------------------+
| query adapter (all trivial registrations, deep inheritance) | 43.2 us        | 46.9 us: 1.09x slower (+9%)  |
+-------------------------------------------------------------+----------------+------------------------------+
| sort mixed                                                  | 361 us         | 354 us: 1.02x faster (-2%)   |
+-------------------------------------------------------------+----------------+------------------------------+
| contains (populated dict: interfaces)                       | 61.3 ns        | 59.7 ns: 1.03x faster (-3%)  |
+-------------------------------------------------------------+----------------+------------------------------+

Not significant (13): call interface (provides; deep); call interface (provides; wide); call interface (no alternate, no conform, not provided); call interface (alternate, invalid conform, not provided); read __name__; read __doc__; read providedBy; sort interfaces; sort implementedBy; contains (empty dict); contains (populated list: interfaces); contains (populated dict: implementedBy); contains (populated list: implementedBy)

Update comments and add a test for more coverage.

2020-03-19T11:54:33+00:00

Move to a metaclass for handling module.

2020-03-18T17:27:20+00:00

This offers the absolute best performance at what seems like reasonable complexity.

+-------------------------------------------------------------+----------------+-------------------------------+
| Benchmark                                                   | 38-master-full | 38-faster-meta                |
+=============================================================+================+===============================+
| read __module__                                             | 41.8 ns        | 40.9 ns: 1.02x faster (-2%)   |
+-------------------------------------------------------------+----------------+-------------------------------+
| read __name__                                               | 41.8 ns        | 39.9 ns: 1.05x faster (-5%)   |
+-------------------------------------------------------------+----------------+-------------------------------+
| read providedBy                                             | 56.9 ns        | 58.4 ns: 1.03x slower (+3%)   |
+-------------------------------------------------------------+----------------+-------------------------------+
| query adapter (no registrations)                            | 3.85 ms        | 2.95 ms: 1.31x faster (-24%)  |
+-------------------------------------------------------------+----------------+-------------------------------+
| query adapter (all trivial registrations)                   | 4.62 ms        | 3.63 ms: 1.27x faster (-21%)  |
+-------------------------------------------------------------+----------------+-------------------------------+
| query adapter (all trivial registrations, wide inheritance) | 51.8 us        | 42.2 us: 1.23x faster (-19%)  |
+-------------------------------------------------------------+----------------+-------------------------------+
| query adapter (all trivial registrations, deep inheritance) | 52.0 us        | 41.7 us: 1.25x faster (-20%)  |
+-------------------------------------------------------------+----------------+-------------------------------+
| sort interfaces                                             | 234 us         | 29.9 us: 7.84x faster (-87%)  |
+-------------------------------------------------------------+----------------+-------------------------------+
| sort mixed                                                  | 569 us         | 340 us: 1.67x faster (-40%)   |
+-------------------------------------------------------------+----------------+-------------------------------+
| contains (empty dict)                                       | 135 ns         | 55.2 ns: 2.44x faster (-59%)  |
+-------------------------------------------------------------+----------------+-------------------------------+
| contains (populated dict: interfaces)                       | 137 ns         | 56.1 ns: 2.45x faster (-59%)  |
+-------------------------------------------------------------+----------------+-------------------------------+
| contains (populated list: interfaces)                       | 39.7 us        | 2.96 us: 13.42x faster (-93%) |
+-------------------------------------------------------------+----------------+-------------------------------+
| contains (populated dict: implementedBy)                    | 137 ns         | 55.2 ns: 2.48x faster (-60%)  |
+-------------------------------------------------------------+----------------+-------------------------------+
| contains (populated list: implementedBy)                    | 40.6 us        | 24.1 us: 1.68x faster (-41%)  |
+-------------------------------------------------------------+----------------+-------------------------------+

Not significant (2): read __doc__; sort implementedBy

Avoid use of a metaclass by implementeng getattribute.

2020-03-18T17:27:20+00:00

This is pretty, but it slows down all attribute access to interfaces.
By up to 25%. I'm not sure that's acceptable for things like
Interface.providedBy.

+-------------------------------------------+------------+-------------------------------+
| Benchmark                                 | 38-master3 | 38-faster3                    |
+===========================================+============+===============================+
| read __module__                           | 41.1 ns    | 44.3 ns: 1.08x slower (+8%)   |
+-------------------------------------------+------------+-------------------------------+
| read __name__                             | 41.3 ns    | 51.6 ns: 1.25x slower (+25%)  |
+-------------------------------------------+------------+-------------------------------+
| read __doc__                              | 41.8 ns    | 53.3 ns: 1.28x slower (+28%)  |
+-------------------------------------------+------------+-------------------------------+
| read providedBy                           | 56.7 ns    | 71.6 ns: 1.26x slower (+26%)  |
+-------------------------------------------+------------+-------------------------------+
| query adapter (no registrations)          | 3.85 ms    | 2.95 ms: 1.31x faster (-23%)  |
+-------------------------------------------+------------+-------------------------------+
| query adapter (all trivial registrations) | 4.59 ms    | 3.65 ms: 1.26x faster (-20%)  |
+-------------------------------------------+------------+-------------------------------+
| contains (empty dict)                     | 136 ns     | 55.4 ns: 2.45x faster (-59%)  |
+-------------------------------------------+------------+-------------------------------+
| contains (populated dict)                 | 137 ns     | 55.0 ns: 2.49x faster (-60%)  |
+-------------------------------------------+------------+-------------------------------+
| contains (populated list)                 | 40.2 us    | 2.95 us: 13.62x faster (-93%) |
+-------------------------------------------+------------+-------------------------------+

Benchmarks looking up adapters from components.

2020-03-18T17:26:35+00:00

Current results (this branch vs master, 354faccebd5b612a2ac8e081a7e5d2f7fb1089c1):

| Benchmark                                 | 38-master | 38-faster                     |
|-------------------------------------------|-----------|-------------------------------|
| query adapter (no registrations)          | 3.81 ms   | 3.03 ms: 1.26x faster (-20%)  |
| query adapter (all trivial registrations) | 4.65 ms   | 3.90 ms: 1.19x faster (-16%)  |
| contains (empty dict)                     | 163 ns    | 76.1 ns: 2.14x faster (-53%)  |
| contains (populated dict)                 | 162 ns    | 76.9 ns: 2.11x faster (-53%)  |
| contains (populated list)                 | 40.3 us   | 3.09 us: 13.04x faster (-92%) |

Also need benchmarks using inheritance. The 'implied' data structures
are also hash/equality based.

Move Interface hashing and comparison to C; 2.5 to 15x speedup in micro benchmarks

2020-03-18T17:26:35+00:00

Included benchmark numbers:

Current master, Python 3.8:

.....................
contains (empty dict): Mean +- std dev: 198 ns +- 5 ns
.....................
contains (populated dict): Mean +- std dev: 197 ns +- 6 ns
.....................
contains (populated list): Mean +- std dev: 53.1 us +- 1.2 us

This code:

.....................
contains (empty dict): Mean +- std dev: 77.9 ns +- 2.3 ns
.....................
contains (populated dict): Mean +- std dev: 78.4 ns +- 3.1 ns
.....................
contains (populated list): Mean +- std dev: 3.69 us +- 0.08 us

So anywhere from 2.5 to 15x faster. Not sure how that will translate to
larger benchmarks, but I'm hopeful.

It turns out that messing with ``__module__`` is nasty, tricky
business, especially when you do it from C. Everytime you define a new
subclass, the descriptors that you set get overridden by the type
machinery (PyType_Ready). I'm using a data descriptor and a meta class
right now to avoid that but I'm not super happy with that and would
like to find a better way. (At least, maybe the data part of the
descriptor isn't necessary?) It may be needed to move more code into
C, I don't want a slowdown accessing ``__module__`` either; copying
around the standard PyGetSet or PyMember descriptors isn't enough
because they don't work on the class object (so
``classImplements(InterfaceClass, IInterface)`` fails).

delta/python-packages/zope-interface.git/benchmarks, branch issue3

More micro benchmarks.

Update comments and add a test for more coverage.

Move to a metaclass for handling __module__.

Avoid use of a metaclass by implementeng __getattribute__.

Benchmarks looking up adapters from components.

Move Interface hashing and comparison to C; 2.5 to 15x speedup in micro benchmarks

Move to a metaclass for handling module.

Avoid use of a metaclass by implementeng getattribute.