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/LICENSE | 22 + VS-Sim-Sources/build.xml | 65 + VS-Sim-Sources/docs/SERIALIZATION_NOTES.txt | 40 + VS-Sim-Sources/icons/pause.png | Bin 0 -> 2467 bytes VS-Sim-Sources/icons/replay.png | Bin 0 -> 2467 bytes VS-Sim-Sources/icons/reset.png | Bin 0 -> 2467 bytes VS-Sim-Sources/icons/start.png | Bin 0 -> 2467 bytes VS-Sim-Sources/scripts/beforecommit.sh | 21 + VS-Sim-Sources/scripts/checklinelengths.sh | 27 + VS-Sim-Sources/scripts/formatthecode.sh | 19 + VS-Sim-Sources/scripts/pdf2txtrmcr.pl | 12 + VS-Sim-Sources/scripts/printstatistics.sh | 21 + VS-Sim-Sources/scripts/replaceastring.sh | 25 + 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 ++ 76 files changed, 15972 insertions(+) create mode 100644 VS-Sim-Sources/LICENSE create mode 100644 VS-Sim-Sources/build.xml create mode 100644 VS-Sim-Sources/docs/SERIALIZATION_NOTES.txt create mode 100644 VS-Sim-Sources/icons/pause.png create mode 100644 VS-Sim-Sources/icons/replay.png create mode 100644 VS-Sim-Sources/icons/reset.png create mode 100644 VS-Sim-Sources/icons/start.png create mode 100755 VS-Sim-Sources/scripts/beforecommit.sh create mode 100755 VS-Sim-Sources/scripts/checklinelengths.sh create mode 100755 VS-Sim-Sources/scripts/formatthecode.sh create mode 100644 VS-Sim-Sources/scripts/pdf2txtrmcr.pl create mode 100755 VS-Sim-Sources/scripts/printstatistics.sh create mode 100755 VS-Sim-Sources/scripts/replaceastring.sh 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') diff --git a/VS-Sim-Sources/LICENSE b/VS-Sim-Sources/LICENSE new file mode 100644 index 0000000..207233e --- /dev/null +++ b/VS-Sim-Sources/LICENSE @@ -0,0 +1,22 @@ +/* + * Copyright (c) 2008 Paul 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/ + */ diff --git a/VS-Sim-Sources/build.xml b/VS-Sim-Sources/build.xml new file mode 100644 index 0000000..6487c16 --- /dev/null +++ b/VS-Sim-Sources/build.xml @@ -0,0 +1,65 @@ + + This is the distributed systems simulation/learning environment! + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/VS-Sim-Sources/docs/SERIALIZATION_NOTES.txt b/VS-Sim-Sources/docs/SERIALIZATION_NOTES.txt new file mode 100644 index 0000000..44ad0a4 --- /dev/null +++ b/VS-Sim-Sources/docs/SERIALIZATION_NOTES.txt @@ -0,0 +1,40 @@ +VSSerialize + prefs(=VSPrefs).serialize + writeObject(...) + simulator(=VSSimulator).serialize + simulatorCanvas(=VSSimulatorCanvas).serialize + writeObject(numProcesses) + for (porcess : processes) process(=VSProcess).serialize { + super(=VSPrefs).serialize + writeObject(processID) + writeObject(numProtocolsToReset) + for (protocol : protocolsToReset) { + writeObject(protocolClassname) + protocol(=VSAbstractProtocol).serialize + super(=VSAbstractEvent).serialize + super(=VSPrefs).serialize + s.o. + writeObject(id) + writeObject(eventShortname) + writeObject(eventClassname) + writeObject(hasOnServerStart) + } + } + taskManager(=VSTaskManager).serialize + writeObject(numTasks) + for (task : tasks) task(=VSTask).serialize + writeObject(eventClassname) + event(=VSAbstractEvent).serialize + s.o. + writeObject(eventID) + writeObject(processNum) + writeObject(taskNum) + writeObject(taskTime) + writeObject(isGlobalTimed) + writeObject(isProgrammed) + +VSProtocolEvent.serialize + super(=VSAbstractEvent).serialize + writeObject(protocolClassname) + writeObject(isClientProtocol) + writeObject(isProtocolActivation) diff --git a/VS-Sim-Sources/icons/pause.png b/VS-Sim-Sources/icons/pause.png new file mode 100644 index 0000000..7976413 Binary files /dev/null and b/VS-Sim-Sources/icons/pause.png differ diff --git a/VS-Sim-Sources/icons/replay.png b/VS-Sim-Sources/icons/replay.png new file mode 100644 index 0000000..416a3b3 Binary files /dev/null and b/VS-Sim-Sources/icons/replay.png differ diff --git a/VS-Sim-Sources/icons/reset.png b/VS-Sim-Sources/icons/reset.png new file mode 100644 index 0000000..bca89e3 Binary files /dev/null and b/VS-Sim-Sources/icons/reset.png differ diff --git a/VS-Sim-Sources/icons/start.png b/VS-Sim-Sources/icons/start.png new file mode 100644 index 0000000..63f6798 Binary files /dev/null and b/VS-Sim-Sources/icons/start.png differ diff --git a/VS-Sim-Sources/scripts/beforecommit.sh b/VS-Sim-Sources/scripts/beforecommit.sh new file mode 100755 index 0000000..a06ee8f --- /dev/null +++ b/VS-Sim-Sources/scripts/beforecommit.sh @@ -0,0 +1,21 @@ +#!/bin/sh +# +# 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. + +./scripts/formatthecode.sh +./scripts/checklinelengths.sh + diff --git a/VS-Sim-Sources/scripts/checklinelengths.sh b/VS-Sim-Sources/scripts/checklinelengths.sh new file mode 100755 index 0000000..cf98cd8 --- /dev/null +++ b/VS-Sim-Sources/scripts/checklinelengths.sh @@ -0,0 +1,27 @@ +#!/bin/sh +# +# 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. + +MAXLEN=80 + +for i in `find ./sources -name \*.java | grep -v VSDefaultPrefs.java` +do + awk -v MAXLEN=$MAXLEN -v file=$i '{ + if (length > MAXLEN) + print file " line " NR " is " length " chars long " + }' $i +done diff --git a/VS-Sim-Sources/scripts/formatthecode.sh b/VS-Sim-Sources/scripts/formatthecode.sh new file mode 100755 index 0000000..5733c31 --- /dev/null +++ b/VS-Sim-Sources/scripts/formatthecode.sh @@ -0,0 +1,19 @@ +#!/bin/sh +# +# 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. + +find ./sources -name \*.java | xargs astyle --style=java --mode=java -n diff --git a/VS-Sim-Sources/scripts/pdf2txtrmcr.pl b/VS-Sim-Sources/scripts/pdf2txtrmcr.pl new file mode 100644 index 0000000..5ffb05d --- /dev/null +++ b/VS-Sim-Sources/scripts/pdf2txtrmcr.pl @@ -0,0 +1,12 @@ +#!/usr/bin/perl + +use strict; +use warnings; + +for () { + chomp if /[a-z]/; + print; +} + +__DATA__ + diff --git a/VS-Sim-Sources/scripts/printstatistics.sh b/VS-Sim-Sources/scripts/printstatistics.sh new file mode 100755 index 0000000..614d36e --- /dev/null +++ b/VS-Sim-Sources/scripts/printstatistics.sh @@ -0,0 +1,21 @@ +#!/bin/sh +# +# 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. + +find ./sources -name \*.java | xargs wc -l +echo "Num .java files:" +find ./sources -name \*.java | wc -l diff --git a/VS-Sim-Sources/scripts/replaceastring.sh b/VS-Sim-Sources/scripts/replaceastring.sh new file mode 100755 index 0000000..6b50b83 --- /dev/null +++ b/VS-Sim-Sources/scripts/replaceastring.sh @@ -0,0 +1,25 @@ +#!/bin/sh +# +# 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. + +FROM=$1 +INTO=$2 + +echo "Replaceing $FROM with $INTO" + +find ./sources -name \*.java -exec sh -c "sed -n 's/$FROM/$INTO/g; \ + w .tmp' {} && mv -f .tmp {}" \; 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 lam