/* set object implementation

Written and maintained by Raymond D. Hettinger <[email protected]>

Derived from Objects/dictobject.c.

The basic lookup function used by all operations.

This is based on Algorithm D from Knuth Vol. 3, Sec. 6.4.

The initial probe index is computed as hash mod the table size.

Subsequent probe indices are computed as explained in Objects/dictobject.c.

To improve cache locality, each probe inspects a series of consecutive

nearby entries before moving on to probes elsewhere in memory. This leaves

us with a hybrid of linear probing and randomized probing. The linear probing

reduces the cost of hash collisions because consecutive memory accesses

tend to be much cheaper than scattered probes. After LINEAR_PROBES steps,

we then use more of the upper bits from the hash value and apply a simple

linear congruential random number generator. This helps break-up long

chains of collisions.

All arithmetic on hash should ignore overflow.

Unlike the dictionary implementation, the lookkey function can return

NULL if the rich comparison returns an error.

Use cases for sets differ considerably from dictionaries where looked-up

keys are more likely to be present. In contrast, sets are primarily

about membership testing where the presence of an element is not known in

advance. Accordingly, the set implementation needs to optimize for both

the found and not-found case.

*/

#include "Python.h"

#include "pycore_ceval.h" // _PyEval_GetBuiltin()

#include "pycore_critical_section.h" // Py_BEGIN_CRITICAL_SECTION, Py_END_CRITICAL_SECTION

#include "pycore_dict.h" // _PyDict_Contains_KnownHash()

#include "pycore_modsupport.h" // _PyArg_NoKwnames()

#include "pycore_object.h" // _PyObject_GC_UNTRACK()

#include "pycore_pyatomic_ft_wrappers.h" // FT_ATOMIC_LOAD_SSIZE_RELAXED()

#include "pycore_pyerrors.h" // _PyErr_SetKeyError()

#include "pycore_setobject.h" // _PySet_NextEntry() definition

#include "pycore_weakref.h" // FT_CLEAR_WEAKREFS()

#include "stringlib/eq.h" // unicode_eq()

#include <stddef.h> // offsetof()

#include "clinic/setobject.c.h"

/*[clinic input]

class set "PySetObject *" "&PySet_Type"

class frozenset "PySetObject *" "&PyFrozenSet_Type"

[clinic start generated code]*/

/*[clinic end generated code: output=da39a3ee5e6b4b0d input=97ad1d3e9f117079]*/

/*[python input]

class setobject_converter(self_converter):

type = "PySetObject *"

[python start generated code]*/

/*[python end generated code: output=da39a3ee5e6b4b0d input=33a44506d4d57793]*/

/* Object used as dummy key to fill deleted entries */

static PyObject _dummy_struct;

#define dummy (&_dummy_struct)

#define SET_LOOKKEY_FOUND 1

#define SET_LOOKKEY_NO_MATCH 0

#define SET_LOOKKEY_ERROR (-1)

#define SET_LOOKKEY_CHANGED (-2)

#define SET_LOOKKEY_EMPTY (-3)

typedef int (*compare_func)(PySetObject *so, setentry *table, setentry *ep,

PyObject *key, Py_hash_t hash);

#ifdef Py_GIL_DISABLED

#define SET_IS_SHARED(so) _PyObject_GC_IS_SHARED(so)

#define SET_MARK_SHARED(so) _PyObject_GC_SET_SHARED(so)

static void

ensure_shared_on_read(PySetObject *so)

{

if (!_Py_IsOwnedByCurrentThread((PyObject *)so) && !SET_IS_SHARED(so)) {

// The first time we access a set from a non-owning thread we mark it

// as shared. This ensures that a concurrent resize operation will

// delay freeing the old entries using QSBR, which is necessary

// to safely allow concurrent reads without locking...

Py_BEGIN_CRITICAL_SECTION(so);

if (!SET_IS_SHARED(so)) {

SET_MARK_SHARED(so);

}

Py_END_CRITICAL_SECTION();

}

}

static inline Py_ALWAYS_INLINE int

set_compare_threadsafe(PySetObject *so, setentry *table, setentry *ep,

PyObject *key, Py_hash_t hash)

{

PyObject *startkey = FT_ATOMIC_LOAD_PTR_ACQUIRE(ep->key);

if (startkey == NULL) {

return SET_LOOKKEY_EMPTY;

}

if (startkey == key) {

return SET_LOOKKEY_FOUND;

}

Py_ssize_t ep_hash = FT_ATOMIC_LOAD_SSIZE_ACQUIRE(ep->hash);

if (ep_hash == hash) {

if (!_Py_TryIncrefCompare(&ep->key, startkey)) {

return SET_LOOKKEY_CHANGED;

}

int cmp = PyObject_RichCompareBool(startkey, key, Py_EQ);

Py_DECREF(startkey);

if (cmp < 0) {

return SET_LOOKKEY_ERROR;

}

if (table == FT_ATOMIC_LOAD_PTR_ACQUIRE(so->table) &&

startkey == FT_ATOMIC_LOAD_PTR_ACQUIRE(ep->key)) {

assert(cmp == SET_LOOKKEY_FOUND || cmp == SET_LOOKKEY_NO_MATCH);

return cmp;

}

else {

/* The set was mutated, restart */

return SET_LOOKKEY_CHANGED;

}

}

return SET_LOOKKEY_NO_MATCH;

}

#else

#define SET_IS_SHARED(so) 0

#define SET_MARK_SHARED(so)

#endif

static inline Py_ALWAYS_INLINE int

set_compare_entry_lock_held(PySetObject *so, setentry *table, setentry *entry,

PyObject *key, Py_hash_t hash)

{

_Py_CRITICAL_SECTION_ASSERT_OBJECT_LOCKED(so);

if (entry->hash == 0 && entry->key == NULL)

return SET_LOOKKEY_EMPTY;

if (entry->hash == hash) {

PyObject *startkey = entry->key;

assert(startkey != dummy);

if (startkey == key)

return SET_LOOKKEY_FOUND;

if (PyUnicode_CheckExact(startkey)

&& PyUnicode_CheckExact(key)

&& unicode_eq(startkey, key))

return SET_LOOKKEY_FOUND;

table = so->table;

Py_INCREF(startkey);

int cmp = PyObject_RichCompareBool(startkey, key, Py_EQ);

Py_DECREF(startkey);

if (cmp < 0)

return SET_LOOKKEY_ERROR;

if (table != so->table || entry->key != startkey)

return SET_LOOKKEY_CHANGED;

if (cmp > 0)

return SET_LOOKKEY_FOUND;

}

return SET_LOOKKEY_NO_MATCH;

}

// This is similar to set_compare_entry_lock_held() but we don't need to

// incref startkey before comparing and we don't need to check if the set has

// changed. This also omits the PyUnicode_CheckExact() special case since it

// doesn't help much for frozensets.

static inline Py_ALWAYS_INLINE int

set_compare_frozenset(PySetObject *so, setentry *table, setentry *ep,

PyObject *key, Py_hash_t hash)

{

assert(PyFrozenSet_Check(so));

PyObject *startkey = ep->key;

if (startkey == NULL) {

return SET_LOOKKEY_EMPTY;

}

if (startkey == key) {

return SET_LOOKKEY_FOUND;

}

Py_ssize_t ep_hash = ep->hash;

if (ep_hash == hash) {

int cmp = PyObject_RichCompareBool(startkey, key, Py_EQ);

if (cmp < 0) {

return SET_LOOKKEY_ERROR;

}

assert(cmp == SET_LOOKKEY_FOUND || cmp == SET_LOOKKEY_NO_MATCH);

return cmp;

}

return SET_LOOKKEY_NO_MATCH;

}

static void

set_zero_table(setentry *table, size_t size)

{

#ifdef Py_GIL_DISABLED

for (size_t i = 0; i < size; i++) {

setentry *entry = &table[i];

FT_ATOMIC_STORE_SSIZE_RELAXED(entry->hash, 0);

FT_ATOMIC_STORE_PTR_RELEASE(entry->key, NULL);

}

#else

memset(table, 0, sizeof(setentry)*size);

#endif

}

/* ======================================================================== */

/* ======= Begin logic for probing the hash table ========================= */

/* Set this to zero to turn-off linear probing */

#ifndef LINEAR_PROBES

#define LINEAR_PROBES 9

#endif

/* This must be >= 1 */

#define PERTURB_SHIFT 5

static int

set_do_lookup(PySetObject *so, setentry *table, size_t mask, PyObject *key,

Py_hash_t hash, setentry **epp, compare_func compare_entry)

{

setentry *entry;

size_t perturb = hash;

size_t i = (size_t)hash & mask; /* Unsigned for defined overflow behavior */

int probes;

int status;

while (1) {

entry = &table[i];

probes = (i + LINEAR_PROBES <= mask) ? LINEAR_PROBES: 0;

do {

status = compare_entry(so, table, entry, key, hash);

if (status != SET_LOOKKEY_NO_MATCH) {

if (status == SET_LOOKKEY_EMPTY) {

return SET_LOOKKEY_NO_MATCH;

}

*epp = entry;

return status;

}

entry++;

} while (probes--);

perturb >>= PERTURB_SHIFT;

i = (i * 5 + 1 + perturb) & mask;

}

Py_UNREACHABLE();

}

static int set_table_resize(PySetObject *, Py_ssize_t);

static int

set_add_entry_takeref(PySetObject *so, PyObject *key, Py_hash_t hash)

{

setentry *table;

setentry *freeslot;

setentry *entry;

size_t perturb;

size_t mask;

size_t i; /* Unsigned for defined overflow behavior */

int probes;

int cmp;

restart:

mask = so->mask;

i = (size_t)hash & mask;

freeslot = NULL;

perturb = hash;

while (1) {

entry = &so->table[i];

probes = (i + LINEAR_PROBES <= mask) ? LINEAR_PROBES: 0;

do {

if (entry->hash == 0 && entry->key == NULL)

goto found_unused_or_dummy;

if (entry->hash == hash) {

PyObject *startkey = entry->key;

assert(startkey != dummy);

if (startkey == key)

goto found_active;

if (PyUnicode_CheckExact(startkey)

&& PyUnicode_CheckExact(key)

&& unicode_eq(startkey, key))

goto found_active;

table = so->table;

Py_INCREF(startkey);

cmp = PyObject_RichCompareBool(startkey, key, Py_EQ);

Py_DECREF(startkey);

if (cmp > 0)

goto found_active;

if (cmp < 0)

goto comparison_error;

if (table != so->table || entry->key != startkey)

goto restart;

mask = so->mask;

}

else if (entry->hash == -1) {

assert (entry->key == dummy);

freeslot = entry;

}

entry++;

} while (probes--);

perturb >>= PERTURB_SHIFT;

i = (i * 5 + 1 + perturb) & mask;

}

found_unused_or_dummy:

if (freeslot == NULL)

goto found_unused;

if (freeslot->hash != -1) {

goto restart;

}

FT_ATOMIC_STORE_SSIZE_RELAXED(so->used, so->used + 1);

FT_ATOMIC_STORE_SSIZE_RELAXED(freeslot->hash, hash);

FT_ATOMIC_STORE_PTR_RELEASE(freeslot->key, key);

return 0;

found_unused:

so->fill++;

FT_ATOMIC_STORE_SSIZE_RELAXED(so->used, so->used + 1);

FT_ATOMIC_STORE_SSIZE_RELAXED(entry->hash, hash);

FT_ATOMIC_STORE_PTR_RELEASE(entry->key, key);

if ((size_t)so->fill*5 < mask*3)

return 0;

return set_table_resize(so, so->used>50000 ? so->used*2 : so->used*4);

found_active:

Py_DECREF(key);

return 0;

comparison_error:

Py_DECREF(key);

return -1;

}

static int

set_add_entry(PySetObject *so, PyObject *key, Py_hash_t hash)

{

_Py_CRITICAL_SECTION_ASSERT_OBJECT_LOCKED(so);

return set_add_entry_takeref(so, Py_NewRef(key), hash);

}

static void

set_unhashable_type(PyObject *key)

{

PyObject *exc = PyErr_GetRaisedException();

assert(exc != NULL);

if (!Py_IS_TYPE(exc, (PyTypeObject*)PyExc_TypeError)) {

PyErr_SetRaisedException(exc);

return;

}

PyErr_Format(PyExc_TypeError,

"cannot use '%T' as a set element (%S)",

key, exc);

Py_DECREF(exc);

}

int

_PySet_AddTakeRef(PySetObject *so, PyObject *key)

{

Py_hash_t hash = _PyObject_HashFast(key);

if (hash == -1) {

set_unhashable_type(key);

Py_DECREF(key);

return -1;

}

// We don't pre-increment here, the caller holds a strong

// reference to the object which we are stealing.

return set_add_entry_takeref(so, key, hash);

}

/*

Internal routine used by set_table_resize() to insert an item which is

known to be absent from the set. Besides the performance benefit,

there is also safety benefit since using set_add_entry() risks making

a callback in the middle of a set_table_resize(), see issue 1456209.

The caller is responsible for updating the key's reference count and

the setobject's fill and used fields.

*/

static void

set_insert_clean(setentry *table, size_t mask, PyObject *key, Py_hash_t hash)

{

setentry *entry;

size_t perturb = hash;

size_t i = (size_t)hash & mask;

size_t j;

while (1) {

entry = &table[i];

if (entry->key == NULL)

goto found_null;

if (i + LINEAR_PROBES <= mask) {

for (j = 0; j < LINEAR_PROBES; j++) {

entry++;

if (entry->key == NULL)

goto found_null;

}

}

perturb >>= PERTURB_SHIFT;

i = (i * 5 + 1 + perturb) & mask;

}

found_null:

FT_ATOMIC_STORE_SSIZE_RELAXED(entry->hash, hash);

FT_ATOMIC_STORE_PTR_RELEASE(entry->key, key);

}

/* ======== End logic for probing the hash table ========================== */

/* ======================================================================== */

static int

set_lookkey(PySetObject *so, PyObject *key, Py_hash_t hash, setentry **epp)

{

int status;

if (PyFrozenSet_CheckExact(so)) {

status = set_do_lookup(so, so->table, so->mask, key, hash, epp,

set_compare_frozenset);

}

else {

Py_BEGIN_CRITICAL_SECTION(so);

do {

status = set_do_lookup(so, so->table, so->mask, key, hash, epp,

set_compare_entry_lock_held);

} while (status == SET_LOOKKEY_CHANGED);

Py_END_CRITICAL_SECTION();

}

assert(status == SET_LOOKKEY_FOUND ||

status == SET_LOOKKEY_NO_MATCH ||

status == SET_LOOKKEY_ERROR);

return status;

}

#ifdef Py_GIL_DISABLED

static int

set_lookkey_threadsafe(PySetObject *so, PyObject *key, Py_hash_t hash)

{

int status;

setentry *entry;

if (PyFrozenSet_CheckExact(so)) {

status = set_do_lookup(so, so->table, so->mask, key, hash, &entry,

set_compare_frozenset);

assert(status == SET_LOOKKEY_FOUND ||

status == SET_LOOKKEY_NO_MATCH ||

status == SET_LOOKKEY_ERROR);

return status;

}

ensure_shared_on_read(so);

setentry *table = FT_ATOMIC_LOAD_PTR_ACQUIRE(so->table);

size_t mask = FT_ATOMIC_LOAD_SSIZE_ACQUIRE(so->mask);

if (table == NULL || table != FT_ATOMIC_LOAD_PTR_ACQUIRE(so->table)) {

return set_lookkey(so, key, hash, &entry);

}

status = set_do_lookup(so, table, mask, key, hash, &entry,

set_compare_threadsafe);

if (status == SET_LOOKKEY_CHANGED) {

return set_lookkey(so, key, hash, &entry);

}

assert(status == SET_LOOKKEY_FOUND ||

status == SET_LOOKKEY_NO_MATCH ||

status == SET_LOOKKEY_ERROR);

return status;

}

#endif

static void free_entries(setentry *entries, size_t size, bool use_qsbr)

{

#ifdef Py_GIL_DISABLED

if (use_qsbr) {

_PyMem_FreeDelayed(entries, size * sizeof(setentry));

return;

}

#endif

PyMem_Free(entries);

}

/*

Restructure the table by allocating a new table and reinserting all

keys again. When entries have been deleted, the new table may

actually be smaller than the old one.

*/

static int

set_table_resize(PySetObject *so, Py_ssize_t minused)

{

setentry *oldtable, *newtable, *entry;

Py_ssize_t oldmask = so->mask;

Py_ssize_t oldsize = (size_t)oldmask + 1;

size_t newmask;

int is_oldtable_malloced;

setentry small_copy[PySet_MINSIZE];

assert(minused >= 0);

/* Find the smallest table size > minused. */

/* XXX speed-up with intrinsics */

size_t newsize = PySet_MINSIZE;

while (newsize <= (size_t)minused) {

newsize <<= 1; // The largest possible value is PY_SSIZE_T_MAX + 1.

}

/* Get space for a new table. */

oldtable = so->table;

assert(oldtable != NULL);

is_oldtable_malloced = oldtable != so->smalltable;

if (newsize == PySet_MINSIZE) {

/* A large table is shrinking, or we can't get any smaller. */

newtable = so->smalltable;

if (newtable == oldtable) {

if (so->fill == so->used) {

/* No dummies, so no point doing anything. */

return 0;

}

/* We're not going to resize it, but rebuild the

table anyway to purge old dummy entries.

Subtle: This is *necessary* if fill==size,

as set_lookkey needs at least one virgin slot to

terminate failing searches. If fill < size, it's

merely desirable, as dummies slow searches. */

assert(so->fill > so->used);

memcpy(small_copy, oldtable, sizeof(small_copy));

oldtable = small_copy;

}

}

else {

newtable = PyMem_NEW(setentry, newsize);

if (newtable == NULL) {

PyErr_NoMemory();

return -1;

}

}

/* Make the set empty, using the new table. */

assert(newtable != oldtable);

set_zero_table(newtable, newsize);

FT_ATOMIC_STORE_PTR_RELEASE(so->table, NULL);

FT_ATOMIC_STORE_SSIZE_RELEASE(so->mask, newsize - 1);

/* Copy the data over; this is refcount-neutral for active entries;

dummy entries aren't copied over, of course */

newmask = (size_t)so->mask;

if (so->fill == so->used) {

for (entry = oldtable; entry <= oldtable + oldmask; entry++) {

if (entry->key != NULL) {

set_insert_clean(newtable, newmask, entry->key, entry->hash);

}

}

} else {

so->fill = so->used;

for (entry = oldtable; entry <= oldtable + oldmask; entry++) {

if (entry->key != NULL && entry->key != dummy) {

set_insert_clean(newtable, newmask, entry->key, entry->hash);

}

}

}

FT_ATOMIC_STORE_PTR_RELEASE(so->table, newtable);

if (is_oldtable_malloced)

free_entries(oldtable, oldsize, SET_IS_SHARED(so));

return 0;

}

static int

set_contains_entry(PySetObject *so, PyObject *key, Py_hash_t hash)

{

#ifdef Py_GIL_DISABLED

return set_lookkey_threadsafe(so, key, hash);

#else

setentry *entry; // unused

return set_lookkey(so, key, hash, &entry);

#endif

}

#define DISCARD_NOTFOUND 0

#define DISCARD_FOUND 1

static int

set_discard_entry(PySetObject *so, PyObject *key, Py_hash_t hash)

{

setentry *entry;

PyObject *old_key;

int status = set_lookkey(so, key, hash, &entry);

if (status < 0) {

return -1;

}

if (status == SET_LOOKKEY_NO_MATCH) {

return DISCARD_NOTFOUND;

}

assert(status == SET_LOOKKEY_FOUND);

old_key = entry->key;

FT_ATOMIC_STORE_SSIZE_RELAXED(entry->hash, -1);

FT_ATOMIC_STORE_SSIZE_RELAXED(so->used, so->used - 1);

FT_ATOMIC_STORE_PTR_RELEASE(entry->key, dummy);

Py_DECREF(old_key);

return DISCARD_FOUND;

}

static int

set_add_key(PySetObject *so, PyObject *key)

{

Py_hash_t hash = _PyObject_HashFast(key);

if (hash == -1) {

set_unhashable_type(key);

return -1;

}

return set_add_entry(so, key, hash);

}

static int

set_contains_key(PySetObject *so, PyObject *key)

{

Py_hash_t hash = _PyObject_HashFast(key);

if (hash == -1) {

set_unhashable_type(key);

return -1;

}

return set_contains_entry(so, key, hash);

}

static int

set_discard_key(PySetObject *so, PyObject *key)

{

Py_hash_t hash = _PyObject_HashFast(key);

if (hash == -1) {

set_unhashable_type(key);

return -1;

}

return set_discard_entry(so, key, hash);

}

static void

set_empty_to_minsize(PySetObject *so)

{

FT_ATOMIC_STORE_PTR_RELEASE(so->table, NULL);

set_zero_table(so->smalltable, PySet_MINSIZE);

so->fill = 0;

FT_ATOMIC_STORE_SSIZE_RELAXED(so->used, 0);

FT_ATOMIC_STORE_SSIZE_RELEASE(so->mask, PySet_MINSIZE - 1);

FT_ATOMIC_STORE_SSIZE_RELAXED(so->hash, -1);

FT_ATOMIC_STORE_PTR_RELEASE(so->table, so->smalltable);

}

static int

set_clear_internal(PyObject *self)

{

PySetObject *so = _PySet_CAST(self);

setentry *entry;

setentry *table = so->table;

Py_ssize_t fill = so->fill;

Py_ssize_t used = so->used;

Py_ssize_t oldsize = (size_t)so->mask + 1;

int table_is_malloced = table != so->smalltable;

setentry small_copy[PySet_MINSIZE];

assert (PyAnySet_Check(so));

assert(table != NULL);

/* This is delicate. During the process of clearing the set,

* decrefs can cause the set to mutate. To avoid fatal confusion

* (voice of experience), we have to make the set empty before

* clearing the slots, and never refer to anything via so->ref while

* clearing.

*/

if (table_is_malloced)

set_empty_to_minsize(so);

else if (fill > 0) {

/* It's a small table with something that needs to be cleared.

* Afraid the only safe way is to copy the set entries into

* another small table first.

*/

memcpy(small_copy, table, sizeof(small_copy));

table = small_copy;

set_empty_to_minsize(so);

}

/* else it's a small table that's already empty */

/* Now we can finally clear things. If C had refcounts, we could

* assert that the refcount on table is 1 now, i.e. that this function

* has unique access to it, so decref side-effects can't alter it.

*/

for (entry = table; used > 0; entry++) {

if (entry->key && entry->key != dummy) {

used--;

Py_DECREF(entry->key);

}

}

if (table_is_malloced)

free_entries(table, oldsize, SET_IS_SHARED(so));

return 0;

}

/*

* Iterate over a set table. Use like so:

*

* Py_ssize_t pos;

* setentry *entry;

* pos = 0; # important! pos should not otherwise be changed by you

* while (set_next(yourset, &pos, &entry)) {

* Refer to borrowed reference in entry->key.

* }

*

* CAUTION: In general, it isn't safe to use set_next in a loop that

* mutates the table.

*/

static int

set_next(PySetObject *so, Py_ssize_t *pos_ptr, setentry **entry_ptr)

{

Py_ssize_t i;

Py_ssize_t mask;

setentry *entry;

assert (PyAnySet_Check(so));

i = *pos_ptr;

assert(i >= 0);

mask = so->mask;

entry = &so->table[i];

while (i <= mask && (entry->key == NULL || entry->key == dummy)) {

i++;

entry++;

}

*pos_ptr = i+1;

if (i > mask)

return 0;

assert(entry != NULL);

*entry_ptr = entry;

return 1;

}

static void

set_dealloc(PyObject *self)

{

PySetObject *so = _PySet_CAST(self);

setentry *entry;

Py_ssize_t used = so->used;

Py_ssize_t oldsize = (size_t)so->mask + 1;

/* bpo-31095: UnTrack is needed before calling any callbacks */

PyObject_GC_UnTrack(so);

FT_CLEAR_WEAKREFS(self, so->weakreflist);

for (entry = so->table; used > 0; entry++) {

if (entry->key && entry->key != dummy) {

used--;

Py_DECREF(entry->key);

}

}

if (so->table != so->smalltable)

free_entries(so->table, oldsize, SET_IS_SHARED(so));

Py_TYPE(so)->tp_free(so);

}

static PyObject *

set_repr_lock_held(PySetObject *so)

{

PyObject *result=NULL, *keys, *listrepr, *tmp;

int status = Py_ReprEnter((PyObject*)so);

if (status != 0) {

if (status < 0)

return NULL;

return PyUnicode_FromFormat("%s(...)", Py_TYPE(so)->tp_name);

}

/* shortcut for the empty set */

if (!so->used) {

Py_ReprLeave((PyObject*)so);

return PyUnicode_FromFormat("%s()", Py_TYPE(so)->tp_name);

}

// gh-129967: avoid PySequence_List because it might re-lock the object

// lock or the GIL and allow something to clear the set from underneath us.

keys = PyList_New(so->used);

if (keys == NULL) {

goto done;

}

Py_ssize_t pos = 0, idx = 0;

setentry *entry;

while (set_next(so, &pos, &entry)) {

PyList_SET_ITEM(keys, idx++, Py_NewRef(entry->key));

}

/* repr(keys)[1:-1] */

listrepr = PyObject_Repr(keys);

Py_DECREF(keys);

if (listrepr == NULL)

goto done;

tmp = PyUnicode_Substring(listrepr, 1, PyUnicode_GET_LENGTH(listrepr)-1);

Py_DECREF(listrepr);

if (tmp == NULL)

goto done;

listrepr = tmp;

if (!PySet_CheckExact(so))

result = PyUnicode_FromFormat("%s({%U})",

Py_TYPE(so)->tp_name,

listrepr);

else

result = PyUnicode_FromFormat("{%U}", listrepr);

Py_DECREF(listrepr);

done:

Py_ReprLeave((PyObject*)so);

return result;

}

static PyObject *

set_repr(PyObject *self)

{

PySetObject *so = _PySet_CAST(self);

PyObject *result;

Py_BEGIN_CRITICAL_SECTION(so);

result = set_repr_lock_held(so);

Py_END_CRITICAL_SECTION();

return result;

}

static Py_ssize_t

set_len(PyObject *self)

{

PySetObject *so = _PySet_CAST(self);

return FT_ATOMIC_LOAD_SSIZE_RELAXED(so->used);

}

static int

set_merge_lock_held(PySetObject *so, PyObject *otherset)

{

PySetObject *other;

PyObject *key;

Py_ssize_t i;

setentry *so_entry;

setentry *other_entry;

assert (PyAnySet_Check(so));

_Py_CRITICAL_SECTION_ASSERT_OBJECT_LOCKED(so);

_Py_CRITICAL_SECTION_ASSERT_OBJECT_LOCKED(otherset);

other = _PySet_CAST(otherset);

if (other == so || other->used == 0)

/* a.update(a) or a.update(set()); nothing to do */

return 0;

/* Do one big resize at the start, rather than

* incrementally resizing as we insert new keys. Expect

* that there will be no (or few) overlapping keys.

*/

if ((so->fill + other->used)*5 >= so->mask*3) {

if (set_table_resize(so, (so->used + other->used)*2) != 0)

return -1;

}

so_entry = so->table;

other_entry = other->table;

/* If our table is empty, and both tables have the same size, and

there are no dummies to eliminate, then just copy the pointers. */

if (so->fill == 0 && so->mask == other->mask && other->fill == other->used) {

for (i = 0; i <= other->mask; i++, so_entry++, other_entry++) {

key = other_entry->key;

if (key != NULL) {

assert(so_entry->key == NULL);

FT_ATOMIC_STORE_SSIZE_RELAXED(so_entry->hash, other_entry->hash);

FT_ATOMIC_STORE_PTR_RELEASE(so_entry->key, Py_NewRef(key));

}

}

so->fill = other->fill;

FT_ATOMIC_STORE_SSIZE_RELAXED(so->used, other->used);

return 0;

}

/* If our table is empty, we can use set_insert_clean() */

if (so->fill == 0) {

setentry *newtable = so->table;

size_t newmask = (size_t)so->mask;

so->fill = other->used;

FT_ATOMIC_STORE_SSIZE_RELAXED(so->used, other->used);

for (i = other->mask + 1; i > 0 ; i--, other_entry++) {

key = other_entry->key;

if (key != NULL && key != dummy) {

set_insert_clean(newtable, newmask, Py_NewRef(key),

other_entry->hash);

}

}

return 0;

}

/* We can't assure there are no duplicates, so do normal insertions */

for (i = 0; i <= other->mask; i++) {

other_entry = &other->table[i];

key = other_entry->key;

if (key != NULL && key != dummy) {

if (set_add_entry(so, key, other_entry->hash))

return -1;

}

}

return 0;

}

/*[clinic input]

@critical_section

set.pop

so: setobject

Remove and return an arbitrary set element.

Raises KeyError if the set is empty.

[clinic start generated code]*/

static PyObject *

set_pop_impl(PySetObject *so)

/*[clinic end generated code: output=4d65180f1271871b input=9296c84921125060]*/

{

/* Make sure the search finger is in bounds */

setentry *entry = so->table + (so->finger & so->mask);

setentry *limit = so->table + so->mask;

PyObject *key;

if (so->used == 0) {

PyErr_SetString(PyExc_KeyError, "pop from an empty set");

return NULL;

}

while (entry->key == NULL || entry->key==dummy) {

entry++;

if (entry > limit)

entry = so->table;

}

FT_ATOMIC_STORE_SSIZE_RELAXED(entry->hash, -1);

FT_ATOMIC_STORE_SSIZE_RELAXED(so->used, so->used - 1);

key = entry->key;

FT_ATOMIC_STORE_PTR_RELEASE(entry->key, dummy);

so->finger = entry - so->table + 1; /* next place to start */

return key;

}

static int

set_traverse(PyObject *self, visitproc visit, void *arg)

{

PySetObject *so = _PySet_CAST(self);

Py_ssize_t pos = 0;

setentry *entry;

while (set_next(so, &pos, &entry))

Py_VISIT(entry->key);

return 0;

}

/* Work to increase the bit dispersion for closely spaced hash values.

This is important because some use cases have many combinations of a

small number of elements with nearby hashes so that many distinct

combinations collapse to only a handful of distinct hash values. */

static Py_uhash_t

_shuffle_bits(Py_uhash_t h)

{

return ((h ^ 89869747UL) ^ (h << 16)) * 3644798167UL;

}

/* Most of the constants in this hash algorithm are randomly chosen

large primes with "interesting bit patterns" and that passed tests

for good collision statistics on a variety of problematic datasets

including powersets and graph structures (such as David Eppstein's

graph recipes in Lib/test/test_set.py).

This hash algorithm can be used on either a frozenset or a set.

When it is used on a set, it computes the hash value of the equivalent

frozenset without creating a new frozenset object.

If you update this code, update also frozendict_hash() which copied this

code. */

static Py_hash_t

frozenset_hash_impl(PyObject *self)

{

PySetObject *so = _PySet_CAST(self);

Py_uhash_t hash = 0;

setentry *entry;

/* Xor-in shuffled bits from every entry's hash field because xor is

commutative and a frozenset hash should be independent of order.

For speed, include null entries and dummy entries and then

subtract out their effect afterwards so that the final hash

depends only on active entries. This allows the code to be

vectorized by the compiler and it saves the unpredictable

branches that would arise when trying to exclude null and dummy

entries on every iteration. */

for (entry = so->table; entry <= &so->table[so->mask]; entry++)

hash ^= _shuffle_bits(entry->hash);

/* Remove the effect of an odd number of NULL entries */

if ((so->mask + 1 - so->fill) & 1)

hash ^= _shuffle_bits(0);

/* Remove the effect of an odd number of dummy entries */

if ((so->fill - so->used) & 1)

hash ^= _shuffle_bits(-1);

/* Factor in the number of active entries */