Threads Taskzeit berechnen

[Rüdiger Hund]

Guten Tag

Ich suche eine Möglichkeit, um die benötigte Rechenzeit eines Tasks innerhalb meines Programms zu ermitteln. Die Genauigkeit sollte in Millisekunden mit einigen Nachkommastellen sein (also am besten Nanosekunden...).

Mein bisheriger Ansatz:

startTimeNano = System.nanoTime( );
//Start Task
//End Task
taskTime = (System.nanoTime( ) - startTimeNano)/1000000;

Das Problem ist nur, dass nebenbei natürlich noch andere Tasks vom Prozessor verarbeitet werden...
so unterscheiden sich meine Werte bei mehreren Messungen relativ stark.

Meine Frage: Gibt es eine Möglichkeit für eine genauere Messung oder soll ich die Messung mehrfach durchführen und immer den kleinsten Wert nehmen?

Danke und Gruss

 

[hüteüberhüte]

Nein, es gibt in Java keine genauere Möglichkeit.

 

[Meno Hochschild]

Also Vorsicht bitte, wenn Millisekundengenauigkeit MIT Nachkommastellen erwartet wird. Auf Standard-PCs mit Windows ist oft nur eine Genauigkeit von 10-50 ms erreichbar, auf modernen Windows-Varianten und UNIX/Linux vielleicht noch 1 ms, aber das war es dann auch. Hier ist das Betriebssystem (und die Hardware) der begrenzende Faktor.

Zwar generiert System.nanoTime(), so wie du das benutzt, auch Nachkommastellen im Mikrosekundenbereich, und die Methode versucht laut API-Dokumentation auch, eine möglichst genaue Hardware-Uhr zu benutzen, aber das heißt noch lange nicht, das diese Stellen als "echte" Mikrosekunden interpretiert werden können.

Vielleicht können hier Hardware-Experten Dir noch etwas Genaueres sagen. Ansonsten ist es immer sinnvoll, Messwerte mit vielen Durchläufen statistisch zu mitteln.

 

[SlaterB]

> Messwerte mit vielen Durchläufen statistisch zu mitteln.

richtig, und dabei auch vermeiden, für jeden Durchlauf eine einzelne Zeit ermitteln zu wollen,
das Sicherste (der bisher genannten Varianten) ist
- eine Zeit A messen
- das Programm beschäftigten, N=10, 100, oder 1000 Wiederholungen der Aktion X, so dass paar Sekunden vergehen
- eine zweite Zeit B messen
- B-A/ N rechnen

 

[tröööt]

Also Vorsicht bitte, wenn Millisekundengenauigkeit MIT Nachkommastellen erwartet wird. Auf Standard-PCs mit Windows ist oft nur eine Genauigkeit von 10-50 ms erreichbar, auf modernen Windows-Varianten und UNIX/Linux vielleicht noch 1 ms, aber das war es dann auch. Hier ist das Betriebssystem (und die Hardware) der begrenzende Faktor.

Zwar generiert System.nanoTime(), so wie du das benutzt, auch Nachkommastellen im Mikrosekundenbereich, und die Methode versucht laut API-Dokumentation auch, eine möglichst genaue Hardware-Uhr zu benutzen, aber das heißt noch lange nicht, das diese Stellen als "echte" Mikrosekunden interpretiert werden können.

Vielleicht können hier Hardware-Experten Dir noch etwas Genaueres sagen. Ansonsten ist es immer sinnvoll, Messwerte mit vielen Durchläufen statistisch zu mitteln.

so .. und jetzt mal bitte ganz erlich : QUELLE ?

wer bitte kommt immer wieder auf diese total bekloppte idee windows sei angeblich unpräzieser als unix ? und vor allem warum gleich 10ms bis 50ms ?

gibt es dafür bitte irgendwelche quellen ... oder ist das alles nur mund-propaganda weil man genau diesen bullshit irgendwo gelesen hat und anstatt es selbst mal auszuprobieren einfach glaubt und weiter erzählt ...

wenn die hardware nur 10ms auflösung schafft ... ist es völlig banane ob man unix oder windows nutzt ... also lasst bitte endlich mal das lästern über windows und darüber das es bei allem was mit zeit-messung zu tun hätte angeblich so stark unpräzise wäre ...


und noch eins : führt doch einfach mal folgenden code aus und postet mal was bei euch so raus kommt

public class Time
{
	public static void main(String[] args)
	{
		for(int i=0; i<10; i++)
		{
			System.out.println(System.nanoTime());
		}
	}
}

liefert bei mir

171600515546808
171600519017361
171600519182186
171600519340586
171600519464624
171600519573856
171600519806567
171600519920269
171600520032015
171600520128116

system :
ASRock ALive Dual eSATA2
AMD Athlon 64 x2 4600+
4GB DDR2 RAM
Win 7 Ulti x64 SP1

und bei mir kommt ne auflösung von ungefähr 100000ns-200000ns ... was also im bereich von 1/10 ms liegt ... und ich denke bei heutigen "modernene" systemen wie Intel i7 oder nem gleichwertigen AMD auf so nem schönen neuen board von ASUS dürfte es noch weit aus genauer gehen ...


um aber die frage von TO zu beantworten

1) sowas nennt man mikro-benchmarking ... und sowas ist schwachsinn da , wie du ja siehst , starke abweichungen zu stande kommen ... mach es lieber so wie Slater sagte
2) du kannst nur die zeit messen die dir das system auch als numerischen wert gibt ... wie lange jetzt ein gewisser ablauf wirklich im cpu war ... und wie lang diese zeitspanne ist wenn man alles zusammenrechnet ... sowas kann man nur sehr schlecht bis gar nicht rausbekommen ... und mit java stehen die chancen eher schlecht ...

 

[Rüdiger Hund]

Erstmal Danke für die schnellen Antworten.

Mit der Zeitmessung (und Genauigkeit) bin ich eigentlich zufrieden. Es geht mir mehr darum, dass auch andere Tasks in die Messzeit hineinwirken.
Ich suche also nach einem Ansatz einen Task zu "isolieren" oder überwachen, um genau seine Zeit zu messen.
Es gibt ja auch Fälle, in denen ein Programm den Prozessor nicht mehr freigibt und es so zu einem Absturz kommt. Könnte ich diesen Zustand "kontrolliert" erreichen, würde ich mit sicherheit nur mein Programm messen...

@SlaterB: Dein Ansatz gefällt mir bisher ganz gut. Sollte ich keine andere Lösung finden, werde ich es wahrscheinlich so machen.

@tröööt: Genau diesen Gedanken hatte ich auch, denn ich führte mehrere Messungen in kurzen Abständen aus und die Zeitunterschieden waren alle im Verhältnis zueinander korrekt und mit sehr kleinen Zeiteinheiten.

 

[freez]

Ich habe mal dein Beispiel verändert um noch kleinere Werte zu erhalten:

		long start = System.nanoTime();

		long[] arr = new long[20];

		for (int i = 0; i < arr.length; i++)
			arr[i] = System.nanoTime() - start;

		for (int i = 1; i < arr.length; i++) {
			System.out.println("Differenz: " + (arr[i] - arr[i - 1]));
		}

Ergebnis (Messzeiten):

Differenz: 1118
Differenz: 838
Differenz: 838
Differenz: 1117
Differenz: 838
Differenz: 838
Differenz: 839
Differenz: 1117
Differenz: 838
Differenz: 838
Differenz: 838
Differenz: 1118
Differenz: 838
Differenz: 838
Differenz: 838
Differenz: 1118
Differenz: 838
Differenz: 838
Differenz: 838

Aber ganz ehrlich ... sagt das jetzt tatsächlich aus, dass mein PC mindestens ca. 1 Microsekunde genau messen kann (unabhängig davon, dass hier Ungenauigkeiten wegen der CPU Auslastung bei dem zu Testenden Code hinzukommen können)?

 

[freez]

Ich suche also nach einem Ansatz einen Task zu "isolieren" oder überwachen, um genau seine Zeit zu messen.

Nun, diese Tasks musst du auch messen und würdest am Ende von der Gesamtzeit abziehen. Aber wie meine Vorredner schon sagten, diese Methode reicht lediglich um einen Eindruck zu erhalten.

 

[tröööt]

Ich habe mal dein Beispiel verändert um noch kleinere Werte zu erhalten:

		long start = System.nanoTime();

		long[] arr = new long[20];

		for (int i = 0; i < arr.length; i++)
			arr[i] = System.nanoTime() - start;

		for (int i = 1; i < arr.length; i++) {
			System.out.println("Differenz: " + (arr[i] - arr[i - 1]));
		}

Ergebnis (Messzeiten):

Differenz: 1118
Differenz: 838
Differenz: 838
Differenz: 1117
Differenz: 838
Differenz: 838
Differenz: 839
Differenz: 1117
Differenz: 838
Differenz: 838
Differenz: 838
Differenz: 1118
Differenz: 838
Differenz: 838
Differenz: 838
Differenz: 1118
Differenz: 838
Differenz: 838
Differenz: 838

Aber ganz ehrlich ... sagt das jetzt tatsächlich aus, dass mein PC mindestens ca. 1 Microsekunde genau messen kann (unabhängig davon, dass hier Ungenauigkeiten wegen der CPU Auslastung bei dem zu Testenden Code hinzukommen können)?

klar ist mein code ein sehr schlechtes beispiel und bezieht sogar die zeit für die ausgabe noch mit ein ... aber es sollte mal ein halbwegs realistischer code sein ...
das du mit nem array und nem loop natürlich auf noch sehr viel kleinere werte kommst ... und mit sicherheit auch eine etwas leistungsfähigere kiste haben dürftest als ich ... war mir klar ...

ich wollte nur mal einen beleg für die behauptung das zeitmessung mit java angeblich so ungenau wäre ... und es angeblich eine große rolle spielt ob man windows oder unix nutzt ... was ja mit unseren beispielen widerlegt ist ...


@TO
ich glaube das dürfte nicht mal mit C so genau möglich sein wirklich nur genau die takt-zyklen zu zählen die auch wirklich der entsprechende thread im cpu läuft und nicht die gesamt-zeit aller in der zeit abgearbeiteten threads ... aber mit java selbst ... also ohne irgendwelche libs ... ist das definitiv unmöglich ...

kontrolliert den zustand erreichen in dem ein thread einen cpu-kern so lange blockiert bis er selbst vollständig abgearbeitet ist ... das dürfte unter modernen systemen sehr schwer werden ... zu mal die VM selbst intern mit einigen threads arbeitet ... und somit selbst zum teil für die verwaltung der eigenen threads sorge zu tragen hat ...


um es also auf den punkt zu bringen : das was du machen möchtest kann man mit java nicht umsetzen

 

[Meno Hochschild]

so .. und jetzt mal bitte ganz erlich : QUELLE ?

wer bitte kommt immer wieder auf diese total bekloppte idee windows sei angeblich unpräzieser als unix ? und vor allem warum gleich 10ms bis 50ms ?

gibt es dafür bitte irgendwelche quellen ... oder ist das alles nur mund-propaganda weil man genau diesen bullshit irgendwo gelesen hat und anstatt es selbst mal auszuprobieren einfach glaubt und weiter erzählt ...

wenn die hardware nur 10ms auflösung schafft ... ist es völlig banane ob man unix oder windows nutzt ... also lasst bitte endlich mal das lästern über windows und darüber das es bei allem was mit zeit-messung zu tun hätte angeblich so stark unpräzise wäre ...


und noch eins : führt doch einfach mal folgenden code aus und postet mal was bei euch so raus kommt

public class Time
{
	public static void main(String[] args)
	{
		for(int i=0; i<10; i++)
		{
			System.out.println(System.nanoTime());
		}
	}
}

liefert bei mir

171600515546808
171600519017361
171600519182186
171600519340586
171600519464624
171600519573856
171600519806567
171600519920269
171600520032015
171600520128116

system :
ASRock ALive Dual eSATA2
AMD Athlon 64 x2 4600+
4GB DDR2 RAM
Win 7 Ulti x64 SP1

und bei mir kommt ne auflösung von ungefähr 100000ns-200000ns ... was also im bereich von 1/10 ms liegt ... und ich denke bei heutigen "modernene" systemen wie Intel i7 oder nem gleichwertigen AMD auf so nem schönen neuen board von ASUS dürfte es noch weit aus genauer gehen ...

Hier eine Quelle direkt von Microsoft aus dem Jahre Juni 2010 (sie sollten es am besten wissen):
MSDN-Seite

Das dort herunterladbare Word-Dokument spricht von standardmäßig 15,6 Millisekunden auf Windows 7. Ganz einfach durch Googeln gefunden. Und ich habe bis jetzt noch NIE im Internet einen Hinweis gefunden, daß ein Betriebssystem (egal ob Windows oder Unix) eine bessere Auflösung als 1 Millisekunde schafft.

Im Gegenteil: Man sollte schon ein wenig mißtrauisch gegenüber angeblichen Mikro- oder gar Nanosekundenanzeigen in eigenen Messversuchen sein. Von Datenbanken z.B. ist bekannt, daß sie ihre "Nano"sekundenzeitstempel gerne als laufende Nummer generieren (was sogar zu sehr gleichmäßig aussehenden Differenzen führen kann, aber mit einer Echtzeitauflösung hat das nichts zu tun). Und von PCs oder Laptops weiß man, daß die CPU-Taktfrequenz aus unterschiedlichen Gründen Schwankungen unterliegt.

Das ganze Thema ist unter der Motorhaube noch weitaus komplizierter...

 

[hüteüberhüte]

    public static void main(String[] args) {
        long[] a = new long[20];
        for (int i = 0; i < 20; i++) {
            a[i] = System.nanoTime();
        }
        for (int i = 1; i < a.length; i++) {
            System.out.println(a[i] - a[i - 1]);
        }
    }

liefert bei mir:

6796
424
425
425
0
424
0
425
425
0
424
0
425
425
0
425
0
424
425

Ich hab keine Ahnung, wie das zustande kommt, und ob die Werte realistische Zeitangaben sind.

 

[Meno Hochschild]

Zu System.nanoTime() zwei Links:

https://blogs.oracle.com/dholmes/entry/inside_the_hotspot_vm_clocks


http://www.java-forum.org/allgemeine-java-themen/47725-system-nanotime-einheitlichen-wert-mehreren-rechnern.html

Also System.currentTimeMillis() liefert allenfalls Millisekundengenauigkeit oder schlechter, weil das darunterliegende Betriebssystem schon aus Gründen des Power-Managements nicht jeden CPU-Zyklus verbrauchen will, zu oft ein entsprechendes Signal des System-Timers zu senden. System.nanoTime() versucht an den CPU-Zyklus-Zähler ranzukommen, wenn verfügbar. Dieser Zähler ist auf jedem Computer verschieden, kann aber deutlich genauere Takte liefern. Ob diese Takte nun Echtzeit-Mikro- oder gar Nanosekunden darstellen, kann leider nicht garantiert werden, weil es da Schwankungen gibt etc. Trotzdem ist System.nanoTime() für RELATIVE Zeitmessungen und Mikro-Benchmarks mit RELATIVEN Aussagen gut geeignet - eine statistische Mittelung dazugenommen vorausgesetzt.

 

[tröööt]

The default system-wide timer resolution in Windows is 15.6 ms, which means that every 15.6*ms the operating system receives a clock interrupt from the system timer hardware. When the clock interrupt fires, Windows updates the timer tick count and checks whether a scheduled timer object has expired. Some applications require that timer expiration is serviced more frequently than once every 15.6 ms.

also ich glaube DAS dürfte ja wohl mit unseren codes deutlich widerlegt sein ...
auch wenn das docx noch nicht alt ist ... und meine hardware deutlich älter ... so hat doch alleine dieser abschnitt NULL bedeutung ...