เหตุใดหน่วยความจำนี้จึงไม่กินหน่วยความจำจริงๆ

ฉันต้องการสร้างโปรแกรมที่จะจำลองสถานการณ์ out-of-memory (OOM) บนเซิร์ฟเวอร์ Unix ฉันสร้างหน่วยความจำที่กินง่ายสุด ๆ นี้:

#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ซึ่งตอนนี้เป็น RAM 50 GB มันจัดสรรหน่วยความจำ 1 MB และพิมพ์จุดที่มันไม่สามารถจัดสรรได้มากขึ้นดังนั้นฉันจึงรู้ว่ามันคุ้มค่าที่จะกินมากที่สุด

ปัญหาคือมันใช้งานได้ แม้แต่ในระบบที่มีหน่วยความจำกายภาพ 1 GB

เมื่อฉันตรวจสอบด้านบนฉันเห็นว่ากระบวนการกินหน่วยความจำเสมือน 50 GB และมีหน่วยความจำภายในน้อยกว่า 1 MB มีวิธีการสร้างหน่วยความจำที่กินมันจริง ๆ หรือไม่?

รายละเอียดของระบบ: Linux kernel 3.16 ( Debian ) เป็นไปได้มากที่สุดเมื่อเปิดใช้งาน overcommit (ไม่แน่ใจว่าจะตรวจสอบได้อย่างไร) โดยไม่มีการสลับและการจำลองเสมือน

เมื่อmalloc()การใช้งานของคุณร้องขอหน่วยความจำจากเคอร์เนลระบบ (ผ่านการโทรsbrk()หรือการmmap()เรียกใช้ระบบ) เคอร์เนลจะทำหมายเหตุว่าคุณได้ร้องขอหน่วยความจำแล้วและวางไว้ที่ไหนภายในพื้นที่ที่อยู่ของคุณ มันยังไม่ได้แมปหน้าเหล่านั้นจริงๆจริงๆ

เมื่อกระบวนการเข้าถึงหน่วยความจำภายในภูมิภาคใหม่ในภายหลังฮาร์ดแวร์จะรับรู้ข้อผิดพลาดการแบ่งส่วนและแจ้งเตือนเคอร์เนลให้เข้ากับสภาพ เคอร์เนลค้นหาหน้าในโครงสร้างข้อมูลของตัวเองและพบว่าคุณควรมีหน้าศูนย์ดังนั้นจึงแมปในหน้าศูนย์ (อาจเป็นหน้าแรก evicting หน้าจากหน้าแคช) และผลตอบแทนจากการขัดจังหวะ กระบวนการของคุณไม่ทราบว่ามีสิ่งใดเกิดขึ้นการดำเนินการของเมล็ดนั้นโปร่งใสอย่างสมบูรณ์ (ยกเว้นการหน่วงเวลาสั้น ๆ ในขณะที่เคอร์เนลทำงาน)

การปรับให้เหมาะสมนี้ช่วยให้การเรียกใช้ระบบกลับมาอย่างรวดเร็วและที่สำคัญที่สุดคือมันหลีกเลี่ยงทรัพยากรใด ๆ ที่จะมุ่งมั่นในกระบวนการของคุณเมื่อทำการแมป วิธีนี้ช่วยให้กระบวนการจองบัฟเฟอร์ที่ค่อนข้างใหญ่ซึ่งพวกเขาไม่ต้องการภายใต้สถานการณ์ปกติโดยไม่ต้องกลัวการกลืนหน่วยความจำมากเกินไป

ดังนั้นหากคุณต้องการตั้งโปรแกรมการกินหน่วยความจำคุณจะต้องทำอะไรบางอย่างกับหน่วยความจำที่คุณจัดสรร สำหรับสิ่งนี้คุณจะต้องเพิ่มบรรทัดเดียวในรหัสของคุณ:

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

โปรดทราบว่ามันสมบูรณ์เพียงพอที่จะเขียนไปยังหนึ่งไบต์ภายในแต่ละหน้า (ซึ่งมี 4096 ไบต์บน X86) นั่นเป็นเพราะการจัดสรรหน่วยความจำทั้งหมดจากเคอร์เนลไปยังโปรเซสนั้นทำที่หน้าหน่วยความจำอย่างละเอียดซึ่งก็คือในทางกลับกันเนื่องจากฮาร์ดแวร์ที่ไม่อนุญาตให้ใช้การเพจที่มีขนาดเล็กกว่า

หน้าเสมือนทั้งหมดเริ่มต้นการทำสำเนาการเขียนเพื่อแมปไปยังหน้าฟิสิคัลที่เป็นศูนย์เดียวกัน หากต้องการใช้ฟิสิคัลเพจคุณสามารถสกปรกได้โดยการเขียนบางสิ่งลงในเพจเสมือนแต่ละเพจ

หากทำงานในฐานะรูทคุณสามารถใช้mlock(2)หรือmlockall(2)ให้เคอร์เนลวางสายเมื่อเพจถูกจัดสรรโดยไม่ต้องทำให้สกปรก (ผู้ใช้ที่ไม่ใช่รูทปกติมีulimit -lเพียง 64kiB เท่านั้น)

ตามที่คนอื่น ๆ แนะนำไว้ดูเหมือนว่าเคอร์เนล Linux จะไม่จัดสรรหน่วยความจำจริงๆเว้นแต่คุณจะเขียนลงไป

รหัสปรับปรุงรุ่นซึ่งทำในสิ่งที่ OP ต้องการ:

สิ่งนี้ยังแก้ไขสตริงรูปแบบ printf ที่ไม่ตรงกันกับประเภท memory_to_eat และ eaten_memory โดยใช้%ziเพื่อพิมพ์size_tจำนวนเต็ม ขนาดหน่วยความจำที่จะกินเป็น kiB สามารถระบุหรือไม่ก็ได้ว่าเป็นบรรทัดคำสั่ง arg

การออกแบบที่ยุ่งเหยิงโดยใช้ตัวแปรทั่วโลกและเพิ่มขึ้น 1k แทนที่จะเป็น 4k หน้าไม่มีการเปลี่ยนแปลง

#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ยังคงปรับการจัดสรรหน่วยความจำให้เหมาะสมจนกว่าจะถึงจุดใช้งาน)

ไม่แน่ใจเกี่ยวกับอันนี้ แต่คำอธิบายเดียวที่ฉันทำได้คือลินุกซ์เป็นระบบปฏิบัติการแบบคัดลอก - เขียน - เขียน เมื่อหนึ่งเรียกforkกระบวนการทั้งสองชี้ไปที่หน่วยความจำทางกายภาพเดียวกัน หน่วยความจำจะถูกคัดลอกเมื่อกระบวนการเดียวจริงเขียนไปยังหน่วยความจำ

ฉันคิดว่าที่นี่หน่วยความจำกายภาพจริงถูกจัดสรรเมื่อพยายามเขียนบางสิ่งเท่านั้น การโทรsbrkหรือmmapอัปเดตหน่วยความจำของเคอร์เนลเก็บไว้อย่างดีเท่านั้น RAM จริงอาจได้รับการจัดสรรเมื่อเราพยายามเข้าถึงหน่วยความจำเท่านั้น