S060 · OS Basics — Processes, Threads, Memory, FDs

"""
os_demo.py — Demonstrate FDs, processes, threads, and memory.
 
Run:
    python os_demo.py fdleak    # deliberately leak file descriptors
    python os_demo.py mem       # allocate memory, watch RSS grow
    python os_demo.py fork      # fork children, print PIDs
    python os_demo.py thread    # spawn threads, watch task list
"""
from __future__ import annotations
 
import os
import resource
import sys
import time
 
 
def show_limits() -> None:
    soft, hard = resource.getrlimit(resource.RLIMIT_NOFILE)
    print(f"[limits] pid={os.getpid()}  soft nofile={soft}  hard nofile={hard}")
 
 
def open_fd_count() -> int:
    """Count open file descriptors for this process via /proc."""
    try:
        return len(os.listdir(f"/proc/{os.getpid()}/fd"))
    except FileNotFoundError:
        # macOS: /proc doesn't exist; skip the count
        return -1
 
 
def fdleak() -> None:
    """Open new files without closing. Watch it hit EMFILE."""
    show_limits()
    files = []
    try:
        while True:
            f = open("/dev/null", "r")   # each open() grabs a new FD
            files.append(f)
            if len(files) % 100 == 0:
                print(f"[fdleak] opened={len(files)}  fds_reported={open_fd_count()}")
    except OSError as e:
        print(f"\n[fdleak] hit OS error at {len(files)} files: {e}")
        print(f"[fdleak] this is why servers set ulimit -n to 65535+ in prod")
 
 
def mem() -> None:
    """Grow RSS by appending to a bytearray."""
    show_limits()
    buf = bytearray()
    chunk = b"x" * (1024 * 1024)  # 1 MB
    for i in range(1, 501):
        buf += chunk
        if i % 50 == 0:
            rss_kb = int(open(f"/proc/{os.getpid()}/status").read().split("VmRSS:")[1].split()[0])
            print(f"[mem] appended {i} MB  RSS={rss_kb/1024:.1f} MB")
 
 
def fork_demo() -> None:
    """Show how fork() creates a child that inherits FDs."""
    print(f"[fork] parent pid={os.getpid()}  ppid={os.getppid()}")
    pid = os.fork()
    if pid == 0:
        # child
        print(f"[fork] child pid={os.getpid()}  ppid={os.getppid()}")
        print(f"[fork] child sees the same open FDs: {open_fd_count()}")
        os._exit(0)
    else:
        # parent
        print(f"[fork] parent spawned child pid={pid}")
        os.waitpid(pid, 0)
        print("[fork] child reaped")
 
 
def thread_demo() -> None:
    """Threads share memory + FDs. Verify with /proc/self/task/."""
    import threading
 
    def worker(i: int) -> None:
        time.sleep(0.3)
        print(f"  thread {i} tid={threading.get_ident()} sees fds={open_fd_count()}")
 
    print(f"[thread] main pid={os.getpid()}  fds={open_fd_count()}")
    ts = [threading.Thread(target=worker, args=(i,)) for i in range(4)]
    for t in ts: t.start()
    # /proc/self/task shows every kernel-level task (thread) in this process
    tasks = os.listdir(f"/proc/{os.getpid()}/task")
    print(f"[thread] /proc/self/task/ has {len(tasks)} entries → all my threads")
    for t in ts: t.join()
 
 
CMDS = {"fdleak": fdleak, "mem": mem, "fork": fork_demo, "thread": thread_demo}
 
if __name__ == "__main__":
    if len(sys.argv) < 2 or sys.argv[1] not in CMDS:
        print(f"usage: python os_demo.py [{'|'.join(CMDS)}]")
        sys.exit(1)
    CMDS[sys.argv[1]]()

# 1) Watch FDs leak until the kernel refuses to open more.
ulimit -n 256           # lower the soft limit for a quick demo
python os_demo.py fdleak
 
# 2) Watch RSS grow. In another terminal: watch -n1 'ps -o pid,rss,vsz,cmd -p $(pgrep -f os_demo)'
python os_demo.py mem
 
# 3) fork() a child; see PPID chain.
python os_demo.py fork
 
# 4) Threads visible in /proc/self/task/.
python os_demo.py thread