Hablemos de un fenómeno que nos afecta, sobre todo en desarrollos que están en ejecución durante mucho tiempo, pero , y es que, debido a la mala gestión de la memoria podemos llegar a consumir más de lo necesario y podemos volver loco al sistema operativo utilizando la memoria virtual para darnos el espacio que necesitamos.
Los memory leaks son fugas de memoria debidas a que hemos pedido un cierto espacio de memoria durante la ejecución de nuestro programa, la hemos usado y cuando hemos dejado de usarla, no la hemos liberado, por tanto estamos ocupando más de lo que necesitamos y acaparando recursos; un ejemplo de esto son esos procesos o programas que tenemos arrancados durante varios días, y cuanto más tiempo llevan arrancados más memoria ocupan (a veces es necesario, pero otras veces, la mayoría, no).
Antes de iniciarnos en la creación de un programa acerca de lo que no debemos hacer, vamos a hacerlo bien, y echaremos un vistazo a un artículo sobre el Out Of Memory Killer (desconozco si Windows tiene algo parecido, tal vez instalando alguna aplicación), que será una utilidad de nuestro kernel que matará el proceso cuando esté consumiendo mucha memoria, o nos permitirá matarlo fácilmente con las teclas (Alt+SysRq o imprimir pantalla+F). Con unas líneas antes de nuestro programa, nos podemos evitar un disgusto, como puede ser un reinicio de sistema mientras hacemos pruebas, y puede que estemos ejecutando algo útil.
Tabla de contenidos
¡Precaución!
Si vemos que nuestro proceso hace que el sistema vaya muy lento, será porque en lugar de utilizar nuestra RAM, estará usando la memoria virtual de forma intensa, esta memoria es mucho más lenta que nuestra RAM, si hemos entendido lo que quiero demostrar, podemos parar el proceso gracias al OOM Killer de antes con Alt+SysRq+F, pero sólo pulsa una vez las teclas, aunque veamos que no nos hace mucho caso, el sistema tarda un tiempo en volver a recolocar toda la información y limpiar la memoria del proceso. Si pulsamos más veces, lo mismo terminamos matando el servidor gráfico o algún proceso importante, y no queremos eso.
Ajustando OOM Killer
Para todo eso, debemos incluir el siguiente código (al final pondré todo el programa, pero primero lo analizamos por separado), el objetivo es escribir el valor 15 sobre el fichero /proc/PID/oom_adj:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 | void error(const char *mens) { cerr << "ERROR: ("<<mens<<") errno: "<<errno<<": "<<strerror(errno)<<endl; exit (1); } void ajusta_oom() { ofstream fi; char nom[30]; // Obtenemos el nombre del fichero, aunque estemos haciéndolo // a lo C++, uso sprintf() aquí porque es más rápido. sprintf(nom, "/proc/%d/oom_adj", getpid()); // Abrimos el fichero fi.open(nom); if (fi.fail()) error("No puedo abrir oom_adj"); // Escribimos 15 en el fichero, para dar más "apeletas de muerte" // a este proceso. Ver: // https://poesiabinaria.net/2010/04/cuando-un-proceso-se-come-la-memoria-de-nuestro-sistema/ fi<<"15"; if (fi.fail()) error("No puedo escribir oom_adj"); fi.close(); } |
Gastando memoria
Para esta parte hay que tener cuidado, ya que depende de la RAM que tengamos cada uno, yo he hecho esto en un equipo con 2GB de RAM, hasta que se ha vuelto extremadamente lento. Aunque el objetivo es que veamos la memoria que está actualmente en consumo. Podemos utilizar el comando free() en paralelo con el programa para ver que cada vez tenemos más memoria consumida, cuando no deberíamos, porque la intuición nos diría que cuando salimos de la función todo lo reservado se libera, pero no es así.
En los sistemas operativos actuales no podremos ponernos a reservar memoria sin control, ya que el SO casi siempre nos la dará (aunque no disponga de ella, dejando el marrón al gestor de memoria del futuro), si de verdad queremos reservar memoria, gastarla y darnos cuenta, debemos utilizar la memoria que reservamos; por ello he optado por rellenar un vector de números. Cuidado con subir mucho más MAX_NEW_ELEMENTS, es más, si tienes poca memoria, te recomiendo bajarla un poco, a la mitad, por ejemplo, en un primer cálculo, sólo contando los elementos del vector (8.000.000 x 8 (long int) = 64Mb), por lo que depende de lo que haya en ejecución, con cuatro llamadas a la función gasta_memoria() habremos gastado 256Mb de memoria.
Para ver lo que vamos gastando, debemos ejecutar en un terminal el programa que voy a mostrar, y en otro terminal ejecutamos free. El programa hará varias paradas pidiendo que pulsemos intro a cada llamada de gasta_memoria() para que podamos ver lo que se ha gastado, después del código veremos la ejecución.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 | #include <iostream> #include <vector> #include <cstdio> #include <unistd.h> #include <cstdlib> #include <cerrno> #include <cstring> #include <fstream> #define MAX_NEW_ELEMENTS 8000000 using namespace std; // Sale del programa devolviendo un error void error(const char *mens); // Ajunta oom_adjust para matar este proceso si se nos cuelga el sistema // Así nos quitamos un disgusto void ajusta_oom(); // Gasta memoria (casi) sin control void gasta_memoria(); // Espera una tecla void intro(); void gasta_memoria2() { vector <long int> *v; v=new vector<long int>; for (unsigned long i=0; i<MAX_NEW_ELEMENTS; i++) v->push_back(i); intro(); // delete v; } int main() { ajusta_oom(); cout << "OOM ajustado" << endl; intro(); gasta_memoria(); gasta_memoria2(); gasta_memoria(); gasta_memoria2(); } void intro() { char key; cout << "Pulse Intro"<<endl; cin.get(key); } void gasta_memoria() { vector <long int> *v; v=new vector<long int>; for (unsigned long i=0; i<MAX_NEW_ELEMENTS; i++) v->push_back(i); intro(); // delete v; } void error(const char *mens) { cerr << "ERROR: ("<<mens<<") errno: "<<errno<<": "<<strerror(errno)<<endl; exit (1); } void ajusta_oom() { ofstream fi; char nom[30]; // Obtenemos el nombre del fichero, aunque estemos haciéndolo // a lo C++, uso sprintf() aquí porque es más rápido. sprintf(nom, "/proc/%d/oom_adj", getpid()); // Abrimos el fichero fi.open(nom); if (fi.fail()) error("No puedo abrir oom_adj"); // Escribimos 15 en el fichero, para dar más "apeletas de muerte" // a este proceso. Ver: // https://poesiabinaria.net/2010/04/cuando-un-proceso-se-come-la-memoria-de-nuestro-sistema/ fi<<"15"; if (fi.fail()) error("No puedo escribir oom_adj"); fi.close(); } |
La ejecución será escalonada, es decir, ejecutamos, y antes de pulsar intro ejecutamos free(), así vemos cómo se va gastando la memoria tal y como indica la imagen. al final de la función gasta_memoria(). Aunque en ocasiones esto no es tan fácil de ver. Generalmente el sistema operativo, que sí que sabe lo que el proceso ha reservado y consumido, libera la memoria, y a veces puede invertir un rato, aunque a veces no aparezca toda la memoria como libre directamente, al cabo de unos minutos (como mucho) ya estará listo. Recuerdo, que si hemos reservado mucha, mucha memoria, el sistema dejará de responder, para ello podemos pulsar Alt+SysRq+F, y el programa morirá rápidamente (pero, pulsad estas teclas, sólo una vez, y esperar). Foto: tao_zhyn (Flickr) Compartido con CC-by a 26/11/2011
Lo que quiero demostrar es que el puntero al vector v, cada vez que ejecutamos new vector
En este caso, la solución a este problema habría sido escribir:Cuando el programa se cierra…
Si el sistema no reacciona…
También podría interesarte....
Pingback: Bitacoras.com /
Pingback: BlogESfera.com /