From afed274c10a93957f82a009824cafe8d83aa68a8 Mon Sep 17 00:00:00 2001 From: Paul Buetow Date: Fri, 15 Aug 2008 04:09:42 +0000 Subject: new branches --- VS-Sim-Sources/sources/core/VSAbstractProcess.java | 753 ++++++++ VS-Sim-Sources/sources/core/VSInternalProcess.java | 459 +++++ VS-Sim-Sources/sources/core/VSMessage.java | 208 +++ VS-Sim-Sources/sources/core/VSMessageStub.java | 61 + VS-Sim-Sources/sources/core/VSTask.java | 522 ++++++ VS-Sim-Sources/sources/core/VSTaskManager.java | 584 +++++++ .../sources/core/time/VSLamportTime.java | 76 + VS-Sim-Sources/sources/core/time/VSTime.java | 45 + VS-Sim-Sources/sources/core/time/VSVectorTime.java | 119 ++ VS-Sim-Sources/sources/events/VSAbstractEvent.java | 256 +++ VS-Sim-Sources/sources/events/VSCopyableEvent.java | 40 + .../sources/events/VSRegisteredEvents.java | 378 ++++ .../implementations/VSProcessCrashEvent.java | 60 + .../implementations/VSProcessRecoverEvent.java | 61 + .../events/internal/VSAbstractInternalEvent.java | 76 + .../events/internal/VSMessageReceiveEvent.java | 112 ++ .../sources/events/internal/VSProtocolEvent.java | 200 +++ .../events/internal/VSProtocolScheduleEvent.java | 151 ++ .../exceptions/VSEventNotCopyableException.java | 39 + .../exceptions/VSNegativeNumberException.java | 35 + .../exceptions/VSParseIntegerVectorException.java | 36 + VS-Sim-Sources/sources/prefs/VSDefaultPrefs.java | 276 +++ VS-Sim-Sources/sources/prefs/VSPrefs.java | 1190 +++++++++++++ .../sources/prefs/VSPrefsRestriction.java | 157 ++ .../sources/prefs/VSSerializablePrefs.java | 60 + .../sources/prefs/editors/.VSEditorFrame.java.swp | Bin 0 -> 16384 bytes .../prefs/editors/VSAbstractBetterEditor.java | 140 ++ .../sources/prefs/editors/VSAbstractEditor.java | 1047 +++++++++++ .../sources/prefs/editors/VSColorChooser.java | 78 + .../sources/prefs/editors/VSEditorFrame.java | 117 ++ .../sources/prefs/editors/VSEditorTable.java | 314 ++++ .../sources/prefs/editors/VSProcessEditor.java | 131 ++ .../sources/prefs/editors/VSSimulatorEditor.java | 143 ++ .../sources/protocols/VSAbstractProtocol.java | 468 +++++ .../sources/protocols/implementations/README | 10 + .../implementations/VSBasicMulticastProtocol.java | 112 ++ .../implementations/VSBerkelyTimeProtocol.java | 229 +++ .../implementations/VSBroadcastProtocol.java | 129 ++ .../protocols/implementations/VSDummyProtocol.java | 124 ++ .../VSExternalTimeSyncProtocol.java | 145 ++ .../VSInternalTimeSyncProtocol.java | 149 ++ .../implementations/VSOnePhaseCommitProtocol.java | 174 ++ .../implementations/VSPingPongProtocol.java | 136 ++ .../VSReliableMulticastProtocol.java | 168 ++ .../implementations/VSTwoPhaseCommitProtocol.java | 224 +++ .../sources/serialize/VSNotSerializable.java | 34 + .../sources/serialize/VSSerializable.java | 55 + VS-Sim-Sources/sources/serialize/VSSerialize.java | 299 ++++ VS-Sim-Sources/sources/simulator/VSCreateTask.java | 203 +++ VS-Sim-Sources/sources/simulator/VSLogging.java | 225 +++ VS-Sim-Sources/sources/simulator/VSMain.java | 91 + .../sources/simulator/VSMenuItemStates.java | 135 ++ VS-Sim-Sources/sources/simulator/VSSimulator.java | 1547 +++++++++++++++++ .../sources/simulator/VSSimulatorFrame.java | 632 +++++++ .../simulator/VSSimulatorVisualization.java | 1821 ++++++++++++++++++++ VS-Sim-Sources/sources/utils/VS3Tupel.java | 84 + VS-Sim-Sources/sources/utils/VSAboutFrame.java | 106 ++ VS-Sim-Sources/sources/utils/VSClassLoader.java | 55 + VS-Sim-Sources/sources/utils/VSFrame.java | 135 ++ VS-Sim-Sources/sources/utils/VSInfoArea.java | 69 + VS-Sim-Sources/sources/utils/VSPriorityQueue.java | 55 + VS-Sim-Sources/sources/utils/VSRandom.java | 63 + VS-Sim-Sources/sources/utils/VSTools.java | 119 ++ 63 files changed, 15720 insertions(+) create mode 100644 VS-Sim-Sources/sources/core/VSAbstractProcess.java create mode 100644 VS-Sim-Sources/sources/core/VSInternalProcess.java create mode 100644 VS-Sim-Sources/sources/core/VSMessage.java create mode 100644 VS-Sim-Sources/sources/core/VSMessageStub.java create mode 100644 VS-Sim-Sources/sources/core/VSTask.java create mode 100644 VS-Sim-Sources/sources/core/VSTaskManager.java create mode 100644 VS-Sim-Sources/sources/core/time/VSLamportTime.java create mode 100644 VS-Sim-Sources/sources/core/time/VSTime.java create mode 100644 VS-Sim-Sources/sources/core/time/VSVectorTime.java create mode 100644 VS-Sim-Sources/sources/events/VSAbstractEvent.java create mode 100644 VS-Sim-Sources/sources/events/VSCopyableEvent.java create mode 100644 VS-Sim-Sources/sources/events/VSRegisteredEvents.java create mode 100644 VS-Sim-Sources/sources/events/implementations/VSProcessCrashEvent.java create mode 100644 VS-Sim-Sources/sources/events/implementations/VSProcessRecoverEvent.java create mode 100644 VS-Sim-Sources/sources/events/internal/VSAbstractInternalEvent.java create mode 100644 VS-Sim-Sources/sources/events/internal/VSMessageReceiveEvent.java create mode 100644 VS-Sim-Sources/sources/events/internal/VSProtocolEvent.java create mode 100644 VS-Sim-Sources/sources/events/internal/VSProtocolScheduleEvent.java create mode 100644 VS-Sim-Sources/sources/exceptions/VSEventNotCopyableException.java create mode 100644 VS-Sim-Sources/sources/exceptions/VSNegativeNumberException.java create mode 100644 VS-Sim-Sources/sources/exceptions/VSParseIntegerVectorException.java create mode 100644 VS-Sim-Sources/sources/prefs/VSDefaultPrefs.java create mode 100644 VS-Sim-Sources/sources/prefs/VSPrefs.java create mode 100644 VS-Sim-Sources/sources/prefs/VSPrefsRestriction.java create mode 100644 VS-Sim-Sources/sources/prefs/VSSerializablePrefs.java create mode 100644 VS-Sim-Sources/sources/prefs/editors/.VSEditorFrame.java.swp create mode 100644 VS-Sim-Sources/sources/prefs/editors/VSAbstractBetterEditor.java create mode 100644 VS-Sim-Sources/sources/prefs/editors/VSAbstractEditor.java create mode 100644 VS-Sim-Sources/sources/prefs/editors/VSColorChooser.java create mode 100644 VS-Sim-Sources/sources/prefs/editors/VSEditorFrame.java create mode 100644 VS-Sim-Sources/sources/prefs/editors/VSEditorTable.java create mode 100644 VS-Sim-Sources/sources/prefs/editors/VSProcessEditor.java create mode 100644 VS-Sim-Sources/sources/prefs/editors/VSSimulatorEditor.java create mode 100644 VS-Sim-Sources/sources/protocols/VSAbstractProtocol.java create mode 100644 VS-Sim-Sources/sources/protocols/implementations/README create mode 100644 VS-Sim-Sources/sources/protocols/implementations/VSBasicMulticastProtocol.java create mode 100644 VS-Sim-Sources/sources/protocols/implementations/VSBerkelyTimeProtocol.java create mode 100644 VS-Sim-Sources/sources/protocols/implementations/VSBroadcastProtocol.java create mode 100644 VS-Sim-Sources/sources/protocols/implementations/VSDummyProtocol.java create mode 100644 VS-Sim-Sources/sources/protocols/implementations/VSExternalTimeSyncProtocol.java create mode 100644 VS-Sim-Sources/sources/protocols/implementations/VSInternalTimeSyncProtocol.java create mode 100644 VS-Sim-Sources/sources/protocols/implementations/VSOnePhaseCommitProtocol.java create mode 100644 VS-Sim-Sources/sources/protocols/implementations/VSPingPongProtocol.java create mode 100644 VS-Sim-Sources/sources/protocols/implementations/VSReliableMulticastProtocol.java create mode 100644 VS-Sim-Sources/sources/protocols/implementations/VSTwoPhaseCommitProtocol.java create mode 100644 VS-Sim-Sources/sources/serialize/VSNotSerializable.java create mode 100644 VS-Sim-Sources/sources/serialize/VSSerializable.java create mode 100644 VS-Sim-Sources/sources/serialize/VSSerialize.java create mode 100644 VS-Sim-Sources/sources/simulator/VSCreateTask.java create mode 100644 VS-Sim-Sources/sources/simulator/VSLogging.java create mode 100644 VS-Sim-Sources/sources/simulator/VSMain.java create mode 100644 VS-Sim-Sources/sources/simulator/VSMenuItemStates.java create mode 100644 VS-Sim-Sources/sources/simulator/VSSimulator.java create mode 100644 VS-Sim-Sources/sources/simulator/VSSimulatorFrame.java create mode 100644 VS-Sim-Sources/sources/simulator/VSSimulatorVisualization.java create mode 100644 VS-Sim-Sources/sources/utils/VS3Tupel.java create mode 100644 VS-Sim-Sources/sources/utils/VSAboutFrame.java create mode 100644 VS-Sim-Sources/sources/utils/VSClassLoader.java create mode 100644 VS-Sim-Sources/sources/utils/VSFrame.java create mode 100644 VS-Sim-Sources/sources/utils/VSInfoArea.java create mode 100644 VS-Sim-Sources/sources/utils/VSPriorityQueue.java create mode 100644 VS-Sim-Sources/sources/utils/VSRandom.java create mode 100644 VS-Sim-Sources/sources/utils/VSTools.java (limited to 'VS-Sim-Sources/sources') diff --git a/VS-Sim-Sources/sources/core/VSAbstractProcess.java b/VS-Sim-Sources/sources/core/VSAbstractProcess.java new file mode 100644 index 0000000..c46194f --- /dev/null +++ b/VS-Sim-Sources/sources/core/VSAbstractProcess.java @@ -0,0 +1,753 @@ +/* + * Copyright (c) 2008 Paul C. Buetow, vs@dev.buetow.org + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * All icons of the icons/ folder are under a Creative Commons + * Attribution-Noncommercial-Share Alike License a CC-by-nc-sa. + * + * The icon's homepage is http://code.google.com/p/ultimate-gnome/ + */ + +package core; + +import java.awt.*; +import java.io.*; +import java.util.*; + +import core.time.*; +//import events.*; +//import events.implementations.*; +import prefs.*; +import protocols.*; +import serialize.*; +import simulator.*; +import utils.*; + +/** + * The class VSAbstractProcess, an object of this class represents a process + * of a simulator. + * + * @author Paul C. Buetow + */ +public abstract class VSAbstractProcess extends VSSerializablePrefs + implements VSSerializable { + /** The data serialization id. */ + protected static final long serialVersionUID = 1L; + + /** The protocols to reset if the simulator is over or the reset + * button has been pressed. + */ + protected ArrayList protocolsToReset; + + /** The crash history. represents all crashes of the process using the + * global simulator time. + */ + protected ArrayList crashHistory; + + /** The lamport time history. */ + protected ArrayList lamportTimeHistory; + + /** The vector time history. */ + protected ArrayList vectorTimeHistory; + + /** The color used if the process has crashed. */ + protected Color crashedColor;; + + /** The process' current color. */ + protected Color currentColor; + + /** A temp. color. For internal usage. */ + protected Color tmpColor; + + /** The loging object. */ + protected VSLogging loging; + + /** The simulator's default prefs. */ + protected VSPrefs prefs; + + /** The random generator of the process. */ + protected VSRandom random; + + /** The simulator canvas. */ + protected VSSimulatorVisualization simulatorVisualization; + + /** The random crash task. May be null if there is no such random task. */ + protected VSTask randomCrashTask; + + /** The vector time. */ + protected VSVectorTime vectorTime; + + /** The tasks of the process. DO ONLY MANIPULATE THIS OBJECT WITHIN THE + * VSTaskManager CLASS! OTHERWISE THE SYNCHRONIZATION IS WRONG! Use the + * VSAbstractProcess.getTasks() method to get a reference to this object + * within the VSTaskManager! */ + protected VSPriorityQueue tasks; + + /** The process has crashed. But may be working again. */ + protected boolean hasCrashed; + + /** The process has started. But may be paused or crashed.. */ + protected boolean hasStarted; + + /** The process is crashed. */ + protected boolean isCrashed; + + /** The process is highlighted. */ + protected boolean isHighlighted; + + /** The process is paused. */ + protected boolean isPaused; + + /** The time has been modified in a task. Needed by the task manager to + * calculate correct offsets. + */ + protected boolean timeModified; + + /** The clock offset. Used by the task manager and also by the process' + * clock variance. + */ + protected double clockOffset; + + /** The clock variance. */ + protected float clockVariance; + + /** The process id. */ + protected int processID; + + /** The process num. It is different to the process id. It represents the + * array index of there the process is stored at. + */ + protected int processNum; + + /** The global time. */ + protected long globalTime; + + /** The lamport time. */ + protected long lamportTime; + + /** The local time. */ + protected long localTime; + + /** The Constant DEFAULT_INTEGER_VALUE_KEYS. + * 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! + */ + protected static final String DEFAULT_INTEGER_VALUE_KEYS[] = { + "process.prob.crash", + "message.prob.outage", + }; + + /** The Constant DEFAULT_LONG_VALUE_KEYS. + * 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! + */ + protected static final String DEFAULT_LONG_VALUE_KEYS[] = { + "message.sendingtime.min", + "message.sendingtime.max", + }; + + /** The Constant DEFAULT_FLOAT_VALUE_KEYS. + * 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! + */ + protected static final String DEFAULT_FLOAT_VALUE_KEYS[] = { + "process.clock.variance", + }; + + /** The Constant DEFAULT_COLOR_VALUE_KEYS. + * 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! + */ + protected static final String DEFAULT_COLOR_VALUE_KEYS[] = { + "col.process.default", + "col.process.running", + "col.process.stopped", + "col.process.highlight", + "col.process.crashed", + }; + + /** The Constant DEFAULT_STRING_VALUE_KEYS. + * 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! + */ + protected static final String DEFAULT_STRING_VALUE_KEYS[] = { + }; + + /** + * Instantiates a new process. + * + * @param prefs the simulator's default prefs + * @param processNum the process num + * @param simulatorVisualization the simulator canvas + * @param loging the loging object + */ + public VSAbstractProcess(VSPrefs prefs, int processNum, + VSSimulatorVisualization simulatorVisualization, + VSLogging loging) { + init(prefs, processNum, simulatorVisualization, loging); + } + + /** + * Inits a the process. + * + * @param prefs the simulator's default prefs + * @param processNum the process num + * @param simulatorVisualization the simulator canvas + * @param loging the loging object + */ + protected void init(VSPrefs prefs, int processNum, + VSSimulatorVisualization simulatorVisualization, + VSLogging loging) { + /* May be not null if called from deserialization */ + if (this.protocolsToReset == null) + this.protocolsToReset = new ArrayList(); + + this.processNum = processNum; + this.prefs = prefs; + this.simulatorVisualization = simulatorVisualization; + this.loging = loging; + + processID = simulatorVisualization.processIDCount(); + random = new VSRandom(processID*processNum+processID+processNum); + tasks = new VSPriorityQueue(); + + initTimeFormats(); + + isPaused = true; + + /* Create the super.VSPrefs with it's default prefs */ + fillWithDefaults(); + + /* Make local copys in order to have more performance */ + clockVariance = getFloat("process.clock.variance"); + currentColor = getColor("col.process.default"); + crashedColor = getColor("col.process.crashed"); + + /* Make additional process settings editable through GUI */ + initLong("process.localtime", localTime, + prefs.getString("lang.process.time.local"), "ms"); + + createRandomCrashTask_(); + } + + /** + * Inits the time formats. E.g. lamport and vector time stamps. + */ + protected void initTimeFormats() { + lamportTime = 0; + lamportTimeHistory = new ArrayList(); + + vectorTime = new VSVectorTime(0); + vectorTimeHistory = new ArrayList(); + crashHistory = new ArrayList(); + + final int numProcesses = simulatorVisualization.getNumProcesses(); + for (int i = 0; i < numProcesses; ++i) + vectorTime.add(new Long(0)); + } + + /** + * Reset time formats. E.g. lamport and vector time stamps. + */ + protected void resetTimeFormats() { + lamportTime = 0; + lamportTimeHistory.clear(); + + vectorTime = new VSVectorTime(0); + vectorTimeHistory.clear(); + crashHistory.clear(); + + final int numProcesses = simulatorVisualization.getNumProcesses(); + for (int i = numProcesses; i > 0; --i) + vectorTime.add(new Long(0)); + } + + /** + * Creates a random percentage 0..100 using the process' own pseudo + * random number generator object of the VSRandom class. + * + * @return A random percentage 0..100. + */ + public synchronized int getRandomPercentage() { + return random.nextInt() % 101; + } + + /** + * Adds the clock offset. This method is used by the task manager. The + * clock offset identifies if the local time of the process has changed and + * how much.. + * + * @param add the clock offset to add. + */ + protected synchronized void addClockOffset(long add) { + this.clockOffset += add; + } + + /** + * Gets the process id. + * + * @return the process id + */ + public synchronized int getProcessID() { + return processID; + } + + /** + * Gets the process num. The num is different to the process id. It + * represents the array index of there the process is stored at. + * + * @return the process num + */ + public synchronized int getProcessNum() { + return processNum; + } + + /** + * Sets the process id. + * + * @param processID the new process id + */ + public synchronized void setProcessID(int processID) { + this.processID = processID; + } + + /** + * Gets the process' local time. + * + * @return the process' local time + */ + public synchronized long getTime() { + return localTime; + } + + /** + * Sets the process' local time. + * + * @param time the new local time of the process. + */ + public synchronized void setTime(final long time) { + if (time >= 0) + this.localTime = time; + else + this.localTime = 0; + + this.timeModified = true; + } + + /** + * Checks if the process is crashed. + * + * @return true, if is crashed + */ + public synchronized boolean isCrashed() { + return isCrashed; + } + + /** + * Sets if the process is crashed. + * + * @param isCrashed true if the process is crashed. + */ + public synchronized void isCrashed(boolean isCrashed) { + this.isCrashed = isCrashed; + crashHistory.add(new Long(globalTime)); + if (!hasCrashed) + hasCrashed = true; + } + + /** + * Checks if the process has crashed. The difference to isCrashed is, + * that the process may be fully functional again after crashing. This + * method is needed by the simulator canvas in order to see if it should + * paint 'crashed areas' using the crash history of this process. + * + * @return true, if yes + */ + public synchronized boolean hasCrashed() { + return hasCrashed; + } + + /** + * Gets the global time. + * + * @return the global time + */ + public synchronized long getGlobalTime() { + return globalTime; + } + + /** + * Gets the clock variance. + * + * @return the clock variance + */ + public synchronized float getClockVariance() { + return clockVariance; + } + + /** + * Sets the clock variance. + * + * @param clockVariance the new clock variance + */ + 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; + } + + /** + * Gets the a random crash time. + * + * @return the a random crash time. It will be -1 if the process will not + * crash at all randomly! + */ + protected long getARandomCrashTime() { + /* Check if the process will crash or not */ + if (getRandomPercentage() < getInteger("process.prob.crash")) { + /* Calculate the random crash time! */ + final long crashTime = + random.nextLong(simulatorVisualization.getUntilTime()+1) % + simulatorVisualization.getUntilTime(); + return crashTime; + } + + /* No crash */ + return -1; + } + + /** + * Increases the process' lamport time. + */ + public synchronized void increaseLamportTime() { + setLamportTime(getLamportTime()+1); + } + + /** + * Updates the process' lamport time. + * + * @param time the lamport time to use as its update reference. + */ + public synchronized void updateLamportTime(long time) { + final long lamportTime = getLamportTime() + 1; + + if (time > lamportTime) + setLamportTime(time); + else + setLamportTime(lamportTime); + } + + /** + * Gets the lamport time. + * + * @return the lamport time. + */ + public synchronized long getLamportTime() { + return lamportTime; + } + + /** + * Sets the lamport time. + * + * @param lamportTime the new lamport time + */ + public synchronized void setLamportTime(long lamportTime) { + this.lamportTime = lamportTime; + lamportTimeHistory.add(new VSLamportTime(globalTime, lamportTime)); + } + + /** + * Gets the lamport time history as an array. + * + * @return the lamport time history array + */ + public synchronized VSTime[] getLamportTimeArray() { + final int size = lamportTimeHistory.size(); + final VSTime[] arr = new VSLamportTime[size]; + + for (int i = 0; i < size; ++i) + arr[i] = (VSTime) lamportTimeHistory.get(i); + + return arr; + } + + /** + * Increases the vector and the lamport time by 1 each if + * sim.update.vectortime.all/sim.update.lamporttime.all are set + * to true. + */ + public void increaseVectorAndLamportTimeIfAll() { + if (prefs.getBoolean("sim.update.lamporttime.all")) + increaseLamportTime(); + + if (prefs.getBoolean("sim.update.vectortime.all")) + increaseVectorTime(); + } + + /** + * Increases the vector time by 1. + */ + public synchronized void increaseVectorTime() { + vectorTime.set(processNum, + new Long(vectorTime.get(processNum).longValue()+1)); + vectorTime.setGlobalTime(globalTime); + vectorTimeHistory.add(vectorTime.getCopy()); + } + + /** + * Updates the vector time. + * + * @param vectorTimeUpdate the vector time of the other process to use for + * the update + */ + public synchronized void updateVectorTime(VSVectorTime vectorTimeUpdate) { + final int size = vectorTime.size(); + + for (int i = 0; i < size; ++i) { + if (i == processNum) + vectorTime.set(i, new Long(vectorTime.get(i).longValue()+1)); + else if (vectorTimeUpdate.get(i) > vectorTime.get(i)) + vectorTime.set(i, vectorTimeUpdate.get(i)); + } + + vectorTime.setGlobalTime(globalTime); + vectorTimeHistory.add(vectorTime.getCopy()); + } + + /** + * Gets the vector time. + * + * @return the vector time + */ + public synchronized VSVectorTime getVectorTime() { + return vectorTime; + } + + /** + * Gets the vector time history as an array. + * + * @return the vector time history array + */ + public synchronized VSTime[] getVectorTimeArray() { + final int size = vectorTimeHistory.size(); + final VSTime[] arr = new VSTime[size]; + + for (int i = 0; i < size; ++i) + arr[i] = (VSTime) vectorTimeHistory.get(i); + + return arr; + } + + /** + * Gets the crash history array. + * + * @return the crash history array + */ + public synchronized Long[] getCrashHistoryArray() { + final int size = crashHistory.size(); + final Long[] arr = new Long[size]; + + for (int i = 0; i < size; ++i) + arr[i] = crashHistory.get(i); + + return arr; + } + + /** + * Logg a message to the loging area. + * + * @param message the message to log + */ + public void log(String message) { + loging.log(toString() + "; " + message, globalTime); + } + + /* (non-Javadoc) + * @see prefs.VSPrefs#fillWithDefaults() + */ + 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); + } + + /* (non-Javadoc) + * @see prefs.VSPrefs#toString() + */ + public synchronized String toString() { + StringBuffer buffer = new StringBuffer(); + buffer.append(prefs.getString("lang.process.id")); + buffer.append(": "); + buffer.append(getProcessID()); + buffer.append("; "); + buffer.append(prefs.getString("lang.process.time.local")); + buffer.append(": "); + buffer.append(VSTools.getTimeString(getTime())); + buffer.append("; "); + buffer.append(prefs.getString("lang.time.lamport")); + buffer.append(": "); + buffer.append(lamportTime); + buffer.append("; "); + buffer.append(prefs.getString("lang.time.vector")); + buffer.append(": "); + buffer.append(vectorTime); + return buffer.toString(); + } + + /** + * The extended string representation of the process object. + * + * @return the extended string representation + */ + public synchronized String toStringFull() { + StringBuffer buffer = new StringBuffer(); + buffer.append(toString()); + buffer.append("; paused: "); + buffer.append(isPaused); + buffer.append("; crashed: "); + buffer.append(isCrashed); + buffer.append("; crashTask: "); + buffer.append(randomCrashTask); + return buffer.toString(); + } + + /** + * Equals. Checks, if both processes have the same process num. + * + * @param process the process to compare to + * + * @return true, if both processes are the same (same processNum). + */ + public boolean equals(VSAbstractProcess process) { + return process.getProcessNum() == processNum; + } + + /** + * Gets the simulator's default prefs. + * + * @return the default prefs + */ + public VSPrefs getPrefs() { + return prefs; + } + + /* (non-Javadoc) + * @see serialize.VSSerializable#serialize(serialize.VSSerialize, + * java.io.ObjectOutputStream) + */ + public synchronized void serialize(VSSerialize serialize, + ObjectOutputStream objectOutputStream) + throws IOException { + super.serialize(serialize, objectOutputStream); + + if (VSSerialize.DEBUG) + System.out.println("Serializing: VSAbstractProcess (num: " + + processNum + + "; id: " + processID + ")"); + + /** For later backwards compatibility, to add more stuff */ + objectOutputStream.writeObject(new Boolean(false)); + + objectOutputStream.writeObject(new Integer(processID)); + objectOutputStream.writeObject(new Integer(protocolsToReset.size())); + for (VSAbstractProtocol protocol : protocolsToReset) { + objectOutputStream.writeObject(protocol.getClassname()); + protocol.serialize(serialize, objectOutputStream); + } + + /** For later backwards compatibility, to add more stuff */ + objectOutputStream.writeObject(new Boolean(false)); + } + + /* (non-Javadoc) + * @see serialize.VSSerializable#deserialize(serialize.VSSerialize, + * java.io.ObjectInputStream) + */ + @SuppressWarnings("unchecked") + public synchronized void deserialize(VSSerialize serialize, + ObjectInputStream objectInputStream) + throws IOException, ClassNotFoundException { + super.deserialize(serialize, objectInputStream); + updateFromPrefs_(); + + if (VSSerialize.DEBUG) + System.out.println("Deserializing: VSAbstractProcess"); + + /** For later backwards compatibility, to add more stuff */ + objectInputStream.readObject(); + + this.processID = ((Integer) + objectInputStream.readObject()).intValue(); + int numProtocols = ((Integer) + objectInputStream.readObject()).intValue(); + + for (int i = 0; i < numProtocols; ++i) { + String protocolClassname = (String) objectInputStream.readObject(); + VSAbstractProtocol protocol = getProtocolObject_(protocolClassname); + protocol.deserialize(serialize, objectInputStream); + } + + localTime = 0; + setLong("process.localTime", localTime); + + /** For later backwards compatibility, to add more stuff */ + objectInputStream.readObject(); + + serialize.setObject(processNum, "process", this); + } + + /** + * Sets the current color. + * + * @param newColor the new current color + */ + protected void setCurrentColor(Color newColor) { + if (isHighlighted) + tmpColor = newColor; + else + currentColor = newColor; + } + + /* (non-Javadoc) + * @see core.VSInternalMessage#updateFromPrefs() + */ + protected abstract void updateFromPrefs_(); + + /* (non-Javadoc) + * @see core.VSInternalMessage#createRandomCrashTask() + */ + protected abstract void createRandomCrashTask_(); + + /* (non-Javadoc) + * @see core.VSInternalMessage#getProtocolObjekt(java.util.String) + */ + protected abstract VSAbstractProtocol getProtocolObject_( + String protocolClassname); +} diff --git a/VS-Sim-Sources/sources/core/VSInternalProcess.java b/VS-Sim-Sources/sources/core/VSInternalProcess.java new file mode 100644 index 0000000..2ccc494 --- /dev/null +++ b/VS-Sim-Sources/sources/core/VSInternalProcess.java @@ -0,0 +1,459 @@ +/* + * Copyright (c) 2008 Paul C. Buetow, vs@dev.buetow.org + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * All icons of the icons/ folder are under a Creative Commons + * Attribution-Noncommercial-Share Alike License a CC-by-nc-sa. + * + * The icon's homepage is http://code.google.com/p/ultimate-gnome/ + */ + +package core; + +import java.awt.*; +//import java.io.*; +//import java.util.*; + +import core.time.*; +import events.*; +import events.implementations.*; +import prefs.*; +import protocols.*; +//import serialize.*; +import simulator.*; +import utils.*; + +/** + * The class VSInternalProcess, an object of this class represents a process + * of a simulator. + * + * @author Paul C. Buetow + */ +public class VSInternalProcess extends VSAbstractProcess { + /** + * Instantiates a new process. + * + * @param prefs the simulator's default prefs + * @param processNum the process num + * @param simulatorVisualization the simulator canvas + * @param loging the loging object + */ + public VSInternalProcess(VSPrefs prefs, int processNum, + VSSimulatorVisualization simulatorVisualization, + VSLogging loging) { + super(prefs, processNum, simulatorVisualization, loging); + } + + /** + * Called from the VSProcessEditor, after finishing editing! This makes + * sure that the VSInternalProcess object is using the up to date prefs! + */ + public synchronized void updateFromPrefs() { + setClockVariance(getFloat("process.clock.variance")); + setLocalTime(getLong("process.localtime")); + crashedColor = getColor("col.process.crashed"); + createRandomCrashTask(); + } + + /** + * Called from the VSProcessEditor, before starting editing! This makes + * sure that the editor edits the up to date prefs of the process! + */ + public synchronized void updatePrefs() { + setFloat("process.clock.variance", getClockVariance()); + setLong("process.localtime", getTime()); + } + + /** + * Syncs the process' time. This method is using the clockOffset and + * clockVariance variables. This method is called repeatedly from the + * VSSimulatorVisualization in order to update the process' local and global + * time values. + * + * @param globalTime the global time. + */ + public synchronized void syncTime(final long globalTime) { + final long currentGlobalTimestep = globalTime - this.globalTime; + this.globalTime = globalTime; + + localTime += currentGlobalTimestep; + clockOffset += currentGlobalTimestep * (double) clockVariance; + + while (clockOffset >= 1) { + clockOffset -= 1; + ++localTime; + } + + while (clockOffset <= -1) { + clockOffset += 1; + --localTime; + } + + /* We do not want a negative time */ + if (localTime < 0) + localTime = 0; + } + + /** + * Highlights the process. + */ + public synchronized void highlightOn() { + tmpColor = currentColor; + currentColor = getColor("col.process.highlight"); + isHighlighted = true; + } + + /** + * Unhighlights the process. + */ + public synchronized void highlightOff() { + currentColor = tmpColor; + isHighlighted = false; + } + + /** + * Resets the process. + */ + public synchronized void reset() { + isPaused = true; + isCrashed = false; + hasCrashed = false; + localTime = 0; + globalTime = 0; + clockOffset = 0; + + for (VSAbstractProtocol protocol : protocolsToReset) + protocol.reset(); + + setCurrentColor(getColor("col.process.default")); + resetTimeFormats(); + } + + /** + * Creates the random crash task. The crash task will be created only if + * the process is not crashed atm. and if + * VSInternalProcess.getARandomCrashTime() * returns a non-negative value. + * The random crash task uses the simulaion's global time for its + * scheduling. + */ + public synchronized void createRandomCrashTask() { + if (!isCrashed) { + VSTaskManager taskManager = simulatorVisualization.getTaskManager(); + long crashTime = getARandomCrashTime(); + + if (crashTime < 0) + return; + + if (randomCrashTask != null) + taskManager.removeTask(randomCrashTask); + + if (crashTime >= getGlobalTime()) { + VSAbstractEvent event = new VSProcessCrashEvent(); + randomCrashTask = new VSTask(crashTime, this, event, + VSTask.GLOBAL); + taskManager.addTask(randomCrashTask); + + } else { + randomCrashTask = null; + } + } + } + + /** + * Creates a random percentage 0..100 using the process' own pseudo + * random number generator object of the VSRandom class. + * + * @return A random percentage 0..100. + */ + public synchronized int getRandomPercentage() { + return random.nextInt() % 101; + } + + /** + * Adds the clock offset. This method is used by the task manager. The + * clock offset identifies if the local time of the process has changed and + * how much.. + * + * @param add the clock offset to add. + */ + public synchronized void addClockOffset(long add) { + this.clockOffset += add; + } + + /** + * The process' state is 'play'. Called by the simulator canvas. + */ + public synchronized void play() { + isPaused = false; + setCurrentColor(getColor("col.process.running")); + } + + /** + * The process' state is 'pause'. Called by the simulator canvas. + */ + public synchronized void pause() { + isPaused = true; + setCurrentColor(getColor("col.process.stopped")); + } + + /** + * The process' state is 'Finish'. Called by the simulator canvas. + */ + public synchronized void finish() { + isPaused = true; + setCurrentColor(getColor("col.process.default")); + } + + /** + * Gets the current process' color. + * + * @return the current color of the process. + */ + public synchronized Color getColor() { + return currentColor; + } + + /** + * Gets the color of this process if it's crashed. + * + * @return the crashed color + */ + public synchronized Color getCrashedColor() { + return crashedColor; + } + + /** + * Checks if the time has been modified. by a task. + * This mehod is needed by the task manager in order to add a clock offset + * to the process object. + * + * @return true, if yes + */ + public synchronized boolean timeModified() { + return timeModified; + } + + /** + * Sets if the time has been modified by a task. + * + * @param timeModified true, if it has been modified. + */ + public synchronized void timeModified(boolean timeModified) { + this.timeModified = timeModified; + } + + /** + * Sets the global time. + * + * @param globalTime the new global time + */ + public synchronized void setGlobalTime(final long globalTime) { + this.globalTime = globalTime >= 0 ? globalTime : 0; + } + + /* Gets the duration time of a message to send. + * + * @return the duration time + */ + public synchronized long getDurationTime() { + final long maxDurationTime = getLong("message.sendingtime.max"); + final long minDurationTime = getLong("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); + } + + /** + * Gets the a random message outage time. + * + * @param durationTime the duration time + * + * @return the a random message outage time. It will be -1 if the message + * will not get lost at all. + */ + public synchronized long getARandomMessageOutageTime(long durationTime, + VSInternalProcess receiverProcess) { + int percentage = (int) ((getInteger("message.prob.outage") + + receiverProcess.getInteger( + "message.prob.outage")) / 2); + + /* Check if the message will have an outage or not */ + if (getRandomPercentage() < percentage) { + + /* Calculate the random outage time! */ + long outageTime = globalTime + random.nextLong(durationTime+1) % + simulatorVisualization.getUntilTime(); + + return outageTime; + } + + /* No outage */ + return -1; + } + + /** + * Gets the random crash task. + * + * @return the random crash task + */ + public synchronized VSTask getCrashTask() { + return randomCrashTask; + } + + /** + * Checks if the process is paused. + * + * @return true, if is paused + */ + public synchronized boolean isPaused() { + return isPaused; + } + + /** + * Called by a task if the process sends a message. + * + * @param message the message to send. + */ + public synchronized void sendMessage(VSMessage message) { + StringBuffer buffer = new StringBuffer(); + buffer.append(prefs.getString("lang.message.sent")); + buffer.append("; "); + buffer.append(message.toStringFull()); + log(buffer.toString()); + simulatorVisualization.sendMessage(message); + } + + /** + * Gets the simulator canvas. + * + * @return the simulator canvas + */ + public VSSimulatorVisualization getSimulatorCanvas() { + return simulatorVisualization; + } + + /** + * Removes the process at the specified index. Called by the simulator + * canvas if a process has been removed from the simulator. Needed in + * order to update the vector time and the local processNum. + * + * @param index the index the process has to get removed. + */ + public synchronized void removedAProcessAtIndex(int index) { + if (index < processNum) + --processNum; + + vectorTime.remove(index); + for (VSVectorTime vectorTime : vectorTimeHistory) + vectorTime.remove(index); + } + + /** + * Added a process. Needed in order to update the vector time's size. + * Called by the simulator canvas if a process has been added to the + * simulator. + */ + public synchronized void addedAProcess() { + vectorTime.add(new Long(0)); + for (VSVectorTime vectorTime : vectorTimeHistory) + vectorTime.add(new Long(0)); + } + + /** + * Gets the tasks of the process. + * + * @return The tasks + */ + public VSPriorityQueue getTasks() { + return tasks; + } + + /** + * Sets the tasks of the process. + * + * @param tasks The tasks + */ + public void setTasks(VSPriorityQueue tasks) { + this.tasks = tasks; + } + + /** + * Gets the protocol object. + * + * @param protocolClassname the protocol classname + * + * @return the protocol object + */ + public synchronized VSAbstractProtocol getProtocolObject( + String protocolClassname) { + VSAbstractProtocol protocol = null; + + if (!objectExists(protocolClassname)) { + protocol = (VSAbstractProtocol) + VSRegisteredEvents.createEventInstanceByClassname( + protocolClassname, this); + + setObject(protocolClassname, protocol); + protocolsToReset.add(protocol); + + } else { + protocol = (VSAbstractProtocol) getObject(protocolClassname); + } + + return protocol; + } + + /** + * Sets the local time. + * + * @param localTime the new local time. + */ + public synchronized void setLocalTime(final long localTime) { + if (localTime >= 0) + this.localTime = localTime; + else + this.localTime = 0; + } + + /* (non-Javadoc) + * @see core.VSInternalMessage#updateFromPrefs() + */ + protected void updateFromPrefs_() { + updateFromPrefs(); + } + + /* (non-Javadoc) + * @see core.VSInternalMessage#createRandomCrashTask() + */ + protected void createRandomCrashTask_() { + createRandomCrashTask(); + } + + /* (non-Javadoc) + * @see core.VSInternalMessage#getProtocolObjekt(java.util.String) + */ + protected VSAbstractProtocol getProtocolObject_(String protocolClassname) { + return getProtocolObject(protocolClassname); + } +} diff --git a/VS-Sim-Sources/sources/core/VSMessage.java b/VS-Sim-Sources/sources/core/VSMessage.java new file mode 100644 index 0000000..8703b6f --- /dev/null +++ b/VS-Sim-Sources/sources/core/VSMessage.java @@ -0,0 +1,208 @@ +/* + * Copyright (c) 2008 Paul C. Buetow, vs@dev.buetow.org + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * All icons of the icons/ folder are under a Creative Commons + * Attribution-Noncommercial-Share Alike License a CC-by-nc-sa. + * + * The icon's homepage is http://code.google.com/p/ultimate-gnome/ + */ + +package core; + +import core.time.*; +import events.*; +import prefs.VSPrefs; + +/** + * An object of this class represents a message which is sent from one process + * to another process in the simulator. + * + * @author Paul C. Buetow + */ +public class VSMessage extends VSPrefs { + /** The serial version uid */ + private static final long serialVersionUID = 1L; + + /** The constant IS_SERVER_MESSAGE. */ + public static final boolean IS_SERVER_MESSAGE = true; + + /** The constant IS_CLIENT_MESSAGE. */ + public static final boolean IS_CLIENT_MESSAGE = false; + + /** true, if the message has been sent from a server. false, if the message + * has been sent from a client. + */ + private boolean isServerMessage; + + /** Each message belongs to a specific protocol. This variable defined the + * class name of the protocol being used. + */ + private String protocolClassname; + + /** The default application preferences. */ + private VSPrefs prefs; + + /** A reference to the process who sent this message. */ + private VSInternalProcess sendingProcess; + + /** The vector time of the sending process after sending. The receiver + * process will use this vector time in order to update the local vector + * time. + */ + private VSVectorTime vectorTime; + + /** The lamport time of the sending process after sending. The receiver + * process will use this lamport time in order to update the local vector + * time. + */ + private long lamportTime; + + /** Each message has its own unique ID. The ID will show up in the loging + * window of the simulator + */ + private long messageID; + + /** This counter is used in order to generate unique message ID's. */ + private static long messageCounter; + + /** + * The constructor of the message. Creates a new message object. + */ + public VSMessage() { + this.messageID = ++messageCounter; + } + + /** + * Initializes the message. + * + * @param process The sending process of this message. + * @param protocolClassname The classname of the protocol this message. + * @param isServerMessage Sets if the message has been sent by a server. + */ + void init(VSInternalProcess process, String protocolClassname, + boolean isServerMessage) { + this.sendingProcess = process; + this.protocolClassname = protocolClassname; + this.isServerMessage = isServerMessage; + this.prefs = process.getPrefs(); + + lamportTime = sendingProcess.getLamportTime(); + vectorTime = sendingProcess.getVectorTime().getCopy(); + } + + /** + * Gets the protocol name of the message. + * + * @return The protocol name of the message. + */ + public String getName() { + return VSRegisteredEvents.getNameByClassname(getProtocolClassname()); + } + + /** + * Gets the protocol classname. + * + * @return The protocol classname of the message. + */ + public String getProtocolClassname() { + return protocolClassname; + } + + /** + * Gets the message id. + * + * @return The id of the message. + */ + public long getMessageID() { + return messageID; + } + + /** + * Gets a reference of the sending process. + * + * @return The process which sent this message. + */ + public VSAbstractProcess getSendingProcess() { + return sendingProcess; + } + + /** + * Gets the lamport time. + * + * @return The lamport time of the sending process. + */ + public long getLamportTime() { + return lamportTime; + } + + /** + * Gets the vector time. + * + * @return The vector time of the sending process. + */ + public VSVectorTime getVectorTime() { + return vectorTime; + } + + /** + * Checks if the message has been sent by a server or a client. + * + * @return true, if the message has been sent by a server. false, if the + * message has been sent by a client. + */ + public boolean isServerMessage() { + return isServerMessage; + } + + /* (non-Javadoc) + * @see prefs.VSPrefs#toString() + */ + public String toString() { + StringBuffer buffer = new StringBuffer(); + + buffer.append("ID: "); + buffer.append(messageID); + buffer.append("; "); + buffer.append(prefs.getString("lang.protocol")); + buffer.append(": "); + buffer.append(VSRegisteredEvents.getShortnameByClassname( + getProtocolClassname())); + + return buffer.toString(); + } + + /** + * Extended string representation of the message object. + * + * @return Extended string representation of the message object. + */ + public String toStringFull() { + return toString() + "; " + super.toString(); + } + + /** + * Compares two messages. + * + * @param message The message to compare with. + * + * @return true, if the messages have the same id. Otherwise false. + */ + public boolean equals(VSMessage message) { + return messageID == message.getMessageID(); + } +} + diff --git a/VS-Sim-Sources/sources/core/VSMessageStub.java b/VS-Sim-Sources/sources/core/VSMessageStub.java new file mode 100644 index 0000000..0210b74 --- /dev/null +++ b/VS-Sim-Sources/sources/core/VSMessageStub.java @@ -0,0 +1,61 @@ +/* + * Copyright (c) 2008 Paul C. Buetow, vs@dev.buetow.org + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * All icons of the icons/ folder are under a Creative Commons + * Attribution-Noncommercial-Share Alike License a CC-by-nc-sa. + * + * The icon's homepage is http://code.google.com/p/ultimate-gnome/ + */ + +package core; + +//import core.time.*; +//import events.*; +//import prefs.VSPrefs; + +/** + * An object of this class represents a message stub. A message stub allows + * to run the init method on a VSMessage object. The init method should be + * hidden by the protocol programming API. + * + * @author Paul C. Buetow + */ +public class VSMessageStub { + /** The serial version uid */ + private static final long serialVersionUID = 1L; + + /** The message */ + private VSMessage message; + + /** + * The constructor of the message stub. Creates a new message stub object. + * + * @param message the message + */ + public VSMessageStub(VSMessage message) { + this.message = message; + } + + /* (non-Javadoc) + * @see core.VSMessage#init(VSInternalProcess, java.util.String, boolean) + */ + public void init(VSInternalProcess process, String protocolClassname, + boolean isServerMessage) { + message.init(process, protocolClassname, isServerMessage); + } +} + diff --git a/VS-Sim-Sources/sources/core/VSTask.java b/VS-Sim-Sources/sources/core/VSTask.java new file mode 100644 index 0000000..ccb4d98 --- /dev/null +++ b/VS-Sim-Sources/sources/core/VSTask.java @@ -0,0 +1,522 @@ +/* + * Copyright (c) 2008 Paul C. Buetow, vs@dev.buetow.org + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * All icons of the icons/ folder are under a Creative Commons + * Attribution-Noncommercial-Share Alike License a CC-by-nc-sa. + * + * The icon's homepage is http://code.google.com/p/ultimate-gnome/ + */ + +package core; + +import java.io.*; + +import events.*; +import events.implementations.*; +import events.internal.*; +import exceptions.*; +import prefs.VSPrefs; +import protocols.VSAbstractProtocol; +import serialize.*; +//import utils.*; + +/** + * The class VSTask, an object of this class represents a task to do or done. + * All tasks are managed by the task manager. There are local and global timed + * tasks. Local timed tasks are being fullfilled if the process' local time is + * reached. Global timed tasks are being fullfilled if the simulator's time is + * reached. + * + * @author Paul C. Buetow + */ +public class VSTask implements Comparable, VSSerializable { + /** The serial version uid */ + private static final long serialVersionUID = 1L; + + /** The Constant LOCAL. Used for the constructor if it's a local timed + * task. + */ + public final static boolean LOCAL = true; + + /** The Constant GLOBAL. Used for the constructor if it's a global timed + * task. + */ + public final static boolean GLOBAL = false; + + /** The task time. */ + private long taskTime; + + /** The event which takes plase if the task time matches. */ + private VSAbstractEvent event; + + /** The process to run the task at. */ + private VSInternalProcess process; + + /** The simulator's default prefs. */ + private VSPrefs prefs; + + /** The task is programmed. The task will be still in the task manager + * after reset. + */ + private boolean isProgrammed; + + /** The task is global timed. If set to true, its local timed. */ + private boolean isGlobalTimed; + + /** The task counter. Needed for the unique task numbers. */ + private static int taskCounter; + + /** The task number. */ + private int taskNum; + + /** + * Instantiates a new task. + * + * @param taskTime the task time + * @param process the process + * @param event the event + * @param isLocal the taks is local timed + */ + public VSTask(long taskTime, VSInternalProcess process, + VSAbstractEvent event, + boolean isLocal) { + init(taskTime, process, event, isLocal); + } + + /** + * Instantiates a new task, it's a copy constructor. + * + * @param task the task to copy + */ + public VSTask(VSTask task) { + VSAbstractEvent event = task.getEvent(); + + try { + // Use the copy of the event object + event = event.getCopy(); + + } catch (VSEventNotCopyableException e) { + // Use the original event object + } + + init(task.getTaskTime(), + task.getProcess(), + event, + !task.isGlobalTimed()); + } + + /** + * Instantiates a new task during a deserialization. + * + * @param serialize the serialize object + * @param objectInputStream The input stream + */ + public VSTask(VSSerialize serialize, ObjectInputStream objectInputStream) + throws IOException, ClassNotFoundException { + deserialize(serialize, objectInputStream); + } + + /** + * Inits the task + * + * @param taskTime the task time + * @param process the process + * @param event the event + * @param isLocal the taks is local timed + */ + private void init(long taskTime, VSInternalProcess process, + VSAbstractEvent event, boolean isLocal) { + this.process = process; + this.taskTime = taskTime > 0 ? taskTime : 0; + /* May be not null if called from deserialization */ + if (this.event == null) + this.event = event; + this.prefs = process.getPrefs(); + this.isGlobalTimed = !isLocal; + this.taskNum = ++taskCounter; + } + + /** + * Gets the task num. + * + * @return the task num + */ + public int getTaskNum() { + return taskNum; + } + + /** + * Sets if the task is programmed. + * + * @param isProgrammed true, if the task is programmed + */ + public void isProgrammed(boolean isProgrammed) { + this.isProgrammed = isProgrammed; + } + + /** + * Checks if the task is programmed. + * + * @return true, if the task is programmed + */ + public boolean isProgrammed() { + return isProgrammed; + } + + /** + * Checks if the task is using an "internal event". + * + * @return true, if the task is using an internal event + */ + public boolean hasInternalEvent() { + return event instanceof VSAbstractInternalEvent; + } + + /** + * Checks if the task should not get serialized. + * + * @return true, if the task should not get serialized + */ + public boolean hasNotSerializableEvent() { + return event instanceof VSNotSerializable; + } + + /** + * Checks if the task is a message receive event. + * + * @return true, if it is a message receive event + */ + public boolean hasMessageReceiveEvent() { + return event instanceof VSMessageReceiveEvent; + } + + /** + * Checks if the task is a process recover event. + * + * @return true, if it is a process recover event + */ + public boolean hasProcessRecoverEvent() { + return event instanceof VSProcessRecoverEvent; + } + + /** + * Checks if the task belongs to the specified protocol object. + * + * @param protocol the protocol object to check against. + * + * @return true, if it's a task using the protocol object. + */ + public boolean isProtocol(VSAbstractProtocol protocol) { + if (event instanceof VSAbstractProtocol) + return ((VSAbstractProtocol) event).equals(protocol); + + return false; + } + + /** + * Checks if the task's time is over. + * + * @return true, if it's over + */ + public boolean timeOver() { + if (isGlobalTimed) + return taskTime < process.getGlobalTime(); + + return taskTime < process.getTime(); + } + + /** + * Checks if the task equals to another task. + * + * @param task the task to compare to + * + * @return true, if equal (the task nums equal) + */ + public boolean equals(VSTask task) { + return taskNum == task.getTaskNum(); + } + + /** + * Checks if the task belongs to the specified process. + * + * @param process the process to check against + * + * @return true, if the task is using the process + */ + public boolean isProcess(VSInternalProcess process) { + return this.process.equals(process); + } + + /** + * Checks if the task is global timed. + * + * @return true, if the taks is global timed + */ + public boolean isGlobalTimed() { + return isGlobalTimed; + } + + /** + * Gets the process. + * + * @return the process of the event + */ + public VSInternalProcess getProcess() { + return process; + } + + /** + * Runs the task. + */ + public void run() { + if (event.getProcess() == null) + event.init(process); + + if (!(event instanceof VSMessageReceiveEvent) + && !(event instanceof VSAbstractProtocol)) + process.increaseVectorAndLamportTimeIfAll(); + + event.onStart(); + } + + /** + * Gets the task time. + * + * @return the task time + */ + public long getTaskTime() { + return taskTime; + } + + /** + * Sets the task time. + * + * @param taskTime the task time + */ + public void setTaskTime(long taskTime) { + this.taskTime = taskTime; + } + + /** + * Sets the process. + * + * @param process the process + */ + public void setProcess(VSInternalProcess process) { + /* Only do it if the process differs */ + if (!this.process.equals(process)) { + this.process = process; + + try { + // Use the copy o