\n\n \n\n## What is SpacetimeDB?\n\nSpacetimeDB is a relational database that is also a server. You upload your application logic directly into the database, and clients connect to it without any server in between.\n\nWrite your schema and business logic as a **module** in [Rust](https://spacetimedb.com/docs/quickstarts/rust), [C#](https://spacetimedb.com/docs/quickstarts/c-sharp), [TypeScript](https://spacetimedb.com/docs/quickstarts/typescript), or [C++](https://spacetimedb.com/docs/quickstarts/c-plus-plus). SpacetimeDB compiles it, runs it inside the database, and automatically synchronizes state to connected clients in real-time.\n\nInstead of deploying a web or game server that sits in between your clients and your database, your clients connect directly to the database and execute your application logic in your module. You can write all of your permission and authorization logic right inside your module just as you would in a normal server.\n\nThis means that you can write your entire application in a single language and deploy it as a single binary. No more separate webserver, no more containers, no more Kubernetes, no more VMs, no more DevOps, no more caching later. Zero infrastructure to manage.\n\n\n \n \n
SpacetimeDB application architecture (elements in white are provided by SpacetimeDB)
\n \n\n\nSpacetimeDB is optimized for maximum speed and minimum latency. SpacetimeDB provides all the ACID guarantees of a traditional RDBMS, with all the speed of an optimized web server. All application state is held in memory for fast access, while a commit log on disk provides durability and crash recovery. The entire backend of our MMORPG [BitCraft Online](https://bitcraftonline.com) runs as a single SpacetimeDB module: chat, items, terrain, player positions, everything, synchronized to thousands of players in real-time.\n\n## Quick Start\n\n### 1. Install\n\n```bash\n# macOS / Linux\ncurl -sSf https://install.spacetimedb.com | sh\n\n# Windows (PowerShell)\niwr https://windows.spacetimedb.com -useb | iex\n```\n\n### 2. Log in\n\n```bash\nspacetime login\n```\n\nThis opens a browser to authenticate with GitHub. Your identity is linked to your account so you can publish databases.\n\n### 3. Start developing\n\n```bash\nspacetime dev --template chat-react-ts\n```\n\nThat is it. This creates a project from a template, publishes it to [Maincloud](https://spacetimedb.com/docs/how-to/deploy/maincloud), and watches for file changes, automatically rebuilding and republishing on save. See [pricing](https://spacetimedb.com/pricing) for details.\n\n## How It Works\n\nSpacetimeDB modules define **tables** (your data) and **reducers** (your logic). Clients connect, call reducers, and subscribe to tables. When data changes, SpacetimeDB pushes updates to subscribed clients automatically.\n\n```rust\n// Define a table\n#[spacetimedb::table(accessor = messages, public)]\npub struct Message {\n #[primary_key]\n #[auto_inc]\n id: u64,\n sender: Identity,\n text: String,\n}\n\n// Define a reducer (your API endpoint)\n#[spacetimedb::reducer]\npub fn send_message(ctx: &ReducerContext, text: String) {\n ctx.db.messages().insert(Message {\n id: 0,\n sender: ctx.sender,\n text,\n });\n}\n```\n\nOn the client side, subscribe and get live updates:\n\n```typescript\nconst [messages] = useTable(tables.message);\n// messages updates automatically when the server state changes.\n// No polling. No refetching.\n```\n\n## Language Support\n\n### Server Modules\n\nWrite your database logic in any of these languages:\n\n| Language | Quickstart |\n|----------|-----------|\n| **Rust** | [Get started](https://spacetimedb.com/docs/quickstarts/rust) |\n| **C#** | [Get started](https://spacetimedb.com/docs/quickstarts/c-sharp) |\n| **TypeScript** | [Get started](https://spacetimedb.com/docs/quickstarts/typescript) |\n| **C++** | [Get started](https://spacetimedb.com/docs/quickstarts/c-plus-plus) |\n\n### Client SDKs\n\nConnect from any of these platforms:\n\n| SDK | Quickstart |\n|-----|-----------|\n| **TypeScript** (React, Next.js, Vue, Svelte, Angular, Node.js, Bun, Deno) | [Get started](https://spacetimedb.com/docs/quickstarts/react) |\n| **Rust** | [Get started](https://spacetimedb.com/docs/quickstarts/rust) |\n| **C#** (standalone and Unity) | [Get started](https://spacetimedb.com/docs/quickstarts/c-sharp) |\n| **C++** (Unreal Engine) | [Get started](https://spacetimedb.com/docs/quickstarts/c-plus-plus) |\n\n## Running with Docker\n\n```bash\ndocker run --rm --pull always -p 3000:3000 clockworklabs/spacetime start\n```\n\n## Building from Source\n\nIf you need features from `master` that have not been released yet:\n\n```bash\n# Prerequisites: Rust toolchain with wasm32-unknown-unknown target\ncurl https://sh.rustup.rs -sSf | sh\n\ngit clone https://github.com/clockworklabs/SpacetimeDB\ncd SpacetimeDB\ncargo build --locked --release -p spacetimedb-standalone -p spacetimedb-update -p spacetimedb-cli\n```\n\nThen install the binaries:\n\n\nmacOS / Linux\n\n```bash\nmkdir -p ~/.local/bin\nSTDB_VERSION=\"$(./target/release/spacetimedb-cli --version | sed -n 's/.*spacetimedb tool version \\([0-9.]*\\);.*/\\1/p')\"\nmkdir -p ~/.local/share/spacetime/bin/$STDB_VERSION\n\ncp target/release/spacetimedb-update ~/.local/bin/spacetime\ncp target/release/spacetimedb-cli ~/.local/share/spacetime/bin/$STDB_VERSION\ncp target/release/spacetimedb-standalone ~/.local/share/spacetime/bin/$STDB_VERSION\n\n# Add to your shell config if not already present:\nexport PATH=\"$HOME/.local/bin:$PATH\"\n\n# Set the active version:\nspacetime version use $STDB_VERSION\n```\n\n\n\nWindows (PowerShell)\n\n```powershell\n$stdbDir = \"$HOME\\AppData\\Local\\SpacetimeDB\"\n$stdbVersion = & \".\\target\\release\\spacetimedb-cli\" --version |\n Select-String -Pattern 'spacetimedb tool version ([0-9.]+);' |\n ForEach-Object { $_.Matches.Groups[1].Value }\nNew-Item -ItemType Directory -Path \"$stdbDir\\bin\\$stdbVersion\" -Force | Out-Null\n\nCopy-Item \"target\\release\\spacetimedb-update.exe\" \"$stdbDir\\spacetime.exe\"\nCopy-Item \"target\\release\\spacetimedb-cli.exe\" \"$stdbDir\\bin\\$stdbVersion\\\"\nCopy-Item \"target\\release\\spacetimedb-standalone.exe\" \"$stdbDir\\bin\\$stdbVersion\\\"\n\n# Add to your system PATH: %USERPROFILE%\\AppData\\Local\\SpacetimeDB\n# Then in a new shell:\nspacetime version use $stdbVersion\n```\n\n\nVerify with `spacetime --version`.\n\n## Documentation\n\nFull documentation is available at **[spacetimedb.com/docs](https://spacetimedb.com/docs)**, including:\n\n- [Quickstart guides](https://spacetimedb.com/docs) for every supported language and framework\n- [Core concepts](https://spacetimedb.com/docs/core-concepts): tables, reducers, subscriptions, authentication\n- [Tutorials](https://spacetimedb.com/docs/tutorials/chat-app): chat app, Unity multiplayer, Unreal Engine multiplayer\n- [Deployment guide](https://spacetimedb.com/docs/how-to/deploy/maincloud): publishing to Maincloud\n- [CLI reference](https://spacetimedb.com/docs/reference/cli-reference)\n- [SQL reference](https://spacetimedb.com/docs/reference/sql-reference)\n\n## License\n\nSpacetimeDB is licensed under the [Business Source License 1.1 (BSL)](LICENSE.txt). It converts to the AGPL v3.0 with a linking exception after a few years. The linking exception means you are **not** required to open-source your own code if you use SpacetimeDB. You only need to contribute back changes to SpacetimeDB itself.\n\n**Why did we choose this license?**\nWe chose to license SpacetimeDB under the MariaDB Business Source License for 4 years because we can't compete with AWS while also building our products for them.\n\nWe chose GPLv3 with linking exception as the open source license because we want contributions merged back into mainline (just like Linux), but we don't want to make anyone else open source their own code (i.e. linking exception). \n"
},
{
"path": "clippy.toml",
"content": "disallowed-macros = [\n { path = \"std::print\", reason = \"print blocks on a global mutex for synchronization, and its output cannot be filtered. Use a log macro instead, or apply #[allow(disallowed-macros)] if this is test or CLI code.\" },\n { path = \"std::println\", reason = \"println blocks on a global mutex for synchronization, and its output cannot be filtered. Use a log macro instead, or apply #[allow(disallowed-macros)] if this is test or CLI code.\" },\n { path = \"std::eprint\", reason = \"eprint blocks on a global mutex for synchronization, and its output cannot be filtered. Use a log macro instead, or apply #[allow(disallowed-macros)] if this is test or CLI code.\" },\n { path = \"std::eprintln\", reason = \"eprintln blocks on a global mutex for synchronization, and its output cannot be filtered. Use a log macro instead, or apply #[allow(disallowed-macros)] if this is test or CLI code.\" },\n { path = \"std::dbg\", reason = \"dbg is a debugging tool and should never be committed into the repository.\" },\n]\n"
},
{
"path": "crates/auth/Cargo.toml",
"content": "[package]\nname = \"spacetimedb-auth\"\nversion.workspace = true\nedition.workspace = true\nrust-version.workspace = true\nlicense-file = \"LICENSE\"\ndescription = \"Auth helpers for SpacetimeDB\"\n\n[dependencies]\nspacetimedb-data-structures.workspace = true\nspacetimedb-lib = { workspace = true, features = [\"serde\"] }\n\nanyhow.workspace = true\nserde.workspace = true\nserde_json.workspace = true\nserde_with.workspace = true\njsonwebtoken.workspace = true\n\n[dev-dependencies]\nserde_json.workspace = true\n\n[lints]\nworkspace = true\n"
},
{
"path": "crates/auth/src/identity.rs",
"content": "pub use jsonwebtoken::errors::Error as JwtError;\npub use jsonwebtoken::errors::ErrorKind as JwtErrorKind;\npub use jsonwebtoken::{DecodingKey, EncodingKey};\nuse serde::Deserializer;\nuse serde::{Deserialize, Serialize};\nuse spacetimedb_data_structures::map::HashMap;\nuse spacetimedb_lib::Identity;\nuse std::time::SystemTime;\n\n#[derive(Debug, Clone)]\npub struct ConnectionAuthCtx {\n pub claims: SpacetimeIdentityClaims,\n pub jwt_payload: Box,\n}\n\nimpl TryFrom for ConnectionAuthCtx {\n type Error = anyhow::Error;\n fn try_from(claims: SpacetimeIdentityClaims) -> Result {\n let payload = serde_json::to_string(&claims).map_err(|e| anyhow::anyhow!(\"Failed to serialize claims: {e}\"))?;\n Ok(ConnectionAuthCtx {\n claims,\n jwt_payload: payload.into(),\n })\n }\n}\n\n// These are the claims that can be attached to a request/connection.\n#[serde_with::serde_as]\n#[derive(Debug, Serialize, Deserialize, Clone)]\npub struct SpacetimeIdentityClaims {\n #[serde(rename = \"hex_identity\")]\n pub identity: Identity,\n #[serde(rename = \"sub\")]\n pub subject: Box,\n #[serde(rename = \"iss\")]\n pub issuer: Box,\n #[serde(rename = \"aud\")]\n pub audience: Box<[Box]>,\n\n /// The unix timestamp the token was issued at\n #[serde_as(as = \"serde_with::TimestampSeconds\")]\n pub iat: SystemTime,\n #[serde_as(as = \"Option\")]\n pub exp: Option,\n\n #[serde(flatten)]\n pub extra: Option, serde_json::Value>>,\n}\n\nfn deserialize_audience<'de, D>(deserializer: D) -> Result]>, D::Error>\nwhere\n D: Deserializer<'de>,\n{\n // By using `untagged`, it will try the different options.\n #[derive(Deserialize)]\n #[serde(untagged)]\n enum Audience {\n Single(Box),\n Multiple(Box<[Box]>),\n }\n\n // Deserialize into the enum\n let audience = Audience::deserialize(deserializer)?;\n\n // Convert the enum into a list.\n Ok(match audience {\n Audience::Single(s) => [s].into(),\n Audience::Multiple(v) => v,\n })\n}\n\n// IncomingClaims are from the token we receive from the client.\n// The signature should be verified already, but further validation is needed to have a SpacetimeIdentityClaims2.\n#[serde_with::serde_as]\n#[derive(Debug, Serialize, Deserialize)]\npub struct IncomingClaims {\n #[serde(rename = \"hex_identity\")]\n pub identity: Option,\n #[serde(rename = \"sub\")]\n pub subject: Box,\n #[serde(rename = \"iss\")]\n pub issuer: Box,\n #[serde(rename = \"aud\", default, deserialize_with = \"deserialize_audience\")]\n pub audience: Box<[Box]>,\n\n /// The unix timestamp the token was issued at\n #[serde_as(as = \"serde_with::TimestampSeconds\")]\n pub iat: SystemTime,\n #[serde_as(as = \"Option\")]\n pub exp: Option,\n\n /// All remaining claims from the JWT payload\n #[serde(flatten)]\n pub extra: Option, serde_json::Value>>,\n}\n\nimpl TryInto for IncomingClaims {\n type Error = anyhow::Error;\n\n fn try_into(self) -> anyhow::Result {\n // The issuer and subject must be less than 128 bytes.\n if self.issuer.len() > 128 {\n return Err(anyhow::anyhow!(\"Issuer too long: {:?}\", self.issuer));\n }\n if self.subject.len() > 128 {\n return Err(anyhow::anyhow!(\"Subject too long: {:?}\", self.subject));\n }\n // The issuer and subject must be non-empty.\n if self.issuer.is_empty() {\n return Err(anyhow::anyhow!(\"Issuer empty\"));\n }\n if self.subject.is_empty() {\n return Err(anyhow::anyhow!(\"Subject empty\"));\n }\n\n let computed_identity = Identity::from_claims(&self.issuer, &self.subject);\n // If an identity is provided, it must match the computed identity.\n if let Some(token_identity) = self.identity\n && token_identity != computed_identity\n {\n return Err(anyhow::anyhow!(\n \"Identity mismatch: token identity {token_identity:?} does not match computed identity {computed_identity:?}\",\n ));\n }\n\n Ok(SpacetimeIdentityClaims {\n identity: computed_identity,\n subject: self.subject,\n issuer: self.issuer,\n audience: self.audience,\n iat: self.iat,\n exp: self.exp,\n extra: self.extra,\n })\n }\n}\n\n#[cfg(test)]\nmod tests {\n use super::*;\n use serde_json::json;\n use std::time::UNIX_EPOCH;\n\n #[test]\n fn test_deserialize_audience_single_string() {\n let json_data = json!({\n \"sub\": \"123\",\n \"iss\": \"example.com\",\n \"aud\": \"audience1\",\n \"iat\": 1693425600,\n \"exp\": 1693512000\n });\n\n let claims: IncomingClaims = serde_json::from_value(json_data).unwrap();\n\n assert_eq!(claims.audience, [\"audience1\".into()].into());\n assert_eq!(&*claims.subject, \"123\");\n assert_eq!(&*claims.issuer, \"example.com\");\n assert_eq!(claims.iat, UNIX_EPOCH + std::time::Duration::from_secs(1693425600));\n assert_eq!(\n claims.exp,\n Some(UNIX_EPOCH + std::time::Duration::from_secs(1693512000))\n );\n }\n\n #[test]\n fn test_deserialize_audience_multiple_strings() {\n let json_data = json!({\n \"sub\": \"123\",\n \"iss\": \"example.com\",\n \"aud\": [\"audience1\", \"audience2\"],\n \"iat\": 1693425600,\n \"exp\": 1693512000\n });\n\n let claims: IncomingClaims = serde_json::from_value(json_data).unwrap();\n\n assert_eq!(claims.audience, [\"audience1\".into(), \"audience2\".into()].into());\n assert_eq!(&*claims.subject, \"123\");\n assert_eq!(&*claims.issuer, \"example.com\");\n assert_eq!(claims.iat, UNIX_EPOCH + std::time::Duration::from_secs(1693425600));\n assert_eq!(\n claims.exp,\n Some(UNIX_EPOCH + std::time::Duration::from_secs(1693512000))\n );\n }\n\n #[test]\n fn test_deserialize_audience_missing_field() {\n let json_data = json!({\n \"sub\": \"123\",\n \"iss\": \"example.com\",\n \"iat\": 1693425600,\n \"exp\": 1693512000\n });\n\n let claims: IncomingClaims = serde_json::from_value(json_data).unwrap();\n\n assert!(claims.audience.is_empty()); // Since `default` is used, it should be an empty vector\n assert_eq!(&*claims.subject, \"123\");\n assert_eq!(&*claims.issuer, \"example.com\");\n assert_eq!(claims.iat, UNIX_EPOCH + std::time::Duration::from_secs(1693425600));\n assert_eq!(\n claims.exp,\n Some(UNIX_EPOCH + std::time::Duration::from_secs(1693512000))\n );\n }\n}\n"
},
{
"path": "crates/auth/src/lib.rs",
"content": "pub mod identity;\n"
},
{
"path": "crates/bench/.gitignore",
"content": ".spacetime/\ntarget/\n"
},
{
"path": "crates/bench/Cargo.toml",
"content": "[package]\nname = \"spacetimedb-bench\"\nversion.workspace = true\nedition.workspace = true\nlicense-file = \"LICENSE\"\ndescription = \"Bench library/utility for SpacetimeDB\"\npublish = false\n\n[[bench]]\nname = \"special\"\nharness = false\n\n[[bench]]\nname = \"generic\"\nharness = false\n\n[[bench]]\nname = \"callgrind\"\nharness = false\n\n[[bench]]\nname = \"subscription\"\nharness = false\n\n[[bench]]\nname = \"delete_table\"\nharness = false\n\n[[bench]]\nname = \"index\"\nharness = false\n\n[[bin]]\nname = \"summarize\"\n\n[lib]\nbench = false\n\n[dependencies]\nspacetimedb-client-api = { path = \"../client-api\" }\nspacetimedb-client-api-messages = { path = \"../client-api-messages\" }\nspacetimedb-core = { path = \"../core\", features = [\"test\"] }\nspacetimedb-data-structures.workspace = true\nspacetimedb-datastore.workspace = true\nspacetimedb-execution = { path = \"../execution\" }\nspacetimedb-lib = { path = \"../lib\" }\nspacetimedb-paths.workspace = true\nspacetimedb-primitives = { path = \"../primitives\" }\nspacetimedb-query = { path = \"../query\" }\nspacetimedb-sats = { path = \"../sats\" }\nspacetimedb-schema = { workspace = true, features = [\"test\"] }\nspacetimedb-standalone = { path = \"../standalone\" }\nspacetimedb-table = { path = \"../table\" }\nspacetimedb-testing = { path = \"../testing\" }\n\nahash.workspace = true\nanyhow.workspace = true\nconvert_case.workspace = true\nanymap.workspace = true\nbyte-unit.workspace = true\nclap.workspace = true\ncriterion.workspace = true\nfutures.workspace = true\nfoldhash.workspace = true\nhashbrown.workspace = true\nlazy_static.workspace = true\nlog.workspace = true\nmimalloc.workspace = true\nrand.workspace = true\nregex.workspace = true\nrusqlite.workspace = true\nserde.workspace = true\nserde_json.workspace = true\nserial_test.workspace = true\nsmallvec.workspace = true\ntempdir.workspace = true\ntokio.workspace = true\ntracing-subscriber.workspace = true\nwalkdir.workspace = true\nitertools.workspace = true\n\n[target.'cfg(not(target_env = \"msvc\"))'.dependencies]\ntikv-jemallocator = { workspace = true }\ntikv-jemalloc-ctl = { workspace = true }\n\n[target.'cfg(target_os = \"linux\")'.dependencies]\n# only try to build these on linux\n\n# also:\n# we've forked iai-callgrind to add custom entrypoint support.\n# FIXME(jgilles): revert to depending on the crates version if we ever get that upstreamed.\n\n# iai-callgrind = \"0.7.2\"\niai-callgrind = { git = \"https://github.com/clockworklabs/iai-callgrind.git\", branch = \"main\" }\niai-callgrind-runner = { git = \"https://github.com/clockworklabs/iai-callgrind.git\", branch = \"main\" }\niai-callgrind-macros = { git = \"https://github.com/clockworklabs/iai-callgrind.git\", branch = \"main\" }\n\n[lints]\nworkspace = true\n"
},
{
"path": "crates/bench/Dockerfile",
"content": "# Dockerfile for callgrind benchmarking environment.\n# Set up to run from linux / WSL (running from a windows file system will be extremely slow).\n# See the README for commands to run.\n\n# sync with: ../../rust-toolchain.toml\nFROM rust:1.93.0\n\nRUN apt-get update && \\\n apt-get install -y valgrind bash && \\\n rm -rf /var/lib/apt/lists/*\n\nENV CARGO_TARGET_DIR=/projects/SpacetimeDB/linux-target\nENV CARGO_HOME=/projects/SpacetimeDB/linux-cache\nENV RUSTUP_HOME=/projects/SpacetimeDB/linux-rustup\n\nRUN cargo install --git https://github.com/clockworklabs/iai-callgrind.git --branch main iai-callgrind-runner\n"
},
{
"path": "crates/bench/README.md",
"content": "# spacetimedb-bench\n\n> ⚠️ **Internal Crate** ⚠️\n>\n> This crate is intended for internal use only. It is **not** stable and may change without notice.\n\nBenchmarking suite for SpacetimeDB using [Criterion](https://github.com/bheisler/criterion.rs) and [Callgrind](https://valgrind.org/docs/manual/cl-manual.html) (via [iai-callgrind](https://github.com/clockworklabs/iai-callgrind)). Provides comparisons between the underlying spacetime datastore, spacetime modules, and sqlite.\n\nTo run the criterion benchmarks:\n\n```bash\ncargo bench --bench generic --bench special\n```\n\nTo enable the criterion benchmarks that do one million inserts or updates, set the RUN_ONE_MILLION environment variable:\n\n```bash\nRUN_ONE_MILLION=true cargo bench --bench generic --bench special\n```\n\nTo run the callgrind benchmarks, you need valgrind installed.\nThe easiest way to get it is to use the docker image in this folder. \nThere's a handy bash script:\n```bash\nbash callgrind-docker.sh \n```\nWhich will build the docker image and run the callgrind benchmarks inside of it.\n\nYou can also comment \"benchmarks please\" or \"callgrind please\" on a pull request in the SpacetimeDB repository to run the criterion/callgrind benchmarks on that PR. The results will be posted in a comment on the PR.\n\nThis is coordinated using the benchmarks GitHub Actions: see [`../../.github/workflows/benchmarks.yml`](../../.github/workflows/benchmarks.yml), and\n[`../../.github/workflows/callgrind_benchmarks.yml`](../../.github/workflows/callgrind_benchmarks.yml). \nThese also rely on the benchmarks-viewer application (https://github.com/clockworklabs/benchmarks-viewer).\n\n\n## Caveats\n\nThe criterion benchmarks take a long time to run -- there are a lot of them. See below for information on running select groups of them.\n\nThe callgrind benchmarks only measure a select portion of the codebase. In particular, they do not collect instruction counts in any async code, due to callgrind limitations; they only time the synchronous code that runs a reducer / the client code that calls a reducer. This is most of the code that it takes to run a reducer, including all database modifications. The async code between client and reducer is mostly just handing off data through a couple of channels. Still, if you're interested in measuring that code, you should rely on the criterion benchmarks & `perf`.\n\n\n\n## Criterion benchmarks\nTimings for spacetime modules should be understood as *latencies to call a spacetime reducer without network delays*. They include serialization and deserialization times for any arguments passed. There are also separate benchmarks that measure these times on their own.\n\nThe complete structure (not yet fully implemented) is as follows:\n\n```\n# generic benchmarks:\n\n[db]/[disk]/\n empty_transaction/\n insert_1/[schema]/[index_type]/[load]\n insert_bulk/[schema]/[index_type]/[load]/[count]\n insert_large_value/[count]\n iterate/[schema]/[count]/\n filter/[string, u64]/[index?]/[load]/[count]\n find_unique/u32/[load]/\n delete/[index_type]/[load]/[count]\n\n# \"load\" refers to the number of rows in the table at the start of the benchmark.\n\n# db: [stdb_raw, stdb_module, sqlite]\n# disk: [disk, mem]\n# schema: [person, location]\n# index_type: [unique, non_unique, multi_index]\n\n# \"person\" is a schema with 2 ints and a string, \"location\" is a schema with 3 ints.\n\nserialize/\n bsatn/[schema]/[count]\n json/[schema]/[count]\n product_value/[schema]/[count]\n\ndeserialize/\n bsatn/[schema]/[count]\n json/[schema]/[count]\n\nstdb_module/\n print_bulk/[count]\n large_arguments/64KiB/\n\ndb_game/\n circles/load=[num rows]\n ia_loop/load=[num rows]\n```\n\nTypically, you don't want to run all benchmarks at once, there are a lot of them and it will take many minutes.\nYou can pass regexes to the bench script to select what slice of benchmarks you'd like. For example,\n\n```sh\ncargo bench -- 'stdb_raw/.*/insert_bulk'\n```\nWill run all of the `insert_bulk` benchmarks against the raw spacetime backend.\n\nSimilarly, \n```sh\ncargo bench -- 'mem/.*/unique'\n```\nWill run benchmarks involving unique primary keys against all databases, without writing to disc.\n\n## Workload Benches\n\nThe workload benches within the `db_game` module are designed to simulate realistic workloads commonly found in games. \n\nInstead of testing for a small set of values, these benches generate a larger number of rows to more effectively stress the database engine. As consequence, they take more time when run inside `criterion`. \n\nThis approach reduces interference caused by noise and provides the potential for better detection of display improvements or regressions in performance.\n\nTo run the workload benches directly outside `criterion`, you can use the following commands:\n\n```bash\ncargo test --release --package spacetimedb-testing --test standalone_integration_test test_calling_bench_db_ia_loop -- --exact --nocapture\ncargo test --release --package spacetimedb-testing --test standalone_integration_test test_calling_bench_db_circles -- --exact --nocapture\n```\n\n## Pretty report\nTo generate a nicely formatted markdown report, you can use the \"summarize\" binary.\nThis is used on CI (see [`../../.github/workflows/benchmarks.yml`](../../.github/workflows/benchmarks.yml)).\n\nTo generate a report without comparisons, use:\n```bash\ncargo bench --bench generic --bench special -- --save-baseline current\ncargo run --bin summarize markdown-report current\n```\n\nTo compare to another branch, do:\n```bash\ngit checkout master\ncargo bench --bench generic --bench special -- --save-baseline base\ngit checkout high-octane-feature-branch\ncargo bench --bench generic --bench special -- --save-baseline current\ncargo run --bin summarize markdown-report current base\n```\n\nOf course, this will take about an hour, so it might be better to let the CI do it for you.\n\n## Adding more\n\nThere are two ways to write benchmarks:\n\n- Targeted, non-generic benchmarks (`benches/special.rs`)\n- Generic over database backends (`benches/generic.rs`)\n\nSee the following sections for how to write these.\n\n#### Targeted benchmarks\nThese are regular [Criterion.rs](https://github.com/bheisler/criterion.rs) benchmarks. Nothing fancy, do whatever you like with these. Put them in `benches/special.rs`.\n\n#### Generic benchmarks\nGeneric benchmarks live in `benches/generic.rs`. These benchmarks involve two traits:\n\n- [`BenchDatabase`](src/database.rs), which is implemented by different database backends.\n- [`BenchTable`](src/schemas.rs), which is implemented by different benchmark tables.\n\nTo add a new generic benchmark, you'll need to:\n- Add a relevant method to the `BenchDatabase` trait.\n- Implement it for each `BenchDatabase` implementation.\n - [`SQLite`](src/sqlite.rs) will require you to write it as a SQL query and submit that to sqlite.\n - [`SpacetimeRaw`](src/spacetime_raw.rs) will require you to execute the query against the Spacetime database backend directly.\n - [`SpacetimeModule`](src/spacetime_module.rs) will require you to add a reducer to the [`benchmarks`](../../modules/benchmarks/src/lib.rs) crate, and then add logic to invoke your reducer with the correct arguments.\n- Add a benchmark harness that actually invokes your method in `benches/generic.rs`.\n\n\n## Callgrind benchmarks\nThese live in `benches/callgrind.rs` and can only be run on linux, although a docker image is provided above.\nSee that f\n\n\n## Install tools\n\nThere are also some scripts that rely on external tools to extract data from the benchmarks.\n\n### OSX + Linux\n\n- [samply](https://github.com/mstange/samply/)\n\n```bash\ncargo install samply\n```\nRun *any* command to see perf data on Firefox:\n\n```bash\n# Note if the `cargo` command triggers compilation, it will also be captured in the profile.\n# Therefore it is useful to run this after the artifact has already been cached.\nsamply record -r 10000000 cargo bench --bench=subscription --profile=profiling -- full-scan --exact --profile-time=30\n```\n\n### OSX Only\n\n- [cargo-instrument](https://github.com/cmyr/cargo-instruments)\n\n```bash\nbrew install cargo-instruments\n```\n\n```bash\n# ./instruments.sh TEMPLATE BENCHMARK BENCHMARK_FILTER\n./instruments.sh time generic stdb_raw/mem/insert_bulk/location/multi_index/load=0/count=100\n```\n\nWhere `TEMPLATE` is one from \n\n```bash\ncargo instruments --list-templates\n```\n\n\n### Linux only\n\n- [cargo-flamegraph](https://github.com/flamegraph-rs/flamegraph)\n\n```bash\ncargo install flamegraph\n```\n\nYou can generate flamegraphs using `flamegraph.sh` script:\n\n```bash\n# ./flamegraph.sh BENCH_EXECUTABLE FILTER SVG_PATH\n./flamegraph.sh generic stdb_raw/mem/insert_bulk/location/multi_index/load=0/count=100 result.svg\"\n```"
},
{
"path": "crates/bench/benches/callgrind.rs",
"content": "#[cfg(target_os = \"linux\")]\nmod callgrind_benches {\n\n /// Benchmarks that run under our iai-callgrind fork (https://github.com/clockworklabs/iai-callgrind)\n /// Callgrind (https://valgrind.org/docs/manual/cl-manual.html) disassembles linux binaries\n /// as they run to insert instrumentation code. This allows for benchmarking with minimal variance,\n /// compared to timing benchmarks.\n ///\n /// Note: you CAN'T save state between these benchmarks, since each is run\n /// in a fresh process.\n ///\n /// FIXME(jgilles): many of the spacetime_module benchmarks are currently disabled due to a bad interaction with sled (issue #564).\n ///\n /// There is some odd boilerplate in this file that is used to make downstream processing of these benchmarks easier.\n /// Every benchmark is a struct that implements serde::Deserialize; these structs contain some redundant information.\n /// Benchmarks are actually dispatched using iai-callgrind's `#[library_benchmark]` macro.\n /// We pass benchmark configurations as JSON strings to these benchmarks.\n /// This JSON ends up in iai-callgrind's output file; we parse all relevant information out of it.\n /// (In the `crate/src/bin/summarize.rs` binary.)\n use iai_callgrind::{library_benchmark, library_benchmark_group, LibraryBenchmarkConfig};\n use serde::Deserialize;\n\n use spacetimedb_bench::{\n database::BenchDatabase,\n schemas::{create_partly_identical, create_sequential, u32_u64_str, BenchTable, IndexStrategy, RandomTable},\n spacetime_raw::SpacetimeRaw,\n sqlite::SQLite,\n };\n use spacetimedb_lib::{AlgebraicType, ProductValue};\n\n /// A benchmark.\n ///\n /// The benchmark information consists of metadata that can be deserialized from JSON.\n /// The JSON is embedded in the output generated by iai-callgrind, which\n /// makes writing downstream tools a lot easier.\n ///\n // TODO(jgilles): use this infra in the non-callgrind benches as well.\n trait Benchmark: Deserialize<'static> {\n fn run_benchmark(self);\n }\n\n // ========================= INSERT BULK =========================\n\n #[derive(Deserialize)]\n struct InsertBulkBenchmark {\n bench: String,\n db: String,\n in_memory: bool,\n schema: String,\n indices: IndexStrategy,\n preload: u32,\n count: u32,\n #[serde(skip)]\n _marker: std::marker::PhantomData<(DB, T)>,\n }\n\n impl Benchmark for InsertBulkBenchmark {\n fn run_benchmark(self) {\n assert_eq!(self.bench, \"insert bulk\", \"provided metadata has incorrect bench name\");\n assert_eq!(self.db, DB::name(), \"provided metadata has incorrect db name\");\n assert_eq!(self.schema, T::name(), \"provided metadata has incorrect db name\");\n\n let mut db = DB::build(self.in_memory).unwrap();\n\n let table_id = db.create_table::(self.indices).unwrap();\n let mut data = create_sequential::(0xdeadbeef, self.count + self.preload, 64);\n let to_preload = data.split_off(self.count as usize);\n\n // warm up\n db.insert_bulk(&table_id, data.clone()).unwrap();\n db.clear_table(&table_id).unwrap();\n\n // add preload data\n db.insert_bulk(&table_id, to_preload).unwrap();\n\n // measure\n spacetimedb::callgrind_flag::enable_callgrind_globally(|| {\n db.insert_bulk(&table_id, data).unwrap();\n });\n\n // clean up\n db.clear_table(&table_id).unwrap();\n }\n }\n\n #[library_benchmark]\n #[bench::mem_unique_64(r#\"{\"bench\":\"insert bulk\", \"db\": \"stdb_raw\", \"in_memory\": true, \"schema\": \"u32_u64_str\", \"indices\": \"unique_0\", \"preload\": 128, \"count\": 64}\"#)]\n #[bench::mem_btree_each_column_64(r#\"{\"bench\":\"insert bulk\", \"db\": \"stdb_raw\", \"in_memory\": true, \"schema\": \"u32_u64_str\", \"indices\": \"btree_each_column\", \"preload\": 128, \"count\": 64}\"#)]\n #[bench::disk_unique_64(r#\"{\"bench\":\"insert bulk\", \"db\": \"stdb_raw\", \"in_memory\": false, \"schema\": \"u32_u64_str\", \"indices\": \"unique_0\", \"preload\": 128, \"count\": 64}\"#)]\n #[bench::disk_btree_each_column_64(r#\"{\"bench\":\"insert bulk\", \"db\": \"stdb_raw\", \"in_memory\": false, \"schema\": \"u32_u64_str\", \"indices\": \"btree_each_column\", \"preload\": 128, \"count\": 64}\"#)]\n fn insert_bulk_raw_u32_u64_str(metadata: &str) {\n let bench: InsertBulkBenchmark = serde_json::from_str(metadata).unwrap();\n bench.run_benchmark();\n }\n\n #[library_benchmark]\n #[bench::mem_unique_64(r#\"{\"bench\":\"insert bulk\", \"db\": \"sqlite\", \"in_memory\": true, \"schema\": \"u32_u64_str\", \"indices\": \"unique_0\", \"preload\": 128, \"count\": 64}\"#)]\n #[bench::mem_btree_each_column_64(r#\"{\"bench\":\"insert bulk\", \"db\": \"sqlite\", \"in_memory\": true, \"schema\": \"u32_u64_str\", \"indices\": \"btree_each_column\", \"preload\": 128, \"count\": 64}\"#)]\n #[bench::disk_unique_64(r#\"{\"bench\":\"insert bulk\", \"db\": \"sqlite\", \"in_memory\": false, \"schema\": \"u32_u64_str\", \"indices\": \"unique_0\", \"preload\": 128, \"count\": 64}\"#)]\n #[bench::disk_btree_each_column_64(r#\"{\"bench\":\"insert bulk\", \"db\": \"sqlite\", \"in_memory\": false, \"schema\": \"u32_u64_str\", \"indices\": \"btree_each_column\", \"preload\": 128, \"count\": 64}\"#)]\n fn insert_bulk_sqlite_u32_u64_str(metadata: &str) {\n let bench: InsertBulkBenchmark = serde_json::from_str(metadata).unwrap();\n bench.run_benchmark();\n }\n\n library_benchmark_group!(\n name = insert_bulk_group;\n benchmarks = insert_bulk_raw_u32_u64_str, /*insert_bulk_module_u32_u64_str,*/ insert_bulk_sqlite_u32_u64_str\n );\n\n // ========================= UPDATE BULK =========================\n\n #[derive(Deserialize)]\n struct UpdateBulkBenchmark {\n bench: String,\n db: String,\n in_memory: bool,\n schema: String,\n indices: IndexStrategy,\n preload: u32,\n count: u32,\n #[serde(skip)]\n _marker: std::marker::PhantomData<(DB, T)>,\n }\n\n impl Benchmark for UpdateBulkBenchmark {\n fn run_benchmark(self) {\n assert_eq!(self.bench, \"update bulk\", \"provided metadata has incorrect bench name\");\n assert_eq!(self.db, DB::name(), \"provided metadata has incorrect db name\");\n assert_eq!(self.schema, T::name(), \"provided metadata has incorrect db name\");\n assert_eq!(\n self.indices,\n IndexStrategy::Unique0,\n \"provided metadata has incorrect index strategy\"\n );\n\n let mut db = DB::build(self.in_memory).unwrap();\n\n let table_id = db.create_table::(self.indices).unwrap();\n let data = create_sequential::(0xdeadbeef, self.preload, 64);\n\n // warm up\n db.insert_bulk(&table_id, data).unwrap();\n db.update_bulk::(&table_id, self.count).unwrap();\n\n // measure\n spacetimedb::callgrind_flag::enable_callgrind_globally(|| {\n db.update_bulk::(&table_id, self.count).unwrap();\n });\n\n // clean up\n db.clear_table(&table_id).unwrap();\n }\n }\n\n #[library_benchmark]\n #[bench::mem_64(r#\"{\"bench\":\"update bulk\", \"db\": \"stdb_raw\", \"in_memory\": true, \"schema\": \"u32_u64_str\", \"indices\": \"unique_0\", \"preload\": 128, \"count\": 64}\"#)]\n #[bench::mem_1024(r#\"{\"bench\":\"update bulk\", \"db\": \"stdb_raw\", \"in_memory\": true, \"schema\": \"u32_u64_str\", \"indices\": \"unique_0\", \"preload\": 1024, \"count\": 1024}\"#)]\n #[bench::disk_64(r#\"{\"bench\":\"update bulk\", \"db\": \"stdb_raw\", \"in_memory\": false, \"schema\": \"u32_u64_str\", \"indices\": \"unique_0\", \"preload\": 128, \"count\": 64}\"#)]\n #[bench::disk_1024(r#\"{\"bench\":\"update bulk\", \"db\": \"stdb_raw\", \"in_memory\": false, \"schema\": \"u32_u64_str\", \"indices\": \"unique_0\", \"preload\": 1024, \"count\": 1024}\"#)]\n fn update_bulk_raw_u32_u64_str(metadata: &str) {\n let bench: UpdateBulkBenchmark = serde_json::from_str(metadata).unwrap();\n bench.run_benchmark();\n }\n\n #[library_benchmark]\n #[bench::mem_64(r#\"{\"bench\":\"update bulk\", \"db\": \"sqlite\", \"in_memory\": true, \"schema\": \"u32_u64_str\", \"indices\": \"unique_0\", \"preload\": 128, \"count\": 64}\"#)]\n #[bench::mem_1024(r#\"{\"bench\":\"update bulk\", \"db\": \"sqlite\", \"in_memory\": true, \"schema\": \"u32_u64_str\", \"indices\": \"unique_0\", \"preload\": 1024, \"count\": 1024}\"#)]\n #[bench::disk_64(r#\"{\"bench\":\"update bulk\", \"db\": \"sqlite\", \"in_memory\": false, \"schema\": \"u32_u64_str\", \"indices\": \"unique_0\", \"preload\": 128, \"count\": 64}\"#)]\n #[bench::disk_1024(r#\"{\"bench\":\"update bulk\", \"db\": \"sqlite\", \"in_memory\": false, \"schema\": \"u32_u64_str\", \"indices\": \"unique_0\", \"preload\": 1024, \"count\": 1024}\"#)]\n fn update_bulk_sqlite_u32_u64_str(metadata: &str) {\n let bench: UpdateBulkBenchmark = serde_json::from_str(metadata).unwrap();\n bench.run_benchmark();\n }\n\n library_benchmark_group!(\n name = update_bulk_group;\n benchmarks = update_bulk_raw_u32_u64_str, /*update_bulk_module_u32_u64_str,*/ update_bulk_sqlite_u32_u64_str\n );\n\n // ========================= ITERATE =========================\n\n #[derive(Deserialize)]\n struct IterateBenchmark {\n bench: String,\n db: String,\n in_memory: bool,\n schema: String,\n indices: IndexStrategy,\n count: u32,\n #[serde(skip)]\n _marker: std::marker::PhantomData<(DB, T)>,\n }\n\n impl Benchmark for IterateBenchmark {\n fn run_benchmark(self) {\n assert_eq!(self.bench, \"iterate\", \"provided metadata has incorrect bench name\");\n assert_eq!(self.db, DB::name(), \"provided metadata has incorrect db name\");\n assert_eq!(self.schema, T::name(), \"provided metadata has incorrect db name\");\n\n let mut db = DB::build(self.in_memory).unwrap();\n\n let table_id = db.create_table::(self.indices).unwrap();\n let data = create_sequential::(0xdeadbeef, self.count, 64);\n\n // warm up\n db.insert_bulk(&table_id, data).unwrap();\n db.iterate(&table_id).unwrap();\n\n // measure\n spacetimedb::callgrind_flag::enable_callgrind_globally(|| {\n db.iterate(&table_id).unwrap();\n });\n\n // clean up\n db.clear_table(&table_id).unwrap();\n }\n }\n\n #[library_benchmark]\n #[bench::mem_64(\n r#\"{\"bench\": \"iterate\", \"db\": \"stdb_raw\", \"in_memory\": true, \"schema\": \"u32_u64_str\", \"indices\": \"unique_0\", \"count\": 64}\"#\n )]\n #[bench::mem_1024(\n r#\"{\"bench\": \"iterate\", \"db\": \"stdb_raw\", \"in_memory\": true, \"schema\": \"u32_u64_str\", \"indices\": \"unique_0\", \"count\": 1024}\"#\n )]\n #[bench::disk_64(\n r#\"{\"bench\": \"iterate\", \"db\": \"stdb_raw\", \"in_memory\": false, \"schema\": \"u32_u64_str\", \"indices\": \"unique_0\", \"count\": 64}\"#\n )]\n #[bench::disk_1024(\n r#\"{\"bench\": \"iterate\", \"db\": \"stdb_raw\", \"in_memory\": false, \"schema\": \"u32_u64_str\", \"indices\": \"unique_0\", \"count\": 1024}\"#\n )]\n fn iterate_raw_u32_u64_str(metadata: &str) {\n let bench: IterateBenchmark = serde_json::from_str(metadata).unwrap();\n bench.run_benchmark();\n }\n\n #[library_benchmark]\n #[bench::mem_64(\n r#\"{\"bench\": \"iterate\", \"db\": \"sqlite\", \"in_memory\": true, \"schema\": \"u32_u64_str\", \"indices\": \"unique_0\", \"count\": 64}\"#\n )]\n #[bench::mem_1024(\n r#\"{\"bench\": \"iterate\", \"db\": \"sqlite\", \"in_memory\": true, \"schema\": \"u32_u64_str\", \"indices\": \"unique_0\", \"count\": 1024}\"#\n )]\n #[bench::disk_64(\n r#\"{\"bench\": \"iterate\", \"db\": \"sqlite\", \"in_memory\": false, \"schema\": \"u32_u64_str\", \"indices\": \"unique_0\", \"count\": 64}\"#\n )]\n #[bench::disk_1024(\n r#\"{\"bench\": \"iterate\", \"db\": \"sqlite\", \"in_memory\": false, \"schema\": \"u32_u64_str\", \"indices\": \"unique_0\", \"count\": 1024}\"#\n )]\n fn iterate_sqlite_u32_u64_str(metadata: &str) {\n let bench: IterateBenchmark = serde_json::from_str(metadata).unwrap();\n bench.run_benchmark();\n }\n\n library_benchmark_group!(\n name = iterate_group;\n benchmarks = iterate_raw_u32_u64_str, /*iterate_module_u32_u64_str,*/ iterate_sqlite_u32_u64_str\n );\n\n // ========================= FILTER =========================\n\n #[derive(Deserialize)]\n struct FilterBenchmark {\n bench: String,\n db: String,\n in_memory: bool,\n schema: String,\n indices: IndexStrategy,\n count: u32,\n preload: u32,\n // Underscore here cause it's an implementation detail.\n // The only thing downstream cares about is data_type\n _column: u16,\n data_type: String,\n #[serde(skip)]\n _marker: std::marker::PhantomData<(DB, T)>,\n }\n\n impl Benchmark for FilterBenchmark {\n fn run_benchmark(self) {\n assert_eq!(self.bench, \"filter\", \"provided metadata has incorrect bench name\");\n assert_eq!(self.db, DB::name(), \"provided metadata has incorrect db name\");\n assert_eq!(self.schema, T::name(), \"provided metadata has incorrect db name\");\n\n let filter_column_type = match T::product_type().elements[self._column as usize].algebraic_type {\n AlgebraicType::String => \"string\",\n AlgebraicType::U32 => \"u32\",\n AlgebraicType::U64 => \"u64\",\n _ => unimplemented!(),\n };\n assert_eq!(\n filter_column_type, self.data_type,\n \"provided metadata has incorrect data type\"\n );\n\n let mut db = DB::build(self.in_memory).unwrap();\n\n let table_id = db.create_table::(self.indices).unwrap();\n let data = create_partly_identical::(0xdeadbeef, self.count as u64, self.preload as u64);\n\n // create_partly_identical guarantees that the first `count` elements will be identical\n let filter_value = data[0].clone().into_product_value().elements[self._column as usize].clone();\n\n // warm up\n db.insert_bulk(&table_id, data).unwrap();\n db.filter::(&table_id, self._column, filter_value.clone()).unwrap();\n\n // measure\n spacetimedb::callgrind_flag::enable_callgrind_globally(|| {\n db.filter::(&table_id, self._column, filter_value.clone()).unwrap();\n });\n\n // clean up\n db.clear_table(&table_id).unwrap();\n }\n }\n\n #[library_benchmark]\n #[bench::string_mem_no_index_64_from_128(\n r#\"{\"bench\": \"filter\", \"db\": \"stdb_raw\", \"in_memory\": true, \"schema\": \"u32_u64_str\", \"indices\": \"no_index\",\n \"count\": 64, \"preload\": 128, \"_column\": 2, \"data_type\": \"string\"}\"#\n )]\n #[bench::string_mem_btree_64_from_128(\n r#\"{\"bench\": \"filter\", \"db\": \"stdb_raw\", \"in_memory\": true, \"schema\": \"u32_u64_str\", \"indices\": \"btree_each_column\",\n \"count\": 64, \"preload\": 128, \"_column\": 2, \"data_type\": \"string\"}\"#\n )]\n #[bench::u64_mem_no_index_64_from_128(\n r#\"{\"bench\": \"filter\", \"db\": \"stdb_raw\", \"in_memory\": true, \"schema\": \"u32_u64_str\", \"indices\": \"no_index\",\n \"count\": 64, \"preload\": 128, \"_column\": 1, \"data_type\": \"u64\"}\"#\n )]\n #[bench::u64_mem_btree_64_from_128(\n r#\"{\"bench\": \"filter\", \"db\": \"stdb_raw\", \"in_memory\": true, \"schema\": \"u32_u64_str\", \"indices\": \"btree_each_column\",\n \"count\": 64, \"preload\": 128, \"_column\": 1, \"data_type\": \"u64\"}\"#\n )]\n #[bench::string_disk_no_index_64_from_128(\n r#\"{\"bench\": \"filter\", \"db\": \"stdb_raw\", \"in_memory\": false, \"schema\": \"u32_u64_str\", \"indices\": \"no_index\",\n \"count\": 64, \"preload\": 128, \"_column\": 2, \"data_type\": \"string\"}\"#\n )]\n #[bench::string_disk_btree_64_from_128(\n r#\"{\"bench\": \"filter\", \"db\": \"stdb_raw\", \"in_memory\": false, \"schema\": \"u32_u64_str\", \"indices\": \"btree_each_column\",\n \"count\": 64, \"preload\": 128, \"_column\": 2, \"data_type\": \"string\"}\"#\n )]\n #[bench::u64_disk_no_index_64_from_128(\n r#\"{\"bench\": \"filter\", \"db\": \"stdb_raw\", \"in_memory\": false, \"schema\": \"u32_u64_str\", \"indices\": \"no_index\",\n \"count\": 64, \"preload\": 128, \"_column\": 1, \"data_type\": \"u64\"}\"#\n )]\n #[bench::u64_disk_btree_64_from_128(\n r#\"{\"bench\": \"filter\", \"db\": \"stdb_raw\", \"in_memory\": false, \"schema\": \"u32_u64_str\", \"indices\": \"btree_each_column\",\n \"count\": 64, \"preload\": 128, \"_column\": 1, \"data_type\": \"u64\"}\"#\n )]\n fn filter_raw_u32_u64_str(metadata: &str) {\n let bench: FilterBenchmark = serde_json::from_str(metadata).unwrap();\n bench.run_benchmark();\n }\n\n #[library_benchmark]\n // string, btree index\n #[bench::string_mem_no_index_64_from_128(\n r#\"{\"bench\": \"filter\", \"db\": \"sqlite\", \"in_memory\": true, \"schema\": \"u32_u64_str\", \"indices\": \"no_index\",\n \"count\": 64, \"preload\": 128, \"_column\": 2, \"data_type\": \"string\"}\"#\n )]\n // string, btree index\n #[bench::string_mem_btree_64_from_128(\n r#\"{\"bench\": \"filter\", \"db\": \"sqlite\", \"in_memory\": true, \"schema\": \"u32_u64_str\", \"indices\": \"btree_each_column\",\n \"count\": 64, \"preload\": 128, \"_column\": 2, \"data_type\": \"string\"}\"#\n )]\n // u64, no index\n #[bench::u64_mem_no_index_64_from_128(\n r#\"{\"bench\": \"filter\", \"db\": \"sqlite\", \"in_memory\": true, \"schema\": \"u32_u64_str\", \"indices\": \"no_index\",\n \"count\": 64, \"preload\": 128, \"_column\": 1, \"data_type\": \"u64\"}\"#\n )]\n // u64, btree index\n #[bench::u64_mem_btree_64_from_128(\n r#\"{\"bench\": \"filter\", \"db\": \"sqlite\", \"in_memory\": true, \"schema\": \"u32_u64_str\", \"indices\": \"btree_each_column\",\n \"count\": 64, \"preload\": 128, \"_column\": 1, \"data_type\": \"u64\"}\"#\n )]\n // string, no index\n #[bench::string_disk_no_index_64_from_128(\n r#\"{\"bench\": \"filter\", \"db\": \"sqlite\", \"in_memory\": false, \"schema\": \"u32_u64_str\", \"indices\": \"no_index\",\n \"count\": 64, \"preload\": 128, \"_column\": 2, \"data_type\": \"string\"}\"#\n )]\n // string, btree index\n #[bench::string_disk_btree_64_from_128(\n r#\"{\"bench\": \"filter\", \"db\": \"sqlite\", \"in_memory\": false, \"schema\": \"u32_u64_str\", \"indices\": \"btree_each_column\",\n \"count\": 64, \"preload\": 128, \"_column\": 2, \"data_type\": \"string\"}\"#\n )]\n // u64, no index\n #[bench::u64_disk_no_index_64_from_128(\n r#\"{\"bench\": \"filter\", \"db\": \"sqlite\", \"in_memory\": false, \"schema\": \"u32_u64_str\", \"indices\": \"no_index\",\n \"count\": 64, \"preload\": 128, \"_column\": 1, \"data_type\": \"u64\"}\"#\n )]\n // u64, btree index\n #[bench::u64_disk_btree_64_from_128(\n r#\"{\"bench\": \"filter\", \"db\": \"sqlite\", \"in_memory\": false, \"schema\": \"u32_u64_str\", \"indices\": \"btree_each_column\",\n \"count\": 64, \"preload\": 128, \"_column\": 1, \"data_type\": \"u64\"}\"#\n )]\n fn filter_sqlite_u32_u64_str(metadata: &str) {\n let bench: FilterBenchmark = serde_json::from_str(metadata).unwrap();\n bench.run_benchmark();\n }\n\n library_benchmark_group!(\n name = filter_group;\n benchmarks = filter_raw_u32_u64_str, /*filter_module_u32_u64_str,*/ filter_sqlite_u32_u64_str\n );\n\n // ========================= FIND =========================\n\n #[derive(Deserialize)]\n #[expect(unused)] // TODO\n struct FindBenchmark {\n bench: String,\n db: String,\n schema: String,\n indices: IndexStrategy,\n preload: u32,\n #[serde(skip)]\n _marker: std::marker::PhantomData<(DB, T)>,\n }\n\n impl Benchmark for FindBenchmark {\n fn run_benchmark(self) {\n assert_eq!(self.bench, \"find\", \"provided metadata has incorrect bench name\");\n assert_eq!(self.db, DB::name(), \"provided metadata has incorrect db name\");\n assert_eq!(self.schema, T::name(), \"provided metadata has incorrect db name\");\n assert_eq!(\n T::product_type().elements[0].algebraic_type,\n AlgebraicType::U32,\n \"primary key in tuple slot 0 must be u32\"\n );\n\n let mut db = DB::build(false).unwrap();\n\n let table_id = db.create_table::(self.indices).unwrap();\n\n let data = create_sequential::(0xdeadbeef, self.preload, 64);\n\n let filter_value = data[(self.preload - 1) as usize].clone().into_product_value().elements[0].clone();\n\n // warm up\n db.insert_bulk(&table_id, data).unwrap();\n db.filter::(&table_id, 0, filter_value.clone()).unwrap();\n\n // measure\n spacetimedb::callgrind_flag::enable_callgrind_globally(|| {\n db.filter::(&table_id, 0, filter_value.clone()).unwrap();\n });\n\n // clean up\n db.clear_table(&table_id).unwrap();\n }\n }\n\n // ========================= EMPTY TRANSACTION =========================\n\n #[derive(Deserialize)]\n struct EmptyTransactionBenchmark {\n bench: String,\n db: String,\n in_memory: bool,\n #[serde(skip)]\n _marker: std::marker::PhantomData,\n }\n\n impl Benchmark for EmptyTransactionBenchmark {\n fn run_benchmark(self) {\n assert_eq!(\n self.bench, \"empty transaction\",\n \"provided metadata has incorrect bench name\"\n );\n assert_eq!(self.db, DB::name(), \"provided metadata has incorrect db name\");\n\n let mut db = DB::build(self.in_memory).unwrap();\n\n // warm up\n db.empty_transaction().unwrap();\n\n // measure\n spacetimedb::callgrind_flag::enable_callgrind_globally(|| db.empty_transaction().unwrap());\n }\n }\n\n #[library_benchmark]\n #[bench::empty_in_mem(r#\"{\"bench\": \"empty transaction\", \"db\": \"stdb_raw\", \"in_memory\": true}\"#)]\n #[bench::empty_on_disk(r#\"{\"bench\": \"empty transaction\", \"db\": \"stdb_raw\", \"in_memory\": false}\"#)]\n fn empty_transaction_raw(metadata: &str) {\n let bench: EmptyTransactionBenchmark = serde_json::from_str(metadata).unwrap();\n bench.run_benchmark();\n }\n\n /*\n #[library_benchmark]\n #[bench::b1(r#\"{\"bench\": \"empty transaction\", \"db\": \"stdb_module\"}\"#)]\n fn empty_transaction_module(metadata: &str) {\n let bench: EmptyTransactionBenchmark = serde_json::from_str(metadata).unwrap();\n bench.run_benchmark();\n }\n */\n\n #[library_benchmark]\n #[bench::empty_in_mem(r#\"{\"bench\": \"empty transaction\", \"db\": \"sqlite\", \"in_memory\": true}\"#)]\n #[bench::empty_on_disk(r#\"{\"bench\": \"empty transaction\", \"db\": \"sqlite\", \"in_memory\": false}\"#)]\n fn empty_transaction_sqlite(metadata: &str) {\n let bench: EmptyTransactionBenchmark = serde_json::from_str(metadata).unwrap();\n bench.run_benchmark();\n }\n\n library_benchmark_group!(\n name = empty_transaction_group;\n benchmarks = empty_transaction_raw, /*empty_transaction_module,*/ empty_transaction_sqlite\n );\n\n // ========================= SERIALIZATION =========================\n\n #[derive(Deserialize)]\n struct BSatnSerializationBenchmark {\n bench: String,\n format: String,\n count: u32,\n }\n\n impl Benchmark for BSatnSerializationBenchmark {\n fn run_benchmark(self) {\n assert_eq!(\n self.bench, \"serialize_product_value\",\n \"provided metadata has incorrect bench name\"\n );\n assert_eq!(self.format, \"bsatn\", \"provided metadata has incorrect format\");\n\n let buckets = 64;\n let data = create_sequential::(0xdeadbeef, self.count, buckets)\n .into_iter()\n .map(|row| spacetimedb_lib::AlgebraicValue::Product(row.into_product_value()))\n .collect::();\n\n spacetimedb::callgrind_flag::enable_callgrind_globally(|| {\n // don't time deallocation: return this!\n spacetimedb_lib::sats::bsatn::to_vec(&data).unwrap()\n }); // allocation dropped here\n }\n }\n\n #[library_benchmark]\n #[bench::b1(r#\"{\"bench\": \"serialize_product_value\", \"format\": \"bsatn\", \"count\": 16}\"#)]\n #[bench::b2(r#\"{\"bench\": \"serialize_product_value\", \"format\": \"bsatn\", \"count\": 64}\"#)]\n fn bsatn_serialization(metadata: &str) {\n let bench: BSatnSerializationBenchmark = serde_json::from_str(metadata).unwrap();\n bench.run_benchmark();\n }\n\n #[derive(Deserialize)]\n struct JSONSerializationBenchmark {\n bench: String,\n format: String,\n count: u32,\n }\n\n impl Benchmark for JSONSerializationBenchmark {\n fn run_benchmark(self) {\n assert_eq!(\n self.bench, \"serialize_product_value\",\n \"provided metadata has incorrect bench name\"\n );\n assert_eq!(self.format, \"json\", \"provided metadata has incorrect format\");\n\n let buckets = 64;\n let data = create_sequential::(0xdeadbeef, self.count, buckets)\n .into_iter()\n .map(|row| spacetimedb_lib::AlgebraicValue::Product(row.into_product_value()))\n .collect::();\n\n spacetimedb::callgrind_flag::enable_callgrind_globally(|| {\n // don't time deallocation: return this!\n serde_json::to_string(&data).unwrap()\n }); // allocation dropped here\n }\n }\n\n #[library_benchmark]\n #[bench::b1(r#\"{\"bench\": \"serialize_product_value\", \"format\": \"json\", \"count\": 16}\"#)]\n #[bench::b2(r#\"{\"bench\": \"serialize_product_value\", \"format\": \"json\", \"count\": 64}\"#)]\n fn json_serialization(metadata: &str) {\n let bench: JSONSerializationBenchmark = serde_json::from_str(metadata).unwrap();\n bench.run_benchmark();\n }\n\n library_benchmark_group!(\n name = serialize_group;\n benchmarks = bsatn_serialization, json_serialization\n );\n\n // ========================= HARNESS =========================\n iai_callgrind::main!(\n config = LibraryBenchmarkConfig::default()\n .pass_through_envs([\"HOME\", \"PATH\", \"RUST_LOG\", \"RUST_BACKTRACE\"])\n // THE NEXT LINE IS CRITICAL.\n // Without this line, this entire file breaks!\n .with_custom_entry_point(\"spacetimedb::callgrind_flag::flag\");\n library_benchmark_groups = insert_bulk_group, update_bulk_group, filter_group,\n iterate_group, empty_transaction_group,\n serialize_group\n );\n\n // have to re-export `main`, it's not marked as `pub` in the macro\n pub fn run_benches() {\n main();\n }\n}\n\nfn main() {\n #[cfg(target_os = \"linux\")]\n callgrind_benches::run_benches();\n\n #[cfg(not(target_os = \"linux\"))]\n println!(\"Callgrind does not exist for your operating system.\");\n}\n"
},
{
"path": "crates/bench/benches/delete_table.rs",
"content": "use core::{cmp::Ordering, iter::repeat_with, time::Duration};\nuse criterion::{\n black_box, criterion_group, criterion_main,\n measurement::{Measurement as _, WallTime},\n BenchmarkGroup, Criterion,\n};\nuse itertools::Itertools;\nuse rand::{prelude::*, seq::SliceRandom};\nuse smallvec::SmallVec;\nuse spacetimedb_data_structures::map::HashSet;\nuse spacetimedb_datastore::locking_tx_datastore::delete_table;\nuse spacetimedb_sats::layout::Size;\nuse spacetimedb_table::indexes::{PageIndex, PageOffset, RowPointer, SquashedOffset};\nuse std::collections::BTreeSet;\n\nfn time(body: impl FnOnce() -> R) -> Duration {\n let start = WallTime.start();\n let ret = body();\n let end = WallTime.end(start);\n black_box(ret);\n end\n}\n\nconst FIXED_ROW_SIZE: Size = Size(4 * 4);\n\nfn gen_row_pointers(iters: u64) -> impl Iterator {\n let mut page_index = PageIndex(0);\n let mut page_offset = PageOffset(0);\n let iter = repeat_with(move || {\n page_offset += FIXED_ROW_SIZE;\n if page_offset >= PageOffset::PAGE_END {\n // Consumed the page, let's use a new page.\n page_index.0 += 1;\n page_offset = PageOffset(0);\n }\n\n black_box(RowPointer::new(\n false,\n page_index,\n page_offset,\n SquashedOffset::COMMITTED_STATE,\n ))\n });\n iter.take(iters as usize)\n}\n\nfn bench_custom(g: &mut BenchmarkGroup<'_, WallTime>, name: &str, run: impl Fn(u64) -> Duration) {\n g.bench_function(name, |b| b.iter_custom(&run));\n}\n\nfn bench_delete_table(c: &mut Criterion) {\n let name = DT::NAME;\n let mut g = c.benchmark_group(name);\n let row_size = black_box(FIXED_ROW_SIZE);\n let new_dt = || DT::new(row_size);\n bench_custom(&mut g, \"mixed\", |i| {\n let mut dt = new_dt();\n gen_row_pointers(i)\n .map(|ptr| time(|| dt.contains(ptr)) + time(|| dt.insert(ptr)))\n .sum()\n });\n bench_custom(&mut g, \"mixed_random\", |i| {\n let mut dt = new_dt();\n let mut ptrs = gen_row_pointers(i).collect_vec();\n let mut rng = ThreadRng::default();\n ptrs.shuffle(&mut rng);\n ptrs.into_iter()\n .map(|ptr| time(|| dt.contains(ptr)) + time(|| dt.insert(ptr)))\n .sum()\n });\n bench_custom(&mut g, \"insert\", |i| {\n let mut dt = new_dt();\n gen_row_pointers(i).map(|ptr| time(|| dt.insert(ptr))).sum()\n });\n bench_custom(&mut g, \"contains_for_half\", |i| {\n let mut dt = new_dt();\n gen_row_pointers(i)\n .enumerate()\n .map(|(i, ptr)| {\n if i % 2 == 0 {\n black_box(dt.insert(ptr));\n }\n time(|| dt.contains(ptr))\n })\n .sum()\n });\n bench_custom(&mut g, \"contains_for_full\", |i| {\n let mut dt = new_dt();\n gen_row_pointers(i)\n .map(|ptr| {\n black_box(dt.insert(ptr));\n time(|| dt.contains(ptr))\n })\n .sum()\n });\n bench_custom(&mut g, \"remove\", |i| {\n let mut dt = new_dt();\n for ptr in gen_row_pointers(i) {\n black_box(dt.insert(ptr));\n }\n gen_row_pointers(i).map(|ptr| time(|| dt.remove(ptr))).sum()\n });\n bench_custom(&mut g, \"iter\", |i| {\n let mut dt = new_dt();\n for ptr in gen_row_pointers(i) {\n black_box(dt.insert(ptr));\n }\n time(|| dt.iter().count())\n });\n g.finish();\n}\n\ntrait DeleteTable {\n const NAME: &'static str;\n fn new(fixed_row_size: Size) -> Self;\n fn contains(&self, ptr: RowPointer) -> bool;\n fn insert(&mut self, ptr: RowPointer) -> bool;\n fn remove(&mut self, ptr: RowPointer) -> bool;\n fn iter(&self) -> impl Iterator;\n #[allow(unused)]\n fn len(&self) -> usize;\n}\n\nstruct DTBTree(BTreeSet);\n\nimpl DeleteTable for DTBTree {\n const NAME: &'static str = \"DTBTree\";\n fn new(_: Size) -> Self {\n Self(<_>::default())\n }\n fn contains(&self, ptr: RowPointer) -> bool {\n self.0.contains(&ptr)\n }\n fn insert(&mut self, ptr: RowPointer) -> bool {\n self.0.insert(ptr)\n }\n fn remove(&mut self, ptr: RowPointer) -> bool {\n self.0.remove(&ptr)\n }\n fn iter(&self) -> impl Iterator {\n self.0.iter().copied()\n }\n fn len(&self) -> usize {\n self.0.len()\n }\n}\n\nstruct DTHashSet(HashSet);\n\nimpl DeleteTable for DTHashSet {\n const NAME: &'static str = \"DTHashSet\";\n fn new(_: Size) -> Self {\n Self(<_>::default())\n }\n fn contains(&self, ptr: RowPointer) -> bool {\n self.0.contains(&ptr)\n }\n fn insert(&mut self, ptr: RowPointer) -> bool {\n self.0.insert(ptr)\n }\n fn remove(&mut self, ptr: RowPointer) -> bool {\n self.0.remove(&ptr)\n }\n fn iter(&self) -> impl Iterator {\n self.0.iter().copied()\n }\n fn len(&self) -> usize {\n self.0.len()\n }\n}\n\nstruct DTHashSetFH(foldhash::HashSet);\n\nimpl DeleteTable for DTHashSetFH {\n const NAME: &'static str = \"DTHashSetFH\";\n fn new(_: Size) -> Self {\n Self(<_>::default())\n }\n fn contains(&self, ptr: RowPointer) -> bool {\n self.0.contains(&ptr)\n }\n fn insert(&mut self, ptr: RowPointer) -> bool {\n self.0.insert(ptr)\n }\n fn remove(&mut self, ptr: RowPointer) -> bool {\n self.0.remove(&ptr)\n }\n fn iter(&self) -> impl Iterator {\n self.0.iter().copied()\n }\n fn len(&self) -> usize {\n self.0.len()\n }\n}\n\ntype DTPageAndBitSet = delete_table::DeleteTable;\n\nimpl DeleteTable for DTPageAndBitSet {\n const NAME: &'static str = \"DTPageAndBitSet\";\n fn new(fixed_row_size: Size) -> Self {\n Self::new(fixed_row_size)\n }\n fn contains(&self, ptr: RowPointer) -> bool {\n self.contains(ptr)\n }\n fn insert(&mut self, ptr: RowPointer) -> bool {\n self.insert(ptr)\n }\n fn remove(&mut self, ptr: RowPointer) -> bool {\n self.remove(ptr)\n }\n fn iter(&self) -> impl Iterator {\n self.iter()\n }\n fn len(&self) -> usize {\n self.len()\n }\n}\n\n#[derive(Clone, Copy)]\nstruct OffsetRange {\n start: PageOffset,\n end: PageOffset,\n}\nimpl OffsetRange {\n fn point(offset: PageOffset) -> Self {\n Self {\n start: offset,\n end: offset,\n }\n }\n}\ntype OffsetRanges = SmallVec<[OffsetRange; 4]>;\nstruct DTPageAndOffsetRanges {\n deleted: Vec,\n len: usize,\n fixed_row_size: Size,\n}\n\nfn cmp_start_end(start: &T, end: &T, needle: &T) -> Ordering {\n match (start.cmp(needle), end.cmp(needle)) {\n // start = needle or start < offset <= end => we have a match.\n (Ordering::Less, Ordering::Equal | Ordering::Greater) | (Ordering::Equal, _) => Ordering::Equal,\n // start <= end < needle => no match.\n (Ordering::Less, Ordering::Less) => Ordering::Less,\n // start <= end > needle => no match.\n (Ordering::Greater, _) => Ordering::Greater,\n }\n}\n\n#[inline]\nfn find_range_to_insert_offset(\n ranges: &OffsetRanges,\n offset: PageOffset,\n fixed_row_size: Size,\n) -> Result<(bool, bool, usize), usize> {\n let mut extend_end = true;\n let mut exists = false;\n ranges\n .binary_search_by(|&OffsetRange { start, end }| {\n extend_end = true;\n exists = false;\n match end.cmp(&offset) {\n // `end + row_size = offset` => we can just extend `end = offset`.\n Ordering::Less if end.0 + fixed_row_size.0 == offset.0 => Ordering::Equal,\n // Cannot extend this range, so let's not find it.\n Ordering::Less => Ordering::Less,\n // `offset` is already covered, so don't do anything,\n // but `end = offset` is a no-op.\n Ordering::Equal => {\n exists = true;\n Ordering::Equal\n }\n // `end` is greater, but we may be covered by `start` instead.\n Ordering::Greater => match start.cmp(&offset) {\n // `offset` is within the range, so don't do anything.\n Ordering::Less | Ordering::Equal => {\n exists = true;\n Ordering::Equal\n }\n // `start - row_size = offset` => we can just extend `start = offset`.\n Ordering::Greater if start.0 - fixed_row_size.0 == offset.0 => {\n extend_end = false;\n Ordering::Equal\n }\n // Range is entirely greater than offset.\n Ordering::Greater => Ordering::Greater,\n },\n }\n })\n .map(|idx| (extend_end, exists, idx))\n}\n\nimpl DeleteTable for DTPageAndOffsetRanges {\n const NAME: &'static str = \"DTPageAndOffsetRanges\";\n fn new(fixed_row_size: Size) -> Self {\n Self {\n deleted: <_>::default(),\n len: 0,\n fixed_row_size,\n }\n }\n fn contains(&self, ptr: RowPointer) -> bool {\n let page_idx = ptr.page_index().idx();\n let page_offset = ptr.page_offset();\n match self.deleted.get(page_idx) {\n Some(ranges) => ranges\n .binary_search_by(|r| cmp_start_end(&r.start, &r.end, &page_offset))\n .is_ok(),\n _ => false,\n }\n }\n fn insert(&mut self, ptr: RowPointer) -> bool {\n let fixed_row_size = self.fixed_row_size;\n let page_idx = ptr.page_index().idx();\n let page_offset = ptr.page_offset();\n\n let Some(ranges) = self.deleted.get_mut(page_idx) else {\n let pages = self.deleted.len();\n let after = 1 + page_idx;\n self.deleted.reserve(after - pages);\n for _ in pages..after {\n self.deleted.push(SmallVec::new());\n }\n self.deleted[page_idx].push(OffsetRange::point(page_offset));\n self.len += 1;\n return true;\n };\n\n let (extend_end, exists, range_idx) = match find_range_to_insert_offset(ranges, page_offset, fixed_row_size) {\n Err(range_idx) => {\n // Not found, so add a point range.\n ranges.insert(range_idx, OffsetRange::point(page_offset));\n self.len += 1;\n return true;\n }\n Ok(x) => x,\n };\n\n if extend_end {\n let next = range_idx + 1;\n let new_end = if let Some(r) = ranges\n .get(next)\n .copied()\n .filter(|r| r.start.0 - fixed_row_size.0 == page_offset.0)\n {\n ranges.remove(next);\n r.end\n } else {\n page_offset\n };\n ranges[range_idx].end = new_end;\n } else {\n let prev = range_idx.saturating_sub(1);\n if let Some(r) = ranges\n .get(prev)\n .copied()\n .filter(|r| r.end.0 + fixed_row_size.0 == page_offset.0)\n {\n ranges[range_idx].start = r.start;\n ranges.remove(prev);\n } else {\n ranges[range_idx].start = page_offset;\n };\n }\n\n let added = !exists;\n if added {\n self.len += 1;\n }\n added\n }\n fn remove(&mut self, ptr: RowPointer) -> bool {\n let fixed_row_size = self.fixed_row_size;\n let page_idx = ptr.page_index().idx();\n let page_offset = ptr.page_offset();\n\n let Some(ranges) = self.deleted.get_mut(page_idx) else {\n return false;\n };\n let Ok(idx) = ranges.binary_search_by(|r| cmp_start_end(&r.start, &r.end, &page_offset)) else {\n return false;\n };\n\n self.len -= 1;\n\n let range = &mut ranges[idx];\n let is_start = range.start == page_offset;\n let is_end = range.end == page_offset;\n match (is_start, is_end) {\n // Remove the point range.\n (true, true) => drop(ranges.remove(idx)),\n // Narrow the start.\n (true, false) => range.start += fixed_row_size,\n // Narrow the end.\n (false, true) => range.end -= fixed_row_size,\n // Split the range.\n (false, false) => {\n // Derive the second range, to the right of the hole.\n let end = range.end;\n let start = PageOffset(page_offset.0 + fixed_row_size.0);\n let new = OffsetRange { start, end };\n // Adjust the first range, to the left of the hole.\n range.end.0 = page_offset.0 - fixed_row_size.0;\n // Add the second range.\n ranges.insert(idx + 1, new);\n }\n }\n true\n }\n fn iter(&self) -> impl Iterator {\n (0..)\n .map(PageIndex)\n .zip(self.deleted.iter())\n .flat_map(move |(pi, ranges)| {\n ranges\n .iter()\n .flat_map(|range| (range.start.0..=range.end.0).step_by(self.fixed_row_size.0 as usize))\n .map(PageOffset)\n .map(move |po| RowPointer::new(false, pi, po, SquashedOffset::COMMITTED_STATE))\n })\n }\n fn len(&self) -> usize {\n self.len\n }\n}\n\ncriterion_group!(\n delete_table,\n bench_delete_table::,\n bench_delete_table::,\n bench_delete_table::,\n bench_delete_table::,\n bench_delete_table::, // best so far.\n);\ncriterion_main!(delete_table);\n"
},
{
"path": "crates/bench/benches/generic.rs",
"content": "use criterion::{\n criterion_group, criterion_main,\n measurement::{Measurement, WallTime},\n Bencher, BenchmarkGroup, Criterion,\n};\nuse lazy_static::lazy_static;\nuse spacetimedb_bench::{\n database::BenchDatabase,\n schemas::{create_sequential, u32_u64_str, u32_u64_u64, BenchTable, IndexStrategy, RandomTable},\n spacetime_module, spacetime_raw, sqlite, ResultBench,\n};\nuse spacetimedb_lib::sats::AlgebraicType;\nuse spacetimedb_primitives::ColId;\nuse spacetimedb_testing::modules::{Csharp, Rust};\n\n#[cfg(target_env = \"msvc\")]\n#[global_allocator]\nstatic GLOBAL: mimalloc::MiMalloc = mimalloc::MiMalloc;\n\n#[cfg(not(target_env = \"msvc\"))]\nuse tikv_jemallocator::Jemalloc;\n\n#[cfg(not(target_env = \"msvc\"))]\n#[global_allocator]\nstatic GLOBAL: Jemalloc = Jemalloc;\n\nlazy_static! {\n static ref RUN_ONE_MILLION: bool = std::env::var(\"RUN_ONE_MILLION\").is_ok();\n}\n\nfn criterion_benchmark(c: &mut Criterion) {\n bench_suite::(c, true).unwrap();\n bench_suite::(c, true).unwrap();\n bench_suite::>(c, true).unwrap();\n bench_suite::>(c, true).unwrap();\n\n bench_suite::(c, false).unwrap();\n bench_suite::(c, false).unwrap();\n bench_suite::>(c, false).unwrap();\n bench_suite::>(c, false).unwrap();\n}\n\n#[inline(never)]\nfn bench_suite(c: &mut Criterion, in_memory: bool) -> ResultBench<()> {\n let mut db = DB::build(in_memory)?;\n let param_db_name = DB::name();\n let param_in_memory = if in_memory { \"mem\" } else { \"disk\" };\n let db_params = format!(\"{param_db_name}/{param_in_memory}\");\n\n let mut g = c.benchmark_group(&db_params);\n\n empty(&mut g, &mut db)?;\n\n table_suite::(&mut g, &mut db)?;\n table_suite::(&mut g, &mut db)?;\n\n Ok(())\n}\n\ntype Group<'a> = BenchmarkGroup<'a, WallTime>;\n\n#[inline(never)]\nfn table_suite(g: &mut Group, db: &mut DB) -> ResultBench<()> {\n // This setup is a compromise between trying to present related benchmarks together,\n // and not having to deal with nasty reentrant generic dispatching.\n\n type TableData = (IndexStrategy, TableId, String);\n let mut prep_table = |index_strategy: IndexStrategy| -> ResultBench> {\n let table_name = T::name();\n let style_name = index_strategy.name();\n let table_params = format!(\"{table_name}/{style_name}\");\n let table_id = db.create_table::(index_strategy)?;\n\n Ok((index_strategy, table_id, table_params))\n };\n let tables: [TableData; 2] = [\n prep_table(IndexStrategy::Unique0)?,\n //prep_table(IndexStrategy::NoIndex)?,\n prep_table(IndexStrategy::BTreeEachColumn)?,\n ];\n\n for (_, table_id, table_params) in &tables {\n insert_bulk::(g, table_params, db, table_id, 2048, 256)?;\n if *RUN_ONE_MILLION {\n insert_bulk::(g, table_params, db, table_id, 0, 1_000_000)?;\n }\n }\n for (index_strategy, table_id, table_params) in &tables {\n if *index_strategy == IndexStrategy::Unique0 {\n // Iterate is unaffected by index strategy, so only run it here\n iterate::(g, table_params, db, table_id, 256)?;\n // Update can only be performed with a unique key\n update_bulk::(g, table_params, db, table_id, 2048, 256)?;\n if *RUN_ONE_MILLION {\n update_bulk::(g, table_params, db, table_id, 1_000_000, 1_000_000)?;\n }\n } else {\n // perform \"filter\" benchmarks\n filter::(g, db, table_id, index_strategy, 2, 2048, 8)?;\n }\n }\n\n Ok(())\n}\n\n/// Custom criterion timing loop. Allows access to a database, which is reset every benchmark iteration.\n///\n/// The prepare closure should restore the database to known state\n/// and prepare any inputs consumed by the benchmark. The time this takes will\n/// not be measured.\n///\n/// You should clear all modified tables after calling this, just to be safe.\n#[inline(never)]\nfn bench_harness<\n DB: BenchDatabase,\n INPUT,\n PREPARE: FnMut(&mut DB) -> ResultBench,\n ROUTINE: FnMut(&mut DB, INPUT) -> ResultBench<()>,\n>(\n b: &mut Bencher,\n db: &mut DB,\n mut prepare: PREPARE,\n mut routine: ROUTINE,\n) {\n b.iter_custom(|n| {\n let timer = WallTime;\n let mut elapsed = timer.zero();\n\n for _ in 0..n {\n let input = prepare(db).unwrap();\n\n // only nanoseconds of overhead\n let start = timer.start();\n routine(db, input).unwrap();\n let just_elapsed = timer.end(start);\n\n elapsed = timer.add(&elapsed, &just_elapsed);\n }\n elapsed\n });\n}\n\n#[inline(never)]\nfn empty(g: &mut Group, db: &mut DB) -> ResultBench<()> {\n let id = \"empty\".to_string();\n g.bench_function(&id, |b| {\n bench_harness(\n b,\n db,\n |_| Ok(()),\n |db, _| {\n // not much to do in this one\n db.empty_transaction()\n },\n )\n });\n Ok(())\n}\n\n#[inline(never)]\nfn insert_bulk(\n g: &mut Group,\n table_params: &str,\n db: &mut DB,\n table_id: &DB::TableId,\n load: u32,\n count: u32,\n) -> ResultBench<()> {\n let id = format!(\"insert_bulk/{table_params}/load={load}/count={count}\");\n let data = create_sequential::(0xdeadbeef, load + count, 1000);\n\n // Each iteration performs one transaction, though it inserts many rows.\n g.throughput(criterion::Throughput::Elements(1));\n // FIXME: only for 1_000_000 inserts\n g.sample_size(10);\n\n g.bench_function(&id, |b| {\n bench_harness(\n b,\n db,\n |db| {\n let mut data = data.clone();\n db.clear_table(table_id)?;\n let to_insert = data.split_off(load as usize);\n if !data.is_empty() {\n db.insert_bulk(table_id, data)?;\n }\n Ok(to_insert)\n },\n |db, to_insert| {\n db.insert_bulk(table_id, to_insert)?;\n Ok(())\n },\n )\n });\n db.clear_table(table_id)?;\n Ok(())\n}\n\n#[inline(never)]\nfn update_bulk(\n g: &mut Group,\n table_params: &str,\n db: &mut DB,\n table_id: &DB::TableId,\n load: u32,\n count: u32,\n) -> ResultBench<()> {\n let id = format!(\"update_bulk/{table_params}/load={load}/count={count}\");\n let data = create_sequential::(0xdeadbeef, load, 1000);\n\n // Each iteration performs one transaction, though it inserts many rows.\n g.throughput(criterion::Throughput::Elements(1));\n\n // running a big guy\n g.sample_size(10);\n\n g.bench_function(&id, |b| {\n bench_harness(\n b,\n db,\n |db| {\n let data = data.clone();\n db.clear_table(table_id)?;\n db.insert_bulk(table_id, data)?;\n Ok(())\n },\n |db, _| {\n db.update_bulk::(table_id, count)?;\n Ok(())\n },\n )\n });\n db.clear_table(table_id)?;\n Ok(())\n}\n\n#[inline(never)]\nfn iterate(\n g: &mut Group,\n table_params: &str,\n db: &mut DB,\n table_id: &DB::TableId,\n count: u32,\n) -> ResultBench<()> {\n let id = format!(\"iterate/{table_params}/count={count}\");\n let data = create_sequential::(0xdeadbeef, count, 1000);\n\n db.insert_bulk(table_id, data)?;\n\n // Each iteration performs a single transaction,\n // though it iterates across many rows.\n g.throughput(criterion::Throughput::Elements(1));\n\n g.bench_function(&id, |b| {\n bench_harness(\n b,\n db,\n |_| Ok(()),\n |db, _| {\n db.iterate(table_id)?;\n Ok(())\n },\n )\n });\n db.clear_table(table_id)?;\n Ok(())\n}\n\n#[inline(never)]\nfn filter(\n g: &mut Group,\n db: &mut DB,\n table_id: &DB::TableId,\n index_strategy: &IndexStrategy,\n col_id: impl Into,\n load: u32,\n buckets: u32,\n) -> ResultBench<()> {\n let col_id = col_id.into();\n\n let filter_column_type = match T::product_type().elements[col_id.idx()].algebraic_type {\n AlgebraicType::String => \"string\",\n AlgebraicType::U32 => \"u32\",\n AlgebraicType::U64 => \"u64\",\n _ => unimplemented!(),\n };\n let mean_result_count = load / buckets;\n let indexed = match index_strategy {\n IndexStrategy::BTreeEachColumn => \"index\",\n IndexStrategy::NoIndex => \"no_index\",\n _ => unimplemented!(),\n };\n let id = format!(\"filter/{filter_column_type}/{indexed}/load={load}/count={mean_result_count}\");\n\n let data = create_sequential::(0xdeadbeef, load, buckets as u64);\n\n db.insert_bulk(table_id, data.clone())?;\n\n // Each iteration performs a single transaction.\n g.throughput(criterion::Throughput::Elements(1));\n\n // We loop through all buckets found in the sample data.\n // This mildly increases variance on the benchmark, but makes \"mean_result_count\" more accurate.\n // Note that all databases have EXACTLY the same sample data.\n let mut i = 0;\n\n g.bench_function(&id, |b| {\n bench_harness(\n b,\n db,\n |_| {\n // pick something to look for\n let value = data[i].clone().into_product_value().elements[col_id.idx()].clone();\n i = (i + 1) % load as usize;\n Ok(value)\n },\n |db, value| {\n db.filter::(table_id, col_id, value)?;\n Ok(())\n },\n )\n });\n db.clear_table(table_id)?;\n Ok(())\n}\n\ncriterion_group!(benches, criterion_benchmark);\ncriterion_main!(benches);\n"
},
{
"path": "crates/bench/benches/index.rs",
"content": "use core::{any::type_name, hash::BuildHasherDefault, hint::black_box, iter::repeat_with, mem, time::Duration};\nuse criterion::{\n criterion_group, criterion_main,\n measurement::{Measurement as _, WallTime},\n BenchmarkGroup, Criterion,\n};\nuse foldhash::{HashSet, HashSetExt};\nuse hashbrown::{hash_map::Entry, HashMap};\nuse itertools::Itertools as _;\nuse rand::{\n distr::{Distribution, StandardUniform},\n Rng,\n};\nuse spacetimedb_lib::AlgebraicValue;\nuse spacetimedb_sats::{layout::Size, product, u256};\nuse spacetimedb_table::indexes::{PageIndex, PageOffset, RowPointer, SquashedOffset};\nuse spacetimedb_table::table_index::uniquemap::UniqueMap;\nuse spacetimedb_table::table_index::Index as _;\nuse spacetimedb_table::table_index::{\n unique_direct_index::{ToFromUsize, UniqueDirectIndex},\n KeySize,\n};\nuse std::hash::Hash;\n\nfn time(body: impl FnOnce() -> R) -> Duration {\n let start = WallTime.start();\n let ret = body();\n let end = WallTime.end(start);\n black_box(ret);\n end\n}\n\nconst FIXED_ROW_SIZE: Size = Size(4 * 4);\n\nfn gen_row_pointers() -> impl Iterator {\n let mut page_index = PageIndex(0);\n let mut page_offset = PageOffset(0);\n repeat_with(move || {\n if page_offset.0 as usize + FIXED_ROW_SIZE.0 as usize >= PageOffset::PAGE_END.0 as usize {\n // Consumed the page, let's use a new page.\n page_index.0 += 1;\n page_offset = PageOffset(0);\n } else {\n page_offset += FIXED_ROW_SIZE;\n }\n\n black_box(RowPointer::new(\n false,\n page_index,\n page_offset,\n SquashedOffset::COMMITTED_STATE,\n ))\n })\n}\n\nfn bench_custom(g: &mut BenchmarkGroup<'_, WallTime>, name: &str, run: impl Fn(u64) -> Duration) {\n g.bench_function(name, |b| b.iter_custom(&run));\n}\n\n/// Returns an iterator with the keys `0..n`.\nfn monotonic_keys(n: u64) -> impl Clone + Iterator {\n (0 as MonoKey..).take(n as usize)\n}\n\n// Returns a set with `n` distinct random keys.\nfn random_keys(n: u64) -> HashSet\nwhere\n StandardUniform: Distribution,\n{\n let desired_len = n as usize;\n let mut set = HashSet::with_capacity(desired_len);\n let mut iter = rand::random_iter();\n while set.len() < desired_len {\n set.insert(iter.next().unwrap());\n }\n set\n}\n\n/// Times inserting `keys` to the index.\nfn time_insertions(keys: impl Iterator) -> Duration {\n let mut index = I::new();\n keys.zip(gen_row_pointers())\n .map(black_box)\n .map(|(key, ptr)| time(|| index.insert(key, ptr)))\n .sum()\n}\n\n/// Times inserting monotonically increasing keys to the index.\n///\n/// The benchmark intentionally times N keys rather than the Nth key.\nfn bench_insert_monotonic>(g: &mut BenchmarkGroup<'_, WallTime>) {\n bench_custom(g, \"insert_monotonic\", |n| time_insertions::(monotonic_keys(n)));\n}\n\n/// Times inserting random keys to the index.\n///\n/// The benchmark intentionally times N keys rather than the Nth key.\nfn bench_insert_random(g: &mut BenchmarkGroup<'_, WallTime>)\nwhere\n StandardUniform: Distribution,\n{\n bench_custom(g, \"insert_random\", |n| time_insertions::(random_keys(n).into_iter()));\n}\n\n/// Times seeking `keys` in the index.\nfn time_seeks(keys: impl Clone + Iterator) -> Duration {\n // Prepare index with the keys.\n let mut index = I::new();\n for (key, ptr) in keys.clone().zip(gen_row_pointers()) {\n index.insert(key, ptr).unwrap();\n }\n\n // Time seeking every K in keys.\n keys.map(black_box)\n .map(|i| time(|| black_box(index.seek(i)).next()))\n .sum()\n}\n\n/// Times seeking all keys index with monotonically increasing keys.\nfn bench_seek_monotonic>(g: &mut BenchmarkGroup<'_, WallTime>) {\n bench_custom(g, \"seek_monotonic\", |n| time_seeks::(monotonic_keys(n)));\n}\n\n/// Times seeking all keys in an index with random keys.\nfn bench_seek_random(g: &mut BenchmarkGroup<'_, WallTime>)\nwhere\n StandardUniform: Distribution,\n{\n bench_custom(g, \"seek_random\", |n| {\n let keys = random_keys(n);\n\n let keys2 = keys.iter().cloned().sorted();\n\n // Prepare index with the keys.\n let mut index = I::new();\n for (key, ptr) in keys2.clone().zip(gen_row_pointers()) {\n index.insert(key, ptr).unwrap();\n }\n\n // Time seeking every K in keys.\n keys.into_iter()\n .map(black_box)\n .map(|i| time(|| black_box(index.seek(i)).next()))\n .sum()\n });\n}\n\n/// Times deleting `keys` in the index.\nfn time_deletes(keys: impl Clone + IntoIterator) -> Duration {\n // Prepare index with the keys.\n let mut index = I::new();\n for (key, ptr) in keys.clone().into_iter().zip(gen_row_pointers()) {\n index.insert(key, ptr).unwrap();\n }\n\n // Time deleting every K in keys.\n keys.into_iter().map(black_box).map(|i| time(|| index.delete(i))).sum()\n}\n\n/// Times deleting for one key in an index with monotonically increasing keys.\nfn bench_delete_monotonic>(g: &mut BenchmarkGroup<'_, WallTime>) {\n bench_custom(g, \"delete_monotonic\", |n| time_deletes::(monotonic_keys(n)));\n}\n\n/// Times seeking for one key in an index with monotonically increasing keys.\nfn bench_delete_random(g: &mut BenchmarkGroup<'_, WallTime>)\nwhere\n StandardUniform: Distribution,\n{\n bench_custom(g, \"delete_random\", |n| time_deletes::(random_keys(n)));\n}\n\nfn bench_index_mono>(c: &mut Criterion) {\n let mut g = c.benchmark_group(type_name::());\n bench_insert_monotonic::(&mut g);\n bench_insert_random::(&mut g);\n bench_seek_monotonic::(&mut g);\n bench_seek_random::(&mut g);\n bench_delete_monotonic::(&mut g);\n bench_delete_random::(&mut g);\n}\n\nfn bench_index_random(c: &mut Criterion)\nwhere\n StandardUniform: Distribution,\n{\n let mut g = c.benchmark_group(type_name::());\n bench_insert_random::(&mut g);\n bench_seek_random::(&mut g);\n bench_delete_random::(&mut g);\n}\n\ntype MonoKey = u32;\n\ntrait Index: Clone {\n type K: Eq + Hash + Ord + Clone;\n fn new() -> Self;\n fn insert(&mut self, key: Self::K, val: RowPointer) -> Result<(), RowPointer>;\n fn seek(&self, key: Self::K) -> impl Iterator;\n fn delete(&mut self, key: Self::K) -> bool;\n}\n\n#[derive(Clone)]\nstruct IBTree>(UniqueMap);\nimpl + Clone + Eq + Hash + Ord> Index for IBTree {\n type K = K;\n fn new() -> Self {\n Self(<_>::default())\n }\n fn insert(&mut self, key: Self::K, val: RowPointer) -> Result<(), RowPointer> {\n self.0.insert(key, val)\n }\n fn seek(&self, key: Self::K) -> impl Iterator {\n self.0.seek_point(&key)\n }\n fn delete(&mut self, key: Self::K) -> bool {\n self.0.delete(&key, RowPointer(0))\n }\n}\n\n#[derive(Clone)]\nstruct IAHash(HashMap>);\nimpl Index for IAHash {\n type K = K;\n fn new() -> Self {\n Self(<_>::default())\n }\n fn insert(&mut self, key: Self::K, val: RowPointer) -> Result<(), RowPointer> {\n match self.0.entry(key) {\n Entry::Vacant(e) => {\n e.insert(val);\n Ok(())\n }\n Entry::Occupied(e) => Err(*e.into_mut()),\n }\n }\n fn seek(&self, key: Self::K) -> impl Iterator {\n self.0.get(&key).into_iter().copied()\n }\n fn delete(&mut self, key: Self::K) -> bool {\n self.0.remove(&key).is_some()\n }\n}\n\n#[derive(Clone)]\nstruct IFoldHash(HashMap);\nimpl Index for IFoldHash {\n type K = K;\n fn new() -> Self {\n Self(<_>::default())\n }\n fn insert(&mut self, key: Self::K, val: RowPointer) -> Result<(), RowPointer> {\n match self.0.entry(key) {\n Entry::Vacant(e) => {\n e.insert(val);\n Ok(())\n }\n Entry::Occupied(e) => Err(*e.into_mut()),\n }\n }\n fn seek(&self, key: Self::K) -> impl Iterator {\n self.0.get(&key).into_iter().copied()\n }\n fn delete(&mut self, key: Self::K) -> bool {\n self.0.remove(&key).is_some()\n }\n}\n\n#[derive(Clone)]\nstruct IDirectIndex(UniqueDirectIndex);\nimpl Index for IDirectIndex {\n type K = K;\n fn new() -> Self {\n Self(<_>::default())\n }\n fn insert(&mut self, key: Self::K, val: RowPointer) -> Result<(), RowPointer> {\n self.0.insert(key, val)\n }\n fn seek(&self, key: Self::K) -> impl Iterator {\n self.0.seek_point(&key)\n }\n fn delete(&mut self, key: Self::K) -> bool {\n self.0.delete(&key, RowPointer(0))\n }\n}\n\n/* Complex keys */\n\n#[derive(Clone, Copy)]\nstruct U256(u256);\n\nimpl Distribution for StandardUniform {\n fn sample(&self, rng: &mut R) -> U256 {\n let (hi, lo) = self.sample(rng);\n U256(u256::from_words(hi, lo))\n }\n}\n\nimpl From for AlgebraicValue {\n fn from(value: U256) -> AlgebraicValue {\n AlgebraicValue::U256(Box::new(value.0))\n }\n}\n\nimpl U256 {\n fn to_le_bytes(self) -> [u8; 32] {\n self.0.to_le_bytes()\n }\n}\n\nmacro_rules! av_enc_type {\n ($name_av:ident, $name_enc:ident, $sample_ty:ty, ($($sample_pat:ident),* $(,)?)) => {\n #[allow(non_camel_case_types)]\n #[derive(Clone, Hash, PartialEq, Eq, PartialOrd, Ord)]\n struct $name_av(AlgebraicValue);\n #[allow(non_camel_case_types)]\n #[derive(Clone, Hash, PartialEq, Eq, PartialOrd, Ord)]\n struct $name_enc([u8; mem::size_of::<$sample_ty>()]);\n\n impl KeySize for $name_av { type MemoStorage = (); }\n impl KeySize for $name_enc { type MemoStorage = (); }\n\n impl Distribution<$name_av> for StandardUniform {\n fn sample(&self, rng: &mut R) -> $name_av {\n let ($($sample_pat,)*): $sample_ty = self.sample(rng);\n $name_av(product![$($sample_pat),*].into())\n }\n }\n\n impl Distribution<$name_enc> for StandardUniform {\n #[allow(unused_assignments)]\n fn sample(&self, rng: &mut R) -> $name_enc {\n let ($($sample_pat,)*): $sample_ty = self.sample(rng);\n\n let mut enc = [0; _];\n let mut start = 0;\n\n $(\n let size = mem::size_of_val(&$sample_pat);\n enc[start..start + size].copy_from_slice(&$sample_pat.to_le_bytes());\n start += size;\n )*\n\n $name_enc(enc)\n }\n }\n };\n}\n\nav_enc_type!(\n U16xU256xU32xU256_AV,\n U16xU256xU32xU256_Enc,\n (u16, U256, u32, U256),\n (a, b, c, d)\n);\nav_enc_type!(U16xU256xU32_AV, U16xU256xU32_Enc, (u16, U256, u32), (a, b, c));\n\nav_enc_type!(U256xU32xBool_AV, U256xU32xBool_Enc, (U256, u32, u8), (a, b, c));\nav_enc_type!(U256xU32_AV, U256xU32_Enc, (U256, u32), (a, b));\n\n// This is the index x_z_chunk_index from\n// https://github.com/clockworklabs/BitCraft/blob/f8177345df1e4ec54b91acee94146e75a0525548/BitCraftServer/packages/game/src/messages/components.rs#L224C18-L224C33\nav_enc_type!(I32xI32xU64_AV, I32xI32xU64_Enc, (i32, i32, u64), (a, b, c));\n\ncriterion_group!(\n delete_table,\n // Primitive types, both random and monotonic keys:\n bench_index_mono::>,\n bench_index_mono::>,\n bench_index_mono::>,\n bench_index_mono::>,\n // Complex keys, hash index:\n bench_index_random::>,\n bench_index_random::>,\n bench_index_random::>,\n bench_index_random::>,\n bench_index_random::>,\n bench_index_random::>,\n bench_index_random::>,\n bench_index_random::>,\n bench_index_random::>,\n bench_index_random::>,\n // Complex keys, btree index:\n bench_index_random::>,\n bench_index_random::>,\n bench_index_random::>,\n bench_index_random::>,\n bench_index_random::>,\n bench_index_random::>,\n bench_index_random::>,\n bench_index_random::>,\n bench_index_random::>,\n bench_index_random::>,\n);\ncriterion_main!(delete_table);\n"
},
{
"path": "crates/bench/benches/special.rs",
"content": "use criterion::async_executor::AsyncExecutor;\nuse criterion::{criterion_group, criterion_main, Criterion, SamplingMode};\nuse spacetimedb_bench::{\n database::BenchDatabase,\n schemas::{create_sequential, u32_u64_str, u32_u64_u64, u64_u64_u32, BenchTable, RandomTable},\n spacetime_module::SpacetimeModule,\n};\nuse spacetimedb_lib::sats::{self, bsatn};\nuse spacetimedb_lib::{bsatn::ToBsatn as _, ProductValue};\nuse spacetimedb_schema::schema::TableSchema;\nuse spacetimedb_schema::table_name::TableName;\nuse spacetimedb_table::page_pool::PagePool;\nuse spacetimedb_testing::modules::{Csharp, ModuleLanguage, Rust};\nuse std::sync::Arc;\nuse std::sync::OnceLock;\n\n#[cfg(target_env = \"msvc\")]\n#[global_allocator]\nstatic GLOBAL: mimalloc::MiMalloc = mimalloc::MiMalloc;\n\n#[cfg(not(target_env = \"msvc\"))]\nuse tikv_jemallocator::Jemalloc;\n\n#[cfg(not(target_env = \"msvc\"))]\n#[global_allocator]\nstatic GLOBAL: Jemalloc = Jemalloc;\n\nfn criterion_benchmark(c: &mut Criterion) {\n serialize_benchmarks::(c);\n serialize_benchmarks::(c);\n serialize_benchmarks::(c);\n\n custom_benchmarks::(c);\n custom_benchmarks::(c);\n}\n\nfn custom_benchmarks(c: &mut Criterion) {\n let db = SpacetimeModule::::build(true).unwrap();\n\n custom_module_benchmarks(&db, c);\n custom_db_benchmarks(&db, c);\n}\n\nfn custom_module_benchmarks(m: &SpacetimeModule, c: &mut Criterion) {\n let mut group = c.benchmark_group(format!(\"special/{}\", SpacetimeModule::::name()));\n\n let args = sats::product![\"0\".repeat(65536).into_boxed_str()];\n group.bench_function(\"large_arguments/64KiB\", |b| {\n b.to_async(m)\n .iter(|| async { m.module.call_reducer_binary(\"fn_with_1_args\", &args).await.unwrap() })\n });\n\n for n in [1u32, 100, 1000] {\n let args = sats::product![n];\n group.bench_function(format!(\"print_bulk/lines={n}\"), |b| {\n b.to_async(m)\n .iter(|| async { m.module.call_reducer_binary(\"print_many_things\", &args).await.unwrap() })\n });\n }\n}\n\nfn custom_db_benchmarks(m: &SpacetimeModule, c: &mut Criterion) {\n let mut group = c.benchmark_group(format!(\"special/db_game/{}\", L::NAME));\n // This bench take long, so adjust for it\n group.sample_size(10);\n group.sampling_mode(SamplingMode::Flat);\n\n let init_db: OnceLock<()> = OnceLock::new();\n for n in [10, 100] {\n let args = sats::product![n];\n group.bench_function(format!(\"circles/load={n}\"), |b| {\n // Initialize outside the benchmark so the db is seed once, to avoid to enlarge the db\n init_db.get_or_init(|| {\n m.block_on(async {\n m.module\n .call_reducer_binary(\"init_game_circles\", &sats::product![100])\n .await\n .unwrap()\n });\n });\n\n b.to_async(m)\n .iter(|| async { m.module.call_reducer_binary(\"run_game_circles\", &args).await.unwrap() })\n });\n }\n\n let init_db: OnceLock<()> = OnceLock::new();\n for n in [10, 100] {\n let args = sats::product![n];\n group.bench_function(format!(\"ia_loop/load={n}\"), |b| {\n // Initialize outside the benchmark so the db is seed once, to avoid `unique` constraints violations\n init_db.get_or_init(|| {\n m.block_on(async {\n m.module\n .call_reducer_binary(\"init_game_ia_loop\", &sats::product![500])\n .await\n .unwrap();\n })\n });\n\n b.to_async(m)\n .iter(|| async { m.module.call_reducer_binary(\"run_game_ia_loop\", &args).await.unwrap() })\n });\n }\n}\n\nfn serialize_benchmarks<\n T: BenchTable + RandomTable + for<'a> spacetimedb_lib::de::Deserialize<'a> + for<'a> serde::de::Deserialize<'a>,\n>(\n c: &mut Criterion,\n) {\n let name = T::name();\n let count = 100;\n let mut group = c.benchmark_group(format!(\"special/serde/serialize/{name}\"));\n group.throughput(criterion::Throughput::Elements(count));\n\n let data = create_sequential::(0xdeadbeef, count as u32, 100);\n\n group.bench_function(format!(\"product_value/count={count}\"), |b| {\n b.iter_batched(\n || data.clone(),\n |data| data.into_iter().map(|row| row.into_product_value()).collect::>(),\n criterion::BatchSize::PerIteration,\n );\n });\n // this measures serialization from a ProductValue, not directly (as in, from generated code in the Rust SDK.)\n let data_pv = &data\n .into_iter()\n .map(|row| spacetimedb_lib::AlgebraicValue::Product(row.into_product_value()))\n .collect::();\n\n group.bench_function(format!(\"bsatn/count={count}\"), |b| {\n b.iter(|| sats::bsatn::to_vec(data_pv).unwrap());\n });\n group.bench_function(format!(\"json/count={count}\"), |b| {\n b.iter(|| serde_json::to_string(data_pv).unwrap());\n });\n\n let mut table_schema = TableSchema::from_product_type(T::product_type());\n table_schema.table_name = TableName::for_test(name);\n let mut table = spacetimedb_table::table::Table::new(\n Arc::new(table_schema),\n spacetimedb_table::indexes::SquashedOffset::COMMITTED_STATE,\n );\n let pool = PagePool::new_for_test();\n let mut blob_store = spacetimedb_table::blob_store::HashMapBlobStore::default();\n\n let ptrs = data_pv\n .elements\n .iter()\n .map(|row| {\n table\n .insert(&pool, &mut blob_store, row.as_product().unwrap())\n .unwrap()\n .1\n .pointer()\n })\n .collect::>();\n let refs = ptrs\n .into_iter()\n .map(|ptr| table.get_row_ref(&blob_store, ptr).unwrap())\n .collect::>();\n group.bench_function(format!(\"bflatn_to_bsatn_slow_path/count={count}\"), |b| {\n b.iter(|| {\n let mut buf = Vec::new();\n for row_ref in &refs {\n bsatn::to_writer(&mut buf, row_ref).unwrap();\n }\n buf\n })\n });\n group.bench_function(format!(\"bflatn_to_bsatn_fast_path/count={count}\"), |b| {\n b.iter(|| {\n let mut buf = Vec::new();\n for row_ref in &refs {\n row_ref.to_bsatn_extend(&mut buf).unwrap();\n }\n buf\n });\n });\n\n group.finish();\n\n let mut group = c.benchmark_group(format!(\"special/serde/deserialize/{name}\"));\n group.throughput(criterion::Throughput::Elements(count));\n\n let data_bin = sats::bsatn::to_vec(&data_pv).unwrap();\n let data_json = serde_json::to_string(&data_pv).unwrap();\n\n group.bench_function(format!(\"bsatn/count={count}\"), |b| {\n b.iter(|| bsatn::from_slice::>(&data_bin).unwrap());\n });\n group.bench_function(format!(\"json/count={count}\"), |b| {\n b.iter(|| serde_json::from_str::>(&data_json).unwrap());\n });\n // TODO: deserialize benches (needs a typespace)\n}\n\ncriterion_group!(benches, criterion_benchmark);\ncriterion_main!(benches);\n"
},
{
"path": "crates/bench/benches/subscription.rs",
"content": "use criterion::{black_box, criterion_group, criterion_main, Criterion};\nuse spacetimedb::client::consume_each_list::ConsumeEachBuffer;\nuse spacetimedb::db::relational_db::RelationalDB;\nuse spacetimedb::error::DBError;\nuse spacetimedb::identity::AuthCtx;\nuse spacetimedb::sql::ast::SchemaViewer;\nuse spacetimedb::subscription::row_list_builder_pool::BsatnRowListBuilderPool;\nuse spacetimedb::subscription::tx::DeltaTx;\nuse spacetimedb::subscription::{collect_table_update, TableUpdateType};\nuse spacetimedb_bench::database::BenchDatabase as _;\nuse spacetimedb_bench::spacetime_raw::SpacetimeRaw;\nuse spacetimedb_client_api_messages::websocket::v1::BsatnFormat;\nuse spacetimedb_datastore::execution_context::Workload;\nuse spacetimedb_execution::pipelined::PipelinedProject;\nuse spacetimedb_primitives::{col_list, TableId};\nuse spacetimedb_query::compile_subscription;\nuse spacetimedb_sats::{bsatn, product, AlgebraicType, AlgebraicValue};\n#[cfg(not(target_env = \"msvc\"))]\nuse tikv_jemallocator::Jemalloc;\n\n#[cfg(not(target_env = \"msvc\"))]\n#[global_allocator]\nstatic GLOBAL: Jemalloc = Jemalloc;\n\nfn create_table_location(db: &RelationalDB) -> Result {\n let schema = &[\n (\"entity_id\", AlgebraicType::U64),\n (\"chunk_index\", AlgebraicType::U64),\n (\"x\", AlgebraicType::I32),\n (\"z\", AlgebraicType::I32),\n (\"dimension\", AlgebraicType::U32),\n ];\n let indexes = &[0.into(), 1.into()];\n\n // Is necessary to test for both single & multi-column indexes...\n db.create_table_for_test_mix_indexes(\"location\", schema, indexes, col_list![2, 3, 4])\n}\n\nfn create_table_footprint(db: &RelationalDB) -> Result {\n let footprint = AlgebraicType::sum([\"A\", \"B\", \"C\", \"D\"].map(|n| (n, AlgebraicType::unit())));\n let schema = &[\n (\"entity_id\", AlgebraicType::U64),\n (\"owner_entity_id\", AlgebraicType::U64),\n (\"type\", footprint),\n ];\n let indexes = &[0.into(), 1.into()];\n db.create_table_for_test(\"footprint\", schema, indexes)\n}\n\nfn eval(c: &mut Criterion) {\n let raw = SpacetimeRaw::build(false).unwrap();\n\n let lhs = create_table_footprint(&raw.db).unwrap();\n let rhs = create_table_location(&raw.db).unwrap();\n\n //TODO: Change this to `Workload::ForTest` once `#[cfg(bench)]` is stabilized.\n let _ = raw\n .db\n .with_auto_commit(Workload::Internal, |tx| -> Result<(), DBError> {\n // 1M rows\n let mut scratch = Vec::new();\n for entity_id in 0u64..1_000_000 {\n let owner = entity_id % 1_000;\n let footprint = AlgebraicValue::sum(entity_id as u8 % 4, AlgebraicValue::unit());\n let row = product!(entity_id, owner, footprint);\n\n scratch.clear();\n bsatn::to_writer(&mut scratch, &row).unwrap();\n let _ = raw.db.insert(tx, lhs, &scratch)?;\n }\n Ok(())\n });\n\n let _ = raw\n .db\n .with_auto_commit(Workload::Internal, |tx| -> Result<(), DBError> {\n // 1000 chunks, 1200 rows per chunk = 1.2M rows\n let mut scratch = Vec::new();\n for chunk_index in 0u64..1_000 {\n for i in 0u64..1200 {\n let entity_id = chunk_index * 1200 + i;\n let x = 0i32;\n let z = entity_id as i32;\n let dimension = 0u32;\n let row = product!(entity_id, chunk_index, x, z, dimension);\n\n scratch.clear();\n bsatn::to_writer(&mut scratch, &row).unwrap();\n let _ = raw.db.insert(tx, rhs, &scratch)?;\n }\n }\n Ok(())\n });\n\n let entity_id = 1_200_000u64;\n let chunk_index = 5u64;\n let x = 0i32;\n let z = 0i32;\n let dimension = 0u32;\n\n let footprint = AlgebraicValue::sum(1, AlgebraicValue::unit());\n let owner = 6u64;\n\n let _new_lhs_row = product!(entity_id, owner, footprint);\n let _new_rhs_row = product!(entity_id, chunk_index, x, z, dimension);\n\n let bsatn_rlb_pool = black_box(BsatnRowListBuilderPool::new());\n\n // A benchmark runner for the subscription engine.\n let bench_query = |c: &mut Criterion, name, sql| {\n c.bench_function(name, |b| {\n let tx = raw.db.begin_tx(Workload::Subscribe);\n let auth = AuthCtx::for_testing();\n let schema_viewer = &SchemaViewer::new(&tx, &auth);\n let (plans, table_id, table_name, _) = compile_subscription(sql, schema_viewer, &auth).unwrap();\n let plans = plans\n .into_iter()\n .map(|plan| plan.optimize(&auth).unwrap())\n .map(PipelinedProject::from)\n .collect::>();\n let tx = DeltaTx::from(&tx);\n\n b.iter(|| {\n let updates = black_box(collect_table_update::(\n &plans,\n table_id,\n table_name.clone(),\n &tx,\n TableUpdateType::Subscribe,\n &bsatn_rlb_pool,\n ));\n if let Ok((updates, _)) = updates {\n updates.consume_each_list(&mut |buffer| bsatn_rlb_pool.try_put(buffer));\n }\n })\n });\n };\n\n // Join 1M rows on the left with 12K rows on the right.\n // Note, this should use an index join so as not to read the entire footprint table.\n let semijoin = format!(\n r#\"\n select f.*\n from footprint f join location l on f.entity_id = l.entity_id\n where l.chunk_index = {chunk_index}\n \"#\n );\n\n let index_scan_multi = \"select * from location WHERE x = 0 AND z = 10000 AND dimension = 0\";\n\n bench_query(c, \"footprint-scan\", \"select * from footprint\");\n bench_query(c, \"footprint-semijoin\", &semijoin);\n bench_query(c, \"index-scan-multi\", index_scan_multi);\n}\n\ncriterion_group!(benches, eval);\ncriterion_main!(benches);\n"
},
{
"path": "crates/bench/callgrind-docker.sh",
"content": "#!/bin/bash\n\n# script to enter iai dockerfile locally\n\nset -exo pipefail\n\nSCRIPT_DIR=\"$(dirname \"$(readlink -f \"$0\")\")\"\ncd \"$SCRIPT_DIR\"\ndocker build . --tag rust-iai-callgrind:latest \ndocker run --privileged -v \"$(realpath $PWD/../..):/projects/SpacetimeDB\" -w /projects/SpacetimeDB/crates/bench rust-iai-callgrind:latest cargo bench --bench callgrind"
},
{
"path": "crates/bench/clippy.toml",
"content": "# we use println in summarize.rs, don't complain about it\ndisallowed-macros = []\n"
},
{
"path": "crates/bench/flamegraph.sh",
"content": "#!/bin/bash\nset -euo pipefail\n\nif [ \"$#\" -lt \"2\" ] ; then\n echo \"Usage: $0 \"\n echo \"E.g.: $0 generic stdb_raw/mem/insert_bulk/location/multi_index/load=0/count=100 result.svg\"\n exit 1\nfi\n\ncd \"$(dirname \"$0\")\"\n\necho\necho \"Warning(jgilles): this script has not been tested since its last modification, sorry if it is broken.\"\necho\necho cargo bench --no-run\necho\n\ncargo bench --no-run\n\necho\necho cargo flamegraph --bench \"${1}\" --deterministic --notes \"${1};${2}\" -o \"${3}\" -- \"${2}\" --profile-time 10\necho\n\ncargo flamegraph --bench \"${1}\" --deterministic --notes \"${1};${2}\" -o \"${3}\" -- \"${2}\" --profile-time 10\n"
},
{
"path": "crates/bench/hyper_cmp.py",
"content": "# Mini-tool for comparing benchmark between PR or locally\nimport os\nimport json\nimport argparse\nimport subprocess\nimport shutil\n\n\ndef statDecoder(statDict):\n return namedtuple('Stat', statDict.keys())(*statDict.values())\n\n\ndef clean(stat):\n new = {}\n for (k, v) in stat.items():\n if k in [\"stddev\", \"command\", \"exit_codes\"]:\n continue\n if k == \"times\":\n v = v[0]\n if isinstance(v, float):\n v = round(v, 2)\n new[k] = v\n return new\n\n\ndef larger(row: list):\n return [len(str(x)) for x in row]\n\n\ndef bar_chart(data: list):\n max_value = max(count for _, count in data.items())\n increment = max_value / 25\n\n longest_label_length = max(len(label) for label, _ in data.items())\n\n for label, count in data.items():\n\n # The ASCII block elements come in chunks of 8, so we work out how\n # many fractions of 8 we need.\n # https://en.wikipedia.org/wiki/Block_Elements\n bar_chunks, remainder = divmod(int(count * 8 / increment), 8)\n\n # First draw the full width chunks\n bar = '█' * bar_chunks\n\n # Then add the fractional part. The Unicode code points for\n # block elements are (8/8), (7/8), (6/8), ... , so we need to\n # work backwards.\n if remainder > 0:\n bar += chr(ord('█') + (8 - remainder))\n\n # If the bar is empty, add a left one-eighth block\n bar = bar or '▏'\n\n print(f'{label.rjust(longest_label_length)} ▏ {count:#4f} {bar}')\n\n\nclass Report:\n def __init__(self, title: str, header: list, bar: dict, rows: dict):\n self.title = title\n size = larger(header)\n for row in rows:\n size = size + larger(row)\n self.header = header\n self.bar = bar\n self.rows = rows\n self.larger = max(size) + 2\n\n\nclass Stat:\n def __init__(self, results):\n self.spacetime = clean(results[0])\n self.sqlite = clean(results[1])\n\n\ndef load_file(named: str):\n data = open(named).read()\n return Stat(json.loads(data)['results'])\n\n\ndef print_cell(cell: str, size: int, is_last: bool):\n spaces = \" \" * (size - len(cell))\n if is_last:\n return \"| %s%s |\" % (cell, spaces)\n else:\n return \"| %s%s \" % (cell, spaces)\n\n\ndef print_row(row: list, size: int):\n line = \"\"\n for (pos, x) in enumerate(row):\n line += print_cell(str(x), size, pos + 1 == len(row))\n print(line)\n\n\ndef print_mkdown(report: Report):\n print(\"###\", report.title)\n print(\"\\n```bash\")\n bar_chart(report.bar)\n print(\"```\\n\")\n print(\"*Smaller is better.*\")\n print_row(report.header, report.larger)\n print_row([\"-\" * report.larger for x in report.header], report.larger)\n\n for row in report.rows:\n print_row(row, report.larger)\n\n\ndef pick_winner(a: dict, b: dict, label_a: str, label_b: str):\n if a[\"mean\"] > b[\"mean\"]:\n winner = label_b\n delta = a[\"times\"]\n else:\n if a[\"mean\"] == b[\"mean\"]:\n winner = \"TIE\"\n delta = a[\"times\"]\n else:\n winner = label_a\n delta = b[\"times\"]\n return winner, delta\n\n\n# Check Sqlite VS Spacetime\ndef cmp_bench(stat: Stat):\n winner, delta = pick_winner(stat.spacetime, stat.sqlite, \"Spacetime\", \"Sqlite\")\n\n header = [\"Stat\", \"Sqlite\", \"Spacetime\", \"Delta\"]\n\n rows = []\n for (k, v) in stat.sqlite.items():\n rows.append([k, v, stat.spacetime[k], round(stat.spacetime[k] - v, 2)])\n\n bar = dict(SpacetimeDB=stat.spacetime[\"mean\"], Sqlite=stat.sqlite[\"mean\"])\n return Report(\"Comparing Sqlite VS Spacetime Winner: **%s**\" % winner, header, bar, rows)\n\n\n# Check the progress of Spacetime between branches / PR\ndef improvement_bench(old: Stat, new: Stat):\n winner, delta = pick_winner(old.spacetime, new.spacetime, \"Old\", \"New\")\n\n header = [\"Stat\", \"OLD\", \"NEW\", \"Delta\"]\n\n rows = []\n for (k, v) in old.spacetime.items():\n rows.append([k, v, new.spacetime[k], round(v - new.spacetime[k], 2)])\n\n bar = dict(Old=old.spacetime[\"mean\"], New=new.spacetime[\"mean\"])\n return Report(\"Improvement of Spacetime. Winner: **%s**\" % winner, header, bar, rows)\n\n\nif __name__ == '__main__':\n parser = argparse.ArgumentParser()\n parser.add_argument(\"bench\", choices=['versus', 'pr'], help=\"Select bench\")\n\n args = vars(parser.parse_args())\n\n # args = {\"bench\": \"pr\"}\n cmd = \"./hyperfine.sh insert\"\n if args[\"bench\"] == \"pr\":\n subprocess.check_call('./pr_copy.sh \"%s\"' % cmd, shell=True)\n\n subprocess.check_call(cmd, shell=True, timeout=60 * 5)\n shutil.copyfile(\"out.json\", \"new.json\")\n\n old = load_file(\"old.json\")\n new = load_file(\"new.json\")\n report = improvement_bench(old, new)\n else:\n subprocess.check_call(cmd, shell=True, timeout=60 * 5)\n\n stat = load_file(\"out.json\")\n report = cmp_bench(stat)\n\n print_mkdown(report)\n"
},
{
"path": "crates/bench/instruments.sh",
"content": "#!/bin/bash\nset -euo pipefail\n\nif [ \"$#\" -lt \"3\" ] ; then\n echo \"Usage: $0 \"\n echo \"E.g.: $0 time generic stdb_raw/mem/insert_bulk/location/multi_index/load=0/count=100\n\"\n exit 1\nfi\n\necho\necho cargo instruments -t \"${1}\" --bench \"${2}\" -- \"${3}\" --profile-time 10\necho\n\n# Only OSX: Run the benchmark in instruments.app\ncargo instruments -t \"${1}\" --bench \"${2}\" -- \"${3}\" --profile-time 10"
},
{
"path": "crates/bench/src/database.rs",
"content": "use spacetimedb_lib::AlgebraicValue;\nuse spacetimedb_primitives::ColId;\n\nuse crate::schemas::{BenchTable, IndexStrategy};\nuse crate::ResultBench;\n\n/// A database we can execute a standard benchmark suite against.\n/// Currently implemented for SQLite, raw Spacetime outside a module boundary\n/// (RelationalDB), and Spacetime through the module boundary.\n///\n/// Not all benchmarks have to go through this trait.\npub trait BenchDatabase: Sized {\n fn name() -> String;\n\n type TableId: Clone + 'static;\n\n fn build(in_memory: bool) -> ResultBench\n where\n Self: Sized;\n\n fn create_table(&mut self, table_style: IndexStrategy) -> ResultBench;\n\n /// Should not drop the table, only delete all the rows.\n fn clear_table(&mut self, table_id: &Self::TableId) -> ResultBench<()>;\n\n /// Count the number of rows in the table.\n fn count_table(&mut self, table_id: &Self::TableId) -> ResultBench;\n\n /// Perform an empty transaction.\n fn empty_transaction(&mut self) -> ResultBench<()>;\n\n /// Perform a transaction that commits many rows.\n fn insert_bulk(&mut self, table_id: &Self::TableId, rows: Vec) -> ResultBench<()>;\n\n /// Perform a transaction that updates many rows, without\n /// sending updated rows across a serialization boundary.\n /// (e.g. in a module, the updates are generated *inside* the reducer).\n /// Update logic should be fast, e.g. wrapping integer increment.\n /// Requires that the table was created with `IndexStrategy::Unique`\n fn update_bulk(&mut self, table_id: &Self::TableId, row_count: u32) -> ResultBench<()>;\n\n /// Perform a transaction that iterates an entire database table.\n /// Note: this can be non-generic because none of the implementations use the relevant generic argument.\n fn iterate(&mut self, table_id: &Self::TableId) -> ResultBench<()>;\n\n /// Filter the table on the specified column id for the specified value.\n fn filter(\n &mut self,\n table_id: &Self::TableId,\n col_id: impl Into,\n value: AlgebraicValue,\n ) -> ResultBench<()>;\n}\n"
},
{
"path": "crates/bench/src/lib.rs",
"content": "pub mod database;\npub mod schemas;\npub mod spacetime_module;\npub mod spacetime_raw;\npub mod sqlite;\n\npub type ResultBench = Result
![\"SpacetimeDB](\"./images/dark/logo.svg\"){kind=logo}
\n ![\"SpacetimeDB](\"./images/light/logo.svg\"){kind=logo}
\n ![\"SpacetimeDB\"](\"./images/dark/logo-text.svg\"){kind=logo}
\n ![\"SpacetimeDB\"](\"./images/light/logo-text.svg\"){kind=logo}
\n ![](\"https://img.shields.io/github/v/release/clockworklabs/spacetimedb?color=%23ff00a0&include_prereleases&label=version&sort=semver&style=flat-square\")
![](\"https://img.shields.io/badge/built_with-Rust-dca282.svg?style=flat-square\"){kind=icon}
\n \n\t![](\"https://img.shields.io/github/actions/workflow/status/clockworklabs/spacetimedb/ci.yml?style=flat-square&branch=master\")
![](\"https://img.shields.io/uptimerobot/ratio/7/m784409192-e472ca350bb615372ededed7?label=cloud%20uptime&style=flat-square\")
![](\"https://img.shields.io/docker/pulls/clockworklabs/spacetimedb?style=flat-square\")
![](\"https://img.shields.io/badge/license-BSL_1.1-00bfff.svg?style=flat-square\"){kind=icon}
\n![](\"https://img.shields.io/crates/d/spacetimedb?color=e45928&label=Rust%20Crate&style=flat-square\")
![](\"https://img.shields.io/nuget/dt/spacetimedb.runtime?color=0b6cff&label=NuGet%20Package&style=flat-square\")
![](\"https://img.shields.io/npm/dm/spacetimedb?color=cb0000&label=npm&style=flat-square\")
![](\"https://img.shields.io/discord/1037340874172014652?label=discord&style=flat-square&color=5a66f6\")
![](\"https://img.shields.io/badge/twitter-Follow_us-1d9bf0.svg?style=flat-square\"){kind=icon}
\n \n ![](\"https://img.shields.io/badge/careers-Join_us-86f7b7.svg?style=flat-square\"){kind=icon}
\n \n ![](\"https://img.shields.io/badge/linkedin-Connect_with_us-0a66c2.svg?style=flat-square\"){kind=icon}
\n![\"Discord\"](\"./images/social/discord.svg\")
\n \n ![\"Twitter\"](\"./images/social/twitter.svg\")
\n \n ![\"GitHub\"](\"./images/social/github.svg\")
\n \n ![\"Twitch\"](\"./images/social/twitch.svg\")
\n \n ![\"YouTube\"](\"./images/social/youtube.svg\")
\n \n ![\"LinkedIn\"](\"./images/social/linkedin.svg\")
\n \n ![\"StackOverflow\"](\"./images/social/stackoverflow.svg\")
\n![\"SpacetimeDB](\"./images/basic-architecture-diagram.png\")
\n