なぜこの記憶を食べる人は本当に記憶を食べないのですか？

Unixサーバーでメモリ不足（OOM）の状況をシミュレートするプログラムを作成したいと思います。私はこの超シンプルなメモリイーターを作成しました：

#include <stdio.h>
#include <stdlib.h>

unsigned long long memory_to_eat = 1024 * 50000;
size_t eaten_memory = 0;
void *memory = NULL;

int eat_kilobyte()
{
    memory = realloc(memory, (eaten_memory * 1024) + 1024);
    if (memory == NULL)
    {
        // realloc failed here - we probably can't allocate more memory for whatever reason
        return 1;
    }
    else
    {
        eaten_memory++;
        return 0;
    }
}

int main(int argc, char **argv)
{
    printf("I will try to eat %i kb of ram\n", memory_to_eat);
    int megabyte = 0;
    while (memory_to_eat > 0)
    {
        memory_to_eat--;
        if (eat_kilobyte())
        {
            printf("Failed to allocate more memory! Stucked at %i kb :(\n", eaten_memory);
            return 200;
        }
        if (megabyte++ >= 1024)
        {
            printf("Eaten 1 MB of ram\n");
            megabyte = 0;
        }
    }
    printf("Successfully eaten requested memory!\n");
    free(memory);
    return 0;
}

それは定義されmemory_to_eatたのと同じだけのメモリを消費しますが、現在はちょうど50 GBのRAMです。メモリを1 MBずつ割り当て、それ以上割り当てられなかったポイントを正確に出力するので、どの最大値を取得できたかがわかります。

問題は、それが機能することです。物理メモリが1 GBのシステムでも。

topを確認すると、プロセスが50 GBの仮想メモリを消費し、常駐メモリは1 MB未満であることがわかります。本当にそれを消費するメモリイーターを作成する方法はありますか？

システム仕様：Linuxカーネル3.16（Debian）は、ほとんどの場合、オーバーコミットが有効になっていて（チェックアウトの方法がわからない）、スワップなしで仮想化されています。

あなたの場合はmalloc()実装が（を経由して、システムのカーネルからのメモリ要求sbrk()またはmmap()システムコール）を、カーネルだけがメモリを要求し、それはあなたのアドレス空間内に配置されるたことをメモします。実際にはまだそれらのページをマップしていません。

その後、プロセスが新しい領域内のメモリにアクセスすると、ハードウェアはセグメンテーション違反を認識し、その状態をカーネルに警告します。次に、カーネルは独自のデータ構造でページを検索し、そこにゼロページがあるはずであると判断して、ゼロページにマップし（おそらく最初にページキャッシュからページを追い出す）、割り込みから戻ります。あなたのプロセスはこれが起こったことを認識していません、カーネルの操作は完全に透過的です（カーネルが動作している間の短い遅延を除いて）。

この最適化により、システムコールは非常に迅速に戻ることができ、最も重要なのは、マッピングが行われるときにプロセスにリソースがコミットされるのを回避することです。これにより、プロセスは、通常の状況では決して必要としないかなり大きなバッファを予約できます。メモリを大量に消費する心配はありません。

したがって、メモリイーターをプログラムする場合は、割り当てるメモリを実際に使用する必要があります。そのためには、コードに1行追加するだけです。

int eat_kilobyte()
{
    if (memory == NULL)
        memory = malloc(1024);
    else
        memory = realloc(memory, (eaten_memory * 1024) + 1024);
    if (memory == NULL)
    {
        return 1;
    }
    else
    {
        //Force the kernel to map the containing memory page.
        ((char*)memory)[1024*eaten_memory] = 42;

        eaten_memory++;
        return 0;
    }
}

各ページ内の1バイト（X86では4096バイトを含む）に書き込むだけで十分です。これは、カーネルからプロセスへのすべてのメモリ割り当てがメモリページの粒度で行われるためです。これは、ハードウェアが小さい粒度でのページングを許可しないためです。

すべての仮想ページは、同じゼロ化された物理ページにマップされたコピーオンライトから始まります。物理ページを使い果たすには、各仮想ページに何かを書き込むことでダーティにすることができます。

rootとして実行している場合は、使用することができますmlock(2)またはmlockall(2)それらが割り当てられているとき汚れにそれらをせずに、ページアップカーネルワイヤーを持っています。（通常の非rootユーザーの場合、ulimit -l64kiBしかありません。）

他の多くの人が示唆したように、あなたが書いていない限り、Linuxカーネルは実際にはメモリを割り当てていないようです

OPが望んでいたことを実行するコードの改良版：

これは、整数を出力%ziするために使用する、memory_to_eatおよびeaten_memoryのタイプとのprintfフォーマット文字列の不一致も修正しsize_tます。食べるメモリサイズ（kiB単位）は、オプションでコマンドライン引数として指定できます。

グローバル変数を使用し、4kページではなく1kページ増加する乱雑なデザインは変更されていません。

#include <stdio.h>
#include <stdlib.h>

size_t memory_to_eat = 1024 * 50000;
size_t eaten_memory = 0;
char *memory = NULL;

void write_kilobyte(char *pointer, size_t offset)
{
    int size = 0;
    while (size < 1024)
    {   // writing one byte per page is enough, this is overkill
        pointer[offset + (size_t) size++] = 1;
    }
}

int eat_kilobyte()
{
    if (memory == NULL)
    {
        memory = malloc(1024);
    } else
    {
        memory = realloc(memory, (eaten_memory * 1024) + 1024);
    }
    if (memory == NULL)
    {
        return 1;
    }
    else
    {
        write_kilobyte(memory, eaten_memory * 1024);
        eaten_memory++;
        return 0;
    }
}

int main(int argc, char **argv)
{
    if (argc >= 2)
        memory_to_eat = atoll(argv[1]);

    printf("I will try to eat %zi kb of ram\n", memory_to_eat);
    int megabyte = 0;
    int megabytes = 0;
    while (memory_to_eat-- > 0)
    {
        if (eat_kilobyte())
        {
            printf("Failed to allocate more memory at %zi kb :(\n", eaten_memory);
            return 200;
        }
        if (megabyte++ >= 1024)
        {
            megabytes++;
            printf("Eaten %i  MB of ram\n", megabytes);
            megabyte = 0;
        }
    }
    printf("Successfully eaten requested memory!\n");
    free(memory);
    return 0;
}

ここで賢明な最適化が行われています。ランタイムは、使用するまで実際にはメモリを取得しません。

memcpyこの最適化を回避するには、単純なもので十分です。（callocそれでも、使用のポイントまでメモリ割り当てが最適化されることに気付くかもしれません。）

これについてはわかりませんが、私ができることの唯一の説明は、Linuxがコピーオンライトオペレーティングシステムであることです。1つを呼び出すとfork、両方のプロセスが同じ物理メモリをポイントします。メモリがコピーされるのは、1つのプロセスが実際にメモリに書き込む場合のみです。

ここでは、実際の物理メモリは、何かを書き込もうとしたときにのみ割り当てられると思います。を呼び出すsbrkかmmap、カーネルのメモリブックキープのみを更新します。実際のRAMは、実際にメモリにアクセスしようとしたときにのみ割り当てられます。