SYMBOL INDEX (566 symbols across 34 files)

FILE: examples/bench.rs
  type Db (line 11) | type Db = SledDb<1024>;
  constant N_WRITES_PER_THREAD (line 13) | const N_WRITES_PER_THREAD: u32 = 4 * 1024 * 1024;
  constant MAX_CONCURRENCY (line 14) | const MAX_CONCURRENCY: u32 = 4;
  constant CONCURRENCY (line 15) | const CONCURRENCY: &[usize] = &[/*1, 2, 4,*/ MAX_CONCURRENCY as _];
  constant BYTES_PER_ITEM (line 16) | const BYTES_PER_ITEM: u32 = 8;
  type Databench (line 18) | trait Databench: Clone + Send {
    constant NAME (line 20) | const NAME: &'static str;
    constant PATH (line 21) | const PATH: &'static str;
    method open (line 22) | fn open() -> Self;
    method remove_generic (line 23) | fn remove_generic(&self, key: &[u8]);
    method insert_generic (line 24) | fn insert_generic(&self, key: &[u8], value: &[u8]);
    method get_generic (line 25) | fn get_generic(&self, key: &[u8]) -> Option<Self::READ>;
    method flush_generic (line 26) | fn flush_generic(&self);
    method print_stats (line 27) | fn print_stats(&self);
    type READ (line 31) | type READ = sled::InlineArray;
    constant NAME (line 33) | const NAME: &'static str = "sled 1.0.0-alpha";
    constant PATH (line 34) | const PATH: &'static str = "timing_test.sled-new";
    method open (line 36) | fn open() -> Self {
    method insert_generic (line 49) | fn insert_generic(&self, key: &[u8], value: &[u8]) {
    method remove_generic (line 52) | fn remove_generic(&self, key: &[u8]) {
    method get_generic (line 55) | fn get_generic(&self, key: &[u8]) -> Option<Self::READ> {
    method flush_generic (line 58) | fn flush_generic(&self) {
    method print_stats (line 61) | fn print_stats(&self) {
  function allocated (line 221) | fn allocated() -> usize {
  function freed (line 229) | fn freed() -> usize {
  function resident (line 237) | fn resident() -> usize {
  function inserts (line 245) | fn inserts<D: Databench>(store: &D) -> Vec<InsertStats> {
  function removes (line 295) | fn removes<D: Databench>(store: &D) -> Vec<RemoveStats> {
  function gets (line 345) | fn gets<D: Databench>(store: &D) -> Vec<GetStats> {
  function execute_lockstep_concurrent (line 383) | fn execute_lockstep_concurrent<
  type InsertStats (line 421) | struct InsertStats {
  type GetStats (line 427) | struct GetStats {
  type RemoveStats (line 433) | struct RemoveStats {
  type Stats (line 440) | struct Stats {
    method print_report (line 452) | fn print_report(&self) {
  function bench (line 489) | fn bench<D: Databench>() -> Stats {
  function du (line 518) | fn du(path: &Path) -> io::Result<u64> {
  function main (line 533) | fn main() {

FILE: fuzz/fuzz_targets/fuzz_model.rs
  type Db (line 11) | type Db = SledDb<3>;
  constant KEYSPACE (line 13) | const KEYSPACE: u64 = 128;
  type Op (line 16) | enum Op {
    method arbitrary (line 33) | fn arbitrary(
  function keygen (line 25) | fn keygen(

FILE: scripts/execution_explorer.py
  class UnreachableBreakpoint (line 60) | class UnreachableBreakpoint(gdb.Breakpoint):
  class DoneBreakpoint (line 64) | class DoneBreakpoint(gdb.Breakpoint):
  class InterestingBreakpoint (line 68) | class InterestingBreakpoint(gdb.Breakpoint):
  class DeterministicExecutor (line 72) | class DeterministicExecutor:
    method __init__ (line 73) | def __init__(self, seed=None):
    method reseed (line 92) | def reseed(self):
    method restart (line 98) | def restart(self):
    method rendezvous_callback (line 118) | def rendezvous_callback(self, event):
    method run (line 128) | def run(self):
    method run_schedule (line 136) | def run_schedule(self):
    method pick (line 152) | def pick(self):
    method scheduler_callback (line 164) | def scheduler_callback(self, event):
    method runnable_threads (line 183) | def runnable_threads(self):
    method exit_callback (line 197) | def exit_callback(self, event):

FILE: src/alloc.rs
  type ShredAllocator (line 21) | struct ShredAllocator;
    method alloc (line 24) | unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
    method dealloc (line 31) | unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) {
  function allocated (line 49) | fn allocated() -> usize {
  function freed (line 53) | fn freed() -> usize {
  function resident (line 57) | fn resident() -> usize {
  type CountingAllocator (line 62) | struct CountingAllocator;
    method alloc (line 65) | unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
    method dealloc (line 74) | unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) {

FILE: src/block_checker.rs
  type LocationMap (line 19) | type LocationMap = BTreeMap<u64, &'static Location<'static>>;
  type BlockChecker (line 22) | pub(crate) struct BlockChecker {
    method report (line 27) | fn report(&self, last_top_10: LocationMap) -> LocationMap {
    method check_in (line 43) | fn check_in(&self, location: &'static Location) -> BlockGuard {
    method check_out (line 50) | fn check_out(&self, id: u64) {
  type BlockGuard (line 56) | pub(crate) struct BlockGuard {
  method drop (line 61) | fn drop(&mut self) {
  function track_blocks (line 67) | pub(crate) fn track_blocks() -> BlockGuard {

FILE: src/config.rs
  type Config (line 23) | pub struct Config {
    method new (line 64) | pub fn new() -> Config {
    method tmp (line 71) | pub fn tmp() -> io::Result<Config> {
    method path (line 82) | pub fn path<P: AsRef<Path>>(mut self, path: P) -> Config {
    method open (line 96) | pub fn open<const LEAF_FANOUT: usize>(
  method default (line 48) | fn default() -> Config {

FILE: src/db.rs
  type Db (line 35) | pub struct Db<const LEAF_FANOUT: usize = 1024> {
  type Target (line 47) | type Target = Tree<LEAF_FANOUT>;
  function deref (line 48) | fn deref(&self) -> &Tree<LEAF_FANOUT> {
  type Item (line 54) | type Item = io::Result<(InlineArray, InlineArray)>;
  type IntoIter (line 55) | type IntoIter = crate::Iter<LEAF_FANOUT>;
  method into_iter (line 57) | fn into_iter(self) -> Self::IntoIter {
  function fmt (line 63) | fn fmt(&self, w: &mut fmt::Formatter<'_>) -> fmt::Result {
  function flusher (line 82) | fn flusher<const LEAF_FANOUT: usize>(
  method drop (line 155) | fn drop(&mut self) {
  function validate (line 169) | fn validate(&self) -> io::Result<()> {
  function stats (line 217) | pub fn stats(&self) -> Stats {
  function size_on_disk (line 221) | pub fn size_on_disk(&self) -> io::Result<u64> {
  function was_recovered (line 248) | pub fn was_recovered(&self) -> bool {
  function open_with_config (line 252) | pub fn open_with_config(config: &Config) -> io::Result<Db<LEAF_FANOUT>> {
  function export (line 406) | pub fn export(
  function import (line 481) | pub fn import(
  function contains_tree (line 516) | pub fn contains_tree<V: AsRef<[u8]>>(&self, name: V) -> io::Result<bool> {
  function drop_tree (line 520) | pub fn drop_tree<V: AsRef<[u8]>>(&self, name: V) -> io::Result<bool> {
  function open_tree (line 545) | pub fn open_tree<V: AsRef<[u8]>>(
  type CollectionType (line 597) | type CollectionType = Vec<u8>;
  type CollectionName (line 598) | type CollectionName = Vec<u8>;

FILE: src/event_verifier.rs
  type State (line 7) | pub(crate) enum State {
    method can_transition_within_epoch_to (line 18) | fn can_transition_within_epoch_to(&self, next: State) -> bool {
    method needs_flush (line 45) | fn needs_flush(&self) -> bool {
  type EventVerifier (line 56) | pub(crate) struct EventVerifier {
    method mark (line 78) | pub(crate) fn mark(
    method dirty_epochs (line 129) | fn dirty_epochs(&self, object_id: ObjectId) -> Vec<FlushEpoch> {
    method print_debug_history_for_object (line 146) | pub(crate) fn print_debug_history_for_object(&self, object_id: ObjectI...
  method drop (line 62) | fn drop(&mut self) {

FILE: src/flush_epoch.rs
  constant SEAL_BIT (line 5) | const SEAL_BIT: u64 = 1 << 63;
  constant SEAL_MASK (line 6) | const SEAL_MASK: u64 = u64::MAX - SEAL_BIT;
  constant MIN_EPOCH (line 7) | const MIN_EPOCH: u64 = 2;
  type FlushEpoch (line 21) | pub struct FlushEpoch(NonZeroU64);
    constant MIN (line 24) | pub const MIN: FlushEpoch = FlushEpoch(NonZeroU64::MIN);
    constant MAX (line 26) | pub const MAX: FlushEpoch = FlushEpoch(NonZeroU64::MAX);
    method increment (line 28) | pub fn increment(&self) -> FlushEpoch {
    method get (line 32) | pub fn get(&self) -> u64 {
    constant MIN (line 38) | const MIN: FlushEpoch = FlushEpoch::MIN;
  type FlushInvariants (line 42) | pub(crate) struct FlushInvariants {
    method mark_flushed_epoch (line 57) | pub(crate) fn mark_flushed_epoch(&self, epoch: FlushEpoch) {
    method mark_flushing_epoch (line 63) | pub(crate) fn mark_flushing_epoch(&self, epoch: FlushEpoch) {
  method default (line 48) | fn default() -> FlushInvariants {
  type Completion (line 71) | pub(crate) struct Completion {
    method epoch (line 78) | pub fn epoch(&self) -> FlushEpoch {
    method new (line 82) | pub fn new(epoch: FlushEpoch) -> Completion {
    method wait_for_complete (line 86) | pub fn wait_for_complete(self) -> FlushEpoch {
    method mark_complete (line 95) | pub fn mark_complete(self) {
    method mark_complete_inner (line 99) | fn mark_complete_inner(&self, previously_sealed: bool) {
    method is_complete (line 114) | pub fn is_complete(&self) -> bool {
  type FlushEpochGuard (line 119) | pub struct FlushEpochGuard<'a> {
  method drop (line 125) | fn drop(&mut self) {
  function epoch (line 137) | pub fn epoch(&self) -> FlushEpoch {
  type EpochTracker (line 143) | pub(crate) struct EpochTracker {
  type FlushEpochTracker (line 151) | pub(crate) struct FlushEpochTracker {
    method roll_epoch_forward (line 207) | pub fn roll_epoch_forward(&self) -> (Completion, Completion, Completio...
    method check_in (line 255) | pub fn check_in<'a>(&self) -> FlushEpochGuard<'a> {
    method manually_advance_epoch (line 278) | pub fn manually_advance_epoch(&self) {
    method current_flush_epoch (line 282) | pub fn current_flush_epoch(&self) -> FlushEpoch {
  type FlushEpochInner (line 157) | pub(crate) struct FlushEpochInner {
  method drop (line 164) | fn drop(&mut self) {
  method default (line 177) | fn default() -> FlushEpochTracker {
  function flush_epoch_basic_functionality (line 290) | fn flush_epoch_basic_functionality() {
  function concurrent_flush_epoch_burn_in_inner (line 311) | fn concurrent_flush_epoch_burn_in_inner() {
  function concurrent_flush_epoch_burn_in (line 380) | fn concurrent_flush_epoch_burn_in() {

FILE: src/heap.rs
  constant WARN (line 20) | const WARN: &str = "DO_NOT_PUT_YOUR_FILES_HERE";
  constant N_SLABS (line 21) | pub(crate) const N_SLABS: usize = 78;
  constant FILE_TARGET_FILL_RATIO (line 22) | const FILE_TARGET_FILL_RATIO: u64 = 80;
  constant FILE_RESIZE_MARGIN (line 23) | const FILE_RESIZE_MARGIN: u64 = 115;
  constant SLAB_SIZES (line 25) | const SLAB_SIZES: [usize; N_SLABS] = [
  type WriteBatchStats (line 107) | pub struct WriteBatchStats {
    method max (line 130) | pub(crate) fn max(&self, other: &WriteBatchStats) -> WriteBatchStats {
    method sum (line 156) | pub(crate) fn sum(&self, other: &WriteBatchStats) -> WriteBatchStats {
  type HeapStats (line 122) | pub struct HeapStats {
  function overhead_for_size (line 184) | const fn overhead_for_size(size: usize) -> usize {
  function slab_for_size (line 200) | fn slab_for_size(size: usize) -> u8 {
  type ObjectRecovery (line 213) | pub struct ObjectRecovery {
  type HeapRecovery (line 219) | pub struct HeapRecovery {
  type PersistentSettings (line 225) | enum PersistentSettings {
    method verify_or_store (line 231) | fn verify_or_store<P: AsRef<Path>>(
    method deserialize (line 251) | fn deserialize(buf: &[u8]) -> io::Result<PersistentSettings> {
    method check_compatibility (line 281) | fn check_compatibility(
    method serialize (line 307) | fn serialize(&self) -> Vec<u8> {
  type SlabAddress (line 338) | pub(crate) struct SlabAddress {
    method from_slab_slot (line 344) | pub(crate) fn from_slab_slot(slab: u8, slot: u64) -> SlabAddress {
    method slab (line 356) | pub const fn slab(&self) -> u8 {
    method slot (line 361) | pub const fn slot(&self) -> u64 {
    method from (line 376) | fn from(i: NonZeroU64) -> SlabAddress {
  method from (line 387) | fn from(sa: SlabAddress) -> NonZeroU64 {
  function read_exact_at (line 409) | pub(super) fn read_exact_at(
  function write_all_at (line 430) | pub(super) fn write_all_at(
  function read_exact_at (line 445) | pub(super) fn read_exact_at(
  function write_all_at (line 472) | pub(super) fn write_all_at(
  type Slab (line 498) | struct Slab {
    method sync (line 505) | fn sync(&self) -> io::Result<()> {
    method read (line 509) | fn read(
    method write (line 565) | fn write(&self, slot: u64, mut data: Vec<u8>) -> io::Result<()> {
  function set_error (line 603) | fn set_error(
  type Update (line 630) | pub enum Update {
    method object_id (line 645) | pub(crate) fn object_id(&self) -> ObjectId {
  type UpdateMetadata (line 654) | pub enum UpdateMetadata {
    method object_id (line 668) | pub fn object_id(&self) -> ObjectId {
  type WriteBatchStatTracker (line 677) | struct WriteBatchStatTracker {
  type Heap (line 683) | pub struct Heap {
    method fmt (line 697) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method recover (line 706) | pub fn recover(
    method get_global_error_arc (line 821) | pub fn get_global_error_arc(
    method check_error (line 827) | fn check_error(&self) -> io::Result<()> {
    method set_error (line 839) | fn set_error(&self, error: &io::Error) {
    method manually_advance_epoch (line 843) | pub fn manually_advance_epoch(&self) {
    method stats (line 847) | pub fn stats(&self) -> HeapStats {
    method read (line 861) | pub fn read(&self, object_id: ObjectId) -> Option<io::Result<Vec<u8>>> {
    method write_batch (line 881) | pub fn write_batch(
    method heap_object_id_pin (line 1106) | pub fn heap_object_id_pin(&self) -> ebr::Guard<'_, DeferredFree, 16, 1...
    method allocate_object_id (line 1110) | pub fn allocate_object_id(&self) -> ObjectId {
    method objects_to_defrag (line 1114) | pub(crate) fn objects_to_defrag(&self) -> FnvHashSet<ObjectId> {

FILE: src/id_allocator.rs
  type FreeSetAndTip (line 10) | struct FreeSetAndTip {
  type Allocator (line 16) | pub struct Allocator {
    method fragmentation_cutoff (line 33) | pub fn fragmentation_cutoff(
    method from_allocated (line 69) | pub fn from_allocated(allocated: &FnvHashSet<u64>) -> Allocator {
    method max_allocated (line 92) | pub fn max_allocated(&self) -> Option<u64> {
    method allocate (line 102) | pub fn allocate(&self) -> u64 {
    method free (line 122) | pub fn free(&self, id: u64) {
    method counters (line 139) | pub fn counters(&self) -> (u64, u64) {
  function compact (line 147) | fn compact(free: &mut FreeSetAndTip) {
  type DeferredFree (line 156) | pub struct DeferredFree {
  method drop (line 162) | fn drop(&mut self) {

FILE: src/leaf.rs
  type Leaf (line 4) | pub(crate) struct Leaf<const LEAF_FANOUT: usize> {
  function empty (line 22) | pub(crate) fn empty() -> Leaf<LEAF_FANOUT> {
  function is_empty (line 39) | pub(crate) const fn is_empty(&self) -> bool {
  function set_dirty_epoch (line 43) | pub(crate) fn set_dirty_epoch(&mut self, epoch: FlushEpoch) {
  function prefix (line 54) | fn prefix(&self) -> &[u8] {
  function get (line 59) | pub(crate) fn get(&self, key: &[u8]) -> Option<&InlineArray> {
  function insert (line 66) | pub(crate) fn insert(
  function remove (line 77) | pub(crate) fn remove(&mut self, key: &[u8]) -> Option<InlineArray> {
  function merge_from (line 85) | pub(crate) fn merge_from(&mut self, other: &mut Self) {
  function iter (line 138) | pub(crate) fn iter(
  function serialize (line 150) | pub(crate) fn serialize(&self, zstd_compression_level: i32) -> Vec<u8> {
  function deserialize (line 164) | pub(crate) fn deserialize(
  function set_in_memory_size (line 177) | fn set_in_memory_size(&mut self) {
  function split_if_full (line 184) | pub(crate) fn split_if_full(
  function shorten_keys_after_split (line 280) | pub(crate) fn shorten_keys_after_split(&mut self, old_prefix_len: usize) {

FILE: src/lib.rs
  function debug_delay (line 153) | fn debug_delay() {
  constant NAME_MAPPING_COLLECTION_ID (line 172) | const NAME_MAPPING_COLLECTION_ID: CollectionId = CollectionId(0);
  constant DEFAULT_COLLECTION_ID (line 173) | const DEFAULT_COLLECTION_ID: CollectionId = CollectionId(1);
  constant INDEX_FANOUT (line 174) | const INDEX_FANOUT: usize = 64;
  constant EBR_LOCAL_GC_BUFFER_SIZE (line 175) | const EBR_LOCAL_GC_BUFFER_SIZE: usize = 128;
  function open (line 209) | pub fn open<P: AsRef<std::path::Path>>(path: P) -> std::io::Result<Db> {
  type Stats (line 214) | pub struct Stats {
  type CompareAndSwapResult (line 226) | pub type CompareAndSwapResult = std::io::Result<
  type Index (line 230) | type Index<const LEAF_FANOUT: usize> = concurrent_map::ConcurrentMap<
  type CompareAndSwapError (line 239) | pub struct CompareAndSwapError {
    method fmt (line 256) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  type CompareAndSwapSuccess (line 248) | pub struct CompareAndSwapSuccess {
  type ObjectId (line 275) | pub struct ObjectId(NonZeroU64);
    method new (line 278) | fn new(from: u64) -> Option<ObjectId> {
    type Target (line 284) | type Target = u64;
    method deref (line 286) | fn deref(&self) -> &u64 {
    constant MIN (line 301) | const MIN: ObjectId = ObjectId(NonZeroU64::MIN);
  type CollectionId (line 316) | pub struct CollectionId(u64);
    constant MIN (line 319) | const MIN: CollectionId = CollectionId(u64::MIN);
  type CacheBox (line 323) | struct CacheBox<const LEAF_FANOUT: usize> {
  type LogValue (line 331) | struct LogValue {
  type Object (line 337) | pub struct Object<const LEAF_FANOUT: usize> {
  method eq (line 345) | fn eq(&self, other: &Self) -> bool {
  type ShutdownDropper (line 353) | struct ShutdownDropper<const LEAF_FANOUT: usize> {
  method drop (line 361) | fn drop(&mut self) {
  function map_bound (line 386) | fn map_bound<T, U, F: FnOnce(T) -> U>(bound: Bound<T>, f: F) -> Bound<U> {
  function _assert_public_types_send_sync (line 394) | const fn _assert_public_types_send_sync() {

FILE: src/metadata_store.rs
  constant WARN (line 22) | const WARN: &str = "DO_NOT_PUT_YOUR_FILES_HERE";
  constant TMP_SUFFIX (line 23) | const TMP_SUFFIX: &str = ".tmp";
  constant LOG_PREFIX (line 24) | const LOG_PREFIX: &str = "log";
  constant SNAPSHOT_PREFIX (line 25) | const SNAPSHOT_PREFIX: &str = "snapshot";
  constant ZSTD_LEVEL (line 27) | const ZSTD_LEVEL: i32 = 3;
  type MetadataStore (line 35) | pub struct MetadataStore {
    method get_global_error_arc (line 233) | pub fn get_global_error_arc(
    method shutdown_inner (line 239) | fn shutdown_inner(&mut self) {
    method check_error (line 252) | fn check_error(&self) -> io::Result<()> {
    method set_error (line 256) | fn set_error(&self, error: &io::Error) {
    method recover (line 262) | pub fn recover<P: AsRef<Path>>(
    method recover_inner (line 345) | fn recover_inner<P: AsRef<Path>>(
    method write_batch (line 365) | pub fn write_batch(&self, batch: &[UpdateMetadata]) -> io::Result<u64> {
  method drop (line 41) | fn drop(&mut self) {
  type MetadataRecovery (line 51) | struct MetadataRecovery {
  type LogAndStats (line 57) | struct LogAndStats {
  type WorkerMessage (line 63) | enum WorkerMessage {
  function get_compactions (line 68) | fn get_compactions(
  function worker (line 103) | fn worker(
  function set_error (line 164) | fn set_error(
  function check_error (line 190) | fn check_error(
  type Inner (line 205) | struct Inner {
  method drop (line 215) | fn drop(&mut self) {
  function serialize_batch (line 430) | fn serialize_batch(batch: &[UpdateMetadata]) -> Vec<u8> {
  function read_frame (line 497) | fn read_frame(
  function read_log (line 621) | fn read_log(
  function read_snapshot (line 644) | fn read_snapshot(
  function log_path (line 665) | fn log_path(directory_path: &Path, id: u64) -> PathBuf {
  function snapshot_path (line 669) | fn snapshot_path(directory_path: &Path, id: u64, temporary: bool) -> Pat...
  function enumerate_logs_and_snapshot (line 678) | fn enumerate_logs_and_snapshot(
  function read_snapshot_and_apply_logs (line 753) | fn read_snapshot_and_apply_logs(

FILE: src/object_cache.rs
  type CacheStats (line 17) | pub struct CacheStats {
  type FlushStats (line 33) | pub struct FlushStats {
    method sum (line 45) | pub fn sum(&self, other: &FlushStats) -> FlushStats {
    method max (line 69) | pub fn max(&self, other: &FlushStats) -> FlushStats {
  type Dirty (line 94) | pub enum Dirty<const LEAF_FANOUT: usize> {
  function is_final_state (line 114) | pub fn is_final_state(&self) -> bool {
  type FlushStatTracker (line 124) | struct FlushStatTracker {
  type ReadStatTracker (line 131) | pub(crate) struct ReadStatTracker {
  type ObjectCache (line 141) | pub struct ObjectCache<const LEAF_FANOUT: usize> {
  function recover (line 171) | pub fn recover(
  function is_clean (line 229) | pub fn is_clean(&self) -> bool {
  function read (line 233) | pub fn read(&self, object_id: ObjectId) -> Option<io::Result<Vec<u8>>> {
  function stats (line 241) | pub fn stats(&self) -> CacheStats {
  function check_error (line 278) | pub fn check_error(&self) -> io::Result<()> {
  function set_error (line 290) | pub fn set_error(&self, error: &io::Error) {
  function allocate_default_node (line 314) | pub fn allocate_default_node(
  function allocate_object_id (line 335) | pub fn allocate_object_id(
  function current_flush_epoch (line 354) | pub fn current_flush_epoch(&self) -> FlushEpoch {
  function check_into_flush_epoch (line 358) | pub fn check_into_flush_epoch(&self) -> FlushEpochGuard {
  function install_dirty (line 362) | pub fn install_dirty(
  function mark_access_and_evict (line 397) | pub fn mark_access_and_evict(
  function heap_object_id_pin (line 469) | pub fn heap_object_id_pin(&self) -> ebr::Guard<'_, DeferredFree, 16, 16> {
  function flush (line 473) | pub fn flush(&self) -> io::Result<FlushStats> {
  function initialize (line 911) | fn initialize<const LEAF_FANOUT: usize>(

FILE: src/object_location_mapper.rs
  type AllocatorStats (line 14) | pub struct AllocatorStats {
  type SlabTenancy (line 22) | struct SlabTenancy {
    method objects_to_defrag (line 29) | fn objects_to_defrag(
  type ObjectLocationMapper (line 59) | pub(crate) struct ObjectLocationMapper {
    method new (line 67) | pub(crate) fn new(
    method get_max_allocated_per_slab (line 118) | pub(crate) fn get_max_allocated_per_slab(&self) -> Vec<(usize, u64)> {
    method stats (line 130) | pub(crate) fn stats(&self) -> AllocatorStats {
    method clone_object_id_allocator_arc (line 152) | pub(crate) fn clone_object_id_allocator_arc(&self) -> Arc<Allocator> {
    method allocate_object_id (line 156) | pub(crate) fn allocate_object_id(&self) -> ObjectId {
    method clone_slab_allocator_arc (line 167) | pub(crate) fn clone_slab_allocator_arc(
    method allocate_slab_slot (line 174) | pub(crate) fn allocate_slab_slot(&self, slab_id: u8) -> SlabAddress {
    method free_slab_slot (line 180) | pub(crate) fn free_slab_slot(&self, slab_address: SlabAddress) {
    method get_location_for_object (line 186) | pub(crate) fn get_location_for_object(
    method insert (line 204) | pub(crate) fn insert(
    method remove (line 244) | pub(crate) fn remove(&self, object_id: ObjectId) -> Option<SlabAddress> {
    method objects_to_defrag (line 269) | pub(crate) fn objects_to_defrag(&self) -> FnvHashSet<ObjectId> {

FILE: src/tree.rs
  type Tree (line 27) | pub struct Tree<const LEAF_FANOUT: usize = 1024> {
  method drop (line 35) | fn drop(&mut self) {
  function fmt (line 48) | fn fmt(&self, w: &mut fmt::Formatter<'_>) -> fmt::Result {
  type LeafReadGuard (line 68) | struct LeafReadGuard<'a, const LEAF_FANOUT: usize = 1024> {
  method drop (line 78) | fn drop(&mut self) {
  type LeafWriteGuard (line 106) | struct LeafWriteGuard<'a, const LEAF_FANOUT: usize = 1024> {
  function epoch (line 117) | fn epoch(&self) -> FlushEpoch {
  function handle_cache_access_and_eviction_externally (line 124) | fn handle_cache_access_and_eviction_externally(
  method drop (line 136) | fn drop(&mut self) {
  function new (line 159) | pub(crate) fn new(
  function check_error (line 170) | pub fn check_error(&self) -> io::Result<()> {
  function set_error (line 174) | fn set_error(&self, error: &io::Error) {
  function storage_stats (line 178) | pub fn storage_stats(&self) -> Stats {
  function flush (line 195) | pub fn flush(&self) -> io::Result<FlushStats> {
  function page_in (line 199) | pub(crate) fn page_in(
  function merge_leaf_into_right_sibling (line 399) | fn merge_leaf_into_right_sibling<'a>(
  function successor_leaf_mut (line 517) | fn successor_leaf_mut<'a>(
  function cooperatively_serialize_leaf (line 560) | fn cooperatively_serialize_leaf(
  function leaf_for_key (line 612) | fn leaf_for_key<'a>(
  function leaf_for_key_mut (line 689) | fn leaf_for_key_mut<'a>(
  function get (line 760) | pub fn get<K: AsRef<[u8]>>(
  function insert (line 794) | pub fn insert<K, V>(
  function remove (line 923) | pub fn remove<K: AsRef<[u8]>>(
  function compare_and_swap (line 1036) | pub fn compare_and_swap<K, OV, NV>(
  function update_and_fetch (line 1210) | pub fn update_and_fetch<K, V, F>(
  function fetch_and_update (line 1282) | pub fn fetch_and_update<K, V, F>(
  function iter (line 1307) | pub fn iter(&self) -> Iter<LEAF_FANOUT> {
  function range (line 1320) | pub fn range<K, R>(&self, range: R) -> Iter<LEAF_FANOUT>
  function apply_batch (line 1376) | pub fn apply_batch(&self, batch: Batch) -> io::Result<()> {
  function contains_key (line 1558) | pub fn contains_key<K: AsRef<[u8]>>(&self, key: K) -> io::Result<bool> {
  function get_lt (line 1604) | pub fn get_lt<K>(
  function get_gt (line 1660) | pub fn get_gt<K>(
  function scan_prefix (line 1710) | pub fn scan_prefix<P>(&self, prefix: P) -> Iter<LEAF_FANOUT>
  function first (line 1729) | pub fn first(&self) -> io::Result<Option<(InlineArray, InlineArray)>> {
  function last (line 1735) | pub fn last(&self) -> io::Result<Option<(InlineArray, InlineArray)>> {
  function pop_last (line 1763) | pub fn pop_last(&self) -> io::Result<Option<(InlineArray, InlineArray)>> {
  function pop_last_in_range (line 1829) | pub fn pop_last_in_range<K, R>(
  function pop_first (line 1877) | pub fn pop_first(&self) -> io::Result<Option<(InlineArray, InlineArray)>> {
  function pop_first_in_range (line 1938) | pub fn pop_first_in_range<K, R>(
  function len (line 1977) | pub fn len(&self) -> io::Result<usize> {
  function is_empty (line 1990) | pub fn is_empty(&self) -> io::Result<bool> {
  function clear (line 2004) | pub fn clear(&self) -> io::Result<()> {
  function checksum (line 2017) | pub fn checksum(&self) -> io::Result<u32> {
  type Iter (line 2029) | pub struct Iter<const LEAF_FANOUT: usize> {
  type Item (line 2041) | type Item = io::Result<(InlineArray, InlineArray)>;
  method next (line 2043) | fn next(&mut self) -> Option<Self::Item> {
  method next_back (line 2087) | fn next_back(&mut self) -> Option<Self::Item> {
  function keys (line 2170) | pub fn keys(
  function values (line 2176) | pub fn values(
  type Item (line 2184) | type Item = io::Result<(InlineArray, InlineArray)>;
  type IntoIter (line 2185) | type IntoIter = Iter<LEAF_FANOUT>;
  method into_iter (line 2187) | fn into_iter(self) -> Self::IntoIter {
  type Batch (line 2219) | pub struct Batch {
    method insert (line 2226) | pub fn insert<K, V>(&mut self, key: K, value: V)
    method remove (line 2235) | pub fn remove<K>(&mut self, key: K)
    method get (line 2244) | pub fn get<K: AsRef<[u8]>>(&self, k: K) -> Option<Option<&InlineArray>> {

FILE: tests/00_regression.rs
  type ShredAllocator (line 12) | struct ShredAllocator;
    method alloc (line 15) | unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
    method dealloc (line 25) | unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) {
  constant INTENSITY (line 34) | const INTENSITY: usize = 10;
  function tree_bug_00 (line 38) | fn tree_bug_00() {
  function tree_bug_01 (line 45) | fn tree_bug_01() {
  function tree_bug_02 (line 70) | fn tree_bug_02() {
  function tree_bug_03 (line 98) | fn tree_bug_03() {
  function tree_bug_04 (line 122) | fn tree_bug_04() {
  function tree_bug_05 (line 148) | fn tree_bug_05() {
  function tree_bug_06 (line 170) | fn tree_bug_06() {
  function tree_bug_07 (line 194) | fn tree_bug_07() {
  function tree_bug_08 (line 218) | fn tree_bug_08() {
  function tree_bug_09 (line 241) | fn tree_bug_09() {
  function tree_bug_10 (line 271) | fn tree_bug_10() {
  function tree_bug_11 (line 310) | fn tree_bug_11() {
  function tree_bug_12 (line 336) | fn tree_bug_12() {
  function tree_bug_13 (line 387) | fn tree_bug_13() {
  function tree_bug_14 (line 418) | fn tree_bug_14() {
  function tree_bug_15 (line 439) | fn tree_bug_15() {
  function tree_bug_17 (line 472) | fn tree_bug_17() {
  function tree_bug_18 (line 489) | fn tree_bug_18() {
  function tree_bug_19 (line 509) | fn tree_bug_19() {
  function tree_bug_20 (line 529) | fn tree_bug_20() {
  function tree_bug_21 (line 550) | fn tree_bug_21() {
  function tree_bug_23 (line 592) | fn tree_bug_23() {
  function tree_bug_31 (line 946) | fn tree_bug_31() {
  function tree_bug_32 (line 970) | fn tree_bug_32() {
  function tree_bug_33 (line 984) | fn tree_bug_33() {
  function tree_bug_35 (line 1026) | fn tree_bug_35() {
  function tree_bug_37 (line 1086) | fn tree_bug_37() {
  function tree_bug_40 (line 1396) | fn tree_bug_40() {
  function tree_bug_41 (line 1409) | fn tree_bug_41() {
  function tree_bug_43 (line 1452) | fn tree_bug_43() {
  function tree_bug_46 (line 1530) | fn tree_bug_46() {
  function tree_bug_47 (line 1542) | fn tree_bug_47() {
  function tree_bug_48 (line 1554) | fn tree_bug_48() {
  function tree_bug_50 (line 1613) | fn tree_bug_50() {
  function tree_bug_51 (line 1636) | fn tree_bug_51() {
  function tree_bug_52 (line 1648) | fn tree_bug_52() {

FILE: tests/common/mod.rs
  type Alloc (line 14) | struct Alloc;
    method alloc (line 17) | unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
    method dealloc (line 24) | unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) {
  function setup_logger (line 31) | pub fn setup_logger() {
  function cleanup (line 60) | pub fn cleanup(dir: &str) {

FILE: tests/concurrent_batch_atomicity.rs
  constant CONCURRENCY (line 6) | const CONCURRENCY: usize = 32;
  constant N_KEYS (line 7) | const N_KEYS: usize = 1024;
  type Db (line 9) | type Db = SledDb<8>;
  function batch_writer (line 11) | fn batch_writer(db: Db, barrier: Arc<Barrier>, thread_number: usize) {
  function concurrent_batch_atomicity (line 23) | fn concurrent_batch_atomicity() {

FILE: tests/crash_tests/crash_batches.rs
  constant CACHE_SIZE (line 7) | const CACHE_SIZE: usize = 1024 * 1024;
  constant BATCH_SIZE (line 8) | const BATCH_SIZE: u32 = 8;
  constant SEGMENT_SIZE (line 9) | const SEGMENT_SIZE: usize = 1024;
  function verify_batches (line 13) | fn verify_batches(tree: &Db) -> u32 {
  function run_batches_inner (line 63) | fn run_batches_inner(db: Db) {
  function run_crash_batches (line 95) | pub fn run_crash_batches() {

FILE: tests/crash_tests/crash_heap.rs
  constant FANOUT (line 3) | const FANOUT: usize = 3;
  function run_crash_heap (line 5) | pub fn run_crash_heap() {

FILE: tests/crash_tests/crash_iter.rs
  constant CACHE_SIZE (line 6) | const CACHE_SIZE: usize = 256;
  function run_crash_iter (line 8) | pub fn run_crash_iter() {

FILE: tests/crash_tests/crash_metadata_store.rs
  function run_crash_metadata_store (line 3) | pub fn run_crash_metadata_store() {

FILE: tests/crash_tests/crash_object_cache.rs
  constant FANOUT (line 3) | const FANOUT: usize = 3;
  function run_crash_object_cache (line 5) | pub fn run_crash_object_cache() {

FILE: tests/crash_tests/crash_sequential_writes.rs
  constant CACHE_SIZE (line 5) | const CACHE_SIZE: usize = 1024 * 1024;
  constant CYCLE (line 6) | const CYCLE: usize = 256;
  constant SEGMENT_SIZE (line 7) | const SEGMENT_SIZE: usize = 1024;
  function verify (line 12) | fn verify(tree: &Db) -> (u32, u32) {
  function run_inner (line 79) | fn run_inner(config: Config) {
  function run_crash_sequential_writes (line 117) | pub fn run_crash_sequential_writes() {

FILE: tests/crash_tests/crash_tx.rs
  constant CACHE_SIZE (line 3) | const CACHE_SIZE: usize = 1024 * 1024;
  function run_crash_tx (line 5) | pub fn run_crash_tx() {

FILE: tests/crash_tests/mod.rs
  type Db (line 28) | type Db = SledDb<8>;
  constant SEQUENTIAL_WRITES_DIR (line 31) | pub const SEQUENTIAL_WRITES_DIR: &str = "crash_sequential_writes";
  constant BATCHES_DIR (line 32) | pub const BATCHES_DIR: &str = "crash_batches";
  constant ITER_DIR (line 33) | pub const ITER_DIR: &str = "crash_iter";
  constant TX_DIR (line 34) | pub const TX_DIR: &str = "crash_tx";
  constant METADATA_STORE_DIR (line 35) | pub const METADATA_STORE_DIR: &str = "crash_metadata_store";
  constant HEAP_DIR (line 36) | pub const HEAP_DIR: &str = "crash_heap";
  constant OBJECT_CACHE_DIR (line 37) | pub const OBJECT_CACHE_DIR: &str = "crash_object_cache";
  constant CRASH_DIR (line 39) | const CRASH_DIR: &str = "crash_test_files";
  function spawn_killah (line 41) | fn spawn_killah() {
  function u32_to_vec (line 49) | fn u32_to_vec(u: u32) -> Vec<u8> {
  function slice_to_u32 (line 54) | fn slice_to_u32(b: &[u8]) -> u32 {
  function tree_to_string (line 61) | fn tree_to_string(tree: &Db) -> String {

FILE: tests/test_crash_recovery.rs
  constant TEST_ENV_VAR (line 11) | const TEST_ENV_VAR: &str = "SLED_CRASH_TEST";
  constant N_TESTS (line 12) | const N_TESTS: usize = 100;
  constant TESTS (line 14) | const TESTS: [&str; 7] = [
  constant CRASH_CHANCE (line 24) | const CRASH_CHANCE: u32 = 250;
  type ShredAllocator (line 30) | struct ShredAllocator;
    method alloc (line 33) | unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
    method dealloc (line 43) | unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) {
  function main (line 51) | fn main() {
  function run_child_process (line 134) | fn run_child_process(dir: &str) {
  function supervisor (line 166) | fn supervisor(dir: &str) {

FILE: tests/test_quiescent.rs
  function quiescent_cpu_time (line 10) | fn quiescent_cpu_time() {

FILE: tests/test_space_leaks.rs
  function size_leak (line 7) | fn size_leak() -> io::Result<()> {

FILE: tests/test_tree.rs
  type Db (line 21) | type Db = SledDb<3>;
  constant N_THREADS (line 28) | const N_THREADS: usize = 32;
  constant N_PER_THREAD (line 29) | const N_PER_THREAD: usize = 10_000;
  constant N (line 30) | const N: usize = N_THREADS * N_PER_THREAD;
  constant SPACE (line 31) | const SPACE: usize = N;
  constant INTENSITY (line 34) | const INTENSITY: usize = 1;
  function kv (line 36) | fn kv(i: usize) -> InlineArray {
  function monotonic_inserts (line 44) | fn monotonic_inserts() {
  function fixed_stride_inserts (line 88) | fn fixed_stride_inserts() {
  function sequential_inserts (line 138) | fn sequential_inserts() {
  function reverse_inserts (line 158) | fn reverse_inserts() {
  function very_large_reverse_tree_iterator (line 179) | fn very_large_reverse_tree_iterator() {
  function varied_compression_ratios (line 195) | fn varied_compression_ratios() {
  function test_pop_first (line 224) | fn test_pop_first() -> io::Result<()> {
  function test_pop_last_in_range (line 247) | fn test_pop_last_in_range() -> io::Result<()> {
  function test_interleaved_gets_sets (line 282) | fn test_interleaved_gets_sets() {
  function concurrent_tree_pops (line 318) | fn concurrent_tree_pops() -> std::io::Result<()> {
  function concurrent_tree_ops (line 356) | fn concurrent_tree_ops() {
  function concurrent_tree_iter (line 499) | fn concurrent_tree_iter() -> io::Result<()> {
  function tree_subdir (line 884) | fn tree_subdir() {
  function tree_small_keys_iterator (line 916) | fn tree_small_keys_iterator() {
  function tree_big_keys_iterator (line 956) | fn tree_big_keys_iterator() {
  function tree_range (line 1086) | fn tree_range() {
  function recover_tree (line 1136) | fn recover_tree() {
  function tree_gc (line 1173) | fn tree_gc() {
  function contains_tree (line 1278) | fn contains_tree() {
  function tree_import_export (line 1296) | fn tree_import_export() -> io::Result<()> {
  function quickcheck_tree_matches_btreemap (line 1365) | fn quickcheck_tree_matches_btreemap() {

FILE: tests/test_tree_failpoints.rs
  constant SEGMENT_SIZE (line 13) | const SEGMENT_SIZE: usize = 256;
  constant BATCH_COUNTER_KEY (line 14) | const BATCH_COUNTER_KEY: &[u8] = b"batch_counter";
  type Op (line 17) | enum Op {
  type BatchOp (line 28) | enum BatchOp {
  method arbitrary (line 34) | fn arbitrary<G: Gen>(g: &mut G) -> BatchOp {
  method arbitrary (line 46) | fn arbitrary<G: Gen>(g: &mut G) -> Op {
  method shrink (line 97) | fn shrink(&self) -> Box<dyn Iterator<Item = Op>> {
  function v (line 133) | fn v(b: &[u8]) -> u16 {
  function value_factory (line 140) | fn value_factory(set_counter: u16) -> Vec<u8> {
  function tear_down_failpoints (line 155) | fn tear_down_failpoints() {
  type ReferenceVersion (line 160) | struct ReferenceVersion {
  type ReferenceEntry (line 166) | struct ReferenceEntry {
  function prop_tree_crashes_nicely (line 171) | fn prop_tree_crashes_nicely(ops: Vec<Op>, flusher: bool) -> bool {
  function run_tree_crashes_nicely (line 203) | fn run_tree_crashes_nicely(ops: Vec<Op>, flusher: bool) -> bool {
  function quickcheck_tree_with_failpoints (line 510) | fn quickcheck_tree_with_failpoints() {
  function failpoints_bug_01 (line 528) | fn failpoints_bug_01() {
  function failpoints_bug_02 (line 538) | fn failpoints_bug_02() {
  function failpoints_bug_03 (line 553) | fn failpoints_bug_03() {
  function failpoints_bug_04 (line 567) | fn failpoints_bug_04() {
  function failpoints_bug_05 (line 584) | fn failpoints_bug_05() {
  function failpoints_bug_06 (line 608) | fn failpoints_bug_06() {
  function failpoints_bug_07 (line 630) | fn failpoints_bug_07() {
  function failpoints_bug_08 (line 666) | fn failpoints_bug_08() {
  function failpoints_bug_09 (line 699) | fn failpoints_bug_09() {
  function failpoints_bug_10 (line 754) | fn failpoints_bug_10() {
  function failpoints_bug_11 (line 966) | fn failpoints_bug_11() {
  function failpoints_bug_12 (line 1007) | fn failpoints_bug_12() {
  function failpoints_bug_13 (line 1032) | fn failpoints_bug_13() {
  function failpoints_bug_14 (line 1076) | fn failpoints_bug_14() {
  function failpoints_bug_15 (line 1108) | fn failpoints_bug_15() {
  function failpoints_bug_16 (line 1118) | fn failpoints_bug_16() {
  function failpoints_bug_17 (line 1128) | fn failpoints_bug_17() {
  function failpoints_bug_18 (line 1165) | fn failpoints_bug_18() {
  function failpoints_bug_19 (line 1175) | fn failpoints_bug_19() {
  function failpoints_bug_20 (line 1219) | fn failpoints_bug_20() {
  function failpoints_bug_21 (line 1231) | fn failpoints_bug_21() {
  function failpoints_bug_22 (line 1306) | fn failpoints_bug_22() {
  function failpoints_bug_23 (line 1316) | fn failpoints_bug_23() {
  function failpoints_bug_24 (line 1332) | fn failpoints_bug_24() {
  function failpoints_bug_25 (line 1343) | fn failpoints_bug_25() {
  function failpoints_bug_26 (line 1406) | fn failpoints_bug_26() {
  function failpoints_bug_27 (line 1479) | fn failpoints_bug_27() {
  function failpoints_bug_28 (line 1520) | fn failpoints_bug_28() {
  function failpoints_bug_29 (line 1557) | fn failpoints_bug_29() {
  function failpoints_bug_30 (line 1586) | fn failpoints_bug_30() {
  function failpoints_bug_31 (line 1602) | fn failpoints_bug_31() {
  function failpoints_bug_32 (line 1621) | fn failpoints_bug_32() {
  function failpoints_bug_33 (line 1633) | fn failpoints_bug_33() {
  function failpoints_bug_34 (line 1703) | fn failpoints_bug_34() {
  function failpoints_bug_35 (line 1741) | fn failpoints_bug_35() {
  function failpoints_bug_36 (line 1767) | fn failpoints_bug_36() {
  function failpoints_bug_37 (line 1803) | fn failpoints_bug_37() {
  function failpoints_bug_38 (line 1820) | fn failpoints_bug_38() {
  function failpoints_bug_39 (line 1839) | fn failpoints_bug_39() {

FILE: tests/tree/mod.rs
  type Db (line 8) | type Db = SledDb<3>;
  type Key (line 11) | pub struct Key(pub Vec<u8>);
    method fmt (line 14) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function range (line 28) | fn range(g: &mut Gen, min_inclusive: usize, max_exclusive: usize) -> usi...
  method arbitrary (line 40) | fn arbitrary(g: &mut Gen) -> Self {
  method shrink (line 64) | fn shrink(&self) -> Box<dyn Iterator<Item = Self>> {
  type Op (line 77) | pub enum Op {
  method arbitrary (line 92) | fn arbitrary(g: &mut Gen) -> Self {
  method shrink (line 112) | fn shrink(&self) -> Box<dyn Iterator<Item = Self>> {
  function bytes_to_u16 (line 134) | fn bytes_to_u16(v: &[u8]) -> u16 {
  function u16_to_bytes (line 139) | fn u16_to_bytes(u: u16) -> Vec<u8> {
  function prop_tree_matches_btreemap (line 158) | pub fn prop_tree_matches_btreemap(
  function prop_tree_matches_btreemap_inner (line 177) | fn prop_tree_matches_btreemap_inner(