memory tools

 https://github.com/0voice/kernel_memory_management/blob/main/%E2%9C%8D%20%E6%96%87%E7%AB%A0/5%20useful%20tools%20to%20detect%20memory%20leaks%20with%20examples.md

https://www.yugabyte.com/blog/linux-performance-tuning-memory-disk-io/

Found from chatgpt:

If you're looking to identify which processes are using the most cache memory on a Linux system, you can use a script that parses the /proc/[PID]/smaps or /proc/meminfo to give detailed information about memory usage, including cached memory for individual processes. Here's an approach that can help you identify which processes are consuming the most cache memory.

Script to Analyze Memory Cache Usage by Process

This script will loop through all processes, check their memory usage, and summarize how much memory is cached for each process.

Steps:

1. Use /proc/[PID]/smaps to identify memory usage for each process.
2. Look for KernelPageSize, Pss, Private_Clean, Private_Dirty, and Shared_Clean.
3. Sum the memory usage per process and list the top offenders.

Script: cache_usage_by_process.sh

#!/bin/bash

# Check if the user is root (required for reading /proc/[PID]/smaps)
if [[ $(id -u) -ne 0 ]]; then
    echo "You must run this script as root to access /proc/[PID]/smaps"
    exit 1
fi

# Temporary file to store results
TMP_FILE=$(mktemp)

# Header
echo "PID   Process Name            Cache (KB)" > $TMP_FILE
echo "----------------------------------------" >> $TMP_FILE

# Loop through each process in /proc
for pid in /proc/[0-9]*; do
    # Check if smaps file exists for the process
    if [ -f "$pid/smaps" ]; then
        # Extract process name
        process_name=$(ps -p $(basename $pid) -o comm=)

        # Extract cache memory from smaps file
        # `Private_Clean` + `Private_Dirty` + `Shared_Clean` will give an estimate of cache usage
        cache_usage=$(grep -E 'Private_Clean|Private_Dirty|Shared_Clean' $pid/smaps | awk '{sum+=$2} END {print sum}')

        # If cache_usage is not empty, output the data
        if [ -n "$cache_usage" ]; then
            echo "$(basename $pid)   $process_name   $cache_usage KB" >> $TMP_FILE
        fi
    fi
done

# Sort the results by cache usage and display the top offenders
echo "----------------------------------------"
echo "Top Processes Using Cached Memory:"
sort -k3 -n -r $TMP_FILE | head -n 20

# Cleanup
rm -f $TMP_FILE

How This Script Works:

1. Check for Root Privileges: The script needs root privileges because /proc/[PID]/smaps can only be accessed by the root user.
2. Loop through Processes: The script loops through all directories in /proc (which correspond to process IDs).
3. Check for smaps File: It checks if the smaps file exists for the process (this file contains detailed memory info).
4. Extract Memory Data: It extracts the cache-related memory stats from the smaps file. Specifically, it looks for Private_Clean, Private_Dirty, and Shared_Clean memory.
5. Summing Memory: The script adds up these values to calculate the total cached memory for each process.
6. Sorting and Display: After gathering the data, it sorts the results by cache usage and shows the top processes.

Example Output:

The output will display the processes consuming the most cache memory, for example:

PID   Process Name            Cache (KB)
----------------------------------------
1234  firefox                4520 KB
5678  mysqld                 10240 KB
2345  apache2                3580 KB
----------------------------------------
Top Processes Using Cached Memory:
5678  mysqld                 10240 KB
1234  firefox                4520 KB
2345  apache2                3580 KB
...

Explanation of Key Memory Fields:

• Private_Clean: Memory that is clean (i.e., has not been modified) and is private to the process.
• Private_Dirty: Memory that has been modified and is private to the process.
• Shared_Clean: Memory that is clean and shared with other processes.
• Shared_Dirty: Memory that has been modified and is shared with other processes.

Notes:

• Cached Memory: The cache used by a process in this script is a sum of the values in Private_Clean, Private_Dirty, and Shared_Clean. These values give an idea of how much memory is used by the page cache that could potentially be freed up.
• Performance Consideration: This script can be slow if there are a lot of processes, as it reads the smaps file for each process.
• Permissions: You'll need to run this script with root privileges to access the /proc/[PID]/smaps of other processes.

Running the Script:

1. Save the script to a file, for example cache_usage_by_process.sh.
2. Make the script executable:

   chmod +x cache_usage_by_process.sh
   

3. Run the script as root:

   sudo ./cache_usage_by_process.sh
   

This will show you which processes are using the most cached memory on your system. You can modify the script to include other memory details as needed.