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
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139

#!/bin/bash
# Production-quality read-ahead benchmarking script
 
set -e
 
# Configuration
DEVICE="sda"                          # Block device to test
TEST_FILE="/mnt/data/benchmark.dat"   # Test file (should not exist)
FILE_SIZE_GB=10                        # Larger than RAM!
BLOCK_SIZE="1M"                        # Read block size
ITERATIONS=5                           # Runs per configuration
READAHEAD_VALUES="0 64 128 256 512 1024 2048 4096"
 
# System preparation
prepare_system() {
    echo "=== Preparing system for benchmark ==="
    
    # Stop unnecessary services
    systemctl stop cron
    systemctl stop unattended-upgrades
    
    # Set CPU governor to performance
    for cpu in /sys/devices/system/cpu/cpu*/cpufreq/scaling_governor; do
        echo "performance" > "$cpu"
    done
    
    # Disable swap to avoid interference
    swapoff -a
    
    echo "System prepared."
}
 
# Drop all caches
drop_caches() {
    sync
    echo 3 > /proc/sys/vm/drop_caches
    sleep 1
}
 
# Set read-ahead size
set_readahead() {
    local size_kb=$1
    echo "$size_kb" > "/sys/block/${DEVICE}/queue/read_ahead_kb"
    # Verify
    local actual=$(cat "/sys/block/${DEVICE}/queue/read_ahead_kb")
    if [ "$actual" != "$size_kb" ]; then
        echo "Warning: Asked for $size_kb KB, got $actual KB"
    fi
}
 
# Create test file (if needed)
create_test_file() {
    if [ ! -f "$TEST_FILE" ]; then
        echo "Creating ${FILE_SIZE_GB}GB test file..."
        dd if=/dev/urandom of="$TEST_FILE" bs=1M count=$((FILE_SIZE_GB * 1024))            status=progress conv=fdatasync
    fi
    echo "Test file ready: $TEST_FILE"
}
 
# Single benchmark run
run_benchmark() {
    local ra_kb=$1
    local run_num=$2
    
    drop_caches
    
    # Use perf for detailed metrics
    local start_time=$(date +%s.%N)
    
    # Record I/O statistics before
    local io_before=$(cat /proc/diskstats | grep " ${DEVICE} ")
    
    # Perform the read
    dd if="$TEST_FILE" of=/dev/null bs="$BLOCK_SIZE" 2>&1 | tail -1
    
    local end_time=$(date +%s.%N)
    
    # Record I/O statistics after
    local io_after=$(cat /proc/diskstats | grep " ${DEVICE} ")
    
    # Calculate metrics
    local elapsed=$(echo "$end_time - $start_time" | bc)
    local throughput=$(echo "scale=2; $FILE_SIZE_GB * 1024 / $elapsed" | bc)
    
    echo "$ra_kb,$run_num,$elapsed,$throughput"
}
 
# Main benchmark loop
run_benchmark_suite() {
    echo "ra_kb,run,elapsed_s,throughput_mb_s" > results.csv
    
    for ra_kb in $READAHEAD_VALUES; do
        echo "=== Testing read-ahead: ${ra_kb} KB ==="
        set_readahead "$ra_kb"
        
        for run in $(seq 1 $ITERATIONS); do
            echo "  Run $run / $ITERATIONS..."
            result=$(run_benchmark "$ra_kb" "$run")
            echo "$result" >> results.csv
            echo "    Result: $result"
        done
    done
}
 
# Generate summary report
generate_report() {
    echo ""
    echo "=== SUMMARY REPORT ==="
    echo ""
    
    for ra_kb in $READAHEAD_VALUES; do
        # Calculate average throughput for this setting
        avg=$(grep "^$ra_kb," results.csv | awk -F, '{sum+=$4; count++} END {print sum/count}')
        echo "Read-ahead ${ra_kb} KB: Average throughput = ${avg} MB/s"
    done
    
    echo ""
    echo "Full results saved to results.csv"
}
 
# Main execution
main() {
    echo "=========================================="
    echo "Read-Ahead Performance Benchmark"
    echo "Device: $DEVICE"
    echo "File Size: ${FILE_SIZE_GB} GB"
    echo "=========================================="
    
    prepare_system
    create_test_file
    run_benchmark_suite
    generate_report
    
    # Restore default read-ahead
    set_readahead 256
    echo "Benchmark complete."
}
 
main "$@"

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

#!/bin/bash
# Comprehensive read-ahead diagnostics
 
echo "=== READ-AHEAD DIAGNOSTIC REPORT ==="
echo "Generated: $(date)"
echo ""
 
# 1. Current read-ahead settings
echo "--- Current Read-Ahead Settings ---"
for device in /sys/block/sd*/queue/read_ahead_kb; do
    dev=$(echo "$device" | cut -d'/' -f4)
    value=$(cat "$device")
    echo "$dev: ${value} KB"
done
echo ""
 
# 2. Memory statistics
echo "--- Memory Status ---"
free -h
echo ""
echo "Page Cache Usage:"
grep -E "^(Cached|Buffers|Active|Inactive):" /proc/meminfo
echo ""
 
# 3. Page cache hit/miss from vmstat
echo "--- Page Cache Activity (last 5 seconds) ---"
vmstat 1 5 | head -7
echo ""
 
# 4. Per-process I/O statistics
echo "--- Top I/O Processes ---"
pidstat -d 1 5 | head -20
echo ""
 
# 5. Block device statistics
echo "--- Block Device I/O Statistics ---"
iostat -x 1 5 | head -20
echo ""
 
# 6. Trace read-ahead activity (requires tracing enabled)
echo "--- Read-Ahead Traces (if available) ---"
if [ -d /sys/kernel/debug/tracing ]; then
    # Check if trace events exist
    if [ -f /sys/kernel/debug/tracing/events/filemap/file_readahead/enable ]; then
        echo "Enabling read-ahead tracing for 5 seconds..."
        echo 1 > /sys/kernel/debug/tracing/events/filemap/file_readahead/enable
        sleep 5
        echo 0 > /sys/kernel/debug/tracing/events/filemap/file_readahead/enable
        echo "Last 20 read-ahead events:"
        tail -20 /sys/kernel/debug/tracing/trace
    else
        echo "Read-ahead trace events not available"
    fi
else
    echo "Tracing not available"
fi
echo ""
 
# 7. Check for memory pressure indicators
echo "--- Memory Pressure Indicators ---"
echo "Page reclaim activity:"
grep -E "^(pgsteal|pgscan|pgfault)" /proc/vmstat | head -10
echo ""
echo "Swap activity:"
grep -E "^(swap)" /proc/meminfo
echo ""
 
# 8. Analyze specific file access patterns
echo "--- File Access Pattern Analysis ---"
echo "To analyze a specific file, run:"
echo "  strace -e read,lseek -c <command>"
echo "  or"
echo "  fatrace -o /tmp/file_access.log -s 10"
echo ""
 
# Summary diagnosis
echo "=== QUICK DIAGNOSIS ==="
# Check if read-ahead might be too small
ra_value=$(cat /sys/block/sda/queue/read_ahead_kb 2>/dev/null || echo "0")
if [ "$ra_value" -lt 128 ]; then
    echo "⚠ WARNING: Read-ahead is very small (${ra_value}KB). Consider increasing."
fi
 
# Check memory pressure
high_reclaim=$(grep "pgsteal_direct" /proc/vmstat | awk '{print $2}')
if [ "$high_reclaim" -gt 100000 ]; then
    echo "⚠ WARNING: High direct page reclaim activity. Read-ahead may be evicting pages."
fi
 
# Check I/O wait
iowait=$(iostat | grep -A1 "avg-cpu" | tail -1 | awk '{print $4}')
if (( $(echo "$iowait > 20" | bc -l) )); then
    echo "⚠ WARNING: High I/O wait (${iowait}%). Read-ahead may be insufficient."
fi
 
echo ""
echo "=== END DIAGNOSTIC REPORT ==="

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
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188

/* Application-level read-ahead optimizations */
 
#include <fcntl.h>
#include <unistd.h>
#include <sys/mman.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
/*
 * Optimization 1: Use posix_fadvise for explicit hints
 */
void optimized_sequential_read(const char *filepath) {
    int fd = open(filepath, O_RDONLY);
    if (fd < 0) return;
    
    // Get file size
    off_t file_size = lseek(fd, 0, SEEK_END);
    lseek(fd, 0, SEEK_SET);
    
    // Tell kernel our access pattern
    posix_fadvise(fd, 0, file_size, POSIX_FADV_SEQUENTIAL);
    
    // Read the file
    char buffer[65536];
    while (read(fd, buffer, sizeof(buffer)) > 0) {
        // Process data...
    }
    
    // Tell kernel we're done - pages can be evicted
    posix_fadvise(fd, 0, file_size, POSIX_FADV_DONTNEED);
    
    close(fd);
}
 
/*
 * Optimization 2: Explicit prefetch for known access patterns
 */
void prefetch_ahead(int fd, off_t current_pos, size_t lookahead) {
    // Trigger kernel prefetch for upcoming region
    posix_fadvise(fd, current_pos, lookahead, POSIX_FADV_WILLNEED);
}
 
void database_scan_optimized(int fd, off_t file_size) {
    const size_t LOOKAHEAD = 4 * 1024 * 1024;  // 4MB lookahead
    const size_t READ_SIZE = 64 * 1024;         // 64KB reads
    
    char *buffer = aligned_alloc(4096, READ_SIZE);
    off_t offset = 0;
    
    // Prime the pump - prefetch initial data
    posix_fadvise(fd, 0, LOOKAHEAD, POSIX_FADV_WILLNEED);
    
    while (offset < file_size) {
        // Prefetch ahead while processing current data
        if (offset + LOOKAHEAD < file_size) {
            prefetch_ahead(fd, offset + READ_SIZE, LOOKAHEAD);
        }
        
        ssize_t bytes = pread(fd, buffer, READ_SIZE, offset);
        if (bytes <= 0) break;
        
        process_data(buffer, bytes);
        offset += bytes;
    }
    
    free(buffer);
}
 
/*
 * Optimization 3: Memory-mapped I/O with madvise
 */
void mmap_optimized_read(const char *filepath) {
    int fd = open(filepath, O_RDONLY);
    if (fd < 0) return;
    
    off_t file_size = lseek(fd, 0, SEEK_END);
    
    // Memory-map the file
    void *map = mmap(NULL, file_size, PROT_READ, MAP_PRIVATE, fd, 0);
    if (map == MAP_FAILED) {
        close(fd);
        return;
    }
    
    // Advise kernel about access pattern
    madvise(map, file_size, MADV_SEQUENTIAL);
    
    // For very large files, prefetch in chunks
    const size_t CHUNK_SIZE = 64 * 1024 * 1024;  // 64MB chunks
    
    for (off_t offset = 0; offset < file_size; offset += CHUNK_SIZE) {
        size_t chunk = (file_size - offset < CHUNK_SIZE) ? 
                       (file_size - offset) : CHUNK_SIZE;
        
        // Prefetch next chunk
        if (offset + CHUNK_SIZE < file_size) {
            madvise((char*)map + offset + CHUNK_SIZE, 
                    CHUNK_SIZE, MADV_WILLNEED);
        }
        
        // Process current chunk
        process_mmap_chunk((char*)map + offset, chunk);
        
        // Release previous chunk (if far enough ahead)
        if (offset >= CHUNK_SIZE * 2) {
            madvise((char*)map + offset - CHUNK_SIZE * 2, 
                    CHUNK_SIZE, MADV_DONTNEED);
        }
    }
    
    munmap(map, file_size);
    close(fd);
}
 
/*
 * Optimization 4: Asynchronous I/O (io_uring)
 * For maximum performance on modern systems
 */
#include <liburing.h>
 
void io_uring_optimized_read(const char *filepath) {
    struct io_uring ring;
    io_uring_queue_init(64, &ring, 0);  // 64 queue entries
    
    int fd = open(filepath, O_RDONLY | O_DIRECT);
    off_t file_size = lseek(fd, 0, SEEK_END);
    
    const int NUM_BUFFERS = 8;
    const size_t BUFFER_SIZE = 1024 * 1024;  // 1MB buffers
    void *buffers[NUM_BUFFERS];
    
    for (int i = 0; i < NUM_BUFFERS; i++) {
        buffers[i] = aligned_alloc(4096, BUFFER_SIZE);
    }
    
    // Submit initial batch of reads
    off_t offset = 0;
    int in_flight = 0;
    int buffer_idx = 0;
    
    // Prime with initial requests
    while (in_flight < NUM_BUFFERS && offset < file_size) {
        struct io_uring_sqe *sqe = io_uring_get_sqe(&ring);
        io_uring_prep_read(sqe, fd, buffers[buffer_idx], BUFFER_SIZE, offset);
        sqe->user_data = buffer_idx;
        
        offset += BUFFER_SIZE;
        buffer_idx = (buffer_idx + 1) % NUM_BUFFERS;
        in_flight++;
    }
    io_uring_submit(&ring);
    
    // Process completions and submit more
    while (in_flight > 0) {
        struct io_uring_cqe *cqe;
        io_uring_wait_cqe(&ring, &cqe);
        
        int completed_buffer = cqe->user_data;
        ssize_t result = cqe->res;
        
        if (result > 0) {
            process_data(buffers[completed_buffer], result);
        }
        
        io_uring_cqe_seen(&ring, cqe);
        in_flight--;
        
        // Submit next read if data remains
        if (offset < file_size) {
            struct io_uring_sqe *sqe = io_uring_get_sqe(&ring);
            io_uring_prep_read(sqe, fd, buffers[completed_buffer], 
                               BUFFER_SIZE, offset);
            sqe->user_data = completed_buffer;
            io_uring_submit(&ring);
            
            offset += BUFFER_SIZE;
            in_flight++;
        }
    }
    
    // Cleanup
    for (int i = 0; i < NUM_BUFFERS; i++) {
        free(buffers[i]);
    }
    close(fd);
    io_uring_queue_exit(&ring);
}

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

"""
Prometheus metrics exporter for read-ahead performance monitoring.
Run as a daemon to expose metrics at :9100/metrics
"""
 
from prometheus_client import start_http_server, Gauge, Counter
import time
import os
import re
 
# Define metrics
CACHE_HIT_RATIO = Gauge('readahead_cache_hit_ratio', 
                         'Page cache hit ratio', ['device'])
PAGE_CACHE_SIZE = Gauge('readahead_page_cache_bytes',
                         'Page cache size in bytes')
READ_AHEAD_KB = Gauge('readahead_setting_kb',
                       'Current read-ahead setting', ['device'])
IO_WAIT_PERCENT = Gauge('readahead_io_wait_percent',
                         'CPU I/O wait percentage')
PAGES_PREFETCHED = Counter('readahead_pages_prefetched_total',
                            'Total pages prefetched', ['device'])
PAGES_USED = Counter('readahead_pages_used_total',
                      'Prefetched pages actually used', ['device'])
 
def get_block_devices():
    """Get list of block devices."""
    devices = []
    for name in os.listdir('/sys/block'):
        if name.startswith('sd') or name.startswith('nvme'):
            devices.append(name)
    return devices
 
def get_read_ahead_kb(device):
    """Get current read-ahead setting for device."""
    path = f'/sys/block/{device}/queue/read_ahead_kb'
    try:
        with open(path) as f:
            return int(f.read().strip())
    except:
        return 0
 
def get_cache_stats():
    """Get page cache statistics from /proc/meminfo."""
    stats = {}
    with open('/proc/meminfo') as f:
        for line in f:
            if line.startswith('Cached:'):
                stats['cached'] = int(line.split()[1]) * 1024
            elif line.startswith('Buffers:'):
                stats['buffers'] = int(line.split()[1]) * 1024
    return stats
 
def get_io_wait():
    """Get CPU I/O wait percentage from /proc/stat."""
    with open('/proc/stat') as f:
        line = f.readline()
        parts = line.split()
        # cpu user nice system idle iowait irq softirq
        total = sum(int(x) for x in parts[1:])
        iowait = int(parts[5])
        return (iowait / total * 100) if total > 0 else 0
 
def get_vmstat_values():
    """Get relevant /proc/vmstat values."""
    stats = {}
    with open('/proc/vmstat') as f:
        for line in f:
            parts = line.strip().split()
            if len(parts) == 2:
                stats[parts[0]] = int(parts[1])
    return stats
 
def calculate_hit_ratio(vmstat):
    """Estimate cache hit ratio from vmstat."""
    # pgfault = minor faults (cache hits)
    # pgmajfault = major faults (cache misses requiring I/O)
    minor = vmstat.get('pgfault', 0) - vmstat.get('pgmajfault', 0)
    major = vmstat.get('pgmajfault', 0)
    total = minor + major
    return (minor / total) if total > 0 else 1.0
 
def collect_metrics():
    """Collect all metrics."""
    devices = get_block_devices()
    
    for device in devices:
        ra_kb = get_read_ahead_kb(device)
        READ_AHEAD_KB.labels(device=device).set(ra_kb)
    
    cache_stats = get_cache_stats()
    PAGE_CACHE_SIZE.set(cache_stats.get('cached', 0))
    
    io_wait = get_io_wait()
    IO_WAIT_PERCENT.set(io_wait)
    
    vmstat = get_vmstat_values()
    hit_ratio = calculate_hit_ratio(vmstat)
    for device in devices:
        CACHE_HIT_RATIO.labels(device=device).set(hit_ratio)
 
def main():
    """Start metrics server and collect periodically."""
    start_http_server(9100)
    print("Metrics server started on :9100")
    
    while True:
        collect_metrics()
        time.sleep(15)  # Collect every 15 seconds
 
if __name__ == '__main__':
    main()