Como preencher espaço de memória virtual no linux usando apenas um único arquivo de imagem?

Question

Então eu estou preso aqui ... Eu tentei usar o mmap (), mas ele não vai manter os arquivos na memória, a menos que eles estejam sendo usados por algo que eu acredito? Aqui está o código:

/* For the size of the file. */
#include <sys/stat.h>
/* This contains the mmap calls. */
#include <sys/mman.h> 
/* These are for error printing. */
#include <errno.h>
#include <string.h>
#include <stdarg.h>
/* This is for open. */
#include <fcntl.h>
#include <stdio.h>
/* For exit. */
#include <stdlib.h>
/* For the final part of the example. */
#include <ctype.h>

/* "check" checks "test" and prints an error and exits if it is
true. */

static void
check (int test, const char * message, ...)
{
if (test) {
    va_list args;
    va_start (args, message);
    vfprintf (stderr, message, args);
    va_end (args);
    fprintf (stderr, "\n");
    exit (EXIT_FAILURE);
}
}

int main ()
{
/* The file descriptor. */
int fd;
/* Information about the file. */
struct stat s;
int status;
size_t size;
/* The file name to open. */
const char * file_name = "MentalClarity.png";
/* The memory-mapped thing itself. */
const char * mapped[200000];
int i;
int j;

/* Open the file for reading. */
fd = open ("me.c", O_RDONLY);
check (fd < 0, "open %s failed: %s", file_name, strerror (errno));

/* Get the size of the file. */
status = fstat (fd, & s);
check (status < 0, "stat %s failed: %s", file_name, strerror (errno));
size = s.st_size;

/* Memory-map the file. */
for(j=1;j<=200000;j++){
mapped[j] = mmap (NULL, size, PROT_READ, 0, fd, 0);
check (mapped == MAP_FAILED, "mmap %s failed: %s",
       file_name, strerror (errno));
}    

int value=0;
while(value!=1){
printf("Enter 1 to exit");
scanf("%d",&value);
}


return 0;
}

Estou apenas tentando preencher meu espaço de troca com um arquivo de imagem, se isso for possível? Obrigado antecipadamente.

    

Answer 1

O Ubuntu evita usar o swap, a menos que precise da memória. Você pode continuar alocando e preenchendo a memória até que ela precise ser paginada. Você não precisa atingir todos os bytes, apenas um byte em cada página. Você pode usar um loop onde você aloca uma página de memória e escreve nela em um loop para preencher a memória.

O uso de mmap mapeia o arquivo na imagem da memória virtual do aplicativo. Qualquer atividade de paginação para a memória mmap usará o arquivo em vez de trocar.

Você pode fazer o mesmo escrevendo um arquivo grande para /tmp se estiver usando tmpfs como seu sistema de arquivos.

Os sistemas operacionais modernos permitem que você supere a memória virtual. Isso permite o uso de estruturas de memória espacial que excedem em muito a memória disponível.