Wie kann ich die Ausgaben in der Konsole löschen?

[fonso]

Hallo Forum,

ich entwickle in meiner Firma ein Hardwaretestprogramm das sehr viele komplizierte Tests an einem LKW-Steuergerät durchfüht. Daher gibt es auch sehr viele print-Ausgaben auf der Konsole (welche natürlich geloggt werden). Mit steigender Anzahl von Ausgaben wird jedoch irgendwann der Punkt erreicht an dem die Programmausführung doch sehr langsam wird (bei ca 15000 print-ausgaben). Es ist auch nicht so das das Programm intern immer neue Resourcen anfordert wie z.B.: Aufblähung von Listen etc. Daher würde mich interessieren wie ich von Zeit zu Zeit (immer nach einer 'Testsection') die Ausgaben auf der Konsole löschen kann damit die Performance meines Programmes vom '1000de von Zeilennachschieben' nicht in den Keller fällt. Anzumerken ist das die Ausgaben auf der Konsole ausdrücklich erwünscht sind.

Schon jetzt danke für die Antworten

Grüße Fonso

[Leonidas]

Hallo fonso, willkommen im Forum,

Durch das Löschen wird es nicht schneller, denn was langsam ist ist hauptsächlich das rausschreiben & rendern durch den Terminal-Emulator, nicht dass, dass dort viel drin steht.

[numerix]

Durch das Löschen wird es nicht schneller, denn was langsam ist ist hauptsächlich das rausschreiben & rendern durch den Terminal-Emulator, nicht dass, dass dort viel drin steht.

Wie erklärst du dir denn dann das beschriebene Verhalten des Programms? Damit, dass es gar nicht die wachsende Ausgabe ist, die den Ablauf verlangsamt?

Gibt es nicht so etwas wie einen Puffer, wo die Ausgaben landen, der dann mit der Zeit immer voller wird und das ganze ausbremst? (Das ist eine ganz naive Frage, weil ich es schlicht nicht weiß)

@fonso: Stichwörter für das Löschen des Terminals wären: curses, wcurses oder WConio.

[BlackJack]

@numerix: Es ist wahrscheinlich schon die wachsende Ausgabe, aber das Problem liegt eben im Terminal-Emulator und nicht beim Python-Programm. Löschen nützt da auch nichts, weil dabei nur der aktuelle "Bildschirm" gelehrt wird, aber nicht der bereits bestehende Verlauf im Terminal.

@fonso: Ich würde zuerst einmal die Ausgabe in eine Datei umlenken und die Zeit vegleichen, also sicherstellen, das wirklich das Terminal bzw. die Ausgaben schuld sind.

Falls ja, müsstest Du mal schauen wie man dem verwendeten Terminal beibringt weniger vom Verlauf zu speichern.

[Nocta]

Ich bin mir auch ziemlich sicher, dass es an der Ausgabe liegt, eine Zeile zu printen dauert eben etwas.
Wenn man ein Programm hat, was 1000Schleifendurchläufe hat, dauert das ohne print ein Bruchteil einer Sekunde (je nach ausgeführter Operation, aber gehen wir mal von pass aus ).
Baut man jetzt in die Schleife eine print-Anweisung ein, zB print(i), dauert das geschätzt für jede 200 Ausgaben eine Sekunde, womit wir dann auf 5 Sekunden laufzeit kämen.
Man muss dabei beachten, dass die Ausgabe gleichmäßig erfolgt.
Also so wie ich das sehe, bremst der print-Befehl alles ganz schön ab.

Code: Alles auswählen

>>> x = time.clock();print("test"); y = time.clock() - x>>> x = time.clock(); print("test"); y = time.clock() - x
test
>>> y
0.053904686210131558

Code: Alles auswählen

>>> x = time.clock(); y = time.clock() - x
>>> y
1.1174604708230618e-06

Und nochmal als Entgegenstellung zum print-Befehl eine andere Anweisung:

Code: Alles auswählen

>>> x = time.clock(); b = [i for i in range(1000)]; y = time.clock() - x
>>> y
0.00011446985581642366

Hier sieht man schön, dass die print-Anweisung ziemlich viel Zeit beansprucht ;o
Wenn man das jetzt auf 1000 hochrechnet:
0.05 * 1000 = 50 Sekunden.
Naja, das kann auch nicht sein, also hab ich mal geguckt, wie sich print verhält, wenn man es mehrmals aufruft:

Code: Alles auswählen

>>> x = time.clock(); print("test"); print("lol"); print("rofl"); y = time.clock() - x
>>> y
0.062265944414718888

Das ganze hab ich dann noch mit 6 prints gemacht, dabei kam die Zahl 0.076368504935715009 heraus.
Bei diesen Ergebnissen kann man dann wohl annehmen, dass immer der erste print-Befehl am meisten Zeit verbraucht, nämlich 0.05.
Zieht man jetzt 0.05 ab und teilt die Zahl durch 3 (bzw durch 6, als ichs mit 6 print-Befehlen probiert habe), kommt eine Zahl um 0.004 heraus.
Das habe ich dann auch bei größeren Anzahlen von prints probiert:

Code: Alles auswählen

for i in range(1000):
	x = time.clock(); print("test"); y = time.clock() - x

Aber dort bestätigt sich das Ergebnis nur, es dauert immer zwischen 0.003 und 0.004 Sekunden.
Jetzt führ ich das Ergebnis mal wieder zurück auf mein Anfangsbeispiel mit 1000 Schleifendurchläufen:
Wenn jedes print 0.004 Sekunden braucht und der erste 0.05, kommt man auf 0.004 * 1000 + 0.05 = 4.05 Sekunden für die print-Anweisungen, was so ziemlich die gesamte Laufzeit des Programmes ausmacht.

Ich hab das übrigens unter Idle (wie man an den >>> erkennt) und Windows ausgeführt.

Also zusammenfassend kann man sagen, dass es an keinem Puffer oder sonstwas liegt (das Programm wartet imo auf die Ausgabe), sondern schlicht und einfach an der Tatsache, dass das Ausgeben auf der Konsole (vielleicht Konsolenabhängig?) ziemlich lange dauert.
PS: Ja das musste mal sein :p

[numerix]

Ich bin mir auch ziemlich sicher, dass es an der Ausgabe liegt, eine Zeile zu printen dauert eben etwas.

Dass Ausgaben auf die Konsole Zeit kosten ist gar keine Frage.
Es ging ja darum, dass die dafür benötigte Zeit mit steigender Anzahl der Ausgaben stärker als linear anwächst.

Ich habe das eben mal mit 10.000, 100.000 und 1.000.000 Ausgaben ausprobiert und der Zeitbedarf wächst bei mir absolut linear (verwendet habe ich das Gnome-Terminal).

Was deine Messungen angeht: Du solltest zur Performance-Messung immer den umgekehrten Weg gehen, also nicht die Zeit für eine geringe Zahl von Durchläufen messen und das dann hochrechnen, sondern eine größere Zahl an Durchläufen messen und dann dividieren. Damit erzielt man die besseren Ergebnisse.

[Nocta]

Dass Ausgaben auf die Konsole Zeit kosten ist gar keine Frage.
Es ging ja darum, dass die dafür benötigte Zeit mit steigender Anzahl der Ausgaben stärker als linear anwächst.

Ok, stimmt schon;)

Ich habe das eben mal mit 10.000, 100.000 und 1.000.000 Ausgaben ausprobiert und der Zeitbedarf wächst bei mir absolut linear (verwendet habe ich das Gnome-Terminal).

Bei mir nicht, ich hab's auch schon mit 10.000 bzw 100.000 probiert, da wächst gar nichts

Was deine Messungen angeht: Du solltest zur Performance-Messung immer den umgekehrten Weg gehen, also nicht die Zeit für eine geringe Zahl von Durchläufen messen und das dann hochrechnen, sondern eine größere Zahl an Durchläufen messen und dann dividieren. Damit erzielt man die besseren Ergebnisse.

Ja das ist mir schon bewusst. Ich hab das nur mal als Ausgangsbasis genommen, um meine Vermutungen aufstellen zu können, die ich dann später, als ich "Lust" hatte mal 5 Minuten zu warten, mit größeren Zahlen bestätigt hab. Und ich dachte mir, so einen großen Unterschied wird's zwischen 1000 und 100.000 auch nicht geben, außer natürlich, das ganze wächst mit der Zeit an - was bei mir aber nicht der Fall ist und wovon ich ehrlich gesagt nicht ausgegangen bin, weil ich keinen Grund sehe, warum es so sein sollte.

[numerix]

Ich habe das eben mal mit 10.000, 100.000 und 1.000.000 Ausgaben ausprobiert und der Zeitbedarf wächst bei mir absolut linear (verwendet habe ich das Gnome-Terminal).

Bei mir nicht, ich hab's auch schon mit 10.000 bzw 100.000 probiert, da wächst gar nichts

"Linear" bedeutet, dass die Zeit für z.B. doppelt so viele Ausgaben auch doppelt so lang ist ...

[Leonidas]

Du solltest, wie numerix auch, das verwendete Terminal angeben. Denn die Geschwindigkeit wird vom Terminal limitiert.

Wenn ihr die Ausgaben mittels ``>`` in eine Datei umleitet, geht das alles schneller, da das Terminal da nix weiter rendern muss sondern der Kram einfach in einer Datei landet, was eine häufige Operation ist vom Kernel effizient implementiert wird.

[Nocta]

"Linear" bedeutet, dass die Zeit für z.B. doppelt so viele Ausgaben auch doppelt so lang ist ...

Okay, das hab ich wohl missverstanden.

Du solltest, wie numerix auch, das verwendete Terminal angeben. Denn die Geschwindigkeit wird vom Terminal limitiert.

Meinst du mich? Ich hab bereits gesagt, dass ich es unter Windows mit IDLE ausgeführt habe.

[Leonidas]

Meinst du mich? Ich hab bereits gesagt, dass ich es unter Windows mit IDLE ausgeführt habe.

Oh, tut mir leid, den Teil habe ich übersehen

Naja, wir stellen empirisch fest: die Ausgabe wird nicht langsamer, wenn viel rausgeschrieben wurde.

[BlackJack]

Also ich hatte mal einen Fall bei einem Terminal, bei dem die Verlaufsgrösse auf "unendlich" eingestellt war und alte Logmeldungen die darauf ausgegeben wurden, nach drei Tagen in der Auslagerungsdatei landeten. Das hat das System doch schon ein klein wenig ausgebremst. War allerdings nicht gerade der schnellste Rechner und hatte auch nicht viel RAM.

[fonso]

Hallo, danke für die vielen Antworten.

Möchte noch genauere Infos nachreichen. Pythonprogramm läuft in Pytonwin, Ausgabekonsole ist also das 'Interactive Window' von Pythonwin. Mein Programm benutzt intensiv die COM-Schnittstelle (win32com) um die Anwendung CANoe von Vektor 'fernzusteuern'. Allerdings glaube ich nicht das es die COM-Schnittstelle ist welches das Programm mit zunehmender Anwendung ausbremst da die Programmausgaben im gesammten langsamer werden und nicht nur 'im Bereich' in dem auf die COM-Schnittstelle zugegriffen wird. Hab mal eine Schleife geschrieben welche einfach sehr viele print-Ausgaben veranlasst. Das Ergebniss ist das gleiche wie bei meinem ersten Posting beschrieben. Die Ausgaben werden immer langsamer. 'Performancebremsgründe' hin oder her was mich trotzdem auf jeden fall interessieren würde ist wie man die Pythonausgaben löschen kann. Wie es von 'Hand' geht weis ich ([STRG] + [a] danach [Entf])

Grüße Fonso

[BlackJack]

@fonso: Von Python aus kannst Du da gar nichts machen. Die ``print``-Ausgaben werden nach `stdout` geschrieben. Das Problem liegt auf der anderen Seite dieser Pipe, bei der IDE.