Estoy pegando un código aquí que usa boost iostream para mmap y luego escribe en el archivo asignado:

typedef unordered_map<int, string> work;

    int main()
    {

            work d;
            d[0] = "a";

            boost::iostreams::mapped_file_params  params;
            params.path = "map.dat";
            params.new_file_size = 1000000000;
            params.mode = (std::ios_base::out | std::ios_base::in);
            boost::iostreams::mapped_file  mf;
            mf.open(params);
            work* w = static_cast<work*>((void*)mf.data());
            w[0] = d;
            for(int i=1; i <1000000000 ;++i)
            {
                    w->insert(std::make_pair(i, "abcdef"));
            }
            mf.close();

    }

Cuando ejecuté esto en mi caja centos 6 con 8 procesadores y 16 GB de RAM, observé lo siguiente:

Cuando los datos se insertaban en el archivo mapeado de memoria, RES (desde el comando superior) aumentaba continuamente y alcanzaba hasta 14 GB. Tenía la impresión de que cuando mapeo un archivo VIRT aumentará y no RES. Entonces, ¿es que cuando escribimos en el archivo mmap, primero se escribe en la memoria y luego se guarda en el disco? ¿O hay algún buffer intermedio / caché utilizado?

Con la ayuda del comando "gratis", también observé que después de que el uso de la memoria alcanza los 16 GB, se usan los buffers. Aquí hay algunas instantáneas de comando libre en diferentes momentos cuando se estaba ejecutando el código anterior:

            total       used       free     shared    buffers     cached
Mem:      16334688   10530380    5804308          0     232576    9205532
-/+ buffers/cache:    1092272   15242416
Swap:     18579448     348020   18231428

            total       used       free     shared    buffers     cached
Mem:      16334688   13594208    2740480          0     232608    9205800
-/+ buffers/cache:    4155800   12178888
Swap:     18579448     348020   18231428

            total       used       free     shared    buffers     cached
Mem:      16334688   15385944     948744          0     232648    9205808
-/+ buffers/cache:    5947488   10387200
Swap:     18579448     348020   18231428

            total       used       free     shared    buffers     cached
Mem:      16334688   16160368     174320          0     204940    4049224
-/+ buffers/cache:   11906204    4428484
Swap:     18579448     338092   18241356

            total       used       free     shared    buffers     cached
Mem:      16334688   16155160     179528          0     141584    2397820
-/+ buffers/cache:   13615756    2718932
Swap:     18579448     338092   18241356

            total       used       free     shared    buffers     cached
Mem:      16334688   16195960     138728          0       5440      17556
-/+ buffers/cache:   16172964     161724
Swap:     18579448     572052   18007396

¿Qué significa este comportamiento?

Tomó mucho tiempo escribir datos en un archivo mapeado en memoria en comparación con escribir en la memoria. ¿Cuál es la razón para esto?

Quería usar el mapeo de memoria para reducir el uso de RES mientras trato con grandes datos. Pero no parece funcionar de esa manera. Quería mantener todos los datos en los archivos de memoria asignados y volver a leerlos cuando fuera necesario.

¿Estoy usando la asignación de memoria de forma incorrecta? ¿O esa es la forma en que se comporta?