Como faço para descobrir quanta memória livre é deixado no GNU C ++ no Linux

Question

Eu estou escrevendo um programa em C ++ (compilado com gcc e em execução no RedHat Linux). O programa precisa saber em tempo de execução quanto espaço é deixado na pilha e quanto é deixado no heap. Sei que pode não haver uma resposta definitiva a esta pergunta (sobre o monte), então, em alternativa, eu poderia usar a quantidade de memória já atribuídos a partir da pilha em vez. Existe uma chamada de função de uma biblioteca / sistema que vai me dar esses dados?

Eu gostaria de acrescentar que eu só preciso disso para fins de depuração, e só precisa estimativas aproximadas, pelo que as soluções rápidas e sujas são perfeitamente aceitáveis. No entanto, eu preciso consultar o uso de memória muito frequentemente, por isso descascar para fora a um Unix CMD-linha utilidade e analisar a sua saída não é aceitável.

Answer 1

Provavelmente, você pode criar suas próprias funções novas e excluir que encapsula os verdadeiros operadores novos e excluir e tomar nota do uso de memória ao mesmo tempo.

Para stack, há um truque em C, onde você dê uma olhada no endereço da primeira variável local definida na sua função atual para ter uma idéia sobre onde o ponteiro da pilha é no momento. Eu acho que ele deve funcionar em C ++, mas ainda não tentei.

Answer 2

no linux você pode ler / proc / pid / status

Answer 3

Esteja ciente de que em sistemas de 32 bits, a pilha cresce para baixo e a pilha cresce para cima, e os dois poderiam encontrar em algum lugar no meio. O poder espaço, portanto, ser alocado para empilhar ou a pilha, mas não ambos ao mesmo tempo. Note-se que segmentos de memória compartilhada (se você usá-los) complicar o mapa de memória. Assim pode carregado dinamicamente bibliotecas (compartilhados).

+------------+
|    stack   | high addresses
|      |     |
|      v     |
+------------+
|            |
|   unused   |
|            |
+------------+
|            |
|      ^     |
|      |     |
|    heap    |
|            |
+------------+
|            |
|     bss    |
|            |
+------------+
|            |
|    data    |
|            |
+------------+
|            |
|    text    |
|            | low addresses
+------------+

Em um sistema de 64 bits, não é suficiente espaço de endereço que você ficar sem memória real e virtual antes de ocorrer colisões.

Além disso, observe que (pelo menos algumas versões do) Linux estão dispostos a dizer mais memória pode ser alocada que eles realmente podem apoiar - eles over-commit. Isso não é muito bom. Isso significa que as experiências práticas como as alocações de memória julgamento pode lhe dar uma falsa sensação de segurança.

Provavelmente, você é melhor fora pedindo 'é o x MB (GB?) De espaço à esquerda', em vez de 'quantos MB (GB?) De espaço é deixado'. Outras pessoas apontou para o sistema de arquivos /proc como uma fonte de informação para a quantidade de memória em uso. Eu não tenho certeza se é confiável fala sobre quanta memória está disponível para agarrar.

Answer 4

Esta é uma função C para retornar a quantidade de memória livre no Raspberry PI. Ele funciona através da leitura do / proc / meminfo. Eu não tenho certeza se ele funciona para outros sistemas.

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

Answer 5

Você pode verificar no / proc namespace os arquivos / proc / / smaps e / proc / / mapas, onde é o atual ID do processo.

Verifique este blogpost fora.

Answer 6

ferramenta Massif em Valgrind suporta tanto pilha e pilha profiling . Você pode querer verificar o seu código fonte para ver como ele faz isso.

Answer 7

Para a parte montão, talvez você está atingindo um limite de recursos. Confira este .

Você pode usar Valgrind para perfilamento pilha, mas o que você vai fazer com ele? Pilha não é como Heap. Você diz, você quer fazer isso para fins de depuração. Se o seu programa funciona muito bem, então não há nenhum problema de pilha (relacionadas ao seu tamanho, pelo menos).

Você pode definir o tamanho da pilha para os tópicos que você criou e inspecionar o valor ponteiro de pilha, olhando para a variável local endereços (que não deve ser otimizado-out). Basta fazer um pouco de matemática usando o tamanho inicial, valor inicial ponteiro de pilha e valor do ponteiro de pilha atual, você vai ter alguns números agradáveis. Só não se esqueça de descobrir a direção pilha primeiro. Isso pode mudar de plataforma para plataforma.

Eu acho que se você se importa tanto para o uso de heap, em seguida, seu programa provavelmente vazamentos de memória. Neste caso, Valgrind você pode apontar para a direção certa. Valgrind

Answer 8

getrlimit com um paramater de RLIMIT_STACK irá dizer-lhe quanto espaço de pilha está lá no total. Com um parâmetro de rlimit_as você pode descobrir o quanto de memória virtual que existe.

Para mais informações olhada http://linux.die.net/man/2/ getrlimit