L'allocation de la mémoire pour les variables globales et locales

J'ai appris que la mémoire pour les variables globales sont alloués au démarrage du programme alors que la mémoire pour les variables locales sont attribués à chaque appel de fonction est faite.

Cas 1:
Je l'ai déclaré à global tableau d'entiers de taille 63500000 et la mémoire utilisée est de 256 MO
Ideone Lien

include <stdio.h>
int a[63500000];
int main()
{
    printf ("This code requires about 250 MB memory\n");
    return 0;
}

Cas 2:
J'ai déclaré un local tableau d'entiers de taille identique dans main (), et la mémoire utilisée est de 1,6 MO
Ideone lien

#include <stdio.h>
int main()
{
    int a[63500000]= {1,5,0};
    printf ("This code requires only 1.6 MB \n");
    //printf ("%d\n", a[0]);
    return 0;
}

Cas 3:
J'ai déclaré un local tableau d'entiers de taille identique dans une autre fonction et la mémoire utilisée est de 1,6 MO
Ideone Lien

#include <stdio.h>
void f()
{
    int a[63500000];
}

int main()
{
    f();
    return 0;
}

Veuillez expliquer pourquoi il existe une différence de mémoire utilisée ou mon concept de l'allocation de mémoire est le problème ??

Vous le savez, vous devriez poster le code directement dans la réponse au lieu de donner des liens Ideone
Comment avez-vous que c'est la quantité de mémoire les programmes de consommer?
Dans votre tableau d'exemples, vous n'avez pas utiliser la plupart de la matrice, de sorte que le compilateur peut optimiser en toute sécurité.
Monsieur, quand on compile un programme en ideone il indique le temps requis et la mémoire utilisée par le programme.
Merci. Je vois que maintenant.

OriginalL'auteur Snehasish | 2012-08-15

c memory-management

25

Première de toutes: l'ideone compilateur est GCC.

Donc, qu'est-GCC faire lorsque vous compilez ce?:
```
void foo ()
{
  int a[63500000];
}
```
gcc -S -O2 foo.c génère:
```
foo:
    pushl   %ebp
    movl    %esp, %ebp
    popl    %ebp
    ret
```
c'est à dire rien est alloué sur la pile, à tous les.

Le tableau est simplement optimisé à l'écart par GCC, car il n'est jamais utilisé.

GCC ne pas le faire avec un global, car il est possible qu'un global est utilisé dans une autre unité de compilation, et donc il n'est pas sûr qu'il n'est jamais utilisé. Aussi: Le mondial est pas sur la pile (car c'est un global).

Maintenant, permet de voir ce qui se passe quand vous utilisation les locaux de tableau:
```
int bar (int a, int b, int c)
{
  int f[63500000];
  f[a] = 9;
  f[b] = 7;
  return f[c];
}
```
Les choses sont très différentes:
```
bar:
    pushl   %ebp
    movl    %esp, %ebp
    subl    $254000000, %esp
    movl    8(%ebp), %eax
    movl    $9, -254000000(%ebp,%eax,4)
    movl    12(%ebp), %eax
    movl    $7, -254000000(%ebp,%eax,4)
    movl    16(%ebp), %eax
    movl    -254000000(%ebp,%eax,4), %eax
    leave
    ret
```
Cette ligne: subl $254000000, %esp correspond à la taille du tableau. c'est à dire de la mémoire est alloué sur la pile.

Maintenant, que faire si j'ai essayé d'utiliser le bar fonction dans un programme:
```
int bar (int a, int b, int c)
{
  int f[63500000];
  f[a] = 9;
  f[b] = 7;
  return f[c];
}

int main (void)
{
  return bar (0, 0, 0);
}
```
Nous l'avons déjà vu, que le bar fonction alloue quelque 250 méga-octets sur la pile. Sur mon défaut de GNU/Linux installer, la taille de la pile est limitée à 8 mo. Ainsi, lorsque le programme s'exécute, il provoque un "Segmentation fault". Je peux l'augmenter, si je veux, en exécutant la commande suivante dans un shell:
```
ulimit -s 1000000 #i.e. allow stack size to grow close to 1GB
```
Alors je peux exécuter le programme, et il sera en effet exécuter.

La raison pour laquelle il échoue sur la ideone site web, c'est qu'ils ont limité la taille de la pile lors de l'exécution de programmes (et ils devraient, sinon les utilisateurs malveillants peuvent gâcher leur système).

Si j'essaie de faire memset (a, 0, sizeof(a)) dans les cas 2 et 3, pourquoi ne SIGSEV exception est levée ?
Regarder le dernier bit de ma réponse. J'ai édité. C'est à cause de la taille de la pile de la limite (c'est une limite définie par le système d'exploitation)
Merci pour votre merveilleuse explication. J'ai appris beaucoup de choses aujourd'hui.
+1 pour expliquer l'optimisation de la version, ce qui n'entraîne pas de dépassement de pile.

OriginalL'auteur ArjunShankar
5

Les cas 2, 3

Variables que vous définissez à l'intérieur des fonctions sont allouées sur la pile. Cela signifie que la mémoire est nettoyé (la pile est "sauté") lorsque la fonction se termine.

Cas 1

Les Variables définies dans la portée globale sont alloués dans un segment de données (ou, plus généralement, un espace mémoire requis à partir du système d'exploitation) qui n'existe que pour la durée de vie du processus.

En outre

De la mémoire allouée à l'aide d' malloc est attribuée à partir d'un segment de mémoire et reste affecté jusqu'à libérées explicitement à l'aide de gratuit.

Noter qu'un système d'exploitation moderne peut très bien fournir l'adresse de l'espace requis par un programme, mais pas physiquement de retour cet espace d'adressage de la RAM jusqu'à ce que la mémoire (ou une portion de la mémoire souvent appelé un page) est physiquement accessible.

Si j'essaie de faire memset(a, 0, sizeof(a)) dans les cas 2 et 3 erreur de segmentation se produit. Pourquoi ?
Sur les cas 2 et 3, la mémoire n'est pas alloué sur la pile. Jamais. Il est tout simplement optimisé à l'écart par GCC. Vous pouvez voir pourquoi ici: ideone.com/1a7A1 c'est à dire La 250MB exemple du tableau par l'OP, et ce 4 octets exemple, ils utilisent presque la même quantité de mémoire, tel que rapporté par ideone.

OriginalL'auteur Eric J.
2

case 2 et case 3 seraient le résultat d'un débordement de pile que vous demandez 64 MO de la mémoire de pile dans lequel votre pile est généralement 8 MO sur Linux . cela aurait pour résultat aléatoire de mauvaises choses et /ou des core dumps et les accidents.

cette réponse grandement explique les différentes sections de l'espace d'adressage du processus (.texte, .sev , .de données )et comment les différentes affectations de variables est fait.

OriginalL'auteur Jay D

Vous devez vous connecter pour publier un commentaire.