Ce qui est plus rapide: l'allocation de Pile ou le Tas de répartition

Allocation de pile est beaucoup plus rapide puisqu'il n'a vraiment est de déplacer le pointeur de pile.
À l'aide de pools de mémoire, vous pouvez obtenir des performances comparables hors de l'allocation de tas, mais qui vient avec une légère ajouté de la complexité et de ses propres maux de tête.

Aussi, pile vs tas n'est pas seulement un facteur de performance; il dit aussi beaucoup sur la durée de vie prévue des objets.

Honnêtement, il est trivial d'écrire un programme pour comparer les performances:

#include <ctime>
#include <iostream>

namespace {
    class empty { }; //even empty classes take up 1 byte of space, minimum
}

int main()
{
    std::clock_t start = std::clock();
    for (int i = 0; i < 100000; ++i)
        empty e;
    std::clock_t duration = std::clock() - start;
    std::cout << "stack allocation took " << duration << " clock ticks\n";
    start = std::clock();
    for (int i = 0; i < 100000; ++i) {
        empty* e = new empty;
        delete e;
    };
    duration = std::clock() - start;
    std::cout << "heap allocation took " << duration << " clock ticks\n";
}

Il est dit que un idiot de cohérence est le lutin de petits esprits. Apparemment, l'optimisation des compilateurs sont les lutins de nombreux programmeurs de l'esprit. Cette discussion utilisé pour être à la base de la réponse, mais les gens ne peuvent apparemment pas être pris la peine de lire de loin, donc je suis en déplacement jusqu'ici pour éviter de se faire des questions que j'ai déjà répondu.

Un compilateur optimisant peut remarquer que ce code ne fait rien, et peut optimiser tout de suite. C'est l'optimiseur de faire des trucs comme ça, et la lutte contre l'optimiseur est sans issue.

Je recommande la compilation de ce code avec l'optimisation éteint car il n'y a pas de bonne façon de tromper tous optimiseur actuellement en cours d'utilisation ou qui sera utilisé dans l'avenir.

Quelqu'un qui fait de la optimizer, puis se plaint de combat qu'il doit être soumis au ridicule public.

Si je souciait une précision à la nanoseconde je ne voudrais pas utiliser std::clock(). Si je voulais publier les résultats d'une thèse de doctorat, je voudrais faire une plus grosse affaire à ce sujet, et je serais probablement comparer GCC, je vais avoir/Ten15, LLVM, Watcom, Borland, Visual C++, Numérique de Mars, de la CPI et d'autres compilateurs. Comme il est, allocation de tas prend des centaines de fois plus que l'allocation de pile, et je ne vois pas quelque chose d'utile à étudier la question plus avant.

L'optimiseur a pour mission de débarrasser le code je suis en essais. Je ne vois pas de raison de dire que l'optimiseur à exécuter, puis essayer de tromper l'optimiseur en a pas en fait de l'optimisation. Mais si j'ai vu de la valeur en faisant cela, je ferais un ou plusieurs des éléments suivants:

1. Ajouter un membre de données de empty, et accéder à ses données, membre de la boucle; mais si je n'avais jamais lu du membre de données de l'optimiseur peut faire de constantes et de supprimer la boucle; si je ne jamais écrire pour le membre de données, l'optimiseur peut passer tous les mais la dernière itération de la boucle. En outre, la question n'était pas "pile de répartition et d'accès aux données vs tas de répartition et d'accès aux données."

2. Déclarer e volatile, mais volatile est souvent compilées de manière incorrecte (PDF).

3. Prendre l'adresse de e l'intérieur de la boucle (et peut-être l'attribuer à une variable qui est déclarée extern et définie dans un autre fichier). Mais même dans ce cas, le compilateur peut remarquer que, sur la pile au moins -- e seront toujours attribués à la même adresse mémoire, et puis faire de constantes comme dans (1) ci-dessus. Je reçois toutes les itérations de la boucle, mais l'objet n'est jamais réellement allouée.

Au-delà de l'évident, ce test est erronée, car elle permet de mesurer à la fois l'allocation et la libération, et la question d'origine ne m'a pas demandé de libération de la mémoire. Bien sûr, les variables allouées sur la pile sont automatiquement libéré à la fin de leur portée, de sorte de ne pas appeler delete serait (1) biaiser les chiffres (pile de libération de la mémoire est inclus dans les chiffres sur l'allocation de pile, il est donc juste de mesurer tas de libération de la mémoire) et (2) la cause d'un assez mauvais souvenir de la fuite, à moins que nous de conserver une référence à la nouvelle pointeur et appel delete après nous avons eu notre mesure du temps.

Sur ma machine, à l'aide de g++ 3.4.4 sur Windows, j'obtiens un "0 tops d'horloge" à la fois la pile et le tas de l'allocation de rien de moins que de 100000 allocations, et même alors, j'ai "0 tops d'horloge" pour l'allocation de pile et "15 ticks" pour l'allocation de tas. Lorsque je mesure 10 000 000 d'allocations, l'allocation de pile prend le 31 tops d'horloge et de tas d'allocation prend 1562 tops d'horloge.

---

Oui, un compilateur optimisant peut éluder créer le vide d'objets. Si je comprends bien, il peut éluder l'ensemble de la première boucle. Quand j'ai heurté les itérations de 10 000 000 allocation de pile pris 31 tops d'horloge et d'allocation de tas a pris 1562 tops d'horloge. Je pense qu'il est sûr de dire que sans le dire à g++ pour optimiser l'exécutable, g++ n'a pas éluder les constructeurs.

---

Dans les années depuis que j'ai écrit cela, la préférence sur Stack Overflow a été de performance par l'optimisation des builds. En général, je pense que c'est correct. Cependant, je pense toujours que c'est idiot de demander au compilateur d'optimiser le code, quand en fait, vous ne voulez pas que le code optimisé. Il me frappe comme étant très similaire à payer un supplément pour service de voiturier, mais refusant de remettre les clés. Dans ce cas particulier, je ne veux pas que l'optimiseur en cours d'exécution.

À l'aide d'une version légèrement modifiée de l'indice de référence (à l'adresse de point valide que l'original n'a pas allouer quelque chose sur la pile à chaque passage dans la boucle) et de la compilation sans optimisations, mais en les reliant à la libération des bibliothèques (à l'adresse valide point que nous ne voulons pas comprendre tout ralentissement causé par les reliant à des bibliothèques de débogage):

#include <cstdio>
#include <chrono>

namespace {
    void on_stack()
    {
        int i;
    }

    void on_heap()
    {
        int* i = new int;
        delete i;
    }
}

int main()
{
    auto begin = std::chrono::system_clock::now();
    for (int i = 0; i < 1000000000; ++i)
        on_stack();
    auto end = std::chrono::system_clock::now();

    std::printf("on_stack took %f seconds\n", std::chrono::duration<double>(end - begin).count());

    begin = std::chrono::system_clock::now();
    for (int i = 0; i < 1000000000; ++i)
        on_heap();
    end = std::chrono::system_clock::now();

    std::printf("on_heap took %f seconds\n", std::chrono::duration<double>(end - begin).count());
    return 0;
}

affiche:

on_stack took 2.070003 seconds
on_heap took 57.980081 seconds

sur mon système lorsqu'il est compilé avec la ligne de commande cl foo.cc /Od /MT /EHsc.

Vous ne pouvez pas d'accord avec ma démarche pour l'obtention d'un non-optimisé construire. C'est très bien: n'hésitez pas à modifier l'indice de référence autant que vous le souhaitez. Quand j'allume l'optimisation, j'obtiens:

on_stack took 0.000000 seconds
on_heap took 51.608723 seconds

Pas parce que l'allocation de pile est en fait instantané, mais parce que toute demi-décent compilateur peut remarquer que on_stack ne pas faire quelque chose d'utile et peut être optimisé à l'écart. GCC sur mon Linux ordinateur portable remarque également que on_heap ne pas faire quelque chose d'utile, et optimise l'éloignant ainsi:

on_stack took 0.000003 seconds
on_heap took 0.000002 seconds

Vous pouvez créer un segment de l'allocateur pour certaines dimensions des objets qui est très performant. Cependant, la général tas allocateur n'est pas particulièrement performant.

Aussi je suis d'accord avec Torbjörn Gyllebring sur la durée de vie prévue des objets. Bon point!

Généralement de l'allocation de pile juste consiste en la soustraction à partir du registre de pointeur de pile. C'est des tonnes plus rapide que de chercher un segment.

Parfois l'allocation de pile nécessite l'ajout d'une page(s) de la mémoire virtuelle. L'ajout d'une nouvelle page de mise à zéro de la mémoire ne nécessite pas la lecture d'une page à partir d'un disque, donc en général c'est toujours des tonnes plus rapide que de chercher un segment (surtout si une partie de ce segment a été paginé trop). Dans une situation rare, et vous pouvez construire un tel exemple, suffisamment d'espace est disponible dans le cadre du tas qui est déjà dans la mémoire vive, mais l'allocation d'une nouvelle page pour la pile doit attendre une autre page pour être écrits sur le disque. Dans cette situation rare, le tas est plus rapide.

Une pile a une capacité limitée, tout un tas n'est pas. Typique de la pile d'un processus ou thread est d'environ 8K. Vous ne pouvez pas modifier la taille une fois qu'il est attribué.

Une pile variable suit les règles de portée, tandis qu'un segment de mémoire on n'a pas. Si votre pointeur d'instruction va au-delà d'une fonction, toutes les nouvelles variables associées à la fonction aller loin.

Le plus important de tous, vous ne pouvez pas prédire l'ensemble de la fonction appel de la chaîne à l'avance. Un peu plus de 200 octets d'allocation de votre part peut faire un débordement de pile. Ceci est particulièrement important si vous êtes à la rédaction d'une bibliothèque, pas une application.

Probablement le plus grand problème de l'allocation de tas rapport à l'allocation de pile, est que l'allocation de tas dans le cas général est une surabondance de l'opération, et vous ne pouvez donc pas l'utiliser où le calendrier est un problème.

Pour d'autres applications où le calendrier n'est pas un problème, il ne peut pas d'importance, mais si vous tas allouer beaucoup, cela va affecter la vitesse d'exécution. Essayez toujours d'utiliser la pile pour de courte durée et souvent la mémoire allouée (par exemple dans les boucles), et aussi longtemps que possible - ne tas d'allocation au démarrage de l'application.

Allocation de pile sera presque toujours être aussi rapide ou plus rapide que l'allocation de tas, bien qu'il soit certainement possible pour un segment de l'allocateur de simplement utiliser une pile d'allocation basée sur la technique.

Cependant, il ya plus de problèmes lorsqu'ils traitent de la performance globale de la pile vs tas en fonction de répartition (ou légèrement meilleures conditions, locale et ceux de l'extérieur de l'allocation). Généralement, des tas (externe) de l'allocation est lent, car il s'agit de différents types d'allocations et les schémas de répartition. La réduction de la portée de l'allocateur que vous utilisez (le rendant locale de l'algorithme/code) aura tendance à augmenter les performances sans changements majeurs. L'ajout de mieux structurer vos schémas de répartition, par exemple, en forçant un PRINCIPE de la commande sur l'allocation et la libération des paires peut aussi améliorer votre allocateur de performances en utilisant l'allocateur de plus simple et de manière plus structurée. Ou, vous pouvez utiliser ou d'écrire un allocateur à l'écoute de votre allocation de modèle; la plupart des programmes d'allouer quelques discrètes tailles fréquemment, de sorte qu'un segment qui est basé sur un tampon de quelques fixe (de préférence connu) tailles va effectuer très bien. Windows utilise sa faible fragmentation du tas pour cette raison.

Sur l'autre main, une pile d'allocation fondée sur un 32 bits de la mémoire est également périlleuse si vous avez un trop grand nombre de threads. Les piles ont besoin d'une mémoire contiguë, de sorte que le plus de threads que vous avez, le plus d'espace d'adressage virtuel, vous aurez besoin pour eux de courir sans un débordement de pile. Ce ne sera pas un problème (pour l'instant) avec la version 64 bits, mais il peut certainement faire des ravages dans de longues programmes en cours d'exécution avec beaucoup de threads. En cours d'exécution hors de l'espace d'adresse virtuelle en raison de la fragmentation est toujours une douleur à traiter.

Il y a un point de vue général sur de telles optimisations.

L'optimisation que vous obtenez est proportionnelle à la quantité de fois que le compteur de programme est dans le code.

Si vous goûtez le compteur de programme, vous découvrirez où il passe son temps, et c'est en général dans une petite partie du code, et souvent dans les routines de la bibliothèque vous n'avez aucun contrôle sur.

Seulement si vous avez du passer beaucoup de temps dans le tas-répartition de vos objets, il sera nettement plus rapide à la pile de les affecter.

class Foo {
public:
    Foo(int a) {

    }
}
int func() {
    int a1, a2;
    std::cin >> a1;
    std::cin >> a2;

    Foo f1(a1);
    __asm push a1;
    __asm lea ecx, [this];
    __asm call Foo::Foo(int);

    Foo* f2 = new Foo(a2);
    __asm push sizeof(Foo);
    __asm call operator new;//there's a lot instruction here(depends on system)
    __asm push a2;
    __asm call Foo::Foo(int);

    delete f2;
}

Ce serait comme ça en asm. Lorsque vous êtes dans func, le f1 et pointeur f2 a été alloué sur la pile (stockage automatisé). Et par la manière, Foo f1(a1) a pas d'instruction des effets sur le pointeur de pile (esp),Il a été alloué, si func veut obtenir le membre f1, c'est l'instruction est quelque chose comme ceci: lea ecx [ebp+f1], call Foo::SomeFunc(). Une autre chose de la pile allouer peut rendre quelqu'un pense que la mémoire est quelque chose comme FIFO, le FIFO vient de se passer quand vous allez dans une fonction, si vous êtes dans la fonction et allouer quelque chose comme int i = 0, il n'y pas de pression qui s'est passé.

En général, l'allocation de pile est plus rapide que l'allocation de tas, comme mentionné par presque toutes les réponses ci-dessus. Une pile push /pop est O(1), tandis que d'allouer ou libérer d'un segment de mémoire peut exiger d'un pied de précédentes allocations. Cependant vous ne devriez pas généralement attribué au serrés, les performances à forte intensité de boucles, de sorte que le choix viennent généralement en bas à d'autres facteurs.

Il pourrait être bon de faire cette distinction: vous pouvez utiliser une pile allocateur" sur le tas. Strictement parlant, je prends l'allocation de pile à dire la méthode de répartition plutôt qu'à l'emplacement de l'allocation. Si vous êtes à l'allocation de beaucoup de choses sur la pile de programme, qui pourrait être mauvais pour une variété de raisons. D'autre part, à l'aide d'une pile méthode pour allouer sur le tas lorsque cela est possible est le meilleur choix que vous pouvez faire pour une méthode de répartition.

Puisque vous avez mentionné Metrowerks et le PPC, je suppose que tu veux dire Wii. Dans ce cas, la mémoire est à une prime, et à l'aide d'une pile méthode de répartition, dans la mesure du possible des garanties que vous ne perdez pas la mémoire sur des fragments. Bien sûr, cela demande beaucoup plus de soins que la "normale" tas de méthodes de répartition. Il est sage d'évaluer les avantages et les inconvénients de chaque situation.

Préoccupations Spécifiques au Langage C++

Tout d'abord, il n'y a pas de soi-disant "pile" ou "tas" de l'allocation mandaté par le C++. Si vous parlez automatique d'objets dans le bloc de portée, ils sont même pas "affecté". (BTW, automatique de la durée de stockage dans C est certainement PAS le même pour "attribué"; le second est "dynamique" dans le C++ le langage.) Et la mémoire allouée dynamiquement est sur le free store, pas nécessairement sur "le tas", même si ce dernier est souvent l' (par défaut) mise en œuvre.

Bien que, comme par le résumé des règles sémantiques, automatique objets occupent encore de la mémoire, une C++ conforme de la mise en œuvre est autorisé à ignorer ce fait, quand il peut le prouver, ce qui n'a pas d'importance (quand il ne change pas les comportements observables du programme). Cette autorisation est accordée par le comme-si la règle en ISO C++, qui est aussi le grand clause permettant à l'habitude des optimisations (et il y a aussi presque la même règle en ISO C). Outre le cas de la règle, la norme ISO C++ a également copier élision des règles pour autoriser l'omission de certaines créations d'objets. Le constructeur et le destructeur des appels concernés sont donc omis. En conséquence, la fonction des objets (le cas échéant) dans ces constructeurs et destructeurs sont également éliminées, par rapport aux naïfs abstrait sémantique implicite par le code source.

D'autre part, free store allocation est certainement "allocation" de par leur conception. En vertu de la norme ISO C++ règles, une telle répartition peut être obtenue par un appel d'un fonction d'allocation. Cependant, depuis l'ISO C++14, il y a une nouvelle (non-comme-si) règle pour autoriser la fusion de répartition mondiale de fonction (c'est à dire ::operator new) appels dans des cas spécifiques. Ce sont des parties de l'allocation dynamique opérations peuvent également être non-op comme le cas de l'automatique des objets.

Des fonctions d'Allocation de répartir les ressources de la mémoire. Les objets peuvent encore être attribués en fonction de répartition à l'aide d'allocateurs. Automatique des objets, ils sont directement présentés, bien que le sous-jacent de la mémoire peut être consulté et être utilisé pour fournir de la mémoire à d'autres objets (par placement new), mais cela n'a pas grand sens comme le free store, car il n'y a aucun moyen de déplacer les ressources ailleurs.

Toutes les autres préoccupations sont hors de la portée de C++. Néanmoins, ils peuvent encore être importante.

Sur les Implémentations de C++

C++ ne pas exposer réifiée de l'activation des enregistrements ou des sortes de première classe de suites (par exemple, par le célèbre call/cc), il n'y a aucun moyen de manipuler directement l'activation de l'enregistrement d'images où la mise en œuvre de placer le automatique des objets. Une fois n'est pas (non portable) interoperations avec l'implémentation sous-jacente ("native" du code non portable, tels que le code d'assembly en ligne), d'une omission de la sous-répartition des cadres peut être tout à fait banale. Par exemple, lorsque la fonction appelée est insérée, les images peuvent être efficacement fusionné dans d'autres, il n'existe aucun moyen de montrer ce qu'est la "répartition".

Cependant, une fois que interops sont respectés, les choses sont plus complexes. Typique de mise en œuvre de C++, va exposer à la capacité de l'interopérabilité sur ISA (instruction set architecture), avec quelques conventions d'appel binaire frontière partagée avec les autochtones (ISA-machine) du code. Ce serait explicitement coûteux, notamment, lors de l'entretien de la pointeur de pile, qui est souvent directement détenus par une administration chargée de niveau de registre (avec probablement spécifique à la machine des instructions d'accès). Le pointeur de pile indique la limite de la partie supérieure du cadre de l' (en cours) d'appel de fonction. Lorsqu'un appel de fonction est entré, une nouvelle image est nécessaire, et le pointeur de pile est ajoutée ou soustraite (selon la convention de l'ISA) par une valeur non moins que la taille de l'image. L'image est alors dit alloué lorsque le pointeur de pile, après les opérations. Les paramètres des fonctions peuvent être transférés sur le frame de pile ainsi, selon la convention d'appel utilisé pour l'appel. Le cadre peut contenir la mémoire automatique des objets (dont probablement les paramètres spécifiés par le code source C++. Dans le sens de la mise en œuvre, ces objets sont "attribués". Lorsque la commande quitte l'appel de la fonction, l'image n'est plus nécessaire, il est généralement libérés par la restauration du pointeur de pile de revenir à l'état avant l'appel (préalablement enregistrée conformément à la convention d'appel). Ceci peut être considéré comme "libération". Ces opérations fait l'historique d'activation effectivement un PRINCIPE de structure de données, de sorte qu'il est souvent appelé "l' (appel) de la pile". Le pointeur de pile efficacement indique la position du haut de la pile.

Parce que la plupart C++ implémentations (en particulier ceux de ciblage de l'ISA au niveau du code natif et à l'aide de la langue de l'assembly que sa sortie immédiate) utilise des stratégies similaires comme cela, par exemple la confusion "allocation" régime est populaire. Ces allocations (ainsi que deallocations) faire passer les cycles machine, et il peut être coûteux lors de la (non optimisé) les appels se produisent fréquemment, même si moderne CPU microarchitectures peut avoir des optimisations mises en œuvre par le matériel pour la commune de modèle de code (comme l'utilisation d'un de la pile du moteur dans la mise en œuvre PUSH/POP instructions).

Mais de toute façon, en général, il est vrai que le coût de la trame de pile de répartition est nettement moins qu'un appel à une fonction d'attribution de l'exploitation du magasin gratuit (sauf s'il est totalement optimisé loin), qui lui-même peut avoir des centaines d' (si ce n'est des millions d' 🙂 les opérations de maintenir le pointeur de pile et d'autres états. Fonctions d'Allocation sont généralement basés sur l'API fournie par l'environnement hébergé (par exemple d'exécution fournis par le système d'exploitation). Différentes pour le but de la détention automatique des objets pour les appels de fonctions, ces affectations sont générale-dessein, de sorte qu'ils n'auront pas la structure du cadre, comme une pile. Traditionnellement, ils allouer de l'espace de la piscine de stockage appelé tas (ou plusieurs tas). Différente de la "pile", le concept de "tas", ici, n'indique pas la structure de données utilisée; il est dérivé du début des implémentations de langue il y a des décennies. (BTW, la pile d'appel est généralement attribuée à revenu fixe ou spécifié par l'utilisateur, la taille du segment de mémoire de l'environnement dans le programme ou le fil de démarrage.) La nature de l'utilisation des cas, les allocations et les deallocations à partir d'un tas beaucoup plus compliqué (que de la pousser ou de la pop de la pile d'images), et ne peut pas être directement optimisée par le matériel.

Effets sur l'Accès à la Mémoire

L'habitude de la pile de répartition de toujours mettre la nouvelle image sur le dessus, de sorte qu'il a une assez bonne localité. C'est sympathique de cache. Otoh, que, la mémoire allouée au hasard dans le magasin libre n'a pas cette propriété. Depuis ISO C++17, il y a des ressources du pool de modèles fournis par les <memory>. Le but immédiat de cette interface est de permettre à des résultats consécutifs à des allocations à proximité de la mémoire. Cette reconnaît le fait que cette stratégie est généralement bon pour les performances contemporaines mises en œuvre, par exemple, être aimable à cache dans les architectures modernes. C'est à propos de la performance de accès plutôt que allocation, si.

Simultanéité

Attente de l'accès simultané de la mémoire peuvent avoir des effets différents entre la pile et le tas. Une pile d'appel est généralement exclusivement détenue par un seul thread d'exécution dans une implémentation C++. Otoh, que, tas sont souvent partagé entre les threads d'un processus. Pour ces tas, l'allocation et la désallocation de fonctions pour protéger l'interne commun de données administratives de la structure de données de la course. En conséquence, les allocations de tas et deallocations peut avoir d'autres frais généraux en raison de la synchronisation interne des opérations.

L'Efficacité De L'Espace

En raison de la nature du cas d'utilisation et des structures de données internes, des tas souffre de interne la fragmentation de la mémoire, tandis que la pile ne fonctionne pas. Cela n'a pas d'impacts directs sur la performance de l'allocation de mémoire, mais dans un système avec la mémoire virtuelle, peu d'espace, l'efficacité peut dégénérer les performances globales d'accès à la mémoire. C'est particulièrement horrible lorsque le disque dur est utilisé en tant que swap de la mémoire physique. Il peut causer de très long temps de latence parfois des milliards de cycles.

Limites de la Pile Allocations

Bien que la pile allocations sont souvent supérieurs à la performance que les allocations de tas dans la réalité, il ne veut certainement pas dire pile allocations pouvez toujours remplacer les allocations de tas.

Tout d'abord, il n'existe aucun moyen pour allouer de l'espace sur la pile avec une taille spécifiée au moment de l'exécution de façon portable avec ISO C++. Il y a des extensions fournies par les implémentations comme alloca et G++'s VLA (de longueur variable tableau), mais il y a des raisons à éviter de les utiliser. (IIRC, source de Linux supprime l'utilisation de VLA récemment.) (À noter également la norme ISO C99 n'ont VLA, mais l'ISO C11 tourne le soutien facultatif.)

Deuxième, il n'y a pas de portable et fiable afin de détecter pile épuisement de l'espace. Ceci est souvent appelé débordement de pile (hmm, l'étymologie de ce site), mais probablement plus accruately, "débordements de pile". En réalité, ce qui provoque souvent des accès non valide de la mémoire et de l'état du programme est alors corruptied (...ou peut-être pire, un trou de sécurité). En fait, l'ISO C++ n'a pas de notion de pile et en fait un comportement indéfini lorsque la ressource est épuisée. D'être prudent sur la façon dont beaucoup de place devrait être à gauche pour le réglage automatique des objets.

Si l'espace de pile épuisée, il y a trop d'objet alloué dans la pile, qui peut être causée par de trop nombreux appels de fonctions ou de la mauvaise utilisation de l'objet. De tels cas peuvent suggérer l'existence de bugs, par exemple, une fonction récursive appel sans corriger les conditions de sortie.

Néanmoins, profonde appels récursifs sont parfois souhaitée. Dans les implémentations de langues qui ont besoin de soutien de unbound les appels actifs (profondeur d'appel uniquement limité par la mémoire totale), il est impossible pour utiliser l'appel des indigènes de la pile directement en tant que la langue cible activation de l'enregistrement comme typique de C++ implémentations. Par exemple, SML/NJ explicitement alloue images sur le tas et utilise cactus piles. La complexité de la répartition de ces activation de l'enregistrement d'images n'est généralement pas rapide comme la pile d'appel des cadres. Cependant, lors de la poursuite de la mise en œuvre de langues avec la bonne queue de récursivité, direct allocation de pile dans la langue d'objet (qui est, "l'objet" dans la langue ne pas stocker les références, mais des valeurs primitives qui peut être un-à-un localisé sur le partage des objets en C++) est encore plus compliqué avec plus de performances en général. Lors de l'utilisation de C++ en œuvre de ces langues, il est difficile d'estimer l'impact sur les performances.

Je voudrais dire, en fait le code générer par GCC (je me souviens VS aussi) n'ont pas les frais généraux de faire de l'allocation de pile.

Dire pour la fonction suivante:

  int f(int i)
  {
      if (i > 0)
      {   
          int array[1000];
      }   
  }

Voici le code générer:

  __Z1fi:
  Leh_func_begin1:
      pushq   %rbp
  Ltmp0:
      movq    %rsp, %rbp
  Ltmp1:
      subq    $**3880**, %rsp <--- here we have the array allocated, even the if doesn't excited.
  Ltmp2:
      movl    %edi, -4(%rbp)
      movl    -8(%rbp), %eax
      addq    $3880, %rsp
      popq    %rbp
      ret 
  Leh_func_end1:

Donc whatevery combien de variable locale, vous avez (même à l'intérieur si ou commutateur), juste le 3880 va changer pour une autre valeur. Sauf si vous n'avez pas de variable locale, cette instruction juste besoin d'exécuter. Donc allouer une variable n'ont pas les frais généraux.