[lkml]   [1998]   [Aug]   [16]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
Messages in this thread
    SubjectRe: A true story of a crash.
       Date: 	Sun, 16 Aug 1998 08:19:36 -0400 (EDT)
    From: "Stephen M. Benoit" <>

    Am I missing the point? I was under the impression that there is a
    well-defined behavior when a Un*x reaches memory resource limits.
    Additional requests for resources are simply denied: currently
    executing processes don't get axed until they segfault, get signalled
    or exit().

    It's very simple --- it's called swap space overcommit. The issue here
    is that with any modern VM system, it's possible to be very efficient
    with how you use data pages. For example, when a process forks, you
    don't need to copy all of its pages; instead you can mark them as "copy
    on write", and only duplicate its pages if they are actually modified.

    The problem with using stract allocation is that you will start
    returning ENOMEM while there is still plenty of memory available, since
    most of the time the maximum theoretical memory that might be used by a
    process (if you have to allocate pages for all of itw COW pages, etc.)
    is nil. For example, if you have a huge executable, but the way you use
    the program, most of it never gets used, a strict allocation system
    might not let you run the executable, even though there might be plenty
    of space and no problems since the executable might not use all of its
    text pages (especially true with shared libraries). Strict allocation
    demands that you reserve a page for each processes's use of a text or
    shared library memory page, since there's a chance it might get
    duplicated because of debugger setting a break point (for example).

    The problem with overcommit is that you don't necessary know when a user
    space process calls malloc(), fork(), etc. whether or not you're going
    to run into trouble, since the pages don't actually get allocated until
    a page fault happens (either because the page needs to be paged in for
    the first time, or because a COW page needs to be copied).

    I've tried using a system with strict allocation, and it runs out of
    memory *really* quickly. In fact, it usually runs out of memory so
    quickly that it's frequently not very useful.

    - Ted

    To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
    the body of a message to
    Please read the FAQ at

     \ /
      Last update: 2005-03-22 13:44    [W:0.019 / U:301.444 seconds]
    ©2003-2016 Jasper Spaans. hosted at Digital OceanAdvertise on this site