The C accelerator for the collections.Counter class (_count_elements() in _collections.c) is slower than the pure Python versions for data that has many unique entries. This is because the fast path for dicts is not taken (Counter is a subtype of dict) and the slower fallback path raises exceptions for each value that wasn't previously seen. This can apparently make it slower than calling get() on Python side.

My suggestion is to drop the fallback path from the accelerator completely and to only call the C function when it's safe to use it, e.g. when "type(self) is Counter" and not a subclass.

Are there any cases where the counter class with the C accelerator is faster than the pure Python version? Here is a benchmarking script (modification of Roy Smith's script [1]) and looks as the pure Python version is faster even for data that has not many unique entries.

[1] http://permalink.gmane.org/gmane.comp.python.general/738820

That sounds like a good idea, Stefan.

40% faster collections.Counter() . Removed C accelerator. Patch attached. Passes all tests. Results comparison follows.

Performance comparison with and without patch applied.

A C-accelerator should ALWAYS be able to beat a pure python version if it does the same steps but without the overhead of the eval-loop.  And in special cases such as type(self)==Counter, it can do much better.

To resolve this report, the C accelerator needs to be fixed.  As Stefan pointed-out, the fast-path isn't being triggered because of PyDict_CheckExact test.  And, the fallback path can be sped-up as well (by doing the same steps in C as are being done with the pure python code).

Repaired version
----------------
$ py -m timeit -s 'from random import seed, randrange; seed(8675309); data=[randrange(1000) for i in range(100000)]; from collections import Counter'  'Counter(data)'
100 loops, best of 3: 14.3 msec per loop
$ py -m timeit -s 'from random import seed, randrange; seed(8675309); data=[randrange(500000) for i in range(100000)]; from collections import Counter'  'Counter(data)'
10 loops, best of 3: 40.8 msec per loop

Current with accelerator
------------------------
$ py -m timeit -s 'from random import seed, randrange; seed(8675309); data=[randrange(1000) for i in range(100000)]; from collections import Counter'  'Counter(data)'
10 loops, best of 3: 61.7 msec per loop
$ py -m timeit -s 'from random import seed, randrange; seed(8675309); data=[randrange(500000) for i in range(100000)]; from collections import Counter'  'Counter(data)'
10 loops, best of 3: 118 msec per loop

Current without accelerator
---------------------------
$ py -m timeit -s 'from random import seed, randrange; seed(8675309); data=[randrange(1000) for i in range(100000)]; from collections import Counter'  'Counter(data)'
10 loops, best of 3: 54.9 msec per loop
$ py -m timeit -s 'from random import seed, randrange; seed(8675309); data=[randrange(500000) for i in range(100000)]; from collections import Counter'  'Counter(data)'
10 loops, best of 3: 80.8 msec per loop

Patch LGTM and seems to work well, according to your numbers.

Only minor nitpick would be that the method references could be decref-ed earlier, but that would complicate the code a bit.

Benchmarking results look great.

But isn't _PyObject_LookupSpecial() more appropriate function for special methods lookup than PyObject_GetAttrString()?

New changeset 6aef095fdb30 by Raymond Hettinger in branch '3.3':
Issue #18594: Fix the fast path for collections.Counter().
http://hg.python.org/cpython/rev/6aef095fdb30

Attaching a patch for the slow path.  Makes the code exactly match the pure python version.  This kicks in whether someone has subclassed Counter and overridden either __getitem__ or __setitem__.

Can you update the benchmark numbers to show what the difference is compared to pure Python (and to the fastpath) now?

One more thing: the fastpath depends on .__getitem__() and friends, whereas the fallback path depends on .get(). What if someone overrides .get() but not .__getitem__()?  (Might be a hypothetical case...)

New changeset 1ee6f8a96fb9 by Raymond Hettinger in branch '3.3':
Issue #18594:  Fix the fallback path in collections.Counter().
http://hg.python.org/cpython/rev/1ee6f8a96fb9

New changeset e4cec1116e5c by Raymond Hettinger in branch '3.3':
Issue #18594:  Make the C code more closely match the pure python code.
http://hg.python.org/cpython/rev/e4cec1116e5c