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

/*
 * Conceptual representation of THP promotion decision making
 * Based on Linux kernel mm/khugepaged.c logic
 */
 
#include <stdbool.h>
#include <stdint.h>
 
#define HPAGE_SIZE (2UL * 1024 * 1024)
#define PAGE_SIZE  4096
#define PAGES_PER_HPAGE (HPAGE_SIZE / PAGE_SIZE)  // 512
 
struct vm_area_struct;  // Forward declaration
struct page;
 
/**
 * Check if a VMA is eligible for THP
 */
bool thp_vma_eligible(struct vm_area_struct *vma) {
    // Check THP mode
    // - "always": All anonymous mappings eligible
    // - "madvise": Only regions with MADV_HUGEPAGE
    // - "never": No promotion
    
    // Must be anonymous memory (not file-backed)
    if (vma_is_file_backed(vma))
        return false;
    
    // Must have write permission (copy-on-write optimization)
    if (!(vma->vm_flags & VM_WRITE))
        return false;
    
    // Must not be marked NOHUGEPAGE
    if (vma->vm_flags & VM_NOHUGEPAGE)
        return false;
    
    // In madvise mode, must have HUGEPAGE hint
    if (thp_mode == THP_MADVISE) {
        if (!(vma->vm_flags & VM_HUGEPAGE))
            return false;
    }
    
    return true;
}
 
/**
 * Check if a specific address range can be collapsed to huge page
 * Called by khugepaged
 */
bool can_collapse_range(unsigned long address, struct vm_area_struct *vma) {
    unsigned long start = address & ~(HPAGE_SIZE - 1);  // Align to 2MB
    int unmapped_pages = 0;
    int swap_pages = 0;
    int max_unmapped = 0;  // Configurable via sysfs
    
    // Check all 512 pages in the range
    for (int i = 0; i < PAGES_PER_HPAGE; i++) {
        unsigned long addr = start + (i * PAGE_SIZE);
        struct page *page = follow_page(vma, addr);
        
        if (page == NULL) {
            // Page not present - would need to fault in
            unmapped_pages++;
            if (unmapped_pages > max_unmapped)
                return false;
        } else if (page_is_in_swap(page)) {
            // Page is swapped out
            swap_pages++;
            if (swap_pages > 0)  // Usually don't collapse if any swapped
                return false;
        } else if (page_count(page) != 1) {
            // Page is shared - would need copy-on-write
            // May or may not collapse depending on settings
        }
    }
    
    // Check if huge page allocation is likely to succeed
    if (!memory_has_contiguous_2mb())
        return false;
    
    return true;
}
 
/**
 * Perform the actual collapse operation
 * This is expensive - involves copying and page table updates
 */
int collapse_range_to_hugepage(unsigned long address, 
                                struct vm_area_struct *vma) {
    struct page *hpage;
    unsigned long start = address & ~(HPAGE_SIZE - 1);
    
    // Allocate a new huge page
    hpage = alloc_hugepage(GFP_KERNEL | __GFP_COMP);
    if (!hpage)
        return -ENOMEM;
    
    // Copy content from 512 small pages
    for (int i = 0; i < PAGES_PER_HPAGE; i++) {
        void *src = page_address(follow_page(vma, start + i*PAGE_SIZE));
        void *dst = page_address(hpage) + (i * PAGE_SIZE);
        copy_page(dst, src);  // memcpy of PAGE_SIZE bytes
    }
    
    // Update page tables atomically
    // This requires locking and TLB shootdown
    update_pmd_to_hugepage(vma, start, hpage);
    
    // Free original small pages
    for (int i = 0; i < PAGES_PER_HPAGE; i++) {
        struct page *old = follow_page(vma, start + i*PAGE_SIZE);
        put_page(old);
    }
    
    return 0;
}
 
/*
 * Key points:
 * 
 * 1. THP promotion is opportunistic, not guaranteed
 * 2. khugepaged runs continuously in background
 * 3. Promotion involves copying ~2MB of data
 * 4. Page tables must be updated atomically
 * 5. TLB entries must be invalidated across all CPUs
 */

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

#!/bin/bash
#
# Transparent Huge Pages Configuration Script
#
 
THP_PATH="/sys/kernel/mm/transparent_hugepage"
 
show_current_settings() {
    echo "=== CURRENT THP SETTINGS ==="
    echo ""
    
    # Main THP mode
    echo "THP Enabled Mode:"
    cat $THP_PATH/enabled
    echo ""
    
    # Defrag behavior
    echo "Defrag Mode:"
    cat $THP_PATH/defrag
    echo ""
    
    # khugepaged settings
    echo "khugepaged Settings:"
    echo "  Scan interval: $(cat $THP_PATH/khugepaged/scan_sleep_millisecs)ms"
    echo "  Pages to scan: $(cat $THP_PATH/khugepaged/pages_to_scan)"
    echo "  Max pages to collapse: $(cat $THP_PATH/khugepaged/max_ptes_none)"
    echo ""
    
    # Statistics
    echo "THP Statistics:"
    cat /proc/vmstat | grep thp_
}
 
set_mode() {
    local mode=$1
    
    case $mode in
        always|madvise|never)
            echo $mode > $THP_PATH/enabled
            echo "THP mode set to: $mode"
            ;;
        *)
            echo "Invalid mode. Use: always, madvise, or never"
            return 1
            ;;
    esac
}
 
# THP defrag modes:
# always:  Always try to defrag on fault (can cause latency)
# defer:   Defer defrag to khugepaged (lower latency)
# madvise: Only defrag for MADV_HUGEPAGE regions
# never:   Never defrag
set_defrag() {
    local mode=$1
    echo $mode > $THP_PATH/defrag
    echo "Defrag mode set to: $mode"
}
 
# Tune khugepaged for different workload profiles
tune_for_throughput() {
    echo "Tuning khugepaged for throughput..."
    
    # Scan more aggressively
    echo 100 > $THP_PATH/khugepaged/scan_sleep_millisecs
    echo 4096 > $THP_PATH/khugepaged/pages_to_scan
    
    # Allow more unmapped pages in collapse range
    echo 511 > $THP_PATH/khugepaged/max_ptes_none
    
    echo "  - Reduced sleep interval"
    echo "  - Increased pages per scan"
    echo "  - More aggressive collapsing"
}
 
tune_for_latency() {
    echo "Tuning khugepaged for latency..."
    
    # Scan less aggressively to reduce CPU overhead
    echo 10000 > $THP_PATH/khugepaged/scan_sleep_millisecs
    echo 512 > $THP_PATH/khugepaged/pages_to_scan
    
    # Be conservative about collapsing
    echo 0 > $THP_PATH/khugepaged/max_ptes_none
    
    echo "  - Increased sleep interval"
    echo "  - Reduced pages per scan"
    echo "  - Conservative collapsing"
}
 
# Recommended production settings for databases
production_database() {
    echo "Configuring THP for database workload..."
    
    # Use madvise mode - let app control THP usage
    set_mode madvise
    
    # Defer defragmentation to background
    set_defrag defer
    
    # Conservative khugepaged settings
    echo 3000 > $THP_PATH/khugepaged/scan_sleep_millisecs
    echo 1024 > $THP_PATH/khugepaged/pages_to_scan
    
    echo "Done. Application should use madvise(MADV_HUGEPAGE) on buffer pool."
}
 
# Completely disable THP (for Redis, etc.)
disable_completely() {
    echo "Completely disabling THP..."
    
    set_mode never
    set_defrag never
    
    echo "THP disabled. Restart applications to take full effect."
}
 
# Main
case "${1:- show}" in
    show)
    show_current_settings
        ;;
    always | madvise | never)
        set_mode $1
        ;;
    throughput)
    tune_for_throughput
        ;;
    latency)
    tune_for_latency
        ;;
    database)
    production_database
        ;;
    disable)
    disable_completely
        ;;
    *)
        echo "Usage: $0 {show|always|madvise|never|throughput|latency|database|disable}"
        ;;
    esac

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

# / etc / systemd / system / disable - thp.service
# Systemd service to disable THP at boot
 
    [Unit]
    Description = Disable Transparent Huge Pages
    DefaultDependencies = no
    Before = sysinit.target local - fs.target
    After = local - fs.target
 
    [Service]
    Type = oneshot
    ExecStart = /bin/sh - c 'echo never > /sys/kernel/mm/transparent_hugepage/enabled'
    ExecStart = /bin/sh - c 'echo never > /sys/kernel/mm/transparent_hugepage/defrag'
 
    [Install]
    WantedBy = basic.target
 
# Enable with:
# sudo systemctl enable disable - thp
# sudo systemctl start disable - thp

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
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205

/*
 * Using madvise() for controlled THP usage
 * 
 * Compile: gcc -o thp_madvise thp_madvise.c
 */
 
    #define _GNU_SOURCE
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #include < sys / mman.h >
        #include <errno.h>
 
    #define HPAGE_SIZE(2UL * 1024 * 1024)
 
    /**
     * Allocate memory with THP hint
     * 
     * @param size      Bytes to allocate (rounded up to 2MB)
     * @param use_thp   If true, advise kernel to use huge pages
     * @return          Pointer to allocated memory, or NULL on failure
     */
    void* alloc_with_thp_hint(size_t size, int use_thp) {
        void * addr;
    size_t aligned_size;
 
        // Round up to 2MB boundary for best THP results
        aligned_size = (size + HPAGE_SIZE - 1) & ~(HPAGE_SIZE - 1);
 
        // Allocate with 2MB alignment hint
        addr = mmap(NULL, aligned_size,
            PROT_READ | PROT_WRITE,
            MAP_PRIVATE | MAP_ANONYMOUS,
            -1, 0);
 
        if (addr == MAP_FAILED) {
            perror("mmap");
            return NULL;
        }
 
        // Set THP advice
        if (use_thp) {
            // MADV_HUGEPAGE: Hint to kernel that this region benefits from THP
            if (madvise(addr, aligned_size, MADV_HUGEPAGE) != 0) {
                perror("madvise MADV_HUGEPAGE");
                // Continue anyway - madvise failure is not fatal
            }
        } else {
            // MADV_NOHUGEPAGE: Never use huge pages for this region
            if (madvise(addr, aligned_size, MADV_NOHUGEPAGE) != 0) {
                perror("madvise MADV_NOHUGEPAGE");
            }
        }
 
        return addr;
    }
 
/**
 * Example: Database buffer pool style allocation
 * Uses THP for large persistent buffer, small pages for metadata
 */
typedef struct {
        void * buffer;          // Main buffer - huge pages
    size_t buffer_size;
        void * metadata;        // Metadata - regular pages
    size_t metadata_size;
    } BufferPool;
 
    BufferPool * create_buffer_pool(size_t buffer_mb) {
        BufferPool * pool = malloc(sizeof(BufferPool));
        if (!pool) return NULL;
 
        pool -> buffer_size = buffer_mb * 1024 * 1024;
        pool -> metadata_size = 1024 * 1024;  // 1MB metadata
 
        // Allocate main buffer with THP hint
        printf("Allocating %zu MB buffer with THP...
", buffer_mb);
        pool -> buffer = alloc_with_thp_hint(pool -> buffer_size, 1);
        if (!pool -> buffer) {
            free(pool);
            return NULL;
        }
 
        // Allocate metadata WITHOUT THP (small, random access)
        printf("Allocating 1 MB metadata without THP...
");
        pool -> metadata = alloc_with_thp_hint(pool -> metadata_size, 0);
        if (!pool -> metadata) {
            munmap(pool -> buffer, pool -> buffer_size);
            free(pool);
            return NULL;
        }
 
        // Touch the memory to trigger allocation
        memset(pool -> buffer, 0, pool -> buffer_size);
        memset(pool -> metadata, 0, pool -> metadata_size);
 
        return pool;
    }
 
    void destroy_buffer_pool(BufferPool * pool) {
        if (pool) {
            if (pool -> buffer)
                munmap(pool -> buffer, pool -> buffer_size);
            if (pool -> metadata)
                munmap(pool -> metadata, pool -> metadata_size);
            free(pool);
        }
    }
 
/**
 * Check if a memory region is backed by huge pages
 */
int check_thp_status(void * addr, size_t size) {
    char smaps_path[64];
    char line[256];
        FILE * f;
    int huge_pages = 0;
 
        snprintf(smaps_path, sizeof(smaps_path), "/proc/self/smaps");
        f = fopen(smaps_path, "r");
        if (!f) {
            perror("fopen smaps");
            return -1;
        }
    
    unsigned long target = (unsigned long) addr;
    int in_target_region = 0;
 
        while (fgets(line, sizeof(line), f)) {
        unsigned long start, end;
 
            // Check for region header
            if (sscanf(line, "%lx-%lx", & start, & end) == 2) {
                in_target_region = (target >= start && target < end);
            }
 
            // Check for AnonHugePages in target region
            if (in_target_region && strstr(line, "AnonHugePages:")) {
            unsigned long kb;
                if (sscanf(line, "AnonHugePages: %lu kB", & kb) == 1) {
                    huge_pages = kb > 0;
                    break;
                }
            }
        }
 
        fclose(f);
        return huge_pages;
    }
 
int main() {
        printf("THP madvise() Demonstration
");
        printf("═══════════════════════════════
 
");
 
        // Create a buffer pool
        BufferPool * pool = create_buffer_pool(64);  // 64MB buffer
        if (!pool) {
            fprintf(stderr, "Failed to create buffer pool
");
            return 1;
        }
 
        // Give khugepaged time to work
        printf("
Waiting for THP promotion...
");
        sleep(2);
 
        // Check THP status
        printf("
Checking huge page backing:
");
    
    int buffer_thp = check_thp_status(pool -> buffer, pool -> buffer_size);
    int metadata_thp = check_thp_status(pool -> metadata, pool -> metadata_size);
 
        printf("  Buffer (THP requested):   %s
",
            buffer_thp > 0 ? "Using huge pages ✓" :
                buffer_thp == 0 ? "Not using huge pages" : "Unknown");
        printf("  Metadata (THP disabled):  %s
",
            metadata_thp > 0 ? "Using huge pages" :
                metadata_thp == 0 ? "Not using huge pages ✓" : "Unknown");
 
        // Show detailed smaps for buffer region
        printf("
Buffer region smaps (excerpt):
");
    char cmd[128];
        snprintf(cmd, sizeof(cmd),
            "grep -A 20 '%lx' /proc/%d/smaps | head -25",
            (unsigned long)pool -> buffer, getpid());
        system(cmd);
 
        // Cleanup
        destroy_buffer_pool(pool);
 
        return 0;
    } 

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

#!/bin/bash
#
# Monitor THP - related latency events
#
 
echo "=== THP LATENCY MONITORING ==="
echo ""
echo "Watching for THP-related events that can cause latency spikes..."
echo "Press Ctrl+C to stop"
echo ""
 
# Key counters to watch:
# - compact_stall: Process stalled waiting for compaction
# - thp_fault_alloc: Page faults that attempted huge page allocation
# - thp_fault_fallback: Huge page allocation failed, fell back to 4KB
# - thp_collapse_alloc: khugepaged allocations
# - thp_collapse_alloc_failed: khugepaged allocation failures
 
    get_counter() {
    grep "^$1 " / proc / vmstat 2 > /dev/null | awk '{print $2}'
    }
 
# Initial values
    PREV_COMPACT_STALL = $(get_counter compact_stall)
    PREV_THP_FALLBACK = $(get_counter thp_fault_fallback)
    PREV_COLLAPSE_FAIL = $(get_counter thp_collapse_alloc_failed)
 
    while true; do
    sleep 1
    
    CURR_COMPACT_STALL = $(get_counter compact_stall)
    CURR_THP_FALLBACK = $(get_counter thp_fault_fallback)
    CURR_COLLAPSE_FAIL = $(get_counter thp_collapse_alloc_failed)
    
    # Calculate deltas
    DELTA_STALL = $((CURR_COMPACT_STALL - PREV_COMPACT_STALL))
    DELTA_FALLBACK = $((CURR_THP_FALLBACK - PREV_THP_FALLBACK))
    DELTA_COLLAPSE_FAIL = $((CURR_COLLAPSE_FAIL - PREV_COLLAPSE_FAIL))
    
    # Report if any activity
    if [$DELTA_STALL - gt 0] || [$DELTA_FALLBACK - gt 0] || [$DELTA_COLLAPSE_FAIL - gt 0]; then
        echo "[$(date +%H:%M:%S)] Events:"
    [$DELTA_STALL - gt 0 ] && echo "  ⚠️  compact_stall: +$DELTA_STALL (LATENCY RISK!)"
    [$DELTA_FALLBACK - gt 0 ] && echo "  📉 thp_fault_fallback: +$DELTA_FALLBACK"
    [$DELTA_COLLAPSE_FAIL - gt 0 ] && echo "  ❌ collapse_alloc_failed: +$DELTA_COLLAPSE_FAIL"
    fi
 
    PREV_COMPACT_STALL = $CURR_COMPACT_STALL
    PREV_THP_FALLBACK = $CURR_THP_FALLBACK
    PREV_COLLAPSE_FAIL = $CURR_COLLAPSE_FAIL
    done

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

THP Allocation Request
        │
        ├── Check if huge page available immediately
        │       │
        │       ├── YES ──> Allocate huge page ✓
        │       │
        │       └── NO ──> Check defrag mode
        │                       │
        │                       ├── "never"
        │                       │       └── Fall back to 4KB pages
        │                       │
        │                       ├── "madvise"
        │                       │       ├── Has MADV_HUGEPAGE ?
        │                       │       │       ├── YES ──> Sync compaction(blocks)
        │                       │       │       └── NO ──> Fall back to 4KB
        │                       │
        │                       ├── "defer" or "defer+madvise"
        │                       │       ├── Wake kcompactd
        │                       │       └── Fall back to 4KB(for now)
        │                       │           └── khugepaged will promote later
        │                       │
        │                       └── "always"
        │                               └── Sync compaction(blocks)
        │                                    ├── Success ──> Huge page
        │                                    └── Fail ──> 4KB pages
 
    Key: "blocks" means the calling thread waits, causing latency.
     "defer" modes return immediately, defrag happens in background.

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 THP Status Report
#
 
echo "═══════════════════════════════════════════════════════════════════════════"
echo "                    TRANSPARENT HUGE PAGES STATUS REPORT"
echo "═══════════════════════════════════════════════════════════════════════════"
echo ""
 
# Section 1: Current Configuration
echo "╔═══════════════════════════════════════════════════════════════════════════╗"
echo "║ CONFIGURATION                                                             ║"
echo "╚═══════════════════════════════════════════════════════════════════════════╝"
echo ""
THP_PATH="/sys/kernel/mm/transparent_hugepage"
echo "THP Enabled:  $(cat $THP_PATH/enabled)"
echo "Defrag Mode:  $(cat $THP_PATH/defrag)"
echo ""
echo "khugepaged settings:"
echo "  scan_sleep_millisecs: $(cat $THP_PATH/khugepaged/scan_sleep_millisecs)"
echo "  pages_to_scan:        $(cat $THP_PATH/khugepaged/pages_to_scan)"
echo "  max_ptes_none:        $(cat $THP_PATH/khugepaged/max_ptes_none)"
 
# Section 2: Memory Usage
echo ""
echo "╔═══════════════════════════════════════════════════════════════════════════╗"
echo "║ MEMORY USAGE                                                              ║"
echo "╚═══════════════════════════════════════════════════════════════════════════╝"
echo ""
grep -E "^(AnonHugePages|ShmemHugePages|HugePages_|Hugepagesize)" /proc/meminfo
 
# Calculate THP percentage
ANON_HUGE=$(grep "^AnonHugePages:" /proc/meminfo | awk '{print $2}')
ANON_TOTAL=$(grep "^AnonPages:" /proc/meminfo | awk '{print $2}')
if [ -n "$ANON_HUGE" ] && [ -n "$ANON_TOTAL" ] && [ "$ANON_TOTAL" -gt 0 ]; then
    PERCENT=$(echo "scale=2; $ANON_HUGE * 100 / $ANON_TOTAL" | bc)
    echo ""
    echo "THP Coverage: ${PERCENT}% of anonymous memory"
fi
 
# Section 3: Statistics
echo ""
echo "╔═══════════════════════════════════════════════════════════════════════════╗"
echo "║ THP STATISTICS (cumulative since boot)                                    ║"
echo "╚═══════════════════════════════════════════════════════════════════════════╝"
echo ""
echo "Page Fault Allocations:"
echo "  thp_fault_alloc:        $(grep "^thp_fault_alloc " /proc/vmstat | awk '{print $2}')"
echo "  thp_fault_fallback:     $(grep "^thp_fault_fallback " /proc/vmstat | awk '{print $2}')"
 
echo ""
echo "khugepaged Activity:"
echo "  thp_collapse_alloc:     $(grep "^thp_collapse_alloc " /proc/vmstat | awk '{print $2}')"
echo "  thp_collapse_alloc_failed: $(grep "^thp_collapse_alloc_failed " /proc/vmstat | awk '{print $2}')"
echo "  pages_scanned:          $(cat $THP_PATH/khugepaged/pages_scanned 2>/dev/null || echo "N/A")"
echo "  full_scans:             $(cat $THP_PATH/khugepaged/full_scans 2>/dev/null || echo "N/A")"
 
echo ""
echo "Splitting Events:"
echo "  thp_split_page:         $(grep "^thp_split_page " /proc/vmstat | awk '{print $2}')"
echo "  thp_split_pmd:          $(grep "^thp_split_pmd " /proc/vmstat | awk '{print $2}')"
 
echo ""
echo "Compaction (latency indicator):"
echo "  compact_stall:          $(grep "^compact_stall " /proc/vmstat | awk '{print $2}')"
echo "  compact_fail:           $(grep "^compact_fail " /proc/vmstat | awk '{print $2}')"
echo "  compact_success:        $(grep "^compact_success " /proc/vmstat | awk '{print $2}')"
 
# Section 4: Top THP consumers
echo ""
echo "╔═══════════════════════════════════════════════════════════════════════════╗"
echo "║ TOP THP CONSUMERS (by AnonHugePages)                                      ║"
echo "╚═══════════════════════════════════════════════════════════════════════════╝"
echo ""
printf "%-10s %-40s %15s
" "PID" "COMMAND" "AnonHugePages"
echo "─────────────────────────────────────────────────────────────────────────────"
 
for pid in /proc/[0-9]*; do
    pid_num=$(basename "$pid")
    if [ -f "$pid/smaps_rollup" ] 2>/dev/null; then
        ahp=$(grep "^AnonHugePages:" "$pid/smaps_rollup" 2>/dev/null | awk '{print $2}')
        if [ -n "$ahp" ] && [ "$ahp" -gt 0 ]; then
            cmd=$(cat "$pid/comm" 2>/dev/null | head -c 40)
            echo "$pid_num|$cmd|$ahp"
        fi
    fi
done 2>/dev/null | sort -t'|' -k3 -rn | head -10 | while IFS='|' read pid cmd ahp; do
    printf "%-10s %-40s %12s kB
" "$pid" "$cmd" "$ahp"
done
 
echo ""
echo "═══════════════════════════════════════════════════════════════════════════"
echo "Report generated: $(date)"
echo "═══════════════════════════════════════════════════════════════════════════"