C - Überprüfen Sie den verfügbaren ram?

Ich weiß, wie Sie malloc() und free() Speicher zuweisen, aber gibt es auch eine standard-C-Funktion, um zu überprüfen, wie viel Speicher übrig ist, so kann ich rufen, die in regelmäßigen Abständen, um sicherzustellen, dass mein code hat keine Speicherverluste?

Das einzige, was ich denken kann, ist das aufrufen malloc(1) in einer endlos-Schleife, bis es wieder ein Fehler, aber sollte es nicht eine effizientere Möglichkeit?

Warum nicht einfach valgrind auf, Ihr Programm auf Dichtheit prüfen?
beachten Sie, dass das aufrufen von malloc in einer Endlosschleife und wird wahrscheinlich nie scheitern, da die meisten Systeme nur Speicher auf touch.
Verwandte : stackoverflow.com/questions/2513505/...
jeder malloc rufen Sie behält sich einen Teil des virtuellen Adressraums, so wird es irgendwann wieder einen Fehler.
Wahr, in der Tat malloc muss auch die (physischen) Speicher zu halten Spur von den zugewiesenen Blöcken (auch wenn Sie die drop-Zeiger). So kann man nicht malloc für immer. Dies jedoch überhaupt nicht helfen, zu wissen, wie viel Speicher übrig ist.

InformationsquelleAutor Muis | 2013-01-17

6

Nein, es gibt keine standard-C-Funktion zu tun. Es gibt einige Plattform-spezifische Funktionen, die Sie verwenden können, um bestimmte Arten von Abfragen (wie working set-Größe), aber diese werden wahrscheinlich nicht hilfreich sein, denn manchmal Speicher, wurde richtig free()d wird immer noch als der Zuweisung durch die OS wegen der malloc Umsetzung halten könnte, wird der freigegebene Speicher in einem Becken umher.

Wenn Sie prüfen wollen, für Speicher-Lecks empfehle ich mit einem tool wie Valgrind, läuft dein Programm in einer virtuellen Maschine sortiert und können verfolgen, Speicher Lecks, unter anderem features.

Wenn Sie unter Windows läuft, können Sie _CrtDbgReport und/oder _CrtSetDbgFlag zu prüfen auf Speicherlecks.

Das Programm ist firmware läuft auf einem Cortex M0 CPU, und verwendet eine Menge von ARM-spezifische Aufforderungen/Anweisungen, so dass ich denke, es wäre schwer zu analysieren, für Valgrind, und ich habe kaum noch genug Speicherplatz auf dem Gerät zu laufen, meinen eigenen code, geschweige denn zum hinzufügen einer virtuellen Maschine.
In diesem Fall Messen Sie, wie viel Speicher Sie haben zu Beginn der Ausführung und zu schreiben wrapper-Funktionen rund um malloc und free zu Dekrementieren und Inkrementieren von Ihrem Startpunkt, als loreb schlägt vor, in einer anderen Antwort.

InformationsquelleAutor Adam Rosenfield
2

Wenn Sie sich leisten können #ifdef ' Ing eine debug-version (eventuell in einem emulator!), Sie könnte einfach erstellen Sie eine debug-version von malloc/free, die verfolgt die Anzahl der bytes, die derzeit im Einsatz, und "drucken" Sie in regelmäßigen Abständen (wieder - nur in der debug-version, möglicherweise unter einem emulator) auf welchem Ausgabegerät Sie für das Debuggen (eine led?), und sehen, ob es hält, steigt.

Den standard-trick ist, um zu reservieren, sizeof(size_t) mehr als beantragt, so ist die Speicherung der Größe zusammen mit der neu zugewiesenen Speicher - aber wenn Sie schreiben eine firmware, die ich denke, Sie wissen es bereits 🙂

Also... hast du einen emulator?

EDIT: ich bin also verwendet, um Computer läuft GHz, dass Sie nicht mit mir kommen, auf den ersten, aber natürlich eine andere Sache, die Sie tun können, ist nur die Anzahl der Zuweisungen, die nicht Ihre Größe-ich kann mir nicht vorstellen, wie das wohl zu viel Speicher zu laufen.

InformationsquelleAutor loreb

Wenn in Ihrem system malloc() weist immer physischen Speicher, können Sie rufen Sie malloc() immer wieder mit Größen, die sich nicht durch 1, sondern durch die aufeinander folgenden Potenzen von zwei. Das wird wirksamer sein. Unten ist ein Beispiel, wie es zu tun.

Wenn auf der anderen Seite malloc() nur reserviert virtuellen Adressraum ohne Zuordnung physikalischer Speicher es dies nicht geben Ihnen, was Sie wollen.

Beispielcode:

#include <stdio.h>
#include <stdlib.h>

void* AllocateLargestFreeBlock(size_t* Size)
{
  size_t s0, s1;
  void* p;

  s0 = ~(size_t)0 ^ (~(size_t)0 >> 1);

  while (s0 && (p = malloc(s0)) == NULL)
    s0 >>= 1;

  if (p)
    free(p);

  s1 = s0 >> 1;

  while (s1)
  {
    if ((p = malloc(s0 + s1)) != NULL)
    {
      s0 += s1;
      free(p);
    }
    s1 >>= 1;
  }

  while (s0 && (p = malloc(s0)) == NULL)
    s0 ^= s0 & -s0;

  *Size = s0;
  return p;
}

size_t GetFreeSize(void)
{
  size_t total = 0;
  void* pFirst = NULL;
  void* pLast = NULL;

  for (;;)
  {
    size_t largest;
    void* p = AllocateLargestFreeBlock(&largest);

    if (largest < sizeof(void*))
    {
      if (p != NULL)
        free(p);
      break;
    }

    *(void**)p = NULL;

    total += largest;

    if (pFirst == NULL)
      pFirst = p;

    if (pLast != NULL)
      *(void**)pLast = p;

    pLast = p;
  }

  while (pFirst != NULL)
  {
    void* p = *(void**)pFirst;
    free(pFirst);
    pFirst = p;
  }

  return total;
}

int main(void)
{
  printf("Total free: %zu\n", GetFreeSize());
  printf("Total free: %zu\n", GetFreeSize());
  printf("Total free: %zu\n", GetFreeSize());
  printf("Total free: %zu\n", GetFreeSize());
  printf("Total free: %zu\n", GetFreeSize());
  return 0;
}

Ausgang (ideone):

Total free: 266677120
Total free: 266673024
Total free: 266673024
Total free: 266673024
Total free: 266673024

Nicht berücksichtigt werden die extra-bytes zugeordnet, die durch bestimmte Implementierungen für jedes malloc ' ed Puffer (für die Ausrichtung der Zwecke, oder die Validierung von buffer overruns)
malloc() nicht zulassen würde, dass du diese bytes sowieso.

InformationsquelleAutor Alexey Frunze

Suchte ich und fand diese Frage, um mir zu helfen einen Antrag zu animieren zahlreiche Iterationen der fraktalen Funktionen auf mehrere arrays aus komplexen Werten.

Danke, Alexey Frunse, für Ihre ideone.c-code. Es ist sicherlich hilfreich.

Gebäude auf das, was ich gelernt, in der Hoffnung, mehr Hilfsbereitschaft, ich habe das folgende geschrieben:

/* File: count-free-blocks.c
 *
 * Revision: 2018-24-12
 * 
 * Copyright (C) Randall Sawyer
 * <https://stackoverflow.com/users/341214/randall-sawyer>
 */

#include <stdarg.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>

size_t  available_blocks (size_t      block_sz);
size_t  largest_n_blocks (size_t      block_sz);
size_t  try_alloc        (size_t      n_blocks,
                          size_t      block_sz);
void    report           (int         indent,
                          const char *format,
                          ...);

int main (int argc, const char **argv)
{
  size_t  n_blocks,
          block_sz = 0;

  if (argc > 1 && sscanf (argv[1], "%zu", &block_sz) != 1)
    report (0, "Argument `%s' is not a valid block size.", argv[1]);

  if (block_sz == 0)
  {
    report (0, "Using 1 byte block size...");
    block_sz = 1;
  }

  n_blocks = available_blocks (block_sz);

  report (0, "Available memory: %zu blocks of %zu bytes == %zu bytes",
          n_blocks, block_sz, n_blocks * block_sz);

  return 0;
}

size_t
available_blocks (size_t block_sz)
{
  size_t  n_blocks[2];

  report (0, "calculating free memory...");

  /* Calculate maximum number of blocks of given size which can be
   * repeatedly allocated.
   */
  do {

    for ( n_blocks[0] = largest_n_blocks (block_sz);
         (n_blocks[1] = largest_n_blocks (block_sz)) < n_blocks[0];
          n_blocks[0] = n_blocks[1] );

    report (1, "check once more...");

  } while (try_alloc (n_blocks[0], block_sz) != n_blocks[0]);

  return n_blocks[0];
}

size_t
largest_n_blocks (size_t block_sz)
{
  static
  const char *f  = "phase %d";
  size_t      n_blocks, max, bit;

  report (1, "calculating largest number of free blocks...");

  /* Phase 1:
   * 
   * Find greatest allocatable number-of-blocks such that
   * it has only one bit set at '1' and '0' for the rest.
   */
  report (2, f, 1);

  n_blocks = ~(UINTPTR_MAX >> 1);     //only MSB is set
  max      = UINTPTR_MAX / block_sz;  //maximimum number of blocks

  while (n_blocks && !(n_blocks & max))
    n_blocks >>= 1;

  while (try_alloc (n_blocks, block_sz) != n_blocks)
    n_blocks >>= 1;

  /* Phase 2:
   * 
   * Starting with first allocatable number-of-blocks, add decreasingly
   * significant bits to this value for each successful allocation.
   */
  report (2, f, 2);

  for ( bit = n_blocks >> 1; bit; bit >>= 1)
  {
    size_t  n = n_blocks | bit;

    if (try_alloc (n, block_sz) == n)
      n_blocks = n;
  }

  /* Phase 3:
   * For as long as allocation cannot be repeated,
   * decrease number of blocks.
   */
  report (2, f, 3);

  while (try_alloc (n_blocks, block_sz) != n_blocks)
    --n_blocks;

  report (1, "free blocks: %zu", n_blocks);

  return n_blocks;
}

size_t
try_alloc  (size_t  n_blocks,
            size_t  block_sz)
{
  if (n_blocks != 0)
  {
    /* Try to allocate all of the requested blocks.
     * If successful, return number of requested blocks;
     * otherwise, return 0.
     */
    void *p = calloc (n_blocks, block_sz);

    report (3, "try %zu blocks of %zu bytes: %s",
            n_blocks, block_sz, p ? "success" : "failure");

    if (p)
    {
      free (p);
      return n_blocks;
    }
  }

  return 0;
}

#define MAX_INDENT    8
#define INDENT_SPACES "        "

void
report (int         indent,
        const char *format,
        ...)
{
  const char  padding[MAX_INDENT+1] = INDENT_SPACES;
  va_list     args;

  if (indent > MAX_INDENT)
    indent = MAX_INDENT;

  if (indent > 0)
    printf ("%s", &padding[8-indent]);

  va_start (args, format);
  vprintf (format, args);
  va_end (args);

  printf ("\n");
}

Verwendung:

Graf-frei-Blöcke [BLOCK_SIZE]

Eingang:

> ./count-free-blocks 33554432

Ausgabe:

calculating free memory...
 calculating largest number of free blocks...
  phase 1
   try 64 blocks of 33554432 bytes: success
  phase 2
   try 96 blocks of 33554432 bytes: failure
   try 80 blocks of 33554432 bytes: success
   try 88 blocks of 33554432 bytes: success
   try 92 blocks of 33554432 bytes: failure
   try 90 blocks of 33554432 bytes: success
   try 91 blocks of 33554432 bytes: success
  phase 3
   try 91 blocks of 33554432 bytes: success
 free blocks: 91
 calculating largest number of free blocks...
  phase 1
   try 64 blocks of 33554432 bytes: success
  phase 2
   try 96 blocks of 33554432 bytes: failure
   try 80 blocks of 33554432 bytes: success
   try 88 blocks of 33554432 bytes: success
   try 92 blocks of 33554432 bytes: failure
   try 90 blocks of 33554432 bytes: success
   try 91 blocks of 33554432 bytes: success
  phase 3
   try 91 blocks of 33554432 bytes: success
 free blocks: 91
 check once more...
   try 91 blocks of 33554432 bytes: success
Available memory: 91 blocks of 33554432 bytes == 3053453312 bytes

Will ich re-Zweck, diese Funktionen in die eigene Anwendung.

InformationsquelleAutor Randall Sawyer

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.