Warmup für Lineare-Suche mit Zeitmessung

Bitte aktiviere JavaScript!
Hallo

da mir schon oft geraten wurde ein Warmup zu programmieren, damit die Zeitwerte nicht verfälscht werden, habe ich dies gemacht.
Meine Frage ist nun, ist dies so richtig ? Die Zeitmessung beginnt damit also erst nach dem Warmup, indem Fall nach 1000 Durchläufen (Warmup).


Code für Suchzeitberechnung mit Warmup :
Java:
public long suchzeitLinear(int schritte1,int schritte2, int warmup) { //schritte1 = 30 , schritte2= 1000 //warmup = 1000
        
        
        long zeit1=0; //Zeit für 30 Suchen
        
        for (int x=0; x<schritte1;x++) {
        long    zeit2=0;; // Zeit für 1000 Suchen
        for (int j=0; j<schritte2;j++ ) {
            
            for (int y=0; y<warmup; y++) {
                
                suche();
            }
            
            final long timeStart = System.nanoTime();
            suche();
            final long timeEnd = System.nanoTime();
            long zeit = timeEnd - timeStart;
            zeit2 += zeit; //Zeit innere Schleife addiert
        
            
        }
        zeit1 += zeit2/schritte2; //Zeit äußere Schleife addiert
        }
        
        long zeitFinal=zeit1/schritte1; //Finale Zeit
        System.out.println("Suchzeit: "+zeitFinal+" Nanosek.");
        return zeitFinal;
    }

Kompletter Code:
Java:
package a3;


import java.util.Random;   
import java.util.Arrays;



public class LineareSuche {
    
    int[] liste; //Array wird definiert als "liste"
    Random zufall = new Random();    // wird erzeugt für Klasse erzeugenUnsortiert()
    int suchzahl; //Dies ist die gesuchte Zahl

    
    public LineareSuche(){
    }
    
    public void erzeugeZufallszahl(int plätze,int oberGrenze) {
        //Erzeugt nicht gleichverteilte Zufallszahlen (doppelte sind möglich)
        
        liste = new int [plätze];
        //Anzahl an Plätze wird übergeben
        
        for (int i=0; i<liste.length;i++) {
            liste[i] = zufall.nextInt(oberGrenze);
            // Liefert eine int-Pseudo-Zufallszahl im Bereich von 0 bis oberGrenze
        }
    }
    
    public void sortieren(){
        Arrays.sort(liste);
    }
    
    
    
    public void ausgabe() {
        for (int i=0; i<liste.length; i++) {
            System.out.println(liste[i] + " || Index: " + (i));
        }
    }
    
    
    
    
    public int suche() {
        
        suchzahl = liste[zufall.nextInt(liste.length)]; //legt eine zufällige Suchzahl im Array fest
        for (int i = 0; i < liste.length; i++){
            if(liste[i] == suchzahl){
                return suchzahl; //wenn gefunden wird suchzahl zurückgegeben
                
            }
        }
                
        return -1; //wenn nicht gefunden
        
        
    }
    
    
    public long suchzeitLinear(int schritte1,int schritte2, int warmup) { //schritte1 = 30 , schritte2= 1000 //warmup = 1000
        
        
        long zeit1=0; //Zeit für 30 Suchen
        
        for (int x=0; x<schritte1;x++) {
        long    zeit2=0;; // Zeit für 1000 Suchen
        for (int j=0; j<schritte2;j++ ) {
            
            for (int y=0; y<warmup; y++) {
                
                suche();
            }
            
            final long timeStart = System.nanoTime();
            suche();
            final long timeEnd = System.nanoTime();
            long zeit = timeEnd - timeStart;
            zeit2 += zeit; //Zeit innere Schleife addiert
        
            
        }
        zeit1 += zeit2/schritte2; //Zeit äußere Schleife addiert
        }
        
        long zeitFinal=zeit1/schritte1; //Finale Zeit
        System.out.println("Suchzeit: "+zeitFinal+" Nanosek.");
        return zeitFinal;
    }
    
    
    
    
    
    
    public static void main(String[] args) {
        LineareSuche l1= new LineareSuche();
        l1.erzeugeZufallszahl(1000, 2000);
        l1.sortieren();
        //l1.ausgabe();
        l1.suchzeitLinear(30,1000,1000);
        
        
    }
}
 
A

Anzeige




Vielleicht hilft dir unser Kurs hier weiter —> (hier klicken)
Als Ergänzung:

Ist dies nicht so, dass die gesuchte Zahlen in den Speicher geladen werden?
Das müsste dann bedeuten, dass die bereits schon mal gesuchte Zahlen, schneller gefunden werden können wenn ich das richtig verstanden habe? Kann ich dem irgendwie entgegen wirken ? Das alle Suchzahlen die selben Voraussetzungen besitzen um die Ergebnisse der Zeitmessung nicht zu verfälschen?
 
Du wirst eher Probleme mit dem CPU Cache kiegern. Der macht RAM Zugriffe überflüssig und hier geht bei einmaliger Ausführung ein Großteil der Zeit drauf. Außerdem misst du die Zeit der Random Funktion mit, was du sicher gar nicht willst.

Du solltest auch bei so einfachen Operationen die Durchläufe viel höher stellen.
 
Passende Stellenanzeigen aus deiner Region:

Oben