When debugging memory issues or optimizing applications, developers often need more than just the current memory footprint. The peak memory usage reveals critical information about worst-case scenarios and potential memory leaks.

The /proc filesystem provides detailed memory statistics through the status file:

cat /proc/[PID]/status | grep VmHWM

VmHWM (High Water Mark) shows the peak physical memory usage. For example:

VmHWM:   12568 kB

For monitoring peaks within specific time windows, consider these approaches:

# Sample bash script to track memory peaks
while true; do
  ps -p $PID -o %mem= >> mem_log.txt
  sleep 1
done

For more sophisticated monitoring, these tools offer detailed peak memory tracking:

• Valgrind massif: Heap profiler with peak snapshots
• smem: Reports USS/PSS/RSS including peaks
• atop: Historical process memory monitoring

Here's how to implement peak memory tracking in a Python application:

import resource
import time

def get_peak_memory():
    return resource.getrusage(resource.RUSAGE_SELF).ru_maxrss

# Main application
for i in range(5):
    large_list = [0] * 1000000 * i
    print(f"Current peak memory: {get_peak_memory()} KB")
    time.sleep(1)

For native applications, consider this instrumentation approach:

#include 
#include 

void log_peak_memory() {
    struct rusage usage;
    getrusage(RUSAGE_SELF, &usage);
    std::cout << "Peak memory: " << usage.ru_maxrss << " KB\n";
}

// Usage in critical sections
void memory_intensive_operation() {
    // ... operation code ...
    log_peak_memory();
}

When implementing peak memory tracking:

• Account for memory fragmentation effects
• Consider using memory cgroups for containerized environments
• Monitor both virtual and physical memory peaks
• Correlate memory peaks with application events

When debugging or optimizing applications, knowing the peak memory consumption of a process is often more valuable than its current memory footprint. Tools like top and ps only show real-time memory usage, but don't track historical maximums.

The Linux kernel provides several mechanisms to track memory usage:

// Check VmPeak in /proc/[pid]/status
cat /proc/$(pidof your_process)/status | grep VmPeak

// Alternative using pmap
pmap -x $(pidof your_process) | tail -1

For continuous monitoring over time, consider these approaches:

# Sample script to log memory usage over time
while true; do
  grep VmPeak /proc/$(pidof your_process)/status >> memory.log
  sleep 1
done

# Using valgrind for detailed profiling
valgrind --tool=massif --massif-out-file=massif.out ./your_program
ms_print massif.out

For containerized environments or more precise control:

# Create memory cgroup
cgcreate -g memory:my_group
echo $(pidof your_process) > /sys/fs/cgroup/memory/my_group/cgroup.procs

# Check peak usage
cat /sys/fs/cgroup/memory/my_group/memory.max_usage_in_bytes

For developers needing portable solutions:

// Python example using psutil
import psutil
p = psutil.Process(pid)
print(f"Peak memory: {p.memory_info().peak_wset if hasattr(p.memory_info(), 'peak_wset') else 'N/A'}")

// C example using getrusage()
#include 
struct rusage usage;
getrusage(RUSAGE_SELF, &usage);
printf("Peak RAM: %ld KB\n", usage.ru_maxrss);