private static void RunStupidModel()
{
int gridRes = 100; //2d resolution
//each grid cell can 'see' +- 4 cells in all direction. All 'motion' is done via communication
//hence R = 4 / gridRes
float r = 4.5f / gridRes;
BaseDB.ConfigContainer config = new BaseDB.ConfigContainer()
{
extent = Int3.One, r = r, m = r * 0.5f
};
Simulation.Configure(new ShardID(Int3.Zero, 0), config, true);
Vec3 outlierCoords = Simulation.MySpace.Min;
var ctx = new SimulationContext(true);
var intermediate0 = new IntermediateSDS();
intermediate0.entities = new EntityPool(MakeGrid2D(gridRes), ctx);
//EntityTest.RandomDefaultPool(100);
intermediate0.ic = InconsistencyCoverage.NewCommon();
intermediate0.inputConsistent = true;
intermediate0.localChangeSet = new EntityChangeSet();
SDSStack.Entry root = new SDSStack.Entry(
new SDS(0, intermediate0.entities.ToArray(), intermediate0.ic),
intermediate0);
//Assert.IsTrue(root.IsFullyConsistent);
SDSStack stack = Simulation.Stack;
stack.ResetToRoot(root);
for (int i = 0; i < 13; i++)
{
//Assert.IsNotNull(stack.NewestSDS.FinalEntities, i.ToString());
var temp = stack.AllocateGeneration(i + 1);
ctx.SetGeneration(i + 1);
var comp = new SDSComputation(new DateTime(), ExtMessagePack.CompleteBlank, TimeSpan.FromMilliseconds(10), ctx);
//ComputationTests.AssertNoErrors(comp, "comp");
//Assert.IsTrue(comp.Intermediate.inputConsistent);
var sds = comp.Complete();
stack.Insert(sds);
//Assert.IsTrue(sds.IsFullyConsistent);
//Assert.AreEqual(sds.FinalEntities.Length, gridRes * gridRes);
int numBugs = 0;
int numPredators = 0;
int numConflicts = 0;
float totalFood = 0;
foreach (var e in sds.Item1.FinalEntities)
{
Habitat h = (Habitat)Helper.Deserialize(e.SerialLogicState);
if (h.bug.HasAnimal)
{
numBugs++;
}
if (h.predator.HasAnimal)
{
numPredators++;
if (h.bug.HasAnimal)
{
numConflicts++;
}
}
totalFood += h.food;
}
Console.WriteLine("Population: b=" + numBugs + ", p=" + numPredators + ", c=" + numConflicts + "; Food=" + totalFood);
}
}
private static void CheckIncoming(int currentTLG, SimulationContext ctx)
{
Tuple <Link, object> pair;
while (incoming.TryTake(out pair))
{
object obj = pair.Item2;
Link lnk = pair.Item1;
if (obj is ClientMessage)
{
Log.Error("Received client message via peer socket");
return;
}
if (obj is OldestGeneration)
{
int gen = ((OldestGeneration)obj).Generation;
if (gen == lnk.OldestGeneration)
{
if (siblings.AllResponsive && siblings.OldestGeneration >= gen)
{
DB.RemoveInboundRCSsAsync(neighbors.Select(sibling => sibling.InboundRCSStackID), gen).Wait(); //maybe only now responsive
}
Log.Minor("OldestGen update from sibling " + lnk + ": Warning: Already moved to generation " + gen);
return;
}
if (gen > lnk.OldestGeneration)
{
lnk.SetOldestGeneration(gen, currentTLG);
lnk.Filter((id, o) =>
{
SerialSDS sds = o as SerialSDS;
if (sds != null)
{
return(sds.Generation >= gen);
}
RCS.Serial rcs = o as RCS.Serial;
if (rcs != null)
{
return(rcs.Generation >= gen);
}
return(true);
});
if (siblings.AllResponsive && siblings.OldestGeneration >= gen)
{
DB.RemoveInboundRCSsAsync(neighbors.Select(sibling => sibling.InboundRCSStackID), gen).Wait();
}
}
return;
}
if (obj is Tuple <int, RCS> )
{
var rcs = (Tuple <int, RCS>)obj;
if (rcs.Item1 <= stack.NewestConsistentSDSGeneration)
{
Log.Error("RCS update from sibling " + lnk + ": Rejected. Already moved past generation " + rcs.Item1);
return;
}
FetchNeighborUpdate(stack.AllocateGeneration(rcs.Item1), lnk, rcs.Item2);
return;
}
if (obj is RCS.Serial)
{
RCS.Serial rcs = (RCS.Serial)obj;
if (rcs.Generation <= stack.NewestConsistentSDSGeneration)
{
Log.Error("RCS update from sibling " + lnk + ": Rejected. Already moved past generation " + rcs.Generation);
return;
}
FetchNeighborUpdate(stack.AllocateGeneration(rcs.Generation), lnk, rcs.Data);
return;
}
if (obj is SerialSDS)
{
//Debug.Assert(HaveSibling(lnk));
SerialSDS raw = (SerialSDS)obj;
if (raw.Generation <= stack.OldestSDSGeneration)
{
Log.Minor("SDS update from sibling or DB: Rejected. Already moved past generation " + raw.Generation);
return;
}
var existing = stack.FindGeneration(raw.Generation);
if (existing != null && existing.IsFullyConsistent)
{
Log.Minor("SDS update from sibling or DB: Rejected. Generation already consistent: " + raw.Generation);
return;
}
SDS sds = raw.Deserialize();
if (existing != null && existing.SDS.ICMessagesAndEntitiesAreEqual(sds))
{
Log.Minor("SDS update from sibling or DB: Equal. Ignoring");
return;
}
if (sds.IsFullyConsistent)
{
Log.Minor("SDS update from sibling or DB: Accepted generation " + raw.Generation);
stack.Insert(sds);
return;
}
SDS merged = existing.SDS.MergeWith(sds, SDS.MergeStrategy.ExclusiveWithPositionCorrection, ctx);
Log.Minor("SDS update from sibling " + lnk + ": Merged generation " + raw.Generation);
if (merged.Inconsistency < existing.SDS.Inconsistency)
{
stack.Insert(merged);
}
if (merged.Inconsistency < sds.Inconsistency)
{
lnk.Set(new SDS.ID(ID.XYZ, raw.Generation).P2PKey, new SerialSDS(merged, Simulation.ID.XYZ));
}
return;
}
if (obj is Tuple <int, MessagePack> )
{
//Debug.Assert(HaveSibling(lnk));
var m = (Tuple <int, MessagePack>)obj;
if (m.Item1 <= stack.OldestSDSGeneration)
{
Log.Minor("CCS update from sibling or DB: Rejected. Already moved past generation " + m.Item1);
return;
}
Messages.Insert(m.Item1, m.Item2);
return;
}
Log.Error("Unsupported update from sibling " + lnk + ": " + obj.GetType());
}
}