src/edu/berkeley/fleet/interpreter/Interpreter.java

   1 package edu.berkeley.fleet.interpreter;
   2 import java.io.*;
   3 import java.util.*;
   4 import java.util.concurrent.*;
   5 import java.lang.reflect.*;
   6 import edu.berkeley.sbp.util.ANSI;
   7 import edu.berkeley.fleet.api.*;
   8 import edu.berkeley.fleet.two.*;
   9 import edu.berkeley.fleet.assembler.*;
  10 import edu.berkeley.fleet.util.*;
  11
  12 public class Interpreter extends FleetTwoFleet implements Parser.FleetWithDynamicShips {
  13
  14     private BlockingQueue<BitVector> debugStream = new LinkedBlockingQueue<BitVector>();
  15     private InterpreterShip debugShip = null;
  16     private HashMap<String,InterpreterShip> ships = new HashMap<String,InterpreterShip>();
  17     public Iterator<Ship> iterator() { return (Iterator<Ship>)(Object)ships.values().iterator(); }
  18     public Ship getShip(String type, int ordinal) {
  19         for(Ship s : this)
  20             if (s.getType().equals(type))
  21                 if (ordinal-- < 0)
  22                     return s;
  23         return null;
  24     }
  25
  26     void dispatch(Instruction i) {
  27         Log.dispatch(i);
  28         ((InterpreterDock)i.dock).addInstruction(i);
  29     }
  30
  31     public Ship createShip(String shipType, String shipname) {
  32         try {
  33             Class c = Class.forName("edu.berkeley.fleet.interpreter."+shipType);
  34             Constructor con = c.getConstructor(new Class[] { Interpreter.class, String.class, ShipDescription.class });
  35             BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("ships/"+shipType+".ship")));
  36             ShipDescription sd = new ShipDescription(shipType, br);
  37             InterpreterShip ret = (InterpreterShip)con.newInstance(new Object[] { this, shipname, sd });
  38             ships.put(shipname, ret);
  39             if (shipType.equals("Debug") && debugShip == null)
  40                 debugShip = ret;
  41             return ret;
  42         } catch (Exception e) {
  43             e.printStackTrace();
  44             return null;
  45         }
  46     }
  47
  48     void debug(long d) {
  49         throw new RuntimeException();
  50     }
  51     void debug(BitVector data) {
  52         try {
  53             if (debugStream != null) debugStream.put(data);
  54             else Log.println(ANSI.invert("   DEBUG: got a datum: " +  data+ANSI.clreol()));
  55         } catch (Exception e) {
  56             throw new RuntimeException(e);
  57         }
  58     }
  59
  60     // Instruction Encoding /////////////////////////////////////////////////////////////////////////
  61
  62     public long getDestAddr(Path path) {
  63         long ret = ((InterpreterDestination)path.getDestination()).addr;
  64         BitVector bv = path.getSignal();
  65         if (bv.length() > 1) throw new RuntimeException();
  66         if (bv.length() > 0 && bv.get(0)) ret |= 1;
  67         return ret;
  68     }
  69
  70
  71     // ShipDescription //////////////////////////////////////////////////////////////////////////////
  72
  73     public void expand(ShipDescription sd) {
  74         try {
  75             String filename = sd.getName();
  76             //String filename = (sd.getName().charAt(0)+"").toUpperCase() + sd.getName().substring(1).toLowerCase();
  77             File outf = new File("build/java/edu/berkeley/fleet/interpreter/"+filename+".java");
  78             new File(outf.getParent()).mkdirs();
  79             System.err.println("writing to " + outf);
  80             FileOutputStream out = new FileOutputStream(outf);
  81             PrintWriter pw = new PrintWriter(out);
  82
  83             pw.println("package edu.berkeley.fleet.interpreter;");
  84             pw.println("import edu.berkeley.sbp.util.ANSI;");
  85             pw.println("import edu.berkeley.fleet.api.*;");
  86             pw.println("import edu.berkeley.fleet.two.*;");
  87             pw.println("import edu.berkeley.fleet.*;");
  88             pw.println("import java.util.*;");
  89             pw.println("import java.io.*;");
  90             pw.println("");
  91             pw.println("public class "+filename+" extends InterpreterShip {");
  92             pw.println("");
  93             for(DockDescription b : sd) {
  94                 String name = b.getName();
  95                 pw.print("    InterpreterDock box_");
  96                 pw.print(name);
  97                 pw.print(" = new InterpreterDock(this, shipDescription.getDockDescription(\""+name+"\"));");
  98             }
  99             pw.println("");
 100             pw.println("    public "+filename+"(Interpreter fleet, String name, ShipDescription sd) {");
 101             pw.println("       super(fleet, sd);");
 102             for(DockDescription b : sd)
 103                 pw.println("       addDock(\""+b.getName()+"\", box_"+b.getName()+");");
 104             pw.println("    }");
 105             pw.println("");
 106             pw.println(sd.getSection("fleeterpreter"));
 107             pw.println("}");
 108             pw.flush();
 109             pw.close();
 110         } catch (Exception e) { throw new RuntimeException(e); }
 111     }
 112
 113     // Run //////////////////////////////////////////////////////////////////////////////
 114
 115     public FleetProcess run(final Instruction[] instructions) {
 116         InterpreterProcess ip = new InterpreterProcess(instructions);
 117         new Thread(ip).start();
 118         return ip;
 119     }
 120
 121     private class InterpreterProcess extends FleetProcess implements Runnable {
 122         private Instruction[] instructions;
 123         public InterpreterProcess(Instruction[] instructions) {
 124             this.instructions = instructions;
 125         }
 126         public void dispatchInstruction(Instruction i) { dispatch(i); }
 127         public Dock getDebugInputDock() { return debugShip.getDock("in"); }
 128         public BitVector readWord() {
 129             try {
 130                 return debugStream.take();
 131             } catch (Exception e) { throw new RuntimeException(e); }
 132         }
 133         protected void _terminate() { }
 134         public void run() {
 135             try {
 136                 while(!isTerminated())
 137                     for(InterpreterShip ship : ships.values())
 138                         for(int j=0; j<10; j++)
 139                             ship._service();
 140                 for(InterpreterShip ship : ships.values())
 141                     ship.reset();
 142                 debugStream.clear();
 143             } catch (Exception e) {
 144                 if (isTerminated()) return;
 145                 throw new RuntimeException(e);
 146             }
 147         }
 148     }
 149 }