为什么我的 Linux 没有执行惰性 memory 分配？

Question

I'm practicing to use the Lazy Allocation and the Demand Paging policies of Linux.

I want a buffer that I allocated by mmap() occupy NO physical memory until I really write something to it. Further more, I want it gradually enlarge(use more physical memory) with a step size of the swap page size(eg 4K) of Linux along with I'm writing continuously from its head to the tail.

According to some docs and searchings , it should NOT enlarge if there be only reading access on it, but the reality I observed in a experiment does NOT like this.

To test this, I coded a program as following, and watched the memory status by top shell command when it running.

constexpr size_t BUF_SIZE = 1024 * 1024 * 1024;

int main( int argc, char** argv ) {
    auto shm_pt = mmap( NULL, BUF_SIZE, PROT_READ | PROT_WRITE,
                        MAP_SHARED | MAP_ANONYMOUS, -1, 0 );
    if( shm_pt == MAP_FAILED ) {
        std::cerr << "mmap error:" << shm_pt;
        exit( EXIT_FAILURE );
    };

    bool full_zero = true;
    uint8_t* pc = reinterpret_cast<uint8_t*>( shm_pt );

    constexpr size_t STEP_SIZE = 1024 * 1024;
    for( size_t j = 0; j < BUF_SIZE / STEP_SIZE; ++j ) {
        this_thread::sleep_for( 100ms );
        size_t base = j * STEP_SIZE;
        std::cerr << "Reading from " << base / 1024 / 1024 << "M..." << endl;

        for( size_t i = 0; i < STEP_SIZE; ++i )
            full_zero = full_zero && pc[ base + i ] == 0;
    }

    if( !full_zero )
        std::cerr << "The buffer has not been initialized with full zeros!";

    for( size_t j = 0; j < BUF_SIZE / STEP_SIZE; ++j ) {
        this_thread::sleep_for( 100ms );
        size_t base = j * STEP_SIZE;
        std::cerr << "Writing to " << base / 1024 / 1024 << "M..." << endl;

        for( size_t i = 0; i < STEP_SIZE; ++i )
            pc[ base + i ] = 'c';
    }

    munmap( shm_pt, BUF_SIZE );
    return EXIT_SUCCESS;
};

What I observed is that the physical memory used by my app is growing gradually along with the Reading operation not with Writing op!

What is going wrong? Maybe my comprehension is wrong?

Any hints will be appreciated, Thanks!!!

Answer 1

I got it!

In the searching content I pasted, that man used a MAP_PRIVATE flag to mmap() as argument, while I used MAP_SHARED .

It looks like that if a buffer is being shared between processes, a READING operation also results real memory allocation!