src/edu/berkeley/fleet/dataflow/MemoryNode.java

   1 package edu.berkeley.fleet.dataflow;
   2 import java.util.*;
   3 import edu.berkeley.fleet.loops.*;
   4 import edu.berkeley.fleet.api.*;
   5 import edu.berkeley.fleet.fpga.*;
   6 import edu.berkeley.fleet.api.Instruction.*;
   7 import edu.berkeley.fleet.api.Instruction.Set;
   8 import edu.berkeley.fleet.api.Instruction.Set.*;
   9 import static edu.berkeley.fleet.api.Predicate.*;
  10
  11
  12 public class MemoryNode extends Node {
  13     private final Ship    ship;
  14     public final InPort  inCBD;
  15     public final InPort  inAddrRead1;
  16     public final InPort  inAddrRead2;
  17     public final InPort  inAddrWrite;
  18     public final InPort  inDataWrite;
  19     public final OutPort outRead1;
  20     public final OutPort outRead2;
  21     public final OutPort outWrite;
  22     public MemoryNode(DataFlowGraph dfg, Ship memoryShip) {
  23         super(dfg);
  24         this.ship = memoryShip;
  25
  26         // ugly hack
  27         if (ship.getType().equals("Dvi")) {
  28             new DockInPort("inPixelX", ship.getDock("inPixelX"), 0, new BitVector[] { null });
  29             new DockInPort("inPixelY", ship.getDock("inPixelY"), 0, new BitVector[] { null });
  30             new DockInPort("inPixelValue", ship.getDock("inPixelValue"), 0, new BitVector[] { null });
  31         }
  32
  33         this.inCBD        = ship.getType().equals("Memory") ? new DockInPort("inCBD", ship.getDock("inCBD")) : null;
  34         this.inDataWrite  = new DockInPort("inDataWrite", ship.getDock("inDataWrite"));
  35         this.inAddrWrite  = new InPort("inAddrWrite") {
  36                 public void recvToken(LoopFactory lf) { lf.recvToken(); }
  37                 public void sendWord(LoopFactory lf) { lf.sendWord(ship.getDock("inAddrWrite").getDataDestination()); }
  38                 public void build(CodeBag ctx) {
  39                     LoopFactory lf = ctx.loopFactory(ship.getDock("inAddrWrite"), 0);
  40                     lf.abortLoopIfTorpedoPresent();
  41                     lf.recvWord();
  42                     lf.deliver();
  43                 }
  44                 public int getTokensToAbsorb() { return outWrite.peer.getTokensToAbsorb(); }
  45                 public int reset(CodeBag ctx, int phase, Destination ackDestination) {
  46                     return DoneNode.doReset(ctx, phase, ship.getDock("inAddrWrite"), this, null, ackDestination, false);
  47                 }
  48             };
  49         this.inAddrRead1  = new InPort("inAddrRead1") {
  50                 public void recvToken(LoopFactory lf) { lf.recvToken(); }
  51                 public void sendWord(LoopFactory lf) { lf.sendWord(ship.getDock("inAddrRead").getDataDestination(), new BitVector(1).set(0)); }
  52                 public void build(CodeBag ctx) { }
  53                 public int getTokensToAbsorb() { return outRead1.peer.getTokensToAbsorb(); }
  54                 public int reset(CodeBag ctx, int phase, Destination ackDestination) {
  55                     return DoneNode.doReset(ctx, phase, ship.getDock("inAddrRead"), this, null, ackDestination, false);
  56                 }
  57             };
  58         this.inAddrRead2  = new InPort("inAddrRead2") {
  59                 public void recvToken(LoopFactory lf) { lf.recvToken(); }
  60                 public void sendWord(LoopFactory lf) { lf.sendWord(ship.getDock("inAddrRead").getDataDestination(), new BitVector(1).set(1)); }
  61                 public void build(CodeBag ctx) { }
  62                 public int getTokensToAbsorb() { return outRead2.peer.getTokensToAbsorb(); }
  63                 public int reset(CodeBag ctx, int phase, Destination ackDestination) { return 0; }
  64             };
  65         this.outRead1 = new OutPort("outRead1") {
  66                 public void sendToken(LoopFactory lf) { inAddrRead1.peer.sendToken(lf); }
  67                 public void recvWord(LoopFactory lf) { lf.recvWord(); }
  68                 public int getNumInitialTokens() { return Math.max(1,Node.CAPACITY/2); }
  69                 public void build(CodeBag ctx) { }
  70                 public int  reset(CodeBag ctx, int phase, Destination ackDestination) { return 0; }
  71             };
  72         this.outRead2 = new OutPort("outRead2") {
  73                 public void sendToken(LoopFactory lf) { inAddrRead2.peer.sendToken(lf); }
  74                 public void recvWord(LoopFactory lf) { lf.recvWord(); }
  75                 public int getNumInitialTokens() { return Math.max(1,Node.CAPACITY/2); }
  76                 public void build(CodeBag ctx) { }
  77                 public int  reset(CodeBag ctx, int phase, Destination ackDestination) { return 0; }
  78             };
  79         this.outWrite = new DockOutPort("out", ship.getDock("out")) {
  80                 public void sendToken(LoopFactory lf) { inAddrWrite.peer.sendToken(lf); }
  81                 public void recvWord(LoopFactory lf) { lf.recvWord(); }
  82                 public int getTokensToAbsorb() { return 0; }
  83                 protected void build(CodeBag ctx, LoopFactory lf) {
  84                     lf = lf.makeNext(0);
  85                     lf.abortLoopIfTorpedoPresent();
  86                     lf.collectWord();
  87
  88                     lf.setFlags(FlagFunction.ONE, FlagFunction.ZERO.add(FlagC));
  89                     if (this.peer != null) {
  90                         lf.setPredicate(Predicate.FlagB);
  91                         lf.literal(77);
  92                         lf.abortLoopIfTorpedoPresent();
  93                         this.peer.sendWord(lf);
  94                     }
  95
  96                     lf.setPredicate(Predicate.NotFlagB);
  97                     lf.abortLoopIfTorpedoPresent();
  98                     lf.recvToken();
  99                     lf.setFlags(FlagFunction.ZERO.add(NotFlagC).add(FlagB), FlagFunction.ZERO.add(FlagC).add(FlagB));
 100                     if (outRead1.peer != null) {
 101                         lf.setPredicate(Predicate.NotFlagB);
 102                         outRead1.peer.sendWord(lf);
 103                     }
 104                     if (outRead2.peer != null) {
 105                         lf.setPredicate(Predicate.NotFlagA);
 106                         outRead2.peer.sendWord(lf);
 107                     }
 108                     lf.setPredicate(null);
 109                 }
 110             };
 111     }
 112     public void build(CodeBag ctx) {
 113         super.build(ctx);
 114         LoopFactory lf;
 115
 116         lf = ctx.loopFactory(ship.getDock("inAddrRead"), 0);
 117         lf.abortLoopIfTorpedoPresent();
 118         lf.recvWord();
 119         lf.setFlags(FlagFunction.ZERO.add(FlagC), FlagFunction.ZERO);
 120         lf.setPredicate(Predicate.NotFlagA);
 121         lf.sendToken(ship.getDock("out").getDataDestination(), new BitVector(1).set(0));
 122         lf.setPredicate(Predicate.FlagA);
 123         lf.sendToken(ship.getDock("out").getDataDestination(), new BitVector(1).set(1));
 124         lf.setPredicate(null);
 125         lf.deliver();
 126     }
 127
 128
 129
 130     public static void clearMem(FleetProcess fp,
 131                                 Ship memory,
 132                                 ShipPool pool,
 133                                 long offset,
 134                                 long count) throws RuntimeException {
 135
 136         DataFlowGraph dfg = new DataFlowGraph(fp.getFleet(), pool);
 137
 138         MemoryNode mem = new MemoryNode(dfg, memory);
 139         UnPunctuatorNode discard = new UnPunctuatorNode(dfg, true);
 140         discard.count.connect(new OnceNode(dfg, (int)(count)).out);
 141         DebugNode debug = new DebugNode(dfg);
 142         DownCounterNode c1 = new DownCounterNode(dfg);
 143         c1.start.connect(new OnceNode(dfg, count).out);
 144         c1.incr.connect(new OnceNode(dfg, 1).out);
 145         mem.inAddrWrite.connect(c1.out);
 146         mem.inDataWrite.connect(new ForeverNode(dfg, 0).out);
 147         mem.outWrite.connect(discard.val);
 148         discard.out.connect(debug.in);
 149
 150         CodeBag ctx = new CodeBag(fp.getFleet());
 151         dfg.build(ctx);
 152         ctx.dispatch(fp, true);
 153         System.out.println("waiting...");
 154         fp.recvWord();
 155         System.out.println("... done");
 156
 157         // FIXME: cleanup?
 158     }
 159
 160     public static void main(String[] s) throws Exception {
 161         Fleet fleet = new Fpga();
 162         FleetProcess fp;
 163         ShipPool pool = new ShipPool(fleet);
 164         Ship mem1 = pool.allocateShip("Memory");
 165         Ship mem2 = pool.allocateShip("Memory");
 166         Ship mem3 = pool.allocateShip("Memory");
 167
 168         fp = fleet.run(new Instruction[0]);
 169         clearMem(fp, mem1, new ShipPool(fleet), 0, 16 * 1024);
 170         fp.terminate();
 171
 172         fp = fleet.run(new Instruction[0]);
 173         clearMem(fp, mem2, new ShipPool(fleet), 0, 16 * 1024);
 174         fp.terminate();
 175
 176         fp = fleet.run(new Instruction[0]);
 177         clearMem(fp, mem3, new ShipPool(fleet), 0, 16 * 1024);
 178         fp.terminate();
 179     }
 180
 181
 182 }