Aufgabe: Welche dieser Funktionen wird am schnellsten ausgeführt?

public class Compare { public static boolean eq1(int a, int b) { if (a == b) return true; else return false; } public static boolean eq2(int a, int b) { if (a == b) return true; return false; } public static boolean eq3(int a, int b) { return (a == b)? true: false; } public static boolean eq4(int a, int b) { return (a == b); } }
Roland

ist das ein rätsel oder was [img]http://images.rapidforum.com/images/i23.gif[/img],

ich tipp mal auf die letzte, schön kurz,
aber wenn ich an meinen frankreich-bei-der-wm-tipp denke… [img]http://images.rapidforum.com/images/i10.gif[/img]

Alle gleichschnell? *verwirrtGuck*

Nicht so ganz….
Ich tippe mal, dass die ersten drei Methoden gleichschnell ablaufen, und zwar um einen Schritt langsamer als die die letzte. Der Grund ist einfach der, dass hier ein Vergleich weniger benötigt wird.
Die If Schleife prüft ja auf (arg == true) also auf (arg1 == arg2) == true. Genau das selbe, wenn man das else weglässt, hier wird lediglich ein Jump-Point nicht gesetzt, bzw. die If-Struktur wird verlassen und der Programmcode wird normal weiter abgearbeitet.
Bei der letzten Variante geschieht nur ein Vergleich nämlich (arg1 == arg2) und das Ergebnis wird nicht noch einmal mit irgendwas verglichen, sondern sofort zurückgeliefert…
ByTheWay… Wenn der Java-Compiler auch nur ein wenig was von Effizienz versteht wird er alle Varianten auf die letzte "herunter"compilieren. Bei der zweiten Methode bin ich mir da nicht ganz so sicher ob er es hinkriegt, sollte aber mit ein wenig "Intelligenz" auch zu durchschauen sein, dass es sich eigentlich nur um eine If-Then-Else Struktur handelt…

ByTheWay… Wenn der Java-Compiler auch nur ein wenig was von Effizienz versteht wird er alle Varianten auf die letzte "herunter"compilieren. Bei der zweiten Methode bin ich mir da nicht ganz so sicher ob er es hinkriegt, sollte aber mit ein wenig "Intelligenz" auch zu durchschauen sein, dass es sich eigentlich nur um eine If-Then-Else Struktur handelt…

Das meinte ich doch damit. [img]http://images.rapidforum.com/images/i23.gif[/img]

da bin ich eher pessimistisch, das er das kann [img]http://images.rapidforum.com/images/i18.gif[/img],
aber wenn ihr meint…

Ich meine nicht, ich mutmaße nur wild und habe im Prinzip absolut keine Ahnung davon. Es würde nur in mein "Schöne-Heile-(PC)Welt"-Bild passen.

Ich meine nicht, ich mutmaße nur wild und habe im Prinzip absolut keine Ahnung davon. Es würde nur in mein "Schöne-Heile-(PC)Welt"-Bild passen.

das war mir auch vorhin schon absolut klar [img]http://images.rapidforum.com/images/i15.gif[/img][img]http://images.rapidforum.com/images/i15.gif[/img]

"Gleich schnell"?!? Mädels, wir reden hier von Java, da fragt man lieber danach, ob man es schafft, zwischendurch noch nen Tee trinken zu gehen oder nicht.

Tja, also wie es bei den Mädels mit -500 MHz Rechnern der früheren Generationen aussieht, möchte ich auch nicht wissen. %)

"Gleich schnell"?!? Mädels, wir reden hier von Java, da fragt man lieber danach, ob man es schafft, zwischendurch noch nen Tee trinken zu gehen oder nicht.

Also ich dachte immer das sei nur ein Gerücht!
Was pure Konsolen-Anwendungen angeht gibt es da glaube ich keinen Unterschied zu C oder ähnlichem.
Natürlich kann man Swing oder AWT da in die Tonne treten, wobei es aber auch schnelleres wie SWT gibt.

Was pure Konsolen-Anwendungen angeht gibt es da glaube ich keinen Unterschied zu C oder ähnlichem.

Glauben ist gut… wenn Java genauso schnell wie C++ sein soll, dann ist VBasic auch so schnell wie Assembler. Wir können ja mal den Vergleich machen: 10 Stunden DivX decoden… einmal mit nem standard codec (ich geh mal stark davon aus, dass die in C mit einzelnen Assemblerroutinen geschrieben werden) und einmal mit Java. Hast du dich noch nie gefragt, warum es bestimmte Sachen NICHT für Java gibt? Java ähnlich in der hinsicht den meisten Emulatoren, nur mit dem Unterschied, dass es versucht, das ganze auch noch in ner sicheren Umgebung ablaufen zu lassen.

but nevermind, have a nice weekend.

Wir können ja mal den Vergleich machen: 10 Stunden DivX decoden… einmal mit nem standard codec (ich geh mal stark davon aus, dass die in C mit einzelnen Assemblerroutinen geschrieben werden) und einmal mit Java.

Ich denke mal beides wird exakt gleich lange dauern.

Allein schon die Tatsache, das Java im Gegensatz zu C nicht direkt auf Hardwareebene läuft, sollte einem wohl klar machen, dass - wenn da noch ne Sandbox zwischenfunkt, und nen Garbagecollector (man stell sich vor den gib's auch in normalen Javakonsolenanwendugen *gg*) fröhlich Rechenzeit frißt - es nur langsamer werden kann. Rechenzeit fällt bekanntlich nicht vom Himmel *fg*.

Vielleicht habe ich etwas übertrieben [img]http://images.rapidforum.com/images/i23.gif[/img]
Java (oder besser die VM) kommt aber durch JIT bzw. HotSpot recht nah an nativen Code heran. Der GC bremst natürlich etwas, kommt aber auch auf die VM an!
Vorteil von Java liegt denke ich mehr in der Stabilität.

uups, das war ich grad

Allein schon die Tatsache, das Java im Gegensatz zu C nicht direkt auf Hardwareebene läuft, sollte einem wohl klar machen, dass […] es nur langsamer werden kann.

Kennst Du nicht den Witz mit dem Kilo Blei und dem Kilo Federn? Genau so ist es hier auch.
Was dauert laenger, 10 Minuten C oder 10 Minuten Java?

Allein schon die Tatsache, das Java im Gegensatz zu C nicht direkt auf Hardwareebene läuft, sollte einem wohl klar machen, dass […] es nur langsamer werden kann.

Kennst Du nicht den Witz mit dem Kilo Blei und dem Kilo Federn? Genau so ist es hier auch.
Was dauert laenger, 10 Minuten C oder 10 Minuten Java?

Das komtm drauf an ob du 10 Stunden lang mit C/Java decoden willst oder ein 10-Stunden-Video meinst ^^

*scharch* Macht mal, ich glaub ihr wißt wieäs gemeint war.

Hier kommt die Auflösung:

Der Compiler ist der Standard-Java-Compiler auf der rzdspc5.

// JReversePro v 1.3.3 - [url=http://jrevpro.sourceforge.net]http://jrevpro.sourceforge.net[/url] // Copyright (C)2000 2001 2002 Karthik Kumar. // JReversePro comes with ABSOLUTELY NO WARRANTY; // This is free software, and you are welcome to redistribute // it under certain conditions;See the File 'COPYING' for more details. // Decompiled by JReversePro 1.3.3 // Home : [url=http://jrevpro.sourceforge.net]http://jrevpro.sourceforge.net[/url] // JVM VERSION: 46.0 // SOURCEFILE: Compare.java public class Compare{ public Compare() { // Max Locals 1 , Max Stack 1 0: aload_0 1: invokespecial #1 > 4: return } public static boolean eq1(int ,int) { // Max Locals 2 , Max Stack 2 0: iload_0 1: iload_1 2: if_icmpne 7 5: iconst_1 6: ireturn 7: iconst_0 8: ireturn } public static boolean eq2(int ,int) { // Max Locals 2 , Max Stack 2 0: iload_0 1: iload_1 2: if_icmpne 7 5: iconst_1 6: ireturn 7: iconst_0 8: ireturn } public static boolean eq3(int ,int) { // Max Locals 2 , Max Stack 2 0: iload_0 1: iload_1 2: if_icmpne 9 5: iconst_1 6: goto 10 9: iconst_0 10: ireturn } public static boolean eq4(int ,int) { // Max Locals 2 , Max Stack 2 0: iload_0 1: iload_1 2: if_icmpne 9 5: iconst_1 6: goto 10 9: iconst_0 10: ireturn } }
Die JVM ist eine (erweiterte) Stackmaschine. Am Anfang der Prozedur stellen wir uns vor, der Stack sei leer. Ich kommentiere jetzt mal die Funktion eq4:

0: iload_0 // Der erste Parameter (= Parameter 0) wird // auf den Stack geladen. 1: iload_1 // der zweite auch. 2: if_icmpne 9 // Die beiden obersten Elemente werden vom Stack // entfernt, verglichen (cmp), und wenn sie // ungleich sind (ne), wird bei (9) weitergemacht. 5: iconst_1 // True auf den Stack schieben 6: goto 10 // und die if-Anweisung beenden 9: iconst_0 // False auf den Stack schieben // und hier ist die if-Anweisung zuende 10: ireturn // Den Wert zurückgeben, der gerade noch auf // dem Stack liegt.

Noch 'ne Anmerkung: Selbst mit dem Aufruf

javac -O Compare.java

schafft es der Sun-Compiler nicht, zu erkennen, daß der jmp-Befehl in eq3 und eq4 direkt zu einem ireturn führt, dieser Schritt also optimiert werden könnte.

Roland

Mir ist eigentlich auch klar, dass Java in der Regel langsamer als c oder auch c++ ist. Mir ist aber nicht klar, wie groß der Unterschied ist.

Vorschlag :

Wir können das ja mal mit ein paar Algorithmen testen. Es wird eine Aufgabe vorgegeben, zu dem dann die Leute, die es drauf haben, in c oder c++ oder in Java ein bischen Code schreiben und hier posten. Die Geschwindigkeit kann dann jeder auf seinem eigenen Rechner vergleichen.

Mein Vorschlag für die 1. Aufgabe :

Sortieren eines Arrays mit 10.000.000 ints. …am Besten mit einer Zeitmessung, damit man das nicht selber machen muss.

In Java habe ich schon einen nicht langsamen Sortieralgorithmus geschrieben. Wenn einer einen Algorithmus in c, c++ oder einer anderen Sprache bringt, dann poste ich meinen hier auch mal.

Gregor

Mein Vorschlag für die 1. Aufgabe :

Sortieren eines Arrays mit 10.000.000 ints. …am Besten mit einer Zeitmessung, damit man das nicht selber machen muss.

Oh Mist. Gerade habe ich das Buch 'Sorting and Searching' von DEK wieder abgegeben …

welche war denn nun die schnellste version?,
ich kann das noch nicht so richtig rauslesen… [img]http://images.rapidforum.com/images/i23.gif[/img]

Ihr solltet ein Quicksort nehmen. Die anderen Sortieralgorithmen sind zu lahm. Mein Algorithmus ist eine Verknüpfung zwischen einem Quicksort und einem Insertionsort.

Gregor

…oder es fällt euch eine gute Möglichkeit ein, ein Bucketsort oder ein Postmansort hier einzusetzen. Das wäre noch um einiges schneller!

Gregor

Ich habe eben einen Test mit Quicksort und 1.000.000 Zufallszahlen durchgeführt. Wobei die Implementationen in C und Java (fast) identisch sind.

(Eigentlich sollten an dieser Stelle die Implementationen kommen, aber aus irgendeinem unerfindlichem Grunde behauptet dieses verf**kte Board ich hätte zu viele Bilder in meinem Post, welche Bilder das auch immer sein mögen)

Und das Ergebnis ist:
VisualC++ : 480ms
Java : 900ms

Also braucht Java 1.8 mal so lange wie C, was schon recht viel ist, wenn man davon ausgeht, dass dieser Geschwindigkeitsunterschied in allen Bereichen so deutlich ist. Ich würde allerdings mutmaßen, dass Java im Bezug auf Grafikdarstellung noch deutlich mehr an Boden verliert.
Vom Speicherverbrauch wollen wir erst gar nicht reden…

Interessanterweise braucht BlueJ ganze 19 Sekunden(!!) für diese Aufgabe. Ich habe wirklich keine Ahnung, was da noch für Bremsen eingebaut werden.

So ich probiers noch mal. Er versucht anscheined einige Sachen aus dem Code in luschtige Symbole umzuwandeln. Wie unheimlich Praktisch, denn gerade dazu ist das -Tag ja da, nicht wahr?? Damit sich zufällig Zeichenfolgen aus heiterem Himmel in Pferde, Pfeile und Pumpguns verwandeln. Das macht das Lesen wesentlich interessanter... grrrr.... Ich hoffe jetzt klappts: Die C-Version: [code] #include <windows.h> #include <stdio.h> void quickSort(int in_array[], int left, int right); void swap(int in_array[], int i, int j); void initArray(); const int NUMBERS = 1000000; int array[NUMBERS]; void main() { initArray(); DWORD StartTime = GetTickCount(); quickSort(array, 0, NUMBERS - 1); DWORD EndTime = GetTickCount(); printf("%d ms\n", EndTime - StartTime); } void initArray() { int seed[ 2 ] = { 0x981d8811, 0x45038805 }; for (int i = 0; i < NUMBERS; i++) { array[ i ] = seed[ 0 ]++ * seed[ 1 ]--; seed[ 0 ] ^= array[ i ]; } } void quickSort(int in_array[], int left, int right) { int current, last; if (left >= right) return; swap(in_array, left, (left+right)/2); last = left; for (current = left + 1; current <= right; current++) if (in_array[current] < in_array[left]) swap(in_array, ++last, current); swap(in_array, left, last); quickSort(in_array, left, last-1); quickSort(in_array, last+1, right); } void swap(int in_array[], int i, int j) { int temp; temp = in_array[i]; in_array[i] = in_array[j]; in_array[j] = temp; }
Die Java-Version:
public class QuickSort { public static void main(String[] args) { initArray(); long startTime = System.currentTimeMillis(); quickSort(array, 0, NUMBERS - 1); long endTime = System.currentTimeMillis(); System.out.println(endTime - startTime + " ms"); } private static final int NUMBERS = 1000000; private static int[] array = new int[NUMBERS]; private static void initArray() { int seed[] = { 0x981d8811, 0x45038805 }; for (int i = 0; i < NUMBERS; i++) { array[ i ] = seed[ 0 ]++ * seed[ 1 ]--; seed[ 0 ] ^= array[ i ]; } } private static void quickSort(int in_array[], int left, int right) { int current, last; if (left >= right) return; swap(in_array, left, (left+right)/2); last = left; for (current = left + 1; current <= right; current++) if (in_array[current] < in_array[left]) swap(in_array, ++last, current); swap(in_array, left, last); quickSort(in_array, left, last-1); quickSort(in_array, last+1, right); } private static void swap(int in_array[], int i, int j) { int temp; temp = in_array[i]; in_array[i] = in_array[j]; in_array[j] = temp; } }

teste doch auch mal mit 2 Mio.,
bei unter 1 sec ist ja viel möglich, da entscheiden vieleicht ein paar einzelne systemzugriffe,

na wahrscheinlich nicht, aber ein vergleichstest hätte java verdient [img]http://images.rapidforum.com/images/i23.gif[/img],
wenn dann die zeitrelation anders auszieht…

edit
das swap in beiden versionen funktioniert doch so gar nicht wie es da steht, oder?
kein -in_array klammer i klammer- sondern nur in_array

edit2

yeah, bluej auf k6/2 400: 2480 ms [img]http://images.rapidforum.com/images/i24.gif[/img]
bei 2 mio: 4890 ms

Werte mit 2 Millionen:
VisualC++: 950ms
Java : 1680ms

Ratio : ~1.7

Also keine große Veränderung.

Natürlich ist die swap Funktion richtig, denn sie vertauscht zwei Werte, die sich in einem Array befinden, wobei in_array das Array angibt und i und j die Indizes.
Das kann man auch einfach verifizieren in dem man sich das Array nach dem sortieren ausgeben lässt und feststellt, ob es wirklich sortiert wurde.

machst du denn dir nicht die mühe mal hinzuschauen, was du da gepostet hast [img]http://images.rapidforum.com/images/i16.gif[/img],
aber hab den fehler schon gefunden, dass wird zusammengeschrieben als html-code interpretiert und nicht als text, und fehlt deshalb,

und java ist eben lahm, nu ist es raus [img]http://images.rapidforum.com/images/i25.gif[/img]

Und dann denkt noch mal an das klasse Speichermanagement… bei kleinen Anwendungen fällt das zwar nicht ins Gewicht, aber wenn der Garbagecollector jedesmal MB-weise Variablen durchwühlt, ist letztenendes Schluss mit lustig. Lieber Memoryleaks als sowas.

Hab mal den Code mit dem OpenWatcom C++ Compiler kompiliert und gegen Java 6 RC antreten lassen. (NUMBERS = 10.000.000)

C++ : 3100ms (Compilerswitch -ox)
Java: 2500ms

Der DigitalMars C++ Compiler verliert ebenfalls gegen Java, MinGW habe ich unter Windows nicht zum Laufen bekommen, der hat die windows.h immer nicht gefunden.

Ich glaube das ist der absolute Rekord im Zombiethreads wiederbeschwören [img]http://www.fb18.de/gfx/15.gif[/img]

Hat jemand zufällig schon ne Unixversion von dem C-Programm mal produziert?

Fred, hast Du für Java die Client-VM oder die Server-VM benutzt? Die Server-VM ist schneller, hat aber einen längeren Startup und höheren Speicherverbrauch. Bei den Größenordnungen solltest Du nichtsdestotrotz noch ein bisschen Speedup rauskitzeln können.

Edit: Einfach java -server [arguments...] statt java [arguments...] zum Starten nehmen.

Die Server-Version ist hier durchgehend langsamer, etwa 2700 zu 2500 [img]http://www.fb18.de/gfx/5.gif[/img]

Naja, mir sind diese "Language Benchmarks" ja im Prinzip völlig Latte. Wahrscheinlich hat GCC dann wieder die Nase vorn, nur krieg ich das hier irgendwie nicht zum Laufen.

Früher war die Server-VM schneller. Hat sich vielleicht verlagert. Oder Du rechnest den Startup mit ein.

10 Millionen Einträge
Java 6: 2300 ms
GCC: 1600 ms

Wobei ich den Source Code für die Variante in C geändert habe, weil sie nicht dem Standard entsprach und der GCC sich weigerte zu kompilieren.
#include <windows.h> #include <stdio.h> #define NUMBERS 10000000 void quickSort(int in_array[], int left, int right); void swap(int in_array[], int i, int j); void initArray(); //const int NUMBERS = 1000000; int array[NUMBERS]; void main() { initArray(); DWORD StartTime = GetTickCount(); quickSort(array, 0, NUMBERS - 1); DWORD EndTime = GetTickCount(); printf("%d ms\n", EndTime - StartTime); } void initArray() { int seed[ 2 ] = { 0x981d8811, 0x45038805 }; int i=0; for (; i < NUMBERS; i++) { array[ i ] = seed[ 0 ]++ * seed[ 1 ]--; seed[ 0 ] ^= array[ i ]; } } void quickSort(int in_array[], int left, int right) { int current, last; if (left >= right) return; swap(in_array, left, (left+right)/2); last = left; for (current = left + 1; current <= right; current++) if (in_array[current] < in_array[left]) swap(in_array, ++last, current); swap(in_array, left, last); quickSort(in_array, left, last-1); quickSort(in_array, last+1, right); } void swap(int in_array[], int i, int j) { int temp; temp = in_array[ i ]; in_array[ i ] = in_array[j]; in_array[j] = temp; }