Cache-Simulator

[oezkany]

Hallo liebe Forum User,

ich sitze an meiner Abgabe für einen Cache-Simulator für einen 1-fach, 2-fach und 4-fach assoziativen Cache.

Ich bekomme eine java.lang.ArrayIndexOutOfBoundsException. Damit weiß ich nichts anzufangen.

Die Daten werden aus einer Datei gelesen, wodurch der Cache simuliert wird.

Folgende Fehlermeldung:

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Array index out of range: 7249
	at java.util.Vector.get(Vector.java:694)
	at Aufgabe3.Tabelle.isHit(Tabelle.java:34)
	at Aufgabe3.Cache.einfach(Cache.java:89)
	at Aufgabe3.Cache.verwerten(Cache.java:80)
	at Aufgabe3.Cache.simulieren(Cache.java:67)
	at Aufgabe3.Main.main(Main.java:29)

Wie auch in der Fehlermeldung ersichtlich beginnt der Prozess, indem von main aus die simulieren()-Methode aufgerufen wird, dann verwerfen(), dann einfach().

Hier der Code von Cache.java:

package Aufgabe3;

import java.io.*;
import java.util.*;

public class Cache {
		// Wird für jeden Cache gebraucht.
		private Tabelle eins;
		// Wird für 2-fach und 4-fach assoziativen Cache gebraucht.
		private Tabelle zwei;
		// drei und vier werden nur für 4-fache Assoziativität gebraucht.
		private Tabelle drei;
		private Tabelle vier;
		
		private int asso;
		private int hits;
		private int misses;
		private int lines;
		
		private String filenameTrace;

		public Cache(int cache, int asso){
			Tabelle neu = new Tabelle((int)(cache/(4*asso)));
			
			if(asso==1){
				this.setEins(neu);
			}
			if(asso==2){
				this.setEins(neu);
				this.setZwei(neu);
			}
			if(asso==4){
				this.setEins(neu);
				this.setZwei(neu);
				this.setDrei(neu);
				this.setVier(neu);
			}
			this.setAsso(asso);
			this.setHits(0);
			this.setMisses(0);
			this.setLines(0);
		}
		
		// Startet die Simulation eines bestimmten Modus (Daten, Instruktionen oder Unified)
		public void simulieren(String modus){
			String line = "";
			int wert1 = 0;
			String wert2 = "";
			
	        try{    
	            BufferedReader in = new BufferedReader(new FileReader(this.getFilenameTrace()));
	            if (!in.ready()) throw new IOException();

	            while ((line = in.readLine()) != null){					
	            	for(int i=0; i<line.length()-1 ; i++){
	            		if(i==0)
	            			wert1 = line.charAt(i);
	            		if(i>1 && i<line.length())
	            			wert2 += line.charAt(i);
	            	}
					
					if(modus.contains("D") && (wert1==0 || wert1==1))
						this.verwerten(Integer.parseInt(wert2));
					if(modus.contains("I") && wert1==2)
						this.verwerten(Integer.parseInt(wert2));
					if(modus.contains("U"))
						this.verwerten(Integer.parseInt(wert2));
	            }

	            in.close();
	        } catch (IOException e) {
	            System.out.println(e + " - Datei " + this.getFilenameTrace() + " konnte nicht gelesen werden!");
	        }
		}
		
		// Gibt die Simulation für die verschiedenen Assoziativitäten weiter. (dm,2fach,4fach)
		public void verwerten(int wert){
			this.incrementLines();
			if(this.getAsso()==1)
				this.einfach(wert);
			if(this.getAsso()==2)
				this.zweifach(wert);
			if(this.getAsso()==4)
				this.vierfach(wert);
		}
		
		// Simulieren schließlich die Assoziativitäten und den obigen 'Filten'-Bedingungen.
		public void einfach(int wert){
			if(this.getEins().isHit(wert)){
				this.incrementHits();
			} else {
				this.incrementMisses();
				this.getEins().eintragen(wert);
			}
		}
		
		public void zweifach(int wert){
			if(this.getEins().isHit(wert) || this.getZwei().isHit(wert)){
				this.incrementHits();
			} else {
				this.incrementMisses();
				int b1 = this.getEins().getBenutzt(wert);
				int b2 = this.getZwei().getBenutzt(wert);
				
				if(b1<=b2){
					this.getEins().pushBenutzt(wert);
					this.getZwei().eintragen(wert);
				} else if(b2<=b1){
					this.getEins().eintragen(wert);
					this.getZwei().pushBenutzt(wert);
				}
			}
		}
		
		public void vierfach(int wert){
			if(eins.isHit(wert) || zwei.isHit(wert) || drei.isHit(wert) || vier.isHit(wert)){
				this.incrementHits();
			} else {
				int b1 = this.getEins().getBenutzt(wert);
				int b2 = this.getZwei().getBenutzt(wert);
				int b3 = this.getDrei().getBenutzt(wert);
				int b4 = this.getVier().getBenutzt(wert);
				this.incrementMisses();
				
				if(b1>=b2 && b1>=b3 && b1>=b4){
					this.getEins().eintragen(wert);
					this.getZwei().pushBenutzt(wert);
					this.getDrei().pushBenutzt(wert);
					this.getVier().pushBenutzt(wert);
				}
				else if(b2>=b1 && b2>=b3 && b2>=b4){
					this.getEins().pushBenutzt(wert);
					this.getZwei().eintragen(wert);
					this.getDrei().pushBenutzt(wert);
					this.getVier().pushBenutzt(wert);
				}
				else if(b3>=b1 && b3>=b2 && b3>=b4){
					this.getEins().pushBenutzt(wert);
					this.getZwei().pushBenutzt(wert);
					this.getDrei().eintragen(wert);
					this.getVier().pushBenutzt(wert);
				}
				else if(b4>=b1 && b4>=b2 && b4>=b3){
					this.getEins().pushBenutzt(wert);
					this.getZwei().pushBenutzt(wert);
					this.getDrei().pushBenutzt(wert);
					this.getVier().eintragen(wert);
				} else {
					System.out.println("Letzte Chance\n");
				}
			}
		}

		public Tabelle getEins() {
			return eins;
		}

		public void setEins(Tabelle eins) {
			this.eins = eins;
		}

		public Tabelle getZwei() {
			return zwei;
		}

		public void setZwei(Tabelle zwei) {
			this.zwei = zwei;
		}

		public Tabelle getDrei() {
			return drei;
		}

		public void setDrei(Tabelle drei) {
			this.drei = drei;
		}

		public Tabelle getVier() {
			return vier;
		}

		public void setVier(Tabelle vier) {
			this.vier = vier;
		}

		public int getAsso() {
			return asso;
		}

		public void setAsso(int asso) {
			this.asso = asso;
		}

		public int getHits() {
			return hits;
		}
		
		public void setHits(int hits) {
			this.hits = hits;
		}
		
		public void incrementHits(){
			this.setHits(this.getHits() + 1);
		}
		
		public int getMisses() {
			return misses;
		}

		public void setMisses(int misses) {
			this.misses = misses;
		}
		
		public void incrementMisses(){
			this.setHits(this.getHits() + 1);
		}
		
		public int getLines() {
			return lines;
		}

		public void setLines(int lines) {
			this.lines = lines;
		}
		
		public void incrementLines(){
			this.setLines(this.getLines() + 1);
		}

		public String getFilenameTrace() {
			return filenameTrace;
		}

		public void setFilenameTrace(String filenameTrace) {
			this.filenameTrace = filenameTrace;
		}		
		
}

hier Tabelle.java:

package Aufgabe3;

import java.util.Iterator;
import java.util.Vector;

public class Tabelle {
	protected Vector<Feld> kompletteTabelle;
	protected int sets;

	public Tabelle() {

	}

	// Initialisiert komplett auf die Anzahl von sets.
	public Tabelle(int set) {
		this.setSets(set);

		Vector<Feld> v = new Vector<Feld>(this.getSets());
		this.setKompetteTabelle(v);
		Feld feld = new Feld();
		for (Iterator<Feld> it = v.iterator(); it.hasNext(); feld = it
				.next()) {
				feld.setBenutzt(15);
		}
	}

	// Prüft ob ein Hit vorliegt. Falls ja wird der 'benutzt'-Wert des
	// entsprechenden
	// Feldes auf 0 (=LRU) gesetzt. Falls nein wird der 'benutzt'-Wert
	// inkrementiert.
	public boolean isHit(int test) {
		int stelle = test % this.getSets();

		if (test == this.getKompletteTabelle().get(stelle).getWert()) {
			this.getKompletteTabelle().get(stelle).setBenutzt(0);
			return true;
		} else {
			this.getKompletteTabelle().get(stelle).incrementBenutzt();
			return false;
		}
	}

	// Liefert den 'benutzt'-Wert an der Stelle zurück, an der Wert im TLB
	// steht.
	public int getBenutzt(int test) {
		return this.getKompletteTabelle().get(test % this.getSets())
				.getBenutzt();
	}

	// Inkrementiert den 'benutzt'-Wert an der Stelle des Wertes.
	public void pushBenutzt(int test) {
		this.getKompletteTabelle().get(test % this.getSets())
				.incrementBenutzt();
	}

	// Trägt den Wert in den TLB ein. 'benutzt'-Wert wird auf 0 gesetzt.
	public void eintragen(int einzutragen) {
		int stelle = einzutragen % this.getSets();
		Feld neu = new Feld(einzutragen, 0);
		this.getKompletteTabelle().set(stelle, neu);
	}

	public void setSets(int value) {
		this.sets = value;
	}

	public int getSets() {
		return this.sets;
	}

	public void setKompetteTabelle(Vector<Feld> value) {
		this.kompletteTabelle = value;
	}

	public Vector<Feld> getKompletteTabelle() {
		return this.kompletteTabelle;
	}
}

hier Feld.java:

package Aufgabe3;

public class Feld {
	private int benutzt;
	private int wert;
	
	public Feld(){
		
	}
	
	public Feld(int wert, int benutzt){
		this.setWert(wert);
		this.setBenutzt(benutzt);
	}
	
	public int getBenutzt() {
		return benutzt;
	}
	public void setBenutzt(int benutzt) {
		this.benutzt = benutzt;
	}
	public int getWert() {
		return wert;
	}
	public void setWert(int wert) {
		this.wert = wert;
	}
	public void incrementBenutzt(){
		this.setBenutzt(this.getBenutzt() + 1);
	}
}

Danke an euch im Voraus..

 

[faetzminator]

Die Grösse der Daten wird kleiner als [c]sets[/c] sein...

 

[oezkany]

und was hat das mit ArrayIndexOutOfBoundsException zu tun?
darf doch nix passieren, wenn die Daten kleiner als sets ist!!
Wie kommst Du drauf?
Danke.

 

[eRaaaa]

       int stelle = test % this.getSets();
 
        if (test == this.getKompletteTabelle().get(stelle).getWert()) {

schau dir mal "stelle" an! (+die Größe des Vectors!)

 

[oezkany]

Ja Du hast recht!
Irgendetwas ist da faul.

ich hab mir die stelle genauer angeguckt.
40017 % 8192 = 7249

und der versucht auf die index-stelle KompletteTabelle[7249] zu schreiben!

hmm, muss mir was besseres einfallen lassen!!

 

[faetzminator]

Da ich nicht diese vielen Zeilen lesen will, was versuchst du? Vielleicht kann ich oder jemand anders dir einen schönen Ansatz für dein Problem geben.