X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=src%2Fedu%2Fberkeley%2Ffleet%2Finterpreter%2FInterpreter.java;h=5f10626fa234d92b2e092c26f779bae5bcdd58f1;hb=c6d2282ef483917ac627b8511a6eda556d75b5c1;hp=b6a68cec6e21e53b862752ed0bcb13e7e5a527c2;hpb=ebbfdbb803fd44a4a9daaff7987e96c13fcb6a68;p=fleet.git diff --git a/src/edu/berkeley/fleet/interpreter/Interpreter.java b/src/edu/berkeley/fleet/interpreter/Interpreter.java index b6a68ce..5f10626 100644 --- a/src/edu/berkeley/fleet/interpreter/Interpreter.java +++ b/src/edu/berkeley/fleet/interpreter/Interpreter.java @@ -9,11 +9,14 @@ import edu.berkeley.fleet.two.*; import edu.berkeley.fleet.assembler.*; import edu.berkeley.fleet.util.*; -public class Interpreter extends FleetTwoFleet implements Parser.FleetWithDynamicShips { +public class Interpreter extends FleetTwoFleet { + + /** used to allocate serial numbers; see InterpreterDestination for further detail */ + int maxAllocatedDestinationSerialNumber = 0; private InterpreterShip debugShip = null; private BlockingQueue debugStream = new LinkedBlockingQueue(); - private HashMap ships = new HashMap(); + private LinkedHashMap ships = new LinkedHashMap(); public Iterator iterator() { return (Iterator)(Object)ships.values().iterator(); } public Ship getShip(String type, int ordinal) { for(Ship s : this) @@ -24,7 +27,41 @@ public class Interpreter extends FleetTwoFleet implements Parser.FleetWithDynami } /** do not use this; it is going to go away */ - public Interpreter() { + public Interpreter() { this(true); } + public Interpreter(boolean logging) { + this(new String[] { + "Debug", + "Memory", + "Memory", + "Memory", + "Alu", + "Alu", + "Alu", + "Alu", + "Alu", + "Alu", + "Alu", + "Fifo", + "Fifo", + "Counter", + "Counter", + "Counter", + "Counter", + "Counter", + "Counter", + "Counter", + "Counter", + "Counter", + "Counter", + "Counter", + "Counter", + "Counter", + "Counter", + "Lut3", + "CarrySaveAdder", + "Rotator", + "Timer", + }, logging); } public Interpreter(String[] ships, boolean logging) { @@ -36,21 +73,15 @@ public class Interpreter extends FleetTwoFleet implements Parser.FleetWithDynami } } - void dispatch(Instruction i) { - Log.dispatch(i); - long il = writeInstruction(i, debugShip.getDock("in")); - Path path = debugShip.getDock("in").getPath(i.dock.getInstructionDestination(), null); - new Packet((InterpreterPath)path, new BitVector(getWordWidth()).set(il), false).send(); - } - - /** do not use this; it is going to go away */ - public Ship createShip(String shipType, String shipname) { + private Ship createShip(String shipType, String shipname) { try { if (ships.get(shipname)!=null) return ships.get(shipname); Class c = Class.forName("edu.berkeley.fleet.interpreter."+shipType); Constructor con = c.getConstructor(new Class[] { Interpreter.class, String.class, ShipDescription.class }); - BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("ships/"+shipType+".ship"))); - ShipDescription sd = new ShipDescription(shipType, br); + String src = "/ships/" + shipType + ".ship"; + InputStream is = getClass().getResourceAsStream(src); + BufferedReader br = new BufferedReader(new InputStreamReader(is)); + ShipDescription sd = new ShipDescription(this, shipType, br); InterpreterShip ret = (InterpreterShip)con.newInstance(new Object[] { this, shipname, sd }); ships.put(shipname, ret); if (shipType.equals("Debug") && debugShip == null) @@ -75,7 +106,7 @@ public class Interpreter extends FleetTwoFleet implements Parser.FleetWithDynami // Instruction Encoding ///////////////////////////////////////////////////////////////////////// public BitVector getDestAddr(Path path) { - long ret = ((InterpreterDestination)path.getDestination()).addr; + long ret = ((InterpreterDestination)path.getDestination()).getSerialNumber(); BitVector sig = path.getSignal(); BitVector bv = new BitVector(DISPATCH_PATH.valmaskwidth+1); bv.set(ret); @@ -109,6 +140,10 @@ public class Interpreter extends FleetTwoFleet implements Parser.FleetWithDynami pw.println(""); pw.println("public class "+filename+" extends InterpreterShip {"); pw.println(""); + pw.println(" public "+filename+"(Interpreter fleet, String name, ShipDescription sd) {"); + pw.println(" super(fleet, sd);"); + pw.println(" }"); + pw.println(""); for(DockDescription b : sd) { String name = b.getName(); pw.print(" InterpreterDock box_"); @@ -116,12 +151,6 @@ public class Interpreter extends FleetTwoFleet implements Parser.FleetWithDynami pw.print(" = new InterpreterDock(this, shipDescription.getDockDescription(\""+name+"\"));"); } pw.println(""); - pw.println(" public "+filename+"(Interpreter fleet, String name, ShipDescription sd) {"); - pw.println(" super(fleet, sd);"); - for(DockDescription b : sd) - pw.println(" addDock(\""+b.getName()+"\", box_"+b.getName()+");"); - pw.println(" }"); - pw.println(""); pw.println(sd.getSection("fleeterpreter")); pw.println("}"); pw.flush(); @@ -132,25 +161,39 @@ public class Interpreter extends FleetTwoFleet implements Parser.FleetWithDynami // Run ////////////////////////////////////////////////////////////////////////////// public FleetProcess run(final Instruction[] instructions) { - InterpreterProcess ip = new InterpreterProcess(instructions); - new Thread(ip).start(); + InterpreterProcess ip = initialize(instructions); + Thread ipt = new Thread(ip); + ipt.setDaemon(true); + ipt.start(); return ip; } + public InterpreterProcess initialize(Instruction[] instr) { + return new InterpreterProcess(instr); + } + public class InterpreterProcess extends FleetProcess implements Runnable { private Instruction[] instructions; - public void flush() { } - public void sendWord(Destination d, BitVector word) { - throw new RuntimeException("not implemented"); + public synchronized void sendWord(Destination d, BitVector word) { sendWord(d, word, null); } + public synchronized void sendWord(Destination d, BitVector word, BitVector signal) { + InterpreterPath path = (InterpreterPath)debugShip.getDock("in").getPath(d, signal==null?new BitVector(1):signal); + new Packet(path, word, false).send(); + } + public synchronized void sendToken(Destination d) { + InterpreterPath path = (InterpreterPath)debugShip.getDock("in").getPath(d, new BitVector(1)); + new Packet(path, new BitVector(getWordWidth()), true).send(); } - public void sendToken(Destination d) { throw new RuntimeException("not implemented"); } public InterpreterProcess(Instruction[] instructions) { this.instructions = instructions; for(Instruction i : instructions) sendInstruction(i); } public Fleet getFleet() { return Interpreter.this; } - public void sendInstruction(Instruction i) { dispatch(i); } + public synchronized void sendInstruction(Instruction i) { + long il = writeInstruction(i, debugShip.getDock("in")); + Path path = debugShip.getDock("in").getPath(i.dock.getInstructionDestination(), null); + new Packet((InterpreterPath)path, new BitVector(getWordWidth()).set(il), false).send(); + } public Dock getDebugInputDock() { return debugShip.getDock("in"); } public BitVector recvWord() { try { @@ -160,10 +203,9 @@ public class Interpreter extends FleetTwoFleet implements Parser.FleetWithDynami protected void _terminate() { } public void run() { try { - while(!isTerminated()) - for(InterpreterShip ship : ships.values()) - for(int j=0; j<10; j++) - ship._service(); + while(!isTerminated()) { + flush(); + } for(InterpreterShip ship : ships.values()) ship.reset(); debugStream.clear(); @@ -173,13 +215,23 @@ public class Interpreter extends FleetTwoFleet implements Parser.FleetWithDynami } } - public void step(Dock d) { + public void flush() { + // FIXME: should this run until we detect some sort of "quiescence"? OTOH that might never happen. + for(InterpreterShip ship : ships.values()) + for(int j=0; j<10; j++) + if (!isTerminated()) + synchronized(this) { + ship._service(); + } + } + + public synchronized void step(Dock d) { ((InterpreterDock)d).service(); } - public void step(Ship s) { + public synchronized void step(Ship s) { ((InterpreterShip)s).service(); } } -} \ No newline at end of file +}