static void Main(string[] args)
{
System.Globalization.CultureInfo customCulture = (System.Globalization.CultureInfo)System.Threading.Thread.CurrentThread.CurrentCulture.Clone();
customCulture.NumberFormat.NumberDecimalSeparator = ".";
System.Threading.Thread.CurrentThread.CurrentCulture = customCulture;
maxParallel = Environment.ProcessorCount - 1;
maxParallel = 4;
Console.WriteLine("Max parallel sims: " + maxParallel);
var pp = new ProtocolParameters()
{
duty_cycle = 0.9, // NOT IN SECONDS: active time percentage (t_l / (t_l + t_s))
t_sense = 0.0521, // carrier sense duration (needs to be more than any signal duration)
t_backoff = 0.0219, // backoff interval length (constant?)
t_listen = 0.016, // listening time, must be quite higher than t_signal
t_data = 0.0521, // data transmission time
t_signal = 0.00521, // signal packet transmission time (RTS and CTS ?)
n_regions = 4, // number of priority regions
n_max_coll = 6, // number of attempts for solving a collision
n_max_sensing = 10,
n_max_pkt = 3,
n_max_region_cycle = 5,
passed_packets_memory = 10
};
var sp = new SimulationParameters()
{
area_side = 200,
debug_interval = 1,
debugType = DebugType.Never,
debug_file = "../../graphic_debug/debug_data.js",
max_time = 10, // / (factor * factor),
n_density = 200, // this is density (nodes per 100^2 area), not total nodes
packet_rate = 1,
range = 20,
min_distance = 2,
asleepEnergy = 2,
idleEnergy = 10,
transmissionEnergy = 50,
emptyRegionType = EmptyRegionType.Lines,
skipCycleEvents = true
};
var versions = Enum.GetValues(typeof(ProtocolVersion)).Cast <ProtocolVersion>().ToList();
var shapes = Enum.GetValues(typeof(EmptyRegionType)).Cast <EmptyRegionType>().ToList();
var runResults = new RunResult {
startTime = DateTime.Now,
basePP = pp,
baseSP = sp
};
var DLparameters = new GeneralParameters()
{
lambdas = new List <double> {
1, 5, 10
},
dutyCycles = new List <double>()
{
0.1, 0.3, 0.5, 0.9
},
emptyRegionTypes = new List <EmptyRegionType> {
EmptyRegionType.None, EmptyRegionType.Lines
},
versions = versions,
simulations = 20
};
var LNparameters = new GeneralParameters()
{
lambdas = new List <double> {
1, 5, 10
},
relay_densities = new List <float> {
100, 200, 300
}, // CHANGE PROPORTIONAL TO AREA
emptyRegionTypes = new List <EmptyRegionType> {
EmptyRegionType.None, EmptyRegionType.Lines
},
versions = versions,
simulations = 20
};
var shapeParameters = new GeneralParameters()
{
versions = versions,
emptyRegionTypes = shapes,
simulations = 200
};
var debugParameters = new GeneralParameters()
{
versions = new List <ProtocolVersion> {
ProtocolVersion.Base
},
emptyRegionTypes = new List <EmptyRegionType> {
EmptyRegionType.Lines
},
simulations = 1
};
//runResults.shapeStats = General.Generate("Shapes", sp, pp, shapeParameters);
//runResults.dutyLambdas = General.Generate("DL", sp, pp, DLparameters);
//runResults.lambdaNs = General.Generate("LN", sp, pp, LNparameters);
// debug
sp.debugType = DebugType.Always;
General.Generate("Debug", sp, pp, debugParameters);
runResults.endTime = DateTime.Now;
Console.WriteLine("Finished simulating");
using (var writer = new StreamWriter("../../stats/runResults.json")) {
writer.WriteLine(JsonConvert.SerializeObject(runResults, Formatting.Indented));
}
Console.WriteLine("Saved results");
//Console.ReadKey();
}
public Simulation(SimulationParameters simulationParameters, ProtocolParameters protocolParameters)
{
this.simulationParameters = simulationParameters;
this.protocolParameters = protocolParameters;
// init sim state
clock = 0;
eventQueue = new EventQueue();
var initialCycleDuration = protocolParameters.t_sleep + protocolParameters.t_listen;
eventQueue.Add(new StartEvent()
{
time = initialCycleDuration + protocolParameters.t_delta, // must start AFTER first duty cycle events
sim = this,
previous = null
});
eventQueue.Add(new EndEvent()
{
time = simulationParameters.max_time,
sim = this,
previous = null
});
if (simulationParameters.debugType == DebugType.Interval)
{
eventQueue.Add(new DebugEvent()
{
time = simulationParameters.debug_interval,
sim = this,
previous = null
});
}
// init relays as asleep and schedule random awake
relays = new List <Relay>();
relayById = new Dictionary <int, Relay>();
for (int i = 0; i < simulationParameters.n_nodes; i++)
{
var relay = new Relay {
id = i,
range = simulationParameters.range,
status = RelayStatus.Asleep,
sim = this
};
relays.Add(relay);
relayById[relay.id] = relay;
eventQueue.Add(new AwakeEvent()
{
relay = relay,
// could be at any point of its duty cycle
time = RNG.rand() * initialCycleDuration,
sim = this,
previous = null
});
}
// create distance matrix
distances = new float[relays.Count, relays.Count];
// move disconnected
//Console.WriteLine("Placing relays");
var connected = false;
int n_slots = simulationParameters.binsCount;
while (!connected)
{
// check wether the grid slot is available
var slotBusy = new bool[n_slots, n_slots];
foreach (var relay in relays)
{
var X_slot = 0;
var Y_slot = 0;
var validRegion = false;
do
{
X_slot = RNG.rand_int(0, n_slots);
Y_slot = RNG.rand_int(0, n_slots);
// assign actual position
relay.position.X = slotToX(X_slot);
relay.position.Y = slotToX(Y_slot);
// calculate if in region
var X = relay.position.X;
var Y = relay.position.Y;
var c = simulationParameters.area_side / 2;
var dx = X - c;
var dy = Y - c;
switch (simulationParameters.emptyRegionType)
{
case EmptyRegionType.None:
validRegion = true;
break;
case EmptyRegionType.Cross:
var w = simulationParameters.emptyRegionSize / Math.Sqrt(2);
var h = Math.Max(relay.range + 2, simulationParameters.emptyRegionSize / 10) / Math.Sqrt(2);
var l = simulationParameters.area_side;
var w1 = (l - w) > (X + Y);
var w2 = (l + w) < (X + Y);
var w3 = (w) < (X - Y);
var w4 = -(w) > (X - Y);
var h1 = (h) < (X - Y);
var h2 = -(h) > (X - Y);
var h3 = (l - h) > (X + Y);
var h4 = (l + h) < (X + Y);
validRegion = (w1 || w2 || h1 || h2) && (w3 || w4 || h3 || h4);
break;
case EmptyRegionType.Square:
var side = simulationParameters.emptyRegionSize;
validRegion = (Math.Abs(dx) >= side / 2) || (Math.Abs(dy) >= side / 2);
break;
case EmptyRegionType.Lines:
var side_w = simulationParameters.emptyRegionSize;
var side_h = Math.Max(relay.range + 2, side_w / 6);
var validFirstLine = (X <= c - side_w / 2) || (X >= c + side_w / 2) || (Y <= c * 3 / 2 - side_h / 2) || (Y >= c * 3 / 2 + side_h / 2);
var validSecondLine = (X <= c - side_w / 2) || (X >= c + side_w / 2) || (Y <= c * 1 / 2 - side_h / 2) || (Y >= c * 1 / 2 + side_h / 2);
validRegion = validFirstLine && validSecondLine;
break;
case EmptyRegionType.Holes:
var radius = simulationParameters.emptyRegionSize;
var d1 = GraphUtils.Distance(X, Y, 0.5 * c, 0.5 * c);
var d2 = GraphUtils.Distance(X, Y, 0.5 * c, 1.5 * c);
var d3 = GraphUtils.Distance(X, Y, 1.5 * c, 0.5 * c);
var d4 = GraphUtils.Distance(X, Y, 1.5 * c, 1.5 * c);
validRegion = d1 >= radius && d2 >= radius && d3 >= radius && d4 >= radius;
break;
}
}while (slotBusy[X_slot, Y_slot] || !validRegion);
// take slot
slotBusy[X_slot, Y_slot] = true;
}
//Console.WriteLine("Checking connected relays");
// calculate new neighbours
GraphUtils.Distances(relays, distances);
GraphUtils.SetNeighbours(relays, distances);
connected = GraphUtils.Connected(relays);
}
if (protocolParameters.protocolVersion == ProtocolVersion.BFS || protocolParameters.protocolVersion == ProtocolVersion.BFS_half)
{
GraphUtils.RepeatedBFS(relays, distances, protocolParameters.protocolVersion);
}
//Console.WriteLine("Placed relays");
// init debug state
if (simulationParameters.debugType != DebugType.Never)
{
debugWriter = new StreamWriter(simulationParameters.debug_file);
debugWriter.Write("debug_data=`");
debugWriter.WriteLine($"{JsonConvert.SerializeObject(simulationParameters)}");
debugWriter.WriteLine("#");
debugWriter.WriteLine($"{JsonConvert.SerializeObject(protocolParameters)}");
debugWriter.WriteLine("#");
foreach (var r in relays)
{
debugWriter.WriteLine($"{r.id};{r.position.X};{r.position.Y};{r.range}");
}
debugWriter.WriteLine("#");
debugWriter.WriteLine($"{JsonConvert.SerializeObject(distances)}");
debugWriter.WriteLine("#");
}
}
