diff options
Diffstat (limited to 'sources/core/VSProcess.java')
| -rw-r--r-- | sources/core/VSProcess.java | 442 |
1 files changed, 442 insertions, 0 deletions
diff --git a/sources/core/VSProcess.java b/sources/core/VSProcess.java new file mode 100644 index 0000000..bb65959 --- /dev/null +++ b/sources/core/VSProcess.java @@ -0,0 +1,442 @@ +package core; + +import java.awt.*; +import java.util.*; + +import prefs.*; +import protocols.*; +import simulator.*; +import utils.*; +import events.*; + +public final class VSProcess extends VSPrefs { + private VSTask randomCrashTask; + private Color currentColor; + private Color tmpColor; + private Color crashedColor;; + private VSLogging logging; + private VSPrefs prefs; + private VSRandom random; + private VSSimulationPanel simulationPanel; + private boolean hasStarted; + private boolean isHighlighted; + private boolean isPaused; + private boolean timeModified; + private double clockOffset; + private float clockVariance; + private int num; + private int processID; + private long globalTime; + private long localTime; + private static int processCounter; + private boolean isCrashed; + private long lamportTime; + private ArrayList<VSLamport> lamportTimestamps; + private ArrayList<Integer> vectorTimestamps; + + /* This array contains all Integer prefs of the process which should show + * up in the prefs menu! All keys which dont start with "sim." only show + * up in the extended prefs menu! + */ + private static final String DEFAULT_INTEGER_VALUE_KEYS[] = { + "sim.process.prob.crash", + "sim.message.prob.outage", + }; + + /* This array contains all Long prefs of the process which should show + * up in the prefs menu! All keys which dont start with "sim." only show + * up in the extended prefs menu! + */ + private static final String DEFAULT_LONG_VALUE_KEYS[] = { + "sim.message.sendingtime.min", + "sim.message.sendingtime.max", + }; + + /* This array contains all Float prefs of the process which should show + * up in the prefs menu! All keys which dont start with "sim." only show + * up in the extended prefs menu! + */ + private static final String DEFAULT_FLOAT_VALUE_KEYS[] = { + "sim.process.clock.variance", + }; + + /* This array contains all Color prefs of the process which should show + * up in the prefs menu! All keys which dont start with "sim." only show + * up in the extended prefs menu! + */ + private static final String DEFAULT_COLOR_VALUE_KEYS[] = { + "process.default", + "process.running", + "process.stopped", + "process.highlight", + "process.crashed", + }; + + /* This array contains all String prefs of the process which should show + * up in the prefs menu! All keys which dont start with "sim." only show + * up in the extended prefs menu! + */ + private static final String DEFAULT_STRING_VALUE_KEYS[] = { + }; + + public VSProcess(VSPrefs prefs, VSSimulationPanel simulationPanel, VSLogging logging, int num) { + this.prefs = prefs; + this.simulationPanel = simulationPanel; + this.logging = logging; + this.num = num; + this.random = new VSRandom(processID+processCounter); + this.lamportTimestamps = new ArrayList<VSLamport>(); + this.vectorTimestamps = new ArrayList<Integer>(); + setLamportTime(0); + + setObject("protocols", new ArrayList<VSProtocol>()); + + isPaused = true; + processID = ++processCounter; + + /* Create the super.VSPrefs with it's default prefs */ + fillWithDefaults(); + + /* Make local copys in order to have more performance */ + clockVariance = getFloat("sim.process.clock.variance"); + currentColor = getColor("process.default"); + + /* Make additional process settings editable through GUI */ + initInteger("sim.process.id", processID, + prefs.getString("lang.process.id"), 1, processID + 10); + setLongIfUnset("sim.process.localtime", localTime, prefs.getString("lang.process.time.local")); + + crashedColor = getColor("process.crashed"); + createRandomCrashTask(); + } + + /** + * Called from the VSProcessEditor, after finishing editing! + */ + public synchronized void updateFromVSPrefs() { + setClockVariance(getFloat("sim.process.clock.variance")); + setProcessID(getInteger("sim.process.id")); + setLocalTime(getLong("sim.process.localtime")); + crashedColor = getColor("process.crashed"); + simulationPanel.repaint(); + createRandomCrashTask(); + } + + /** + * Called from the VSProcessEditor, before starting editing! + */ + public synchronized void updatePrefs() { + setFloat("sim.process.clock.variance", getClockVariance()); + setInteger("sim.process.id", getProcessID()); + setLong("sim.process.localtime", getTime()); + } + + public synchronized void syncTime(final long globalTime) { + final long currentGlobalTimestep = globalTime - this.globalTime; + this.globalTime = globalTime; + + if (!isCrashed) { + localTime += currentGlobalTimestep; + clockOffset += currentGlobalTimestep * (double) clockVariance; + } + + while (clockOffset >= 1) { + clockOffset -= 1; + ++localTime; + } + + while (clockOffset <= -1) { + clockOffset += 1; + --localTime; + } + + if (localTime < 0) + localTime = 0; + } + + private void setCurrentColor(Color newColor) { + if (isHighlighted) + tmpColor = newColor; + else + currentColor = newColor; + } + + public synchronized void highlightOn() { + tmpColor = currentColor; + currentColor = getColor("process.highlight"); + isHighlighted = true; + } + + public synchronized void highlightOff() { + currentColor = tmpColor; + isHighlighted = false; + } + + public synchronized void reset() { + isPaused = true; + isCrashed = false; + localTime = 0; + globalTime = 0; + clockOffset = 0; + lamportTime = 0; + lamportTimestamps.clear(); + vectorTimestamps.clear(); + + if (objectExists("protocols.registered")) { + Object protocolsObj = getObject("protocols.registered"); + if (protocolsObj instanceof Vector) { + Vector<VSProtocol> protocols = (Vector<VSProtocol>) protocolsObj; + for (VSProtocol protocol : protocols) + protocol.reset(); + } + } + + setCurrentColor(getColor("process.default")); + createRandomCrashTask(); + } + + private void createRandomCrashTask() { + if (!isCrashed) { + VSTaskManager taskManager = simulationPanel.getTaskManager(); + long crashTime = getARandomCrashTime(); + + if (randomCrashTask != null) + taskManager.removeTask(randomCrashTask); + + if (crashTime >= 0 && crashTime >= getGlobalTime()) { + randomCrashTask = new VSTask(crashTime, this, new ProcessCrashEvent()); + taskManager.addTask(randomCrashTask); + //System.out.println("DEBUG " + processID + " crashes at " + crashTime); + + } else { + randomCrashTask = null; + } + } + } + + public synchronized void addClockOffset(long add) { + this.clockOffset += add; + } + + public synchronized void play() { + isPaused = false; + setCurrentColor(getColor("process.running")); + } + + public synchronized void pause() { + isPaused = true; + setCurrentColor(getColor("process.stopped")); + } + + public synchronized void finish() { + isPaused = true; + setCurrentColor(getColor("process.default")); + } + + public synchronized int getProcessID() { + return processID; + } + + public synchronized void setProcessID(int processID) { + this.processID = processID; + } + + public synchronized Color getColor() { + return currentColor; + } + + public synchronized void setLocalTime(final long localTime) { + if (localTime >= 0) + this.localTime = localTime; + else + this.localTime = 0; + } + + public synchronized long getTime() { + return localTime; + } + + public synchronized void setTime(final long time) { + if (time >= 0) + this.localTime = time; + else + this.localTime = 0; + + this.timeModified = true; + } + + public synchronized boolean isCrashed() { + return isCrashed; + } + + public synchronized void isCrashed(boolean isCrashed) { + this.isCrashed = isCrashed; + } + + public synchronized Color getCrashedColor() { + return crashedColor; + } + + public int getNum() { + return num; + } + + public synchronized boolean timeModified() { + return timeModified; + } + + public synchronized void timeModified(boolean timeModified) { + this.timeModified = timeModified; + } + + public synchronized long getGlobalTime() { + return globalTime; + } + + public synchronized void setGlobalTime(final long globalTime) { + this.globalTime = globalTime >= 0 ? globalTime : 0; + } + + public synchronized float getClockVariance() { + return clockVariance; + } + + public synchronized void setClockVariance(float clockVariance) { + /* If negative, only allow < 1 prefs */ + if (clockVariance < 0) { + int part = (int) -clockVariance; + if (part > 0) { + this.clockVariance = 0; + return; + } + } + + this.clockVariance = clockVariance; + } + + public synchronized long getDurationTime() { + final long maxDurationTime = getLong("sim.message.sendingtime.max"); + final long minDurationTime = getLong("sim.message.sendingtime.min"); + + if (maxDurationTime <= minDurationTime) + return minDurationTime; + + final int diff = (int) (maxDurationTime - minDurationTime); + + /* Integer overflow */ + if (diff <= 0) + return minDurationTime; + + return minDurationTime + random.nextInt(diff+1); + } + + public synchronized long getARandomMessageOutageTime(final long durationTime) { + /* Check if the message will have an outage or not */ + if (random.nextInt(100) <= getInteger("sim.message.prob.outage")) { + /* Calculate the random outage time! */ + final long outageTime = globalTime + random.nextLong(durationTime+1) % simulationPanel.getUntilTime(); + return outageTime; + } + + /* No outage */ + return -1; + } + + private long getARandomCrashTime() { + /* Check if the process will crash or not */ + if (random.nextInt(100) <= getInteger("sim.process.prob.crash")) { + /* Calculate the random crash time! */ + final long crashTime = random.nextLong(simulationPanel.getUntilTime()+1) % simulationPanel.getUntilTime(); + return crashTime; + } + + /* No crash */ + return -1; + } + + public synchronized VSTask getCrashTask() { + return randomCrashTask; + } + + public synchronized boolean isPaused() { + return isPaused; + } + + public synchronized long getLamportTime() { + return lamportTime; + } + + public synchronized void setLamportTime(long lamportTime) { + this.lamportTime = lamportTime; + lamportTimestamps.add(new VSLamport(globalTime, lamportTime)); + } + + public synchronized VSLamport[] getLamportArray() { + final int size = lamportTimestamps.size(); + final VSLamport[] arr = new VSLamport[size]; + + for (int i = 0; i < size; ++i) + arr[i] = lamportTimestamps.get(i); + + return arr; + } + + public synchronized int[] getVectorTime() { + final int size = vectorTimestamps.size(); + final int[] arr = new int[size]; + + for (int i = 0; i < size; ++i) + arr[i] = vectorTimestamps.get(i); + + return arr; + } + + + public void sendMessage(VSMessage message) { + logg(prefs.getString("lang.message.sent") + "; " + + prefs.getString("lang.protocol") + ": " + message.getProtocolName() + "; " + + prefs.getString("lang.message") + " " + message.toStringFull()); + simulationPanel.sendMessage(message); + } + + public void logg(String message) { + logging.logg(toString() + "; " + message, globalTime); + } + + public void fillWithDefaults() { + prefs.copyIntegers(this, DEFAULT_INTEGER_VALUE_KEYS); + prefs.copyLongs(this, DEFAULT_LONG_VALUE_KEYS); + prefs.copyFloats(this, DEFAULT_FLOAT_VALUE_KEYS); + prefs.copyColors(this, DEFAULT_COLOR_VALUE_KEYS); + prefs.copyStrings(this, DEFAULT_STRING_VALUE_KEYS); + } + + public String toString() { + return + prefs.getString("lang.process.id") + ": " + + getProcessID() + "; " + + prefs.getString("lang.process.time.local") + ": " + + VSTools.getTimeString(getTime()) + + "; Lamport: " + lamportTime; + } + + public String toStringFull() { + return toString() + "; paused: " + isPaused + "; crashed: " + isCrashed + "; crashTask: " + randomCrashTask; + } + + public boolean equals(VSProcess process) { + return process.getNum() == getNum(); + } + + public VSSimulationPanel getSimulationPanel() { + return simulationPanel; + } + + public VSPrefs getPrefs() { + return prefs; + } + + public static void resetProcessCounter() { + processCounter = 0; + } +} |