[Python-checkins] cpython: Add implementation notes
python-checkins at python.org
Wed Apr 23 09:59:23 CEST 2014
user: Raymond Hettinger <python at rcn.com>
date: Wed Apr 23 00:58:48 2014 -0700
Add implementation notes
Modules/_collectionsmodule.c | 33 +++++++++++++++++++++++-
1 files changed, 32 insertions(+), 1 deletions(-)
diff --git a/Modules/_collectionsmodule.c b/Modules/_collectionsmodule.c
@@ -3,7 +3,7 @@
/* collections module implementation of a deque() datatype
Written and maintained by Raymond D. Hettinger <python at rcn.com>
- Copyright (c) 2004-2013 Python Software Foundation.
+ Copyright (c) 2004-2014 Python Software Foundation.
All rights reserved.
@@ -145,6 +145,12 @@
static PyTypeObject deque_type;
+/* XXX Todo:
+ If aligned memory allocations become available, make the
+ deque object 64 byte aligned so that all of the fields
+ can be retrieved or updated in a single cache line.
static PyObject *
deque_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
@@ -454,6 +460,31 @@
return (PyObject *)deque;
+/* The rotate() method is part of the public API and is used internally
+as a primitive for other methods.
+Rotation by 1 or -1 is a common case, so any optimizations for high
+volume rotations should take care not to penalize the common case.
+Conceptually, a rotate by one is equivalent to a pop on one side and an
+append on the other. However, a pop/append pair is unnecessarily slow
+because it requires a incref/decref pair for an object located randomly
+in memory. It is better to just move the object pointer from one block
+to the next without changing the reference count.
+When moving batches of pointers, it is tempting to use memcpy() but that
+proved to be slower than a simple loop for a variety of reasons.
+Memcpy() cannot know in advance that we're copying pointers instead of
+bytes, that the source and destination are pointer aligned and
+non-overlapping, that moving just one pointer is a common case, that we
+never need to move more than BLOCKLEN pointers, and that at least one
+pointer is always moved.
+For high volume rotations, newblock() and freeblock() are never called
+more than once. Previously emptied blocks are immediately reused as a
+destination block. If a block is left-over at the end, it is freed.
_deque_rotate(dequeobject *deque, Py_ssize_t n)
Repository URL: http://hg.python.org/cpython
More information about the Python-checkins