Neden bu hafıza yiyen gerçekten hafıza yemiyor?

Unix sunucusunda bellek yetersiz (OOM) durumunu simüle edecek bir program oluşturmak istiyorum. Bu süper basit bellek yiyiciyi yarattım:

#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;
}

Şu memory_to_eatanda tam olarak 50 GB RAM olan tanımlandığı kadar yer kaplıyor. 1 MB bellek ayırır ve tam olarak daha fazla ayırmak başarısız olduğu noktaya yazdırır, böylece hangi maksimum değeri yemek başardı biliyorum.

Sorun şu ki, işe yarıyor. 1 GB fiziksel belleğe sahip bir sistemde bile.

En üste baktığımda, işlemin 50 GB sanal bellek ve sadece 1 MB'den az yerleşik bellek yediğini görüyorum. Gerçekten tüketen bir bellek yiyici oluşturmanın bir yolu var mı?

Sistem özellikleri: Linux çekirdeği 3.16 ( Debian ), büyük olasılıkla aşırı taahhüt etkinken (nasıl kontrol edileceğinden emin değilim) takas ve sanallaştırılmış.

Senin ne zaman malloc()uygulanması (bir yoluyla sistem çekirdeğinden bellek istekleri sbrk()veya mmap()sistem çağrısı), çekirdek yalnızca bellek talep etmiş ve adres alanı içinde yerleştirilmek üzere olduğu bir not yapar. Henüz bu sayfaları eşlemiyor .

İşlem daha sonra yeni bölge içindeki belleğe eriştiğinde, donanım bir segmentasyon hatasını tanır ve çekirdeği duruma uyarır. Çekirdek daha sonra sayfayı kendi veri yapılarında arar ve orada sıfır sayfanız olması gerektiğini bulur, böylece sıfır sayfada eşlenir (muhtemelen ilk olarak sayfa önbelleğinden bir sayfa çıkarır) ve kesmeden geri döner. İşleminiz, bunların hiçbirinin gerçekleşmediğini, çekirdek işleminin mükemmel derecede şeffaf olduğunu fark etmez (çekirdek işini yaparken kısa gecikme hariç).

Bu optimizasyon, sistem çağrısının çok hızlı bir şekilde geri dönmesini sağlar ve en önemlisi, eşleme yapıldığında tüm kaynakların işleminize adanmasını önler. Bu, işlemlerin normal şartlar altında asla ihtiyaç duymadıkları oldukça büyük tamponları ayırmasına izin verir, çok fazla bellek artırma korkusu olmadan.

Yani, bir bellek yiyiciyi programlamak istiyorsanız, kesinlikle tahsis ettiğiniz bellekle bir şeyler yapmanız gerekir. Bunun için kodunuza yalnızca tek bir satır eklemeniz gerekir:

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;
    }
}

Her sayfada tek bir bayta (X86'da 4096 bayt içeren) yazmanın mükemmel olduğunu unutmayın. Bunun nedeni, çekirdekten bir sürece tüm bellek ayırma işlemlerinin bellek sayfası ayrıntı düzeyinde yapılmasıdır; bu da, daha küçük ayrıntı düzeylerinde sayfalamaya izin vermeyen donanım nedeniyle.

Tüm sanal sayfalar, aynı sıfırlanmış fiziksel sayfayla eşlenen yazma üzerine kopyalamaya başlar. Fiziksel sayfaları kullanmak için, her sanal sayfaya bir şeyler yazarak onları kirletebilirsiniz.

Root olarak çalışan varsa, kullanabilir mlock(2)veya mlockall(2)kirli onları gerek kalmadan, onlar ayrılan sayfalarla kadar çekirdek teli olması. (normal root olmayan kullanıcıların ulimit -l64KB'si vardır.)

Diğerlerinin de belirttiği gibi, Linux çekirdeği, siz yazmadığınız sürece belleği gerçekten ayırmıyor gibi görünüyor

OP'nin istediği şeyi yapan kodun geliştirilmiş bir sürümü:

Bu aynı zamanda printf biçimindeki dize uyumsuzluklarını, tamsayıları %ziyazdırmak için memory_to_eat ve eaten_memory türleriyle düzeltir size_t. KiB cinsinden yenilecek bellek boyutu isteğe bağlı olarak bir komut satırı argümanı olarak belirtilebilir.

Global değişkenleri kullanan ve 4k sayfalar yerine 1k büyüyen dağınık tasarım değişmez.

#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;
}

Burada mantıklı bir optimizasyon yapılıyor. Çalışma zamanı aslında değil kazanmak kullanana kadar bellek.

memcpyBu optimizasyonu atlatmak için bir basit yeterli olacaktır. ( callocKullanım noktasına kadar bellek ayırmayı yine de optimize ettiğini görebilirsiniz .)

Bu konuda emin değilim ama yapabileceğim tek açıklama linux'un bir kopyala-yaz işletim sistemi olmasıdır. Biri forkher iki işlemi çağırdığında aynı fiziksel belleği gösterir. Bellek yalnızca bir işlem belleğe YAZIYOR yazıldığında kopyalanır.

Bence burada, gerçek fiziksel bellek sadece biri ona bir şeyler yazmaya çalıştığında tahsis edilir. Arayarak sbrkveya mmapyalnızca çekirdeğin bellek defteri tutmasını güncelleyebilir. Gerçek RAM yalnızca belleğe gerçekten erişmeye çalıştığımızda tahsis edilebilir.