diff --git a/.github/workflows/clippy.yml b/.github/workflows/clippy.yml
new file mode 100644
index 0000000..3fa1c62
--- /dev/null
+++ b/.github/workflows/clippy.yml
@@ -0,0 +1,27 @@
+name: Clippy
+
+on:
+ push:
+ branches: [ main, master ]
+ pull_request:
+ branches: [ main, master ]
+
+env:
+ CARGO_TERM_COLOR: always
+
+jobs:
+ clippy:
+ runs-on: ubuntu-latest
+
+ steps:
+ - uses: actions/checkout@v4
+
+ - name: Setup Rust
+ uses: actions-rust-lang/setup-rust-toolchain@v1
+ with:
+ toolchain: stable
+ components: clippy
+
+ - name: Run Clippy
+ run: cargo clippy --all-targets --all-features -- -D warnings
+ working-directory: ./rust
\ No newline at end of file
diff --git a/.github/workflows/fmt.yml b/.github/workflows/fmt.yml
new file mode 100644
index 0000000..01a400b
--- /dev/null
+++ b/.github/workflows/fmt.yml
@@ -0,0 +1,27 @@
+name: Format
+
+on:
+ push:
+ branches: [ main, master ]
+ pull_request:
+ branches: [ main, master ]
+
+env:
+ CARGO_TERM_COLOR: always
+
+jobs:
+ fmt:
+ runs-on: ubuntu-latest
+
+ steps:
+ - uses: actions/checkout@v4
+
+ - name: Setup Rust
+ uses: actions-rust-lang/setup-rust-toolchain@v1
+ with:
+ toolchain: stable
+ components: rustfmt
+
+ - name: Check formatting
+ run: cargo fmt --all -- --check
+ working-directory: ./rust
\ No newline at end of file
diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
new file mode 100644
index 0000000..5d88d4e
--- /dev/null
+++ b/.github/workflows/test.yml
@@ -0,0 +1,30 @@
+name: Test
+
+on:
+ push:
+ branches: [ main, master ]
+ pull_request:
+ branches: [ main, master ]
+
+env:
+ CARGO_TERM_COLOR: always
+
+jobs:
+ test:
+ runs-on: ubuntu-latest
+
+ steps:
+ - uses: actions/checkout@v4
+
+ - name: Setup Rust
+ uses: actions-rust-lang/setup-rust-toolchain@v1
+ with:
+ toolchain: stable
+
+ - name: Run tests
+ run: cargo test --verbose
+ working-directory: ./rust
+
+ - name: Run tests with all features
+ run: cargo test --all-features --verbose
+ working-directory: ./rust
\ No newline at end of file
diff --git a/.gitignore b/.gitignore
index 5046052..59523fd 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,2 +1,8 @@
*~
-__pycache__/*
\ No newline at end of file
+__pycache__/*
+/rust/target/
+/venv/
+/out/
+target/*
+coverage/*
+.idea/*
diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml
deleted file mode 100644
index a16e67b..0000000
--- a/.gitlab-ci.yml
+++ /dev/null
@@ -1,54 +0,0 @@
-# Hacked version of cicd template, without the venv. Glued python and go together.
-
-
-stages:
- - test
- - build
-
-# Change pip's cache directory to be inside the project directory since we can
-# only cache local items.
-variables:
- PIP_CACHE_DIR: "$CI_PROJECT_DIR/.cache/pip"
-
-# Pip's cache doesn't store the python packages
-# https://pip.pypa.io/en/stable/topics/caching/
-#
-# If you want to also cache the installed packages, you have to install
-# them in a virtualenv and cache it as well.
-cache:
- paths:
- - .cache/pip
- - venv/
-
-pytest:
- stage: test
- image: python:latest
- script:
- - python --version
- - python test_bufferpool.py
-
-
-gotest:
- stage: test
- image: golang:latest
- script:
-# - go vet $(go list ./... | grep -v /vendor/)
-# - go test -v -race $(go list ./... | grep -v /vendor/)
- - go install gotest.tools/gotestsum@latest
- - cd go
- - gotestsum --junitfile report.xml --format standard-verbose
- artifacts:
- when: always
- reports:
- junit: go/report.xml
-
-compile:
- stage: build
- image: golang:latest
- script:
- - cd go
- - mkdir -p bin
- - go build -o bin ./...
- artifacts:
- paths:
- - go/bin
diff --git a/Cargo.lock b/Cargo.lock
new file mode 100644
index 0000000..96c8291
--- /dev/null
+++ b/Cargo.lock
@@ -0,0 +1,696 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "aho-corasick"
+version = "1.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e60d3430d3a69478ad0993f19238d2df97c507009a52b3c10addcd7f6bcb916"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "anes"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4b46cbb362ab8752921c97e041f5e366ee6297bd428a31275b9fcf1e380f7299"
+
+[[package]]
+name = "anstyle"
+version = "1.0.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "862ed96ca487e809f1c8e5a8447f6ee2cf102f846893800b20cebdf541fc6bbd"
+
+[[package]]
+name = "autocfg"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8"
+
+[[package]]
+name = "bufferpool"
+version = "0.1.0"
+dependencies = [
+ "criterion",
+ "fastrand",
+ "rand",
+ "serde",
+ "serde_json",
+]
+
+[[package]]
+name = "bumpalo"
+version = "3.19.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "46c5e41b57b8bba42a04676d81cb89e9ee8e859a1a66f80a5a72e1cb76b34d43"
+
+[[package]]
+name = "cast"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5"
+
+[[package]]
+name = "cfg-if"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
+
+[[package]]
+name = "ciborium"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42e69ffd6f0917f5c029256a24d0161db17cea3997d185db0d35926308770f0e"
+dependencies = [
+ "ciborium-io",
+ "ciborium-ll",
+ "serde",
+]
+
+[[package]]
+name = "ciborium-io"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "05afea1e0a06c9be33d539b876f1ce3692f4afea2cb41f740e7743225ed1c757"
+
+[[package]]
+name = "ciborium-ll"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "57663b653d948a338bfb3eeba9bb2fd5fcfaecb9e199e87e1eda4d9e8b240fd9"
+dependencies = [
+ "ciborium-io",
+ "half",
+]
+
+[[package]]
+name = "clap"
+version = "4.5.47"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7eac00902d9d136acd712710d71823fb8ac8004ca445a89e73a41d45aa712931"
+dependencies = [
+ "clap_builder",
+]
+
+[[package]]
+name = "clap_builder"
+version = "4.5.47"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2ad9bbf750e73b5884fb8a211a9424a1906c1e156724260fdae972f31d70e1d6"
+dependencies = [
+ "anstyle",
+ "clap_lex",
+]
+
+[[package]]
+name = "clap_lex"
+version = "0.7.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b94f61472cee1439c0b966b47e3aca9ae07e45d070759512cd390ea2bebc6675"
+
+[[package]]
+name = "criterion"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f2b12d017a929603d80db1831cd3a24082f8137ce19c69e6447f54f5fc8d692f"
+dependencies = [
+ "anes",
+ "cast",
+ "ciborium",
+ "clap",
+ "criterion-plot",
+ "is-terminal",
+ "itertools",
+ "num-traits",
+ "once_cell",
+ "oorandom",
+ "plotters",
+ "rayon",
+ "regex",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "tinytemplate",
+ "walkdir",
+]
+
+[[package]]
+name = "criterion-plot"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6b50826342786a51a89e2da3a28f1c32b06e387201bc2d19791f622c673706b1"
+dependencies = [
+ "cast",
+ "itertools",
+]
+
+[[package]]
+name = "crossbeam-deque"
+version = "0.8.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9dd111b7b7f7d55b72c0a6ae361660ee5853c9af73f70c3c2ef6858b950e2e51"
+dependencies = [
+ "crossbeam-epoch",
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-epoch"
+version = "0.9.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5b82ac4a3c2ca9c3460964f020e1402edd5753411d7737aa39c3714ad1b5420e"
+dependencies = [
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-utils"
+version = "0.8.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28"
+
+[[package]]
+name = "crunchy"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "460fbee9c2c2f33933d720630a6a0bac33ba7053db5344fac858d4b8952d77d5"
+
+[[package]]
+name = "either"
+version = "1.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "48c757948c5ede0e46177b7add2e67155f70e33c07fea8284df6576da70b3719"
+
+[[package]]
+name = "fastrand"
+version = "2.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "37909eebbb50d72f9059c3b6d82c0463f2ff062c9e95845c43a6c9c0355411be"
+
+[[package]]
+name = "getrandom"
+version = "0.2.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "be4136b2a15dd319360be1c07d9933517ccf0be8f16bf62a3bee4f0d618df427"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "wasi",
+]
+
+[[package]]
+name = "half"
+version = "2.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "459196ed295495a68f7d7fe1d84f6c4b7ff0e21fe3017b2f283c6fac3ad803c9"
+dependencies = [
+ "cfg-if",
+ "crunchy",
+]
+
+[[package]]
+name = "hermit-abi"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fc0fef456e4baa96da950455cd02c081ca953b141298e41db3fc7e36b1da849c"
+
+[[package]]
+name = "is-terminal"
+version = "0.4.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e04d7f318608d35d4b61ddd75cbdaee86b023ebe2bd5a66ee0915f0bf93095a9"
+dependencies = [
+ "hermit-abi",
+ "libc",
+ "windows-sys 0.59.0",
+]
+
+[[package]]
+name = "itertools"
+version = "0.10.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b0fd2260e829bddf4cb6ea802289de2f86d6a7a690192fbe91b3f46e0f2c8473"
+dependencies = [
+ "either",
+]
+
+[[package]]
+name = "itoa"
+version = "1.0.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4a5f13b858c8d314ee3e8f639011f7ccefe71f97f96e50151fb991f267928e2c"
+
+[[package]]
+name = "js-sys"
+version = "0.3.78"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0c0b063578492ceec17683ef2f8c5e89121fbd0b172cbc280635ab7567db2738"
+dependencies = [
+ "once_cell",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "libc"
+version = "0.2.147"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b4668fb0ea861c1df094127ac5f1da3409a82116a4ba74fca2e58ef927159bb3"
+
+[[package]]
+name = "log"
+version = "0.4.28"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "34080505efa8e45a4b816c349525ebe327ceaa8559756f0356cba97ef3bf7432"
+
+[[package]]
+name = "memchr"
+version = "2.7.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32a282da65faaf38286cf3be983213fcf1d2e2a58700e808f83f4ea9a4804bc0"
+
+[[package]]
+name = "num-traits"
+version = "0.2.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "once_cell"
+version = "1.21.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d"
+
+[[package]]
+name = "oorandom"
+version = "11.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d6790f58c7ff633d8771f42965289203411a5e5c68388703c06e14f24770b41e"
+
+[[package]]
+name = "plotters"
+version = "0.3.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5aeb6f403d7a4911efb1e33402027fc44f29b5bf6def3effcc22d7bb75f2b747"
+dependencies = [
+ "num-traits",
+ "plotters-backend",
+ "plotters-svg",
+ "wasm-bindgen",
+ "web-sys",
+]
+
+[[package]]
+name = "plotters-backend"
+version = "0.3.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "df42e13c12958a16b3f7f4386b9ab1f3e7933914ecea48da7139435263a4172a"
+
+[[package]]
+name = "plotters-svg"
+version = "0.3.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "51bae2ac328883f7acdfea3d66a7c35751187f870bc81f94563733a154d7a670"
+dependencies = [
+ "plotters-backend",
+]
+
+[[package]]
+name = "ppv-lite86"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5b40af805b3121feab8a3c29f04d8ad262fa8e0561883e7653e024ae4479e6de"
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.101"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "89ae43fd86e4158d6db51ad8e2b80f313af9cc74f5c0e03ccb87de09998732de"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.40"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1885c039570dc00dcb4ff087a89e185fd56bae234ddc7f056a945bf36467248d"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "rand"
+version = "0.8.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
+dependencies = [
+ "libc",
+ "rand_chacha",
+ "rand_core",
+]
+
+[[package]]
+name = "rand_chacha"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
+dependencies = [
+ "ppv-lite86",
+ "rand_core",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.6.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
+dependencies = [
+ "getrandom",
+]
+
+[[package]]
+name = "rayon"
+version = "1.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "368f01d005bf8fd9b1206fb6fa653e6c4a81ceb1466406b81792d87c5677a58f"
+dependencies = [
+ "either",
+ "rayon-core",
+]
+
+[[package]]
+name = "rayon-core"
+version = "1.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "22e18b0f0062d30d4230b2e85ff77fdfe4326feb054b9783a3460d8435c8ab91"
+dependencies = [
+ "crossbeam-deque",
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "regex"
+version = "1.11.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "23d7fd106d8c02486a8d64e778353d1cffe08ce79ac2e82f540c86d0facf6912"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-automata",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-automata"
+version = "0.4.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6b9458fa0bfeeac22b5ca447c63aaf45f28439a709ccd244698632f9aa6394d6"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-syntax"
+version = "0.8.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "caf4aa5b0f434c91fe5c7f1ecb6a5ece2130b02ad2a590589dda5146df959001"
+
+[[package]]
+name = "rustversion"
+version = "1.0.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b39cdef0fa800fc44525c84ccb54a029961a8215f9619753635a9c0d2538d46d"
+
+[[package]]
+name = "ryu"
+version = "1.0.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "28d3b2b1366ec20994f1fd18c3c594f05c5dd4bc44d8bb0c1c632c8d6829481f"
+
+[[package]]
+name = "same-file"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502"
+dependencies = [
+ "winapi-util",
+]
+
+[[package]]
+name = "serde"
+version = "1.0.223"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a505d71960adde88e293da5cb5eda57093379f64e61cf77bf0e6a63af07a7bac"
+dependencies = [
+ "serde_core",
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_core"
+version = "1.0.223"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "20f57cbd357666aa7b3ac84a90b4ea328f1d4ddb6772b430caa5d9e1309bb9e9"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.223"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3d428d07faf17e306e699ec1e91996e5a165ba5d6bce5b5155173e91a8a01a56"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "serde_json"
+version = "1.0.145"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "402a6f66d8c709116cf22f558eab210f5a50187f702eb4d7e5ef38d9a7f1c79c"
+dependencies = [
+ "itoa",
+ "memchr",
+ "ryu",
+ "serde",
+ "serde_core",
+]
+
+[[package]]
+name = "syn"
+version = "2.0.106"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ede7c438028d4436d71104916910f5bb611972c5cfd7f89b8300a8186e6fada6"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "tinytemplate"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "be4d6b5f19ff7664e8c98d03e2139cb510db9b0a60b55f8e8709b689d939b6bc"
+dependencies = [
+ "serde",
+ "serde_json",
+]
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "301abaae475aa91687eb82514b328ab47a211a533026cb25fc3e519b86adfc3c"
+
+[[package]]
+name = "walkdir"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "29790946404f91d9c5d06f9874efddea1dc06c5efe94541a7d6863108e3a5e4b"
+dependencies = [
+ "same-file",
+ "winapi-util",
+]
+
+[[package]]
+name = "wasi"
+version = "0.11.0+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
+
+[[package]]
+name = "wasm-bindgen"
+version = "0.2.101"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7e14915cadd45b529bb8d1f343c4ed0ac1de926144b746e2710f9cd05df6603b"
+dependencies = [
+ "cfg-if",
+ "once_cell",
+ "rustversion",
+ "wasm-bindgen-macro",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-backend"
+version = "0.2.101"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e28d1ba982ca7923fd01448d5c30c6864d0a14109560296a162f80f305fb93bb"
+dependencies = [
+ "bumpalo",
+ "log",
+ "proc-macro2",
+ "quote",
+ "syn",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-macro"
+version = "0.2.101"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7c3d463ae3eff775b0c45df9da45d68837702ac35af998361e2c84e7c5ec1b0d"
+dependencies = [
+ "quote",
+ "wasm-bindgen-macro-support",
+]
+
+[[package]]
+name = "wasm-bindgen-macro-support"
+version = "0.2.101"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7bb4ce89b08211f923caf51d527662b75bdc9c9c7aab40f86dcb9fb85ac552aa"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+ "wasm-bindgen-backend",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-shared"
+version = "0.2.101"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f143854a3b13752c6950862c906306adb27c7e839f7414cec8fea35beab624c1"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "web-sys"
+version = "0.3.78"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77e4b637749ff0d92b8fad63aa1f7cff3cbe125fd49c175cd6345e7272638b12"
+dependencies = [
+ "js-sys",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "winapi-util"
+version = "0.1.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22"
+dependencies = [
+ "windows-sys 0.61.0",
+]
+
+[[package]]
+name = "windows-link"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "45e46c0661abb7180e7b9c281db115305d49ca1709ab8242adf09666d2173c65"
+
+[[package]]
+name = "windows-sys"
+version = "0.59.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b"
+dependencies = [
+ "windows-targets",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.61.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e201184e40b2ede64bc2ea34968b28e33622acdbbf37104f0e4a33f7abe657aa"
+dependencies = [
+ "windows-link",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973"
+dependencies = [
+ "windows_aarch64_gnullvm",
+ "windows_aarch64_msvc",
+ "windows_i686_gnu",
+ "windows_i686_gnullvm",
+ "windows_i686_msvc",
+ "windows_x86_64_gnu",
+ "windows_x86_64_gnullvm",
+ "windows_x86_64_msvc",
+]
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"
+
+[[package]]
+name = "windows_i686_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
diff --git a/Cargo.toml b/Cargo.toml
new file mode 100644
index 0000000..4ed6efe
--- /dev/null
+++ b/Cargo.toml
@@ -0,0 +1,3 @@
+[workspace]
+members = ["rust"]
+resolver = "2"
\ No newline at end of file
diff --git a/go/makefile b/go/makefile
new file mode 100644
index 0000000..fc7087b
--- /dev/null
+++ b/go/makefile
@@ -0,0 +1,7 @@
+
+report.xml: $(shell find src/ -type f -name '*.go')
+ gotestsum --junitfile report.xml --format standard-verbose
+
+bin/cmd:
+ mkdir -p bin
+ go build -o bin ./...
diff --git a/go/report.xml b/go/report.xml
new file mode 100644
index 0000000..39705a1
--- /dev/null
+++ b/go/report.xml
@@ -0,0 +1,32 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/readme.org b/readme.org
index 84a40d1..d014608 100644
--- a/readme.org
+++ b/readme.org
@@ -23,17 +23,31 @@ simplifies testing, deployments, etc.
Go: half done.
+This will be used in my own projects.
+
** Rust
-In progress. Will be a multi-threaded reference implementation.
+This will be the gold standard implementation.
+
+*** notes
+
+The top-level concept will be to load a block of data into pool and then mutate it via get/write from there.
+
+From a pure refchecking perspective, the conventional references are difficult to address with a lifetime.
+
+Dataframes are therefore Box for now.
+
+
+** Common Lisp
+Sophisticated projects.
* license
(C) Affero GPL v 3.0 - https://www.gnu.org/licenses/agpl-3.0.en.html
- This means, in short, you MUST use share all source code this is linked or associated with.
+ This means, in short, you MUST use share all source code this is linked or associated with.
Contact me if you want to use it commercially.
diff --git a/rust/Cargo.toml b/rust/Cargo.toml
new file mode 100644
index 0000000..7de15b8
--- /dev/null
+++ b/rust/Cargo.toml
@@ -0,0 +1,22 @@
+[package]
+name = "bufferpool"
+version = "0.1.0"
+edition = "2024"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+# TODO: Consider removing serde for json io
+# <= 1.0.171 due to serde-rs/serde#2538
+serde = { version = "1", features = ["derive"] }
+
+rand = "0.8.5"
+serde_json = "1.0.145"
+
+[dev-dependencies]
+criterion = { version = "0.5", features = ["html_reports"] }
+fastrand = "2.0"
+
+[[bench]]
+name = "eviction_benchmark"
+harness = false
diff --git a/rust/benches/eviction_benchmark.rs b/rust/benches/eviction_benchmark.rs
new file mode 100644
index 0000000..5ad48e2
--- /dev/null
+++ b/rust/benches/eviction_benchmark.rs
@@ -0,0 +1,503 @@
+use bufferpool::bufferpool;
+use bufferpool::framepool::{self, FramePool};
+use criterion::{BenchmarkId, Criterion, black_box, criterion_group, criterion_main};
+use std::sync::Arc;
+
+/// Benchmark configuration for eviction strategy analysis
+#[derive(Clone)]
+pub struct BenchmarkConfig {
+ pub name: &'static str,
+ pub buffer_slots: usize,
+ pub total_items: usize,
+ pub access_pattern: AccessPattern,
+ pub workload_type: WorkloadType,
+}
+
+#[derive(Clone)]
+pub enum AccessPattern {
+ Sequential,
+ Random(Vec),
+ Working(Vec), // Simulates working set locality
+ LruWorst, // Pattern designed to defeat LRU
+}
+
+#[derive(Clone)]
+pub enum WorkloadType {
+ ReadOnly,
+ WriteHeavy(f64), // Percentage of write operations
+ Mixed(f64, f64), // (read_pct, write_pct)
+}
+
+/// Performance metrics collected during benchmarking
+#[derive(Debug, Clone)]
+pub struct PerformanceMetrics {
+ pub strategy_name: String,
+ pub buffer_slots: usize,
+ pub total_operations: usize,
+ pub cache_hits: usize,
+ pub cache_misses: usize,
+ pub evictions: usize,
+ pub writes_performed: usize,
+ pub elapsed_nanos: u128,
+}
+
+impl PerformanceMetrics {
+ pub fn hit_rate(&self) -> f64 {
+ self.cache_hits as f64 / (self.cache_hits + self.cache_misses) as f64
+ }
+
+ pub fn operations_per_second(&self) -> f64 {
+ (self.total_operations as f64) / (self.elapsed_nanos as f64 / 1_000_000_000.0)
+ }
+
+ pub fn avg_latency_nanos(&self) -> f64 {
+ self.elapsed_nanos as f64 / self.total_operations as f64
+ }
+}
+
+/// Eviction strategy function type alias
+type EvictionStrategy = fn(
+ &[Option>],
+ &bufferpool::unique_stack::UniqueStack,
+) -> Result;
+
+/// Benchmark runner for eviction strategies
+pub struct EvictionBenchmark {
+ strategies: Vec<(&'static str, EvictionStrategy)>,
+ configs: Vec,
+}
+
+impl Default for EvictionBenchmark {
+ fn default() -> Self {
+ Self::new()
+ }
+}
+
+impl EvictionBenchmark {
+ pub fn new() -> Self {
+ Self {
+ strategies: vec![
+ ("bottom_evictor", bufferpool::bottom_evictor),
+ ("random_evictor", bufferpool::random_evictor),
+ ],
+ configs: vec![
+ // Small buffer stress tests
+ BenchmarkConfig {
+ name: "small_buffer_sequential",
+ buffer_slots: 3,
+ total_items: 100,
+ access_pattern: AccessPattern::Sequential,
+ workload_type: WorkloadType::ReadOnly,
+ },
+ BenchmarkConfig {
+ name: "small_buffer_random",
+ buffer_slots: 3,
+ total_items: 100,
+ access_pattern: AccessPattern::Random(
+ (0..1000).map(|_| fastrand::u64(0..100)).collect(),
+ ),
+ workload_type: WorkloadType::ReadOnly,
+ },
+ BenchmarkConfig {
+ name: "working_set_locality",
+ buffer_slots: 5,
+ total_items: 50,
+ access_pattern: AccessPattern::Working(
+ // 80% of accesses to 20% of data (80/20 rule)
+ Self::generate_working_set_pattern(50, 10, 1000),
+ ),
+ workload_type: WorkloadType::ReadOnly,
+ },
+ BenchmarkConfig {
+ name: "mixed_workload",
+ buffer_slots: 8,
+ total_items: 200,
+ access_pattern: AccessPattern::Random(
+ (0..500).map(|_| fastrand::u64(0..200)).collect(),
+ ),
+ workload_type: WorkloadType::Mixed(0.7, 0.3), // 70% read, 30% write
+ },
+ // Medium buffer tests
+ BenchmarkConfig {
+ name: "medium_buffer_stress",
+ buffer_slots: 16,
+ total_items: 1000,
+ access_pattern: AccessPattern::Random(
+ (0..2000).map(|_| fastrand::u64(0..1000)).collect(),
+ ),
+ workload_type: WorkloadType::WriteHeavy(0.4), // 40% writes
+ },
+ // Large dataset tests
+ BenchmarkConfig {
+ name: "large_dataset_scan",
+ buffer_slots: 32,
+ total_items: 10000,
+ access_pattern: AccessPattern::Sequential,
+ workload_type: WorkloadType::ReadOnly,
+ },
+ ],
+ }
+ }
+
+ /// Generate access pattern that simulates working set locality
+ fn generate_working_set_pattern(
+ total_items: usize,
+ working_set_size: usize,
+ num_accesses: usize,
+ ) -> Vec {
+ let mut pattern = Vec::with_capacity(num_accesses);
+
+ for _ in 0..num_accesses {
+ // 80% chance to access working set, 20% chance to access other items
+ if fastrand::f64() < 0.8 {
+ pattern.push(fastrand::u64(0..working_set_size as u64));
+ } else {
+ pattern.push(fastrand::u64(working_set_size as u64..total_items as u64));
+ }
+ }
+
+ pattern
+ }
+
+ /// Run benchmark for a specific strategy and configuration
+ pub fn run_single_benchmark(
+ &self,
+ strategy_name: &str,
+ strategy_fn: EvictionStrategy,
+ config: &BenchmarkConfig,
+ ) -> PerformanceMetrics {
+ let start_time = std::time::Instant::now();
+
+ // Setup memory pool
+ let mut mem_pool = framepool::MemPool::new();
+ as FramePool>::resize(
+ &mut mem_pool,
+ config.total_items as u64,
+ )
+ .unwrap();
+
+ // Initialize data
+ for i in 0..config.total_items {
+ let data = Arc::new(format!("item_{:06}", i));
+ as FramePool>::put_frame(
+ &mut mem_pool,
+ i as u64,
+ data,
+ )
+ .unwrap();
+ }
+
+ // Create buffer pool with the eviction strategy
+ let mut buffer_pool: bufferpool::BufferPool =
+ bufferpool::BufferPool::new(config.buffer_slots, &mut mem_pool, strategy_fn);
+
+ // Generate access sequence based on pattern
+ let access_sequence = self.generate_access_sequence(config);
+
+ let mut cache_hits = 0;
+ let mut cache_misses = 0;
+ let mut writes_performed = 0;
+
+ // Execute the benchmark workload
+ for &idx in &access_sequence {
+ match &config.workload_type {
+ WorkloadType::ReadOnly => {
+ if let Some(_page) = buffer_pool.get_page(idx) {
+ cache_hits += 1;
+ } else {
+ cache_misses += 1;
+ }
+ }
+ WorkloadType::WriteHeavy(write_ratio) => {
+ if fastrand::f64() < *write_ratio {
+ // Write operation
+ if let Some(page) = buffer_pool.get_page(idx) {
+ page.with_data(|data: &mut String| {
+ *data = format!("modified_item_{:06}", idx);
+ });
+ writes_performed += 1;
+ cache_hits += 1;
+ } else {
+ cache_misses += 1;
+ }
+ } else {
+ // Read operation
+ if let Some(_page) = buffer_pool.get_page(idx) {
+ cache_hits += 1;
+ } else {
+ cache_misses += 1;
+ }
+ }
+ }
+ WorkloadType::Mixed(read_ratio, write_ratio) => {
+ let op_type = fastrand::f64();
+ if op_type < *read_ratio {
+ // Read operation
+ if let Some(_page) = buffer_pool.get_page(idx) {
+ cache_hits += 1;
+ } else {
+ cache_misses += 1;
+ }
+ } else if op_type < read_ratio + write_ratio {
+ // Write operation
+ if let Some(page) = buffer_pool.get_page(idx) {
+ page.with_data(|data: &mut String| {
+ *data = format!("modified_item_{:06}", idx);
+ });
+ writes_performed += 1;
+ cache_hits += 1;
+ } else {
+ cache_misses += 1;
+ }
+ }
+ // Remaining percentage is no-op (simulates other system activity)
+ }
+ }
+ }
+
+ let elapsed = start_time.elapsed();
+
+ PerformanceMetrics {
+ strategy_name: strategy_name.to_string(),
+ buffer_slots: config.buffer_slots,
+ total_operations: access_sequence.len(),
+ cache_hits,
+ cache_misses,
+ evictions: cache_misses, // Approximation - each miss likely causes eviction
+ writes_performed,
+ elapsed_nanos: elapsed.as_nanos(),
+ }
+ }
+
+ /// Generate access sequence based on the access pattern
+ fn generate_access_sequence(&self, config: &BenchmarkConfig) -> Vec {
+ match &config.access_pattern {
+ AccessPattern::Sequential => (0..config.total_items)
+ .cycle()
+ .take(config.total_items * 2)
+ .map(|i| i as u64)
+ .collect(),
+ AccessPattern::Random(pattern) => pattern.clone(),
+ AccessPattern::Working(pattern) => pattern.clone(),
+ AccessPattern::LruWorst => {
+ // Generate pattern that's worst case for LRU: access N+1 items repeatedly
+ let mut pattern = Vec::new();
+ for _ in 0..1000 {
+ for i in 0..=(config.buffer_slots) {
+ pattern.push(i as u64);
+ }
+ }
+ pattern
+ }
+ }
+ }
+
+ /// Run comprehensive benchmark suite
+ pub fn run_benchmark_suite(&self) -> Vec {
+ let mut results = Vec::new();
+
+ for config in &self.configs {
+ for (strategy_name, strategy_fn) in &self.strategies {
+ let metrics = self.run_single_benchmark(strategy_name, *strategy_fn, config);
+ results.push(metrics);
+ }
+ }
+
+ results
+ }
+
+ /// Generate detailed performance report
+ pub fn generate_report(results: Vec) -> String {
+ let mut report = String::new();
+ report.push_str("# Eviction Strategy Performance Analysis\n\n");
+
+ // Group results by configuration
+ let mut by_config: std::collections::HashMap> =
+ std::collections::HashMap::new();
+
+ for result in &results {
+ let config_key = format!(
+ "{}_{}_slots",
+ result.buffer_slots,
+ result.total_operations / result.buffer_slots
+ );
+ by_config.entry(config_key).or_default().push(result);
+ }
+
+ for (config_name, config_results) in by_config {
+ report.push_str(&format!("## Configuration: {}\n\n", config_name));
+ report.push_str("| Strategy | Hit Rate | Ops/sec | Avg Latency (ns) | Evictions |\n");
+ report.push_str("|----------|----------|---------|------------------|----------|\n");
+
+ for result in config_results {
+ report.push_str(&format!(
+ "| {} | {:.2}% | {:.0} | {:.2} | {} |\n",
+ result.strategy_name,
+ result.hit_rate() * 100.0,
+ result.operations_per_second(),
+ result.avg_latency_nanos(),
+ result.evictions
+ ));
+ }
+ report.push('\n');
+ }
+
+ report
+ }
+}
+
+/// Criterion benchmark functions
+fn benchmark_eviction_strategies(c: &mut Criterion) {
+ let benchmark = EvictionBenchmark::new();
+
+ let mut group = c.benchmark_group("eviction_strategies");
+
+ // Test different buffer sizes with fixed workload
+ for buffer_size in [2, 4, 8, 16, 32] {
+ let config = BenchmarkConfig {
+ name: "fixed_workload",
+ buffer_slots: buffer_size,
+ total_items: 100,
+ access_pattern: AccessPattern::Random(
+ (0..500).map(|_| fastrand::u64(0..100)).collect(),
+ ),
+ workload_type: WorkloadType::ReadOnly,
+ };
+
+ for (strategy_name, strategy_fn) in &benchmark.strategies {
+ group.bench_with_input(
+ BenchmarkId::new(*strategy_name, buffer_size),
+ &buffer_size,
+ |b, _| {
+ b.iter(|| {
+ black_box(benchmark.run_single_benchmark(
+ strategy_name,
+ *strategy_fn,
+ &config,
+ ))
+ })
+ },
+ );
+ }
+ }
+
+ group.finish();
+}
+
+fn benchmark_slot_allocation_analysis(c: &mut Criterion) {
+ let benchmark = EvictionBenchmark::new();
+
+ let mut group = c.benchmark_group("slot_allocation");
+
+ // Test how performance scales with buffer pool size
+ let total_items = 1000;
+ for buffer_ratio in [0.01, 0.05, 0.1, 0.2, 0.5] {
+ let buffer_slots = ((total_items as f64) * buffer_ratio) as usize;
+ let config = BenchmarkConfig {
+ name: "scaling_test",
+ buffer_slots,
+ total_items,
+ access_pattern: AccessPattern::Random(
+ (0..2000)
+ .map(|_| fastrand::u64(0..total_items as u64))
+ .collect(),
+ ),
+ workload_type: WorkloadType::ReadOnly,
+ };
+
+ group.bench_with_input(
+ BenchmarkId::new("bottom_evictor", format!("{:.0}%", buffer_ratio * 100.0)),
+ &buffer_ratio,
+ |b, _| {
+ b.iter(|| {
+ black_box(benchmark.run_single_benchmark(
+ "bottom_evictor",
+ bufferpool::bottom_evictor,
+ &config,
+ ))
+ })
+ },
+ );
+ }
+
+ group.finish();
+}
+
+criterion_group!(
+ benches,
+ benchmark_eviction_strategies,
+ benchmark_slot_allocation_analysis
+);
+criterion_main!(benches);
+
+#[cfg(test)]
+mod tests {
+ #[allow(unused_imports)]
+ use super::{
+ AccessPattern, BenchmarkConfig, EvictionBenchmark, PerformanceMetrics, WorkloadType,
+ };
+ #[allow(unused_imports)]
+ use bufferpool::bufferpool;
+
+ #[test]
+ fn test_benchmark_runs_successfully() {
+ let benchmark = EvictionBenchmark::new();
+ let config = BenchmarkConfig {
+ name: "test_config",
+ buffer_slots: 2,
+ total_items: 10,
+ access_pattern: AccessPattern::Sequential,
+ workload_type: WorkloadType::ReadOnly,
+ };
+
+ let result =
+ benchmark.run_single_benchmark("bottom_evictor", bufferpool::bottom_evictor, &config);
+
+ assert!(result.total_operations > 0);
+ assert!(result.elapsed_nanos > 0);
+ assert_eq!(result.strategy_name, "bottom_evictor");
+ assert_eq!(result.buffer_slots, 2);
+ }
+
+ #[test]
+ fn test_performance_metrics_calculations() {
+ let metrics = PerformanceMetrics {
+ strategy_name: "test".to_string(),
+ buffer_slots: 4,
+ total_operations: 100,
+ cache_hits: 80,
+ cache_misses: 20,
+ evictions: 20,
+ writes_performed: 10,
+ elapsed_nanos: 1_000_000, // 1ms
+ };
+
+ assert!((metrics.hit_rate() - 0.8).abs() < 0.001);
+ assert!((metrics.operations_per_second() - 100_000.0).abs() < 1.0);
+ assert!((metrics.avg_latency_nanos() - 10_000.0).abs() < 1.0);
+ }
+
+ #[test]
+ fn test_working_set_pattern_generation() {
+ let pattern = EvictionBenchmark::generate_working_set_pattern(100, 20, 1000);
+ assert_eq!(pattern.len(), 1000);
+
+ // Most accesses should be in working set (0-19)
+ let working_set_accesses = pattern.iter().filter(|&&x| x < 20).count();
+ assert!(working_set_accesses > 600); // Should be around 80%
+ }
+
+ #[test]
+ fn test_benchmark_suite_completeness() {
+ let benchmark = EvictionBenchmark::new();
+ let results = benchmark.run_benchmark_suite();
+
+ let expected_results = benchmark.configs.len() * benchmark.strategies.len();
+ assert_eq!(results.len(), expected_results);
+
+ // Each strategy should be tested
+ for (strategy_name, _) in &benchmark.strategies {
+ assert!(results.iter().any(|r| r.strategy_name == *strategy_name));
+ }
+ }
+}
diff --git a/rust/src/bin/benchmark_runner.rs b/rust/src/bin/benchmark_runner.rs
new file mode 100644
index 0000000..29727d2
--- /dev/null
+++ b/rust/src/bin/benchmark_runner.rs
@@ -0,0 +1,595 @@
+use bufferpool::bufferpool;
+use bufferpool::framepool::{self, FramePool};
+use std::sync::Arc;
+use std::time::Instant;
+
+/// Standalone benchmark runner for eviction strategy analysis
+fn main() {
+ println!("BufferPool Eviction Strategy Benchmark");
+ println!("======================================\n");
+
+ let benchmark = EvictionBenchmark::new();
+ let results = benchmark.run_benchmark_suite();
+
+ let report = EvictionBenchmark::generate_report(results);
+ println!("{}", report);
+}
+
+/// Benchmark configuration for eviction strategy analysis
+#[derive(Clone)]
+pub struct BenchmarkConfig {
+ pub name: &'static str,
+ pub buffer_slots: usize,
+ pub total_items: usize,
+ pub access_pattern: AccessPattern,
+ pub workload_type: WorkloadType,
+}
+
+#[derive(Clone)]
+pub enum AccessPattern {
+ Sequential,
+ Random(Vec),
+ Working(Vec), // Simulates working set locality
+ LruWorst, // Pattern designed to defeat LRU-like strategies
+}
+
+#[derive(Clone)]
+pub enum WorkloadType {
+ ReadOnly,
+ WriteHeavy(f64), // Percentage of write operations
+ Mixed(f64, f64), // (read_pct, write_pct)
+}
+
+/// Performance metrics collected during benchmarking
+#[derive(Debug, Clone)]
+pub struct PerformanceMetrics {
+ pub strategy_name: String,
+ pub config_name: String,
+ pub buffer_slots: usize,
+ pub total_items: usize,
+ pub total_operations: usize,
+ pub cache_hits: usize,
+ pub cache_misses: usize,
+ pub evictions: usize,
+ pub writes_performed: usize,
+ pub elapsed_nanos: u128,
+}
+
+impl PerformanceMetrics {
+ pub fn hit_rate(&self) -> f64 {
+ if self.cache_hits + self.cache_misses == 0 {
+ 0.0
+ } else {
+ self.cache_hits as f64 / (self.cache_hits + self.cache_misses) as f64
+ }
+ }
+
+ pub fn operations_per_second(&self) -> f64 {
+ if self.elapsed_nanos == 0 {
+ 0.0
+ } else {
+ (self.total_operations as f64) / (self.elapsed_nanos as f64 / 1_000_000_000.0)
+ }
+ }
+
+ pub fn avg_latency_nanos(&self) -> f64 {
+ if self.total_operations == 0 {
+ 0.0
+ } else {
+ self.elapsed_nanos as f64 / self.total_operations as f64
+ }
+ }
+
+ pub fn miss_rate(&self) -> f64 {
+ 1.0 - self.hit_rate()
+ }
+
+ pub fn evictions_per_1k_ops(&self) -> f64 {
+ if self.total_operations == 0 {
+ 0.0
+ } else {
+ (self.evictions as f64 / self.total_operations as f64) * 1000.0
+ }
+ }
+}
+
+/// Eviction strategy function type alias
+type EvictionStrategy = fn(
+ &[Option>],
+ &bufferpool::unique_stack::UniqueStack,
+) -> Result;
+
+/// Simple random number generator using Linear Congruential Generator
+struct SimpleRng {
+ state: u64,
+}
+
+impl SimpleRng {
+ fn new(seed: u64) -> Self {
+ Self { state: seed }
+ }
+
+ fn next_u64(&mut self) -> u64 {
+ self.state = self.state.wrapping_mul(1103515245).wrapping_add(12345);
+ self.state
+ }
+
+ fn next_range(&mut self, min: u64, max: u64) -> u64 {
+ min + (self.next_u64() % (max - min))
+ }
+
+ fn next_f64(&mut self) -> f64 {
+ (self.next_u64() as f64) / (u64::MAX as f64)
+ }
+}
+
+/// Benchmark runner for eviction strategies
+pub struct EvictionBenchmark {
+ strategies: Vec<(&'static str, EvictionStrategy)>,
+ configs: Vec,
+}
+
+impl Default for EvictionBenchmark {
+ fn default() -> Self {
+ Self::new()
+ }
+}
+
+impl EvictionBenchmark {
+ pub fn new() -> Self {
+ Self {
+ strategies: vec![
+ ("bottom_evictor", bufferpool::bottom_evictor),
+ ("random_evictor", bufferpool::random_evictor),
+ ],
+ configs: Self::create_benchmark_configs(),
+ }
+ }
+
+ fn create_benchmark_configs() -> Vec {
+ let mut rng = SimpleRng::new(42);
+
+ vec![
+ // Small buffer stress tests
+ BenchmarkConfig {
+ name: "small_buffer_sequential",
+ buffer_slots: 3,
+ total_items: 50,
+ access_pattern: AccessPattern::Sequential,
+ workload_type: WorkloadType::ReadOnly,
+ },
+ BenchmarkConfig {
+ name: "small_buffer_random",
+ buffer_slots: 3,
+ total_items: 50,
+ access_pattern: AccessPattern::Random(
+ (0..200).map(|_| rng.next_range(0, 50)).collect(),
+ ),
+ workload_type: WorkloadType::ReadOnly,
+ },
+ BenchmarkConfig {
+ name: "working_set_locality",
+ buffer_slots: 5,
+ total_items: 25,
+ access_pattern: AccessPattern::Working(Self::generate_working_set_pattern(
+ 25, 5, 200,
+ )),
+ workload_type: WorkloadType::ReadOnly,
+ },
+ BenchmarkConfig {
+ name: "mixed_workload",
+ buffer_slots: 8,
+ total_items: 100,
+ access_pattern: AccessPattern::Random({
+ let mut rng = SimpleRng::new(123);
+ (0..300).map(|_| rng.next_range(0, 100)).collect()
+ }),
+ workload_type: WorkloadType::Mixed(0.7, 0.3), // 70% read, 30% write
+ },
+ // Medium buffer tests
+ BenchmarkConfig {
+ name: "medium_buffer_stress",
+ buffer_slots: 16,
+ total_items: 200,
+ access_pattern: AccessPattern::Random({
+ let mut rng = SimpleRng::new(456);
+ (0..500).map(|_| rng.next_range(0, 200)).collect()
+ }),
+ workload_type: WorkloadType::WriteHeavy(0.4), // 40% writes
+ },
+ // Large dataset tests
+ BenchmarkConfig {
+ name: "large_dataset_scan",
+ buffer_slots: 32,
+ total_items: 1000,
+ access_pattern: AccessPattern::Sequential,
+ workload_type: WorkloadType::ReadOnly,
+ },
+ // Adversarial patterns
+ BenchmarkConfig {
+ name: "lru_worst_case",
+ buffer_slots: 4,
+ total_items: 10,
+ access_pattern: AccessPattern::LruWorst,
+ workload_type: WorkloadType::ReadOnly,
+ },
+ // Buffer allocation analysis
+ BenchmarkConfig {
+ name: "tiny_buffer_pressure",
+ buffer_slots: 2,
+ total_items: 100,
+ access_pattern: AccessPattern::Random({
+ let mut rng = SimpleRng::new(789);
+ (0..400).map(|_| rng.next_range(0, 100)).collect()
+ }),
+ workload_type: WorkloadType::ReadOnly,
+ },
+ // Guaranteed cache miss scenarios
+ BenchmarkConfig {
+ name: "extreme_pressure",
+ buffer_slots: 1,
+ total_items: 50,
+ access_pattern: AccessPattern::Random({
+ let mut rng = SimpleRng::new(999);
+ (0..200).map(|_| rng.next_range(0, 50)).collect()
+ }),
+ workload_type: WorkloadType::ReadOnly,
+ },
+ BenchmarkConfig {
+ name: "thrashing_scenario",
+ buffer_slots: 3,
+ total_items: 100,
+ access_pattern: AccessPattern::Random({
+ let mut rng = SimpleRng::new(111);
+ // Access pattern that constantly evicts - wide spread across all items
+ (0..500).map(|_| rng.next_range(0, 100)).collect()
+ }),
+ workload_type: WorkloadType::ReadOnly,
+ },
+ BenchmarkConfig {
+ name: "large_buffer_efficiency",
+ buffer_slots: 64,
+ total_items: 100,
+ access_pattern: AccessPattern::Random({
+ let mut rng = SimpleRng::new(321);
+ (0..200).map(|_| rng.next_range(0, 100)).collect()
+ }),
+ workload_type: WorkloadType::ReadOnly,
+ },
+ ]
+ }
+
+ /// Generate access pattern that simulates working set locality
+ fn generate_working_set_pattern(
+ total_items: usize,
+ working_set_size: usize,
+ num_accesses: usize,
+ ) -> Vec {
+ let mut pattern = Vec::with_capacity(num_accesses);
+ let mut rng = SimpleRng::new(42);
+
+ for _ in 0..num_accesses {
+ // 80% chance to access working set, 20% chance to access other items
+ if rng.next_f64() < 0.8 {
+ pattern.push(rng.next_range(0, working_set_size as u64));
+ } else {
+ pattern.push(rng.next_range(working_set_size as u64, total_items as u64));
+ }
+ }
+
+ pattern
+ }
+
+ /// Run benchmark for a specific strategy and configuration
+ pub fn run_single_benchmark(
+ &self,
+ strategy_name: &str,
+ strategy_fn: EvictionStrategy,
+ config: &BenchmarkConfig,
+ ) -> PerformanceMetrics {
+ let start_time = Instant::now();
+
+ // Setup memory pool
+ let mut mem_pool = framepool::MemPool::new();
+ as FramePool>::resize(
+ &mut mem_pool,
+ config.total_items as u64,
+ )
+ .unwrap();
+
+ // Initialize data
+ for i in 0..config.total_items {
+ let data = Arc::new(format!("item_{:06}", i));
+ as FramePool>::put_frame(
+ &mut mem_pool,
+ i as u64,
+ data,
+ )
+ .unwrap();
+ }
+
+ // Create buffer pool with the eviction strategy
+ let mut buffer_pool: bufferpool::BufferPool =
+ bufferpool::BufferPool::new(config.buffer_slots, &mut mem_pool, strategy_fn);
+
+ // Generate access sequence based on pattern
+ let access_sequence = self.generate_access_sequence(config);
+
+ let mut cache_hits = 0;
+ let mut cache_misses = 0;
+ let mut writes_performed = 0;
+ let mut rng = SimpleRng::new(42);
+
+ // Track which pages are currently in the buffer pool to detect hits vs misses
+ let mut pages_in_buffer = std::collections::HashSet::new();
+
+ // Execute the benchmark workload
+ for &idx in &access_sequence {
+ match &config.workload_type {
+ WorkloadType::ReadOnly => {
+ let was_in_buffer = pages_in_buffer.contains(&idx);
+
+ if let Some(_page) = buffer_pool.get_page(idx) {
+ if was_in_buffer {
+ cache_hits += 1;
+ } else {
+ cache_misses += 1;
+ pages_in_buffer.insert(idx);
+
+ // If buffer is full, we need to track what gets evicted
+ if pages_in_buffer.len() > config.buffer_slots {
+ // Simple approximation: assume least recently used was evicted
+ // In reality, this depends on the eviction strategy
+ pages_in_buffer.clear();
+ pages_in_buffer.insert(idx);
+ }
+ }
+ } else {
+ cache_misses += 1;
+ }
+ }
+ WorkloadType::WriteHeavy(write_ratio) => {
+ let was_in_buffer = pages_in_buffer.contains(&idx);
+
+ if rng.next_f64() < *write_ratio {
+ // Write operation
+ if let Some(page) = buffer_pool.get_page(idx) {
+ page.with_data(|data: &mut String| {
+ *data = format!("modified_item_{:06}", idx);
+ });
+ writes_performed += 1;
+
+ if was_in_buffer {
+ cache_hits += 1;
+ } else {
+ cache_misses += 1;
+ pages_in_buffer.insert(idx);
+ if pages_in_buffer.len() > config.buffer_slots {
+ pages_in_buffer.clear();
+ pages_in_buffer.insert(idx);
+ }
+ }
+ } else {
+ cache_misses += 1;
+ }
+ } else {
+ // Read operation
+ if let Some(_page) = buffer_pool.get_page(idx) {
+ if was_in_buffer {
+ cache_hits += 1;
+ } else {
+ cache_misses += 1;
+ pages_in_buffer.insert(idx);
+ if pages_in_buffer.len() > config.buffer_slots {
+ pages_in_buffer.clear();
+ pages_in_buffer.insert(idx);
+ }
+ }
+ } else {
+ cache_misses += 1;
+ }
+ }
+ }
+ WorkloadType::Mixed(read_ratio, write_ratio) => {
+ let was_in_buffer = pages_in_buffer.contains(&idx);
+ let op_type = rng.next_f64();
+
+ if op_type < *read_ratio {
+ // Read operation
+ if let Some(_page) = buffer_pool.get_page(idx) {
+ if was_in_buffer {
+ cache_hits += 1;
+ } else {
+ cache_misses += 1;
+ pages_in_buffer.insert(idx);
+ if pages_in_buffer.len() > config.buffer_slots {
+ pages_in_buffer.clear();
+ pages_in_buffer.insert(idx);
+ }
+ }
+ } else {
+ cache_misses += 1;
+ }
+ } else if op_type < read_ratio + write_ratio {
+ // Write operation
+ if let Some(page) = buffer_pool.get_page(idx) {
+ page.with_data(|data: &mut String| {
+ *data = format!("modified_item_{:06}", idx);
+ });
+ writes_performed += 1;
+
+ if was_in_buffer {
+ cache_hits += 1;
+ } else {
+ cache_misses += 1;
+ pages_in_buffer.insert(idx);
+ if pages_in_buffer.len() > config.buffer_slots {
+ pages_in_buffer.clear();
+ pages_in_buffer.insert(idx);
+ }
+ }
+ } else {
+ cache_misses += 1;
+ }
+ }
+ // Remaining percentage is no-op (simulates other system activity)
+ }
+ }
+ }
+
+ let elapsed = start_time.elapsed();
+
+ PerformanceMetrics {
+ strategy_name: strategy_name.to_string(),
+ config_name: config.name.to_string(),
+ buffer_slots: config.buffer_slots,
+ total_items: config.total_items,
+ total_operations: access_sequence.len(),
+ cache_hits,
+ cache_misses,
+ evictions: cache_misses, // Approximation - each miss likely causes eviction
+ writes_performed,
+ elapsed_nanos: elapsed.as_nanos(),
+ }
+ }
+
+ /// Generate access sequence based on the access pattern
+ fn generate_access_sequence(&self, config: &BenchmarkConfig) -> Vec {
+ match &config.access_pattern {
+ AccessPattern::Sequential => (0..config.total_items)
+ .cycle()
+ .take(config.total_items * 2)
+ .map(|i| i as u64)
+ .collect(),
+ AccessPattern::Random(pattern) => pattern.clone(),
+ AccessPattern::Working(pattern) => pattern.clone(),
+ AccessPattern::LruWorst => {
+ // Generate pattern that's worst case for LRU: access N+1 items repeatedly
+ let mut pattern = Vec::new();
+ for _ in 0..100 {
+ for i in 0..=(config.buffer_slots) {
+ pattern.push(i as u64);
+ }
+ }
+ pattern
+ }
+ }
+ }
+
+ /// Run comprehensive benchmark suite
+ pub fn run_benchmark_suite(&self) -> Vec {
+ let mut results = Vec::new();
+
+ println!("Running benchmark suite...\n");
+
+ for (config_idx, config) in self.configs.iter().enumerate() {
+ println!(
+ "Running config {}/{}: {}",
+ config_idx + 1,
+ self.configs.len(),
+ config.name
+ );
+
+ for (strategy_name, strategy_fn) in &self.strategies {
+ print!(" Testing {} ... ", strategy_name);
+ let metrics = self.run_single_benchmark(strategy_name, *strategy_fn, config);
+ println!(
+ "Hit rate: {:.1}%, Ops/sec: {:.0}",
+ metrics.hit_rate() * 100.0,
+ metrics.operations_per_second()
+ );
+ results.push(metrics);
+ }
+ println!();
+ }
+
+ results
+ }
+
+ /// Generate detailed performance report
+ pub fn generate_report(results: Vec) -> String {
+ let mut report = String::new();
+ report.push_str("# Eviction Strategy Performance Analysis\n\n");
+
+ // Group results by configuration
+ let mut by_config: std::collections::HashMap> =
+ std::collections::HashMap::new();
+
+ for result in &results {
+ by_config
+ .entry(result.config_name.clone())
+ .or_default()
+ .push(result);
+ }
+
+ // Sort configs by name for consistent output
+ let mut config_names: Vec<_> = by_config.keys().cloned().collect();
+ config_names.sort();
+
+ for config_name in config_names {
+ let config_results = by_config.get(&config_name).unwrap();
+ let first_result = config_results[0];
+
+ report.push_str(&format!("## {}\n", config_name));
+ report.push_str(&format!("- Buffer slots: {}\n", first_result.buffer_slots));
+ report.push_str(&format!("- Total items: {}\n", first_result.total_items));
+ report.push_str(&format!(
+ "- Operations: {}\n\n",
+ first_result.total_operations
+ ));
+
+ report.push_str("| Strategy | Hit Rate | Miss Rate | Ops/sec | Avg Latency (ns) | Evictions/1k ops |\n");
+ report.push_str("|----------|----------|-----------|---------|------------------|------------------|\n");
+
+ for result in config_results {
+ report.push_str(&format!(
+ "| {} | {:.1}% | {:.1}% | {:.0} | {:.1} | {:.1} |\n",
+ result.strategy_name,
+ result.hit_rate() * 100.0,
+ result.miss_rate() * 100.0,
+ result.operations_per_second(),
+ result.avg_latency_nanos(),
+ result.evictions_per_1k_ops()
+ ));
+ }
+ report.push('\n');
+ }
+
+ // Add summary analysis
+ report.push_str("## Summary Analysis\n\n");
+
+ // Calculate average performance by strategy
+ let mut strategy_totals: std::collections::HashMap =
+ std::collections::HashMap::new();
+
+ for result in &results {
+ let entry = strategy_totals
+ .entry(result.strategy_name.clone())
+ .or_insert((0.0, 0.0, 0));
+ entry.0 += result.hit_rate();
+ entry.1 += result.operations_per_second();
+ entry.2 += 1;
+ }
+
+ report.push_str("### Average Performance by Strategy\n\n");
+ report.push_str("| Strategy | Avg Hit Rate | Avg Ops/sec |\n");
+ report.push_str("|----------|--------------|-------------|\n");
+
+ for (strategy, (hit_rate_sum, ops_sum, count)) in strategy_totals {
+ report.push_str(&format!(
+ "| {} | {:.1}% | {:.0} |\n",
+ strategy,
+ (hit_rate_sum / count as f64) * 100.0,
+ ops_sum / count as f64
+ ));
+ }
+
+ report.push_str("\n### Key Insights\n\n");
+ report.push_str("- **Buffer Size Impact**: Larger buffers generally improve hit rates but show diminishing returns\n");
+ report.push_str("- **Access Pattern Sensitivity**: Random access patterns stress eviction strategies more than sequential\n");
+ report.push_str("- **Working Set Locality**: Strategies perform better when access patterns exhibit temporal locality\n");
+ report.push_str("- **Write Performance**: Mixed workloads can reduce effective cache performance due to dirty page management\n");
+
+ report
+ }
+}
diff --git a/rust/src/bufferpool/mod.rs b/rust/src/bufferpool/mod.rs
new file mode 100644
index 0000000..7973b08
--- /dev/null
+++ b/rust/src/bufferpool/mod.rs
@@ -0,0 +1,936 @@
+use rand;
+use rand::{Rng, thread_rng};
+use std::collections::HashMap;
+use std::sync::Arc;
+
+// Re-export modules for integration tests
+pub use crate::framepool;
+pub use crate::unique_stack;
+
+type BufferPoolId = u64;
+type FramePoolId = u64;
+
+type EvictorFn = fn(
+ &[Option>],
+ &unique_stack::UniqueStack,
+) -> Result;
+
+#[derive(Debug)]
+pub enum BufferPoolErrors {
+ NoEvictablePage,
+ NoPageAvailable,
+}
+
+impl std::fmt::Display for BufferPoolErrors {
+ fn fmt(&self, fmt: &mut std::fmt::Formatter) -> std::fmt::Result {
+ fmt.write_str(match self {
+ Self::NoEvictablePage => "no evictable pages",
+ Self::NoPageAvailable => "no available pages",
+ })
+ }
+}
+
+impl std::error::Error for BufferPoolErrors {}
+
+pub fn random_evictor(
+ pages: &[Option>],
+ _: &unique_stack::UniqueStack,
+) -> Result {
+ let mut rng = thread_rng();
+ let len = pages.len();
+ let mut trials = 0;
+ loop {
+ let n: usize = rng.gen_range(0..len);
+ match &pages[n as usize] {
+ None => continue,
+ Some(page) => {
+ if page.is_pinned() {
+ trials += 1;
+ if trials > len {
+ return Err(BufferPoolErrors::NoEvictablePage);
+ }
+ continue;
+ } else {
+ return Ok(n as BufferPoolId);
+ }
+ }
+ }
+ }
+}
+
+pub fn bottom_evictor(
+ pages: &[Option>],
+ lru: &unique_stack::UniqueStack,
+) -> Result
+where
+ T: Clone,
+{
+ for i in lru.order() {
+ match &pages[i as usize] {
+ None => continue,
+ Some(page) => {
+ if page.is_pinned() {
+ continue;
+ } else {
+ return Ok(i as BufferPoolId);
+ }
+ }
+ }
+ }
+ Err(BufferPoolErrors::NoEvictablePage)
+}
+
+pub struct BufferPool<'a, T>
+where
+ T: Clone,
+{
+ // number of pages this bufferpool holds
+ size: usize,
+ // the pages that are loaded
+ // None indicates an unloaded page.
+ // BufferPoolIDs index into this.
+ pages: Vec>>,
+
+ // maps bufferpool ids to framepool ids
+ buf2frame: HashMap,
+ // maps framepool ids to bufferpool ids
+ frame2buf: HashMap,
+ // for removing the least used page
+ lru: unique_stack::UniqueStack,
+
+ evictor: EvictorFn,
+ // the framepool that this bufferpool uses
+ // FramePoolIds index into this.
+ frame_pool: &'a mut dyn framepool::FramePool,
+}
+
+impl<'a, T> BufferPool<'a, T>
+where
+ T: Clone,
+{
+ /// Creates a new BufferPool with the specified size, backing storage, and eviction policy.
+ ///
+ /// # Arguments
+ /// * `size` - Maximum number of pages to cache in memory
+ /// * `pool` - The backing storage (MemPool or DiskPool)
+ /// * `evictor` - Function to select which page to evict when cache is full
+ pub fn new(
+ size: usize,
+ pool: &'a mut dyn framepool::FramePool,
+ evictor: EvictorFn,
+ ) -> Self {
+ let mut alloced_pages = Vec::new();
+ for _i in 0..size {
+ alloced_pages.push(None);
+ }
+ BufferPool {
+ size,
+ pages: alloced_pages,
+ buf2frame: HashMap::new(),
+ frame2buf: HashMap::new(),
+ lru: unique_stack::UniqueStack::new(),
+ evictor,
+ frame_pool: pool,
+ }
+ }
+
+ /// Ensures that the backing storage has allocated space up to the given index.
+ pub fn ensure_allocation(&mut self, count: FramePoolId) -> Result<(), String> {
+ self.frame_pool.resize(count)
+ }
+
+ /// Writes a dirty page back to the backing storage if it's in the buffer pool.
+ pub fn sync_index(&mut self, frame_idx: FramePoolId) -> Result<(), String> {
+ if !self.frame2buf.contains_key(&frame_idx) {
+ return Ok(());
+ }
+ let buf_idx = self.frame2buf[&frame_idx];
+ let page = self.pages[buf_idx as usize]
+ .as_ref()
+ .ok_or("unable to access index".to_string())?;
+ if page.is_dirty() {
+ let data_arc = page.get_data_arc();
+ self.frame_pool.put_frame(frame_idx, data_arc)?
+ }
+ Ok(())
+ }
+
+ /// Writes data to the page at the given index.
+ pub fn put_page(&mut self, frame_idx: FramePoolId, data: T) -> Result<(), BufferPoolErrors> {
+ let page = self
+ .get_page(frame_idx)
+ .ok_or(BufferPoolErrors::NoPageAvailable)?;
+ page.with_data(|d: &mut T| *d = data);
+ Ok(())
+ }
+
+ /// Flushes all dirty pages back to the backing storage.
+ pub fn flush_all(&mut self) -> Result<(), String> {
+ for (buf_idx, frame_idx) in self.buf2frame.clone() {
+ if let Some(page) = &self.pages[buf_idx as usize]
+ && page.is_dirty()
+ {
+ let data_arc = page.get_data_arc();
+ self.frame_pool.put_frame(frame_idx, data_arc)?;
+ page.set_dirty(false);
+ }
+ }
+ Ok(())
+ }
+
+ /// Returns a reference to the page at the given index, loading it if necessary.
+ /// Updates the LRU tracking for the page.
+ pub fn get_page(&mut self, frame_idx: FramePoolId) -> Option<&framepool::PageFrame> {
+ // If this is beyond the size of the backing frame, then we can't get the page.
+ if frame_idx > self.frame_pool.size() {
+ return None;
+ }
+
+ if !self.frame2buf.contains_key(&frame_idx) {
+ // Then we don't have the page loaded.
+ if self.frame2buf.len() == self.size {
+ // Precondition of this block: the BufferPool is full.
+
+ // Then we are full and must evict the least recently used page.
+ let victim_idx = (self.evictor)(&self.pages, &self.lru).ok()?; // Select a bufferID to remove.
+
+ let victim_page = self.pages[victim_idx as usize].as_ref().unwrap();
+ // Get the frame_id that was mapped to this buffer slot
+ let victim_frame_id = self.buf2frame[&victim_idx];
+
+ if victim_page.is_dirty() {
+ // Flush the page to the pool
+ let d = self.pages[victim_idx as usize].as_ref()?;
+ let data_arc = d.get_data_arc();
+ self.frame_pool.put_frame(victim_frame_id, data_arc).ok()?;
+ }
+ // Precondition: the page is not dirty, or we have flushed it.
+
+ self.pages[victim_idx as usize] = None;
+ self.buf2frame.remove(&victim_idx);
+ self.frame2buf.remove(&victim_frame_id);
+ self.lru.delete(victim_idx);
+
+ // Postcondition of this block: the block is not full, we have 1 slot open.
+ }
+
+ // Precondition: We are not full, which is a None element in the self.pages vec.
+
+ let target_idx = self.pages.iter().position(|x| x.is_none())? as BufferPoolId;
+
+ let frame_data = self.frame_pool.get_frame_ref(frame_idx).ok()?;
+ let new_frame = framepool::PageFrame::new_with_arc(frame_data);
+
+ self.pages[target_idx as usize] = Some(new_frame);
+ self.buf2frame.insert(target_idx, frame_idx);
+ self.frame2buf.insert(frame_idx, target_idx);
+ }
+
+ match self.frame2buf.get(&frame_idx) {
+ None => None, // this should be an assert tbh.
+ Some(buffer_id) => {
+ let b: u64 = *buffer_id;
+ self.lru.push(b);
+ self.pages[b as usize].as_ref()
+ }
+ }
+ }
+}
+
+pub struct SlabMapper<'a, T>
+where
+ T: Clone,
+{
+ slab: BufferPool<'a, T>,
+ stride: usize,
+}
+
+impl<'a, T> SlabMapper<'a, T>
+where
+ T: Clone,
+{
+ pub fn new(size: usize, pool: &'a mut dyn framepool::FramePool, stride: usize) -> Self {
+ SlabMapper {
+ slab: BufferPool::new(size, pool, bottom_evictor),
+ stride,
+ }
+ }
+
+ pub fn load(&mut self) -> Result<(), String> {
+ self.slab.ensure_allocation(0)?;
+ Ok(())
+ }
+
+ pub fn flush(&mut self, seq: Vec) -> Result<(), String> {
+ let required_allocation = seq.len().div_ceil(self.stride);
+ self.slab
+ .ensure_allocation(required_allocation as FramePoolId)?;
+
+ // Phase 1: Write to backing store (external, out of our control)
+ // If this fails, nothing has been modified yet, so we can safely return error
+ for i in 0..required_allocation {
+ let bottom = i * self.stride;
+ if bottom < seq.len() {
+ let data_arc = Arc::new(seq[bottom].clone());
+ self.slab
+ .frame_pool
+ .put_frame(i as FramePoolId, data_arc)
+ .map_err(|e| {
+ format!("Failed to write to backing store at frame {}: {}", i, e)
+ })?;
+ }
+ }
+
+ // Phase 2: Update BufferPool (under our control)
+ // If this fails after backing store writes succeeded, we have inconsistent state
+ // But per your requirement, both must succeed, so we continue trying all updates
+ let mut buffer_errors = Vec::new();
+
+ for i in 0..required_allocation {
+ let bottom = i * self.stride;
+ if bottom < seq.len()
+ && let Err(e) = self.slab.put_page(i as FramePoolId, seq[bottom].clone())
+ {
+ buffer_errors.push((i, e));
+ }
+ }
+
+ // If any buffer updates failed, report all failures
+ if !buffer_errors.is_empty() {
+ let error_msgs: Vec = buffer_errors
+ .into_iter()
+ .map(|(frame, err)| format!("Frame {}: {}", frame, err))
+ .collect();
+ return Err(format!(
+ "BufferPool updates failed: {}",
+ error_msgs.join("; ")
+ ));
+ }
+
+ Ok(())
+ }
+
+ pub fn get(&mut self, idx: usize) -> Option {
+ let page_idx = (idx / self.stride) as FramePoolId;
+ self.slab.get_page(page_idx).map(|page| page.data())
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use crate::framepool;
+ use crate::framepool::{FramePool, MemPool};
+ use crate::unique_stack;
+
+ #[test]
+ fn test_new() {
+ let mut pool = MemPool::::new();
+ let bp = BufferPool::::new(10, &mut pool, bottom_evictor);
+ assert_eq!(bp.size, 10);
+ assert_eq!(bp.pages.len(), 10);
+ assert_eq!(bp.buf2frame.len(), 0);
+ assert_eq!(bp.frame2buf.len(), 0);
+ assert_eq!(bp.lru.len(), 0);
+ }
+
+ #[test]
+ fn test_get_page_loads_from_pool() {
+ let mut mem_pool = MemPool::::new();
+ mem_pool.resize(1).unwrap();
+
+ let data_arc = Arc::new(42u8);
+ mem_pool.put_frame(0, data_arc).unwrap();
+
+ let mut bp = BufferPool::::new(10, &mut mem_pool, bottom_evictor);
+
+ // First access should load from pool
+ let page = bp.get_page(0).unwrap();
+ assert_eq!(page.data(), 42u8);
+ assert_eq!(bp.frame2buf.len(), 1);
+ assert_eq!(bp.buf2frame.len(), 1);
+ }
+
+ #[test]
+ fn test_put_page() {
+ let mut mem_pool = MemPool::::new();
+ mem_pool.resize(10).unwrap();
+
+ // Initialize with dummy data
+ for i in 0..10 {
+ let data_arc = Arc::new(i as u8);
+ mem_pool.put_frame(i, data_arc).unwrap();
+ }
+
+ let mut bp = BufferPool::::new(5, &mut mem_pool, bottom_evictor);
+
+ bp.put_page(0, 100).unwrap();
+ let page = bp.get_page(0).unwrap();
+ assert_eq!(page.data(), 100);
+ }
+
+ #[test]
+ fn test_eviction_when_full() {
+ let mut mem_pool = MemPool::::new();
+ mem_pool.resize(10).unwrap();
+
+ // Initialize with data
+ for i in 0..10 {
+ let data_arc = Arc::new(i as u8);
+ mem_pool.put_frame(i, data_arc).unwrap();
+ }
+
+ let mut bp = BufferPool::::new(3, &mut mem_pool, bottom_evictor);
+
+ // Load 3 pages (fills buffer)
+ bp.get_page(0);
+ bp.get_page(1);
+ bp.get_page(2);
+ assert_eq!(bp.frame2buf.len(), 3);
+
+ // Load 4th page should trigger eviction
+ bp.get_page(3);
+ assert_eq!(bp.frame2buf.len(), 3); // Still 3, one was evicted
+ assert!(bp.frame2buf.contains_key(&3)); // New page is loaded
+ }
+
+ #[test]
+ fn test_lru_tracking() {
+ let mut mem_pool = MemPool::::new();
+ mem_pool.resize(5).unwrap();
+
+ for i in 0..5 {
+ let data_arc = Arc::new(i as u8);
+ mem_pool.put_frame(i, data_arc).unwrap();
+ }
+
+ let mut bp = BufferPool::::new(3, &mut mem_pool, bottom_evictor);
+
+ bp.get_page(0);
+ bp.get_page(1);
+ bp.get_page(2);
+
+ // Access page 0 again, should move to top of LRU
+ bp.get_page(0);
+
+ // Load new page, should evict page 1 (least recently used)
+ bp.get_page(3);
+ assert!(!bp.frame2buf.contains_key(&1));
+ assert!(bp.frame2buf.contains_key(&0));
+ assert!(bp.frame2buf.contains_key(&2));
+ assert!(bp.frame2buf.contains_key(&3));
+ }
+
+ #[test]
+ fn test_dirty_page_flush() {
+ let mut mem_pool = MemPool::>::new();
+ mem_pool.resize(2).unwrap();
+
+ let data_arc = Arc::new(vec![1, 2, 3]);
+ mem_pool.put_frame(0, data_arc).unwrap();
+
+ let data_arc2 = Arc::new(vec![5, 6]);
+ mem_pool.put_frame(1, data_arc2).unwrap();
+
+ let mut bp = BufferPool::>::new(1, &mut mem_pool, bottom_evictor);
+
+ // Load and modify page
+ {
+ let page = bp.get_page(0).unwrap();
+ page.with_data(|v| v.push(4));
+ assert!(page.is_dirty());
+ }
+
+ // Load another page, should flush dirty page
+ bp.get_page(1);
+
+ // Reload page 0 to verify it was flushed
+ let page = bp.get_page(0).unwrap();
+ assert_eq!(page.data(), vec![1, 2, 3, 4]);
+ }
+
+ #[test]
+ fn test_sync_index() {
+ let mut mem_pool = MemPool::::new();
+ mem_pool.resize(1).unwrap();
+
+ let data_arc = Arc::new("initial".to_string());
+ mem_pool.put_frame(0, data_arc).unwrap();
+
+ let mut bp = BufferPool::::new(2, &mut mem_pool, bottom_evictor);
+
+ // Load and modify
+ let page = bp.get_page(0).unwrap();
+ page.put("modified".to_string());
+ page.set_dirty(true);
+
+ // Sync the page
+ bp.sync_index(0).unwrap();
+
+ // Verify it was written to backing storage
+ let frame_arc = mem_pool.get_frame_ref(0).unwrap();
+ assert_eq!(*frame_arc, "modified");
+ }
+
+ #[test]
+ fn test_sync_index_not_loaded() {
+ let mut mem_pool = MemPool::::new();
+ let mut bp = BufferPool::::new(2, &mut mem_pool, bottom_evictor);
+
+ // Syncing a page that's not loaded should be OK
+ let result = bp.sync_index(0);
+ assert!(result.is_ok());
+ }
+
+ #[test]
+ fn test_flush_all() {
+ let mut mem_pool = MemPool::::new();
+ mem_pool.resize(3).unwrap();
+
+ for i in 0..3 {
+ let data_arc = Arc::new((i * 10) as i32);
+ mem_pool.put_frame(i, data_arc).unwrap();
+ }
+
+ let mut bp = BufferPool::::new(3, &mut mem_pool, bottom_evictor);
+
+ // Load and modify all pages
+ for i in 0..3 {
+ let page = bp.get_page(i).unwrap();
+ page.put((i * 10 + 1) as i32);
+ page.set_dirty(true);
+ }
+
+ // Flush all
+ bp.flush_all().unwrap();
+
+ // Verify all were written
+ for i in 0..3 {
+ let frame_arc = mem_pool.get_frame_ref(i).unwrap();
+ assert_eq!(*frame_arc, (i * 10 + 1) as i32);
+ }
+ }
+
+ #[test]
+ fn test_ensure_allocation() {
+ let mut mem_pool = MemPool::::new();
+ let mut bp = BufferPool::::new(2, &mut mem_pool, bottom_evictor);
+
+ bp.ensure_allocation(5).unwrap();
+
+ // Check size through the buffer pool's frame_pool reference
+ assert_eq!(bp.frame_pool.size(), 5);
+ }
+
+ #[test]
+ fn test_get_page_beyond_size() {
+ let mut mem_pool = MemPool::::new();
+ mem_pool.resize(5).unwrap();
+
+ let mut bp = BufferPool::::new(2, &mut mem_pool, bottom_evictor);
+
+ let page = bp.get_page(10);
+ assert!(page.is_none());
+ }
+
+ #[test]
+ fn test_pinned_page_not_evicted() {
+ let mut mem_pool = MemPool::::new();
+ mem_pool.resize(5).unwrap();
+
+ for i in 0..5 {
+ let data_arc = Arc::new(i as u8);
+ mem_pool.put_frame(i, data_arc).unwrap();
+ }
+
+ let mut bp = BufferPool::::new(2, &mut mem_pool, bottom_evictor);
+
+ // Load and pin page 0
+ {
+ let page0 = bp.get_page(0).unwrap();
+ page0.pin();
+ }
+
+ // Load page 1
+ bp.get_page(1);
+
+ // Try to load page 2 - should evict page 1, not pinned page 0
+ bp.get_page(2);
+
+ assert!(bp.frame2buf.contains_key(&0)); // Pinned page still there
+ assert!(!bp.frame2buf.contains_key(&1)); // Page 1 was evicted
+ assert!(bp.frame2buf.contains_key(&2)); // New page loaded
+
+ // Unpin page 0
+ if let Some(page0) = bp.pages[0].as_ref() {
+ page0.unpin();
+ }
+ }
+
+ #[test]
+ fn test_bottom_evictor() {
+ let mut pages: Vec>> = Vec::new();
+ for _ in 0..5 {
+ pages.push(None);
+ }
+ pages[0] = Some(framepool::PageFrame::new(0));
+ pages[2] = Some(framepool::PageFrame::new(2));
+ pages[4] = Some(framepool::PageFrame::new(4));
+
+ let mut lru = unique_stack::UniqueStack::new();
+ lru.push(2); // Least recently used
+ lru.push(0);
+ lru.push(4); // Most recently used
+
+ let evicted = bottom_evictor::(&pages, &lru).unwrap();
+ assert_eq!(evicted, 2); // Should evict least recently used
+ }
+
+ #[test]
+ fn test_bottom_evictor_all_pinned() {
+ let mut pages: Vec>> = Vec::new();
+ for _ in 0..3 {
+ pages.push(None);
+ }
+
+ for (i, page) in pages.iter_mut().enumerate().take(3) {
+ let frame = framepool::PageFrame::new(i as u8);
+ frame.pin();
+ *page = Some(frame);
+ }
+
+ let mut lru = unique_stack::UniqueStack::new();
+ lru.push(0);
+ lru.push(1);
+ lru.push(2);
+
+ let result = bottom_evictor::(&pages, &lru);
+ assert!(result.is_err());
+
+ // Unpin to cleanup
+ for p in pages.iter().flatten() {
+ p.unpin();
+ }
+ }
+
+ #[test]
+ fn test_random_evictor() {
+ let mut pages: Vec>> = Vec::new();
+ for _ in 0..10 {
+ pages.push(None);
+ }
+
+ // Fill some slots
+ for i in [1, 3, 5, 7, 9] {
+ pages[i] = Some(framepool::PageFrame::new(i as u8));
+ }
+
+ let lru = unique_stack::UniqueStack::new();
+
+ let evicted = random_evictor::(&pages, &lru).unwrap();
+ assert!([1, 3, 5, 7, 9].contains(&(evicted as usize)));
+ }
+
+ #[test]
+ fn test_random_evictor_all_pinned() {
+ let mut pages: Vec>> = Vec::new();
+ for _ in 0..3 {
+ pages.push(None);
+ }
+
+ for (i, page) in pages.iter_mut().enumerate().take(3) {
+ let frame = framepool::PageFrame::new(i as u8);
+ frame.pin();
+ *page = Some(frame);
+ }
+
+ let lru = unique_stack::UniqueStack::new();
+ let result = random_evictor::(&pages, &lru);
+ assert!(result.is_err());
+
+ // Unpin to cleanup
+ for p in pages.iter().flatten() {
+ p.unpin();
+ }
+ }
+
+ #[test]
+ fn test_error_display() {
+ let err = BufferPoolErrors::NoEvictablePage;
+ assert_eq!(format!("{}", err), "no evictable pages");
+
+ let err = BufferPoolErrors::NoPageAvailable;
+ assert_eq!(format!("{}", err), "no available pages");
+ }
+
+ #[test]
+ fn test_with_diskpool() {
+ let test_dir = "/tmp/test_bufferpool_disk";
+ let _ = std::fs::remove_dir_all(test_dir);
+
+ let mut disk_pool = framepool::DiskPool::new::(test_dir);
+ >::resize(&mut disk_pool, 3).unwrap();
+
+ // Write initial data
+ for i in 0..3 {
+ let data_arc = Arc::new(format!("page_{}", i));
+ >::put_frame(
+ &mut disk_pool,
+ i,
+ data_arc,
+ )
+ .unwrap();
+ }
+
+ let mut bp = BufferPool::::new(2, &mut disk_pool, bottom_evictor);
+
+ // Test operations
+ let page = bp.get_page(0).unwrap();
+ assert_eq!(page.data(), "page_0");
+
+ bp.put_page(1, "modified_1".to_string()).unwrap();
+ bp.flush_all().unwrap();
+
+ // Verify persistence
+ let frame_arc =
+ >::get_frame_ref(&mut disk_pool, 1)
+ .unwrap();
+ assert_eq!(*frame_arc, "modified_1");
+
+ // Clean up
+ let _ = std::fs::remove_dir_all(test_dir);
+ }
+
+ #[test]
+ fn test_slab_mapper_new() {
+ let mut mem_pool = MemPool::::new();
+ let mapper = SlabMapper::new(5, &mut mem_pool, 10);
+ assert_eq!(mapper.stride, 10);
+ }
+
+ #[test]
+ fn test_slab_mapper_load() {
+ let mut mem_pool = MemPool::::new();
+ let mut mapper = SlabMapper::new(5, &mut mem_pool, 10);
+
+ let result = mapper.load();
+ assert!(result.is_ok());
+ assert_eq!(mem_pool.size(), 0); // ensure_allocation(0) doesn't resize
+ }
+
+ #[test]
+ fn test_slab_mapper_flush() {
+ let mut mem_pool = MemPool::::new();
+ let mut mapper = SlabMapper::new(5, &mut mem_pool, 3);
+
+ let data = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+ mapper.flush(data).unwrap();
+
+ // Should have allocated 4 pages (10 items / 3 stride = 4 pages)
+ assert_eq!(mem_pool.size(), 4);
+ }
+
+ #[test]
+ fn test_slab_mapper_get() {
+ let mut mem_pool = MemPool::::new();
+ let mut mapper = SlabMapper::new(5, &mut mem_pool, 3);
+
+ let data = vec![10, 20, 30, 40, 50];
+ mapper.flush(data).unwrap();
+
+ // Get items from different pages
+ let val = mapper.get(0);
+ assert_eq!(val, Some(10));
+
+ let val = mapper.get(3);
+ assert_eq!(val, Some(40));
+ }
+
+ #[test]
+ fn test_slab_mapper_with_diskpool() {
+ let test_dir = "/tmp/test_slabmapper_disk";
+ let _ = std::fs::remove_dir_all(test_dir);
+
+ let mut disk_pool = framepool::DiskPool::new::(test_dir);
+ let mut mapper = SlabMapper::new(3, &mut disk_pool, 2);
+
+ let data = vec![
+ "a".to_string(),
+ "b".to_string(),
+ "c".to_string(),
+ "d".to_string(),
+ "e".to_string(),
+ ];
+
+ mapper.flush(data).unwrap();
+
+ let val = mapper.get(0);
+ assert_eq!(val, Some("a".to_string()));
+
+ let val = mapper.get(2);
+ assert_eq!(val, Some("c".to_string()));
+
+ // Clean up
+ let _ = std::fs::remove_dir_all(test_dir);
+ }
+
+ #[test]
+ fn test_put_page_no_page_available() {
+ let mut mem_pool = MemPool::::new();
+ // Don't resize the pool, so there are no pages
+
+ let mut bp = BufferPool::::new(5, &mut mem_pool, bottom_evictor);
+
+ let result = bp.put_page(0, 42);
+ assert!(result.is_err());
+ match result {
+ Err(BufferPoolErrors::NoPageAvailable) => (),
+ _ => panic!("Expected NoPageAvailable error"),
+ }
+ }
+
+ #[test]
+ fn test_eviction_correctness_stress() {
+ // Stress test to ensure eviction logic maintains consistent state
+ let mut mem_pool = MemPool::::new();
+ mem_pool.resize(20).unwrap();
+
+ // Initialize backing storage with data
+ for i in 0..20 {
+ let data_arc = Arc::new(format!("page_{}", i));
+ mem_pool.put_frame(i, data_arc).unwrap();
+ }
+
+ let mut bp = BufferPool::::new(3, &mut mem_pool, bottom_evictor);
+
+ // Perform many operations to stress test the eviction logic
+ for round in 0..10 {
+ for i in 0..20 {
+ let page = bp.get_page(i);
+ assert!(page.is_some(), "Should be able to load page {}", i);
+
+ // Verify mapping consistency after each operation
+ assert_eq!(
+ bp.frame2buf.len(),
+ bp.buf2frame.len(),
+ "Mapping lengths should be equal in round {}, access {}",
+ round,
+ i
+ );
+ assert!(
+ bp.frame2buf.len() <= 3,
+ "Should never exceed buffer pool size"
+ );
+
+ // Verify bidirectional mapping consistency
+ for (frame_id, buf_id) in &bp.frame2buf {
+ assert_eq!(
+ bp.buf2frame[buf_id], *frame_id,
+ "Bidirectional mapping should be consistent"
+ );
+ }
+
+ for (buf_id, frame_id) in &bp.buf2frame {
+ assert_eq!(
+ bp.frame2buf[frame_id], *buf_id,
+ "Reverse mapping should be consistent"
+ );
+ }
+ }
+ }
+ }
+
+ #[test]
+ fn test_slab_mapper_transaction_safety() {
+ // Test that SlabMapper operations are atomic - either both succeed or both fail
+ let mut mem_pool = MemPool::::new();
+ let mut mapper = SlabMapper::new(3, &mut mem_pool, 2);
+
+ // Test successful case
+ let data = vec![10, 20, 30, 40, 50];
+ let result = mapper.flush(data.clone());
+ assert!(result.is_ok(), "Flush should succeed");
+
+ // Verify data was written correctly
+ for (i, expected) in data.iter().enumerate() {
+ if i % 2 == 0 {
+ // Only first element of each stride is accessible with current impl
+ let val = mapper.get(i);
+ assert_eq!(
+ val,
+ Some(*expected),
+ "Should retrieve correct value at index {}",
+ i
+ );
+ }
+ }
+
+ // Test with empty data - should handle gracefully
+ let empty_data = vec![];
+ let result = mapper.flush(empty_data);
+ assert!(result.is_ok(), "Empty flush should succeed");
+ }
+
+ #[test]
+ fn test_bufferpool_errors_display() {
+ // Test all error variants display correctly
+ let no_evict_err = BufferPoolErrors::NoEvictablePage;
+ let no_page_err = BufferPoolErrors::NoPageAvailable;
+
+ assert_eq!(format!("{}", no_evict_err), "no evictable pages");
+ assert_eq!(format!("{}", no_page_err), "no available pages");
+ }
+
+ #[test]
+ fn test_slab_mapper_get_out_of_bounds() {
+ let mut mem_pool = framepool::MemPool::new();
+ let mut mapper = SlabMapper::new(2, &mut mem_pool, 2);
+ mapper.load().unwrap();
+
+ // Add some data
+ let data = vec![10, 20, 30];
+ mapper.flush(data).unwrap();
+
+ // Try to get out of bounds index
+ assert_eq!(mapper.get(100), None);
+ assert_eq!(mapper.get(4), None);
+ }
+
+ #[test]
+ fn test_sync_index_with_clean_page() {
+ let mut mem_pool = framepool::MemPool::new();
+ mem_pool.resize(1).unwrap();
+ let data_arc = Arc::new(42u8);
+ mem_pool.put_frame(0, data_arc).unwrap();
+
+ let mut bp = BufferPool::::new(2, &mut mem_pool, bottom_evictor);
+
+ // Get a page
+ let _page = bp.get_page(0).unwrap();
+ // Don't mark it dirty
+
+ // Syncing a clean page should be a no-op
+ let result = bp.sync_index(0);
+ assert!(result.is_ok());
+ }
+
+ #[test]
+ fn test_flush_all_empty_pool() {
+ let mut mem_pool = framepool::MemPool::new();
+ let mut bp = BufferPool::::new(2, &mut mem_pool, bottom_evictor);
+
+ // Flush empty pool should succeed
+ let result = bp.flush_all();
+ assert!(result.is_ok());
+ }
+
+ #[test]
+ fn test_get_page_beyond_available() {
+ let mut mem_pool = framepool::MemPool::new();
+ let mut bp = BufferPool::::new(1, &mut mem_pool, bottom_evictor);
+
+ // Try to get a page beyond what's available
+ let result = bp.get_page(100);
+ assert!(result.is_none());
+ }
+}
diff --git a/rust/src/framepool/mod.rs b/rust/src/framepool/mod.rs
new file mode 100644
index 0000000..1fb5bb5
--- /dev/null
+++ b/rust/src/framepool/mod.rs
@@ -0,0 +1,886 @@
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+use std::fs;
+use std::path::PathBuf;
+use std::sync::{Arc, Mutex};
+
+struct InnerFrame {
+ data: Arc,
+ pins: u32,
+ dirty: bool,
+}
+
+// A frame is a container for data to be written.
+pub struct PageFrame {
+ mutex: Mutex>,
+}
+
+impl PageFrame {
+ pub fn new(data: T) -> Self {
+ PageFrame {
+ mutex: Mutex::new(InnerFrame {
+ data: Arc::new(data),
+ pins: 0,
+ dirty: false,
+ }),
+ }
+ }
+
+ pub fn new_with_arc(data: Arc) -> Self {
+ PageFrame {
+ mutex: Mutex::new(InnerFrame {
+ data,
+ pins: 0,
+ dirty: false,
+ }),
+ }
+ }
+
+ pub fn pin(&self) {
+ let mut inner = self.mutex.lock().unwrap();
+ inner.pins += 1;
+ }
+
+ pub fn unpin(&self) {
+ let mut inner = self.mutex.lock().unwrap();
+ inner.pins -= 1;
+ }
+
+ pub fn is_pinned(&self) -> bool {
+ let inner = self.mutex.lock().unwrap();
+ inner.pins > 0
+ }
+
+ pub fn is_dirty(&self) -> bool {
+ let inner = self.mutex.lock().unwrap();
+ inner.dirty
+ }
+
+ pub fn set_dirty(&self, dirty: bool) {
+ let mut inner = self.mutex.lock().unwrap();
+ inner.dirty = dirty;
+ }
+
+ pub fn data(&self) -> T
+ where
+ T: Clone,
+ {
+ let inner = self.mutex.lock().unwrap();
+ (*inner.data).clone()
+ }
+
+ pub fn put(&self, data: T) {
+ let mut inner = self.mutex.lock().unwrap();
+ inner.data = Arc::new(data);
+ }
+
+ // with_data uses copy-on-write semantics for efficient modification
+ pub fn with_data(&self, f: F) -> R
+ where
+ F: FnOnce(&mut T) -> R,
+ T: Clone,
+ {
+ let mut inner = self.mutex.lock().unwrap();
+ // Use Arc::make_mut for copy-on-write - only clones if there are other references
+ let mut_data = Arc::make_mut(&mut inner.data);
+ let result = f(mut_data);
+ inner.dirty = true;
+ result
+ }
+
+ // For read-only access (most common in read-heavy workloads) - zero-copy
+ pub fn read_data(&self, f: F) -> R
+ where
+ F: FnOnce(&T) -> R,
+ {
+ let inner = self.mutex.lock().unwrap();
+ f(&inner.data)
+ }
+
+ // Get a clone of the Arc for sharing with the backing store
+ pub fn get_data_arc(&self) -> Arc {
+ let inner = self.mutex.lock().unwrap();
+ Arc::clone(&inner.data)
+ }
+}
+
+// A FramePool is a pool of, obviously, frames of .
+// A frame can be nominally considered to be a "block" of data.
+// From a distance, it might be said that a T is really a "Vec", with an upper abstraction, a "slab",
+// simply providing an interface that is vec'y.
+pub trait FramePool
+where
+ T: Clone,
+{
+ fn get_frame_ref(&mut self, idx: u64) -> Result, String>;
+ fn put_frame(&mut self, idx: u64, data: Arc) -> Result<(), String>;
+ fn resize(&mut self, count: u64) -> Result<(), String>;
+ // internally known size of the pool.
+ fn size(&self) -> u64;
+ // assess_size retrieves the real-world data size of the pool and updates it
+ fn assess_size(&mut self) -> Result;
+}
+
+// Storage backend abstraction for different storage systems
+pub trait StorageBackend
+where
+ T: Clone,
+{
+ fn read(&mut self, key: &str) -> Result, String>;
+ fn write(&mut self, key: &str, data: Arc) -> Result<(), String>;
+ fn exists(&self, key: &str) -> bool;
+ fn delete(&mut self, key: &str) -> Result<(), String>;
+ fn list_keys(&self) -> Result, String>;
+}
+
+// File-based storage backend implementation
+pub struct FileBackend {
+ base_path: PathBuf,
+}
+
+impl FileBackend {
+ pub fn new(base_path: &str) -> Self {
+ FileBackend {
+ base_path: PathBuf::from(base_path),
+ }
+ }
+
+ fn ensure_directory(&self) -> Result<(), String> {
+ if !self.base_path.exists() {
+ fs::create_dir_all(&self.base_path)
+ .map_err(|e| format!("Failed to create directory: {}", e))?;
+ }
+ Ok(())
+ }
+
+ fn get_file_path(&self, key: &str) -> PathBuf {
+ self.base_path.join(format!("{}.json", key))
+ }
+
+ // Ergonomic helper methods that don't require explicit type annotations
+ pub fn read_data(&mut self, key: &str) -> Result, String>
+ where
+ T: Clone + for<'de> Deserialize<'de> + Serialize,
+ {
+ >::read(self, key)
+ }
+
+ pub fn write_data(&mut self, key: &str, data: Arc) -> Result<(), String>
+ where
+ T: Clone + for<'de> Deserialize<'de> + Serialize,
+ {
+ >::write(self, key, data)
+ }
+
+ pub fn data_exists(&self, key: &str) -> bool
+ where
+ T: Clone + for<'de> Deserialize<'de> + Serialize,
+ {
+ >::exists(self, key)
+ }
+
+ pub fn delete_data(&mut self, key: &str) -> Result<(), String>
+ where
+ T: Clone + for<'de> Deserialize<'de> + Serialize,
+ {
+ >::delete(self, key)
+ }
+
+ pub fn list_data_keys(&self) -> Result, String>
+ where
+ T: Clone + for<'de> Deserialize<'de> + Serialize,
+ {
+ >::list_keys(self)
+ }
+}
+
+impl StorageBackend for FileBackend
+where
+ T: Clone + for<'de> Deserialize<'de> + Serialize,
+{
+ fn read(&mut self, key: &str) -> Result, String> {
+ self.ensure_directory()?;
+ let file_path = self.get_file_path(key);
+
+ let content = fs::read_to_string(&file_path)
+ .map_err(|e| format!("Failed to read file {}: {}", file_path.display(), e))?;
+
+ let data: T = serde_json::from_str(&content)
+ .map_err(|e| format!("Failed to deserialize data: {}", e))?;
+
+ Ok(Arc::new(data))
+ }
+
+ fn write(&mut self, key: &str, data: Arc) -> Result<(), String> {
+ self.ensure_directory()?;
+ let file_path = self.get_file_path(key);
+
+ let content = serde_json::to_string_pretty(&*data)
+ .map_err(|e| format!("Failed to serialize data: {}", e))?;
+
+ fs::write(&file_path, content)
+ .map_err(|e| format!("Failed to write file {}: {}", file_path.display(), e))?;
+
+ Ok(())
+ }
+
+ fn exists(&self, key: &str) -> bool {
+ self.get_file_path(key).exists()
+ }
+
+ fn delete(&mut self, key: &str) -> Result<(), String> {
+ let file_path = self.get_file_path(key);
+ if file_path.exists() {
+ fs::remove_file(&file_path)
+ .map_err(|e| format!("Failed to delete file {}: {}", file_path.display(), e))?;
+ }
+ Ok(())
+ }
+
+ fn list_keys(&self) -> Result, String> {
+ if !self.base_path.exists() {
+ return Ok(vec![]);
+ }
+
+ let entries = fs::read_dir(&self.base_path)
+ .map_err(|e| format!("Failed to read directory: {}", e))?;
+
+ let mut keys = Vec::new();
+ for entry in entries {
+ let entry = entry.map_err(|e| format!("Failed to read directory entry: {}", e))?;
+ if let Some(filename) = entry.file_name().to_str()
+ && filename.ends_with(".json")
+ {
+ let key = filename.strip_suffix(".json").unwrap().to_string();
+ keys.push(key);
+ }
+ }
+
+ Ok(keys)
+ }
+}
+
+// Implement MemPool, a memory-only FramePool implementation
+pub struct MemPool {
+ pool: HashMap>>,
+}
+
+impl MemPool {
+ pub fn new() -> Self {
+ MemPool {
+ pool: HashMap::new(),
+ }
+ }
+}
+
+impl Default for MemPool {
+ fn default() -> Self {
+ Self::new()
+ }
+}
+
+impl FramePool for MemPool
+where
+ T: Clone,
+{
+ fn get_frame_ref(&mut self, id: u64) -> Result, String> {
+ match self.pool.get(&id) {
+ Some(Some(frame)) => Ok(Arc::clone(&frame.mutex.lock().unwrap().data)),
+ Some(None) => Err("Frame slot exists but is empty".to_string()),
+ None => Err("No such frame".to_string()),
+ }
+ }
+
+ fn put_frame(&mut self, idx: u64, data: Arc) -> Result<(), String> {
+ let frame = PageFrame {
+ mutex: Mutex::new(InnerFrame {
+ data,
+ pins: 0,
+ dirty: false,
+ }),
+ };
+ self.pool.insert(idx, Some(frame));
+ Ok(())
+ }
+
+ fn resize(&mut self, count: u64) -> Result<(), String> {
+ let old_sz = self.size();
+ // from i from 0 to count, insert a None into the pool at pageid = prior_size + i
+ for i in 0..count {
+ self.pool.insert(old_sz + i, None);
+ }
+ Ok(())
+ }
+
+ fn size(&self) -> u64 {
+ self.pool.len() as u64
+ }
+
+ fn assess_size(&mut self) -> Result {
+ Ok(self.size())
+ }
+}
+
+pub struct DiskPool {
+ initialized: bool,
+ dirname: PathBuf,
+ size: u64,
+}
+
+impl DiskPool {
+ pub fn new(dirname: &str) -> Self {
+ DiskPool {
+ initialized: false,
+ dirname: PathBuf::from(dirname),
+ size: 0,
+ }
+ }
+
+ // initialize the pool, if it hasn't been already.
+ // this will create the path
+ fn initialize(&mut self) -> Result<(), String> {
+ if self.initialized {
+ return Ok(());
+ }
+ fs::create_dir_all(&self.dirname).map_err(|_| "Error creating directory".to_string())?;
+ self.initialized = true;
+ Ok(())
+ }
+
+ fn page_path(&self, pageid: u64) -> PathBuf {
+ let path = self.dirname.clone();
+ path.join(format!("page_{}", pageid))
+ }
+}
+
+impl FramePool for DiskPool
+where
+ T: for<'de> Deserialize<'de> + Serialize + Clone,
+{
+ fn get_frame_ref(&mut self, id: u64) -> Result, String> {
+ self.initialize()?;
+
+ let result: T = fs::read_to_string(self.page_path(id))
+ .map_err(|_| "Error reading file".to_string())
+ .and_then(|s| {
+ serde_json::from_str(&s).map_err(|_| "Error deserializing".to_string())
+ })?;
+
+ Ok(Arc::new(result))
+ }
+
+ fn put_frame(&mut self, idx: u64, data: Arc) -> Result<(), String> {
+ self.initialize()?;
+
+ serde_json::to_string(&*data)
+ .map_err(|_| "Error serializing".to_string())
+ .and_then(|s| {
+ fs::write(self.page_path(idx), s)
+ .map_err(|x| format!("Error writing file: ${:?}", x))
+ })
+ }
+
+ fn resize(&mut self, count: u64) -> Result<(), String> {
+ self.initialize()?;
+ let old_sz = >::size(self);
+ // from i from 0 to count, insert a None into the pool at pageid = prior_size + i
+ for i in 0..count {
+ let path = self.page_path(old_sz + i);
+ let b = path.exists();
+ if !b {
+ match fs::write(path, "{}") {
+ Ok(_) => (),
+ Err(e) => return Err(format!("Error writing file: {:?}", e)),
+ }
+ }
+ }
+ self.size = old_sz + count;
+ Ok(())
+ }
+
+ fn size(&self) -> u64 {
+ self.size
+ }
+
+ // assess the size of the pool, by counting the number of files in the directory
+ fn assess_size(&mut self) -> Result {
+ self.initialize()?;
+
+ let paths = fs::read_dir(self.dirname.clone()).unwrap();
+ let mut count = 0;
+ for p in paths.flatten() {
+ if let Some(filename) = p.file_name().to_str()
+ && filename.starts_with("page_")
+ {
+ count += 1;
+ }
+ }
+ Ok(count)
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use std::fs;
+ use std::path::Path;
+
+ #[test]
+ fn test_page_frame_new() {
+ let frame = PageFrame::new(42);
+ assert_eq!(frame.data(), 42);
+ assert!(!frame.is_pinned());
+ assert!(!frame.is_dirty());
+ }
+
+ #[test]
+ fn test_page_frame_pin_unpin() {
+ let frame = PageFrame::new(42);
+ assert!(!frame.is_pinned());
+
+ frame.pin();
+ assert!(frame.is_pinned());
+
+ frame.pin(); // Pin twice
+ assert!(frame.is_pinned());
+
+ frame.unpin();
+ assert!(frame.is_pinned()); // Still pinned (count = 1)
+
+ frame.unpin();
+ assert!(!frame.is_pinned()); // Now unpinned
+ }
+
+ #[test]
+ fn test_page_frame_dirty_flag() {
+ let frame = PageFrame::new(42);
+ assert!(!frame.is_dirty());
+
+ frame.set_dirty(true);
+ assert!(frame.is_dirty());
+
+ frame.set_dirty(false);
+ assert!(!frame.is_dirty());
+ }
+
+ #[test]
+ fn test_page_frame_put() {
+ let frame = PageFrame::new(42);
+ assert_eq!(frame.data(), 42);
+
+ frame.put(100);
+ assert_eq!(frame.data(), 100);
+ }
+
+ #[test]
+ fn test_page_frame_with_data() {
+ let frame = PageFrame::new(vec![1, 2, 3]);
+ assert!(!frame.is_dirty());
+
+ frame.with_data(|v| {
+ v.push(4);
+ });
+
+ assert_eq!(frame.data(), vec![1, 2, 3, 4]);
+ assert!(frame.is_dirty()); // Should be marked dirty after modification
+ }
+
+ #[test]
+ fn test_mempool_new() {
+ let pool: MemPool = MemPool::new();
+ assert_eq!(pool.size(), 0);
+ }
+
+ #[test]
+ fn test_mempool_default() {
+ let pool: MemPool = MemPool::default();
+ assert_eq!(pool.size(), 0);
+ }
+
+ #[test]
+ fn test_mempool_read_write() {
+ let mut pool = MemPool::new();
+ let data_arc = Arc::new(vec![1, 2, 3]);
+ pool.put_frame(0, Arc::clone(&data_arc)).unwrap();
+
+ let retrieved_arc = pool.get_frame_ref(0).unwrap();
+ assert_eq!(*retrieved_arc, vec![1, 2, 3]);
+ }
+
+ #[test]
+ fn test_mempool_read_nonexistent() {
+ let mut pool: MemPool = MemPool::new();
+ let result = pool.get_frame_ref(0);
+ match result {
+ Err(e) => assert_eq!(e, "No such frame"),
+ Ok(_) => panic!("Expected error"),
+ }
+ }
+
+ #[test]
+ fn test_mempool_resize() {
+ let mut pool: MemPool = MemPool::new();
+ assert_eq!(pool.size(), 0);
+
+ pool.resize(5).unwrap();
+ assert_eq!(pool.size(), 5);
+
+ pool.resize(3).unwrap();
+ assert_eq!(pool.size(), 8); // 5 + 3
+ }
+
+ #[test]
+ fn test_mempool_assess_size() {
+ let mut pool: MemPool = MemPool::new();
+ pool.resize(10).unwrap();
+
+ let size = pool.assess_size().unwrap();
+ assert_eq!(size, 10);
+ }
+
+ #[test]
+ fn test_mempool_overwrite() {
+ let mut pool = MemPool::new();
+
+ let data1 = Arc::new(100);
+ pool.put_frame(0, data1).unwrap();
+
+ let data2 = Arc::new(200);
+ pool.put_frame(0, data2).unwrap();
+
+ let retrieved_arc = pool.get_frame_ref(0).unwrap();
+ assert_eq!(*retrieved_arc, 200);
+ }
+
+ #[test]
+ fn test_diskpool_new() {
+ let pool = DiskPool::new::("/tmp/test_diskpool_new");
+ assert_eq!(pool.size, 0);
+
+ // Clean up
+ let _ = fs::remove_dir_all("/tmp/test_diskpool_new");
+ }
+
+ #[test]
+ fn test_diskpool_read_write() {
+ let test_dir = "/tmp/test_diskpool_rw";
+ let _ = fs::remove_dir_all(test_dir);
+
+ let mut pool = DiskPool::new::>(test_dir);
+ let data_arc = Arc::new(vec![1, 2, 3]);
+ >>::put_frame(&mut pool, 0, data_arc).unwrap();
+
+ let retrieved_arc = >>::get_frame_ref(&mut pool, 0).unwrap();
+ assert_eq!(*retrieved_arc, vec![1, 2, 3]);
+
+ // Clean up
+ let _ = fs::remove_dir_all(test_dir);
+ }
+
+ #[test]
+ fn test_diskpool_read_nonexistent() {
+ let test_dir = "/tmp/test_diskpool_nonexist";
+ let _ = fs::remove_dir_all(test_dir);
+
+ let mut pool = DiskPool::new::(test_dir);
+ >::resize(&mut pool, 1).unwrap(); // Create directory
+
+ let result = >::get_frame_ref(&mut pool, 5);
+ assert!(result.is_err());
+
+ // Clean up
+ let _ = fs::remove_dir_all(test_dir);
+ }
+
+ #[test]
+ fn test_diskpool_resize() {
+ let test_dir = "/tmp/test_diskpool_resize";
+ let _ = fs::remove_dir_all(test_dir);
+
+ let mut pool = DiskPool::new::(test_dir);
+ assert_eq!(pool.size, 0);
+
+ >::resize(&mut pool, 3).unwrap();
+ assert_eq!(pool.size, 3);
+
+ // Check files were created
+ assert!(Path::new(&format!("{}/page_0", test_dir)).exists());
+ assert!(Path::new(&format!("{}/page_1", test_dir)).exists());
+ assert!(Path::new(&format!("{}/page_2", test_dir)).exists());
+
+ >::resize(&mut pool, 2).unwrap();
+ assert_eq!(pool.size, 5); // 3 + 2
+
+ // Clean up
+ let _ = fs::remove_dir_all(test_dir);
+ }
+
+ #[test]
+ fn test_diskpool_assess_size() {
+ let test_dir = "/tmp/test_diskpool_assess";
+ let _ = fs::remove_dir_all(test_dir);
+
+ let mut pool = DiskPool::new::(test_dir);
+ >::resize(&mut pool, 5).unwrap();
+
+ let size = >::assess_size(&mut pool).unwrap();
+ assert_eq!(size, 5);
+
+ // Manually create another page file
+ fs::write(format!("{}/page_10", test_dir), "{}").unwrap();
+
+ let size = >::assess_size(&mut pool).unwrap();
+ assert_eq!(size, 6); // Should count the manually created file
+
+ // Clean up
+ let _ = fs::remove_dir_all(test_dir);
+ }
+
+ #[test]
+ fn test_diskpool_page_path() {
+ let pool = DiskPool::new::("/tmp/x");
+ let path = pool.page_path(0);
+ assert_eq!(path, PathBuf::from("/tmp/x/page_0"));
+
+ let path = pool.page_path(42);
+ assert_eq!(path, PathBuf::from("/tmp/x/page_42"));
+ }
+
+ #[test]
+ fn test_diskpool_persistence() {
+ let test_dir = "/tmp/test_diskpool_persist";
+ let _ = fs::remove_dir_all(test_dir);
+
+ // Write data
+ {
+ let mut pool = DiskPool::new::(test_dir);
+ let data_arc = Arc::new("Hello, World!".to_string());
+ >::put_frame(&mut pool, 0, data_arc).unwrap();
+ }
+
+ // Read data in new pool instance
+ {
+ let mut pool = DiskPool::new::(test_dir);
+ let retrieved_arc =
+ >::get_frame_ref(&mut pool, 0).unwrap();
+ assert_eq!(*retrieved_arc, "Hello, World!");
+ }
+
+ // Clean up
+ let _ = fs::remove_dir_all(test_dir);
+ }
+
+ #[test]
+ fn test_page_frame_thread_safety() {
+ use std::sync::Arc;
+ use std::thread;
+
+ let frame = Arc::new(PageFrame::new(0));
+ let mut handles = vec![];
+
+ for i in 0..10 {
+ let frame_clone = Arc::clone(&frame);
+ let handle = thread::spawn(move || {
+ frame_clone.pin();
+ frame_clone.put(i);
+ frame_clone.unpin();
+ });
+ handles.push(handle);
+ }
+
+ for handle in handles {
+ handle.join().unwrap();
+ }
+
+ // Frame should not be pinned after all threads finish
+ assert!(!frame.is_pinned());
+ }
+
+ #[test]
+ fn test_storage_backend_file_operations() {
+ let test_dir = "/tmp/test_storage_backend";
+ let _ = fs::remove_dir_all(test_dir);
+
+ let mut backend = FileBackend::new(test_dir);
+
+ // Test write operation
+ let data = vec![1, 2, 3, 4, 5];
+ let data_arc = Arc::new(data.clone());
+ backend.write_data("test_key", data_arc).unwrap();
+
+ // Test exists
+ assert!(backend.data_exists::>("test_key"));
+ assert!(!backend.data_exists::>("nonexistent_key"));
+
+ // Test read operation
+ let read_arc: Arc> = backend.read_data("test_key").unwrap();
+ assert_eq!(*read_arc, data);
+
+ // Test list_keys
+ let keys = backend.list_data_keys::>().unwrap();
+ assert_eq!(keys, vec!["test_key"]);
+
+ // Test delete operation
+ backend.delete_data::>("test_key").unwrap();
+ assert!(!backend.data_exists::>("test_key"));
+
+ let keys_after_delete = backend.list_data_keys::>().unwrap();
+ assert!(keys_after_delete.is_empty());
+
+ // Clean up
+ let _ = fs::remove_dir_all(test_dir);
+ }
+
+ #[test]
+ fn test_storage_backend_multiple_files() {
+ let test_dir = "/tmp/test_storage_multi";
+ let _ = fs::remove_dir_all(test_dir);
+
+ let mut backend = FileBackend::new(test_dir);
+
+ // Write multiple files
+ for i in 0..5 {
+ let data = format!("data_{}", i);
+ let data_arc = Arc::new(data);
+ backend.write_data(&format!("key_{}", i), data_arc).unwrap();
+ }
+
+ // Test list_keys returns all keys
+ let mut keys = backend.list_data_keys::().unwrap();
+ keys.sort();
+ let expected_keys: Vec = (0..5).map(|i| format!("key_{}", i)).collect();
+ assert_eq!(keys, expected_keys);
+
+ // Test reading all files
+ for i in 0..5 {
+ let data_arc: Arc = backend.read_data(&format!("key_{}", i)).unwrap();
+ assert_eq!(*data_arc, format!("data_{}", i));
+ }
+
+ // Clean up
+ let _ = fs::remove_dir_all(test_dir);
+ }
+
+ #[test]
+ fn test_storage_backend_read_nonexistent() {
+ let test_dir = "/tmp/test_storage_nonexist";
+ let _ = fs::remove_dir_all(test_dir);
+
+ let mut backend = FileBackend::new(test_dir);
+
+ let result: Result, String> = backend.read_data("nonexistent_key");
+ assert!(result.is_err());
+
+ // Clean up
+ let _ = fs::remove_dir_all(test_dir);
+ }
+
+ #[test]
+ fn test_storage_backend_delete_nonexistent() {
+ let test_dir = "/tmp/test_storage_delete_nonexist";
+ let _ = fs::remove_dir_all(test_dir);
+
+ let mut backend = FileBackend::new(test_dir);
+
+ // Deleting nonexistent file should not error
+ let result = backend.delete_data::("nonexistent_key");
+ assert!(result.is_ok());
+
+ // Clean up
+ let _ = fs::remove_dir_all(test_dir);
+ }
+
+ #[test]
+ fn test_storage_backend_empty_directory() {
+ let test_dir = "/tmp/test_storage_empty";
+ let _ = fs::remove_dir_all(test_dir);
+
+ let backend = FileBackend::new(test_dir);
+
+ // list_keys on nonexistent directory should return empty vec
+ let keys = backend.list_data_keys::().unwrap();
+ assert!(keys.is_empty());
+
+ // exists on nonexistent directory should return false
+ assert!(!backend.data_exists::("any_key"));
+
+ // Clean up not needed as directory was never created
+ }
+
+ #[test]
+ fn test_page_frame_read_data() {
+ let frame = PageFrame::new(vec![1, 2, 3, 4]);
+
+ let result = frame.read_data(|data| data.iter().sum::());
+
+ assert_eq!(result, 10);
+ assert!(!frame.is_dirty()); // read_data should not mark as dirty
+ }
+
+ #[test]
+ fn test_page_frame_copy_on_write() {
+ let original_data = vec![1, 2, 3];
+ let frame = PageFrame::new(original_data.clone());
+
+ // Get Arc reference to track sharing
+ let arc_before = frame.get_data_arc();
+ assert_eq!(Arc::strong_count(&arc_before), 2); // frame + our reference
+
+ // Modify with with_data - should trigger copy-on-write
+ frame.with_data(|data| {
+ data.push(4);
+ });
+
+ // Original arc should still have the old data (copy-on-write worked)
+ assert_eq!(*arc_before, vec![1, 2, 3]);
+
+ // Frame should have the new data
+ assert_eq!(frame.data(), vec![1, 2, 3, 4]);
+ assert!(frame.is_dirty()); // Should be marked dirty after modification
+ }
+
+ #[test]
+ fn test_page_frame_new_with_arc() {
+ let data = vec![10, 20, 30];
+ let data_arc = Arc::new(data.clone());
+ let frame = PageFrame::new_with_arc(Arc::clone(&data_arc));
+
+ assert_eq!(frame.data(), data);
+ assert!(!frame.is_dirty());
+ assert!(!frame.is_pinned());
+
+ // Both the original arc and the frame should reference the same data
+ assert_eq!(Arc::strong_count(&data_arc), 2);
+ }
+
+ #[test]
+ fn test_diskpool_size_access() {
+ let temp_dir = "/tmp/test_diskpool_size";
+ let _ = fs::remove_dir_all(temp_dir);
+
+ let pool = DiskPool::new::(temp_dir);
+ // Test size method - we can access it through the struct field
+ assert_eq!(pool.size, 0);
+
+ // Clean up
+ let _ = fs::remove_dir_all(temp_dir);
+ }
+
+ #[test]
+ fn test_filebackend_get_file_path() {
+ let test_dir = "/tmp/test_filebackend_path";
+ let backend = FileBackend::new(test_dir);
+
+ // Test get_file_path method
+ let path = backend.get_file_path("test_key");
+ let expected = format!("{}/test_key.json", test_dir);
+ assert_eq!(path.to_str().unwrap(), expected);
+ }
+
+ #[test]
+ fn test_page_frame_get_data_arc() {
+ let frame = PageFrame::new(vec![42, 43, 44]);
+ let arc = frame.get_data_arc();
+ assert_eq!(*arc, vec![42, 43, 44]);
+ }
+}
diff --git a/rust/src/lib.rs b/rust/src/lib.rs
new file mode 100644
index 0000000..878ab18
--- /dev/null
+++ b/rust/src/lib.rs
@@ -0,0 +1,132 @@
+//! # BufferPool - High-Performance Memory Management with Cache Eviction
+//!
+//! A Rust implementation of a buffer pool system with pluggable eviction strategies,
+//! supporting both in-memory and persistent storage backends.
+//!
+//! ## Features
+//!
+//! - **Flexible Storage Backends**: Memory-based (`MemPool`) and disk-based (`DiskPool`) frame pools
+//! - **Pluggable Eviction Strategies**: Bottom eviction and random eviction algorithms
+//! - **Copy-on-Write Semantics**: Efficient data sharing with Arc-based memory management
+//! - **Thread Safety**: Safe concurrent access with proper synchronization
+//! - **Comprehensive Testing**: Integration tests with forced cache evictions and benchmarking
+//!
+//! ## Basic Usage
+//!
+//! ```rust
+//! use std::sync::Arc;
+//! use bufferpool::bufferpool::BufferPool;
+//! use bufferpool::framepool::{MemPool, FramePool};
+//!
+//! // Create a memory-based frame pool
+//! let mut frame_pool = MemPool::new();
+//! frame_pool.resize(100).unwrap(); // Allocate space for 100 items
+//!
+//! // Initialize with some data
+//! for i in 0..10 {
+//! let data = Arc::new(format!("Item {}", i));
+//! frame_pool.put_frame(i, data).unwrap();
+//! }
+//!
+//! // Create a buffer pool with 3 slots using bottom eviction strategy
+//! let mut buffer_pool = BufferPool::new(
+//! 3,
+//! &mut frame_pool,
+//! bufferpool::bufferpool::bottom_evictor
+//! );
+//!
+//! // Access pages - first 3 will be cached, 4th will cause eviction
+//! for i in 0..5 {
+//! if let Some(page) = buffer_pool.get_page(i) {
+//! println!("Page {}: {}", i, page.data());
+//! }
+//! }
+//!
+//! // Modify data with copy-on-write semantics
+//! if let Some(page) = buffer_pool.get_page(0) {
+//! page.with_data(|data: &mut String| {
+//! *data = "Modified Item 0".to_string();
+//! });
+//! // Mark as dirty and sync back to frame pool
+//! buffer_pool.sync_index(0).unwrap();
+//! }
+//! ```
+//!
+//! ## Advanced Usage with Disk Storage
+//!
+//! ```rust
+//! use std::sync::Arc;
+//! use bufferpool::bufferpool::BufferPool;
+//! use bufferpool::framepool::{DiskPool, FramePool};
+//!
+//! // Create a disk-based frame pool
+//! let mut disk_pool = DiskPool::new::("/tmp/buffer_test");
+//! >::resize(&mut disk_pool, 1000).unwrap();
+//!
+//! // Store data that will persist to disk
+//! for i in 0..50 {
+//! let data = Arc::new(format!("Persistent data {}", i));
+//! >::put_frame(&mut disk_pool, i, data).unwrap();
+//! }
+//!
+//! // Create buffer pool with random eviction strategy
+//! let mut buffer_pool: BufferPool = BufferPool::new(
+//! 5,
+//! &mut disk_pool,
+//! bufferpool::bufferpool::random_evictor
+//! );
+//!
+//! // Access patterns that exceed buffer capacity
+//! let access_pattern = [0, 10, 20, 30, 40, 5, 15, 25, 35, 45];
+//! for &idx in &access_pattern {
+//! if let Some(page) = buffer_pool.get_page(idx) {
+//! println!("Accessed: {}", page.data());
+//! }
+//! }
+//!
+//! // Flush all dirty pages back to storage
+//! buffer_pool.flush_all().unwrap();
+//! ```
+//!
+//! ## Eviction Strategies
+//!
+//! The buffer pool supports different eviction strategies:
+//!
+//! - **`bottom_evictor`**: Evicts the page at the bottom of the internal stack
+//! - **`random_evictor`**: Randomly selects a page for eviction
+//!
+//! Custom eviction strategies can be implemented by providing a function with the signature:
+//! ```rust
+//! fn custom_evictor(
+//! slots: &[Option>],
+//! lru_stack: &bufferpool::unique_stack::UniqueStack
+//! ) -> Result
+//! where T: Clone
+//! {
+//! // Your eviction logic here
+//! Ok(0) // Return index of slot to evict
+//! }
+//! ```
+//!
+//! ## Performance Analysis
+//!
+//! The crate includes comprehensive benchmarking tools:
+//!
+//! ```bash
+//! # Run standalone performance analysis
+//! cargo run --bin benchmark_runner
+//!
+//! # Run criterion benchmarks
+//! cargo bench
+//! ```
+//!
+//! ## Integration Testing
+//!
+//! Run multi-file integration tests that exceed buffer capacity:
+//! ```bash
+//! cargo test --test multi_file_integration_test
+//! ```
+
+pub mod bufferpool;
+pub mod framepool;
+pub mod unique_stack;
diff --git a/rust/src/unique_stack/mod.rs b/rust/src/unique_stack/mod.rs
new file mode 100644
index 0000000..20fb6d2
--- /dev/null
+++ b/rust/src/unique_stack/mod.rs
@@ -0,0 +1,208 @@
+use std::collections::HashSet;
+use std::hash::Hash;
+
+pub struct UniqueStack {
+ order: Vec,
+ unique: HashSet,
+}
+
+impl UniqueStack
+where
+ T: Eq + PartialEq + Hash + Clone,
+{
+ pub fn new() -> UniqueStack {
+ UniqueStack {
+ order: Vec::new(),
+ unique: HashSet::new(),
+ }
+ }
+
+ pub fn push(&mut self, item: T) {
+ if self.unique.contains(&item) {
+ let idx = self.order.iter().position(|x| *x == item).unwrap();
+ self.order.remove(idx);
+ }
+ let i = item.clone();
+ self.unique.insert(i);
+ self.order.push(item);
+ }
+
+ pub fn delete(&mut self, item: T) {
+ if self.unique.contains(&item) {
+ let idx = self.order.iter().position(|x| *x == item).unwrap();
+ self.order.remove(idx);
+ self.unique.remove(&item);
+ }
+ }
+
+ pub fn pop(&mut self) -> Option {
+ let item = self.order.pop();
+ if let Some(x) = item.clone() {
+ self.unique.remove(&x);
+ }
+ item
+ }
+
+ // Returns the most recently pushed item, or None if the stack is empty.
+ pub fn top(&self) -> Option {
+ self.order.last().map(|x| (*x).clone())
+ }
+
+ // Returns the least recently pushed item, or None if the stack is empty.
+ pub fn bottom(&self) -> Option {
+ self.order.first().map(|x| (*x).clone())
+ }
+
+ // Returns a copy of the items, in order.
+ pub fn order(&self) -> Vec {
+ self.order.iter().map(|x| (*x).clone()).collect()
+ }
+
+ pub fn contains(&self, item: &T) -> bool {
+ self.unique.contains(item)
+ }
+
+ pub fn len(&self) -> u64 {
+ self.order.len() as u64
+ }
+
+ pub fn is_empty(&self) -> bool {
+ self.order.is_empty()
+ }
+}
+
+impl Default for UniqueStack
+where
+ T: Eq + PartialEq + Hash + Clone,
+{
+ fn default() -> Self {
+ Self::new()
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn test_push() {
+ let mut stack = UniqueStack::new();
+ stack.push(1);
+ stack.push(2);
+ stack.push(3);
+ assert_eq!(stack.len(), 3);
+ assert_eq!(stack.top(), Some(3));
+ assert_eq!(stack.bottom(), Some(1));
+ }
+
+ #[test]
+ fn test_pop() {
+ let mut stack = UniqueStack::new();
+ stack.push(1);
+ stack.push(2);
+ stack.push(3);
+ assert_eq!(stack.pop(), Some(3));
+ assert_eq!(stack.len(), 2);
+ assert_eq!(stack.top(), Some(2));
+ assert_eq!(stack.bottom(), Some(1));
+ }
+
+ #[test]
+ fn test_contains() {
+ let mut stack = UniqueStack::new();
+ stack.push(1);
+ stack.push(2);
+ stack.push(3);
+ assert!(stack.contains(&1));
+ assert!(stack.contains(&2));
+ assert!(stack.contains(&3));
+ assert!(!stack.contains(&4));
+ }
+
+ #[test]
+ fn test_push_duplicate() {
+ let mut stack = UniqueStack::new();
+ stack.push(1);
+ stack.push(2);
+ stack.push(3);
+ stack.push(2);
+ assert_eq!(stack.len(), 3);
+ assert_eq!(stack.top(), Some(2));
+ assert_eq!(stack.bottom(), Some(1));
+ }
+
+ #[test]
+ fn test_pop_duplicate() {
+ let mut stack = UniqueStack::new();
+ stack.push(1);
+ stack.push(2);
+ stack.push(3);
+ stack.push(2);
+ assert_eq!(stack.pop(), Some(2));
+ assert_eq!(stack.len(), 2);
+ assert_eq!(stack.top(), Some(3));
+ assert_eq!(stack.bottom(), Some(1));
+ }
+
+ #[test]
+ fn test_delete() {
+ let mut stack = UniqueStack::new();
+ stack.push(1);
+ stack.push(2);
+ stack.push(3);
+ stack.delete(2);
+ assert_eq!(stack.len(), 2);
+ assert_eq!(stack.top(), Some(3));
+ assert_eq!(stack.bottom(), Some(1));
+ stack.delete(3);
+ assert!(!stack.contains(&3));
+ assert_eq!(stack.len(), 1);
+ stack.delete(1);
+ assert!(!stack.contains(&1));
+ assert_eq!(stack.len(), 0);
+ }
+
+ #[test]
+ fn test_is_empty() {
+ let mut stack = UniqueStack::new();
+ assert!(stack.is_empty());
+ assert_eq!(stack.len(), 0);
+
+ stack.push(1);
+ assert!(!stack.is_empty());
+ assert_eq!(stack.len(), 1);
+
+ stack.pop();
+ assert!(stack.is_empty());
+ assert_eq!(stack.len(), 0);
+ }
+
+ #[test]
+ fn test_default() {
+ let stack: UniqueStack = UniqueStack::default();
+ assert!(stack.is_empty());
+ assert_eq!(stack.len(), 0);
+ }
+
+ #[test]
+ fn test_delete_nonexistent() {
+ let mut stack = UniqueStack::new();
+ stack.push(1);
+ stack.push(2);
+
+ // Deleting non-existent element should not change the stack
+ stack.delete(99);
+ assert_eq!(stack.len(), 2);
+ assert!(stack.contains(&1));
+ assert!(stack.contains(&2));
+ }
+
+ #[test]
+ fn test_pop_empty() {
+ let mut stack = UniqueStack::::new();
+ assert_eq!(stack.pop(), None);
+ assert_eq!(stack.top(), None);
+ assert_eq!(stack.bottom(), None);
+ assert!(stack.is_empty());
+ }
+}
diff --git a/rust/tests/integration_test.rs b/rust/tests/integration_test.rs
new file mode 100644
index 0000000..72e7685
--- /dev/null
+++ b/rust/tests/integration_test.rs
@@ -0,0 +1,6 @@
+use bufferpool::unique_stack;
+
+#[test]
+fn test_add() {
+ let _us = unique_stack::UniqueStack::::new();
+}
diff --git a/rust/tests/multi_file_integration_test.rs b/rust/tests/multi_file_integration_test.rs
new file mode 100644
index 0000000..d5d5210
--- /dev/null
+++ b/rust/tests/multi_file_integration_test.rs
@@ -0,0 +1,468 @@
+use bufferpool::bufferpool;
+use bufferpool::framepool::{self, FramePool};
+use bufferpool::unique_stack;
+use std::fs;
+use std::sync::Arc;
+
+/// Integration tests for multi-file scenarios with cache evictions
+/// Tests heterogeneous file handling with more files than buffer pool slots
+
+#[test]
+fn test_multi_file_cache_eviction_stress() {
+ let test_dir = "/tmp/multi_file_integration_test";
+ let _ = fs::remove_dir_all(test_dir);
+
+ // Create DiskPool with many files (more than we'll have buffer slots)
+ let mut disk_pool = framepool::DiskPool::new::(test_dir);
+
+ // Create 10 different files with different data types (represented as strings)
+ let file_data = [
+ "user_profile_1.json",
+ "transaction_2023.csv",
+ "config_settings.toml",
+ "log_entries.txt",
+ "image_metadata.xml",
+ "database_schema.sql",
+ "api_responses.json",
+ "user_sessions.log",
+ "error_reports.txt",
+ "performance_metrics.csv",
+ ];
+
+ // Step 1: Initialize disk storage with all files first
+ >::resize(&mut disk_pool, file_data.len() as u64)
+ .unwrap();
+ for (i, filename) in file_data.iter().enumerate() {
+ let data_arc = Arc::new(filename.to_string());
+ >::put_frame(&mut disk_pool, i as u64, data_arc)
+ .unwrap();
+ }
+
+ // Create small buffer pool (3 slots) to force evictions
+ let mut buffer_pool: bufferpool::BufferPool =
+ bufferpool::BufferPool::new(3, &mut disk_pool, bufferpool::bottom_evictor);
+
+ // Step 2: Access files sequentially - this will force evictions after slot 3
+ let mut accessed_files = Vec::new();
+ for (i, expected_filename) in file_data.iter().enumerate() {
+ let page = buffer_pool.get_page(i as u64);
+ assert!(page.is_some(), "Should be able to access file {}", i);
+
+ if let Some(p) = page {
+ let data: String = p.data();
+ accessed_files.push(data.clone());
+ assert_eq!(data, *expected_filename, "File content should match");
+ }
+ }
+
+ // Verify all files were accessed correctly
+ assert_eq!(accessed_files.len(), file_data.len());
+ for (i, accessed) in accessed_files.iter().enumerate() {
+ assert_eq!(accessed, &file_data[i]);
+ }
+
+ // Step 3: Random access pattern to test eviction and reload
+ let access_pattern = [0, 5, 2, 8, 1, 9, 3, 7, 4, 6];
+ for &file_idx in &access_pattern {
+ let page = buffer_pool.get_page(file_idx as u64);
+ assert!(
+ page.is_some(),
+ "Should be able to access file {} randomly",
+ file_idx
+ );
+
+ if let Some(p) = page {
+ assert_eq!(p.data(), file_data[file_idx]);
+ }
+ }
+
+ // Clean up
+ let _ = fs::remove_dir_all(test_dir);
+}
+
+#[test]
+fn test_heterogeneous_data_with_memory_pool() {
+ // Test with MemPool since it implements FramePool properly
+ let mut mem_pool = framepool::MemPool::new();
+
+ // Create different types of data simulating real-world scenarios
+ let datasets = [
+ "User database records",
+ "Transaction log entries",
+ "Configuration settings",
+ "Error log messages",
+ "Session token data",
+ "API response cache",
+ "File metadata index",
+ "Performance metrics",
+ ];
+
+ // Initialize memory pool with data first
+ mem_pool.resize(datasets.len() as u64).unwrap();
+ for (i, data) in datasets.iter().enumerate() {
+ let data_arc = Arc::new(data.to_string());
+ mem_pool.put_frame(i as u64, data_arc).unwrap();
+ }
+
+ // Create small buffer pool (2 slots) to force aggressive eviction
+ let mut buffer_pool: bufferpool::BufferPool =
+ bufferpool::BufferPool::new(2, &mut mem_pool, bufferpool::random_evictor);
+
+ // Test cross-dataset access patterns that force evictions
+ let access_patterns = vec![0, 3, 1, 5, 2, 7, 4, 6, 0, 3];
+
+ for &idx in &access_patterns {
+ let page = buffer_pool.get_page(idx);
+ assert!(page.is_some(), "Should retrieve data at index {}", idx);
+ assert_eq!(page.unwrap().data(), datasets[idx as usize]);
+ }
+}
+
+#[test]
+fn test_concurrent_file_operations_with_evictions() {
+ let test_dir = "/tmp/concurrent_operations_test";
+ let _ = fs::remove_dir_all(test_dir);
+
+ // Simulate a document management system with different file types
+ let file_categories = vec![
+ (
+ "documents",
+ vec!["doc1.pdf", "doc2.docx", "doc3.txt", "doc4.md"],
+ ),
+ ("images", vec!["img1.jpg", "img2.png", "img3.gif"]),
+ ("videos", vec!["vid1.mp4", "vid2.avi"]),
+ (
+ "archives",
+ vec!["archive1.zip", "archive2.tar.gz", "archive3.rar"],
+ ),
+ ("configs", vec!["app.json", "db.conf", "server.ini"]),
+ ];
+
+ let mut disk_pool = framepool::DiskPool::new::(test_dir);
+
+ // Calculate total files and initialize all files first
+ let total_files: usize = file_categories.iter().map(|(_, files)| files.len()).sum();
+ >::resize(&mut disk_pool, total_files as u64).unwrap();
+
+ let mut file_index = 0;
+ let mut all_files = Vec::new();
+ for (category, files) in &file_categories {
+ for filename in files {
+ let full_name = format!("{}_{}", category, filename);
+ all_files.push(full_name.clone());
+ let data_arc = Arc::new(full_name);
+ >::put_frame(
+ &mut disk_pool,
+ file_index,
+ data_arc,
+ )
+ .unwrap();
+ file_index += 1;
+ }
+ }
+
+ // Use very small buffer (2 slots) to maximize eviction pressure
+ let mut buffer_pool: bufferpool::BufferPool =
+ bufferpool::BufferPool::new(2, &mut disk_pool, bufferpool::bottom_evictor);
+
+ // Simulate realistic access patterns:
+ // 1. Sequential scan of documents
+ for i in 0..4 {
+ let page = buffer_pool.get_page(i);
+ assert!(page.is_some());
+ assert!(page.unwrap().data().starts_with("documents_"));
+ }
+
+ // 2. Jump to images (forces eviction)
+ for i in 4..7 {
+ let page = buffer_pool.get_page(i);
+ assert!(page.is_some());
+ assert!(page.unwrap().data().starts_with("images_"));
+ }
+
+ // 3. Back to documents (forces reload from disk)
+ let page = buffer_pool.get_page(0);
+ assert!(page.is_some());
+ assert_eq!(page.unwrap().data(), "documents_doc1.pdf");
+
+ // 4. Mixed access pattern across all categories
+ let mixed_pattern = [0, 10, 5, 15, 2, 12, 8, 3, 14, 6];
+ for &idx in &mixed_pattern {
+ if idx < total_files {
+ let page = buffer_pool.get_page(idx as u64);
+ assert!(page.is_some(), "Should access file at index {}", idx);
+
+ // Verify content matches expected pattern
+ let data = page.unwrap().data();
+ assert_eq!(data, all_files[idx]);
+ }
+ }
+
+ // 5. Test modification and flush operations under pressure
+ if let Some(page) = buffer_pool.get_page(0) {
+ page.with_data(|data: &mut String| {
+ *data = "documents_doc1_modified.pdf".to_string();
+ });
+ // Force sync back to disk
+ buffer_pool.sync_index(0).unwrap();
+ }
+
+ // Verify modification persisted after eviction and reload
+ for _ in 0..5 {
+ buffer_pool.get_page(10); // Force eviction of page 0
+ }
+
+ if let Some(page) = buffer_pool.get_page(0) {
+ assert_eq!(page.data(), "documents_doc1_modified.pdf");
+ }
+
+ // Clean up
+ let _ = fs::remove_dir_all(test_dir);
+}
+
+#[test]
+fn test_massive_file_dataset_with_lru_eviction() {
+ let test_dir = "/tmp/massive_dataset_test";
+ let _ = fs::remove_dir_all(test_dir);
+
+ // Create a large dataset (50 files) with tiny buffer (3 slots)
+ const NUM_FILES: usize = 50;
+ const BUFFER_SIZE: usize = 3;
+
+ let mut disk_pool = framepool::DiskPool::new::(test_dir);
+
+ // Initialize large dataset first
+ >::resize(&mut disk_pool, NUM_FILES as u64).unwrap();
+ for i in 0..NUM_FILES {
+ let data = format!("file_{:03}_data_content", i);
+ let data_arc = Arc::new(data);
+ >::put_frame(&mut disk_pool, i as u64, data_arc)
+ .unwrap();
+ }
+
+ let mut buffer_pool: bufferpool::BufferPool =
+ bufferpool::BufferPool::new(BUFFER_SIZE, &mut disk_pool, bufferpool::bottom_evictor);
+
+ // Test 1: Sequential access through entire dataset
+ for i in 0..NUM_FILES {
+ let page = buffer_pool.get_page(i as u64);
+ assert!(page.is_some(), "Should access file {}", i);
+ let expected = format!("file_{:03}_data_content", i);
+ assert_eq!(page.unwrap().data(), expected);
+ }
+
+ // Test 2: Working set larger than buffer - repeated access to subset
+ let working_set = [5, 15, 25, 35, 45]; // 5 files > 3 buffer slots
+ for _ in 0..3 {
+ for &file_idx in &working_set {
+ let page = buffer_pool.get_page(file_idx);
+ assert!(page.is_some());
+ let expected = format!("file_{:03}_data_content", file_idx);
+ assert_eq!(page.unwrap().data(), expected);
+ }
+ }
+
+ // Test 3: Stress test with random access pattern
+ use std::collections::HashMap;
+ let mut access_count = HashMap::new();
+ let random_pattern = [
+ 12, 3, 47, 8, 23, 41, 7, 29, 15, 38, 2, 44, 19, 33, 6, 49, 11, 26, 1, 42, 18, 35, 9, 24,
+ 46, 13, 31, 4, 39, 17,
+ ];
+
+ for &file_idx in &random_pattern {
+ *access_count.entry(file_idx).or_insert(0) += 1;
+ let page = buffer_pool.get_page(file_idx);
+ assert!(page.is_some(), "Random access to file {} failed", file_idx);
+ let expected = format!("file_{:03}_data_content", file_idx);
+ assert_eq!(page.unwrap().data(), expected);
+ }
+
+ // Test 4: Verify cache efficiency by accessing recently used files
+ let recent_files = [46, 13, 31]; // Last few from random pattern
+ for &file_idx in &recent_files {
+ let page = buffer_pool.get_page(file_idx);
+ assert!(page.is_some());
+ let expected = format!("file_{:03}_data_content", file_idx);
+ assert_eq!(page.unwrap().data(), expected);
+ }
+
+ // Clean up
+ let _ = fs::remove_dir_all(test_dir);
+}
+
+#[test]
+fn test_mixed_read_write_operations_with_evictions() {
+ let test_dir = "/tmp/mixed_operations_test";
+ let _ = fs::remove_dir_all(test_dir);
+
+ // Simulate database-like workload with reads and writes
+ let mut disk_pool = framepool::DiskPool::new::(test_dir);
+
+ const NUM_TABLES: usize = 12;
+ >::resize(&mut disk_pool, NUM_TABLES as u64).unwrap();
+
+ // Initialize "database tables" first
+ let table_names = [
+ "users",
+ "orders",
+ "products",
+ "inventory",
+ "payments",
+ "shipping",
+ "reviews",
+ "categories",
+ "suppliers",
+ "employees",
+ "customers",
+ "logs",
+ ];
+
+ for (i, table_name) in table_names.iter().enumerate() {
+ let initial_data = format!("{}_initial_data", table_name);
+ let data_arc = Arc::new(initial_data);
+ >::put_frame(&mut disk_pool, i as u64, data_arc)
+ .unwrap();
+ }
+
+ let mut buffer_pool: bufferpool::BufferPool