/// <summary>
/// Call this function when an error occurs during the simulation stage.
/// </summary>
/// <param name="reason">The reason of the error.</param>
/// <param name="customData">Custom data about the error.</param>
public void SimulationStageError(string reason, byte[] customData)
{
if (!this.initialized)
{
throw new DssException("DssSimulationMgr is uninitialized!");
}
/// If we are currently finishing the simulation --> do nothing
if (this.hostLeft)
{
return;
}
/// Stop the alarm clocks
StopCommitTimeoutClock();
StopSimulationFrameClock();
UnregisterAllCommitMonitors();
/// Send the DSS_SIM_ERROR message to the others
RCPackage errPackage = RCPackage.CreateNetworkCustomPackage(DssRoot.DSS_SIM_ERROR);
errPackage.WriteString(0, reason);
errPackage.WriteByteArray(1, customData);
this.root.LobbyIface.SendPackage(errPackage);
/// Quit from the DSS immediately
this.root.SimulatorIface.SimulationError(reason, customData);
this.root.EventQueue.ExitEventLoop();
}
/// <summary>
/// Sends a commit for this.nextNextRound to the lobby.
/// </summary>
/// <remarks>
/// Call this function only if this.currentRound has been finished.
/// </remarks>
private void SendCommit()
{
if (!this.initialized)
{
throw new DssException("DssSimulationMgr is uninitialized!");
}
if (this.currentRound.StepNextFrame())
{
throw new DssException("DssSimulationMgr.SendCommit() denied!");
}
if (!this.hostLeft)
{
byte[] stateHash = this.root.SimulatorIface.StateHash;
int highestAPT = this.HighestAPT;
/// Generate a ticket for the commit.
int ticket = -1;
do
{
ticket = RandomService.DefaultGenerator.Next();
} while (this.commitAwMonitors.ContainsKey(ticket));
/// Create the commit package.
RCPackage commitPackage = RCPackage.CreateNetworkCustomPackage(DssRoot.DSS_COMMIT);
commitPackage.WriteShort(0, (short)this.aftCalculator.Average);
commitPackage.WriteShort(1, (short)highestAPT); /// The highest measured APT
commitPackage.WriteInt(2, this.nextNextRound.RoundIndex); /// Round index of the commit
commitPackage.WriteInt(3, ticket); /// Commit answer ticket
commitPackage.WriteByteArray(4, stateHash != null ? stateHash : new byte[0] {
}); /// State-hash value
/// Send the commit package to the lobby.
this.root.LobbyIface.SendPackage(commitPackage);
RegisterCommitMonitor(ticket);
TraceManager.WriteAllTrace(string.Format("Self commit round {0}", this.nextNextRound.RoundIndex), DssTraceFilters.SIMULATION_INFO);
if (!this.nextNextRound.Commit(this.root.IdOfThisPeer, this.aftCalculator.Average, highestAPT, stateHash))
{
SimulationStageError(string.Format("Commit of round-{0} failed!", this.nextNextRound.RoundIndex),
new byte[0] {
});
}
}
}
/// <summary>
/// Sends a DSS_LEAVE message to the lobby and leaves the DSS.
/// </summary>
private void SendLeaveMessage()
{
if (!this.initialized)
{
throw new DssException("DssSimulationMgr is uninitialized!");
}
StopCommitTimeoutClock();
StopSimulationFrameClock();
UnregisterAllCommitMonitors();
if (!this.hostLeft)
{
RCPackage leaveMessage = RCPackage.CreateNetworkCustomPackage(DssRoot.DSS_LEAVE);
leaveMessage.WriteString(0, "Leave DSS during simulation stage!");
leaveMessage.WriteByteArray(1, new byte[0] {
});
this.root.LobbyIface.SendPackage(leaveMessage);
}
}
private void txtIO_TextChanged(object sender, EventArgs e)
{
if (!this.textChangingFromNetwork && this.textBoxMap[(TextBox)sender] == this.lastKnownIdOfThisPeer)
{
/// Get an interface for sending the message
ILobby sendIface = null;
if (this.joinedLobby != null && this.createdLobby == null)
{
sendIface = this.joinedLobby;
}
else if (this.joinedLobby == null && this.createdLobby != null)
{
sendIface = this.createdLobby;
}
if (sendIface != null)
{
/// Create the package
RCPackage package = RCPackage.CreateNetworkCustomPackage(MY_FORMAT);
package.WriteString(0, ((TextBox)sender).Text);
/// Get the targets of the package
List <int> targets = new List <int>();
for (int i = 0; i < this.lastKnownLineStates.Length; i++)
{
if (i != this.lastKnownIdOfThisPeer && this.targetSelectors[i].Checked)
{
targets.Add(i);
}
}
if (targets.Count != 0)
{
/// Send a dedicated message.
sendIface.SendPackage(package, targets.ToArray());
}
else
{
/// Send the message to the whole lobby.
sendIface.SendPackage(package);
}
}
}
}
/// <summary>
/// Internal function to timestamp and send the given commands to the lobby.
/// </summary>
/// <param name="cmds">The list of the commands to send.</param>
private void SendCommandsToLobby(RCPackage[] cmds)
{
if (!this.initialized)
{
throw new DssException("DssSimulationMgr is uninitialized!");
}
if (cmds != null && cmds.Length != 0)
{
/// Compute the length of the buffer needed for sending the commands as a byte sequence
int bufferLength = 0;
for (int i = 0; i < cmds.Length; i++)
{
if (cmds[i] != null && cmds[i].IsCommitted && cmds[i].PackageType == RCPackageType.CUSTOM_DATA_PACKAGE &&
!DssRoot.IsInternalFormat(cmds[i].PackageFormat))
{
bufferLength += cmds[i].PackageLength;
}
else
{
throw new DssException("Unexpected command from the client module!");
}
}
/// Create the buffer and write the commands into this buffer
byte[] cmdBuffer = new byte[bufferLength];
int offset = 0;
for (int i = 0; i < cmds.Length; i++)
{
offset += cmds[i].WritePackageToBuffer(cmdBuffer, offset);
}
/// Create the DSS_COMMAND package and send it to the lobby
RCPackage cmdPackage = RCPackage.CreateNetworkCustomPackage(DssRoot.DSS_COMMAND);
cmdPackage.WriteInt(0, this.nextNextRound.RoundIndex); /// Round index of the command
cmdPackage.WriteInt(1, this.currentRound.CurrentFrameIndex); /// Frame index of the command
cmdPackage.WriteByteArray(2, cmdBuffer); /// The command list
this.root.LobbyIface.SendPackage(cmdPackage); /// Send the command package to the lobby
}
}
/// <summary>
/// Registers the given commit arrived from the given operator.
/// </summary>
/// <param name="commit">The arrived commit package.</param>
/// <param name="senderID">The sender operator.</param>
/// <returns>True in case of success, false otherwise.</returns>
public bool RegisterCommit(RCPackage commit, int senderID)
{
if (!this.initialized)
{
throw new DssException("DssSimulationMgr is uninitialized!");
}
/// If we are currently finishing the simulation --> do nothing
if (this.hostLeft)
{
return(true);
}
if (commit == null || !commit.IsCommitted)
{
throw new ArgumentException("commit");
}
if (senderID == this.root.IdOfThisPeer)
{
throw new DssException("Unexpected commit sender!");
}
if (senderID < 0 || senderID >= this.root.OpCount)
{
throw new ArgumentException("senderID");
}
if (commit.PackageFormat.ID != DssRoot.DSS_COMMIT)
{
/// Package format error.
return(false);
}
short senderAFT = commit.ReadShort(0);
short senderAPT = commit.ReadShort(1);
int roundIdx = commit.ReadInt(2);
int ticket = commit.ReadInt(3);
byte[] stateHash = commit.ReadByteArray(4);
if (senderAFT < 0)
{
return(false);
}
if (senderAPT < 0)
{
return(false);
}
if (stateHash == null)
{
return(false);
}
bool success = false;
if (roundIdx == this.nextRound.RoundIndex)
{
success = this.nextRound.Commit(senderID, senderAFT, senderAPT, stateHash);
if (this.waitingForCommit && this.nextRound.IsCommitted)
{
TraceManager.WriteAllTrace("WAITING FOR COMMIT END", DssTraceFilters.SIMULATION_INFO);
/// The missing commit has arrived, so we can continue the simulation
this.waitingForCommit = false;
/// Compute the scheduled time for the next frame
int nextFrameStartTime = this.currentRound.BaseTime
+ (this.currentRound.CurrentFrameIndex + 1) * this.currentRound.TargetFrameTime;
SendCommit();
SwapRounds();
/// Schedule the next frame.
SetNextFrameExecutionTime(Math.Max(nextFrameStartTime, DssRoot.Time));
}
}
else if (roundIdx == this.nextNextRound.RoundIndex)
{
success = this.nextNextRound.Commit(senderID, senderAFT, senderAPT, stateHash);
}
else
{
TraceManager.WriteAllTrace(string.Format("RoundIdx mismatch! RoundIdx: {0}", roundIdx), DssTraceFilters.SIMULATION_ERROR);
}
if (success)
{
/// Create the answer for the commit and send it back to the sender.
RCPackage commitAw = RCPackage.CreateNetworkCustomPackage(DssRoot.DSS_COMMIT_ANSWER);
commitAw.WriteInt(0, ticket);
this.root.LobbyIface.SendPackage(commitAw, new int[1] {
senderID
});
}
return(success);
}
/// <summary>
/// Resets the state of the DssSimulationMgr. Call this function every time you start a simulation stage.
/// </summary>
/// <param name="opFlags">
/// The current operator flag array. See the comment at this.operatorFlags for more information.
/// </param>
public void Reset(bool[] opFlags)
{
if (opFlags == null)
{
throw new ArgumentNullException("opFlags");
}
if (opFlags.Length != this.root.OpCount)
{
throw new ArgumentException("Array length mismatch.", "opFlags");
}
this.aftCalculator = new AverageCalculator(DssConstants.AVG_CALC_VECTOR_LENGTH,
DssConstants.INITIAL_AFT);
this.aptCalculators = new AverageCalculator[this.root.OpCount];
for (int i = 0; i < this.aptCalculators.Length; i++)
{
this.aptCalculators[i] = new AverageCalculator(DssConstants.AVG_CALC_VECTOR_LENGTH,
DssConstants.INITIAL_APT);
}
if (this.commitAwTimeouts != null)
{
foreach (KeyValuePair <AlarmClock, CommitMonitor> item in this.commitAwTimeouts)
{
item.Key.Cancel();
}
}
this.commitAwMonitors = new Dictionary <int, CommitMonitor>();
this.commitAwTimeouts = new Dictionary <AlarmClock, CommitMonitor>();
StopCommitTimeoutClock();
StopSimulationFrameClock();
this.operatorFlags = opFlags;
this.currentRound = new SimulationRound(this.operatorFlags);
this.currentRound.Reset(true, 0);
this.currentRound.ComputeSpeedControl();
this.nextRound = new SimulationRound(this.operatorFlags);
this.nextRound.Reset(false, 1);
this.nextNextRound = new SimulationRound(this.operatorFlags);
this.nextNextRound.Reset(false, 2);
this.nextNextNextRound = new SimulationRound(this.operatorFlags);
this.nextNextNextRound.Reset(false, 3);
this.waitingForCommit = false;
this.initialized = true;
this.hostLeft = false;
int ticket = RandomService.DefaultGenerator.Next();
byte[] stateHash = this.root.SimulatorIface.StateHash;
int highestAPT = this.HighestAPT;
this.commitTimeoutClock = this.root.AlarmClkMgr.SetAlarmClock(DssRoot.Time + DssConstants.COMMIT_TIMEOUT,
this.CommitTimeout);
/// Create the first commit package.
RCPackage commitPackage = RCPackage.CreateNetworkCustomPackage(DssRoot.DSS_COMMIT);
commitPackage.WriteShort(0, (short)this.aftCalculator.Average);
commitPackage.WriteShort(1, (short)highestAPT); /// The highest measured APT
commitPackage.WriteInt(2, 1); /// Round index of the commit is 1 (next round is committed)
commitPackage.WriteInt(3, ticket); /// Commit answer ticket
commitPackage.WriteByteArray(4, stateHash != null ? stateHash : new byte[0] {
}); /// State-hash value
/// Send the commit package to the lobby.
this.root.LobbyIface.SendPackage(commitPackage);
RegisterCommitMonitor(ticket);
TraceManager.WriteAllTrace(string.Format("Self commit round {0}", this.nextRound.RoundIndex), DssTraceFilters.SIMULATION_INFO);
if (!this.nextRound.Commit(this.root.IdOfThisPeer, this.aftCalculator.Average, highestAPT, stateHash))
{
SimulationStageError(string.Format("Commit of round-{0} failed!", this.nextRound.RoundIndex),
new byte[0] {
});
}
}
public static RCPackage GenerateRandomPackage()
{
int rndType = rnd.Next(0, 3);
int rndFormat = rnd.Next(0, 3);
RCPackage retPack = null;
if (rndType == 0)
{
retPack = RCPackage.CreateNetworkPingPackage(); return(retPack);
}
else if (rndType == 1)
{
retPack = RCPackage.CreateCustomDataPackage(rndFormat);
}
else if (rndType == 2)
{
retPack = RCPackage.CreateNetworkCustomPackage(rndFormat);
}
RCPackageFormat format = RCPackageFormat.GetPackageFormat(rndFormat);
for (int i = 0; i < format.NumOfFields; i++)
{
RCPackageFieldType datatype = format.GetFieldType(i);
if (datatype == RCPackageFieldType.BYTE)
{
retPack.WriteByte(i, (byte)rnd.Next(byte.MinValue, byte.MaxValue));
}
else if (datatype == RCPackageFieldType.SHORT)
{
retPack.WriteShort(i, (short)rnd.Next(short.MinValue, short.MaxValue));
}
else if (datatype == RCPackageFieldType.INT)
{
retPack.WriteInt(i, (int)rnd.Next(int.MinValue, int.MaxValue));
}
else if (datatype == RCPackageFieldType.LONG)
{
retPack.WriteLong(i, (long)rnd.Next(int.MinValue, int.MaxValue));
}
else if (datatype == RCPackageFieldType.STRING)
{
int strIdx = rnd.Next(0, 10);
retPack.WriteString(i, strCollection[strIdx]);
}
else if (datatype == RCPackageFieldType.BYTE_ARRAY)
{
int arrLen = rnd.Next(0, 10);
byte[] arr = new byte[arrLen];
rnd.NextBytes(arr);
retPack.WriteByteArray(i, arr);
}
else if (datatype == RCPackageFieldType.SHORT_ARRAY)
{
int arrLen = rnd.Next(0, 10);
short[] arr = new short[arrLen];
for (int j = 0; j < arrLen; ++j)
{
arr[j] = (short)rnd.Next(short.MinValue, short.MaxValue);
}
retPack.WriteShortArray(i, arr);
}
else if (datatype == RCPackageFieldType.INT_ARRAY)
{
int arrLen = rnd.Next(0, 10);
int[] arr = new int[arrLen];
for (int j = 0; j < arrLen; ++j)
{
arr[j] = (int)rnd.Next(int.MinValue, int.MaxValue);
}
retPack.WriteIntArray(i, arr);
}
else if (datatype == RCPackageFieldType.LONG_ARRAY)
{
int arrLen = rnd.Next(0, 10);
long[] arr = new long[arrLen];
for (int j = 0; j < arrLen; ++j)
{
arr[j] = (long)rnd.Next(int.MinValue, int.MaxValue);
}
retPack.WriteLongArray(i, arr);
}
else if (datatype == RCPackageFieldType.STRING_ARRAY)
{
int arrLen = rnd.Next(0, 10);
string[] arr = new string[arrLen];
for (int j = 0; j < arrLen; ++j)
{
int strIdx = rnd.Next(0, 10);
arr[j] = strCollection[strIdx];
}
retPack.WriteStringArray(i, arr);
}
else
{
throw new NetworkingSystemException("Unknown datatype");
}
}
return(retPack);
}
