src/edu/berkeley/fleet/loops/MemoryUtils.java

   1 package edu.berkeley.fleet.loops;
   2 import edu.berkeley.fleet.loops.*;
   3 import java.util.concurrent.Semaphore;
   4 import java.util.*;
   5 import java.io.*;
   6 import java.net.*;
   7 import edu.berkeley.fleet.two.*;
   8 import edu.berkeley.fleet.fpga.*;
   9 import edu.berkeley.fleet.api.*;
  10 import edu.berkeley.fleet.api.Instruction.*;
  11 import edu.berkeley.fleet.api.Instruction.Set;
  12 import edu.berkeley.fleet.api.Instruction.Set.*;
  13 import edu.berkeley.fleet.api.Instruction.Set.SetDest;
  14 import edu.berkeley.fleet.api.Instruction.Set.FlagFunction;
  15 import static edu.berkeley.fleet.api.Predicate.*;
  16
  17 public class MemoryUtils {
  18
  19     public static void readMem(FleetProcess fp,
  20                                ShipPool pool,
  21                                Ship memory,
  22                                long offset,
  23                                BitVector[] vals) throws RuntimeException {
  24         try {
  25             Ship alu = pool.allocateShip("Alu");
  26             pool.assertAllocated(memory);
  27             MemoryInputStream mos = new MemoryInputStream(fp, pool, memory, alu, offset, 1);
  28             fp.flush();
  29             for(int i=0; i<vals.length; i++) {
  30                 int pct = (int)Math.ceil(100.0*((double)(i)/((double)(vals.length-1))));
  31                 String status = i + "/" + (vals.length-1) + "= " + pct + "%";
  32                 System.out.print("\rreading from address: " + status + "...");
  33                 vals[i] = mos.readWord();
  34                 System.out.print("\rread    from address: " + status + ", got " + vals[i] + " = " + vals[i].toLong()+"           ");
  35             }
  36             mos.close();
  37             pool.releaseShip(alu);
  38         } catch (IOException e) {
  39             throw new RuntimeException(e);
  40         }
  41     }
  42
  43     public static void writeMem(FleetProcess fp,
  44                                 ShipPool pool,
  45                                 Ship memory,
  46                                 long offset,
  47                                 BitVector[] vals) throws RuntimeException {
  48         try {
  49             Ship alu = pool.allocateShip("Alu");
  50             pool.assertAllocated(memory);
  51             MemoryOutputStream mos = new MemoryOutputStream(fp, pool, memory, alu, offset);
  52             for(int i=0; i<vals.length; i++) {
  53                 int pct = (int)Math.ceil(100.0*((double)(i)/((double)(vals.length-1))));
  54                 String status = i + "/" + (vals.length-1) + "= " + pct + "%";
  55                 System.out.print("\rwrote to address: " + status +"           ");
  56                 mos.writeWord(vals[i]);
  57             }
  58             mos.close();
  59             pool.releaseShip(alu);
  60         } catch (IOException e) {
  61             throw new RuntimeException(e);
  62         }
  63     }
  64
  65     public static class MemoryOutputStream extends DockOutputStream {
  66
  67         private FleetProcess fp;
  68         private Ship memory;
  69         private Ship alu;
  70
  71         public MemoryOutputStream(FleetProcess fp,
  72                                   ShipPool pool,
  73                                   Ship memory,
  74                                   Ship alu,
  75                                   long offset) throws IOException {
  76
  77             super(fp, pool, memory.getDock("inDataWrite"), alu.getDock("out").getDataDestination());
  78             pool.assertAllocated(memory);
  79             pool.assertAllocated(alu);
  80
  81             this.fp = fp;
  82             this.memory = memory;
  83             this.alu = alu;
  84
  85             buildIt(fp, memory, alu, memory.getDock("inAddrWrite"), offset);
  86             CodeBag cb = new CodeBag(fp.getFleet());
  87             LoopFactory lf;
  88             lf = cb.loopFactory(memory.getDock("out"), 0);
  89             lf.abortLoopIfTorpedoPresent();
  90             lf.collectWord();
  91             cb.dispatch(fp);
  92         }
  93
  94         public void close() {
  95             super.close();
  96             fp.sendTorpedo(memory.getDock("inAddrWrite"));
  97             fp.sendTorpedo(memory.getDock("out"));
  98             fp.sendTorpedo(alu.getDock("in1"));
  99             fp.sendTorpedo(alu.getDock("in2"));
 100             fp.sendTorpedo(alu.getDock("inOp"));
 101             fp.sendTorpedo(alu.getDock("out"));
 102         }
 103
 104     }
 105
 106
 107     public static class MemoryInputStream extends DockInputStream {
 108
 109         private FleetProcess fp;
 110         private Ship memory;
 111         private Ship alu;
 112
 113         public MemoryInputStream(FleetProcess fp,
 114                                  ShipPool pool,
 115                                  Ship memory,
 116                                  Ship alu,
 117                                  long offset,
 118                                  int inflight) throws IOException {
 119             super(fp, pool, memory.getDock("out"), alu.getDock("out").getDataDestination(), inflight);
 120             pool.assertAllocated(memory);
 121             pool.assertAllocated(alu);
 122             this.fp = fp;
 123             this.memory = memory;
 124             this.alu = alu;
 125             buildIt(fp, memory, alu, memory.getDock("inAddrRead"), offset);
 126         }
 127
 128         public void close() {
 129             super.close();
 130             fp.sendTorpedo(memory.getDock("inAddrRead"));
 131             fp.sendTorpedo(memory.getDock("out"));
 132             fp.sendTorpedo(alu.getDock("in1"));
 133             fp.sendTorpedo(alu.getDock("in2"));
 134             fp.sendTorpedo(alu.getDock("inOp"));
 135             fp.sendTorpedo(alu.getDock("out"));
 136         }
 137     }
 138
 139     private static void buildIt(FleetProcess fp, Ship memory, Ship alu, Dock dest, long offset) {
 140
 141         CodeBag ctx = new CodeBag(fp.getFleet());
 142
 143         LoopFactory lf;
 144         // alu.in1: receive and deliver
 145         lf = ctx.loopFactory(alu.getDock("in1"), 0);
 146         lf.abortLoopIfTorpedoPresent();
 147         lf.recvWord();
 148         lf.deliver();
 149
 150         // alu.in2: receive tokens, deliver 1's
 151         lf = ctx.loopFactory(alu.getDock("in2"), 1);
 152         lf.literal(1);
 153         lf = lf.makeNext(0);
 154         lf.abortLoopIfTorpedoPresent();
 155         lf.recvToken();
 156         lf.deliver();
 157
 158         // alu.inOp: receive tokens, deliver ADD's
 159         lf = ctx.loopFactory(alu.getDock("inOp"), 1);
 160         lf.literal("ADD");
 161         lf = lf.makeNext(0);
 162         lf.abortLoopIfTorpedoPresent();
 163         lf.recvToken();
 164         lf.deliver();
 165
 166         // alu.out: for each token, provide a word of count-data
 167         lf = ctx.loopFactory(alu.getDock("out"), 1);
 168         lf.literal(offset);
 169         lf = lf.makeNext(0);
 170         lf.abortLoopIfTorpedoPresent();
 171         lf.recvToken();
 172         lf.sendWord(dest);
 173         lf.sendWord(alu.getDock("in1"));
 174         lf.sendToken(alu.getDock("in2"));
 175         lf.sendToken(alu.getDock("inOp"));
 176         lf.collectWord();
 177
 178         lf = ctx.loopFactory(dest, 0);
 179         lf.abortLoopIfTorpedoPresent();
 180         lf.recvWord();
 181         lf.deliver();
 182
 183         ctx.dispatch(fp);
 184     }
 185
 186     public static void putMemoryShipInDispatchMode(FleetProcess fp, Ship memoryShip) {
 187         CodeBag ctx = new CodeBag(fp.getFleet());
 188         LoopFactory lf;
 189
 190         lf = ctx.loopFactory(memoryShip.getDock("out"), 0);
 191         lf.abortLoopIfTorpedoPresent();
 192         lf.collectPacket();
 193         lf.sendPacket();
 194
 195         lf = ctx.loopFactory(memoryShip.getDock("inCBD"), 0);
 196         lf.abortLoopIfTorpedoPresent();
 197         lf.recvWord();
 198         lf.deliver();
 199
 200         ctx.dispatch(fp);
 201     }
 202
 203     public static void removeMemoryShipFromDispatchMode(FleetProcess fp, Ship memoryShip) {
 204         fp.sendToken(memoryShip.getDock("out").getInstructionDestination());
 205         fp.sendToken(memoryShip.getDock("inCBD").getInstructionDestination());
 206     }
 207
 208     public static void main(String[] s) throws Exception {
 209         Random random = new Random(System.currentTimeMillis());
 210         Fleet fleet = new Fpga();
 211         FleetProcess fp = fleet.run(new Instruction[0]);
 212         Ship memory = fleet.getShip("DDR2",0);
 213         //Ship memory = fleet.getShip("Dvi",0);
 214         //Ship memory = fleet.getShip("Memory",0);
 215
 216         //int size = (548 * 478) / 2;
 217         int size = 2048;
 218
 219         BitVector[] vals  = new BitVector[size];
 220         BitVector[] vals2 = new BitVector[size];
 221
 222         for(int i=0; i<vals.length; i++) {
 223             vals[i] = new BitVector(fleet.getWordWidth()).set(random.nextLong());
 224             for(int j=36; j<vals[i].length(); j++)
 225                 vals[i].set(j, false);
 226             vals[i].set(1, false);
 227         }
 228
 229         ShipPool pool = new ShipPool(fleet);
 230         pool.allocateShip(memory);
 231         writeMem(fp, pool, memory, 0, vals);
 232         readMem(fp, pool, memory, 0, vals2);
 233         System.out.println();
 234         int fails = 0;
 235         for(int i=0; i<vals.length; i++)
 236             if (!vals[i].equals(vals2[i])) {
 237                 System.out.println("disagreement!  on index " + i + "\n  expected="+vals[i]+"\n       got="+vals2[i]);
 238                 fails++;
 239             }
 240         System.out.println("done! ("+fails+" failures)");
 241         if (fails>0) System.exit(-1);
 242     }
 243 }