Warum ist das Lesen von Zeilen aus stdin in C ++ viel langsamer als in Python?

Ich wollte das Lesen von Zeilen der Zeichenfolgeneingabe von stdin mit Python und C ++ vergleichen und war schockiert, als mein C ++ - Code eine Größenordnung langsamer als der entsprechende Python-Code ausgeführt wurde. Da mein C ++ rostig ist und ich noch kein Pythonista-Experte bin, sagen Sie mir bitte, ob ich etwas falsch mache oder ob ich etwas falsch verstehe.

(TLDR-Antwort: Fügen Sie die Anweisung hinzu: cin.sync_with_stdio(false)oder verwenden Sie fgetsstattdessen einfach .

TLDR-Ergebnisse: Scrollen Sie bis zum Ende meiner Frage und sehen Sie sich die Tabelle an.)

C ++ - Code:

#include <iostream>
#include <time.h>

using namespace std;

int main() {
    string input_line;
    long line_count = 0;
    time_t start = time(NULL);
    int sec;
    int lps;

    while (cin) {
        getline(cin, input_line);
        if (!cin.eof())
            line_count++;
    };

    sec = (int) time(NULL) - start;
    cerr << "Read " << line_count << " lines in " << sec << " seconds.";
    if (sec > 0) {
        lps = line_count / sec;
        cerr << " LPS: " << lps << endl;
    } else
        cerr << endl;
    return 0;
}

// Compiled with:
// g++ -O3 -o readline_test_cpp foo.cpp

Python-Äquivalent:

#!/usr/bin/env python
import time
import sys

count = 0
start = time.time()

for line in  sys.stdin:
    count += 1

delta_sec = int(time.time() - start_time)
if delta_sec >= 0:
    lines_per_sec = int(round(count/delta_sec))
    print("Read {0} lines in {1} seconds. LPS: {2}".format(count, delta_sec,
       lines_per_sec))

Hier sind meine Ergebnisse:

$ cat test_lines | ./readline_test_cpp
Read 5570000 lines in 9 seconds. LPS: 618889

$cat test_lines | ./readline_test.py
Read 5570000 lines in 1 seconds. LPS: 5570000

Ich sollte beachten, dass ich dies sowohl unter Mac OS X 10.6.8 (Snow Leopard) als auch unter Linux 2.6.32 (Red Hat Linux 6.2) versucht habe. Ersteres ist ein MacBook Pro, und letzteres ist ein sehr leistungsfähiger Server, nicht dass dies zu relevant wäre.

$ for i in {1..5}; do echo "Test run $i at `date`"; echo -n "CPP:"; cat test_lines | ./readline_test_cpp ; echo -n "Python:"; cat test_lines | ./readline_test.py ; done
Test run 1 at Mon Feb 20 21:29:28 EST 2012
CPP:   Read 5570001 lines in 9 seconds. LPS: 618889
Python:Read 5570000 lines in 1 seconds. LPS: 5570000
Test run 2 at Mon Feb 20 21:29:39 EST 2012
CPP:   Read 5570001 lines in 9 seconds. LPS: 618889
Python:Read 5570000 lines in 1 seconds. LPS: 5570000
Test run 3 at Mon Feb 20 21:29:50 EST 2012
CPP:   Read 5570001 lines in 9 seconds. LPS: 618889
Python:Read 5570000 lines in 1 seconds. LPS: 5570000
Test run 4 at Mon Feb 20 21:30:01 EST 2012
CPP:   Read 5570001 lines in 9 seconds. LPS: 618889
Python:Read 5570000 lines in 1 seconds. LPS: 5570000
Test run 5 at Mon Feb 20 21:30:11 EST 2012
CPP:   Read 5570001 lines in 10 seconds. LPS: 557000
Python:Read 5570000 lines in  1 seconds. LPS: 5570000

Winziger Benchmark-Nachtrag und Zusammenfassung

Der Vollständigkeit halber dachte ich, ich würde die Lesegeschwindigkeit für dieselbe Datei auf derselben Box mit dem ursprünglichen (synchronisierten) C ++ - Code aktualisieren. Dies gilt wiederum für eine 100-MB-Zeilendatei auf einer schnellen Festplatte. Hier ist der Vergleich mit mehreren Lösungen / Ansätzen:

Implementation      Lines per second
python (default)           3,571,428
cin (default/naive)          819,672
cin (no sync)             12,500,000
fgets                     14,285,714
wc (not fair comparison)  54,644,808

Standardmäßig wird cines mit stdio synchronisiert, wodurch jegliche Eingabepufferung vermieden wird. Wenn Sie dies oben in Ihrem Hauptfenster hinzufügen, sollten Sie eine viel bessere Leistung sehen:

std::ios_base::sync_with_stdio(false);

Wenn ein Eingabestream gepuffert wird, wird der Stream normalerweise in größeren Blöcken gelesen, anstatt jeweils ein Zeichen zu lesen. Dies reduziert die Anzahl der Systemaufrufe, die typischerweise relativ teuer sind. Da die FILE*basierten stdiound iostreamshäufig getrennten Implementierungen und daher getrennte Puffer haben, könnte dies zu einem Problem führen, wenn beide zusammen verwendet würden. Zum Beispiel:

int myvalue1;
cin >> myvalue1;
int myvalue2;
scanf("%d",&myvalue2);

Wenn mehr Eingaben gelesen würden, cinals tatsächlich benötigt würden, wäre der zweite ganzzahlige Wert für die scanfFunktion, die über einen eigenen unabhängigen Puffer verfügt, nicht verfügbar . Dies würde zu unerwarteten Ergebnissen führen.

Um dies zu vermeiden, werden Streams standardmäßig mit synchronisiert stdio. Eine übliche Möglichkeit, dies zu erreichen, besteht darin cin, jedes Zeichen nach Bedarf mithilfe von stdioFunktionen einzeln zu lesen . Dies führt leider zu einem hohen Overhead. Bei kleinen Eingaben ist dies kein großes Problem, aber wenn Sie Millionen von Zeilen lesen, ist der Leistungsverlust erheblich.

Glücklicherweise haben die Bibliotheksdesigner entschieden, dass Sie diese Funktion auch deaktivieren können sollten, um eine verbesserte Leistung zu erzielen, wenn Sie wissen, was Sie tun. Daher haben sie die sync_with_stdioMethode bereitgestellt .

Nur aus Neugier habe ich mir angesehen, was unter der Haube passiert, und ich habe Dtruss / Strace verwendet bei jedem Test verwendet.

C ++

./a.out < in
Saw 6512403 lines in 8 seconds.  Crunch speed: 814050

Systemaufrufe sudo dtruss -c ./a.out < in

CALL                                        COUNT
__mac_syscall                                   1
<snip>
open                                            6
pread                                           8
mprotect                                       17
mmap                                           22
stat64                                         30
read_nocancel                               25958

Python

./a.py < in
Read 6512402 lines in 1 seconds. LPS: 6512402

Systemaufrufe sudo dtruss -c ./a.py < in

CALL                                        COUNT
__mac_syscall                                   1
<snip>
open                                            5
pread                                           8
mprotect                                       17
mmap                                           21
stat64                                         29

Ich bin ein paar Jahre hinterher, aber:

In 'Edit 4/5/6' des ursprünglichen Beitrags verwenden Sie die Konstruktion:

$ /usr/bin/time cat big_file | program_to_benchmark

Dies ist in vielerlei Hinsicht falsch:

1. Sie planen tatsächlich die Ausführung cat, nicht Ihren Benchmark. Die ‚Benutzer‘ und ‚sys‘ CPU - Auslastung angezeigt durch timediejenigen sind cat, nicht Ihre gebenchmarkt Programm. Schlimmer noch, die "Echtzeit" ist auch nicht unbedingt genau. Abhängig von der Implementierung von catund von Pipelines in Ihrem lokalen Betriebssystem ist es möglich, dass catein endgültiger Riesenpuffer geschrieben und beendet wird, lange bevor der Lesevorgang seine Arbeit beendet.

2. Die Verwendung von catist unnötig und in der Tat kontraproduktiv; Sie fügen bewegliche Teile hinzu. Wenn Sie sich auf einem ausreichend alten System befinden (dh mit einer einzelnen CPU und - bei bestimmten Computergenerationen - E / A schneller als die CPU), kann die bloße Tatsache, dass sie catausgeführt wird, die Ergebnisse erheblich beeinflussen. Sie unterliegen auch jeglicher Eingabe- und Ausgabepufferung und anderer Verarbeitung cat. (Dies würde Ihnen wahrscheinlich die Auszeichnung "Nutzlose Verwendung von Katzen" einbringen, wenn ich Randal Schwartz wäre.

Eine bessere Konstruktion wäre:

$ /usr/bin/time program_to_benchmark < big_file

In dieser Anweisung ist es die Shell, die big_file öffnet und timeals bereits geöffneter Dateideskriptor an Ihr Programm übergibt (also tatsächlich an das dann Ihr Programm als Unterprozess ausgeführt wird). 100% des Dateilesens liegt ausschließlich in der Verantwortung des Programms, das Sie bewerten möchten. Auf diese Weise erhalten Sie einen echten Überblick über die Leistung ohne störende Komplikationen.

Ich werde zwei mögliche, aber tatsächlich falsche "Korrekturen" erwähnen, die ebenfalls in Betracht gezogen werden könnten (aber ich "nummeriere" sie unterschiedlich, da dies keine Dinge sind, die im ursprünglichen Beitrag falsch waren):

A. Sie können dies beheben, indem Sie nur Ihr Programm zeitlich festlegen:

$ cat big_file | /usr/bin/time program_to_benchmark

B. oder durch Timing der gesamten Pipeline:

$ /usr/bin/time sh -c 'cat big_file | program_to_benchmark'

Diese sind aus den gleichen Gründen wie # 2 falsch: Sie werden immer noch catunnötig verwendet. Ich erwähne sie aus mehreren Gründen:

• Sie sind „natürlicher“ für Personen, die mit den E / A-Umleitungsfunktionen der POSIX-Shell nicht ganz vertraut sind

• kann es Fälle geben, wo cat ist erforderlich (zB: die Datei erfordert eine Art Privileg , den Zugang zu lesen, und Sie wollen nicht dieses Privileg , um das Programm zu gewähren , werden gebenchmarkt: sudo cat /dev/sda | /usr/bin/time my_compression_test --no-output)

• In der Praxis hat das Hinzufügen moderner Maschinen auf modernen Maschinen catwahrscheinlich keine wirkliche Konsequenz.

Aber ich sage das letzte mit einigem Zögern. Wenn wir das letzte Ergebnis in 'Edit 5' untersuchen -

$ /usr/bin/time cat temp_big_file | wc -l
0.01user 1.34system 0:01.83elapsed 74%CPU ...

- dies behauptet, dass cat74% der CPU während des Tests verbraucht wurden; und tatsächlich ist 1,34 / 1,83 ungefähr 74%. Vielleicht eine Serie von:

$ /usr/bin/time wc -l < temp_big_file

hätte nur die restlichen 0,49 Sekunden gedauert! Wahrscheinlich nicht: catHier mussten die read()Systemaufrufe (oder gleichwertige) bezahlt werden, die die Datei von 'disk' (eigentlich Puffer-Cache) übertragen haben, sowie die Pipe-Schreibvorgänge, um sie zu liefern wc. Der richtige Test hätte diese noch durchführen müssenread() Anrufe ; nur die Write-to-Pipe- und Read-from-Pipe-Aufrufe wären gespeichert worden, und diese sollten ziemlich billig sein.

Trotzdem gehe ich davon aus, dass Sie den Unterschied zwischen messen können cat file | wc -l undwc -l < file und einen spürbaren Unterschied (zweistelliger Prozentsatz) feststellen können. Jeder der langsameren Tests hat in absoluter Zeit eine ähnliche Strafe gezahlt; Dies würde jedoch einen kleineren Bruchteil seiner größeren Gesamtzeit ausmachen.

Tatsächlich habe ich einige schnelle Tests mit einer 1,5-Gigabyte-Mülldatei auf einem Linux 3.13-System (Ubuntu 14.04) durchgeführt, um diese Ergebnisse zu erhalten (dies sind tatsächlich die besten 3-Ergebnisse; natürlich nach dem Priming des Caches):

$ time wc -l < /tmp/junk
real 0.280s user 0.156s sys 0.124s (total cpu 0.280s)
$ time cat /tmp/junk | wc -l
real 0.407s user 0.157s sys 0.618s (total cpu 0.775s)
$ time sh -c 'cat /tmp/junk | wc -l'
real 0.411s user 0.118s sys 0.660s (total cpu 0.778s)

Beachten Sie, dass die beiden Pipeline-Ergebnisse angeblich mehr CPU-Zeit (Benutzer + System) als die tatsächliche Wanduhrzeit in Anspruch genommen haben. Dies liegt daran, dass ich den in die Shell (bash) integrierten Befehl 'time' verwende, der die Pipeline kennt. und ich bin auf einem Multi-Core-Computer, auf dem separate Prozesse in einer Pipeline separate Kerne verwenden können, wodurch die CPU-Zeit schneller als in Echtzeit angesammelt wird. Verwenden von/usr/bin/time sehe ich eine geringere CPU-Zeit als in Echtzeit - dies zeigt, dass nur das einzelne Pipeline-Element, das an ihn übergeben wurde, in der Befehlszeile zeitlich festgelegt werden kann. Außerdem gibt die Ausgabe der Shell Millisekunden an, während /usr/bin/timenur Hundertstelsekunden ausgegeben werden .

Also auf dem Wirkungsgrad von wc -l , dercat macht einen großen Unterschied: 409/283 = 1,453 oder 45,3% mehr in Echtzeit, und 775/280 = 2,768, oder ein sattes 177% mehr CPU verwendet! Auf meiner zufälligen Testbox war es zu der Zeit da.

Ich sollte hinzufügen, dass es mindestens einen weiteren signifikanten Unterschied zwischen diesen Teststilen gibt, und ich kann nicht sagen, ob es sich um einen Vorteil oder einen Fehler handelt. das musst du selbst entscheiden:

Wenn Sie ausführen cat big_file | /usr/bin/time my_program, empfängt Ihr Programm Eingaben von einer Pipe, genau in dem Tempo, das von gesendet wirdcat , und in Blöcken, die nicht größer als von geschrieben sindcat .

Wenn Sie ausführen /usr/bin/time my_program < big_file, erhält Ihr Programm einen offenen Dateideskriptor für die eigentliche Datei. Ihr Programm - oder in vielen Fällen die E / A-Bibliotheken der Sprache, in der es geschrieben wurde - kann unterschiedliche Aktionen ausführen, wenn ein Dateideskriptor angezeigt wird, der auf eine reguläre Datei verweist. Es kann verwendet werden mmap(2), um die Eingabedatei ihrem Adressraum zuzuordnen, anstatt explizite read(2)Systemaufrufe zu verwenden. Diese Unterschiede können sich weitaus stärker auf Ihre Benchmark-Ergebnisse auswirken als die geringen Kosten für die Ausführung der catBinärdatei.

Natürlich ist es ein interessantes Benchmark-Ergebnis, wenn dasselbe Programm zwischen den beiden Fällen signifikant unterschiedlich abschneidet. Es zeigt , dass in der Tat, das Programm oder dessen I / O - Bibliotheken sind etwas Interessantes zu tun, wie mit mmap(). In der Praxis kann es daher sinnvoll sein, die Benchmarks in beide Richtungen auszuführen. Vielleicht wird das catErgebnis um einen kleinen Faktor abgezinst , um die Kosten für den Betrieb catselbst zu "verzeihen" .

Ich habe das ursprüngliche Ergebnis auf meinem Computer mit g ++ auf einem Mac reproduziert.

Durch Hinzufügen der folgenden Anweisungen zur C ++ - Version unmittelbar vor der whileSchleife wird sie mit der Python- Version in Einklang gebracht :

std::ios_base::sync_with_stdio(false);
char buffer[1048576];
std::cin.rdbuf()->pubsetbuf(buffer, sizeof(buffer));

sync_with_stdio verbesserte die Geschwindigkeit auf 2 Sekunden und durch Einstellen eines größeren Puffers auf 1 Sekunde.

getlineStream-Operatoren scanfkönnen nützlich sein, wenn Sie sich nicht für die Ladezeit von Dateien interessieren oder wenn Sie kleine Textdateien laden. Wenn Sie sich jedoch für die Leistung interessieren, sollten Sie die gesamte Datei einfach in den Speicher puffern (vorausgesetzt, sie passt).

Hier ist ein Beispiel:

//open file in binary mode
std::fstream file( filename, std::ios::in|::std::ios::binary );
if( !file ) return NULL;

//read the size...
file.seekg(0, std::ios::end);
size_t length = (size_t)file.tellg();
file.seekg(0, std::ios::beg);

//read into memory buffer, then close it.
char *filebuf = new char[length+1];
file.read(filebuf, length);
filebuf[length] = '\0'; //make it null-terminated
file.close();

Wenn Sie möchten, können Sie einen Stream um diesen Puffer wickeln, um einen bequemeren Zugriff wie folgt zu erhalten:

std::istrstream header(&filebuf[0], length);

Wenn Sie die Kontrolle über die Datei haben, sollten Sie auch ein flaches Binärdatenformat anstelle von Text verwenden. Lesen und Schreiben ist zuverlässiger, da Sie sich nicht mit allen Mehrdeutigkeiten von Leerzeichen auseinandersetzen müssen. Es ist auch kleiner und viel schneller zu analysieren.

Der folgende Code war für mich schneller als der andere Code, der bisher hier veröffentlicht wurde: (Visual Studio 2013, 64-Bit-Datei mit 500 MB und einheitlicher Zeilenlänge in [0, 1000)).

const int buffer_size = 500 * 1024;  // Too large/small buffer is not good.
std::vector<char> buffer(buffer_size);
int size;
while ((size = fread(buffer.data(), sizeof(char), buffer_size, stdin)) > 0) {
    line_count += count_if(buffer.begin(), buffer.begin() + size, [](char ch) { return ch == '\n'; });
}

Es übertrifft alle meine Python-Versuche um mehr als den Faktor 2.

Der Grund, warum die Zeilenanzahl für die C ++ - Version um eins höher ist als die Anzahl für die Python-Version, ist übrigens, dass das eof-Flag nur gesetzt wird, wenn versucht wird, über eof hinaus zu lesen. Die richtige Schleife wäre also:

while (cin) {
    getline(cin, input_line);

    if (!cin.eof())
        line_count++;
};

In Ihrem zweiten Beispiel (mit scanf ()) liegt dies möglicherweise daran, dass scanf ("% s") die Zeichenfolge analysiert und nach Leerzeichen (Leerzeichen, Tabulator, Zeilenumbruch) sucht.

Ja, CPython führt auch ein Caching durch, um das Lesen von Festplatten zu vermeiden.

Ein erstes Element einer Antwort: <iostream>ist langsam. Verdammt langsam. Ich bekomme einen enormen Leistungsschub mit scanfwie unten, aber es ist immer noch zweimal langsamer als Python.

#include <iostream>
#include <time.h>
#include <cstdio>

using namespace std;

int main() {
    char buffer[10000];
    long line_count = 0;
    time_t start = time(NULL);
    int sec;
    int lps;

    int read = 1;
    while(read > 0) {
        read = scanf("%s", buffer);
        line_count++;
    };
    sec = (int) time(NULL) - start;
    line_count--;
    cerr << "Saw " << line_count << " lines in " << sec << " seconds." ;
    if (sec > 0) {
        lps = line_count / sec;
        cerr << "  Crunch speed: " << lps << endl;
    } 
    else
        cerr << endl;
    return 0;
}

Nun, ich sehe, dass Sie in Ihrer zweiten Lösung von cinzu gewechselt haben scanf, was der erste Vorschlag war, den ich Ihnen machen wollte (cin ist sloooooooooooow). Wenn Sie jetzt von scanfzu wechseln fgets, sehen Sie einen weiteren Leistungsschub:fgets ist die schnellste C ++ - Funktion für die Eingabe von Zeichenfolgen.

Übrigens, wusste nichts über diese Synchronisierungssache, nett. Aber du solltest es trotzdem versuchen fgets.