Warum gibt es einen solchen Unterschied in der Ausführungszeit von Echo und Katze?

Die Beantwortung dieser Frage veranlasste mich, eine andere Frage zu stellen:
Ich dachte, die folgenden Skripte tun dasselbe und die zweite sollte viel schneller sein, da die erste verwendet cat, die die Datei immer wieder öffnen muss, aber die zweite nur die Datei öffnet einmal und gibt dann nur eine Variable aus:

(Den richtigen Code finden Sie im Update-Abschnitt.)

Zuerst:

#!/bin/sh
for j in seq 10; do
  cat input
done >> output

Zweite:

#!/bin/sh
i=`cat input`
for j in seq 10; do
  echo $i
done >> output

während die Eingabe etwa 50 Megabyte beträgt.

Aber als ich das zweite ausprobierte, war es zu langsam, weil es die Variable wiedergab i es ein gewaltiger Prozess . Ich habe auch einige Probleme mit dem zweiten Skript, zum Beispiel die Größe der Ausgabedatei war geringer als erwartet.

Ich habe auch die Manpage von echound durchgesehencat sie verglichen:

echo - Zeigt eine Textzeile an

cat - Dateien verketten und auf der Standardausgabe drucken

Aber ich habe den Unterschied nicht verstanden.

So:

• Warum ist die Katze so schnell und das Echo im zweiten Drehbuch so langsam?
• Oder ist das Problem mit der Variablen i? (Weil in der Manpage echodavon die Rede ist, dass es "eine Textzeile" anzeigt, und ich vermute, dass es nur für kurze Variablen optimiert ist, nicht für sehr lange Variablen wie i. Dies ist jedoch nur eine Vermutung.)
• Und warum habe ich Probleme, wenn ich benutze echo?

AKTUALISIEREN

Ich habe seq 10statt `seq 10`falsch verwendet. Dies ist bearbeiteter Code:

Zuerst:

#!/bin/sh
for j in `seq 10`; do
  cat input
done >> output

Zweite:

#!/bin/sh
i=`cat input`
for j in `seq 10`; do
  echo $i
done >> output

(Besonderer Dank geht an Roaima .)

Es ist jedoch nicht der Punkt des Problems. Auch wenn die Schleife nur einmal auftritt, bekomme ich das gleiche Problem: catArbeitet viel schneller als echo.

Hier sind einige Dinge zu beachten.

i=`cat input`

kann teuer sein und es gibt viele Variationen zwischen den Schalen.

Dies ist eine Funktion, die als Befehlsersetzung bezeichnet wird. Die Idee ist, die gesamte Ausgabe des Befehls abzüglich der nachfolgenden Zeilenumbrüche in der iVariablen im Speicher zu speichern.

Dazu geben Shells den Befehl in einer Subshell an und lesen seine Ausgabe über eine Pipe oder ein Socket-Paar. Sie sehen hier eine Menge Variationen. In einer 50-MB-Datei sehe ich beispielsweise, dass Bash 6-mal so langsam ist wie ksh93, aber etwas schneller als zsh und doppelt so schnell wie yash.

Der Hauptgrund dafür bash, dass es langsam ist, ist, dass es 128 Bytes gleichzeitig aus der Pipe liest (während andere Shells 4 KB oder 8 KB gleichzeitig lesen) und durch den Systemaufruf-Overhead bestraft wird.

zshNachbearbeitung erforderlich, um NUL-Bytes zu umgehen (andere Shells setzen NUL-Bytes außer Kraft), und yashnoch umfangreichere Nachbearbeitung durch Analysieren von Multi-Byte-Zeichen.

Alle Shells müssen die nachfolgenden Zeilenumbrüche entfernen, was sie möglicherweise mehr oder weniger effizient ausführen.

Einige möchten möglicherweise mit NUL-Bytes eleganter umgehen als andere und auf Vorhandensein prüfen.

Sobald Sie diese große Variable im Arbeitsspeicher haben, müssen Sie bei jeder Manipulation im Allgemeinen mehr Arbeitsspeicher zuweisen und Daten übertragen.

Hier übergeben Sie (wollten) den Inhalt der Variablen an echo.

Zum Glück echoist es in Ihrer Shell eingebaut, sonst wäre die Ausführung wahrscheinlich mit einem zu langen Fehler fehlgeschlagen . Selbst dann wird das Erstellen des Argumentlistenarrays möglicherweise das Kopieren des Inhalts der Variablen umfassen.

Das andere Hauptproblem bei Ihrem Befehlssubstitutionsansatz besteht darin, dass Sie den Operator split + glob aufrufen (indem Sie vergessen, die Variable in Anführungszeichen zu setzen).

Dazu Schalen müssen die Zeichenfolge als eine Folge von behandeln Zeichen (obwohl einige Granaten nicht und sind fehlerhaft in dieser Hinsicht) so in UTF-8 - Locales, dass Mittel UTF-8 - Sequenzen Parsen (falls noch nicht geschehen , wie der yashFall ist) Suchen Sie nach $IFSZeichen in der Zeichenfolge. Wenn $IFSLeerzeichen, Tabulatoren oder Zeilenumbrüche enthalten sind (was standardmäßig der Fall ist), ist der Algorithmus noch komplexer und teurer. Dann müssen die aus dieser Aufteilung resultierenden Wörter zugewiesen und kopiert werden.

Der Glob-Teil wird noch teurer. Wenn eines dieser Wörter glob Zeichen ( *, ?, [), dann wird die Shell den Inhalt einiger Verzeichnisse lesen und einige teure Musterabgleich tun ( bashs Implementierung zum Beispiel ist bekanntlich sehr schlecht dazu).

Wenn die Eingabe so etwas enthält /*/*/*/../../../*/*/*/../../../*/*/*, ist das extrem teuer, da das bedeutet, dass Tausende von Verzeichnissen aufgelistet werden und sich diese auf mehrere Hundert MiB erweitern können.

Dann echowird in der Regel eine zusätzliche Verarbeitung durchgeführt. Einige Implementierungen erweitern \xSequenzen in dem Argument, das sie erhalten, was bedeutet, dass der Inhalt und wahrscheinlich eine andere Zuordnung und Kopie der Daten analysiert werden.

Auf der anderen Seite ist OK in den meisten Shells catnicht integriert. Dies bedeutet, dass Sie einen Prozess forken und ausführen (also den Code und die Bibliotheken laden), aber nach dem ersten Aufruf diesen Code und den Inhalt der Eingabedatei wird im Speicher zwischengespeichert. Auf der anderen Seite wird es keinen Vermittler geben. catliest große Mengen gleichzeitig und schreibt sie sofort ohne Verarbeitung, und es muss keine große Menge an Speicher reserviert werden, nur der eine Puffer, den es wiederverwendet.

Dies bedeutet auch, dass es viel zuverlässiger ist, da es nicht an NUL-Bytes verstopft und nachfolgende Zeilenumbrüche nicht abschneidet Erweitern Sie die Escape-Sequenz, obwohl Sie dies vermeiden können, indem Sie printfanstelle von echo) verwenden.

Wenn Sie es weiter optimieren möchten, anstatt es catmehrmals aufzurufen , übergeben Sie es einfach inputmehrmals an cat.

yes input | head -n 100 | xargs cat

Führt 3 anstelle von 100 Befehlen aus.

Um die variable Version zuverlässiger zu machen, müssen Sie Folgendes verwenden zsh(andere Shells können mit NUL-Bytes nicht umgehen):

zmodload zsh/mapfile
var=$mapfile[input]
repeat 10 print -rn -- "$var"

Wenn Sie wissen, dass die Eingabe keine NUL-Bytes enthält, können Sie dies POSIX-zuverlässig tun (obwohl dies möglicherweise nicht funktioniert, wenn printfkeine eingebauten Daten vorliegen) mit:

i=$(cat input && echo .) || exit # add an extra .\n to avoid trimming newlines
i=${i%.} # remove that trailing dot (the \n was removed by cmdsubst)
n=10
while [ "$n" -gt 10 ]; do
  printf %s "$i"
  n=$((n - 1))
done

Aber das wird niemals effizienter als die Verwendung catin der Schleife (es sei denn, die Eingabe ist sehr klein).

Das Problem ist nicht etwa catund echo, es geht um das Zitat Variable vergessen $i.

zshWenn Sie in einem Bourne-ähnlichen Shell-Skript (außer ) Variablen nicht in Anführungszeichen setzen, werden die Variablen von glob+splitOperatoren bearbeitet .

$var

ist eigentlich:

glob(split($var))

So wird bei jeder Schleifeniteration der gesamte Inhalt von input(ohne nachfolgende Zeilenumbrüche) erweitert, aufgeteilt und verschoben. Für den gesamten Prozess muss die Shell Speicher zuweisen und die Zeichenfolge immer wieder analysieren. Das ist der Grund, warum du die schlechte Leistung hast.

Sie können die Variable in Anführungszeichen setzen, um glob+splitdies zu verhindern, aber es wird Ihnen nicht viel helfen, da die Shell immer noch das große Zeichenfolgenargument erstellen und dessen Inhalt nach echo(Ersetzen von builtin echodurch external /bin/echoführt dazu, dass die Argumentliste zu lang ist oder nicht genügend Speicherplatz zur Verfügung steht abhängig von der $iGröße). Die meisten echoImplementierungen sind nicht POSIX-konform. Sie erweitern die Backslash- \xSequenzen in den empfangenen Argumenten.

Mit catmuss die Shell nur bei jeder Schleifeniteration einen Prozess erzeugen und catkopiert die Ein- / Ausgabe. Das System kann den Dateiinhalt auch zwischenspeichern, um den Cat-Prozess zu beschleunigen.

Wenn Sie anrufen

i=`cat input`

Dadurch wächst Ihr Shell-Prozess um 50 MB auf bis zu 200 MB (abhängig von der internen Wide Character-Implementierung). Dies kann Ihre Shell verlangsamen, aber dies ist nicht das Hauptproblem.

Das Hauptproblem besteht darin, dass der obige Befehl die gesamte Datei in den Shell-Speicher einlesen und die echo $iFeldaufteilung für diesen Dateiinhalt in ausführen muss$i . Um eine Feldaufteilung durchzuführen, muss der gesamte Text aus der Datei in breite Zeichen konvertiert werden, und hier wird die meiste Zeit verbracht.

Ich habe einige Tests mit dem langsamen Fall durchgeführt und folgende Ergebnisse erhalten:

• Am schnellsten ist ksh93
• Als nächstes kommt meine Bourne Shell (2x langsamer als ksh93)
• Weiter ist bash (3x langsamer als ksh93)
• Letzteres ist ksh88 (7x langsamer als ksh93)

Der Grund, warum ksh93 am schnellsten ist, scheint darin zu liegen, dass ksh93 nicht mbtowc()von libc verwendet wird, sondern eine eigene Implementierung.

Übrigens: Stephane ist der Meinung, dass die Lesegröße einen gewissen Einfluss hat. Ich habe die Bourne-Shell kompiliert, um 4096-Byte-Chunks anstelle von 128-Byte-Chunks einzulesen, und in beiden Fällen die gleiche Leistung erzielt.

In beiden Fällen wird die Schleife nur zweimal ausgeführt (einmal für das Wort seqund einmal für das Wort 10).

Außerdem werden beide benachbarte Leerzeichen zusammengeführt und führende / nachfolgende Leerzeichen entfernt, sodass die Ausgabe nicht unbedingt zwei Kopien der Eingabe enthält.

Zuerst

#!/bin/sh
for j in $(seq 10); do
    cat input
done >> output

Zweite

#!/bin/sh
i="$(cat input)"
for j in $(seq 10); do
    echo "$i"
done >> output

Ein Grund, warum das echolangsamer ist, kann sein, dass Ihre Variable ohne Anführungszeichen in Leerzeichen in separate Wörter aufgeteilt wird. Für 50MB ist das eine Menge Arbeit. Zitiere die Variablen!

Ich schlage vor, dass Sie diese Fehler beheben und dann Ihre Timings neu bewerten.

Ich habe das vor Ort getestet. Ich habe eine 50MB-Datei mit der Ausgabe von erstellt tar cf - | dd bs=1M count=50. Ich habe auch die Schleifen so erweitert, dass sie um den Faktor x100 laufen, sodass die Timings auf einen vernünftigen Wert skaliert wurden (ich habe eine weitere Schleife um Ihren gesamten Code hinzugefügt: for k in $(seq 100); do... done). Hier sind die Zeiten:

time ./1.sh

real    0m5.948s
user    0m0.012s
sys     0m0.064s

time ./2.sh

real    0m5.639s
user    0m4.060s
sys     0m0.224s

Wie Sie sehen, gibt es keinen wirklichen Unterschied, aber wenn überhaupt, echoläuft die Version, die sie enthält, geringfügig schneller. Wenn ich die Anführungszeichen entferne und Ihre kaputte Version 2 ausführe, verdoppelt sich die Zeit und zeigt, dass die Shell weitaus mehr Arbeit leisten muss, als erwartet werden sollte.

time ./2original.sh

real    0m12.498s
user    0m8.645s
sys     0m2.732s

read ist viel schneller als cat

Ich denke, jeder kann das testen:

$ cd /sys/devices/system/cpu/cpu0/cpufreq
───────────────────────────────────────────────────────────────────────────────────────────
$ time for ((i=0; i<10000; i++ )); do read p < scaling_cur_freq ; done

real    0m0.232s
user    0m0.139s
sys     0m0.088s
───────────────────────────────────────────────────────────────────────────────────────────
$ time for ((i=0; i<10000; i++ )); do cat scaling_cur_freq > /dev/null ; done

real    0m9.372s
user    0m7.518s
sys     0m2.435s
───────────────────────────────────────────────────────────────────────────────────────────
$ type -a read
read is a shell builtin
───────────────────────────────────────────────────────────────────────────────────────────
$ type -a cat
cat is /bin/cat

catdauert 9,372 Sekunden. echodauert .232Sekunden.

readist 40 mal schneller .

Mein erster Test, als $pauf dem Bildschirm angezeigt wurde, readwar 48-mal schneller als cat.

Das echosoll 1 Zeile auf dem Bildschirm setzen. Was Sie im zweiten Beispiel tun, ist, dass Sie den Inhalt der Datei in eine Variable einfügen und dann diese Variable drucken. In der ersten setzen Sie den Inhalt sofort auf den Bildschirm.

catist für diese Nutzung optimiert. echoist nicht. Es ist keine gute Idee, 50 MB in eine Umgebungsvariable zu schreiben.

Es geht nicht darum, dass Echo schneller ist, sondern darum, was Sie tun:

In einem Fall lesen Sie direkt von der Eingabe und schreiben zur Ausgabe. Mit anderen Worten, was von der Eingabe über cat gelesen wird, wird über stdout ausgegeben.

input -> output

In dem anderen Fall lesen Sie von der Eingabe in eine Variable im Speicher und schreiben dann den Inhalt der Variablen in die Ausgabe.

input -> variable
variable -> output

Letzteres ist viel langsamer, insbesondere wenn der Eingang 50 MB beträgt.