Split benched.rs into benched/ subdirectory with separate backend files

Reorganized src/benched.rs into:
- src/benched/mod.rs - Benched trait definition with documentation
- src/benched/doublets_benched.rs - Doublets storage implementations
- src/benched/psql_benched.rs - PostgreSQL storage implementations

This follows the same pattern used in Neo4jVSDoublets for clear separation
between backend implementations.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: konard

rust/src/benched.rs

@@ -0,0 +1,84 @@
+//! # Doublets Backend Implementations
+//!
+//! This module contains [`Benched`] trait implementations for all Doublets
+//! storage variants.
+//!
+//! ## Storage Backends
+//!
+//! | Backend                          | Description                    |
+//! |----------------------------------|--------------------------------|
+//! | `unit::Store<T, FileMapped<_>>`  | File-mapped unit storage       |
+//! | `unit::Store<T, Alloc<_>>`       | In-memory unit storage         |
+//! | `split::Store<T, FileMapped<_>>` | File-mapped split storage      |
+//! | `split::Store<T, Alloc<_>>`      | In-memory split storage        |
+//!
+//! ## Cleanup Strategy
+//!
+//! Each backend's `unfork()` implementation calls `delete_all()` to clean up
+//! all links created during the benchmark iteration.
+
+use crate::{map_file, Result};
+use doublets::{
+    data::LinkType,
+    mem::{Alloc, FileMapped},
+    split::{self, DataPart, IndexPart},
+    unit::{self, LinkPart},
+    Doublets,
+};
+use std::alloc::Global;
+
+use super::Benched;
+
+/// Benched implementation for file-mapped unit storage.
+impl<T: LinkType> Benched for unit::Store<T, FileMapped<LinkPart<T>>> {
+    type Builder<'a> = &'a str;
+
+    fn setup(builder: Self::Builder<'_>) -> Result<Self> {
+        Self::new(map_file(builder)?).map_err(Into::into)
+    }
+
+    unsafe fn unfork(&mut self) {
+        let _ = self.delete_all();
+    }
+}
+
+/// Benched implementation for in-memory unit storage.
+impl<T: LinkType> Benched for unit::Store<T, Alloc<LinkPart<T>, Global>> {
+    type Builder<'a> = ();
+
+    fn setup(_: Self::Builder<'_>) -> Result<Self> {
+        Self::new(Alloc::new(Global)).map_err(Into::into)
+    }
+
+    unsafe fn unfork(&mut self) {
+        let _ = self.delete_all();
+    }
+}
+
+/// Benched implementation for file-mapped split storage.
+impl<T: LinkType> Benched for split::Store<T, FileMapped<DataPart<T>>, FileMapped<IndexPart<T>>> {
+    type Builder<'a> = (&'a str, &'a str);
+
+    fn setup((data, index): Self::Builder<'_>) -> Result<Self> {
+        Self::new(map_file(data)?, map_file(index)?).map_err(Into::into)
+    }
+
+    unsafe fn unfork(&mut self) {
+        let _ = self.delete_all();
+    }
+}
+
+/// Benched implementation for in-memory split storage.
+impl<T: LinkType> Benched
+    for split::Store<T, Alloc<DataPart<T>, Global>, Alloc<IndexPart<T>, Global>>
+{
+    type Builder<'a> = ();
+
+    fn setup(_: Self::Builder<'_>) -> Result<Self> {
+        Self::new(Alloc::new(Global), Alloc::new(Global)).map_err(Into::into)
+    }
+
+    unsafe fn unfork(&mut self) {
+        let _ = self.delete_all();
+    }
+}

rust/src/benched/doublets_benched.rs

@@ -0,0 +1,44 @@
+//! # Benchmark Lifecycle Management
+//!
+//! This module defines the [`Benched`] trait that provides setup/teardown lifecycle
+//! for benchmark iterations. Both PostgreSQL and Doublets storage backends implement
+//! this trait to enable fair benchmarking.
+//!
+//! ## Module Structure
+//!
+//! The implementations are split into separate files for clear comparison:
+//!
+//! - **[`doublets_benched`]** - Doublets storage backend implementations
+//! - **[`psql_benched`]** - PostgreSQL storage backend implementations
+
+mod doublets_benched;
+mod psql_benched;
+
+use crate::Fork;
+
+/// Trait for types that can be benchmarked.
+///
+/// Provides the setup/teardown lifecycle for benchmark iterations:
+/// - [`Benched::setup`] - Initialize the storage backend
+/// - [`Benched::fork`] - Create an isolated environment for a single iteration
+/// - [`Benched::unfork`] - Clean up after the iteration
+pub trait Benched: Sized {
+    /// Builder parameter type for constructing this storage.
+    type Builder<'params>;
+
+    /// Set up a new storage backend for benchmarking.
+    fn setup<'a>(builder: Self::Builder<'a>) -> crate::Result<Self>;
+
+    /// Create a fork for a single benchmark iteration.
+    ///
+    /// This allows each iteration to run in isolation without affecting others.
+    fn fork(&mut self) -> Fork<Self> {
+        Fork(self)
+    }
+
+    /// Clean up after a benchmark iteration.
+    ///
+    /// # Safety
+    /// This method may perform unsafe operations like clearing all data.
+    unsafe fn unfork(&mut self);
+}

rust/src/benched/mod.rs

@@ -0,0 +1,73 @@
+//! # PostgreSQL Backend Implementations
+//!
+//! This module contains [`Benched`] trait implementations for PostgreSQL
+//! storage variants.
+//!
+//! ## Storage Backends
+//!
+//! | Backend                    | Description                         |
+//! |----------------------------|-------------------------------------|
+//! | `Exclusive<Client<T>>`     | Direct SQL execution (no transaction) |
+//! | `Exclusive<Transaction<T>>`| SQL execution within transaction    |
+//!
+//! ## Table Management
+//!
+//! Each backend's lifecycle manages a `links` table:
+//! - `fork()` calls `CREATE TABLE` to set up the table
+//! - `unfork()` calls `DROP TABLE` to clean up
+//!
+//! ## SQL Schema
+//!
+//! The `links` table has the following structure:
+//! ```sql
+//! CREATE TABLE links (
+//!     id BIGINT PRIMARY KEY,
+//!     source BIGINT NOT NULL,
+//!     target BIGINT NOT NULL
+//! )
+//! ```
+
+use crate::{Client, Exclusive, Fork, Result, Sql, Transaction};
+use doublets::data::LinkType;
+
+use super::Benched;
+
+/// Benched implementation for PostgreSQL client (non-transactional).
+impl<T: LinkType> Benched for Exclusive<Client<T>> {
+    type Builder<'a> = ();
+
+    fn setup(_: Self::Builder<'_>) -> Result<Self> {
+        // Safety: Exclusive wrapper ensures single-threaded access
+        unsafe { Ok(Exclusive::new(crate::connect()?)) }
+    }
+
+    fn fork(&mut self) -> Fork<Self> {
+        let _ = self.create_table();
+        Fork(self)
+    }
+
+    unsafe fn unfork(&mut self) {
+        let _ = self.drop_table();
+    }
+}
+
+/// Benched implementation for PostgreSQL transaction.
+impl<'a, T: LinkType> Benched for Exclusive<Transaction<'a, T>> {
+    type Builder<'b> = &'a mut Client<T>;
+
+    fn setup(builder: Self::Builder<'_>) -> Result<Self> {
+        let mut transaction = builder.transaction()?;
+        transaction.create_table()?;
+        // Safety: Exclusive wrapper ensures single-threaded access
+        unsafe { Ok(Exclusive::new(transaction)) }
+    }
+
+    fn fork(&mut self) -> Fork<Self> {
+        let _ = self.create_table();
+        Fork(self)
+    }
+
+    unsafe fn unfork(&mut self) {
+        let _ = self.drop_table();
+    }
+}