Skip to main content

SmashTable

SmashTable makes one update span several containers. Either every change lands or none does: a group stages into every container or into none, and a commit spanning two or more of them asks each for permission before the first one writes. A partitioned container is the one that cannot be asked, so a group holding one publishes its participants in turn. It's implemented in C++ 20 as header-only templates, and exposed to Python 3 through the raw CPython API.

Three std::maps cannot do this, and neither can three dicts. It needs no threads to be useful — the same guarantee that keeps two indexes consistent under contention is what keeps them consistent when an exception unwinds a loop halfway through.

SmashTable Thumbnail

What's Inside

  basic_*            → cores, single-threaded     vector · AVL · weight-balanced · hash
  atomic_*           → pinned, GPU-capable        hash
       ↑ ::adopt() moves one allocation between the two, no rehash, no copy

  *_store            → transactions over a core   monotonic · snapshot · reference
       ↓ wrap any of those for thread safety
  locked_store       → one lock per transaction
  partitioned_store  → one lock per partition, 16 by default

  transaction_group  → one commit spanning several stores

Every store publishes what it promises as a compile-time isolation_k, and the suite checks that constant against behaviour rather than against itself — a container that quietly changes level fails. Each rung implies the ones beneath it, so one column names the highest a store reaches rather than five ticking the same fact five times. Every row below the cores wraps something: a transactional store wraps a plain container, and either thread-safety wrapper wraps a store. So a usable type reads locked_store<snapshot_store<basic_avl_tree<…>>> for one lock over the whole store, or partitioned_store<…> for sixteen. Nesting the two wrappers is redundant rather than clever: every call would take an inner lock inside a partition lock that already excludes.

Isolation Writers Transactions Ordered
basic_vector — one thread — —
basic_avl_tree — one thread — ✔
basic_wb_tree — one thread — rank · select
basic_hash_table — one thread — —
atomic_hash_table — ⁴ per slot ⁴ — —
monotonic_store Monotonic Atomic View ⁶ one thread ✔ inherits
snapshot_store Snapshot ⁷ one thread ✔ inherits ²
serializable_store Serializable ⁸ one thread ✔ inherits ²
strict_serializable_store Strict Serializable ⁹ one thread ✔ inherits ²
reference_store ⁵ Monotonic Atomic View ⁶ one thread ✔ ✔
locked_store inherits one call ✔ inherits
partitioned_store inherits ¹ per partition ✔ inherits ³

¹ A stamp-based store keeps its level: one clock, and the watermark moves only once the last partition has published, so a reader sees a whole commit or none. A clock-less store has no stamp to hold, so only Read Committed survives; atomicity costs in proportion to the partitions touched. ² select and rank are exact at the newest commit; an older snapshot gets a merged walk, since one count per node cannot answer an unbounded parameter. ³ A bound, a range and an ordinal hold every partition's lock for the whole walk, so each is decided at one moment rather than by probes that can disagree. An unbounded enumeration takes one partition at a time and answers unordered, while the cursor behind iteration walks the merged order and holds no lock between its steps. ⁴ Per-slot spin locks: atomic over one slot and nothing wider, so size() is a relaxed read, a stalled thread blocks its slot, and there are no transactions. ⁵ A std::set-backed oracle: it installs alongside every other header, and the suites hold the tree containers against it. ⁶ Permits a lost update and a repeated read that moves. ⁷ Refuses both; permits write skew, since a read you did not watch is not validated. ⁸ Refuses write skew and phantoms too: every key and window read is re-checked at commit. ⁹ Same refusals as ⁸; strict also waits for its own publication, so a transaction opening after a commit cannot precede it — which changes only sharded commits and writes outside a transaction.

The ladder runs from Read Committed through Monotonic Atomic View and Snapshot Isolation to the two serializable rungs, and every level from Monotonic Atomic View upward is delivered by multi-version concurrency control: a key keeps one version per commit that touched it, a reader is answered from the newest version its own snapshot can name, and versions below the oldest live reader are reclaimed.

Python Quick Start

pip install smashtable

The wheel ships type stubs, so an editor completes the container methods and a checker rejects a misspelled isolation level or key layout before the call ever runs.

Two indexes over the same entities have to move together, or a lookup by name finds an identifier that no longer resolves:

import smashtable as st

by_id = st.SortedMap(key=int)     # entity id → record
by_name = st.SortedMap(key=str)   # name      → entity id

with st.transaction(by_id, by_name) as (ids, names):
    ids[42] = "carol"
    names["carol"] = 42
# both indexes became visible together

Each container is a mapping in its own right, so the usual vocabulary works:

list(by_id)                  # [42]           — keys, in order
dict(by_name)                # {'carol': 42}
by_id.items()                # a lazy view, not a copy
by_id.scan(0, 100)           # the half-open window [0, 100)

If the block raises, nothing was applied:

try:
    with st.transaction(by_id, by_name) as (ids, names):
        ids[43] = "dave"
        names["dave"] = 43
        raise ValueError("failed validation")
except ValueError:
    pass

assert 43 not in by_id and "dave" not in by_name

Without this, the alternative is an O(n) defensive copy that every alias to the container can still read through mid-update:

backup = dict(cache)                      # copies the whole thing
try:
    for key, value in updates.items():
        cache[key] = transform(value)     # raises on item 40 of 100
except Exception:
    cache.clear(); cache.update(backup)   # O(n) again, and readers already saw the torn state

Optimistic Concurrency

watch makes a transaction fail rather than overwrite a key someone else touched first. ConflictError is the retry signal, and the only exception a correct program is expected to catch routinely:

while True:
    try:
        with st.transaction(accounts) as (view,):
            view.watch("alice")
            view["alice"] = view["alice"] - 100
        break
    except st.ConflictError:
        continue    # nothing was applied, so retrying is safe

The Two Phases

with is exactly begin(), the body, stage(), commit(). Both phases are also available directly:

group = st.transaction(by_id, by_name)
ids, names = group.begin()
ids[42] = "carol"; names["carol"] = 42
group.stage()      # validates watches and reserves; still invisible, and may raise ConflictError
group.commit()     # flips visibility

Separating the fallible phase from the applying phase is what lets independent transactions compose into one all-or-nothing unit. stage is where a conflict or an allocation failure normally surfaces. Between the two the participants take no more writes: ids[43] = 'dave' after stage() raises StateError, since staging already reserved and validated what the transaction would change. A read still answers. commit validates again and can still refuse, because a watched key may be committed over while the group sits staged. A group of two or more containers, none of them partitioned, is asked in full before any of them writes, so a refusal there publishes nothing and leaves the group staged and retryable. A lone participant commits in one call, having nothing to tear against, and so does a group holding a sharing='partitioned' container, where a refusal part-way leaves the participants before it published. A refusal by the first participant asked has published nothing and leaves the group staged, which is the state rollback() accepts. A refusal by any later one returns the group to open — the position decides that, not whether anything was published — and reset() rather than rollback() clears what the rest still hold. Inside a with block the exit discards that remainder itself, so reset() is the remedy on the manual stage() and commit() path. Even where every participant is asked first, one of them may be committed over between the two passes: what the split buys is that the second pass cannot refuse, not that nothing moves beneath it.

What It Guarantees, and What It Does Not

  • A group stages in full or not at all. A body that raises resets every participant. A stage that fails on one participant unwinds them all.
  • A commit publishes in full or not at all, wherever every participant can be asked first. That is a group of two or more containers, none of them partitioned. Elsewhere the participants publish in turn, and only a refusal by the first leaves the group staged — any later one returns it to open, where reset() and not rollback() clears the remainder.
  • Staged writes are invisible to everyone else, including a transaction opened after the stage.
  • A transaction reads its own writes, until it stages. view[k] sees what view[k] = v put there; after stage() the write is in the store carrying no stamp, so it is invisible to everyone including its own transaction until commit().
  • Commit is not a snapshot. It applies each container in turn, so another thread reading two containers while a commit runs may find one of them a step ahead. A reader that needs the pair to agree should take its own transaction or read after the writer's block returns.
  • Scans are not snapshots either. scan() walks in key order and never yields a key twice or raises mid-walk, but a key inserted behind the cursor is missed. That is the container's own scan; the same call on a transaction participant records the window it read, so at serializable and above a key committed into that window refuses the commit rather than being silently missed.

Ordered and Unordered

SortedMap and SortedSet keep their keys in order, which is what iteration, scan and slice erase rest on. HashMap and HashSet are the same stores over an open-addressed core, and offer point access only:

cache = st.HashMap(key=str)
cache['a'] = 1
cache['a'], len(cache), 'a' in cache      # (1, 1, True)

cache.scan()                              # AttributeError — no ordering to scan
list(cache)                               # TypeError — not iterable

The absent methods are absent from the type rather than refused at the call, so reaching for one fails the way a typo fails. Everything else is shared — the same key layouts, the same isolation and sharing choices, the same transactions — so one st.transaction() may span ordered and unordered stores together.

Choosing an Isolation Level

A container names what it promises a reader, and reports back what it actually delivers:

cache = st.SortedMap(key=int)                                    # monotonic atomic view, the default
ledger = st.SortedMap(key=int, isolation='snapshot')
books = st.SortedMap(key=int, isolation='serializable')
audit = st.SortedMap(key=int, isolation='strict_serializable')

cache.isolation    # 'monotonic_atomic_view'
ledger.isolation   # 'snapshot'
books.isolation    # 'serializable'
audit.isolation    # 'strict_serializable'

Four names, refused by ValueError if misspelled — and the shipped type stubs turn a misspelling into a checker error before it ever runs.

Under snapshot every read a transaction makes is answered at the instant the transaction opened, so a repeated read returns what it first saw:

with st.transaction(ledger) as (view,):
    first = view[account]
    # ... another thread commits a new value for `account` here ...
    assert view[account] == first     # holds under snapshot, not under monotonic

That is what monotonic does not give you, and the reason to pay for the extra versions. The cost is memory: a key keeps every version a live reader can still name, and the tail is freed once the last transaction closes.

Snapshot validates what a transaction wrote, plus any key it explicitly watched, and nothing more, so two transactions that each read what the other writes and then write elsewhere both land — write skew, which Snapshot Isolation permits by construction because no two writes ever collide. serializable validates the read set as well, which is also what makes a phantom detectable: a window a transaction scanned is remembered as a window, so a key committed into it afterwards is a conflict even though no key either transaction touched overlaps.

with st.transaction(books) as (view,):
    empty = view.scan(20, 80)          # reads a window, and records that it did
    # ... another thread commits key 50 here ...
    ...                                # PhantomConflictError on leaving the block

PhantomConflictError derives from ConflictError, so a caller that retries on conflict needs no new branch. strict_serializable refuses exactly what serializable refuses; it adds only that a transaction opening after a commit returned cannot be ordered before it.

sharing decides how many writers can proceed at once:

st.SortedMap(key=int, sharing='locked')        # one lock, the default
st.SortedMap(key=int, sharing='partitioned')   # sixteen partitions, concurrent writers

isolation reports what a container delivers, not what it was asked for, and sharding is the one place those differ:

sharded_snapshot = st.SortedMap(key=int, isolation='snapshot', sharing='partitioned')
sharded_monotonic = st.SortedMap(key=int, isolation='monotonic_atomic_view', sharing='partitioned')

sharded_snapshot.isolation    # 'snapshot'        — asked for snapshot, got snapshot
sharded_monotonic.isolation   # 'read_committed'  — asked for monotonic, got less

A monotonic container has no stamp for a reader to hold, so a walk crossing partitions can catch a commit half-applied, and only Read Committed survives above a single key. A snapshot container does have one — visibility there is a comparison against a stamp rather than a lock somebody holds — so its commits become visible everywhere at once and its level survives however many partitions it is spread across.

Keeping the guarantee is not free, though. Making a commit atomic across partitions costs in proportion to how many of them a transaction touches: one writing a single key is unaffected, while one writing across all sixteen serializes against every other transaction that does the same. Sharding pays off for point-heavy work spread over many keys, and least for transactions that touch everything.

locked is the default because it is the setting under which the default level means what it says.

Stored Types

Values are int, float, bool, str and bytes, deep-copied into memory the library owns, so a stored value outlives the object it came from. str and bytes stay distinct, and bool round-trips as bool rather than as 1.

A container may instead hold arbitrary objects, which it stores by reference rather than by copy:

documents = st.SortedMap(key=str, value='object')
documents['doc'] = {'nested': [1, 2]}   # the very same object comes back out

The mode is named rather than inferred, because it is what the scalar guarantee rests on. In the default scalar mode nothing stored can touch a reference count, so the interpreter lock is released around every store; in object mode it is held, and the container is correspondingly slower.

Keys are typed and homogeneous. A container names its key layout at construction and refuses every other type:

st.SortedMap(key=int)      # signed 64-bit
st.SortedMap(key='uint')   # unsigned 64-bit, the only way to ask, since Python has no unsigned type
st.SortedMap(key=str)      # UTF-8, ordered bytewise
st.SortedMap(key=bytes)    # opaque, never decoded

That is what lets every comparison skip type dispatch: the ordering function is chosen once, at construction, rather than re-derived from a tag on each of the millions of comparisons a tree makes.

float and bool are values but never keys. A float key would make ordering depend on a total order over NaN, and bool is a subclass of int in Python, so accepting it would silently alias two key spaces:

m = st.SortedMap(key=int)
m[1] = 'one'      # fine
m[1.0] = 'one'    # TypeError: float is not a valid key
m[True] = 'one'   # TypeError: bool is not a valid key

This is the one place the library is deliberately stricter than dict, which treats 1, 1.0 and True as one key.

C++ Quick Start

include(FetchContent)
FetchContent_Declare(
    smashtable
    GIT_REPOSITORY https://github.com/ashvardanian/SmashTable
    GIT_TAG main
)
FetchContent_MakeAvailable(smashtable)
target_link_libraries(your_target PRIVATE smashtable::smashtable)

For a system-wide install, standard CMake package discovery works:

sudo cmake --install build_release
find_package(smashtable REQUIRED)
target_link_libraries(your_target PRIVATE smashtable::smashtable)

The library throws nowhere, and will not let you make it. Every API returns status_t, reads included, and a read delivers its answer through noexcept callbacks rather than through the return. A read is fallible from serializable_k up, where it has to write down what it read before the commit can validate it. A key whose copy or comparison can throw fails to compile rather than being quietly accepted. All containers take custom allocators and can be pre-allocated.

The same shape as the Python example, with no threads in sight:

#include <smashtable/basic_avl_tree.hpp>
#include <smashtable/monotonic_store.hpp>

namespace st = ashvardanian::smashtable;

using id_t = std::uint64_t;
using by_id_t = st::monotonic_avl_map<id_t, record_t>;      // id   → record
using by_name_t = st::monotonic_avl_map<name_t, id_t>;      // name → id

auto by_id = *by_id_t::make();
auto by_name = *by_name_t::make();

auto group = *st::make_transaction_group(by_id, by_name);
auto &ids = group.participant<0>();
auto &names = group.participant<1>();

_ = ids.upsert({id, record});
_ = names.upsert({record.name, id});
_ = ids.watch(id);                  // fail rather than clobber a concurrent write

_ = group.stage();                  // both reserve, or neither does
_ = group.commit();                 // both become visible

Staging the two by hand would leave the first one staged when the second refuses, which is the bug a group exists to remove. Participants are visited in order of the store's address rather than of the argument list, so two groups naming the same stores in opposite orders cannot deadlock on each other. A refused stage() rolls the staged prefix back rather than resetting it, so the writes survive and the group can be retried.

Basic containers — basic_avl_tree, basic_wb_tree — carry STL-style bidirectional iterators. Transactional containers do not, because keeping an iterator valid across concurrent updates costs more than it returns:

  • find(), lower_bound() and upper_bound() return status_t and take two noexcept callbacks, for the found and missing cases.
  • equal_range() and sample_one() return status_t and take one callback, invoked per element in the answer.
  • sample_reservoir() also returns status_t, but scatters into a random-access output iterator rather than a callback, taking the bounds, a generator, a running seen count and the reservoir capacity.
  • find_copy(), lower_bound_copy() and upper_bound_copy() return an expected<value_t> for callers that cannot use a callback.

Why The C++ Library

The standard library has loose ends around failure. std::set::insert(first, last) has no defined behaviour on partial failure, and in practice an allocation failure leaves some elements inserted and the rest not:

struct budget_t { std::size_t used = 0, limit = 0; };

template <typename value_type_> // ? rebind, converting constructor and `deallocate` elided
struct failing_allocator {
    using value_type = value_type_;
    budget_t *budget {};

    value_type_ *allocate(std::size_t count) {
        if (!budget || budget->used + count > budget->limit) throw std::bad_alloc {};
        budget->used += count;
        return static_cast<value_type_ *>(::operator new(count * sizeof(value_type_)));
    }
};

int main() {
    budget_t budget {0, 3};
    std::set<int, std::less<>, failing_allocator<int>> values {std::less<> {}, failing_allocator<int> {&budget}};

    try { for (int value : {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}) values.insert(value); }
    catch (std::bad_alloc const &) { std::println("std::bad_alloc after {} allocations", budget.used); }

    std::println("set contains {} elements:", values.size());
    for (int value : values) std::print("{} ", value);
    std::print("\n");
}

Under Clang++ 21 and G++ 15 that prints:

std::bad_alloc after 3 allocations
set contains 3 elements:
0 1 2

Where this matters is secondary-index consistency inside a storage engine — an id → slot map, a slot → vector map and a deleted set that have to move together, and where "the crash left index B disagreeing with index A" is a corruption bug someone has already debugged.

Stores

Terminology first, since both words are overloaded:

  • "Concurrency" does not imply threads. Several transactions can be open on one thread.
  • "Consistency" does not imply strict serializability. Weaker levels exist, and each store here names the one it targets as a compile-time isolation_k rather than leaving you to infer it.

Headers group as:

  basic_*               → Cores. Own their memory, no transactions, one thread.
    ├─ basic_vector<T, Alloc>
    ├─ basic_avl_tree<T, Comparator, Alloc>
    ├─ basic_wb_tree<T, Comparator, Alloc>          # also `rank` and `select`
    └─ basic_hash_table<T, Hash, Equals, Alloc>     # grows, iterates, rehashes

  atomic_*              → Pinned core. Fixed capacity, atomic per slot, callback reads.
    └─ atomic_hash_table<T, Hash, Equals, Alloc>    # the one type that runs on a GPU
       ↑ ::adopt(std::move(growable).release())     ↓ ::adopt(std::move(pinned).release())

  *_store               → 2-phase commit, watch and CAS.
    ├─ monotonic_store<Core>                        # one visible version per key
    ├─ snapshot_store<Core>                         # every version a live reader can still name
    └─ reference_store<T, Comparator, Alloc>        # the same contract over `std::set`, kept as the oracle
       ↓ either of the first two wraps a core; either of these wraps a store
    ├─ locked_store<Store, Mutex>                   # one lock spans a whole commit
    └─ partitioned_store<Store, Hash, Mutex, N>     # one lock per partition, one shared commit clock

  transaction_group<Stores...>  → One 2-phase commit spanning several stores

Transactions and thread-safety are two independent axes, not one ladder. A wrapper takes its mutex per call, not across a transaction: stage and commit each take it and drop it in between. What carries the inner store's level across that gap is the reservation staging made, since no other transaction can claim those keys until this one publishes or unwinds. A clock-less store gives its reader no stamp to hold, so a monotonic reader spanning partitions can catch a commit half-applied and only Read Committed survives — but a snapshot reader answers at its own stamp, and every partition draws from one clock, so it keeps Snapshot across all sixteen. Every container publishes what it promises as isolation_k, so the level is checkable rather than folklore. atomic_hash_table has no transactions at all — it offers per-operation atomicity, which is a different product, and is why it is not a *_store.

status_t reports out_of_memory_heap_k == ENOMEM, invalid_argument_k == EINVAL, key_not_found_k == ENOENT and others, and is [[nodiscard]] on every mutating API.

Making std::set Transactional

smashtable/reference_store.hpp

The baseline reference design, and the yardstick the tree containers are held against — it runs the same test suites they do. Updates group into transactions that stage and roll back before committing, which is what lets inter-dependent updates span several stores.

Reads are consistent at the Monotonic Atomic View level, so a transaction never sees another's partial update. That is weaker than Snapshot Isolation: there is no guarantee that every read within one transaction sees the same snapshot. It keeps a version per key all the same, dated by a generation rather than by a shared commit stamp, which is why a watch is re-resolved at commit instead of compared against one. snapshot_store is the sibling that does make that guarantee, and the section below states what it costs.

Adelson-Velsky and Landis Trees

smashtable/basic_avl_tree.hpp

Rarely called by its full name, the AVL tree is the simplest clean self-balancing binary search tree, from 1962. basic_avl_tree<value, comparator, allocator> is an ordered store in the shape of std::set or std::map. Standard libraries usually pick Red-Black trees; AVL balances more rigidly, trading slightly slower updates for faster lookups.

Its API differs from the STL where exception-free reporting demands it:

  • insert() returns std::pair<iterator, bool>, as the STL does.
  • erase(iterator) returns erase_result_t { iterator next; status_t status; }.
  • Range insert(first, last) returns status_t.
  • Hint-based insert(hint, value) and emplace_hint() are deleted, since AVL trees gain nothing from a hint.

Weight-Balanced Trees

smashtable/basic_wb_tree.hpp

basic_wb_tree balances on subtree sizes rather than heights, using Δ=3 and Γ=2 — the only proven integer solution, per Hirai and Yamamoto. Storing sizes buys order statistics: select(k) finds the k-th smallest and rank(x) finds a key's position, both in O(log n). That is what pagination, percentiles and quantiles need, and it is the one thing the AVL tree cannot offer.

Expect depth around 1.88 log₂(n) against AVL's 1.44, in exchange for O(1) amortized rotations per update.

Transactional Stores

smashtable/monotonic_store.hpp

monotonic_store<Core> adds two-phase commit, watches and CAS on top of any key-addressable core. monotonic_avl_set, monotonic_avl_map, monotonic_wb_set and monotonic_wb_map are the aliases you'll name directly. monotonic_hash_set and monotonic_hash_map back the same store with the open-addressed table, which supplies no ordering, so bounds, ranges and order statistics are gated out of those instantiations at compile time.

Which version a reader sees is decided by one number, stamped when a transaction commits. A version that has not committed carries no stamp, so it is invisible to readers and cannot make anyone else's validation fail — a transaction that stages and then rolls back costs its peers nothing. Two writers on one key are ordered by their stamps, and the later one wins. That is a lost update, which this level permits: Monotonic Atomic View constrains what a reader observes, not what two writers do to each other, and a level that is available under partition provably cannot prevent it. A writer that needs the first commit to win must watch() the key, or use a snapshot container, where the write set is validated whether you ask or not.

find never records what it read, here. A read set is memory, and a read that allocates is a read that can fail, so on this engine the recording variant is a different name:

_ = transaction.find(key, on_found, on_missing);             // answers, and records nothing
_ = transaction.find_and_watch(key, on_found, on_missing);   // records, and can report out of memory

Both return status_t, because a read that cannot write down what it read has to say so where it happened rather than poisoning the transaction silently until commit. snapshot_store at serializable_k and above needs no second name: every read records, and every read reports.

An erase leaves a tombstone that readers skip, and vacuum() is what returns that space:

expected<std::size_t> const reclaimed = store.vacuum();          // everything no reader can name
expected<std::size_t> const window = store.vacuum(lower, upper); // ordered cores, one slice at a time

Snapshot Isolation

smashtable/snapshot_store.hpp

snapshot_store<Core> is the sibling that fixes a transaction's reads to one instant, and it is where multi-version concurrency control is at its most literal here: a transaction draws a snapshot when it opens, every read is answered from the newest version at or below that snapshot, and a writer never overwrites what a reader can still name. It rebinds the same cores, exports snapshot_avl_set, _avl_map, _wb_set, _wb_map, _hash_set and _hash_map, and publishes isolation_k == snapshot_k. A repeated read returns what it first saw, a repeated range admits no phantoms, and neither holds in its sibling.

The same template answers at three levels, selected by a second parameter rather than by a second implementation, and each has aliases of its own:

snapshot_store<Core>                        // isolation_k == snapshot_k
serializable_store<Core>                    // reads validated too
strict_serializable_store<Core>             // and a commit waits for its own publication

serializable_avl_map<Key, Value>            // and `_avl_set`, `_wb_*`, `_hash_*`
strict_serializable_avl_map<Key, Value>     // the same six for the top rung

Versions are kept as ordinary entries keyed by (key, generation) rather than chained off one entry, on ordered and unordered cores alike. The hash core still hashes the bare key, so every version of a key shares one probe run and a lookup walks that run instead of stopping at the first match.

Reclamation is the other half of multi-version concurrency control, and the whole of it here: old versions are freed against a low-water mark that sits at the oldest open snapshot, so it can never pass a snapshot somebody still holds, and it advances as soon as the oldest reader leaves rather than waiting for the last. Pruning happens on every commit, and vacuum() reaches the keys nobody writes again. There is no background thread and no epoch registry. clear() refuses while a reader is open rather than dropping versions out from under it.

Range writes publish under one stamp, so a reader on an older snapshot sees all of a range erase or none of it. update_range builds new versions rather than rewriting the visible one, which is what open readers make unsound. select and rank descend on the weight-balanced tree's augmented count, exact at the newest commit — a reader at an older snapshot gets the merged walk instead, because one number per node cannot answer for an unbounded parameter.

What it costs, on an AVL core over mapping<key, int>:

monotonic_store snapshot_store
Resident per key, one version 80 B 72 B
Each retained older version 48 B chain node 72 B, a full entry
Read of one key one chain head the key's whole run

At rest it is the cheaper of the two, because a key carries no chain-head pointer and no per-entry allocator. It becomes the more expensive one exactly when a long-lived reader pins history — and on the hash core a pinned version occupies a real slot, so it lengthens the probe runs of its neighbours as well. With no transaction open the low-water mark sits at the newest commit and the whole version tail is freed on the next write, so a store nobody is reading costs what its sibling costs.

Hash Tables

smashtable/basic_hash_table.hpp

hash_set<key> and hash_map<key, value> are open-addressing containers with linear probing. They differ from google::dense_hash_map and tsl::robin_map by not reserving sentinel key values for tombstones, by unpacking keys and values into disjoint arrays, and by carrying two bits of metadata per slot rather than a byte.

Keys and values live in separate regions, so a lookup that only compares keys never pulls values into cache — which is most of them, since a miss touches no value at all. Thirty-two slots share one 64-bit header holding two parallel bitmasks, encoding free, deleted, populated and locked in two bits each. Sixty-four bits is the widest atomic every target supports, which is what lets a whole bucket header move in one instruction.

Growing repoints the key, value and header regions that every live slot reference has cached, so a table that can grow can never be read concurrently. The type system enforces that rather than a sentence: two types, neither of which includes the other's header. basic_hash_table grows, iterates and rehashes; atomic_hash_table is pinned and atomic over the slot each operation touches. What passes between them is the allocation itself — a hash_storage — so the hand-off is a move of a value rather than one table reaching into the other:

_ = growable.reserve(1u << 20);                                          // pin the capacity first
auto pinned = atomic_hash_map<key_t, value_t>::adopt(std::move(growable).release());

_ = pinned.find(key, [](auto const &slot) noexcept { use(slot.value()); });
if (failed(pinned.emplace(key, value))) report_full();                   // a pinned table can fill up

auto compacted = hash_map<key_t, value_t>::adopt(std::move(pinned).release());   // iterators return

Every operation on the pinned table is atomic over the slot it touches: it takes that slot by setting both its bits with a fetch_or and releases it with a fetch_xor of the difference to the desired state, so neither path needs a compare-and-swap loop. It is not lock-free, though — fetch_or spins until it wins the slot, so a thread descheduled while holding one blocks every other prober that walks onto it. No global lock and no reallocation is what the pinning buys; a stalled thread stalling its neighbours is what it does not. Reads take a callback rather than returning a reference or an iterator, since both would dangle the moment another thread erased the slot. Tombstones only accumulate while pinned, because compaction needs a rehash — deleted_count() is what says it is time to hand the storage back.

Readers take the slot lock like writers do. A reader that merely loaded the header would be unsound, and measurably so: the two bits per slot cannot distinguish "untouched" from "locked, rewritten and unlocked", because a completed write cycle restores exactly the bits the reader first saw. Adding a per-bucket version counter would fix it and would cost half the slots per bucket, which is not worth breaking the one-warp-per-bucket geometry for.

Order-dependent operations are absent by construction: there is no range, erase_range, lower_bound or select.

The small-string specialization mentioned in the header is a design note, not shipped behaviour.

Testing

cmake -B build -DCMAKE_BUILD_TYPE=Debug -DSMASHTABLE_WERROR=ON
cmake --build build
ctest --test-dir build --output-on-failure

SMASHTABLE_FILTER selects a subset by substring, matched against suite.name, and fails the binary when it matches nothing:

SMASHTABLE_FILTER=transactional_consistency ./build/smashtable_test_avl_tree

One binary per container family runs the same suites — the std::set store, both trees, both thread-safety wrappers, the bare hash table and the transactional stores over it — so a behavioural difference between them shows up as a failure rather than a surprise.

The suite asserts costs, not only answers. select over the augmented count is pinned to an exact node count rather than to a bound: an independent descent measures 13 nodes at 4096 entries and 19 at 262144, one per level of a tree that ascending keys leave perfectly balanced. The counting comparator tallies rank alone, because select_augmented navigates on subtree sizes and asks the comparator nothing. An element type that tallies its own construction and destruction turns a leak into arithmetic — a key leaked inside a correctly freed node is invisible to a sanitizer and not to the tally. A key whose hash keeps only its group forces the long probe runs a well-spread hash never produces, which is where tombstone reuse and severed runs actually show.

isolation_k is checked against behaviour rather than against itself. The shared suite branches on the level a container declares and asserts both outcomes, so a container that quietly starts snapshotting without raising its level fails just as one that claims a level it does not deliver.

For the Python side:

pip install -e . --group test && pytest test/

Metadata

Release files for smashtable 0.3.3

For a detailed explanation of source distributions (sdists) and built distributions (wheels), please see the package formats documentation.

Source distribution (sdist)

Source distribution for smashtable 0.3.3
File Size Uploaded Provenance Actions
smashtable-0.3.3.tar.gz 328.9 kB With provenance Details for smashtable-0.3.3.tar.gz

Built distributions (wheels)

Table of built distributions (wheels) for smashtable 0.3.3
File Actions
smashtable-0.3.3-cp314-cp314t-win_amd64.whl CPython 3.14 CPython 3.14 free-threading Windows x86-64 Details for smashtable-0.3.3-cp314-cp314t-win_amd64.whl
smashtable-0.3.3-cp314-cp314t-win32.whl CPython 3.14 CPython 3.14 free-threading Windows x86-32 Details for smashtable-0.3.3-cp314-cp314t-win32.whl
smashtable-0.3.3-cp314-cp314t-musllinux_1_2_x86_64.whl CPython 3.14 CPython 3.14 free-threading Linux musl 1.2+ x86-64 Details for smashtable-0.3.3-cp314-cp314t-musllinux_1_2_x86_64.whl
smashtable-0.3.3-cp314-cp314t-musllinux_1_2_aarch64.whl CPython 3.14 CPython 3.14 free-threading Linux musl 1.2+ ARM64 Details for smashtable-0.3.3-cp314-cp314t-musllinux_1_2_aarch64.whl
smashtable-0.3.3-cp314-cp314t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl CPython 3.14 CPython 3.14 free-threading Linux glibc 2.24+ x86-64, Linux glibc 2.28+ x86-64 Details for smashtable-0.3.3-cp314-cp314t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl
smashtable-0.3.3-cp314-cp314t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl CPython 3.14 CPython 3.14 free-threading Linux glibc 2.28+ ARM64, Linux glibc 2.24+ ARM64 Details for smashtable-0.3.3-cp314-cp314t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl
smashtable-0.3.3-cp314-cp314t-macosx_11_0_arm64.whl CPython 3.14 CPython 3.14 free-threading macOS 11.0+ ARM64 Details for smashtable-0.3.3-cp314-cp314t-macosx_11_0_arm64.whl
smashtable-0.3.3-cp314-cp314-win_arm64.whl CPython 3.14 CPython 3.14 Windows ARM64 Details for smashtable-0.3.3-cp314-cp314-win_arm64.whl
smashtable-0.3.3-cp314-cp314-win_amd64.whl CPython 3.14 CPython 3.14 Windows x86-64 Details for smashtable-0.3.3-cp314-cp314-win_amd64.whl
smashtable-0.3.3-cp314-cp314-win32.whl CPython 3.14 CPython 3.14 Windows x86-32 Details for smashtable-0.3.3-cp314-cp314-win32.whl
smashtable-0.3.3-cp314-cp314-musllinux_1_2_x86_64.whl CPython 3.14 CPython 3.14 Linux musl 1.2+ x86-64 Details for smashtable-0.3.3-cp314-cp314-musllinux_1_2_x86_64.whl
smashtable-0.3.3-cp314-cp314-musllinux_1_2_aarch64.whl CPython 3.14 CPython 3.14 Linux musl 1.2+ ARM64 Details for smashtable-0.3.3-cp314-cp314-musllinux_1_2_aarch64.whl
smashtable-0.3.3-cp314-cp314-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl CPython 3.14 CPython 3.14 Linux glibc 2.24+ x86-64, Linux glibc 2.28+ x86-64 Details for smashtable-0.3.3-cp314-cp314-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl
smashtable-0.3.3-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl CPython 3.14 CPython 3.14 Linux glibc 2.28+ ARM64, Linux glibc 2.24+ ARM64 Details for smashtable-0.3.3-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl
smashtable-0.3.3-cp314-cp314-macosx_11_0_arm64.whl CPython 3.14 CPython 3.14 macOS 11.0+ ARM64 Details for smashtable-0.3.3-cp314-cp314-macosx_11_0_arm64.whl
smashtable-0.3.3-cp313-cp313-win_arm64.whl CPython 3.13 CPython 3.13 Windows ARM64 Details for smashtable-0.3.3-cp313-cp313-win_arm64.whl
smashtable-0.3.3-cp313-cp313-win_amd64.whl CPython 3.13 CPython 3.13 Windows x86-64 Details for smashtable-0.3.3-cp313-cp313-win_amd64.whl
smashtable-0.3.3-cp313-cp313-win32.whl CPython 3.13 CPython 3.13 Windows x86-32 Details for smashtable-0.3.3-cp313-cp313-win32.whl
smashtable-0.3.3-cp313-cp313-musllinux_1_2_x86_64.whl CPython 3.13 CPython 3.13 Linux musl 1.2+ x86-64 Details for smashtable-0.3.3-cp313-cp313-musllinux_1_2_x86_64.whl
smashtable-0.3.3-cp313-cp313-musllinux_1_2_aarch64.whl CPython 3.13 CPython 3.13 Linux musl 1.2+ ARM64 Details for smashtable-0.3.3-cp313-cp313-musllinux_1_2_aarch64.whl
smashtable-0.3.3-cp313-cp313-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl CPython 3.13 CPython 3.13 Linux glibc 2.24+ x86-64, Linux glibc 2.28+ x86-64 Details for smashtable-0.3.3-cp313-cp313-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl
smashtable-0.3.3-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl CPython 3.13 CPython 3.13 Linux glibc 2.28+ ARM64, Linux glibc 2.24+ ARM64 Details for smashtable-0.3.3-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl
smashtable-0.3.3-cp313-cp313-macosx_11_0_arm64.whl CPython 3.13 CPython 3.13 macOS 11.0+ ARM64 Details for smashtable-0.3.3-cp313-cp313-macosx_11_0_arm64.whl
smashtable-0.3.3-cp312-cp312-win_arm64.whl CPython 3.12 CPython 3.12 Windows ARM64 Details for smashtable-0.3.3-cp312-cp312-win_arm64.whl
smashtable-0.3.3-cp312-cp312-win_amd64.whl CPython 3.12 CPython 3.12 Windows x86-64 Details for smashtable-0.3.3-cp312-cp312-win_amd64.whl
smashtable-0.3.3-cp312-cp312-win32.whl CPython 3.12 CPython 3.12 Windows x86-32 Details for smashtable-0.3.3-cp312-cp312-win32.whl
smashtable-0.3.3-cp312-cp312-musllinux_1_2_x86_64.whl CPython 3.12 CPython 3.12 Linux musl 1.2+ x86-64 Details for smashtable-0.3.3-cp312-cp312-musllinux_1_2_x86_64.whl
smashtable-0.3.3-cp312-cp312-musllinux_1_2_aarch64.whl CPython 3.12 CPython 3.12 Linux musl 1.2+ ARM64 Details for smashtable-0.3.3-cp312-cp312-musllinux_1_2_aarch64.whl
smashtable-0.3.3-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl CPython 3.12 CPython 3.12 Linux glibc 2.24+ x86-64, Linux glibc 2.28+ x86-64 Details for smashtable-0.3.3-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl
smashtable-0.3.3-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl CPython 3.12 CPython 3.12 Linux glibc 2.28+ ARM64, Linux glibc 2.24+ ARM64 Details for smashtable-0.3.3-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl
smashtable-0.3.3-cp312-cp312-macosx_11_0_arm64.whl CPython 3.12 CPython 3.12 macOS 11.0+ ARM64 Details for smashtable-0.3.3-cp312-cp312-macosx_11_0_arm64.whl

Total release size: 184.1 MB

Release files / smashtable-0.3.3.tar.gz

Download URL smashtable-0.3.3.tar.gz
Size 328.9 kB
Tags Source
SHA-256 checksum
How to use checksums
7680c81c4d410cfe553f417deadd0fa47a621640ba766134799a17e72677d5d8
BLAKE2b-256 checksum
How to use checksums
4f2c35ad35da1d9d3f7ebec2f20d1240b617b638b67e89e204b9d89e80f6edd9
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
Yes
Uploaded via twine/7.0.0 CPython/3.13.16

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

PyPI Publish Attestation

PyPI verified that this artifact, at this checksum, originated from the publisher listed below.

Signed by GitHub Actions, verified by PyPI on Oct 31, 2026.

Transparency log

Release files / smashtable-0.3.3-cp314-cp314t-win_amd64.whl

Download URL smashtable-0.3.3-cp314-cp314t-win_amd64.whl
Size 560.0 kB
Tags CPython 3.14 CPython 3.14 free-threading Windows x86-64
SHA-256 checksum
How to use checksums
7e19ff6a1096c6515c1681bb23250c50c2028342a39e2b4d881ee9b85da9146b
BLAKE2b-256 checksum
How to use checksums
244c4ecee04e3d2d252159c4638cc45b2b47c68045485e78ffe701113985db31
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
Yes
Uploaded via twine/7.0.0 CPython/3.13.16

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

PyPI Publish Attestation

PyPI verified that this artifact, at this checksum, originated from the publisher listed below.

Signed by GitHub Actions, verified by PyPI on Oct 31, 2026.

Transparency log

Release files / smashtable-0.3.3-cp314-cp314t-win32.whl

Download URL smashtable-0.3.3-cp314-cp314t-win32.whl
Size 439.6 kB
Tags CPython 3.14 CPython 3.14 free-threading Windows x86-32
SHA-256 checksum
How to use checksums
bf7d5fa6146103633ca6a54df28a7e419b843e7beae63d3fdf6adf12f7b829d5
BLAKE2b-256 checksum
How to use checksums
bee368d49859149a8dce39c472f04e683d0b24fae0036c4c651a3b2f2c986361
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
Yes
Uploaded via twine/7.0.0 CPython/3.13.16

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

PyPI Publish Attestation

PyPI verified that this artifact, at this checksum, originated from the publisher listed below.

Signed by GitHub Actions, verified by PyPI on Oct 31, 2026.

Transparency log

Release files / smashtable-0.3.3-cp314-cp314t-musllinux_1_2_x86_64.whl

Download URL smashtable-0.3.3-cp314-cp314t-musllinux_1_2_x86_64.whl
Size 11.3 MB
Tags CPython 3.14 CPython 3.14 free-threading Linux musl 1.2+ x86-64
SHA-256 checksum
How to use checksums
acf2fa63733801a350315144f0b8b023690e317d9de37ff2c01a810f39c210ea
BLAKE2b-256 checksum
How to use checksums
51e9facac6e503d6b708476cfa7f2c2820f5a80490dd555357b35d2573bdb8d9
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
Yes
Uploaded via twine/7.0.0 CPython/3.13.16

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

PyPI Publish Attestation

PyPI verified that this artifact, at this checksum, originated from the publisher listed below.

Signed by GitHub Actions, verified by PyPI on Oct 31, 2026.

Transparency log

Release files / smashtable-0.3.3-cp314-cp314t-musllinux_1_2_aarch64.whl

Download URL smashtable-0.3.3-cp314-cp314t-musllinux_1_2_aarch64.whl
Size 11.1 MB
Tags CPython 3.14 CPython 3.14 free-threading Linux musl 1.2+ ARM64
SHA-256 checksum
How to use checksums
7acce4fcd55b632a876ec6b6f0789dde9cafdbfcb81c493a35d812f13e72e250
BLAKE2b-256 checksum
How to use checksums
aac51845903cb94adb43fa850f41bd3b556fce6a144d506c4443376a76ce7fd5
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
Yes
Uploaded via twine/7.0.0 CPython/3.13.16

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

PyPI Publish Attestation

PyPI verified that this artifact, at this checksum, originated from the publisher listed below.

Signed by GitHub Actions, verified by PyPI on Oct 31, 2026.

Transparency log

Release files / smashtable-0.3.3-cp314-cp314t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl

Download URL smashtable-0.3.3-cp314-cp314t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl
Size 10.7 MB
Tags CPython 3.14 CPython 3.14 free-threading Linux glibc 2.24+ x86-64 Linux glibc 2.28+ x86-64
SHA-256 checksum
How to use checksums
baa7cbd7dea26f230486936a2f2c38dee1d3478b5022e0b436f57805b3a8b193
BLAKE2b-256 checksum
How to use checksums
dc5d6c425027962b056aca624785ba2861ed10821a7ba4b99a345b4db8c04b2a
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
Yes
Uploaded via twine/7.0.0 CPython/3.13.16

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

PyPI Publish Attestation

PyPI verified that this artifact, at this checksum, originated from the publisher listed below.

Signed by GitHub Actions, verified by PyPI on Oct 31, 2026.

Transparency log

Release files / smashtable-0.3.3-cp314-cp314t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl

Download URL smashtable-0.3.3-cp314-cp314t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl
Size 10.7 MB
Tags CPython 3.14 CPython 3.14 free-threading Linux glibc 2.24+ ARM64 Linux glibc 2.28+ ARM64
SHA-256 checksum
How to use checksums
298c74c0fed451ccdc67e4e6a3832ebf2fd4986ff5638776282df24b4f13e400
BLAKE2b-256 checksum
How to use checksums
d9882e83f06c29e2196718f802f5d4c43cfa206977fd38836222d579e2b76896
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
Yes
Uploaded via twine/7.0.0 CPython/3.13.16

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

PyPI Publish Attestation

PyPI verified that this artifact, at this checksum, originated from the publisher listed below.

Signed by GitHub Actions, verified by PyPI on Oct 31, 2026.

Transparency log

Release files / smashtable-0.3.3-cp314-cp314t-macosx_11_0_arm64.whl

Download URL smashtable-0.3.3-cp314-cp314t-macosx_11_0_arm64.whl
Size 761.0 kB
Tags CPython 3.14 CPython 3.14 free-threading macOS 11.0+ ARM64
SHA-256 checksum
How to use checksums
1f1cf86303678bf6e6a288935633fbfc89f566ec0cbfa3336e95d83946ac00b1
BLAKE2b-256 checksum
How to use checksums
78f426635e0ba985822cef6e9dc78cd1616d7becfec12a73ee2ac9f0f760e9e8
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
Yes
Uploaded via twine/7.0.0 CPython/3.13.16

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

PyPI Publish Attestation

PyPI verified that this artifact, at this checksum, originated from the publisher listed below.

Signed by GitHub Actions, verified by PyPI on Oct 31, 2026.

Transparency log

Release files / smashtable-0.3.3-cp314-cp314-win_arm64.whl

Download URL smashtable-0.3.3-cp314-cp314-win_arm64.whl
Size 748.8 kB
Tags CPython 3.14 Windows ARM64
SHA-256 checksum
How to use checksums
84ca7f80e32a30285156d05eeef57948f44147b69c31662a4c0a6e6b61216f75
BLAKE2b-256 checksum
How to use checksums
e495655425964a56f8aaf1ddafa61cdd671421ee1d50709feadd4de15aeba57a
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
Yes
Uploaded via twine/7.0.0 CPython/3.13.16

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

PyPI Publish Attestation

PyPI verified that this artifact, at this checksum, originated from the publisher listed below.

Signed by GitHub Actions, verified by PyPI on Oct 31, 2026.

Transparency log

Release files / smashtable-0.3.3-cp314-cp314-win_amd64.whl

Download URL smashtable-0.3.3-cp314-cp314-win_amd64.whl
Size 559.3 kB
Tags CPython 3.14 Windows x86-64
SHA-256 checksum
How to use checksums
61bd85dc275bbc2da7abbc123f9a0cd8839641186f046459f2341871cdb920b4
BLAKE2b-256 checksum
How to use checksums
353b8857aee4d614051084c38b28f5ac8abc30c46d73fefa9ac8d19a5d083c6f
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
Yes
Uploaded via twine/7.0.0 CPython/3.13.16

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

PyPI Publish Attestation

PyPI verified that this artifact, at this checksum, originated from the publisher listed below.

Signed by GitHub Actions, verified by PyPI on Oct 31, 2026.

Transparency log

Release files / smashtable-0.3.3-cp314-cp314-win32.whl

Download URL smashtable-0.3.3-cp314-cp314-win32.whl
Size 438.8 kB
Tags CPython 3.14 Windows x86-32
SHA-256 checksum
How to use checksums
849e1a234d606691a6de2cbb94db50fafdbd712fc4910246989a4578dcf33f6b
BLAKE2b-256 checksum
How to use checksums
358ac9244af2253ac6ee7002eb9097e77fff244c3a1f9690ade5c14b0981723b
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
Yes
Uploaded via twine/7.0.0 CPython/3.13.16

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

PyPI Publish Attestation

PyPI verified that this artifact, at this checksum, originated from the publisher listed below.

Signed by GitHub Actions, verified by PyPI on Oct 31, 2026.

Transparency log

Release files / smashtable-0.3.3-cp314-cp314-musllinux_1_2_x86_64.whl

Download URL smashtable-0.3.3-cp314-cp314-musllinux_1_2_x86_64.whl
Size 11.2 MB
Tags CPython 3.14 Linux musl 1.2+ x86-64
SHA-256 checksum
How to use checksums
9be28cdc40aed3879838746bfbfa51971750d78103c8908e76da3f0adc56697f
BLAKE2b-256 checksum
How to use checksums
0e3627bfa1d5f15e0228142d2bb7ed2463bceba9ed8c867ee55b9d4b24dcade9
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
Yes
Uploaded via twine/7.0.0 CPython/3.13.16

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

PyPI Publish Attestation

PyPI verified that this artifact, at this checksum, originated from the publisher listed below.

Signed by GitHub Actions, verified by PyPI on Oct 31, 2026.

Transparency log

Release files / smashtable-0.3.3-cp314-cp314-musllinux_1_2_aarch64.whl

Download URL smashtable-0.3.3-cp314-cp314-musllinux_1_2_aarch64.whl
Size 11.1 MB
Tags CPython 3.14 Linux musl 1.2+ ARM64
SHA-256 checksum
How to use checksums
6003d7bf8c4b1b8e62ef43bc850cf5507cef14f396bdf32f78d0adfb1a9baa8e
BLAKE2b-256 checksum
How to use checksums
1d6c399d3a5131fa0f2d2e36b8e3b18a0646d245152396081feeef535b85084b
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
Yes
Uploaded via twine/7.0.0 CPython/3.13.16

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

PyPI Publish Attestation

PyPI verified that this artifact, at this checksum, originated from the publisher listed below.

Signed by GitHub Actions, verified by PyPI on Oct 31, 2026.

Transparency log

Release files / smashtable-0.3.3-cp314-cp314-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl

Download URL smashtable-0.3.3-cp314-cp314-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl
Size 10.7 MB
Tags CPython 3.14 Linux glibc 2.24+ x86-64 Linux glibc 2.28+ x86-64
SHA-256 checksum
How to use checksums
af0dc8b43b95b19eac9dece83f2bdcad9b1b7cae1c8afc4d7adfd86c1c9c9984
BLAKE2b-256 checksum
How to use checksums
4413cafa8e5838105ab02111288efdbb4e02ff94c7ba6c091b0e9cc77385c64e
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
Yes
Uploaded via twine/7.0.0 CPython/3.13.16

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

PyPI Publish Attestation

PyPI verified that this artifact, at this checksum, originated from the publisher listed below.

Signed by GitHub Actions, verified by PyPI on Oct 31, 2026.

Transparency log

Release files / smashtable-0.3.3-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl

Download URL smashtable-0.3.3-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl
Size 10.6 MB
Tags CPython 3.14 Linux glibc 2.24+ ARM64 Linux glibc 2.28+ ARM64
SHA-256 checksum
How to use checksums
d9db2e75fcc11bf2c457947d2450acbbe305798c7f464472913665da040e2f2e
BLAKE2b-256 checksum
How to use checksums
0ab29fc1571e1ebbaa4f8ea8fcea5c94ee742ba9c13527e6ea54881561c0df04
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
Yes
Uploaded via twine/7.0.0 CPython/3.13.16

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

PyPI Publish Attestation

PyPI verified that this artifact, at this checksum, originated from the publisher listed below.

Signed by GitHub Actions, verified by PyPI on Oct 31, 2026.

Transparency log

Release files / smashtable-0.3.3-cp314-cp314-macosx_11_0_arm64.whl

Download URL smashtable-0.3.3-cp314-cp314-macosx_11_0_arm64.whl
Size 759.1 kB
Tags CPython 3.14 macOS 11.0+ ARM64
SHA-256 checksum
How to use checksums
af49bb5b373b7c6735f947c15b49f9f902d6078ea37fadf683b85f0c7fe3c6bf
BLAKE2b-256 checksum
How to use checksums
38fc0df7e4811a1765cdee575cf88c61b211c66f07d622377a5416029621e033
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
Yes
Uploaded via twine/7.0.0 CPython/3.13.16

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

PyPI Publish Attestation

PyPI verified that this artifact, at this checksum, originated from the publisher listed below.

Signed by GitHub Actions, verified by PyPI on Oct 31, 2026.

Transparency log

Release files / smashtable-0.3.3-cp313-cp313-win_arm64.whl

Download URL smashtable-0.3.3-cp313-cp313-win_arm64.whl
Size 724.9 kB
Tags CPython 3.13 Windows ARM64
SHA-256 checksum
How to use checksums
a1a7eba4beabf9c214e8161dd306b5dac96bdf7932c013dc809b2456ad082cc1
BLAKE2b-256 checksum
How to use checksums
c4a35f7d9d0f29f364651b0117537d2082c7e2fc866df9b30ba9566a10f50abd
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
Yes
Uploaded via twine/7.0.0 CPython/3.13.16

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

PyPI Publish Attestation

PyPI verified that this artifact, at this checksum, originated from the publisher listed below.

Signed by GitHub Actions, verified by PyPI on Oct 31, 2026.

Transparency log

Release files / smashtable-0.3.3-cp313-cp313-win_amd64.whl

Download URL smashtable-0.3.3-cp313-cp313-win_amd64.whl
Size 542.5 kB
Tags CPython 3.13 Windows x86-64
SHA-256 checksum
How to use checksums
dd8c064511d3542514636f8ea496ae05ba2604c2d2acdcddbf5d54ac99abe9f6
BLAKE2b-256 checksum
How to use checksums
026a07772ec3b5aa6c33623e446aa0e8ce31afc5c3815dd6488e640850d3c3d4
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
Yes
Uploaded via twine/7.0.0 CPython/3.13.16

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

PyPI Publish Attestation

PyPI verified that this artifact, at this checksum, originated from the publisher listed below.

Signed by GitHub Actions, verified by PyPI on Oct 31, 2026.

Transparency log

Release files / smashtable-0.3.3-cp313-cp313-win32.whl

Download URL smashtable-0.3.3-cp313-cp313-win32.whl
Size 428.3 kB
Tags CPython 3.13 Windows x86-32
SHA-256 checksum
How to use checksums
32e0fa5d02d07db1d1ac9992d25c69288bb83b7929863e36e716766b3f2f5e44
BLAKE2b-256 checksum
How to use checksums
6ac2f64df336215204990287746e264508c56057a272918a366e138af6f06bed
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
Yes
Uploaded via twine/7.0.0 CPython/3.13.16

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

PyPI Publish Attestation

PyPI verified that this artifact, at this checksum, originated from the publisher listed below.

Signed by GitHub Actions, verified by PyPI on Oct 31, 2026.

Transparency log

Release files / smashtable-0.3.3-cp313-cp313-musllinux_1_2_x86_64.whl

Download URL smashtable-0.3.3-cp313-cp313-musllinux_1_2_x86_64.whl
Size 11.2 MB
Tags CPython 3.13 Linux musl 1.2+ x86-64
SHA-256 checksum
How to use checksums
f0954ffadf525dad7628353dcdcba7edb7b9e4b0b9d4085202703aa92c5e37f2
BLAKE2b-256 checksum
How to use checksums
169c06aad7e405b625cf318c1082a6d0fea5346233045243f2d214b0c56fe985
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
Yes
Uploaded via twine/7.0.0 CPython/3.13.16

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

PyPI Publish Attestation

PyPI verified that this artifact, at this checksum, originated from the publisher listed below.

Signed by GitHub Actions, verified by PyPI on Oct 31, 2026.

Transparency log

Release files / smashtable-0.3.3-cp313-cp313-musllinux_1_2_aarch64.whl

Download URL smashtable-0.3.3-cp313-cp313-musllinux_1_2_aarch64.whl
Size 11.1 MB
Tags CPython 3.13 Linux musl 1.2+ ARM64
SHA-256 checksum
How to use checksums
da1b8a33086ea234574af731a7dd413524d3de9b0150e6f725c2bf95f3c2de58
BLAKE2b-256 checksum
How to use checksums
f7b593497f80704acb4b126e2805a273d88a874a43c0bc54d4b89f55a3d4a161
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
Yes
Uploaded via twine/7.0.0 CPython/3.13.16

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

PyPI Publish Attestation

PyPI verified that this artifact, at this checksum, originated from the publisher listed below.

Signed by GitHub Actions, verified by PyPI on Oct 31, 2026.

Transparency log

Release files / smashtable-0.3.3-cp313-cp313-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl

Download URL smashtable-0.3.3-cp313-cp313-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl
Size 10.7 MB
Tags CPython 3.13 Linux glibc 2.24+ x86-64 Linux glibc 2.28+ x86-64
SHA-256 checksum
How to use checksums
b49ed86371bb57161bad379012f68563c0d3aa2bcaf0edcb865a4c9e4060b72b
BLAKE2b-256 checksum
How to use checksums
0497db0ddd224e557e5427a6edc7185dccf419acd58d378f2f3db74f9ae95e2a
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
Yes
Uploaded via twine/7.0.0 CPython/3.13.16

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

PyPI Publish Attestation

PyPI verified that this artifact, at this checksum, originated from the publisher listed below.

Signed by GitHub Actions, verified by PyPI on Oct 31, 2026.

Transparency log

Release files / smashtable-0.3.3-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl

Download URL smashtable-0.3.3-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl
Size 10.6 MB
Tags CPython 3.13 Linux glibc 2.24+ ARM64 Linux glibc 2.28+ ARM64
SHA-256 checksum
How to use checksums
f12668725b87ddc8b2818a22d367376babaccbb913356ae838903e506b28081c
BLAKE2b-256 checksum
How to use checksums
96637170440d6b9130eb7e5688f8411ac519c6197cf278ed79bec268690842e8
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
Yes
Uploaded via twine/7.0.0 CPython/3.13.16

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

PyPI Publish Attestation

PyPI verified that this artifact, at this checksum, originated from the publisher listed below.

Signed by GitHub Actions, verified by PyPI on Oct 31, 2026.

Transparency log

Release files / smashtable-0.3.3-cp313-cp313-macosx_11_0_arm64.whl

Download URL smashtable-0.3.3-cp313-cp313-macosx_11_0_arm64.whl
Size 759.1 kB
Tags CPython 3.13 macOS 11.0+ ARM64
SHA-256 checksum
How to use checksums
f0aac080f18e3b519289bb30236311b7a7eb23457bb566521c685dce93395115
BLAKE2b-256 checksum
How to use checksums
7ee8615f43b7dad5035c350eab9dac4f988d04661a68dcf06e85dcf487d0b8f9
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
Yes
Uploaded via twine/7.0.0 CPython/3.13.16

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

PyPI Publish Attestation

PyPI verified that this artifact, at this checksum, originated from the publisher listed below.

Signed by GitHub Actions, verified by PyPI on Oct 31, 2026.

Transparency log

Release files / smashtable-0.3.3-cp312-cp312-win_arm64.whl

Download URL smashtable-0.3.3-cp312-cp312-win_arm64.whl
Size 724.9 kB
Tags CPython 3.12 Windows ARM64
SHA-256 checksum
How to use checksums
4e0a92731917c8dcb03f696fa6389719190c2f640a4fb736bb1cb014e373a4d0
BLAKE2b-256 checksum
How to use checksums
9cdbba5faf5b51bab4926e5de907a6e0ea53426d920297acf892acc88e555fc7
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
Yes
Uploaded via twine/7.0.0 CPython/3.13.16

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

PyPI Publish Attestation

PyPI verified that this artifact, at this checksum, originated from the publisher listed below.

Signed by GitHub Actions, verified by PyPI on Oct 31, 2026.

Transparency log

Release files / smashtable-0.3.3-cp312-cp312-win_amd64.whl

Download URL smashtable-0.3.3-cp312-cp312-win_amd64.whl
Size 542.5 kB
Tags CPython 3.12 Windows x86-64
SHA-256 checksum
How to use checksums
d8b6013b0f636f397edb0e370700399519ee7fe1750c7b85207d821b819ce009
BLAKE2b-256 checksum
How to use checksums
3d6d64550d33778c172949e6b804dadeca52f7978afb208010fa896ba5d105a0
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
Yes
Uploaded via twine/7.0.0 CPython/3.13.16

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

PyPI Publish Attestation

PyPI verified that this artifact, at this checksum, originated from the publisher listed below.

Signed by GitHub Actions, verified by PyPI on Oct 31, 2026.

Transparency log

Release files / smashtable-0.3.3-cp312-cp312-win32.whl

Download URL smashtable-0.3.3-cp312-cp312-win32.whl
Size 428.3 kB
Tags CPython 3.12 Windows x86-32
SHA-256 checksum
How to use checksums
a32f601082dbd3c40722104862228fb61bc4eeabf11c872084cf191af2f077d1
BLAKE2b-256 checksum
How to use checksums
71b45b089230c45d62db6fcc9b71d84457a5bf6718affc34b0139353f27e88e5
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
Yes
Uploaded via twine/7.0.0 CPython/3.13.16

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

PyPI Publish Attestation

PyPI verified that this artifact, at this checksum, originated from the publisher listed below.

Signed by GitHub Actions, verified by PyPI on Oct 31, 2026.

Transparency log

Release files / smashtable-0.3.3-cp312-cp312-musllinux_1_2_x86_64.whl

Download URL smashtable-0.3.3-cp312-cp312-musllinux_1_2_x86_64.whl
Size 11.2 MB
Tags CPython 3.12 Linux musl 1.2+ x86-64
SHA-256 checksum
How to use checksums
0fbda97075e0359cb7923e2b61ff354f37a2e488c3fcd1d99484d4f2e5a492d8
BLAKE2b-256 checksum
How to use checksums
89a1c3e01ac3dd300e044584ec7c44265e239766084de5bfcddb4f03fb359f59
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
Yes
Uploaded via twine/7.0.0 CPython/3.13.16

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

PyPI Publish Attestation

PyPI verified that this artifact, at this checksum, originated from the publisher listed below.

Signed by GitHub Actions, verified by PyPI on Oct 31, 2026.

Transparency log

Release files / smashtable-0.3.3-cp312-cp312-musllinux_1_2_aarch64.whl

Download URL smashtable-0.3.3-cp312-cp312-musllinux_1_2_aarch64.whl
Size 11.1 MB
Tags CPython 3.12 Linux musl 1.2+ ARM64
SHA-256 checksum
How to use checksums
41ba41cfe7813b5f9768abb4c0b579bc061bb4f02850e552250e1a2fbe7c8bed
BLAKE2b-256 checksum
How to use checksums
f84464e49c769d99ceb2544e860a895fdcce66eae3e6b9dc340f0f3842a1637c
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
Yes
Uploaded via twine/7.0.0 CPython/3.13.16

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

PyPI Publish Attestation

PyPI verified that this artifact, at this checksum, originated from the publisher listed below.

Signed by GitHub Actions, verified by PyPI on Oct 31, 2026.

Transparency log

Release files / smashtable-0.3.3-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl

Download URL smashtable-0.3.3-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl
Size 10.7 MB
Tags CPython 3.12 Linux glibc 2.24+ x86-64 Linux glibc 2.28+ x86-64
SHA-256 checksum
How to use checksums
1c796eed82fc455eb58c87825879505b42291b8900b7af0e3eca8ae1806f12ec
BLAKE2b-256 checksum
How to use checksums
fb843e338f2459c606915b8bfda3c5daea1f729929b218dabf7728acd3a54494
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
Yes
Uploaded via twine/7.0.0 CPython/3.13.16

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

PyPI Publish Attestation

PyPI verified that this artifact, at this checksum, originated from the publisher listed below.

Signed by GitHub Actions, verified by PyPI on Oct 31, 2026.

Transparency log

Release files / smashtable-0.3.3-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl

Download URL smashtable-0.3.3-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl
Size 10.6 MB
Tags CPython 3.12 Linux glibc 2.24+ ARM64 Linux glibc 2.28+ ARM64
SHA-256 checksum
How to use checksums
4aaa769493ed9dd5cb1dca0d977579e854777cc13e8d690d6a04e607abf8a21b
BLAKE2b-256 checksum
How to use checksums
fd3935f3d316e5d88675bd21bf41974922e1e1fa3bf3603f94b5fe19ff575239
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
Yes
Uploaded via twine/7.0.0 CPython/3.13.16

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

PyPI Publish Attestation

PyPI verified that this artifact, at this checksum, originated from the publisher listed below.

Signed by GitHub Actions, verified by PyPI on Oct 31, 2026.

Transparency log

Release files / smashtable-0.3.3-cp312-cp312-macosx_11_0_arm64.whl

Download URL smashtable-0.3.3-cp312-cp312-macosx_11_0_arm64.whl
Size 759.1 kB
Tags CPython 3.12 macOS 11.0+ ARM64
SHA-256 checksum
How to use checksums
d8bed5a8faca4b7d27ed036f79aa9c173f1ea6f2770dbea3c8ce6eb710070ad8
BLAKE2b-256 checksum
How to use checksums
c43bde486519be836252600fd511718b1f9bd71c922899fd17be6c8fd363923a
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
Yes
Uploaded via twine/7.0.0 CPython/3.13.16

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

PyPI Publish Attestation

PyPI verified that this artifact, at this checksum, originated from the publisher listed below.

Signed by GitHub Actions, verified by PyPI on Oct 31, 2026.

Transparency log

Security for smashtable 0.3.3

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

Full provenance

All 32 files in this release have been uploaded with provenance metadata.

Select from 32 files

Attestation for smashtable-0.3.3.tar.gz

PyPI Publish Attestation

PyPI verified that this artifact, at this checksum, originated from the publisher listed below.

Signed by GitHub Actions, verified by PyPI on Oct 31, 2026.

Transparency log

A note on package security

PyPI is a repository for distributing packages, not a service for auditing them. While third-party security researchers and our staff do their best to detect and remove malicious packages, PyPI cannot guarantee the quality, security or suitability of any given package.

To learn more about protecting yourself from malicious actors, visit our package security documentation.

Anthropic, PBC Visionary sponsor Bloomberg Visionary sponsor Hudson River Trading Visionary sponsor Meta Visionary sponsor NVIDIA Visionary sponsor Microsoft Sustainability sponsor Depot Continuous Integration AWS Cloud computing and Security Sponsor Datadog Monitoring Fastly CDN Google Download Analytics Sentry Error logging StatusPage Status page