> ## Documentation Index
> Fetch the complete documentation index at: https://mintlify.com/leonardo02lobo/Memory-Monitor/llms.txt
> Use this file to discover all available pages before exploring further.

# Memory Monitoring

> Understanding how Memory Monitor reads and parses memory information from the Linux /proc filesystem

## Overview

Memory Monitor tracks system memory usage by reading data directly from the `/proc/meminfo` file, a virtual file provided by the Linux kernel that contains real-time memory statistics.

## How /proc/meminfo Works

The `/proc/meminfo` file is a virtual file that doesn't actually exist on disk. Instead, the Linux kernel generates its contents dynamically whenever a process reads it. This file provides a comprehensive snapshot of the system's current memory state.

> [!NOTE]
>
> The `/proc` filesystem is a pseudo-filesystem that provides an interface to kernel data structures. It's called "proc" because it was originally designed to provide information about processes.

## Memory Metrics Explained

Memory Monitor tracks five key memory metrics:

> **MemTotal**
>
> The total amount of usable RAM in the system (physical RAM minus reserved bits and kernel binary code). This value remains constant unless hardware changes occur.

> **MemFree**
>
> The amount of physical RAM that is completely unused by the system. This does NOT represent available memory, as it doesn't include memory used for buffers and cache that can be reclaimed.

> **Buffers**
>
> Memory used for temporary storage of raw disk blocks. This is relatively small and shouldn't get very large.

> **Cached**
>
> Memory used to cache files read from disk (page cache). The kernel can reclaim this memory when applications need it, making it effectively available.

> **MemUsed (Calculated)**
>
> The actual memory being used by applications and the kernel. This is calculated as:
>
> ```
> MemUsed = MemTotal - MemFree - Buffers - Cached
> ```
>
> This formula gives you the memory that is actively in use and cannot be easily reclaimed.

## Implementation Details

### Reading Memory Information

The `InformationMemory()` function reads and parses `/proc/meminfo` using Python's `pathlib` module:

```python memory_info.py theme={null}
def InformationMemory() -> str | None:
    information: str = pathlib.Path("/proc/meminfo").read_text()
    mem_free: int = 0
    mem_total: int = 0
    buffers: int = 0
    cached: int = 0

    if not information:
        return None
```

> [!NOTE]
>
> The function uses `pathlib.Path` for a modern, object-oriented approach to file handling. The `read_text()` method reads the entire file contents as a string.

### Parsing Strategy

The parser iterates through each line of `/proc/meminfo` and extracts only the metrics it needs:

```python memory_info.py theme={null}
information: list[str] = information.strip().splitlines()
for info in information:
    if (not info.startswith("MemTotal:") and 
        not info.startswith("MemFree:") and
        not info.startswith("Buffers:") and 
        not info.startswith("Cached:")):
        continue

    if info.startswith("MemTotal:"):
        mem_total: int = int(info.split()[1])
    elif info.startswith("MemFree:"):
        mem_free: int = int(info.split()[1])
    elif info.startswith("Buffers:"):
        buffers: int = int(info.split()[1])
    elif info.startswith("Cached:"):
        cached: int = int(info.split()[1])
```

This approach:

* **Splits the text into lines** using `splitlines()`
* **Filters for relevant metrics** using `startswith()` checks
* **Extracts values** by splitting on whitespace and taking the second element (index 1)
* **Converts to integers** for mathematical operations

> [!WARNING]
>
> The values in `/proc/meminfo` are in kilobytes (kB). Make sure to handle unit conversions appropriately if displaying in MB or GB.

### Calculating Memory Usage

The actual memory in use is calculated by subtracting reclaimable memory from the total:

```python memory_info.py theme={null}
mem_used: int = mem_total - mem_free - buffers - cached
```

This calculation gives you the memory that is actively being used by applications and the kernel, excluding memory that can be quickly freed if needed.

### Output Format

The function returns a formatted string with all memory metrics:

```python memory_info.py theme={null}
return f"Memoria Total: {mem_total} kB\nMemoria Libre: {mem_free} kB\nBuffers: {buffers} kB\nCached: {cached} kB\nMemoria Usada: {mem_used} kB"
```

## Key Design Decisions

> **Why not use psutil or other libraries?**
>
> Memory Monitor is designed to be lightweight with minimal dependencies. Reading from `/proc` directly eliminates external dependencies and provides full control over what data is collected.

> **Why filter only specific metrics?**
>
> `/proc/meminfo` contains dozens of memory metrics. By filtering for only the essential metrics, Memory Monitor minimizes processing time and keeps the output focused on the most relevant information.

> **Why calculate MemUsed instead of reading it?**
>
> `/proc/meminfo` doesn't provide a "MemUsed" field directly. The calculation `MemTotal - MemFree - Buffers - Cached` is the standard way to determine actual memory usage on Linux systems.

## Example /proc/meminfo Output

Here's what a typical `/proc/meminfo` file looks like:

```
MemTotal:       16384000 kB
MemFree:         8192000 kB
MemAvailable:   12288000 kB
Buffers:          512000 kB
Cached:          3072000 kB
SwapCached:            0 kB
...
```

Memory Monitor extracts the highlighted metrics and calculates:

```
MemUsed = 16384000 - 8192000 - 512000 - 3072000 = 4608000 kB
```

## Next Steps

> **[Process Analysis](https://mintlify.com/leonardo02lobo/Memory-Monitor/concepts/process-analysis.md)**
>
> Learn how Memory Monitor identifies which processes are consuming the most memory


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.