Qu'est-ce que le code Réutilisable , Chaud code et des points Chauds?

Je sais que ces termes sont utilisés dans le cadre de l'atteinte du rendement. Ces jours, je suis en train de travailler sur, et qui ont cherché à savoir à propos de ces de internet mais n'ai obtenu aucun exemple qui présentent clairement ces concepts avec l'existence de ces problèmes et les concepts dans le monde réel des scénarios de développement. Quelqu'un peut-il veuillez expliquer en détail ces conditions, l'exemple des scénarios, et où ces concepts et de termes qui sont susceptibles d'avoir été utilisées.

Grâce.

Une question pour les Programmeurs de la pile?

OriginalL'auteur static void main | 2011-10-27

  1. 15

    "Standard" n'a rien à voir avec la performance: cela signifie simplement standard code qui est nécessaire pour définir une application ou de travailler avec un certain cadre. C'est le code qui est susceptible d'être identique dans chaque application.

    Un "hot spot", d'autre part, signifie une partie du code qui est exécuté plusieurs fois, et donc de sa performance est très important pour l'ensemble de la performance de l'application. Habituellement, un point chaud est identifié par profilage réel: ce n'est pas un point chaud si il est exécuté plusieurs fois mais c'est tellement trivial que son impact sur les performances est minime.

    OriginalL'auteur Ernest Friedman-Hill

  2. 4

    Code réutilisable

    "à chaud "code" est évolutif, bien écrit, code

    "hot spots" sont une zone d'intense activité. Ils sont des points chauds, car ils sont fréquemment exécutées code.

    OriginalL'auteur viktor

  3. 3

    Une définition de "hot spot" est une région de code où le compteur de programme, passe une bonne fraction de son temps.
    Le terme est "goulot d'étranglement" qui, bien que mal définie, fait généralement référence à un code localisé à une fonction, la routine, ou de la méthode, qui provoque une grande fraction de temps que nécessaire.

    Ces deux termes sont très trompeur, car il y a une énorme non écrite hypothèse.
    L'hypothèse est qu'il n'y a pas de possibilités pour accélérer un programme qui ne sont pas d'un point d'accès ou un goulot d'étranglement.
    Accélération des opportunités peuvent être de plus en plus diffuses que cela, et si elles ne sont pas résolus, ils deviennent la performance limiteur.

    Permettez-moi de donner un exemple.
    Récemment, lorsque l'on travaille sur un programme en C++ d'environ 300 lignes, j'ai pris dix stackshots, parce que je voulais voir comment je pourrais accélérer.
    Quatre de ces stackshots ressemblait à ceci:

    CTypedPtrArray<CPtrArray,COperation *>::operator[]() line 1555 + 23 bytes
TcProcess() line 246 + 14 bytes ---> COperation* pOp = oplist[i];
CMhAck::Handler() line 165
doit() line 297 + 12 bytes
main() line 318

CTypedPtrArray<CPtrArray,CJob *>::operator[]() line 1555 + 23 bytes
SchProcess() line 212 + 14 bytes ---> pJob = joblist[i];
COpAck::Handler() line 145
doit() line 297 + 12 bytes
main() line 318

CTypedPtrArray<CPtrArray,CTask *>::operator[]() line 1555 + 23 bytes
TcProcess() line 249 + 18 bytes ---> pTask = pOp->tasks[pOp->iCurTask];
CMhAck::Handler() line 165
doit() line 297 + 12 bytes
main() line 318

CTypedPtrArray<CPtrArray,CTask *>::operator[]() line 1555 + 23 bytes
COperation::~COperation() line 57 + 15 bytes ---> CTask* p = tasks[i];
COperation::`scalar deleting destructor'() + 37 bytes
TcProcess() line 259 + 28 bytes
CTskAck::Handler() line 193
doit() line 297 + 12 bytes
main() line 318

    Le programme a pris 20 secondes dans l'ensemble.
    Ce que ces pile échantillons me dis est d'environ 40% de ce temps, ou 8 secondes, est passé à l'indexation de l'opérateur sur le tableau de la classe.
    Qui me dit que je pourrait réduire les temps de 20 secondes à 12 secondes, donner ou prendre, si je pouvais faire indexation plus directement, pas par le biais d'un appel de fonction.
    L'accélération serait 20/12 = 1.67, soit environ 67% de l'accélération.
    (Avis: je ne donne pas une huée au sujet de "exacte" quand il s'agit de timing. Ce que je voulais faire était de trouver le problème.)

    Maintenant, on peut facilement être en désaccord avec cette méthode de résolution du problème, mais vous pouvez voir comment j'ai détecté quel était le problème, droit?

    OK, où est donc le "hotspot" et où est le "goulot d'étranglement"?
    Clairement il y a un hotspot dans l'indexation de l'opérateur de la fonction, mais c'est que là où est le problème?
    (En fait, c'est même pas ça, parce que c'est trois fonctions différentes.)
    Est-ce à dire que je devrais essayer de faire que la routine la plus rapide?
    Je n'ai pas encore propre!

    Est-il un goulot d'étranglement dans la forme de certains lente "de routine"?
    Non!
    Il n'y a aucune routine qui est lent, ou un "mauvais" algorithme.

    Ce que j'ai fait faire un description de ce qu'il était en train de faire ("C'est l'indexation de certaines routines.") d'où cette description s'applique à une grande partie du temps.

    Le meilleur terme, je peux venir avec ces choses, c'est "le temps des cerveaux", car elle y consacre une grande partie de temps à faire des choses qui ne sont pas vraiment ont à faire.

    Plus au sujet de la terminologie et des idées reçues.

    OriginalL'auteur Mike Dunlavey

  5. 0

    Mon hypothèse, c'est que vous avez déjà suffisamment de définitions pour le terme "standard". Je serais probablement souhaitez sauvegarder ce que vous avez avec l'aide d'un exemple.
    Venant de Java arrière-plan, et, récemment, le déplacement à la Scala, vous vous rendez compte qu'en Java, on ne peut pas écrire des énoncés dépourvus de points-virgules (;). En outre, il n'est pas rare d'écrire des milliers de déclarations pour un programme qui est probablement en cours d'exécution dans la production. Votre supposition est aussi bonne que la mienne, vous finissez par écrire beaucoup de choses répétitives à faible impact code mais il se trouve être le code qui est demandé par le compilateur Java. Scala est une langue concise, dans le sens que le besoin d'écrire du code réutilisable a été réduit. Vous n'avez pas à écrire des points-virgules en Scala. J'espère que cela est assez simpliste

    OriginalL'auteur Davis Osiemo