Comment puis-je savoir que la mémoire libre reste dans GNU C ++ sous Linux
https://stackoverflow.com/questions/391107
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianQuestion
J'écris un programme C ++ (compilé avec gcc et en cours d'exécution sur RedHat Linux). Le programme a besoin de savoir à l'exécution de combien d'espace est laissé sur la pile et combien reste dans le tas. Je sais qu'il ne peut y avoir une réponse définitive à cette question (sur le tas), donc, je pourrais également utiliser la quantité de mémoire déjà alloués dans le tas à la place. Y at-il une fonction bibliothèque / système d'appel qui va me donner ces données?
Je voudrais ajouter que je ne besoin de cela pour des fins de débogage, et seulement besoin d'estimations approximatives, donc des solutions rapides et sale sont parfaitement acceptables. Cependant, je dois interroger l'utilisation de la mémoire très souvent, si les bombardements à un utilitaire cmd ligne Unix et analyse sa sortie n'est pas acceptable.
Pas de solution correcte
Autres conseils
Vous pouvez probablement créer votre propre nouvelle et supprimer des fonctions qui encapsule le vrai nouveau et supprimer les opérateurs et prendre note de l'utilisation de la mémoire en même temps.
Pour pile, il y a un truc en C où vous jetez un oeil à l'adresse de la première variable locale définie dans votre fonction actuelle pour avoir une idée approximative où le pointeur de la pile est à l'heure actuelle. Je suppose que cela devrait fonctionner en C ++, mais ne l'ai pas essayé.
sur linux vous pouvez lire / proc / pid / état
Sachez que sur les systèmes 32 bits, la pile grossit vers le bas et le tas grandit vers le haut, et les deux pourrait rencontrer quelque part au milieu. L'espace peut donc être attribué à pile ou tas, mais pas les deux en même temps. Notez que les segments de mémoire partagée (si vous les utilisez) compliquerait la carte mémoire. Ainsi, de manière dynamique, chargé (partagé) bibliothèques.
+------------+
| stack | high addresses
| | |
| v |
+------------+
| |
| unused |
| |
+------------+
| |
| ^ |
| | |
| heap |
| |
+------------+
| |
| bss |
| |
+------------+
| |
| data |
| |
+------------+
| |
| text |
| | low addresses
+------------+
Sur un système 64 bits, il y a assez d'espace d'adresses que vous avez de la mémoire réelle et virtuelle avant que les collisions se produisent.
En outre, notez que (au moins certaines versions de) Linux sont prêts à dire plus de mémoire peut être allouée qu'ils peuvent réellement soutenir - ils trop commettre. Ce n'est pas très bon. Cela signifie que les expériences pratiques telles que les allocations de mémoire d'essai peuvent vous donner un faux sentiment de sécurité.
Très probablement, vous êtes mieux loti demander « est le x Mo (GB?) De l'espace gauche », plutôt que «combien de Mo (GB?) De l'espace est laissé. D'autres personnes ont souligné le système de fichiers /proc en tant que source d'information pour la quantité de mémoire est en cours d'utilisation. Je ne sais pas si elle vous dit de manière fiable sur la quantité de mémoire disponible pour saisir.
Ceci est une fonction C pour renvoyer la quantité de mémoire disponible sur la PI framboise. Il fonctionne en lisant le fichier / proc / meminfo. Je ne sais pas si cela fonctionne pour d'autres systèmes.
#include <stdio.h>
#include <string.h>
// Return the amount of free memory in kbytes.
// Returns -1 if something went wrong.
int getfreememory()
{
int returnValue;
const int BUFFER_SIZE = 1000;
char buffer[BUFFER_SIZE];
FILE *fInput;
int loop;
int len;
char ch;
returnValue = -1;
fInput = fopen("/proc/meminfo","r");
if (fInput != NULL)
{
while (!feof(fInput))
{
fgets(buffer,BUFFER_SIZE-1,fInput);
if (feof(fInput))
{
break;
}
buffer[BUFFER_SIZE-1] = 0;
// Look for serial number
if (strncmp(buffer,"MemFree:",8)==0)
{
// Extract mem free from the line.
for(loop=0;loop<BUFFER_SIZE;loop++)
{
ch = buffer[loop];
if (ch == ':')
{
returnValue = 0;
continue;
}
if (ch == 0)
{
break;
}
if (returnValue >=0)
{
if (ch >='A')
{
break;
}
if ((ch >='0') && (ch <='9'))
{
returnValue = returnValue * 10 + (ch-'0');
}
}
}
break;
}
}
fclose(fInput);
}
return returnValue;
}
Vous pouvez vérifier dans le répertoire / proc namespace les fichiers / proc /
Vérifier ce blogpost sur.
outil massif de Valgrind supporte à la fois la pile et tas profilage . Vous pouvez vérifier son code source pour voir comment elle le fait.
Pour la partie du tas, peut-être vous frappez une limite de ressources. Consultez cette .
Vous pouvez utiliser Valgrind pour le profilage de la pile, mais qu'est-ce que tu vas faire? Stack est pas comme Heap. Vous dites que vous voulez faire cela pour des fins de débogage. Si votre programme fonctionne bien, alors il n'y a pas de problème de pile (par rapport à sa taille au moins).
Vous pouvez définir la taille de la pile pour les fils créés et vérifiez la valeur de pointeur de pile en regardant la variable locale (qui ne doit pas être optimisé out) adresses. Il suffit de faire quelques calculs en utilisant la taille initiale, la valeur initiale du pointeur de la pile et la valeur actuelle du pointeur de la pile, vous obtiendrez quelques chiffres agréables. Il suffit de ne pas oublier de trouver la direction de la pile en premier. Cela peut changer de plate-forme à plate-forme.
Je pense que si vous vous souciez autant pour l'utilisation du tas, votre programme fuites probablement la mémoire. Dans ce cas, Valgrind peut vous indiquer la bonne direction. Valgrind
getrlimit avec un paramater de RLIMIT_STACK vous dira combien d'espace pile est-il au total. Avec un paramètre de RLIMIT_AS vous pouvez savoir combien de mémoire virtuelle il y a.
Pour plus d'information à regarder http://linux.die.net/man/2/ getrlimit
