Tại sao bộ nhớ này không thực sự ăn bộ nhớ?

Tôi muốn tạo một chương trình mô phỏng tình huống hết bộ nhớ (OOM) trên máy chủ Unix. Tôi đã tạo ra bộ nhớ siêu đơn giản này:

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

Nó ăn nhiều bộ nhớ như được xác định trong memory_to_eatđó bây giờ chính xác là 50 GB RAM. Nó phân bổ bộ nhớ cho 1 MB và in chính xác điểm không thể phân bổ nhiều hơn, để tôi biết giá trị tối đa mà nó quản lý để ăn.

Vấn đề là nó hoạt động. Ngay cả trên một hệ thống có 1 GB bộ nhớ vật lý.

Khi tôi kiểm tra hàng đầu, tôi thấy rằng quá trình này chiếm 50 GB bộ nhớ ảo và chỉ dưới 1 MB bộ nhớ lưu trú. Có cách nào để tạo ra một bộ nhớ ăn mà thực sự tiêu thụ nó?

Thông số kỹ thuật hệ thống: Linux kernel 3.16 ( Debian ) rất có thể được kích hoạt vượt mức (không chắc chắn cách kiểm tra) mà không có trao đổi và ảo hóa.

Khi malloc()việc triển khai của bạn yêu cầu bộ nhớ từ kernel hệ thống (thông qua một cuộc gọi sbrk()hoặc mmap()hệ thống), kernel chỉ ghi chú rằng bạn đã yêu cầu bộ nhớ và vị trí của nó sẽ được đặt trong không gian địa chỉ của bạn. Nó không thực sự ánh xạ các trang đó .

Khi quá trình sau đó truy cập vào bộ nhớ trong vùng mới, phần cứng sẽ nhận ra lỗi phân đoạn và cảnh báo kernel về tình trạng này. Sau đó, kernel tìm kiếm trang trong cấu trúc dữ liệu của chính nó và thấy rằng bạn nên có một trang 0 ở đó, vì vậy nó ánh xạ trong một trang 0 (trước tiên có thể là một trang từ bộ đệm trang) và trả về từ ngắt. Quá trình của bạn không nhận ra rằng bất kỳ điều này đã xảy ra, hoạt động của hạt nhân hoàn toàn trong suốt (ngoại trừ độ trễ ngắn trong khi kernel thực hiện công việc của nó).

Tối ưu hóa này cho phép cuộc gọi hệ thống trở lại rất nhanh và quan trọng nhất là nó tránh mọi tài nguyên được cam kết cho quy trình của bạn khi ánh xạ được thực hiện. Điều này cho phép các quá trình dự trữ bộ đệm khá lớn mà chúng không bao giờ cần trong các trường hợp thông thường, mà không sợ ngấu nghiến quá nhiều bộ nhớ.

Vì vậy, nếu bạn muốn lập trình một bộ nhớ, bạn thực sự phải làm gì đó với bộ nhớ bạn phân bổ. Đối với điều này, bạn chỉ cần thêm một dòng vào mã của bạn:

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

Lưu ý rằng việc ghi vào một byte trong mỗi trang là hoàn toàn đủ (chứa 4096 byte trên X86). Đó là bởi vì tất cả việc cấp phát bộ nhớ từ kernel cho một tiến trình được thực hiện ở mức độ chi tiết của trang bộ nhớ, do đó, do phần cứng không cho phép phân trang ở mức độ chi tiết nhỏ hơn.

Tất cả các trang ảo bắt đầu sao chép trên bản ghi vào cùng một trang vật lý bằng không. Để sử dụng hết các trang vật lý, bạn có thể làm bẩn chúng bằng cách viết một cái gì đó lên từng trang ảo.

Nếu chạy bằng root, bạn có thể sử dụng mlock(2)hoặc mlockall(2)để nhân kernel nối các trang khi chúng được phân bổ mà không phải làm bẩn chúng. (người dùng không root bình thường ulimit -lchỉ có 64kiB.)

Như nhiều người khác đề xuất, có vẻ như nhân Linux không thực sự phân bổ bộ nhớ trừ khi bạn ghi vào nó

Một phiên bản cải tiến của mã, thực hiện những gì OP muốn:

Điều này cũng sửa lỗi chuỗi định dạng printf không khớp với các loại memory_to_eat và eaten_memory, sử dụng %ziđể in size_tcác số nguyên. Kích thước bộ nhớ để ăn, trong kiB, tùy chọn có thể được chỉ định là một dòng lệnh arg.

Thiết kế lộn xộn sử dụng các biến toàn cục và tăng 1k thay vì 4k trang là không thay đổi.

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

Một tối ưu hóa hợp lý đang được thực hiện ở đây. Thời gian chạy không thực sự có được bộ nhớ cho đến khi bạn sử dụng nó.

Một đơn giản memcpysẽ đủ để phá vỡ sự tối ưu hóa này. (Bạn có thể thấy rằng callocvẫn tối ưu hóa việc cấp phát bộ nhớ cho đến thời điểm sử dụng.)

Không chắc chắn về điều này nhưng lời giải thích duy nhất mà tôi có thể nghĩ là linux là một hệ điều hành sao chép trên ghi. Khi một người gọi forkcả hai quá trình trỏ đến cùng một bộ nhớ vật lý. Bộ nhớ chỉ được sao chép khi một quá trình thực sự VIẾT vào bộ nhớ.

Tôi nghĩ ở đây, bộ nhớ vật lý thực tế chỉ được phân bổ khi một người cố gắng viết một cái gì đó cho nó. Gọi điện thoại sbrkhoặc mmapcó thể chỉ cập nhật lưu giữ bộ nhớ của kernel. RAM thực tế chỉ có thể được phân bổ khi chúng ta thực sự cố gắng truy cập bộ nhớ.