From 697e1d8bb2e177b38d3223d4560fc960f4278dd3 Mon Sep 17 00:00:00 2001 From: adam Date: Thu, 22 Feb 2007 16:32:34 +0100 Subject: [PATCH] move all defunct ships to defunct-ships directory --- defunct-ships/ArithmeticShip.java | 162 ++++++++++++++++++++++++++++++++++++ defunct-ships/Counter.java | 35 ++++++++ defunct-ships/DeMux.java | 34 ++++++++ defunct-ships/Dup.java | 29 +++++++ defunct-ships/Dup3.java | 31 +++++++ defunct-ships/DuplicatorShip.java | 36 ++++++++ defunct-ships/HomeworkCounter.java | 39 +++++++++ defunct-ships/MemoryReadShip.java | 47 +++++++++++ defunct-ships/MemoryWriteShip.java | 49 +++++++++++ defunct-ships/MultiplierShip.java | 39 +++++++++ defunct-ships/Mux.java | 28 +++++++ defunct-ships/ScatterShip.java | 44 ++++++++++ defunct-ships/Sort2.java | 28 +++++++ 13 files changed, 601 insertions(+) create mode 100644 defunct-ships/ArithmeticShip.java create mode 100644 defunct-ships/Counter.java create mode 100644 defunct-ships/DeMux.java create mode 100644 defunct-ships/Dup.java create mode 100644 defunct-ships/Dup3.java create mode 100644 defunct-ships/DuplicatorShip.java create mode 100644 defunct-ships/HomeworkCounter.java create mode 100644 defunct-ships/MemoryReadShip.java create mode 100644 defunct-ships/MemoryWriteShip.java create mode 100644 defunct-ships/MultiplierShip.java create mode 100644 defunct-ships/Mux.java create mode 100644 defunct-ships/ScatterShip.java create mode 100644 defunct-ships/Sort2.java diff --git a/defunct-ships/ArithmeticShip.java b/defunct-ships/ArithmeticShip.java new file mode 100644 index 0000000..3335c26 --- /dev/null +++ b/defunct-ships/ArithmeticShip.java @@ -0,0 +1,162 @@ +package edu.berkeley.fleet.interpreter.ships; +import edu.berkeley.fleet.interpreter.*; +import edu.berkeley.fleet.*; + +import java.util.*; +import java.io.*; + +/* +You should note the following: +I haven't implemented all the link-out policies. +You can give the SHIP a single cmd with up to four operations. For +example, "ADD ZERO 0 SUBTRACT SIGN 1 MAX MAX 0". These will be done +in left-to-right order. +You can use any link-out policy with any operation, though some don't +make much sense. +*/ + +/** + * @author Dominic Antonelli + */ +public class ArithmeticShip extends InterpreterShip { + + private int link; + + DataInbox A = new DataInbox(this, "A"); + DataInbox B = new DataInbox(this, "B"); + DataInbox cmd = new DataInbox(this, "cmd"); + DataOutbox out = new DataOutbox(this, "out"); + + public ArithmeticShip(Interpreter fleet, String name) { + super(fleet, name); + } + + public enum Operation { + // NOTE: NOP is not to be used, but rather simply prevents other ops from using opcode 0 + // This is so that we can detect the "end" of a command - when the command is all zero + NOP { int eval(int a, int b, int link) { System.out.println("ERROR: Arith_NOP\n"); return 0; } }, + ADD { int eval(int a, int b, int link) { return a + b + link; } }, + SUBTRACT { int eval(int a, int b, int link) { return a - b + link; } }, + COPY_A { int eval(int a, int b, int link) { return a + link; } }, + COPY_B { int eval(int a, int b, int link) { return b + link; } }, + SELECT { int eval(int a, int b, int link) { return ((link==1) ? b : a); } }, + NEGATE_A { int eval(int a, int b, int link) { return -(a+link); } }, + NEGATE_B { int eval(int a, int b, int link) { return -(b+link); } }, + ABS_A { int eval(int a, int b, int link) { a+=link; return (a<0 ? -a : a); } }, + ABS_B { int eval(int a, int b, int link) { b+=link; return (b<0 ? -b : b); } }, + MAX { int eval(int a, int b, int link) { return (a>b ? a : b) + link; } }, + MIN { int eval(int a, int b, int link) { return (a> 1) & 0x7)); + Operation op = Operation.convertInt((int)((command >> 4) & 0xf)); + int result = 0; + + int oldLink = link; + if (op == Operation.SELECT) { + link = link ^ linkInPolicy; // LinkInPolicy = 1 mean flip the selection for the SELECT op. + } else { + link = link & linkInPolicy; // If linkInPolicy is zero, unset the link bit for the upcoming computation. + // NOTE: The final value of link will be computed after eval. + } + + result = op.eval(inA, inB, link); + + switch (linkOutPolicy) { + case LINK_IN: + link = oldLink; + break; + case ZERO: + link = (result == 0) ? 1 : 0; +// link = 0; + break; + case SIGN: + link = (result >> 31) & 0x1; + break; + case MAX: + if (inA > inB) link = 1; else link = 0; + break; + case MIN: + if (inA < inB) link = 1; else link = 0; + break; + case CARRY: + case OLD_SIGN: + case OVERFLOW: + System.out.println("ERROR: non-implemented linkOutPolicy selected"); + break; + default: + System.out.println("ERROR: Unknown linkOutPolicy selected"); + break; + }; + out.addDataFromShip(result); + + savedCommand = command >> 8; + +// System.out.println("Link is now " + link); + } + + public int resolveShipSpecificConstant(String shipSpecificData) { + String[] data = shipSpecificData.split("\\s"); + int result = 0; + + if ((data.length % 3) != 0) { + System.out.println("ERROR: ArithmeticShip received invalid ShipSpecificConstant"); + } + for (int i = data.length - 1; i >= 2; i-=3) { + result <<= 8; + if (data[i].equals("1")) { + result |= 1; + } + for (LinkOutPolicy policy : LinkOutPolicy.values()) { + if (data[i-1].equals(policy.toString())) { + result |= (policy.ordinal() << 1); + } + } + for (Operation op : Operation.values()) { + if (data[i-2].equals(op.toString())) { + result |= (op.ordinal() << 4); + } + } + } + return result; + } +} diff --git a/defunct-ships/Counter.java b/defunct-ships/Counter.java new file mode 100644 index 0000000..921a2b3 --- /dev/null +++ b/defunct-ships/Counter.java @@ -0,0 +1,35 @@ +package edu.berkeley.fleet.interpreter.ships; +import edu.berkeley.fleet.interpreter.*; +import edu.berkeley.fleet.*; + +import java.util.*; +import java.io.*; + +public class Counter extends InterpreterShip { + + private int count = 0; + + DataInbox load = new DataInbox(this, "load"); + TokenInbox decrement = new TokenInbox(this, "decrement"); + TokenOutbox zero = new TokenOutbox(this, "zero"); + + public Counter(Interpreter fleet, String name) { + super(fleet, name); + } + + public String getBalsaName() { return "counter"; } + public void service() { + if (!zero.readyForTokenFromShip()) return; + if (count==0 && load.dataReadyForShip()) { + count = load.removeDataForShip(); + return; + } + if (count>0 && decrement.tokenReadyForShip()) { + decrement.removeTokenForShip(); + count--; + if (count==0) + zero.addTokenFromShip(); + } + } + +} diff --git a/defunct-ships/DeMux.java b/defunct-ships/DeMux.java new file mode 100644 index 0000000..3006dd9 --- /dev/null +++ b/defunct-ships/DeMux.java @@ -0,0 +1,34 @@ +package edu.berkeley.fleet.interpreter.ships; +import edu.berkeley.fleet.interpreter.*; +import edu.berkeley.fleet.*; + +import java.util.*; +import java.io.*; + +public class DeMux extends InterpreterShip { + + DataInbox inp = new DataInbox(this, "in"); + DataInbox selp = new DataInbox(this, "select"); + DataOutbox truep = new DataOutbox(this, "true"); + DataOutbox falsep = new DataOutbox(this, "false"); + + public String getBalsaName() { return "demux"; } + + public DeMux (Interpreter fleet, String name) { + super(fleet, name); + } + + public void service() { + if (inp.dataReadyForShip() && selp.dataReadyForShip() && + truep.readyForDataFromShip() && falsep.readyForDataFromShip()) { + int in = inp.removeDataForShip(); + int sel = selp.removeDataForShip(); + if (sel==0) + falsep.addDataFromShip(in); + else + truep.addDataFromShip(in); + } + } + +} + diff --git a/defunct-ships/Dup.java b/defunct-ships/Dup.java new file mode 100644 index 0000000..e78273a --- /dev/null +++ b/defunct-ships/Dup.java @@ -0,0 +1,29 @@ +package edu.berkeley.fleet.interpreter.ships; +import edu.berkeley.fleet.interpreter.*; +import edu.berkeley.fleet.*; + +import java.util.*; +import java.io.*; + +public class Dup extends InterpreterShip { + + DataInbox in = new DataInbox(this, "in"); + DataOutbox a = new DataOutbox(this, "a"); + DataOutbox b = new DataOutbox(this, "b"); + + public String getBalsaName() { return "dup"; } + + public Dup (Interpreter fleet, String name) { + super(fleet, name); + } + + public void service() { + if (in.dataReadyForShip() && a.readyForDataFromShip() && b.readyForDataFromShip()) { + int data = in.removeDataForShip(); + a.addDataFromShip(data); + b.addDataFromShip(data); + } + } + +} + diff --git a/defunct-ships/Dup3.java b/defunct-ships/Dup3.java new file mode 100644 index 0000000..1820970 --- /dev/null +++ b/defunct-ships/Dup3.java @@ -0,0 +1,31 @@ +package edu.berkeley.fleet.interpreter.ships; +import edu.berkeley.fleet.interpreter.*; +import edu.berkeley.fleet.*; + +import java.util.*; +import java.io.*; + +public class Dup3 extends InterpreterShip { + + DataInbox in = new DataInbox(this, "in"); + DataOutbox a = new DataOutbox(this, "a"); + DataOutbox b = new DataOutbox(this, "b"); + DataOutbox c = new DataOutbox(this, "c"); + + public String getBalsaName() { return "dup3"; } + + public Dup3 (Interpreter fleet, String name) { + super(fleet, name); + } + + public void service() { + if (in.dataReadyForShip() && a.readyForDataFromShip() && b.readyForDataFromShip() && c.readyForDataFromShip()) { + int data = in.removeDataForShip(); + a.addDataFromShip(data); + b.addDataFromShip(data); + c.addDataFromShip(data); + } + } + +} + diff --git a/defunct-ships/DuplicatorShip.java b/defunct-ships/DuplicatorShip.java new file mode 100644 index 0000000..70d3e5e --- /dev/null +++ b/defunct-ships/DuplicatorShip.java @@ -0,0 +1,36 @@ +package edu.berkeley.fleet.interpreter.ships; +import edu.berkeley.fleet.interpreter.*; +import edu.berkeley.fleet.*; + +import java.util.*; +import java.io.*; + +/** + * @author Dominic Antonelli + */ +public class DuplicatorShip extends InterpreterShip { + + DataInbox in = new DataInbox(this, "in"); + DataOutbox out0 = new DataOutbox(this, "out0"); + DataOutbox out1 = new DataOutbox(this, "out1"); + DataOutbox out2 = new DataOutbox(this, "out2"); + DataOutbox out3 = new DataOutbox(this, "out3"); + + public DuplicatorShip (Interpreter fleet, String name) { + super(fleet, name); + } + + public void service() { + if (in.dataReadyForShip() && out0.readyForDataFromShip() && + out1.readyForDataFromShip() && out2.readyForDataFromShip() && + out3.readyForDataFromShip()) { + int data = in.removeDataForShip(); + out0.addDataFromShip(data); + out1.addDataFromShip(data); + out2.addDataFromShip(data); + out3.addDataFromShip(data); + } + } + +} + diff --git a/defunct-ships/HomeworkCounter.java b/defunct-ships/HomeworkCounter.java new file mode 100644 index 0000000..0aa8be8 --- /dev/null +++ b/defunct-ships/HomeworkCounter.java @@ -0,0 +1,39 @@ +package edu.berkeley.fleet.interpreter.ships; +import edu.berkeley.fleet.interpreter.*; +import edu.berkeley.fleet.*; + +import java.util.*; +import java.io.*; + +public class HomeworkCounter extends InterpreterShip { + + private int count = -1; + + TokenOutbox zero = new TokenOutbox(this, "zero"); + TokenOutbox positive = new TokenOutbox(this, "positive"); + DataInbox load = new DataInbox(this, "load"); + TokenInbox ask = new TokenInbox(this, "ask"); + + public HomeworkCounter(Interpreter fleet, String name) { + super(fleet, name); + } + + public void service() { + if (!zero.readyForTokenFromShip()) return; + if (!positive.readyForTokenFromShip()) return; + if (load.dataReadyForShip()) { + count = load.removeDataForShip(); + return; + } + if (ask.tokenReadyForShip()) { + ask.removeTokenForShip(); + if (count > 0) { + count--; + positive.addTokenFromShip(); + } else if (count<=0) { + zero.addTokenFromShip(); + } + } + } + +} diff --git a/defunct-ships/MemoryReadShip.java b/defunct-ships/MemoryReadShip.java new file mode 100644 index 0000000..ffe4511 --- /dev/null +++ b/defunct-ships/MemoryReadShip.java @@ -0,0 +1,47 @@ +package edu.berkeley.fleet.interpreter.ships; +import edu.berkeley.fleet.interpreter.*; + +import edu.berkeley.fleet.*; +import java.util.*; +import java.io.*; + +public class MemoryReadShip extends InterpreterShip { + + boolean _loaded = false; + int _count = 0; + int _stride = 0; + int _addr = 0; + + DataInbox addr = new DataInbox(this, "addr"); + DataInbox stride = new DataInbox(this, "stride"); + DataInbox count = new DataInbox(this, "count"); + DataOutbox data = new DataOutbox(this, "data"); + TokenOutbox done = new TokenOutbox(this, "done"); + + public MemoryReadShip(Interpreter fleet, String name) { + super(fleet, name); + } + + public void service() { + if (_count > 0) { + if (!data.readyForDataFromShip()) return; + data.addDataFromShip(_addr>=getInterpreter().mem.length ? 0 : getInterpreter().mem[_addr]); + _count--; + _addr += _stride; + if (_count==0) + done.addTokenFromShip(); + } else { + if (count.dataReadyForShip() && + addr.dataReadyForShip() && + stride.dataReadyForShip() && + done.readyForTokenFromShip() && + data.readyForDataFromShip()) { + + _count = count.removeDataForShip(); + _addr = addr.removeDataForShip(); + _stride = stride.removeDataForShip(); + } + } + } + +} diff --git a/defunct-ships/MemoryWriteShip.java b/defunct-ships/MemoryWriteShip.java new file mode 100644 index 0000000..7e33936 --- /dev/null +++ b/defunct-ships/MemoryWriteShip.java @@ -0,0 +1,49 @@ +package edu.berkeley.fleet.interpreter.ships; +import edu.berkeley.fleet.interpreter.*; + +import edu.berkeley.fleet.*; +import java.util.*; +import java.io.*; + +/** + * @author Thomas Kho + */ +public class MemoryWriteShip extends InterpreterShip { + + int _count = 0; + int _stride = 0; + int _addr = 0; + + DataInbox addr = new DataInbox(this, "addr"); + DataInbox stride = new DataInbox(this, "stride"); + DataInbox count = new DataInbox(this, "count"); + DataInbox data = new DataInbox(this, "data"); + TokenOutbox done = new TokenOutbox(this, "done"); + + public MemoryWriteShip(Interpreter fleet, String name) { + super(fleet, name); + } + + public void service() { + if (_count > 0) { + if (!data.dataReadyForShip()) return; + //getInterpreter().writeMem(_addr, data.removeDataForShip()); + _count--; + _addr += _stride; + if (_count==0) + done.addTokenFromShip(); + } else { + if (count.dataReadyForShip() && + addr.dataReadyForShip() && + stride.dataReadyForShip() && + done.readyForTokenFromShip() && + data.dataReadyForShip()) { + + _count = count.removeDataForShip(); + _addr = addr.removeDataForShip(); + _stride = stride.removeDataForShip(); + } + } + } + +} diff --git a/defunct-ships/MultiplierShip.java b/defunct-ships/MultiplierShip.java new file mode 100644 index 0000000..3efd5da --- /dev/null +++ b/defunct-ships/MultiplierShip.java @@ -0,0 +1,39 @@ +package edu.berkeley.fleet.interpreter.ships; +import edu.berkeley.fleet.interpreter.*; +import edu.berkeley.fleet.*; + +import java.util.*; +import java.io.*; + +/** + * @author Dominic Antonelli + */ +public class MultiplierShip extends InterpreterShip { + + private int link; + + DataInbox A = new DataInbox(this, "A"); + DataInbox B = new DataInbox(this, "B"); + DataOutbox out0 = new DataOutbox(this, "out0"); + DataOutbox out1 = new DataOutbox(this, "out1"); + + public MultiplierShip(Interpreter fleet, String name) { + super(fleet, name); + } + + public void service() { + if (!out0.readyForDataFromShip()) return; + if (!out1.readyForDataFromShip()) return; + if (!A.dataReadyForShip()) return; + if (!B.dataReadyForShip()) return; + + long inA = (long)A.removeDataForShip(); + long inB = (long)B.removeDataForShip(); + long result = inA * inB; + int result0 = (int)(result >> 32); + int result1 = (int)(result & 0xffffffff); + + out0.addDataFromShip(result0); + out1.addDataFromShip(result1); + } +} diff --git a/defunct-ships/Mux.java b/defunct-ships/Mux.java new file mode 100644 index 0000000..86a2822 --- /dev/null +++ b/defunct-ships/Mux.java @@ -0,0 +1,28 @@ +package edu.berkeley.fleet.interpreter.ships; +import edu.berkeley.fleet.interpreter.*; +import edu.berkeley.fleet.*; + +import java.util.*; +import java.io.*; + +public class Mux extends InterpreterShip { + + DataInbox ap = new DataInbox(this, "a"); + DataInbox bp = new DataInbox(this, "b"); + DataInbox choicep = new DataInbox(this, "select"); + DataOutbox out = new DataOutbox(this, "out"); + + public Mux(Interpreter fleet, String name) { super(fleet, name); } + + public String getBalsaName() { return "mux"; } + + public void service() { + if (ap.dataReadyForShip() && bp.dataReadyForShip() && choicep.dataReadyForShip()) { + int a = ap.removeDataForShip(); + int b = bp.removeDataForShip(); + int choice = choicep.removeDataForShip(); + out.addDataFromShip(choice==0 ? a : b); + } + } + +} diff --git a/defunct-ships/ScatterShip.java b/defunct-ships/ScatterShip.java new file mode 100644 index 0000000..4f6b892 --- /dev/null +++ b/defunct-ships/ScatterShip.java @@ -0,0 +1,44 @@ +package edu.berkeley.fleet.interpreter.ships; +import edu.berkeley.fleet.interpreter.*; +import edu.berkeley.fleet.*; + +import java.util.*; +import java.io.*; + +/** + * @author Dominic Antonelli + */ +public class ScatterShip extends InterpreterShip { + + DataInbox in = new DataInbox(this, "in"); + Vector out = new Vector(); + + private int size = 2; + private int state = 0; + + public ScatterShip(Interpreter fleet, String name) { + super(fleet, name); + init(); + } + + private boolean initialized = false; + private void init() { + for (int i = 0; i < size; i++) { + out.add(new DataOutbox(this, "out" + i)); + } + initialized = true; + } + + public void service() { + if (!initialized) init(); + if (in.dataReadyForShip() && out.get(state).readyForDataFromShip()) { + out.get(state).addDataFromShip(in.removeDataForShip()); + state = (state + 1) % size; + } + } + + public int resolveShipSpecificConstant(String shipSpecificData) { + return 0; + } + +} diff --git a/defunct-ships/Sort2.java b/defunct-ships/Sort2.java new file mode 100644 index 0000000..90cb3e4 --- /dev/null +++ b/defunct-ships/Sort2.java @@ -0,0 +1,28 @@ +package edu.berkeley.fleet.interpreter.ships; +import edu.berkeley.fleet.interpreter.*; +import edu.berkeley.fleet.*; + +import java.util.*; +import java.io.*; + +public class Sort2 extends InterpreterShip { + + DataInbox ap = new DataInbox(this, "a"); + DataInbox bp = new DataInbox(this, "b"); + DataOutbox min = new DataOutbox(this, "min"); + DataOutbox max = new DataOutbox(this, "max"); + + public Sort2(Interpreter fleet, String name) { super(fleet, name); } + + public String getBalsaName() { return "sort2"; } + + public void service() { + if (ap.dataReadyForShip() && bp.dataReadyForShip()) { + int a = ap.removeDataForShip(); + int b = bp.removeDataForShip(); + max.addDataFromShip(Math.max(a,b)); + min.addDataFromShip(Math.min(a,b)); + } + } + +} -- 1.7.10.4