TLDR para personas en el futuro: heredé un programa y necesito adaptarlo para manejar datos varias magnitudes más grandes de lo que es actualmente. Necesito ayuda para encontrar una forma de administrar varias copias de una matriz de 30 GB.
Heredé un código de investigación bastante recientemente (escrito en c) que inicialmente se escribió para ejecutarse en un pequeño conjunto de datos comparativamente ~ 5 GB. El código requiere que pueda acceder a cuatro copias de la matriz a la vez (una char de caracteres y tres matrices double ). Por lo tanto, el autor en ese momento no necesitaba preocuparse por el uso de la memoria y, como tal, tiene varias instancias en las que hay de 2 a 4 matrices adicionales al mismo tiempo en la memoria.
Además, se trata de datos biológicos (genoma) y las matrices no son escasas.
El problema ahora es que tengo que adaptar el código a donde una única matriz de dobles es de 30 GB.
No estoy seguro de si necesito que todos los valores estén accesibles a la vez, pero sé que muy a menudo ocurre que el código recorre todos los valores.
Dividí cada una de las matrices en conjuntos de 10k caracteres o dobles y los escribí todos en archivos. Luego cambié todo el acceso a mis propias funciones y lo leí del archivo o sobrescribí esa línea en el archivo. Aunque esto funcionó. El problema era que era terriblemente lento (probablemente debido a todas las aperturas y cierres de archivos + la velocidad de escritura en el disco), que es algo que ya es un problema con el programa y no quiero empeorarlo.
Me di cuenta de que varias veces habría períodos de tiempo en los que el programa no necesitaría una matriz y decidí escribir eso en el disco y luego leerlo cuando fuera necesario. El problema al que me enfrento es que aún lleva mucho tiempo (¿más de 10 minutos?) escribir toda la matriz en el disco, solo abrir el archivo y cerrarlo una vez (a diferencia del método anterior).
Como esto es para investigación, tengo acceso a un clúster informático con 150 GB de RAM. Envié este programa como un trabajo, pero desafortunadamente, incluso entonces el proceso se eliminó por ocupar demasiada memoria. Originalmente sospeché que esto era solo una pérdida de memoria, pero luego de una inspección más detallada, realmente parece que se están creando> 5 matrices dobles cuando el programa se estaba ejecutando. Al igual que una máquina personal de notas al margen tiene 40 (un número extraño que sé) GB de memoria.
Deshabilité el kernel para que no prometiera demasiado la memoria porque noté que fallaba no cuando asignaba muchas de las matrices, sino cuando realmente comenzaba a acceder a ellas. Sin embargo, no creo que esto termine haciendo nada porque todavía promete demasiado.
Una noche me frustré bastante porque se estaba eliminando todo el tiempo y decidí ejecutar el programa con una amabilidad de -10000, lo que provocó que mi computadora fallara al eliminar otros procesos para compensar más memoria.
También jugué con el uso de mmap() pero no estoy seguro de si esto es algo que debería seguir.
Aunque realmente no puedo estar seguro de si es un problema XY, estoy bastante seguro de que necesito tener al menos tres matrices al mismo tiempo (aunque no salto demasiado en las matrices).
¿Alguien tiene alguna experiencia sobre cómo solucionar este problema? De forma anticipada, muchas gracias por su ayuda. Y finalmente, estoy usando Linux.
Esto suena como un buen caso de uso para mmap .
La función mmap se puede utilizar para tomar un archivo abierto y asignarlo a una región de la memoria. Las lecturas y escrituras en el archivo a través del puntero devuelto se manejan internamente, aunque puede vaciarlo periódicamente en el disco de forma manual. Esto le permitirá manipular una estructura de datos más grande que la memoria física del sistema.
Esto también tiene la ventaja de que no necesita preocuparse por mover datos de un disco a otro manualmente. El núcleo se encargará de ello por usted.
Entonces, para cada una de estas matrices grandes, puede crear una asignación de memoria respaldada por un archivo en el disco.
#include <stdio.h> #include <sys/types.h> #include <sys/stat.h> #include <fcntl.h> #include <sys/mman.h> #define DATA_LEN 30000000000LL int main() { int array1_fd = open("/tmp/array1", O_RDWR | O_CREAT | O_TRUNC, 0644); if (array1_fd < 0) { perror("open failed"); exit(1); } // make sure file is big enough if (lseek(array1_fd, DATA_LEN, SEEK_SET) == -1) { perror("seek to len failed"); exit(1); } if (write(array1_fd, "x", 1) == -1) { perror("write at end failed"); exit(1); } if (lseek(array1_fd, 0, SEEK_SET) == -1) { perror("seek to 0 failed"); exit(1); } char *array1 = mmap(NULL, DATA_LEN, PROT_READ | PROT_WRITE, MAP_SHARED, array1_fd, 0); if (array1 == MAP_FAILED) { perror("mmap failed"); exit(1); } // Use array1 munmap(array1, DATA_LEN); close(array1_fd); return 0; } La parte importante de la llamada mmap es el indicador MAP_SHARED . Esto significa que las actualizaciones de la región de memoria asignada se llevan al descriptor de archivo subyacente.