内存lru file比cache大的一种场景介绍

static void lru_lazyfree_fn(struct page *page, struct lruvec *lruvec)
{
        if (PageAnon(page) && PageSwapBacked(page) &&
            !PageSwapCache(page) && !PageUnevictable(page)) {
                bool active = PageActive(page);

                del_page_from_lru_list(page, lruvec,
                                       LRU_INACTIVE_ANON + active); //这里从LRU的active anon移除
                ClearPageActive(page);
                ClearPageReferenced(page);
                /*
                 * lazyfree pages are clean anonymous pages. They have
                 * SwapBacked flag cleared to distinguish normal anonymous
                 * pages
                 */
                ClearPageSwapBacked(page);
                add_page_to_lru_list(page, lruvec, LRU_INACTIVE_FILE);//把page加到lru INACTIVE FILE上

                __count_vm_events(PGLAZYFREE, hpage_nr_pages(page));
                count_memcg_page_event(page, PGLAZYFREE);
                update_page_reclaim_stat(lruvec, 1, 0);
        }
}

# cat madvise-sample.c
#include <signal.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdio.h>
#include <sys/mman.h>
#include <unistd.h>

bool cont = true;
//static const ptrdiff_t len = 1 << 25; // 32 MB
static const ptrdiff_t len = (1*1024*1024*1024);
void
handle_signal(int sig)
{
        if (sig != SIGINT) {
                return;
        }

        cont ^= true;
}

void
wait()
{
        cont = false;
        signal(SIGINT, handle_signal);

        printf("CTRL+C to continue\n");

        while (!cont) {
                sleep(1);
        }
}

int
main(void)
{
        char *start, *end;
        void* pb;

        pb = sbrk(0);
        if (pb == (void*)-1) {
                perror("sbrk");
                return 1;
        }

        start = (char*)pb;
        end = start + len;

        // "allocate" mem by increasing the program break
        //
        if (!~brk(end)) {
                perror("brk");
                return 1;
        }
        printf("allocate mem\r\n");
        wait();

        // "touch" the memory so that we get it really utilized - at this point,
        // we should see the faults taking place, and both RSS and active anon
        // going up
        //
        for (; start < end;) {
                *(start++) = 123;
        }
        printf("using allocate mem\r\n");
        wait();

        // let the kernel know that we don't really need half of the memory we
        // allocated anymore - while this will not change RSS, it'll definitely
        // change active and inactive.
        //
/*        if (!~madvise(pb + (len >> 1), (len >> 1), MADV_FREE)) {
                perror("madvise");
                return 1;
        }*/
        if (!~madvise(pb  , len, MADV_FREE)) {
                perror("madvise");
                return 1;
        }

        printf("madvise MADV_FREE mem\r\n");

        wait();

        return 0;
}

compile it
gcc -O2 -static -o sample ./madvise-sample.c

run it in a terminal that has the current proc in a cgroup
mkdir /sys/fs/cgroup/memory/test
echo $$ > /sys/fs/cgroup/memory/test/cgroup.procs
./sample

in another terminal, observe memory.stat for that cgroup
cat /sys/fs/cgroup/memory/test/memory.stat

use CTRL+C to make sample advance - see memory.stat as you do it.

#include <stdio.h>
#include <stdlib.h>
#include <sys/mman.h>
#include <unistd.h>

#define SIZE_3GB (3ull * 1024 * 1024 * 1024)

int main() {
    void *addr = mmap(NULL, SIZE_3GB, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
    if (addr == MAP_FAILED) {
        perror("mmap");
        exit(1);
    }


    for (size_t i = 0; i < SIZE_3GB; i += sysconf(_SC_PAGESIZE)) {
        ((char *)addr)[i] = 42;
    }
    printf("begin sleep\r\n");
    sleep(20);
    printf("end sleep\r\n");

    if (madvise(addr, SIZE_3GB, MADV_FREE) == -1) {
        perror("madvise");
        exit(1);
    }


    while (1) {
        sleep(1);
    }

    return 0;
}
~