lernen auf Probe, wahrscheinlich() und unwahrscheinlich() compiler-Hinweise

Wie kann ich demonstrieren für Studierende der usability von likely und unlikely compiler-Hinweise (__builtin_expect)?

Können Sie schreiben, ein Beispiel-code, die wird mehrmals schneller mit diesen Andeutungen Vergleich der code ohne Hinweise.

  • kerneltrap.org/node/4705
  • Crowder, ja. aber ich will ein Beispiel Programm, in dem die Studierenden können den Unterschied SPÜREN, es nicht zu Lesen in assembler.
  • Sie bekommen nicht solch ein Beispiel, denn es ist kein Unterschied zu spüren. Das ist das Schlimmste, hässlichste Art von nutzlos Mikro-Optimierung.
  • aber Linux-kernel aktiv verwenden. Auch der Programmierer weiß viel über sein Programm und markieren können selten verwendete code besser als der compiler dies erkennt.
  • Linux-kernel ist aktiv schreiben alle möglichen Dinge, die sind schrecklich C. ich bin damit einverstanden kann der Programmierer besser wissen, welche Filiale ist wahrscheinlicher, aber das bedeutet nicht, dass ich Unterstützung hässliche vorzeitige Mikro-Optimierung alle über dem Platz. Es ist wirklich selten, dass diese hässliche likely Makros erzeugen keine wahrnehmbaren performance-Vorteil.
  • Wenn Sie denken, dass wahrscheinlich/unwahrscheinlich nicht geben kann, keinen nutzen, Sie Katze öffnen Sie eine neue Frage. Aber diese Frage eröffnet wurde, auf Wunsch von meinem Freund. Er ist ein CS-Lehrer von erste-Jahr-Studenten, und er wollte Ihnen zeigen, ein wahrscheinlich/unwahrscheinlich Beispiel. Er war nicht in der Lage, zu produzieren, ein Beispiel, so fragte ich diese q. Ich weiß nicht, ist in diesem Beispiel erforderlich, die durch natürlich oder fügt er es von selbst. Aber das Ziel ist es, zu geben, grundlegende Verständnis, wahrscheinlich Studenten.
  • Welche Art von erste-Jahr CS Lehrer lehrt die Schüler vorzeitigen Mikro-Optimierung? Er sollte lehren Sie die richtige Sprache erste und höhere Effizienz-überlegungen (wie die Arbeit mit Daten in-place statt der Zuweisung kopiert, effiziente algorithmen mit Bezug zu Zeit und Raum, etc.). Wenn likely und unlikely sind gelehrt in CS-Lehrplan, es sollte ein senior-Jahr Thema.
  • Seine Russland. Ersten Jahr der high school. Was meinst du als "senior-Jahr"?
  • Dieser Lehrer ist der coach von ACM-team, das übergeben halb-Finale oder sogar endgültig. Also, ich denke, er lehrt Sie eine Menge von high-level Optimierung. Auch dies unwahrscheinlich/wahrscheinlich war nicht die erste Lektion, aber es war nur ein Teil der Lektion, in der Mitte des Jahres.

InformationsquelleAutor osgx | 2010-04-29
  1. 23

    Hier ist der, den ich verwenden, ein wirklich ineffiziente Umsetzung der Fibonacci-zahlen:

    #include <stdio.h>
#include <inttypes.h>
#include <time.h>
#include <assert.h>

#define likely(x) __builtin_expect((x),1)
#define unlikely(x) __builtin_expect((x),0)

uint64_t fib(uint64_t n)
{
    if (opt(n == 0 || n == 1)) {
        return n;
    } else {
        return fib(n - 2) + fib(n - 1);
    }
}

int main(int argc, char **argv)
{
    int i, max = 45;
    clock_t tm;

    if (argc == 2) {
        max = atoi(argv[1]);
        assert(max > 0);
    } else {
        assert(argc == 1);
    }

    tm = -clock();
    for (i = 0; i <= max; ++i)
        printf("fib(%d) = %" PRIu64 "\n", i, fib(i));
    tm += clock();

    printf("Time elapsed: %.3fs\n", (double)tm / CLOCKS_PER_SEC);
    return 0;
}

    Demonstrieren, mit GCC:

    ~% gcc -O2 -Dopt= -o test-nrm test.c
~% ./test-nrm
...
fib(45) = 1134903170
Time elapsed: 34.290s

~% gcc -O2 -Dopt=unlikely -o test-opt test.c
~% ./test-opt
...
fib(45) = 1134903170
Time elapsed: 33.530s

    Wenige hundert Millisekunden weniger. Dieser Gewinn ist aufgrund der Programmierer-aided branch prediction.

    Aber jetzt, für das, was der Programmierer sollte wirklich tun, statt:

    ~% gcc -O2 -Dopt= -fprofile-generate -o test.prof test.c
~% ./test.prof 
...
fib(45) = 1134903170
Time elapsed: 77.530s  /this run is slowed down by profile generation.

~% gcc -O2 -Dopt= -fprofile-use -o test.good test.c
~% ./test.good
fib(45) = 1134903170
Time elapsed: 17.760s

    Compiler-aided runtime profiling, haben wir es geschafft zu reduzieren, von der ursprünglichen 34.290 s zu 17.760 s. Viel besser als mit Programmierer-aided branch prediction!

    • Profil ist das gute option, aber ich brauche, um zu demonstrieren likely und unlikely
    • aah, tm = -clock(); tm += clock(); ist schön, ich habe nicht gesehen, danke!
    • Ich denke, was dieses zeigt, ist, dass likely und unlikely sind nicht sehr nützlich. Vielleicht auch, dass dies eine wirklich schlechte Umsetzung von fib()...
    • R.., Dies ist nur ein Studium, und zeigen, dass manchmal wahrscheinlich ein wenig helfen.
    • Wo sind likely und unlikely eigentlich im obigen code?
    • hanson: Sie übergeben Sie es als compiler definieren -Dopt=
    • Auf meinem laptop: -Dopt= ==> 44.284 s, -Dopt=unwahrscheinlich ==> 43.833 s | -Dopt= -fprofile-generate ==> 27.563 s, -Dopt= -fprofile-use - ==> 21.878 s | -Dopt=unwahrscheinlich -fprofile-generate ==> 27.245 s, -Dopt=unwahrscheinlich -fprofile-use - ==> 21.863 s (gcc version 4.8.4) Ich denke, der nutzen ist es sowieso, wenn Sie schreiben einen linux-scheduler...

    InformationsquelleAutor Juliano
Schreibe einen Kommentar