vm_map.h

#ifndef INTERNAL_VM_MAP_H
#define INTERNAL_VM_MAP_H
#include "ruby/internal/config.h"
#include <stddef.h>             /* for size_t */
#include "ruby/internal/stdbool.h" /* for bool */
 
#ifdef HAVE_SYS_MMAN_H
# include <sys/mman.h>
#endif
#ifdef HAVE_ERRNO_H
# include <errno.h>             /* for errno, EAGAIN */
#endif
 
// On Solaris, madvise() is NOT declared for SUS (XPG4v2) or later,
// but MADV_* macros are defined when __EXTENSIONS__ is defined.
#ifdef NEED_MADVICE_PROTOTYPE_USING_CADDR_T
#include <sys/types.h>
extern int madvise(caddr_t, size_t, int);
#endif
 
/* zeroed_out (optional) reports whether the range now reads as all zero.  That needs an
 * advice which discards the pages outright -- only Linux's MADV_DONTNEED, and only on a
 * private anonymous mapping, which the caller must know: a private file mapping reverts
 * to the file's contents instead.  MADV_FREE may or may not drop the old contents, and
 * MADV_FREE_REUSABLE, the BSD MADV_DONTNEED and MEM_RESET keep them, so those all report
 * false, as does a failed call. */
 
// Reduces RSS lazily if possible, otherwise does it immediately. Keeps the mapping.
static inline void
rb_vm_map_reusable_lazy(void *addr, size_t len, int advice, bool *zeroed_out)
{
    if (zeroed_out) *zeroed_out = false;
#ifdef __wasi__
    /* WebAssembly doesn't support madvise. */
#elif defined(VM_CHECK_MODE) && VM_CHECK_MODE > 0 && defined(MADV_DONTNEED)
    if (!advice) advice = MADV_DONTNEED;
    int err = madvise(addr, len, advice);
# ifdef __linux__
    if (zeroed_out) *zeroed_out = (err == 0 && advice == MADV_DONTNEED);
# else
    (void)err;
# endif
#elif defined(MADV_FREE_REUSABLE)
    /* Darwin / macOS / iOS.  Drops phys_footprint; pages stay in resident_size
     * until the kernel reclaims them.  Retry on EAGAIN. */
    if (!advice) advice = MADV_FREE_REUSABLE;
    while (madvise(addr, len, advice) == -1 && errno == EAGAIN);
#elif defined(MADV_FREE)
    /* Recent Linux. */
    if (!advice) advice = MADV_FREE;
    madvise(addr, len, advice);
#elif defined(MADV_DONTNEED)
    /* Old Linux. */
    if (!advice) advice = MADV_DONTNEED;
    madvise(addr, len, advice);
#elif defined(POSIX_MADV_DONTNEED)
    /* Solaris. */
    if (!advice) advice = POSIX_MADV_DONTNEED;
    posix_madvise(addr, len, advice);
#elif defined(_WIN32)
    VirtualAlloc(addr, len, MEM_RESET, PAGE_READWRITE);
#endif
}
 
// Reduces RSS immediately if possible, otherwise does it lazily. Keeps the mapping.
// See rb_vm_map_reusable_lazy for zeroed_out.
static inline void
rb_vm_map_reusable_immediate(void *addr, size_t len, int advice, bool *zeroed_out)
{
    if (zeroed_out) *zeroed_out = false;
#ifdef __wasi__
    /* WebAssembly doesn't support madvise. */
#elif defined(MADV_FREE_REUSABLE)
    /* The most aggressive option is MADV_FREE_REUSABLE — same as _lazy.  It drops
     * phys_footprint immediately.  Retry on EAGAIN. */
    if (!advice) advice = MADV_FREE_REUSABLE;
    while (madvise(addr, len, advice) == -1 && errno == EAGAIN);
#elif defined(MADV_DONTNEED)
    /* Linux: kernel discards physical pages immediately; next touch
     * zero-faults and RSS drops at once. */
    if (!advice) advice = MADV_DONTNEED;
    int err = madvise(addr, len, advice);
# ifdef __linux__
    if (zeroed_out) *zeroed_out = (err == 0 && advice == MADV_DONTNEED);
# else
    (void)err;
# endif
#elif defined(POSIX_MADV_DONTNEED)
    if (!advice) advice = POSIX_MADV_DONTNEED;
    posix_madvise(addr, len, advice);
#elif defined(_WIN32)
    // Does not reduce working set immediately. We would need 2 system calls to do this.
    VirtualAlloc(addr, len, MEM_RESET, PAGE_READWRITE);
#endif
}
 
/* Re-acquire pages previously given back. Only needed for certain platforms. */
static inline void
rb_vm_map_reuse(void *addr, size_t len)
{
#if defined(MADV_FREE_REUSE)
    /* Darwin: mandatory handshake with MADV_FREE_REUSABLE.  Retry on EAGAIN. */
    while (madvise(addr, len, MADV_FREE_REUSE) == -1 && errno == EAGAIN);
#endif
    /* Linux/Windows/wasi: no-op (fault re-materializes zero-filled pages). */
}
 
#endif /* INTERNAL_VM_MAP_H */