membase 0.2.1

Ultra-high performance async runtime with fast task cycling, lock-free scheduling, and zero-overhead performance
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117

//! Prefetching optimizations for memory mapping.
//!
//! This module provides functionality for optimizing memory access patterns
//! through prefetching.

use crate::advanced::PrefetchStrategy;

/// Apply a prefetching strategy to a memory region.
///
/// # Safety
///
/// This function is unsafe because it operates on raw memory.
#[inline]
pub unsafe fn apply_strategy(ptr: *mut u8, len: usize, strategy: PrefetchStrategy) {
    match strategy {
        PrefetchStrategy::None => {
            // No prefetching
        },
        PrefetchStrategy::Sequential => {
            // Sequential prefetching
            prefetch_sequential(ptr, len);
        },
        PrefetchStrategy::Random => {
            // Random access prefetching
            // For random access, we don't do any specific prefetching
        },
        PrefetchStrategy::Custom(lookahead) => {
            // Custom prefetching with specified lookahead
            prefetch_custom(ptr, len, lookahead);
        },
    }
}

/// Prefetch memory sequentially.
///
/// # Safety
///
/// This function is unsafe because it operates on raw memory.
#[inline]
unsafe fn prefetch_sequential(ptr: *mut u8, len: usize) {
    // Get the page size
    let page_size = page_size();
    
    // Prefetch the first few pages
    let prefetch_pages = 4;
    let prefetch_size = std::cmp::min(len, prefetch_pages * page_size);
    
    for i in (0..prefetch_size).step_by(64) {
        prefetch_read((ptr as usize + i) as *const u8);
    }
}

/// Prefetch memory with a custom lookahead.
///
/// # Safety
///
/// This function is unsafe because it operates on raw memory.
#[inline]
unsafe fn prefetch_custom(ptr: *mut u8, len: usize, lookahead: usize) {
    // Prefetch with the specified lookahead
    let prefetch_size = std::cmp::min(len, lookahead);
    
    for i in (0..prefetch_size).step_by(64) {
        prefetch_read((ptr as usize + i) as *const u8);
    }
}

/// Prefetch memory for reading.
///
/// # Safety
///
/// This function is unsafe because it operates on raw memory.
#[inline]
unsafe fn prefetch_read(ptr: *const u8) {
    #[cfg(target_arch = "x86_64")]
    {
        std::arch::x86_64::_mm_prefetch(ptr as *const i8, std::arch::x86_64::_MM_HINT_T0);
    }
    
    #[cfg(target_arch = "aarch64")]
    {
        std::arch::aarch64::_prefetch(ptr, std::arch::aarch64::_PREFETCH_READ, std::arch::aarch64::_PREFETCH_LOCALITY3);
    }
    
    #[cfg(not(any(target_arch = "x86_64", target_arch = "aarch64")))]
    {
        // No prefetch instruction available
        // We'll just read the memory to bring it into cache
        std::ptr::read_volatile(ptr);
    }
}

/// Get the system page size.
#[inline]
fn page_size() -> usize {
    #[cfg(unix)]
    {
        unsafe { libc::sysconf(libc::_SC_PAGESIZE) as usize }
    }
    
    #[cfg(windows)]
    {
        use winapi::um::sysinfoapi::{GetSystemInfo, SYSTEM_INFO};
        
        unsafe {
            let mut system_info: SYSTEM_INFO = std::mem::zeroed();
            GetSystemInfo(&mut system_info);
            system_info.dwPageSize as usize
        }
    }
    
    #[cfg(not(any(unix, windows)))]
    {
        // Default to 4KB for unknown platforms
        4096
    }
}