Warum ist istream/ostream langsam

50:40 von http://channel9.msdn.com/Events/GoingNative/2013/Writing-Quick-Code-in-Cpp-Quickly Andrei Alexandrescu macht einen Witz darüber, wie Sie nicht effizient/langsam istream ist.

Hatte ich ein Problem in der Vergangenheit mit ostream langsam und fwrite deutlich schneller (Reduzierung viele Sekunden beim ausführen der main-Schleife einmal), aber ich habe nie verstanden, warum noch geprüft.

Was macht istream und ostream langsam in C++? oder zumindest langsam im Vergleich zu anderen Dingen (wie fread/fget, fwrite), die auch befriedigt die Bedürfnisse.

InformationsquelleAutor | 2013-09-08
  1. 43

    Eigentlich IOStreams müssen nicht langsam sein! Es ist eine Frage der Umsetzung Sie in einem angemessenen Weg, um Sie schnell. Die meisten standard-C++ - Bibliothek scheinen nicht zu viel Aufmerksamkeit zu implementieren IOStreams. Vor langer Zeit, als mein CXXRT war noch eingehalten, es war in etwa so schnell wie stdio - wenn es richtig eingesetzt wird!

    Beachten Sie, dass es einige performance-fallen für Benutzer ausgelegt, die mit IOStreams, jedoch. Die folgenden Richtlinien gelten für alle IOStream-Implementierungen, aber vor allem für diejenigen, die sind auf schnell sein:

    1. Bei der Verwendung std::cin, std::cout usw. müssen Sie rufen Sie std::sync_with_stdio(false)! Ohne diesen Aufruf, jegliche Nutzung der standard-stream-Objekte ist erforderlich, um die Synchronisierung mit C standard-streams. Natürlich, bei der Verwendung von std::sync_with_stdio(false) es wird davon ausgegangen, dass Sie nicht mischen std::cin mit stdin, std::cout mit stdout usw.
    2. Jedoch nicht verwenden Sie std::endl , wie es Mandate viele unnötige Leerungen Puffer. Ebenfalls nicht festgelegt std::ios_base::unitbuf oder verwenden Sie std::flush unnötig.
    3. Bei der Erstellung Ihrer eigenen stream-Puffer (OK, einige Benutzer tun), stellen Sie sicher, Sie verwenden einen internen Puffer! Die Bearbeitung der einzelnen Zeichen Sprünge durch die mehrere Bedingungen und einen virtual Funktion macht es schrecklich langsam.
    • behoben! Danke!
    • +1 Für den Hinweis auf, dass es vor allem ein problem mit der Umsetzung, nicht die Bibliothek selbst. Effiziente iostreams Umsetzung ist auch eines der wichtigsten Anliegen in der C++ Performance Report veröffentlicht, die von der ISO-Komitees im Jahr 2006.
    • Wie es geschieht, viel von dem material auf die Leistung der IOStreams basiert auf meine Beiträge 🙂 (die Beiträge sind nicht zurückzuführen auf Ihre jeweiligen Autoren; die Autoren sind auf Seite 6 aufgeführt, jedoch).
    InformationsquelleAutor Dietmar Kühl
  2. 9

    Vielleicht dies kann Ihnen eine Vorstellung davon, was Sie zu tun haben:

    #include <stdio.h>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <fstream>
#include <time.h>
#include <string>
#include <algorithm>

unsigned count1(FILE *infile, char c) { 
    int ch;
    unsigned count = 0;

    while (EOF != (ch=getc(infile)))
        if (ch == c)
            ++count;
    return count;
}

unsigned int count2(FILE *infile, char c) { 
    static char buffer[8192];
    int size;
    unsigned int count = 0;

    while (0 < (size = fread(buffer, 1, sizeof(buffer), infile)))
        for (int i=0; i<size; i++)
            if (buffer[i] == c)
                ++count;
    return count;
}

unsigned count3(std::istream &infile, char c) {    
    return std::count(std::istreambuf_iterator<char>(infile), 
                    std::istreambuf_iterator<char>(), c);
}

unsigned count4(std::istream &infile, char c) {    
    return std::count(std::istream_iterator<char>(infile), 
                    std::istream_iterator<char>(), c);
}

unsigned int count5(std::istream &infile, char c) {
    static char buffer[8192];
    unsigned int count = 0;

    while (infile.read(buffer, sizeof(buffer)))
        count += std::count(buffer, buffer+infile.gcount(), c);
    count += std::count(buffer, buffer+infile.gcount(), c);
    return count;
}

unsigned count6(std::istream &infile, char c) {
    unsigned int count = 0;
    char ch;

    while (infile >> ch)
        if (ch == c)
            ++count;
    return count;
}

template <class F, class T>
void timer(F f, T &t, std::string const &title) { 
    unsigned count;
    clock_t start = clock();
    count = f(t, 'N');
    clock_t stop = clock();
    std::cout << std::left << std::setw(30) << title << "\tCount: " << count;
    std::cout << "\tTime: " << double(stop-start)/CLOCKS_PER_SEC << "\n";
}

int main() {
    char const *name = "equivs2.txt";

    FILE *infile=fopen(name, "r");

    timer(count1, infile, "ignore");

    rewind(infile);
    timer(count1, infile, "using getc");

    rewind(infile);
    timer(count2, infile, "using fread");

    fclose(infile);

    std::ifstream in2(name);
    timer(count3, in2, "ignore");

    in2.clear();
    in2.seekg(0);
    timer(count3, in2, "using streambuf iterators");

    in2.clear();
    in2.seekg(0);
    timer(count4, in2, "using stream iterators");

    in2.clear();
    in2.seekg(0);
    timer(count5, in2, "using istream::read");

    in2.clear();
    in2.seekg(0);
    timer(count6, in2, "using operator>>");

    return 0;
}

    Läuft, bekomme ich Ergebnisse wie dieses (mit MS-VC++):

    ignore                          Count: 1300     Time: 0.309
using getc                      Count: 1300     Time: 0.308
using fread                     Count: 1300     Time: 0.028
ignore                          Count: 1300     Time: 0.091
using streambuf iterators       Count: 1300     Time: 0.091
using stream iterators          Count: 1300     Time: 0.613
using istream::read             Count: 1300     Time: 0.028
using operator>>                Count: 1300     Time: 0.619

    und diese (mit MinGW):

    ignore                          Count: 1300     Time: 0.052
using getc                      Count: 1300     Time: 0.044
using fread                     Count: 1300     Time: 0.036
ignore                          Count: 1300     Time: 0.068
using streambuf iterators       Count: 1300     Time: 0.068
using stream iterators          Count: 1300     Time: 0.131
using istream::read             Count: 1300     Time: 0.037
using operator>>                Count: 1300     Time: 0.121

    Wie wir sehen in den Ergebnissen, es ist nicht wirklich eine Angelegenheit von iostreams wird kategorisch langsam. Eher, viel genau hängt davon ab, wie Sie verwenden iostreams (und in geringerem Maße FILE * auch). Es gibt auch eine ziemlich beträchtliche Unterschiede zwischen diesen zu-Implementierungen.

    Dennoch, den schnellsten Versionen, die mit jeder (fread und istream::read) sind im wesentlichen gebunden. Mit VC++ getc ist ein bisschen langsamer als die beiden istream::read oder und istreambuf_iterator.

    Fazit: gute Leistung von iostreams erfordert ein wenig mehr Pflege als mit FILE * -- aber es ist sicherlich möglich. Sie geben Ihnen auch mehr Optionen: Komfort, wenn Sie don ' T care so viel über die Geschwindigkeit und Leistung, die direkt im Wettbewerb mit das beste, was Sie können erhalten von C-style-I/O, mit ein wenig zusätzliche Arbeit.

    • Da meine Bearbeiten haben Sie abgelehnt: Ihr istream::read-version hat einen bug. Das Letzte Stück der Zeichen nicht markiert, siehe hier.
    • Praktisch. Auch, wenn Sie kopieren count6 zu einem neuen count7 mit "while (infile.get(ch))" und du wirst sehen, dass es doppelt so schnell wie der operator>> aber immer noch doppelt so langsam wie getc.
    • Ja-egal, wie viele ich hinzufügen, gibt es mindestens drei weitere, die Hinzugefügt werden könnten. Wenn (zum Beispiel) eine andere Methode wäre schneller als alles andere, würde ich wahrscheinlich hinzufügen, dass es--aber andere, die mehr oder weniger in der Mitte der Packung einfach nicht, wie es scheint lohnt sich die Mühe...
    • Gut wäre es nützlich für diejenigen (wie mich), die einen Vergleich der aktuellen Zustand von etwas code, um die anderen Optionen. Ich bin ziemlich enttäuscht, dass istream::get verbringt viel Zeit mit der Eingabe und verlassen der kritischen Abschnitte in einige single-threaded-code, den ich erhalten. ; - ) Trotzdem, vielen Dank für den handy-test-suite.
    InformationsquelleAutor Jerry Coffin
  3. 0

    Während diese Frage ist ziemlich alt, ich bin überrascht, niemand hat erwähnt iostream-Objekt-Konstruktion.

    Ist, dass, wenn Sie erstellen eine STL - iostream (und anderen stream-Varianten), wenn Sie Schritt in den code, der Konstruktor ruft eine interne Init Funktion. Dort operator new wird aufgerufen, um eine neue zu erstellen locale Objekt.
    Und ebenso ist zerstört, auf Zerstörung.

    Dies ist hässlich, IMHO. Und trägt sicherlich zu langsam-Objekt-Konstruktion/Zerstörung, da Speicher reserviert/freigegeben, mit einem system sperren, irgendwann.

    Weiter, einige der STL-streams können Sie angeben, eine allocator, also warum ist die locale erstellt, NICHT über die angegebene Zuweisung?

    Mithilfe von streams in einer Multithread-Umgebung, Sie könnte sich auch vorstellen, den Engpass auferlegt durch den Aufruf operator new jedes mal, wenn ein neues stream-Objekt konstruiert wird.

    Grässliches Chaos, wenn du mich fragst, wie ich finde mich jetzt!

    • Karl Knechtel, sagt here: "(...) Diese Aufgabe ist fast sicher E/A-gebunden und es gibt viel zu viel FUD zu gehen um über die Kosten zu erstellen std::string-Objekte in C++ oder mit <iostream> in und von sich selbst."
    InformationsquelleAutor dicksters
Schreibe einen Kommentar