#include /* For offsetof */ #include "pythoncapi_compat.h" #include "_map.h" /* This file provides an implemention of an immutable mapping using the Hash Array Mapped Trie (or HAMT) datastructure. This design allows to have: 1. Efficient copy: immutable mappings can be copied by reference, making it an O(1) operation. 2. Efficient mutations: due to structural sharing, only a portion of the trie needs to be copied when the collection is mutated. The cost of set/delete operations is O(log N). 3. Efficient lookups: O(log N). (where N is number of key/value items in the immutable mapping.) HAMT ==== The core idea of HAMT is that the shape of the trie is encoded into the hashes of keys. Say we want to store a K/V pair in our mapping. First, we calculate the hash of K, let's say it's 19830128, or in binary: 0b1001011101001010101110000 = 19830128 Now let's partition this bit representation of the hash into blocks of 5 bits each: 0b00_00000_10010_11101_00101_01011_10000 = 19830128 (6) (5) (4) (3) (2) (1) Each block of 5 bits represents a number between 0 and 31. So if we have a tree that consists of nodes, each of which is an array of 32 pointers, those 5-bit blocks will encode a position on a single tree level. For example, storing the key K with hash 19830128, results in the following tree structure: (array of 32 pointers) +---+ -- +----+----+----+ -- +----+ root node | 0 | .. | 15 | 16 | 17 | .. | 31 | 0b10000 = 16 (1) (level 1) +---+ -- +----+----+----+ -- +----+ | +---+ -- +----+----+----+ -- +----+ a 2nd level node | 0 | .. | 10 | 11 | 12 | .. | 31 | 0b01011 = 11 (2) +---+ -- +----+----+----+ -- +----+ | +---+ -- +----+----+----+ -- +----+ a 3rd level node | 0 | .. | 04 | 05 | 06 | .. | 31 | 0b00101 = 5 (3) +---+ -- +----+----+----+ -- +----+ | +---+ -- +----+----+----+----+ a 4th level node | 0 | .. | 04 | 29 | 30 | 31 | 0b11101 = 29 (4) +---+ -- +----+----+----+----+ | +---+ -- +----+----+----+ -- +----+ a 5th level node | 0 | .. | 17 | 18 | 19 | .. | 31 | 0b10010 = 18 (5) +---+ -- +----+----+----+ -- +----+ | +--------------+ | +---+ -- +----+----+----+ -- +----+ a 6th level node | 0 | .. | 15 | 16 | 17 | .. | 31 | 0b00000 = 0 (6) +---+ -- +----+----+----+ -- +----+ | V -- our value (or collision) To rehash: for a K/V pair, the hash of K encodes where in the tree V will be stored. To optimize memory footprint and handle hash collisions, our implementation uses three different types of nodes: * A Bitmap node; * An Array node; * A Collision node. Because we implement an immutable dictionary, our nodes are also immutable. Therefore, when we need to modify a node, we copy it, and do that modification to the copy. Array Nodes ----------- These nodes are very simple. Essentially they are arrays of 32 pointers we used to illustrate the high-level idea in the previous section. We use Array nodes only when we need to store more than 16 pointers in a single node. Array nodes do not store key objects or value objects. They are used only as an indirection level - their pointers point to other nodes in the tree. Bitmap Node ----------- Allocating a new 32-pointers array for every node of our tree would be very expensive. Unless we store millions of keys, most of tree nodes would be very sparse. When we have less than 16 elements in a node, we don't want to use the Array node, that would mean that we waste a lot of memory. Instead, we can use bitmap compression and can have just as many pointers as we need! Bitmap nodes consist of two fields: 1. An array of pointers. If a Bitmap node holds N elements, the array will be of N pointers. 2. A 32bit integer -- a bitmap field. If an N-th bit is set in the bitmap, it means that the node has an N-th element. For example, say we need to store a 3 elements sparse array: +---+ -- +---+ -- +----+ -- +----+ | 0 | .. | 4 | .. | 11 | .. | 17 | +---+ -- +---+ -- +----+ -- +----+ | | | o1 o2 o3 We allocate a three-pointer Bitmap node. Its bitmap field will be then set to: 0b_00100_00010_00000_10000 == (1 << 17) | (1 << 11) | (1 << 4) To check if our Bitmap node has an I-th element we can do: bitmap & (1 << I) And here's a formula to calculate a position in our pointer array which would correspond to an I-th element: popcount(bitmap & ((1 << I) - 1)) Let's break it down: * `popcount` is a function that returns a number of bits set to 1; * `((1 << I) - 1)` is a mask to filter the bitmask to contain bits set to the *right* of our bit. So for our 17, 11, and 4 indexes: * bitmap & ((1 << 17) - 1) == 0b100000010000 => 2 bits are set => index is 2. * bitmap & ((1 << 11) - 1) == 0b10000 => 1 bit is set => index is 1. * bitmap & ((1 << 4) - 1) == 0b0 => 0 bits are set => index is 0. To conclude: Bitmap nodes are just like Array nodes -- they can store a number of pointers, but use bitmap compression to eliminate unused pointers. Bitmap nodes have two pointers for each item: +----+----+----+----+ -- +----+----+ | k1 | v1 | k2 | v2 | .. | kN | vN | +----+----+----+----+ -- +----+----+ When kI == NULL, vI points to another tree level. When kI != NULL, the actual key object is stored in kI, and its value is stored in vI. Collision Nodes --------------- Collision nodes are simple arrays of pointers -- two pointers per key/value. When there's a hash collision, say for k1/v1 and k2/v2 we have `hash(k1)==hash(k2)`. Then our collision node will be: +----+----+----+----+ | k1 | v1 | k2 | v2 | +----+----+----+----+ Tree Structure -------------- All nodes are PyObjects. The `MapObject` object has a pointer to the root node (h_root), and has a length field (h_count). High-level functions accept a MapObject object and dispatch to lower-level functions depending on what kind of node h_root points to. Operations ========== There are three fundamental operations on an immutable dictionary: 1. "o.assoc(k, v)" will return a new immutable dictionary, that will be a copy of "o", but with the "k/v" item set. Functions in this file: map_node_assoc, map_node_bitmap_assoc, map_node_array_assoc, map_node_collision_assoc `map_node_assoc` function accepts a node object, and calls other functions depending on its actual type. 2. "o.find(k)" will lookup key "k" in "o". Functions: map_node_find, map_node_bitmap_find, map_node_array_find, map_node_collision_find 3. "o.without(k)" will return a new immutable dictionary, that will be a copy of "o", buth without the "k" key. Functions: map_node_without, map_node_bitmap_without, map_node_array_without, map_node_collision_without Further Reading =============== 1. http://blog.higher-order.net/2009/09/08/understanding-clojures-persistenthashmap-deftwice.html 2. http://blog.higher-order.net/2010/08/16/assoc-and-clojures-persistenthashmap-part-ii.html 3. Clojure's PersistentHashMap implementation: https://github.com/clojure/clojure/blob/master/src/jvm/clojure/lang/PersistentHashMap.java */ #define IS_ARRAY_NODE(node) (Py_TYPE(node) == &_Map_ArrayNode_Type) #define IS_BITMAP_NODE(node) (Py_TYPE(node) == &_Map_BitmapNode_Type) #define IS_COLLISION_NODE(node) (Py_TYPE(node) == &_Map_CollisionNode_Type) /* Return type for 'find' (lookup a key) functions. * F_ERROR - an error occurred; * F_NOT_FOUND - the key was not found; * F_FOUND - the key was found. */ typedef enum {F_ERROR, F_NOT_FOUND, F_FOUND} map_find_t; /* Return type for 'without' (delete a key) functions. * W_ERROR - an error occurred; * W_NOT_FOUND - the key was not found: there's nothing to delete; * W_EMPTY - the key was found: the node/tree would be empty if the key is deleted; * W_NEWNODE - the key was found: a new node/tree is returned without that key. */ typedef enum {W_ERROR, W_NOT_FOUND, W_EMPTY, W_NEWNODE} map_without_t; /* Low-level iterator protocol type. * I_ITEM - a new item has been yielded; * I_END - the whole tree was visited (similar to StopIteration). */ typedef enum {I_ITEM, I_END} map_iter_t; #define HAMT_ARRAY_NODE_SIZE 32 typedef struct { PyObject_HEAD MapNode *a_array[HAMT_ARRAY_NODE_SIZE]; Py_ssize_t a_count; uint64_t a_mutid; } MapNode_Array; typedef struct { PyObject_VAR_HEAD uint64_t b_mutid; uint32_t b_bitmap; PyObject *b_array[1]; } MapNode_Bitmap; typedef struct { PyObject_VAR_HEAD uint64_t c_mutid; int32_t c_hash; PyObject *c_array[1]; } MapNode_Collision; static volatile uint64_t mutid_counter = 1; static MapNode_Bitmap *_empty_bitmap_node; /* Create a new HAMT immutable mapping. */ static MapObject * map_new(void); /* Return a new collection based on "o", but with an additional key/val pair. */ static MapObject * map_assoc(MapObject *o, PyObject *key, PyObject *val); /* Return a new collection based on "o", but without "key". */ static MapObject * map_without(MapObject *o, PyObject *key); /* Check if "v" is equal to "w". Return: - 0: v != w - 1: v == w - -1: An error occurred. */ static int map_eq(BaseMapObject *v, BaseMapObject *w); static map_find_t map_find(BaseMapObject *o, PyObject *key, PyObject **val); /* Return the size of "o"; equivalent of "len(o)". */ static Py_ssize_t map_len(BaseMapObject *o); static MapObject * map_alloc(void); static MapNode * map_node_assoc(MapNode *node, uint32_t shift, int32_t hash, PyObject *key, PyObject *val, int* added_leaf, uint64_t mutid); static map_without_t map_node_without(MapNode *node, uint32_t shift, int32_t hash, PyObject *key, MapNode **new_node, uint64_t mutid); static map_find_t map_node_find(MapNode *node, uint32_t shift, int32_t hash, PyObject *key, PyObject **val); static int map_node_dump(MapNode *node, _PyUnicodeWriter *writer, int level); static MapNode * map_node_array_new(Py_ssize_t, uint64_t mutid); static MapNode * map_node_collision_new(int32_t hash, Py_ssize_t size, uint64_t mutid); static inline Py_ssize_t map_node_collision_count(MapNode_Collision *node); static int map_node_update(uint64_t mutid, PyObject *seq, MapNode *root, Py_ssize_t count, MapNode **new_root, Py_ssize_t *new_count); static int map_update_inplace(uint64_t mutid, BaseMapObject *o, PyObject *src); static MapObject * map_update(uint64_t mutid, MapObject *o, PyObject *src); #if !defined(NDEBUG) static void _map_node_array_validate(void *o) { assert(IS_ARRAY_NODE(o)); MapNode_Array *node = (MapNode_Array*)(o); assert(node->a_count <= HAMT_ARRAY_NODE_SIZE); Py_ssize_t i = 0, count = 0; for (; i < HAMT_ARRAY_NODE_SIZE; i++) { if (node->a_array[i] != NULL) { count++; } } assert(count == node->a_count); } #define VALIDATE_ARRAY_NODE(NODE) \ do { _map_node_array_validate(NODE); } while (0); #else #define VALIDATE_ARRAY_NODE(NODE) #endif /* Returns -1 on error */ static inline int32_t map_hash(PyObject *o) { Py_hash_t hash = PyObject_Hash(o); #if SIZEOF_PY_HASH_T <= 4 return hash; #else if (hash == -1) { /* exception */ return -1; } /* While it's suboptimal to reduce Python's 64 bit hash to 32 bits via XOR, it seems that the resulting hash function is good enough (this is also how Long type is hashed in Java.) Storing 10, 100, 1000 Python strings results in a relatively shallow and uniform tree structure. Please don't change this hashing algorithm, as there are many tests that test some exact tree shape to cover all code paths. */ int32_t xored = (int32_t)(hash & 0xffffffffl) ^ (int32_t)(hash >> 32); return xored == -1 ? -2 : xored; #endif } static inline uint32_t map_mask(int32_t hash, uint32_t shift) { return (((uint32_t)hash >> shift) & 0x01f); } static inline uint32_t map_bitpos(int32_t hash, uint32_t shift) { return (uint32_t)1 << map_mask(hash, shift); } static inline uint32_t map_bitcount(uint32_t i) { /* We could use native popcount instruction but that would require to either add configure flags to enable SSE4.2 support or to detect it dynamically. Otherwise, we have a risk of CPython not working properly on older hardware. In practice, there's no observable difference in performance between using a popcount instruction or the following fallback code. The algorithm is copied from: https://graphics.stanford.edu/~seander/bithacks.html */ i = i - ((i >> 1) & 0x55555555); i = (i & 0x33333333) + ((i >> 2) & 0x33333333); return (((i + (i >> 4)) & 0xF0F0F0F) * 0x1010101) >> 24; } static inline uint32_t map_bitindex(uint32_t bitmap, uint32_t bit) { return map_bitcount(bitmap & (bit - 1)); } /////////////////////////////////// Dump Helpers static int _map_dump_ident(_PyUnicodeWriter *writer, int level) { /* Write `' ' * level` to the `writer` */ PyObject *str = NULL; PyObject *num = NULL; PyObject *res = NULL; int ret = -1; str = PyUnicode_FromString(" "); if (str == NULL) { goto error; } num = PyLong_FromLong((long)level); if (num == NULL) { goto error; } res = PyNumber_Multiply(str, num); if (res == NULL) { goto error; } ret = _PyUnicodeWriter_WriteStr(writer, res); error: Py_XDECREF(res); Py_XDECREF(str); Py_XDECREF(num); return ret; } static int _map_dump_format(_PyUnicodeWriter *writer, const char *format, ...) { /* A convenient helper combining _PyUnicodeWriter_WriteStr and PyUnicode_FromFormatV. */ PyObject* msg; int ret; va_list vargs; #ifdef HAVE_STDARG_PROTOTYPES va_start(vargs, format); #else va_start(vargs); #endif msg = PyUnicode_FromFormatV(format, vargs); va_end(vargs); if (msg == NULL) { return -1; } ret = _PyUnicodeWriter_WriteStr(writer, msg); Py_DECREF(msg); return ret; } /////////////////////////////////// Bitmap Node static MapNode * map_node_bitmap_new(Py_ssize_t size, uint64_t mutid) { /* Create a new bitmap node of size 'size' */ MapNode_Bitmap *node; Py_ssize_t i; assert(size >= 0); assert(size % 2 == 0); if (size == 0 && _empty_bitmap_node != NULL && mutid == 0) { Py_INCREF(_empty_bitmap_node); return (MapNode *)_empty_bitmap_node; } /* No freelist; allocate a new bitmap node */ node = PyObject_GC_NewVar( MapNode_Bitmap, &_Map_BitmapNode_Type, size); if (node == NULL) { return NULL; } Py_SET_SIZE(node, size); for (i = 0; i < size; i++) { node->b_array[i] = NULL; } node->b_bitmap = 0; node->b_mutid = mutid; PyObject_GC_Track(node); if (size == 0 && _empty_bitmap_node == NULL && mutid == 0) { /* Since bitmap nodes are immutable, we can cache the instance for size=0 and reuse it whenever we need an empty bitmap node. */ _empty_bitmap_node = node; Py_INCREF(_empty_bitmap_node); } return (MapNode *)node; } static inline Py_ssize_t map_node_bitmap_count(MapNode_Bitmap *node) { return Py_SIZE(node) / 2; } static MapNode_Bitmap * map_node_bitmap_clone(MapNode_Bitmap *node, uint64_t mutid) { /* Clone a bitmap node; return a new one with the same child notes. */ MapNode_Bitmap *clone; Py_ssize_t i; clone = (MapNode_Bitmap *)map_node_bitmap_new( Py_SIZE(node), mutid); if (clone == NULL) { return NULL; } for (i = 0; i < Py_SIZE(node); i++) { Py_XINCREF(node->b_array[i]); clone->b_array[i] = node->b_array[i]; } clone->b_bitmap = node->b_bitmap; return clone; } static MapNode_Bitmap * map_node_bitmap_clone_without(MapNode_Bitmap *o, uint32_t bit, uint64_t mutid) { assert(bit & o->b_bitmap); assert(map_node_bitmap_count(o) > 1); MapNode_Bitmap *new = (MapNode_Bitmap *)map_node_bitmap_new( Py_SIZE(o) - 2, mutid); if (new == NULL) { return NULL; } uint32_t idx = map_bitindex(o->b_bitmap, bit); uint32_t key_idx = 2 * idx; uint32_t val_idx = key_idx + 1; uint32_t i; for (i = 0; i < key_idx; i++) { Py_XINCREF(o->b_array[i]); new->b_array[i] = o->b_array[i]; } assert(Py_SIZE(o) >= 0 && Py_SIZE(o) <= 32); for (i = val_idx + 1; i < (uint32_t)Py_SIZE(o); i++) { Py_XINCREF(o->b_array[i]); new->b_array[i - 2] = o->b_array[i]; } new->b_bitmap = o->b_bitmap & ~bit; return new; } static MapNode * map_node_new_bitmap_or_collision(uint32_t shift, PyObject *key1, PyObject *val1, int32_t key2_hash, PyObject *key2, PyObject *val2, uint64_t mutid) { /* Helper method. Creates a new node for key1/val and key2/val2 pairs. If key1 hash is equal to the hash of key2, a Collision node will be created. If they are not equal, a Bitmap node is created. */ int32_t key1_hash = map_hash(key1); if (key1_hash == -1) { return NULL; } if (key1_hash == key2_hash) { MapNode_Collision *n; n = (MapNode_Collision *)map_node_collision_new(key1_hash, 4, mutid); if (n == NULL) { return NULL; } Py_INCREF(key1); n->c_array[0] = key1; Py_INCREF(val1); n->c_array[1] = val1; Py_INCREF(key2); n->c_array[2] = key2; Py_INCREF(val2); n->c_array[3] = val2; return (MapNode *)n; } else { int added_leaf = 0; MapNode *n = map_node_bitmap_new(0, mutid); if (n == NULL) { return NULL; } MapNode *n2 = map_node_assoc( n, shift, key1_hash, key1, val1, &added_leaf, mutid); Py_DECREF(n); if (n2 == NULL) { return NULL; } n = map_node_assoc( n2, shift, key2_hash, key2, val2, &added_leaf, mutid); Py_DECREF(n2); if (n == NULL) { return NULL; } return n; } } static MapNode * map_node_bitmap_assoc(MapNode_Bitmap *self, uint32_t shift, int32_t hash, PyObject *key, PyObject *val, int* added_leaf, uint64_t mutid) { /* assoc operation for bitmap nodes. Return: a new node, or self if key/val already is in the collection. 'added_leaf' is later used in 'map_assoc' to determine if `map.set(key, val)` increased the size of the collection. */ uint32_t bit = map_bitpos(hash, shift); uint32_t idx = map_bitindex(self->b_bitmap, bit); /* Bitmap node layout: +------+------+------+------+ --- +------+------+ | key1 | val1 | key2 | val2 | ... | keyN | valN | +------+------+------+------+ --- +------+------+ where `N < Py_SIZE(node)`. The `node->b_bitmap` field is a bitmap. For a given `(shift, hash)` pair we can determine: - If this node has the corresponding key/val slots. - The index of key/val slots. */ if (self->b_bitmap & bit) { /* The key is set in this node */ uint32_t key_idx = 2 * idx; uint32_t val_idx = key_idx + 1; assert(val_idx < (size_t)Py_SIZE(self)); PyObject *key_or_null = self->b_array[key_idx]; PyObject *val_or_node = self->b_array[val_idx]; if (key_or_null == NULL) { /* key is NULL. This means that we have a few keys that have the same (hash, shift) pair. */ assert(val_or_node != NULL); MapNode *sub_node = map_node_assoc( (MapNode *)val_or_node, shift + 5, hash, key, val, added_leaf, mutid); if (sub_node == NULL) { return NULL; } if (val_or_node == (PyObject *)sub_node) { Py_DECREF(sub_node); Py_INCREF(self); return (MapNode *)self; } if (mutid != 0 && self->b_mutid == mutid) { Py_SETREF(self->b_array[val_idx], (PyObject*)sub_node); Py_INCREF(self); return (MapNode *)self; } else { MapNode_Bitmap *ret = map_node_bitmap_clone(self, mutid); if (ret == NULL) { return NULL; } Py_SETREF(ret->b_array[val_idx], (PyObject*)sub_node); return (MapNode *)ret; } } assert(key != NULL); /* key is not NULL. This means that we have only one other key in this collection that matches our hash for this shift. */ int comp_err = PyObject_RichCompareBool(key, key_or_null, Py_EQ); if (comp_err < 0) { /* exception in __eq__ */ return NULL; } if (comp_err == 1) { /* key == key_or_null */ if (val == val_or_node) { /* we already have the same key/val pair; return self. */ Py_INCREF(self); return (MapNode *)self; } /* We're setting a new value for the key we had before. */ if (mutid != 0 && self->b_mutid == mutid) { /* We've been mutating this node before: update inplace. */ Py_INCREF(val); Py_SETREF(self->b_array[val_idx], val); Py_INCREF(self); return (MapNode *)self; } else { /* Make a new bitmap node with a replaced value, and return it. */ MapNode_Bitmap *ret = map_node_bitmap_clone(self, mutid); if (ret == NULL) { return NULL; } Py_INCREF(val); Py_SETREF(ret->b_array[val_idx], val); return (MapNode *)ret; } } /* It's a new key, and it has the same index as *one* another key. We have a collision. We need to create a new node which will combine the existing key and the key we're adding. `map_node_new_bitmap_or_collision` will either create a new Collision node if the keys have identical hashes, or a new Bitmap node. */ MapNode *sub_node = map_node_new_bitmap_or_collision( shift + 5, key_or_null, val_or_node, /* existing key/val */ hash, key, val, /* new key/val */ self->b_mutid ); if (sub_node == NULL) { return NULL; } if (mutid != 0 && self->b_mutid == mutid) { Py_SETREF(self->b_array[key_idx], NULL); Py_SETREF(self->b_array[val_idx], (PyObject *)sub_node); Py_INCREF(self); *added_leaf = 1; return (MapNode *)self; } else { MapNode_Bitmap *ret = map_node_bitmap_clone(self, mutid); if (ret == NULL) { Py_DECREF(sub_node); return NULL; } Py_SETREF(ret->b_array[key_idx], NULL); Py_SETREF(ret->b_array[val_idx], (PyObject *)sub_node); *added_leaf = 1; return (MapNode *)ret; } } else { /* There was no key before with the same (shift,hash). */ uint32_t n = map_bitcount(self->b_bitmap); if (n >= 16) { /* When we have a situation where we want to store more than 16 nodes at one level of the tree, we no longer want to use the Bitmap node with bitmap encoding. Instead we start using an Array node, which has simpler (faster) implementation at the expense of having prealocated 32 pointers for its keys/values pairs. Small map objects (<30 keys) usually don't have any Array nodes at all. Between ~30 and ~400 keys map objects usually have one Array node, and usually it's a root node. */ uint32_t jdx = map_mask(hash, shift); /* 'jdx' is the index of where the new key should be added in the new Array node we're about to create. */ MapNode *empty = NULL; MapNode_Array *new_node = NULL; MapNode *res = NULL; /* Create a new Array node. */ new_node = (MapNode_Array *)map_node_array_new(n + 1, mutid); if (new_node == NULL) { goto fin; } /* Create an empty bitmap node for the next map_node_assoc call. */ empty = map_node_bitmap_new(0, mutid); if (empty == NULL) { goto fin; } /* Make a new bitmap node for the key/val we're adding. Set that bitmap node to new-array-node[jdx]. */ new_node->a_array[jdx] = map_node_assoc( empty, shift + 5, hash, key, val, added_leaf, mutid); if (new_node->a_array[jdx] == NULL) { goto fin; } /* Copy existing key/value pairs from the current Bitmap node to the new Array node we've just created. */ Py_ssize_t i, j; for (i = 0, j = 0; i < HAMT_ARRAY_NODE_SIZE; i++) { if (((self->b_bitmap >> i) & 1) != 0) { /* Ensure we don't accidentally override `jdx` element we set few lines above. */ assert(new_node->a_array[i] == NULL); if (self->b_array[j] == NULL) { new_node->a_array[i] = (MapNode *)self->b_array[j + 1]; Py_INCREF(new_node->a_array[i]); } else { int32_t rehash = map_hash(self->b_array[j]); if (rehash == -1) { goto fin; } new_node->a_array[i] = map_node_assoc( empty, shift + 5, rehash, self->b_array[j], self->b_array[j + 1], added_leaf, mutid); if (new_node->a_array[i] == NULL) { goto fin; } } j += 2; } } VALIDATE_ARRAY_NODE(new_node) /* That's it! */ res = (MapNode *)new_node; fin: Py_XDECREF(empty); if (res == NULL) { Py_XDECREF(new_node); } return res; } else { /* We have less than 16 keys at this level; let's just create a new bitmap node out of this node with the new key/val pair added. */ uint32_t key_idx = 2 * idx; uint32_t val_idx = key_idx + 1; uint32_t i; *added_leaf = 1; /* Allocate new Bitmap node which can have one more key/val pair in addition to what we have already. */ MapNode_Bitmap *new_node = (MapNode_Bitmap *)map_node_bitmap_new(2 * (n + 1), mutid); if (new_node == NULL) { return NULL; } /* Copy all keys/values that will be before the new key/value we are adding. */ for (i = 0; i < key_idx; i++) { Py_XINCREF(self->b_array[i]); new_node->b_array[i] = self->b_array[i]; } /* Set the new key/value to the new Bitmap node. */ Py_INCREF(key); new_node->b_array[key_idx] = key; Py_INCREF(val); new_node->b_array[val_idx] = val; /* Copy all keys/values that will be after the new key/value we are adding. */ assert(Py_SIZE(self) >= 0 && Py_SIZE(self) <= 32); for (i = key_idx; i < (uint32_t)Py_SIZE(self); i++) { Py_XINCREF(self->b_array[i]); new_node->b_array[i + 2] = self->b_array[i]; } new_node->b_bitmap = self->b_bitmap | bit; return (MapNode *)new_node; } } } static map_without_t map_node_bitmap_without(MapNode_Bitmap *self, uint32_t shift, int32_t hash, PyObject *key, MapNode **new_node, uint64_t mutid) { uint32_t bit = map_bitpos(hash, shift); if ((self->b_bitmap & bit) == 0) { return W_NOT_FOUND; } uint32_t idx = map_bitindex(self->b_bitmap, bit); uint32_t key_idx = 2 * idx; uint32_t val_idx = key_idx + 1; PyObject *key_or_null = self->b_array[key_idx]; PyObject *val_or_node = self->b_array[val_idx]; if (key_or_null == NULL) { /* key == NULL means that 'value' is another tree node. */ MapNode *sub_node = NULL; MapNode_Bitmap *target = NULL; map_without_t res = map_node_without( (MapNode *)val_or_node, shift + 5, hash, key, &sub_node, mutid); switch (res) { case W_EMPTY: /* It's impossible for us to receive a W_EMPTY here: - Array nodes are converted to Bitmap nodes when we delete 16th item from them; - Collision nodes are converted to Bitmap when there is one item in them; - Bitmap node's without() inlines single-item sub-nodes. So in no situation we can have a single-item Bitmap child of another Bitmap node. */ abort(); case W_NEWNODE: { assert(sub_node != NULL); if (IS_BITMAP_NODE(sub_node)) { MapNode_Bitmap *sub_tree = (MapNode_Bitmap *)sub_node; if (map_node_bitmap_count(sub_tree) == 1 && sub_tree->b_array[0] != NULL) { /* A bitmap node with one key/value pair. Just merge it into this node. Note that we don't inline Bitmap nodes that have a NULL key -- those nodes point to another tree level, and we cannot simply move tree levels up or down. */ if (mutid != 0 && self->b_mutid == mutid) { target = self; Py_INCREF(target); } else { target = map_node_bitmap_clone(self, mutid); if (target == NULL) { Py_DECREF(sub_node); return W_ERROR; } } PyObject *key = sub_tree->b_array[0]; PyObject *val = sub_tree->b_array[1]; Py_INCREF(key); Py_XSETREF(target->b_array[key_idx], key); Py_INCREF(val); Py_SETREF(target->b_array[val_idx], val); Py_DECREF(sub_tree); *new_node = (MapNode *)target; return W_NEWNODE; } } #if !defined(NDEBUG) /* Ensure that Collision.without implementation converts to Bitmap nodes itself. */ if (IS_COLLISION_NODE(sub_node)) { assert(map_node_collision_count( (MapNode_Collision*)sub_node) > 1); } #endif if (mutid != 0 && self->b_mutid == mutid) { target = self; Py_INCREF(target); } else { target = map_node_bitmap_clone(self, mutid); if (target == NULL) { return W_ERROR; } } Py_SETREF(target->b_array[val_idx], (PyObject *)sub_node); /* borrow */ *new_node = (MapNode *)target; return W_NEWNODE; } case W_ERROR: case W_NOT_FOUND: assert(sub_node == NULL); return res; default: abort(); } } else { /* We have a regular key/value pair */ int cmp = PyObject_RichCompareBool(key_or_null, key, Py_EQ); if (cmp < 0) { return W_ERROR; } if (cmp == 0) { return W_NOT_FOUND; } if (map_node_bitmap_count(self) == 1) { return W_EMPTY; } *new_node = (MapNode *) map_node_bitmap_clone_without(self, bit, mutid); if (*new_node == NULL) { return W_ERROR; } return W_NEWNODE; } } static map_find_t map_node_bitmap_find(MapNode_Bitmap *self, uint32_t shift, int32_t hash, PyObject *key, PyObject **val) { /* Lookup a key in a Bitmap node. */ uint32_t bit = map_bitpos(hash, shift); uint32_t idx; uint32_t key_idx; uint32_t val_idx; PyObject *key_or_null; PyObject *val_or_node; int comp_err; if ((self->b_bitmap & bit) == 0) { return F_NOT_FOUND; } idx = map_bitindex(self->b_bitmap, bit); key_idx = idx * 2; val_idx = key_idx + 1; assert(val_idx < (size_t)Py_SIZE(self)); key_or_null = self->b_array[key_idx]; val_or_node = self->b_array[val_idx]; if (key_or_null == NULL) { /* There are a few keys that have the same hash at the current shift that match our key. Dispatch the lookup further down the tree. */ assert(val_or_node != NULL); return map_node_find((MapNode *)val_or_node, shift + 5, hash, key, val); } /* We have only one key -- a potential match. Let's compare if the key we are looking at is equal to the key we are looking for. */ assert(key != NULL); comp_err = PyObject_RichCompareBool(key, key_or_null, Py_EQ); if (comp_err < 0) { /* exception in __eq__ */ return F_ERROR; } if (comp_err == 1) { /* key == key_or_null */ *val = val_or_node; return F_FOUND; } return F_NOT_FOUND; } static int map_node_bitmap_traverse(MapNode_Bitmap *self, visitproc visit, void *arg) { /* Bitmap's tp_traverse */ Py_ssize_t i; for (i = Py_SIZE(self); --i >= 0; ) { Py_VISIT(self->b_array[i]); } return 0; } static void map_node_bitmap_dealloc(MapNode_Bitmap *self) { /* Bitmap's tp_dealloc */ Py_ssize_t len = Py_SIZE(self); Py_ssize_t i; PyObject_GC_UnTrack(self); Py_TRASHCAN_SAFE_BEGIN(self) if (len > 0) { i = len; while (--i >= 0) { Py_XDECREF(self->b_array[i]); } } Py_TYPE(self)->tp_free((PyObject *)self); Py_TRASHCAN_SAFE_END(self) } static int map_node_bitmap_dump(MapNode_Bitmap *node, _PyUnicodeWriter *writer, int level) { /* Debug build: __dump__() method implementation for Bitmap nodes. */ Py_ssize_t i; PyObject *tmp1; PyObject *tmp2; if (_map_dump_ident(writer, level + 1)) { goto error; } if (_map_dump_format(writer, "BitmapNode(size=%zd count=%zd ", Py_SIZE(node), Py_SIZE(node) / 2)) { goto error; } tmp1 = PyLong_FromUnsignedLong(node->b_bitmap); if (tmp1 == NULL) { goto error; } tmp2 = _PyLong_Format(tmp1, 2); Py_DECREF(tmp1); if (tmp2 == NULL) { goto error; } if (_map_dump_format(writer, "bitmap=%S id=%p):\n", tmp2, node)) { Py_DECREF(tmp2); goto error; } Py_DECREF(tmp2); for (i = 0; i < Py_SIZE(node); i += 2) { PyObject *key_or_null = node->b_array[i]; PyObject *val_or_node = node->b_array[i + 1]; if (_map_dump_ident(writer, level + 2)) { goto error; } if (key_or_null == NULL) { if (_map_dump_format(writer, "NULL:\n")) { goto error; } if (map_node_dump((MapNode *)val_or_node, writer, level + 2)) { goto error; } } else { if (_map_dump_format(writer, "%R: %R", key_or_null, val_or_node)) { goto error; } } if (_map_dump_format(writer, "\n")) { goto error; } } return 0; error: return -1; } /////////////////////////////////// Collision Node static MapNode * map_node_collision_new(int32_t hash, Py_ssize_t size, uint64_t mutid) { /* Create a new Collision node. */ MapNode_Collision *node; Py_ssize_t i; assert(size >= 4); assert(size % 2 == 0); node = PyObject_GC_NewVar( MapNode_Collision, &_Map_CollisionNode_Type, size); if (node == NULL) { return NULL; } for (i = 0; i < size; i++) { node->c_array[i] = NULL; } Py_SET_SIZE(node, size); node->c_hash = hash; node->c_mutid = mutid; PyObject_GC_Track(node); return (MapNode *)node; } static map_find_t map_node_collision_find_index(MapNode_Collision *self, PyObject *key, Py_ssize_t *idx) { /* Lookup `key` in the Collision node `self`. Set the index of the found key to 'idx'. */ Py_ssize_t i; PyObject *el; for (i = 0; i < Py_SIZE(self); i += 2) { el = self->c_array[i]; assert(el != NULL); int cmp = PyObject_RichCompareBool(key, el, Py_EQ); if (cmp < 0) { return F_ERROR; } if (cmp == 1) { *idx = i; return F_FOUND; } } return F_NOT_FOUND; } static MapNode * map_node_collision_assoc(MapNode_Collision *self, uint32_t shift, int32_t hash, PyObject *key, PyObject *val, int* added_leaf, uint64_t mutid) { /* Set a new key to this level (currently a Collision node) of the tree. */ if (hash == self->c_hash) { /* The hash of the 'key' we are adding matches the hash of other keys in this Collision node. */ Py_ssize_t key_idx = -1; map_find_t found; MapNode_Collision *new_node; Py_ssize_t i; /* Let's try to lookup the new 'key', maybe we already have it. */ found = map_node_collision_find_index(self, key, &key_idx); switch (found) { case F_ERROR: /* Exception. */ return NULL; case F_NOT_FOUND: /* This is a totally new key. Clone the current node, add a new key/value to the cloned node. */ new_node = (MapNode_Collision *)map_node_collision_new( self->c_hash, Py_SIZE(self) + 2, mutid); if (new_node == NULL) { return NULL; } for (i = 0; i < Py_SIZE(self); i++) { Py_INCREF(self->c_array[i]); new_node->c_array[i] = self->c_array[i]; } Py_INCREF(key); new_node->c_array[i] = key; Py_INCREF(val); new_node->c_array[i + 1] = val; *added_leaf = 1; return (MapNode *)new_node; case F_FOUND: /* There's a key which is equal to the key we are adding. */ assert(key_idx >= 0); assert(key_idx < Py_SIZE(self)); Py_ssize_t val_idx = key_idx + 1; if (self->c_array[val_idx] == val) { /* We're setting a key/value pair that's already set. */ Py_INCREF(self); return (MapNode *)self; } /* We need to replace old value for the key with a new value. */ if (mutid != 0 && self->c_mutid == mutid) { new_node = self; Py_INCREF(self); } else { /* Create a new Collision node.*/ new_node = (MapNode_Collision *)map_node_collision_new( self->c_hash, Py_SIZE(self), mutid); if (new_node == NULL) { return NULL; } /* Copy all elements of the old node to the new one. */ for (i = 0; i < Py_SIZE(self); i++) { Py_INCREF(self->c_array[i]); new_node->c_array[i] = self->c_array[i]; } } /* Replace the old value with the new value for the our key. */ Py_DECREF(new_node->c_array[val_idx]); Py_INCREF(val); new_node->c_array[val_idx] = val; return (MapNode *)new_node; default: abort(); } } else { /* The hash of the new key is different from the hash that all keys of this Collision node have. Create a Bitmap node inplace with two children: key/value pair that we're adding, and the Collision node we're replacing on this tree level. */ MapNode_Bitmap *new_node; MapNode *assoc_res; new_node = (MapNode_Bitmap *)map_node_bitmap_new(2, mutid); if (new_node == NULL) { return NULL; } new_node->b_bitmap = map_bitpos(self->c_hash, shift); Py_INCREF(self); new_node->b_array[1] = (PyObject*) self; assoc_res = map_node_bitmap_assoc( new_node, shift, hash, key, val, added_leaf, mutid); Py_DECREF(new_node); return assoc_res; } } static inline Py_ssize_t map_node_collision_count(MapNode_Collision *node) { return Py_SIZE(node) / 2; } static map_without_t map_node_collision_without(MapNode_Collision *self, uint32_t shift, int32_t hash, PyObject *key, MapNode **new_node, uint64_t mutid) { if (hash != self->c_hash) { return W_NOT_FOUND; } Py_ssize_t key_idx = -1; map_find_t found = map_node_collision_find_index(self, key, &key_idx); switch (found) { case F_ERROR: return W_ERROR; case F_NOT_FOUND: return W_NOT_FOUND; case F_FOUND: assert(key_idx >= 0); assert(key_idx < Py_SIZE(self)); Py_ssize_t new_count = map_node_collision_count(self) - 1; if (new_count == 0) { /* The node has only one key/value pair and it's for the key we're trying to delete. So a new node will be empty after the removal. */ return W_EMPTY; } if (new_count == 1) { /* The node has two keys, and after deletion the new Collision node would have one. Collision nodes with one key shouldn't exist, so convert it to a Bitmap node. */ MapNode_Bitmap *node = (MapNode_Bitmap *) map_node_bitmap_new(2, mutid); if (node == NULL) { return W_ERROR; } if (key_idx == 0) { Py_INCREF(self->c_array[2]); node->b_array[0] = self->c_array[2]; Py_INCREF(self->c_array[3]); node->b_array[1] = self->c_array[3]; } else { assert(key_idx == 2); Py_INCREF(self->c_array[0]); node->b_array[0] = self->c_array[0]; Py_INCREF(self->c_array[1]); node->b_array[1] = self->c_array[1]; } node->b_bitmap = map_bitpos(hash, shift); *new_node = (MapNode *)node; return W_NEWNODE; } /* Allocate a new Collision node with capacity for one less key/value pair */ MapNode_Collision *new = (MapNode_Collision *) map_node_collision_new( self->c_hash, Py_SIZE(self) - 2, mutid); if (new == NULL) { return W_ERROR; } /* Copy all other keys from `self` to `new` */ Py_ssize_t i; for (i = 0; i < key_idx; i++) { Py_INCREF(self->c_array[i]); new->c_array[i] = self->c_array[i]; } for (i = key_idx + 2; i < Py_SIZE(self); i++) { Py_INCREF(self->c_array[i]); new->c_array[i - 2] = self->c_array[i]; } *new_node = (MapNode*)new; return W_NEWNODE; default: abort(); } } static map_find_t map_node_collision_find(MapNode_Collision *self, uint32_t shift, int32_t hash, PyObject *key, PyObject **val) { /* Lookup `key` in the Collision node `self`. Set the value for the found key to 'val'. */ Py_ssize_t idx = -1; map_find_t res; res = map_node_collision_find_index(self, key, &idx); if (res == F_ERROR || res == F_NOT_FOUND) { return res; } assert(idx >= 0); assert(idx + 1 < Py_SIZE(self)); *val = self->c_array[idx + 1]; assert(*val != NULL); return F_FOUND; } static int map_node_collision_traverse(MapNode_Collision *self, visitproc visit, void *arg) { /* Collision's tp_traverse */ Py_ssize_t i; for (i = Py_SIZE(self); --i >= 0; ) { Py_VISIT(self->c_array[i]); } return 0; } static void map_node_collision_dealloc(MapNode_Collision *self) { /* Collision's tp_dealloc */ Py_ssize_t len = Py_SIZE(self); PyObject_GC_UnTrack(self); Py_TRASHCAN_SAFE_BEGIN(self) if (len > 0) { while (--len >= 0) { Py_XDECREF(self->c_array[len]); } } Py_TYPE(self)->tp_free((PyObject *)self); Py_TRASHCAN_SAFE_END(self) } static int map_node_collision_dump(MapNode_Collision *node, _PyUnicodeWriter *writer, int level) { /* Debug build: __dump__() method implementation for Collision nodes. */ Py_ssize_t i; if (_map_dump_ident(writer, level + 1)) { goto error; } if (_map_dump_format(writer, "CollisionNode(size=%zd id=%p):\n", Py_SIZE(node), node)) { goto error; } for (i = 0; i < Py_SIZE(node); i += 2) { PyObject *key = node->c_array[i]; PyObject *val = node->c_array[i + 1]; if (_map_dump_ident(writer, level + 2)) { goto error; } if (_map_dump_format(writer, "%R: %R\n", key, val)) { goto error; } } return 0; error: return -1; } /////////////////////////////////// Array Node static MapNode * map_node_array_new(Py_ssize_t count, uint64_t mutid) { Py_ssize_t i; MapNode_Array *node = PyObject_GC_New( MapNode_Array, &_Map_ArrayNode_Type); if (node == NULL) { return NULL; } for (i = 0; i < HAMT_ARRAY_NODE_SIZE; i++) { node->a_array[i] = NULL; } node->a_count = count; node->a_mutid = mutid; PyObject_GC_Track(node); return (MapNode *)node; } static MapNode_Array * map_node_array_clone(MapNode_Array *node, uint64_t mutid) { MapNode_Array *clone; Py_ssize_t i; VALIDATE_ARRAY_NODE(node) assert(node->a_count <= HAMT_ARRAY_NODE_SIZE); /* Create a new Array node. */ clone = (MapNode_Array *)map_node_array_new(node->a_count, mutid); if (clone == NULL) { return NULL; } /* Copy all elements from the current Array node to the new one. */ for (i = 0; i < HAMT_ARRAY_NODE_SIZE; i++) { Py_XINCREF(node->a_array[i]); clone->a_array[i] = node->a_array[i]; } clone->a_mutid = mutid; VALIDATE_ARRAY_NODE(clone) return clone; } static MapNode * map_node_array_assoc(MapNode_Array *self, uint32_t shift, int32_t hash, PyObject *key, PyObject *val, int* added_leaf, uint64_t mutid) { /* Set a new key to this level (currently a Collision node) of the tree. Array nodes don't store values, they can only point to other nodes. They are simple arrays of 32 BaseNode pointers/ */ uint32_t idx = map_mask(hash, shift); MapNode *node = self->a_array[idx]; MapNode *child_node; MapNode_Array *new_node; Py_ssize_t i; if (node == NULL) { /* There's no child node for the given hash. Create a new Bitmap node for this key. */ MapNode_Bitmap *empty = NULL; /* Get an empty Bitmap node to work with. */ empty = (MapNode_Bitmap *)map_node_bitmap_new(0, mutid); if (empty == NULL) { return NULL; } /* Set key/val to the newly created empty Bitmap, thus creating a new Bitmap node with our key/value pair. */ child_node = map_node_bitmap_assoc( empty, shift + 5, hash, key, val, added_leaf, mutid); Py_DECREF(empty); if (child_node == NULL) { return NULL; } if (mutid != 0 && self->a_mutid == mutid) { new_node = self; self->a_count++; Py_INCREF(self); } else { /* Create a new Array node. */ new_node = (MapNode_Array *)map_node_array_new( self->a_count + 1, mutid); if (new_node == NULL) { Py_DECREF(child_node); return NULL; } /* Copy all elements from the current Array node to the new one. */ for (i = 0; i < HAMT_ARRAY_NODE_SIZE; i++) { Py_XINCREF(self->a_array[i]); new_node->a_array[i] = self->a_array[i]; } } assert(new_node->a_array[idx] == NULL); new_node->a_array[idx] = child_node; /* borrow */ VALIDATE_ARRAY_NODE(new_node) } else { /* There's a child node for the given hash. Set the key to it./ */ child_node = map_node_assoc( node, shift + 5, hash, key, val, added_leaf, mutid); if (child_node == NULL) { return NULL; } else if (child_node == (MapNode *)self) { Py_DECREF(child_node); return (MapNode *)self; } if (mutid != 0 && self->a_mutid == mutid) { new_node = self; Py_INCREF(self); } else { new_node = map_node_array_clone(self, mutid); } if (new_node == NULL) { Py_DECREF(child_node); return NULL; } Py_SETREF(new_node->a_array[idx], child_node); /* borrow */ VALIDATE_ARRAY_NODE(new_node) } return (MapNode *)new_node; } static map_without_t map_node_array_without(MapNode_Array *self, uint32_t shift, int32_t hash, PyObject *key, MapNode **new_node, uint64_t mutid) { uint32_t idx = map_mask(hash, shift); MapNode *node = self->a_array[idx]; if (node == NULL) { return W_NOT_FOUND; } MapNode *sub_node = NULL; MapNode_Array *target = NULL; map_without_t res = map_node_without( (MapNode *)node, shift + 5, hash, key, &sub_node, mutid); switch (res) { case W_NOT_FOUND: case W_ERROR: assert(sub_node == NULL); return res; case W_NEWNODE: { /* We need to replace a node at the `idx` index. Clone this node and replace. */ assert(sub_node != NULL); if (mutid != 0 && self->a_mutid == mutid) { target = self; Py_INCREF(self); } else { target = map_node_array_clone(self, mutid); if (target == NULL) { Py_DECREF(sub_node); return W_ERROR; } } Py_SETREF(target->a_array[idx], sub_node); /* borrow */ *new_node = (MapNode*)target; /* borrow */ return W_NEWNODE; } case W_EMPTY: { assert(sub_node == NULL); /* We need to remove a node at the `idx` index. Calculate the size of the replacement Array node. */ Py_ssize_t new_count = self->a_count - 1; if (new_count == 0) { return W_EMPTY; } if (new_count >= 16) { /* We convert Bitmap nodes to Array nodes, when a Bitmap node needs to store more than 15 key/value pairs. So we will create a new Array node if we the number of key/values after deletion is still greater than 15. */ if (mutid != 0 && self->a_mutid == mutid) { target = self; Py_INCREF(self); } else { target = map_node_array_clone(self, mutid); if (target == NULL) { return W_ERROR; } } target->a_count = new_count; Py_CLEAR(target->a_array[idx]); *new_node = (MapNode*)target; /* borrow */ return W_NEWNODE; } /* New Array node would have less than 16 key/value pairs. We need to create a replacement Bitmap node. */ Py_ssize_t bitmap_size = new_count * 2; uint32_t bitmap = 0; MapNode_Bitmap *new = (MapNode_Bitmap *) map_node_bitmap_new(bitmap_size, mutid); if (new == NULL) { return W_ERROR; } Py_ssize_t new_i = 0; for (uint32_t i = 0; i < HAMT_ARRAY_NODE_SIZE; i++) { if (i == idx) { /* Skip the node we are deleting. */ continue; } MapNode *node = self->a_array[i]; if (node == NULL) { /* Skip any missing nodes. */ continue; } bitmap |= 1u << i; if (IS_BITMAP_NODE(node)) { MapNode_Bitmap *child = (MapNode_Bitmap *)node; if (map_node_bitmap_count(child) == 1 && child->b_array[0] != NULL) { /* node is a Bitmap with one key/value pair, just merge it into the new Bitmap node we're building. Note that we don't inline Bitmap nodes that have a NULL key -- those nodes point to another tree level, and we cannot simply move tree levels up or down. */ PyObject *key = child->b_array[0]; PyObject *val = child->b_array[1]; Py_INCREF(key); new->b_array[new_i] = key; Py_INCREF(val); new->b_array[new_i + 1] = val; } else { new->b_array[new_i] = NULL; Py_INCREF(node); new->b_array[new_i + 1] = (PyObject*)node; } } else { #if !defined(NDEBUG) if (IS_COLLISION_NODE(node)) { assert( (map_node_collision_count( (MapNode_Collision*)node)) > 1); } else if (IS_ARRAY_NODE(node)) { assert(((MapNode_Array*)node)->a_count >= 16); } #endif /* Just copy the node into our new Bitmap */ new->b_array[new_i] = NULL; Py_INCREF(node); new->b_array[new_i + 1] = (PyObject*)node; } new_i += 2; } new->b_bitmap = bitmap; *new_node = (MapNode*)new; /* borrow */ return W_NEWNODE; } default: abort(); } } static map_find_t map_node_array_find(MapNode_Array *self, uint32_t shift, int32_t hash, PyObject *key, PyObject **val) { /* Lookup `key` in the Array node `self`. Set the value for the found key to 'val'. */ uint32_t idx = map_mask(hash, shift); MapNode *node; node = self->a_array[idx]; if (node == NULL) { return F_NOT_FOUND; } /* Dispatch to the generic map_node_find */ return map_node_find(node, shift + 5, hash, key, val); } static int map_node_array_traverse(MapNode_Array *self, visitproc visit, void *arg) { /* Array's tp_traverse */ Py_ssize_t i; for (i = 0; i < HAMT_ARRAY_NODE_SIZE; i++) { Py_VISIT(self->a_array[i]); } return 0; } static void map_node_array_dealloc(MapNode_Array *self) { /* Array's tp_dealloc */ Py_ssize_t i; PyObject_GC_UnTrack(self); Py_TRASHCAN_SAFE_BEGIN(self) for (i = 0; i < HAMT_ARRAY_NODE_SIZE; i++) { Py_XDECREF(self->a_array[i]); } Py_TYPE(self)->tp_free((PyObject *)self); Py_TRASHCAN_SAFE_END(self) } static int map_node_array_dump(MapNode_Array *node, _PyUnicodeWriter *writer, int level) { /* Debug build: __dump__() method implementation for Array nodes. */ Py_ssize_t i; if (_map_dump_ident(writer, level + 1)) { goto error; } if (_map_dump_format(writer, "ArrayNode(id=%p count=%zd):\n", node, node->a_count) ) { goto error; } for (i = 0; i < HAMT_ARRAY_NODE_SIZE; i++) { if (node->a_array[i] == NULL) { continue; } if (_map_dump_ident(writer, level + 2)) { goto error; } if (_map_dump_format(writer, "%d::\n", i)) { goto error; } if (map_node_dump(node->a_array[i], writer, level + 1)) { goto error; } if (_map_dump_format(writer, "\n")) { goto error; } } return 0; error: return -1; } /////////////////////////////////// Node Dispatch static MapNode * map_node_assoc(MapNode *node, uint32_t shift, int32_t hash, PyObject *key, PyObject *val, int* added_leaf, uint64_t mutid) { /* Set key/value to the 'node' starting with the given shift/hash. Return a new node, or the same node if key/value already set. added_leaf will be set to 1 if key/value wasn't in the tree before. This method automatically dispatches to the suitable map_node_{nodetype}_assoc method. */ *added_leaf = 0; if (IS_BITMAP_NODE(node)) { return map_node_bitmap_assoc( (MapNode_Bitmap *)node, shift, hash, key, val, added_leaf, mutid); } else if (IS_ARRAY_NODE(node)) { return map_node_array_assoc( (MapNode_Array *)node, shift, hash, key, val, added_leaf, mutid); } else { assert(IS_COLLISION_NODE(node)); return map_node_collision_assoc( (MapNode_Collision *)node, shift, hash, key, val, added_leaf, mutid); } } static map_without_t map_node_without(MapNode *node, uint32_t shift, int32_t hash, PyObject *key, MapNode **new_node, uint64_t mutid) { if (IS_BITMAP_NODE(node)) { return map_node_bitmap_without( (MapNode_Bitmap *)node, shift, hash, key, new_node, mutid); } else if (IS_ARRAY_NODE(node)) { return map_node_array_without( (MapNode_Array *)node, shift, hash, key, new_node, mutid); } else { assert(IS_COLLISION_NODE(node)); return map_node_collision_without( (MapNode_Collision *)node, shift, hash, key, new_node, mutid); } } static map_find_t map_node_find(MapNode *node, uint32_t shift, int32_t hash, PyObject *key, PyObject **val) { /* Find the key in the node starting with the given shift/hash. If a value is found, the result will be set to F_FOUND, and *val will point to the found value object. If a value wasn't found, the result will be set to F_NOT_FOUND. If an exception occurs during the call, the result will be F_ERROR. This method automatically dispatches to the suitable map_node_{nodetype}_find method. */ if (IS_BITMAP_NODE(node)) { return map_node_bitmap_find( (MapNode_Bitmap *)node, shift, hash, key, val); } else if (IS_ARRAY_NODE(node)) { return map_node_array_find( (MapNode_Array *)node, shift, hash, key, val); } else { assert(IS_COLLISION_NODE(node)); return map_node_collision_find( (MapNode_Collision *)node, shift, hash, key, val); } } static int map_node_dump(MapNode *node, _PyUnicodeWriter *writer, int level) { /* Debug build: __dump__() method implementation for a node. This method automatically dispatches to the suitable map_node_{nodetype})_dump method. */ if (IS_BITMAP_NODE(node)) { return map_node_bitmap_dump( (MapNode_Bitmap *)node, writer, level); } else if (IS_ARRAY_NODE(node)) { return map_node_array_dump( (MapNode_Array *)node, writer, level); } else { assert(IS_COLLISION_NODE(node)); return map_node_collision_dump( (MapNode_Collision *)node, writer, level); } } /////////////////////////////////// Iterators: Machinery static map_iter_t map_iterator_next(MapIteratorState *iter, PyObject **key, PyObject **val); static void map_iterator_init(MapIteratorState *iter, MapNode *root) { for (uint32_t i = 0; i < _Py_HAMT_MAX_TREE_DEPTH; i++) { iter->i_nodes[i] = NULL; iter->i_pos[i] = 0; } iter->i_level = 0; /* Note: we don't incref/decref nodes in i_nodes. */ iter->i_nodes[0] = root; } static map_iter_t map_iterator_bitmap_next(MapIteratorState *iter, PyObject **key, PyObject **val) { int8_t level = iter->i_level; MapNode_Bitmap *node = (MapNode_Bitmap *)(iter->i_nodes[level]); Py_ssize_t pos = iter->i_pos[level]; if (pos + 1 >= Py_SIZE(node)) { #if !defined(NDEBUG) assert(iter->i_level >= 0); iter->i_nodes[iter->i_level] = NULL; #endif iter->i_level--; return map_iterator_next(iter, key, val); } if (node->b_array[pos] == NULL) { iter->i_pos[level] = pos + 2; assert(level + 1 < _Py_HAMT_MAX_TREE_DEPTH); int8_t next_level = (int8_t)(level + 1); iter->i_level = next_level; iter->i_pos[next_level] = 0; iter->i_nodes[next_level] = (MapNode *) node->b_array[pos + 1]; return map_iterator_next(iter, key, val); } *key = node->b_array[pos]; *val = node->b_array[pos + 1]; iter->i_pos[level] = pos + 2; return I_ITEM; } static map_iter_t map_iterator_collision_next(MapIteratorState *iter, PyObject **key, PyObject **val) { int8_t level = iter->i_level; MapNode_Collision *node = (MapNode_Collision *)(iter->i_nodes[level]); Py_ssize_t pos = iter->i_pos[level]; if (pos + 1 >= Py_SIZE(node)) { #if !defined(NDEBUG) assert(iter->i_level >= 0); iter->i_nodes[iter->i_level] = NULL; #endif iter->i_level--; return map_iterator_next(iter, key, val); } *key = node->c_array[pos]; *val = node->c_array[pos + 1]; iter->i_pos[level] = pos + 2; return I_ITEM; } static map_iter_t map_iterator_array_next(MapIteratorState *iter, PyObject **key, PyObject **val) { int8_t level = iter->i_level; MapNode_Array *node = (MapNode_Array *)(iter->i_nodes[level]); Py_ssize_t pos = iter->i_pos[level]; if (pos >= HAMT_ARRAY_NODE_SIZE) { #if !defined(NDEBUG) assert(iter->i_level >= 0); iter->i_nodes[iter->i_level] = NULL; #endif iter->i_level--; return map_iterator_next(iter, key, val); } for (Py_ssize_t i = pos; i < HAMT_ARRAY_NODE_SIZE; i++) { if (node->a_array[i] != NULL) { iter->i_pos[level] = i + 1; assert((level + 1) < _Py_HAMT_MAX_TREE_DEPTH); int8_t next_level = (int8_t)(level + 1); iter->i_pos[next_level] = 0; iter->i_nodes[next_level] = node->a_array[i]; iter->i_level = next_level; return map_iterator_next(iter, key, val); } } #if !defined(NDEBUG) assert(iter->i_level >= 0); iter->i_nodes[iter->i_level] = NULL; #endif iter->i_level--; return map_iterator_next(iter, key, val); } static map_iter_t map_iterator_next(MapIteratorState *iter, PyObject **key, PyObject **val) { if (iter->i_level < 0) { return I_END; } assert(iter->i_level < _Py_HAMT_MAX_TREE_DEPTH); MapNode *current = iter->i_nodes[iter->i_level]; if (IS_BITMAP_NODE(current)) { return map_iterator_bitmap_next(iter, key, val); } else if (IS_ARRAY_NODE(current)) { return map_iterator_array_next(iter, key, val); } else { assert(IS_COLLISION_NODE(current)); return map_iterator_collision_next(iter, key, val); } } /////////////////////////////////// HAMT high-level functions static MapObject * map_assoc(MapObject *o, PyObject *key, PyObject *val) { int32_t key_hash; int added_leaf = 0; MapNode *new_root; MapObject *new_o; key_hash = map_hash(key); if (key_hash == -1) { return NULL; } new_root = map_node_assoc( (MapNode *)(o->h_root), 0, key_hash, key, val, &added_leaf, 0); if (new_root == NULL) { return NULL; } if (new_root == o->h_root) { Py_DECREF(new_root); Py_INCREF(o); return o; } new_o = map_alloc(); if (new_o == NULL) { Py_DECREF(new_root); return NULL; } new_o->h_root = new_root; /* borrow */ new_o->h_count = added_leaf ? o->h_count + 1 : o->h_count; return new_o; } static MapObject * map_without(MapObject *o, PyObject *key) { int32_t key_hash = map_hash(key); if (key_hash == -1) { return NULL; } MapNode *new_root = NULL; map_without_t res = map_node_without( (MapNode *)(o->h_root), 0, key_hash, key, &new_root, 0); switch (res) { case W_ERROR: return NULL; case W_EMPTY: return map_new(); case W_NOT_FOUND: PyErr_SetObject(PyExc_KeyError, key); return NULL; case W_NEWNODE: { assert(new_root != NULL); MapObject *new_o = map_alloc(); if (new_o == NULL) { Py_DECREF(new_root); return NULL; } new_o->h_root = new_root; /* borrow */ new_o->h_count = o->h_count - 1; assert(new_o->h_count >= 0); return new_o; } default: abort(); } } static map_find_t map_find(BaseMapObject *o, PyObject *key, PyObject **val) { if (o->b_count == 0) { return F_NOT_FOUND; } int32_t key_hash = map_hash(key); if (key_hash == -1) { return F_ERROR; } return map_node_find(o->b_root, 0, key_hash, key, val); } static int map_eq(BaseMapObject *v, BaseMapObject *w) { if (v == w) { return 1; } if (v->b_count != w->b_count) { return 0; } MapIteratorState iter; map_iter_t iter_res; map_find_t find_res; PyObject *v_key; PyObject *v_val; PyObject *w_val; map_iterator_init(&iter, v->b_root); do { iter_res = map_iterator_next(&iter, &v_key, &v_val); if (iter_res == I_ITEM) { find_res = map_find(w, v_key, &w_val); switch (find_res) { case F_ERROR: return -1; case F_NOT_FOUND: return 0; case F_FOUND: { int cmp = PyObject_RichCompareBool(v_val, w_val, Py_EQ); if (cmp < 0) { return -1; } if (cmp == 0) { return 0; } } } } } while (iter_res != I_END); return 1; } static Py_ssize_t map_len(BaseMapObject *o) { return o->b_count; } static MapObject * map_alloc(void) { MapObject *o; o = PyObject_GC_New(MapObject, &_Map_Type); if (o == NULL) { return NULL; } o->h_weakreflist = NULL; o->h_hash = -1; o->h_count = 0; o->h_root = NULL; PyObject_GC_Track(o); return o; } static MapObject * map_new(void) { MapObject *o = map_alloc(); if (o == NULL) { return NULL; } o->h_root = map_node_bitmap_new(0, 0); if (o->h_root == NULL) { Py_DECREF(o); return NULL; } return o; } static PyObject * map_dump(MapObject *self) { _PyUnicodeWriter writer; _PyUnicodeWriter_Init(&writer); if (_map_dump_format(&writer, "HAMT(len=%zd):\n", self->h_count)) { goto error; } if (map_node_dump(self->h_root, &writer, 0)) { goto error; } return _PyUnicodeWriter_Finish(&writer); error: _PyUnicodeWriter_Dealloc(&writer); return NULL; } /////////////////////////////////// Iterators: Shared Iterator Implementation static int map_baseiter_tp_clear(MapIterator *it) { Py_CLEAR(it->mi_obj); return 0; } static void map_baseiter_tp_dealloc(MapIterator *it) { PyObject_GC_UnTrack(it); (void)map_baseiter_tp_clear(it); PyObject_GC_Del(it); } static int map_baseiter_tp_traverse(MapIterator *it, visitproc visit, void *arg) { Py_VISIT(it->mi_obj); return 0; } static PyObject * map_baseiter_tp_iternext(MapIterator *it) { PyObject *key; PyObject *val; map_iter_t res = map_iterator_next(&it->mi_iter, &key, &val); switch (res) { case I_END: PyErr_SetNone(PyExc_StopIteration); return NULL; case I_ITEM: { return (*(it->mi_yield))(key, val); } default: { abort(); } } } static int map_baseview_tp_clear(MapView *view) { Py_CLEAR(view->mv_obj); Py_CLEAR(view->mv_itertype); return 0; } static void map_baseview_tp_dealloc(MapView *view) { PyObject_GC_UnTrack(view); (void)map_baseview_tp_clear(view); PyObject_GC_Del(view); } static int map_baseview_tp_traverse(MapView *view, visitproc visit, void *arg) { Py_VISIT(view->mv_obj); return 0; } static Py_ssize_t map_baseview_tp_len(MapView *view) { return view->mv_obj->h_count; } static PyMappingMethods MapView_as_mapping = { (lenfunc)map_baseview_tp_len, }; static PyObject * map_baseview_newiter(PyTypeObject *type, binaryfunc yield, MapObject *map) { MapIterator *iter = PyObject_GC_New(MapIterator, type); if (iter == NULL) { return NULL; } Py_INCREF(map); iter->mi_obj = map; iter->mi_yield = yield; map_iterator_init(&iter->mi_iter, map->h_root); PyObject_GC_Track(iter); return (PyObject *)iter; } static PyObject * map_baseview_iter(MapView *view) { return map_baseview_newiter( view->mv_itertype, view->mv_yield, view->mv_obj); } static PyObject * map_baseview_new(PyTypeObject *type, binaryfunc yield, MapObject *o, PyTypeObject *itertype) { MapView *view = PyObject_GC_New(MapView, type); if (view == NULL) { return NULL; } Py_INCREF(o); view->mv_obj = o; view->mv_yield = yield; Py_INCREF(itertype); view->mv_itertype = itertype; PyObject_GC_Track(view); return (PyObject *)view; } #define ITERATOR_TYPE_SHARED_SLOTS \ .tp_basicsize = sizeof(MapIterator), \ .tp_itemsize = 0, \ .tp_dealloc = (destructor)map_baseiter_tp_dealloc, \ .tp_getattro = PyObject_GenericGetAttr, \ .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, \ .tp_traverse = (traverseproc)map_baseiter_tp_traverse, \ .tp_clear = (inquiry)map_baseiter_tp_clear, \ .tp_iter = PyObject_SelfIter, \ .tp_iternext = (iternextfunc)map_baseiter_tp_iternext, #define VIEW_TYPE_SHARED_SLOTS \ .tp_basicsize = sizeof(MapView), \ .tp_itemsize = 0, \ .tp_as_mapping = &MapView_as_mapping, \ .tp_dealloc = (destructor)map_baseview_tp_dealloc, \ .tp_getattro = PyObject_GenericGetAttr, \ .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, \ .tp_traverse = (traverseproc)map_baseview_tp_traverse, \ .tp_clear = (inquiry)map_baseview_tp_clear, \ .tp_iter = (getiterfunc)map_baseview_iter, \ /////////////////////////////////// _MapItems_Type PyTypeObject _MapItems_Type = { PyVarObject_HEAD_INIT(NULL, 0) "items", VIEW_TYPE_SHARED_SLOTS }; PyTypeObject _MapItemsIter_Type = { PyVarObject_HEAD_INIT(NULL, 0) "items_iterator", ITERATOR_TYPE_SHARED_SLOTS }; static PyObject * map_iter_yield_items(PyObject *key, PyObject *val) { return PyTuple_Pack(2, key, val); } static PyObject * map_new_items_view(MapObject *o) { return map_baseview_new( &_MapItems_Type, map_iter_yield_items, o, &_MapItemsIter_Type); } /////////////////////////////////// _MapKeys_Type PyTypeObject _MapKeys_Type = { PyVarObject_HEAD_INIT(NULL, 0) "keys", VIEW_TYPE_SHARED_SLOTS }; PyTypeObject _MapKeysIter_Type = { PyVarObject_HEAD_INIT(NULL, 0) "keys_iterator", ITERATOR_TYPE_SHARED_SLOTS }; static PyObject * map_iter_yield_keys(PyObject *key, PyObject *val) { Py_INCREF(key); return key; } static PyObject * map_new_keys_iter(MapObject *o) { return map_baseview_newiter( &_MapKeysIter_Type, map_iter_yield_keys, o); } static PyObject * map_new_keys_view(MapObject *o) { return map_baseview_new( &_MapKeys_Type, map_iter_yield_keys, o, &_MapKeysIter_Type); } /////////////////////////////////// _MapValues_Type PyTypeObject _MapValues_Type = { PyVarObject_HEAD_INIT(NULL, 0) "values", VIEW_TYPE_SHARED_SLOTS }; PyTypeObject _MapValuesIter_Type = { PyVarObject_HEAD_INIT(NULL, 0) "values_iterator", ITERATOR_TYPE_SHARED_SLOTS }; static PyObject * map_iter_yield_values(PyObject *key, PyObject *val) { Py_INCREF(val); return val; } static PyObject * map_new_values_view(MapObject *o) { return map_baseview_new( &_MapValues_Type, map_iter_yield_values, o, &_MapValuesIter_Type); } /////////////////////////////////// _Map_Type static PyObject * map_dump(MapObject *self); static PyObject * map_tp_new(PyTypeObject *type, PyObject *args, PyObject *kwds) { return (PyObject*)map_new(); } static int map_tp_init(MapObject *self, PyObject *args, PyObject *kwds) { PyObject *arg = NULL; uint64_t mutid = 0; if (!PyArg_UnpackTuple(args, "immutables.Map", 0, 1, &arg)) { return -1; } if (arg != NULL) { if (Map_Check(arg)) { MapObject *other = (MapObject *)arg; Py_INCREF(other->h_root); Py_SETREF(self->h_root, other->h_root); self->h_count = other->h_count; self->h_hash = other->h_hash; } else if (MapMutation_Check(arg)) { PyErr_Format( PyExc_TypeError, "cannot create Maps from MapMutations"); return -1; } else { mutid = mutid_counter++; if (map_update_inplace(mutid, (BaseMapObject *)self, arg)) { return -1; } } } if (kwds != NULL) { if (!PyArg_ValidateKeywordArguments(kwds)) { return -1; } if (!mutid) { mutid = mutid_counter++; } if (map_update_inplace(mutid, (BaseMapObject *)self, kwds)) { return -1; } } return 0; } static int map_tp_clear(BaseMapObject *self) { Py_CLEAR(self->b_root); return 0; } static int map_tp_traverse(BaseMapObject *self, visitproc visit, void *arg) { Py_VISIT(self->b_root); return 0; } static void map_tp_dealloc(BaseMapObject *self) { PyObject_GC_UnTrack(self); if (self->b_weakreflist != NULL) { PyObject_ClearWeakRefs((PyObject*)self); } (void)map_tp_clear(self); Py_TYPE(self)->tp_free(self); } static PyObject * map_tp_richcompare(PyObject *v, PyObject *w, int op) { if (!Map_Check(v) || !Map_Check(w) || (op != Py_EQ && op != Py_NE)) { Py_RETURN_NOTIMPLEMENTED; } int res = map_eq((BaseMapObject *)v, (BaseMapObject *)w); if (res < 0) { return NULL; } if (op == Py_NE) { res = !res; } if (res) { Py_RETURN_TRUE; } else { Py_RETURN_FALSE; } } static int map_tp_contains(BaseMapObject *self, PyObject *key) { PyObject *val; map_find_t res = map_find(self, key, &val); switch (res) { case F_ERROR: return -1; case F_NOT_FOUND: return 0; case F_FOUND: return 1; default: abort(); } } static PyObject * map_tp_subscript(BaseMapObject *self, PyObject *key) { PyObject *val; map_find_t res = map_find(self, key, &val); switch (res) { case F_ERROR: return NULL; case F_FOUND: Py_INCREF(val); return val; case F_NOT_FOUND: PyErr_SetObject(PyExc_KeyError, key); return NULL; default: abort(); } } static Py_ssize_t map_tp_len(BaseMapObject *self) { return map_len(self); } static PyObject * map_tp_iter(MapObject *self) { return map_new_keys_iter(self); } static PyObject * map_py_set(MapObject *self, PyObject *args) { PyObject *key; PyObject *val; if (!PyArg_UnpackTuple(args, "set", 2, 2, &key, &val)) { return NULL; } return (PyObject *)map_assoc(self, key, val); } static PyObject * map_py_get(BaseMapObject *self, PyObject *args) { PyObject *key; PyObject *def = NULL; if (!PyArg_UnpackTuple(args, "get", 1, 2, &key, &def)) { return NULL; } PyObject *val = NULL; map_find_t res = map_find(self, key, &val); switch (res) { case F_ERROR: return NULL; case F_FOUND: Py_INCREF(val); return val; case F_NOT_FOUND: if (def == NULL) { Py_RETURN_NONE; } Py_INCREF(def); return def; default: abort(); } } static PyObject * map_py_delete(MapObject *self, PyObject *key) { return (PyObject *)map_without(self, key); } static PyObject * map_py_mutate(MapObject *self, PyObject *args) { MapMutationObject *o; o = PyObject_GC_New(MapMutationObject, &_MapMutation_Type); if (o == NULL) { return NULL; } o->m_weakreflist = NULL; o->m_count = self->h_count; Py_INCREF(self->h_root); o->m_root = self->h_root; o->m_mutid = mutid_counter++; PyObject_GC_Track(o); return (PyObject *)o; } static PyObject * map_py_update(MapObject *self, PyObject *args, PyObject *kwds) { PyObject *arg = NULL; MapObject *new = NULL; uint64_t mutid = 0; if (!PyArg_UnpackTuple(args, "update", 0, 1, &arg)) { return NULL; } if (arg != NULL) { mutid = mutid_counter++; new = map_update(mutid, self, arg); if (new == NULL) { return NULL; } } else { Py_INCREF(self); new = self; } if (kwds != NULL) { if (!PyArg_ValidateKeywordArguments(kwds)) { Py_DECREF(new); return NULL; } if (!mutid) { mutid = mutid_counter++; } MapObject *new2 = map_update(mutid, new, kwds); Py_DECREF(new); if (new2 == NULL) { return NULL; } new = new2; } return (PyObject *)new; } static PyObject * map_py_items(MapObject *self, PyObject *args) { return map_new_items_view(self); } static PyObject * map_py_values(MapObject *self, PyObject *args) { return map_new_values_view(self); } static PyObject * map_py_keys(MapObject *self, PyObject *args) { return map_new_keys_view(self); } static PyObject * map_py_dump(MapObject *self, PyObject *args) { return map_dump(self); } static PyObject * map_py_repr(BaseMapObject *m) { Py_ssize_t i; _PyUnicodeWriter writer; i = Py_ReprEnter((PyObject *)m); if (i != 0) { return i > 0 ? PyUnicode_FromString("{...}") : NULL; } _PyUnicodeWriter_Init(&writer); if (MapMutation_Check(m)) { if (_PyUnicodeWriter_WriteASCIIString( &writer, "immutables.MapMutation({", 24) < 0) { goto error; } } else { if (_PyUnicodeWriter_WriteASCIIString( &writer, "immutables.Map({", 16) < 0) { goto error; } } MapIteratorState iter; map_iter_t iter_res; map_iterator_init(&iter, m->b_root); int second = 0; do { PyObject *v_key; PyObject *v_val; iter_res = map_iterator_next(&iter, &v_key, &v_val); if (iter_res == I_ITEM) { if (second) { if (_PyUnicodeWriter_WriteASCIIString(&writer, ", ", 2) < 0) { goto error; } } PyObject *s = PyObject_Repr(v_key); if (s == NULL) { goto error; } if (_PyUnicodeWriter_WriteStr(&writer, s) < 0) { Py_DECREF(s); goto error; } Py_DECREF(s); if (_PyUnicodeWriter_WriteASCIIString(&writer, ": ", 2) < 0) { goto error; } s = PyObject_Repr(v_val); if (s == NULL) { goto error; } if (_PyUnicodeWriter_WriteStr(&writer, s) < 0) { Py_DECREF(s); goto error; } Py_DECREF(s); } second = 1; } while (iter_res != I_END); if (_PyUnicodeWriter_WriteASCIIString(&writer, "})", 2) < 0) { goto error; } Py_ReprLeave((PyObject *)m); return _PyUnicodeWriter_Finish(&writer); error: _PyUnicodeWriter_Dealloc(&writer); Py_ReprLeave((PyObject *)m); return NULL; } static Py_uhash_t _shuffle_bits(Py_uhash_t h) { return ((h ^ 89869747UL) ^ (h << 16)) * 3644798167UL; } static Py_hash_t map_py_hash(MapObject *self) { /* Adapted version of frozenset.__hash__: it's important that Map.__hash__ is independant of key/values order. Optimization idea: compute and memoize intermediate hash values for HAMT nodes. */ if (self->h_hash != -1) { return self->h_hash; } Py_uhash_t hash = 0; MapIteratorState iter; map_iter_t iter_res; map_iterator_init(&iter, self->h_root); do { PyObject *v_key; PyObject *v_val; iter_res = map_iterator_next(&iter, &v_key, &v_val); if (iter_res == I_ITEM) { Py_hash_t vh = PyObject_Hash(v_key); if (vh == -1) { return -1; } hash ^= _shuffle_bits((Py_uhash_t)vh); vh = PyObject_Hash(v_val); if (vh == -1) { return -1; } hash ^= _shuffle_bits((Py_uhash_t)vh); } } while (iter_res != I_END); hash ^= ((Py_uhash_t)self->h_count * 2 + 1) * 1927868237UL; hash ^= (hash >> 11) ^ (hash >> 25); hash = hash * 69069U + 907133923UL; self->h_hash = (Py_hash_t)hash; if (self->h_hash == -1) { self->h_hash = 1; } return self->h_hash; } static PyObject * map_reduce(MapObject *self) { MapIteratorState iter; map_iter_t iter_res; PyObject *dict = PyDict_New(); if (dict == NULL) { return NULL; } map_iterator_init(&iter, self->h_root); do { PyObject *key; PyObject *val; iter_res = map_iterator_next(&iter, &key, &val); if (iter_res == I_ITEM) { if (PyDict_SetItem(dict, key, val) < 0) { Py_DECREF(dict); return NULL; } } } while (iter_res != I_END); PyObject *args = PyTuple_Pack(1, dict); Py_DECREF(dict); if (args == NULL) { return NULL; } PyObject *tup = PyTuple_Pack(2, Py_TYPE(self), args); Py_DECREF(args); return tup; } static PyObject * map_py_class_getitem(PyObject *type, PyObject *item) { Py_INCREF(type); return type; } static PyMethodDef Map_methods[] = { {"set", (PyCFunction)map_py_set, METH_VARARGS, NULL}, {"get", (PyCFunction)map_py_get, METH_VARARGS, NULL}, {"delete", (PyCFunction)map_py_delete, METH_O, NULL}, {"mutate", (PyCFunction)map_py_mutate, METH_NOARGS, NULL}, {"items", (PyCFunction)map_py_items, METH_NOARGS, NULL}, {"keys", (PyCFunction)map_py_keys, METH_NOARGS, NULL}, {"values", (PyCFunction)map_py_values, METH_NOARGS, NULL}, {"update", (PyCFunction)map_py_update, METH_VARARGS | METH_KEYWORDS, NULL}, {"__reduce__", (PyCFunction)map_reduce, METH_NOARGS, NULL}, {"__dump__", (PyCFunction)map_py_dump, METH_NOARGS, NULL}, { "__class_getitem__", (PyCFunction)map_py_class_getitem, METH_O|METH_CLASS, NULL }, {NULL, NULL} }; static PySequenceMethods Map_as_sequence = { 0, /* sq_length */ 0, /* sq_concat */ 0, /* sq_repeat */ 0, /* sq_item */ 0, /* sq_slice */ 0, /* sq_ass_item */ 0, /* sq_ass_slice */ (objobjproc)map_tp_contains, /* sq_contains */ 0, /* sq_inplace_concat */ 0, /* sq_inplace_repeat */ }; static PyMappingMethods Map_as_mapping = { (lenfunc)map_tp_len, /* mp_length */ (binaryfunc)map_tp_subscript, /* mp_subscript */ }; PyTypeObject _Map_Type = { PyVarObject_HEAD_INIT(NULL, 0) "immutables._map.Map", sizeof(MapObject), .tp_methods = Map_methods, .tp_as_mapping = &Map_as_mapping, .tp_as_sequence = &Map_as_sequence, .tp_iter = (getiterfunc)map_tp_iter, .tp_dealloc = (destructor)map_tp_dealloc, .tp_getattro = PyObject_GenericGetAttr, .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, .tp_richcompare = map_tp_richcompare, .tp_traverse = (traverseproc)map_tp_traverse, .tp_clear = (inquiry)map_tp_clear, .tp_new = map_tp_new, .tp_init = (initproc)map_tp_init, .tp_weaklistoffset = offsetof(MapObject, h_weakreflist), .tp_hash = (hashfunc)map_py_hash, .tp_repr = (reprfunc)map_py_repr, }; /////////////////////////////////// MapMutation static int map_node_update_from_map(uint64_t mutid, MapObject *map, MapNode *root, Py_ssize_t count, MapNode **new_root, Py_ssize_t *new_count) { assert(Map_Check(map)); MapIteratorState iter; map_iter_t iter_res; MapNode *last_root; Py_ssize_t last_count; Py_INCREF(root); last_root = root; last_count = count; map_iterator_init(&iter, map->h_root); do { PyObject *key; PyObject *val; int32_t key_hash; int added_leaf; iter_res = map_iterator_next(&iter, &key, &val); if (iter_res == I_ITEM) { key_hash = map_hash(key); if (key_hash == -1) { goto err; } MapNode *iter_root = map_node_assoc( last_root, 0, key_hash, key, val, &added_leaf, mutid); if (iter_root == NULL) { goto err; } if (added_leaf) { last_count++; } Py_SETREF(last_root, iter_root); } } while (iter_res != I_END); *new_root = last_root; *new_count = last_count; return 0; err: Py_DECREF(last_root); return -1; } static int map_node_update_from_dict(uint64_t mutid, PyObject *dct, MapNode *root, Py_ssize_t count, MapNode **new_root, Py_ssize_t *new_count) { assert(PyDict_Check(dct)); PyObject *it = PyObject_GetIter(dct); if (it == NULL) { return -1; } MapNode *last_root; Py_ssize_t last_count; Py_INCREF(root); last_root = root; last_count = count; PyObject *key; while ((key = PyIter_Next(it))) { PyObject *val; int added_leaf; int32_t key_hash; key_hash = map_hash(key); if (key_hash == -1) { Py_DECREF(key); goto err; } val = PyDict_GetItemWithError(dct, key); if (val == NULL) { Py_DECREF(key); goto err; } MapNode *iter_root = map_node_assoc( last_root, 0, key_hash, key, val, &added_leaf, mutid); Py_DECREF(key); if (iter_root == NULL) { goto err; } if (added_leaf) { last_count++; } Py_SETREF(last_root, iter_root); } if (key == NULL && PyErr_Occurred()) { goto err; } Py_DECREF(it); *new_root = last_root; *new_count = last_count; return 0; err: Py_DECREF(it); Py_DECREF(last_root); return -1; } static int map_node_update_from_seq(uint64_t mutid, PyObject *seq, MapNode *root, Py_ssize_t count, MapNode **new_root, Py_ssize_t *new_count) { PyObject *it; Py_ssize_t i; PyObject *item = NULL; PyObject *fast = NULL; MapNode *last_root; Py_ssize_t last_count; it = PyObject_GetIter(seq); if (it == NULL) { return -1; } Py_INCREF(root); last_root = root; last_count = count; for (i = 0; ; i++) { PyObject *key, *val; Py_ssize_t n; int32_t key_hash; int added_leaf; item = PyIter_Next(it); if (item == NULL) { if (PyErr_Occurred()) { goto err; } break; } fast = PySequence_Fast(item, ""); if (fast == NULL) { if (PyErr_ExceptionMatches(PyExc_TypeError)) PyErr_Format(PyExc_TypeError, "cannot convert map update " "sequence element #%zd to a sequence", i); goto err; } n = PySequence_Fast_GET_SIZE(fast); if (n != 2) { PyErr_Format(PyExc_ValueError, "map update sequence element #%zd " "has length %zd; 2 is required", i, n); goto err; } key = PySequence_Fast_GET_ITEM(fast, 0); val = PySequence_Fast_GET_ITEM(fast, 1); Py_INCREF(key); Py_INCREF(val); key_hash = map_hash(key); if (key_hash == -1) { Py_DECREF(key); Py_DECREF(val); goto err; } MapNode *iter_root = map_node_assoc( last_root, 0, key_hash, key, val, &added_leaf, mutid); Py_DECREF(key); Py_DECREF(val); if (iter_root == NULL) { goto err; } if (added_leaf) { last_count++; } Py_SETREF(last_root, iter_root); Py_DECREF(fast); Py_DECREF(item); } Py_DECREF(it); *new_root = last_root; *new_count = last_count; return 0; err: Py_DECREF(last_root); Py_XDECREF(item); Py_XDECREF(fast); Py_DECREF(it); return -1; } static int map_node_update(uint64_t mutid, PyObject *src, MapNode *root, Py_ssize_t count, MapNode **new_root, Py_ssize_t *new_count) { if (Map_Check(src)) { return map_node_update_from_map( mutid, (MapObject *)src, root, count, new_root, new_count); } else if (PyDict_Check(src)) { return map_node_update_from_dict( mutid, src, root, count, new_root, new_count); } else { return map_node_update_from_seq( mutid, src, root, count, new_root, new_count); } } static int map_update_inplace(uint64_t mutid, BaseMapObject *o, PyObject *src) { MapNode *new_root = NULL; Py_ssize_t new_count; int ret = map_node_update( mutid, src, o->b_root, o->b_count, &new_root, &new_count); if (ret) { return -1; } assert(new_root); Py_SETREF(o->b_root, new_root); o->b_count = new_count; return 0; } static MapObject * map_update(uint64_t mutid, MapObject *o, PyObject *src) { MapNode *new_root = NULL; Py_ssize_t new_count; int ret = map_node_update( mutid, src, o->h_root, o->h_count, &new_root, &new_count); if (ret) { return NULL; } assert(new_root); MapObject *new = map_alloc(); if (new == NULL) { Py_DECREF(new_root); return NULL; } Py_XSETREF(new->h_root, new_root); new->h_count = new_count; return new; } static int mapmut_check_finalized(MapMutationObject *o) { if (o->m_mutid == 0) { PyErr_Format( PyExc_ValueError, "mutation %R has been finished", o, NULL); return -1; } return 0; } static int mapmut_delete(MapMutationObject *o, PyObject *key, int32_t key_hash) { MapNode *new_root = NULL; assert(key_hash != -1); map_without_t res = map_node_without( (MapNode *)(o->m_root), 0, key_hash, key, &new_root, o->m_mutid); switch (res) { case W_ERROR: return -1; case W_EMPTY: new_root = map_node_bitmap_new(0, o->m_mutid); if (new_root == NULL) { return -1; } Py_SETREF(o->m_root, new_root); o->m_count = 0; return 0; case W_NOT_FOUND: PyErr_SetObject(PyExc_KeyError, key); return -1; case W_NEWNODE: { assert(new_root != NULL); Py_SETREF(o->m_root, new_root); o->m_count--; return 0; } default: abort(); } } static int mapmut_set(MapMutationObject *o, PyObject *key, int32_t key_hash, PyObject *val) { int added_leaf = 0; assert(key_hash != -1); MapNode *new_root = map_node_assoc( (MapNode *)(o->m_root), 0, key_hash, key, val, &added_leaf, o->m_mutid); if (new_root == NULL) { return -1; } if (added_leaf) { o->m_count++; } if (new_root == o->m_root) { Py_DECREF(new_root); return 0; } Py_SETREF(o->m_root, new_root); return 0; } static int mapmut_finish(MapMutationObject *o) { o->m_mutid = 0; return 0; } static PyObject * mapmut_py_set(MapMutationObject *o, PyObject *args) { PyObject *key; PyObject *val; if (!PyArg_UnpackTuple(args, "set", 2, 2, &key, &val)) { return NULL; } if (mapmut_check_finalized(o)) { return NULL; } int32_t key_hash = map_hash(key); if (key_hash == -1) { return NULL; } if (mapmut_set(o, key, key_hash, val)) { return NULL; } Py_RETURN_NONE; } static PyObject * mapmut_tp_richcompare(PyObject *v, PyObject *w, int op) { if (!MapMutation_Check(v) || !MapMutation_Check(w) || (op != Py_EQ && op != Py_NE)) { Py_RETURN_NOTIMPLEMENTED; } int res = map_eq((BaseMapObject *)v, (BaseMapObject *)w); if (res < 0) { return NULL; } if (op == Py_NE) { res = !res; } if (res) { Py_RETURN_TRUE; } else { Py_RETURN_FALSE; } } static PyObject * mapmut_py_update(MapMutationObject *self, PyObject *args, PyObject *kwds) { PyObject *arg = NULL; if (!PyArg_UnpackTuple(args, "update", 0, 1, &arg)) { return NULL; } if (mapmut_check_finalized(self)) { return NULL; } if (arg != NULL) { if (map_update_inplace(self->m_mutid, (BaseMapObject *)self, arg)) { return NULL; } } if (kwds != NULL) { if (!PyArg_ValidateKeywordArguments(kwds)) { return NULL; } if (map_update_inplace(self->m_mutid, (BaseMapObject *)self, kwds)) { return NULL; } } Py_RETURN_NONE; } static PyObject * mapmut_py_finish(MapMutationObject *self, PyObject *args) { if (mapmut_finish(self)) { return NULL; } MapObject *o = map_alloc(); if (o == NULL) { return NULL; } Py_INCREF(self->m_root); o->h_root = self->m_root; o->h_count = self->m_count; return (PyObject *)o; } static PyObject * mapmut_py_enter(MapMutationObject *self, PyObject *args) { Py_INCREF(self); return (PyObject *)self; } static PyObject * mapmut_py_exit(MapMutationObject *self, PyObject *args) { if (mapmut_finish(self)) { return NULL; } Py_RETURN_FALSE; } static int mapmut_tp_ass_sub(MapMutationObject *self, PyObject *key, PyObject *val) { if (mapmut_check_finalized(self)) { return -1; } int32_t key_hash = map_hash(key); if (key_hash == -1) { return -1; } if (val == NULL) { return mapmut_delete(self, key, key_hash); } else { return mapmut_set(self, key, key_hash, val); } } static PyObject * mapmut_py_pop(MapMutationObject *self, PyObject *args) { PyObject *key, *deflt = NULL, *val = NULL; if(!PyArg_UnpackTuple(args, "pop", 1, 2, &key, &deflt)) { return NULL; } if (mapmut_check_finalized(self)) { return NULL; } if (!self->m_count) { goto not_found; } int32_t key_hash = map_hash(key); if (key_hash == -1) { return NULL; } map_find_t find_res = map_node_find(self->m_root, 0, key_hash, key, &val); switch (find_res) { case F_ERROR: return NULL; case F_NOT_FOUND: goto not_found; case F_FOUND: break; default: abort(); } Py_INCREF(val); if (mapmut_delete(self, key, key_hash)) { Py_DECREF(val); return NULL; } return val; not_found: if (deflt) { Py_INCREF(deflt); return deflt; } PyErr_SetObject(PyExc_KeyError, key); return NULL; } static PyMethodDef MapMutation_methods[] = { {"set", (PyCFunction)mapmut_py_set, METH_VARARGS, NULL}, {"get", (PyCFunction)map_py_get, METH_VARARGS, NULL}, {"pop", (PyCFunction)mapmut_py_pop, METH_VARARGS, NULL}, {"finish", (PyCFunction)mapmut_py_finish, METH_NOARGS, NULL}, {"update", (PyCFunction)mapmut_py_update, METH_VARARGS | METH_KEYWORDS, NULL}, {"__enter__", (PyCFunction)mapmut_py_enter, METH_NOARGS, NULL}, {"__exit__", (PyCFunction)mapmut_py_exit, METH_VARARGS, NULL}, {NULL, NULL} }; static PySequenceMethods MapMutation_as_sequence = { 0, /* sq_length */ 0, /* sq_concat */ 0, /* sq_repeat */ 0, /* sq_item */ 0, /* sq_slice */ 0, /* sq_ass_item */ 0, /* sq_ass_slice */ (objobjproc)map_tp_contains, /* sq_contains */ 0, /* sq_inplace_concat */ 0, /* sq_inplace_repeat */ }; static PyMappingMethods MapMutation_as_mapping = { (lenfunc)map_tp_len, /* mp_length */ (binaryfunc)map_tp_subscript, /* mp_subscript */ (objobjargproc)mapmut_tp_ass_sub, /* mp_subscript */ }; PyTypeObject _MapMutation_Type = { PyVarObject_HEAD_INIT(NULL, 0) "immutables._map.MapMutation", sizeof(MapMutationObject), .tp_methods = MapMutation_methods, .tp_as_mapping = &MapMutation_as_mapping, .tp_as_sequence = &MapMutation_as_sequence, .tp_dealloc = (destructor)map_tp_dealloc, .tp_getattro = PyObject_GenericGetAttr, .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, .tp_traverse = (traverseproc)map_tp_traverse, .tp_richcompare = mapmut_tp_richcompare, .tp_clear = (inquiry)map_tp_clear, .tp_weaklistoffset = offsetof(MapMutationObject, m_weakreflist), .tp_repr = (reprfunc)map_py_repr, .tp_hash = PyObject_HashNotImplemented, }; /////////////////////////////////// Tree Node Types PyTypeObject _Map_ArrayNode_Type = { PyVarObject_HEAD_INIT(NULL, 0) "map_array_node", sizeof(MapNode_Array), 0, .tp_dealloc = (destructor)map_node_array_dealloc, .tp_getattro = PyObject_GenericGetAttr, .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, .tp_traverse = (traverseproc)map_node_array_traverse, .tp_free = PyObject_GC_Del, .tp_hash = PyObject_HashNotImplemented, }; PyTypeObject _Map_BitmapNode_Type = { PyVarObject_HEAD_INIT(NULL, 0) "map_bitmap_node", sizeof(MapNode_Bitmap) - sizeof(PyObject *), sizeof(PyObject *), .tp_dealloc = (destructor)map_node_bitmap_dealloc, .tp_getattro = PyObject_GenericGetAttr, .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, .tp_traverse = (traverseproc)map_node_bitmap_traverse, .tp_free = PyObject_GC_Del, .tp_hash = PyObject_HashNotImplemented, }; PyTypeObject _Map_CollisionNode_Type = { PyVarObject_HEAD_INIT(NULL, 0) "map_collision_node", sizeof(MapNode_Collision) - sizeof(PyObject *), sizeof(PyObject *), .tp_dealloc = (destructor)map_node_collision_dealloc, .tp_getattro = PyObject_GenericGetAttr, .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, .tp_traverse = (traverseproc)map_node_collision_traverse, .tp_free = PyObject_GC_Del, .tp_hash = PyObject_HashNotImplemented, }; static void module_free(void *m) { Py_CLEAR(_empty_bitmap_node); } static struct PyModuleDef _mapmodule = { PyModuleDef_HEAD_INIT, /* m_base */ "_map", /* m_name */ NULL, /* m_doc */ -1, /* m_size */ NULL, /* m_methods */ NULL, /* m_slots */ NULL, /* m_traverse */ NULL, /* m_clear */ module_free, /* m_free */ }; PyMODINIT_FUNC PyInit__map(void) { PyObject *m = PyModule_Create(&_mapmodule); if ((PyType_Ready(&_Map_Type) < 0) || (PyType_Ready(&_MapMutation_Type) < 0) || (PyType_Ready(&_Map_ArrayNode_Type) < 0) || (PyType_Ready(&_Map_BitmapNode_Type) < 0) || (PyType_Ready(&_Map_CollisionNode_Type) < 0) || (PyType_Ready(&_MapKeys_Type) < 0) || (PyType_Ready(&_MapValues_Type) < 0) || (PyType_Ready(&_MapItems_Type) < 0) || (PyType_Ready(&_MapKeysIter_Type) < 0) || (PyType_Ready(&_MapValuesIter_Type) < 0) || (PyType_Ready(&_MapItemsIter_Type) < 0)) { return 0; } Py_INCREF(&_Map_Type); if (PyModule_AddObject(m, "Map", (PyObject *)&_Map_Type) < 0) { Py_DECREF(&_Map_Type); return NULL; } return m; }