public void ParallelSchedulerEmptySequenceTest()
{
ParallelScheduler ps = new ParallelScheduler();
var variablesUsedByNode = new[] { new int[] { } };
ps.CreateGraph(variablesUsedByNode);
}
public void ParallelSchedulerTest2()
{
ParallelScheduler ps = new ParallelScheduler();
ps.FillIdleSlots = true;
int depth = 10;
int[][] variablesUsedByNode = Util.ArrayInit(2 * depth + 1, i =>
{
if (i < depth)
{
return(new int[] { 0 });
}
else if (i < 2 * depth)
{
return(new int[] { i - depth });
}
else
{
return(Util.ArrayInit(depth, j => j));
}
});
ps.CreateGraph(variablesUsedByNode);
var schedule = ps.GetScheduleWithBarriers(2);
ParallelScheduler.WriteSchedule(schedule);
var perThread = ps.ConvertToSchedulePerThread(schedule, 2);
Assert.True(perThread[1][0].Length == 0);
Assert.True(perThread[0][2].Length == 0);
}
private void DistributedSchedule(int processCount, int threadCount)
{
int nodeCount = 100;
IReadOnlyList <Gaussian> xExpected;
Gaussian shiftExpected;
IReadOnlyList <int[]> variablesUsedByNode;
var schedulePerThread = parallelScheduleTest(processCount, nodeCount, out xExpected, out shiftExpected, out variablesUsedByNode);
int[][][] schedulePerProcess = ParallelScheduler.ConvertToSchedulePerProcess(schedulePerThread);
Dictionary <int, int>[] processLocalIndexOfArrayIndexPerProcess;
IReadOnlyList <Compiler.Graphs.DistributedCommunicationInfo> distributedCommunicationInfos = ParallelScheduler.GetDistributedCommunicationInfos(schedulePerThread, variablesUsedByNode, out processLocalIndexOfArrayIndexPerProcess);
Console.WriteLine("communication cost = {0}", TotalCommunicationCost(distributedCommunicationInfos));
int[][][][][] schedulePerThreadPerProcess;
if (threadCount > 1)
{
schedulePerThreadPerProcess = Util.ArrayInit(processCount, process =>
ParallelScheduler.GetSchedulePerThreadInProcess(schedulePerProcess[process], distributedCommunicationInfos[process].indices, threadCount)
);
}
else
{
schedulePerThreadPerProcess = Util.ArrayInit(processCount, process => default(int[][][][]));
}
IList <Gaussian>[] xResultPerProcess = new IList <Gaussian> [processCount];
Gaussian[] shiftResultPerProcess = new Gaussian[processCount];
bool debug = false;
if (debug)
{
Assert.Equal(1, processCount);
SequentialCommunicator comm = new SequentialCommunicator();
DistributedScheduleTestProcess(comm, xResultPerProcess, shiftResultPerProcess, distributedCommunicationInfos[comm.Rank], schedulePerProcess[comm.Rank], schedulePerThreadPerProcess[comm.Rank]);
}
else
{
ThreadCommunicator.Run(processCount, comm =>
DistributedScheduleTestProcess(comm, xResultPerProcess, shiftResultPerProcess, distributedCommunicationInfos[comm.Rank], schedulePerProcess[comm.Rank], schedulePerThreadPerProcess[comm.Rank])
);
}
Gaussian[] arrayMarginal = new Gaussian[nodeCount];
for (int process = 0; process < processCount; process++)
{
////Console.WriteLine($"shift {shiftExpected} {shiftResultPerProcess[process]}");
Assert.Equal(shiftExpected, shiftResultPerProcess[process]);
foreach (var entry in processLocalIndexOfArrayIndexPerProcess[process])
{
int arrayIndex = entry.Key;
int localIndex = entry.Value;
arrayMarginal[arrayIndex] = xResultPerProcess[process][localIndex];
}
}
var arrayActual = new DistributionStructArray <Gaussian, double>(arrayMarginal);
////Console.WriteLine(arrayActual);
double error = arrayActual.MaxDiff(xExpected);
Assert.True(error < 1e-10);
}
public void ParallelSchedulerTest3()
{
var schedule = ParallelSchedulerTest(20000, 2);
ParallelScheduler.WriteSchedule(schedule, true);
Assert.True(schedule.Count == 10);
Assert.True(schedule[3].Count == 2);
//Assert.True(schedule[3][0].Count == 21);
Assert.True(schedule[9].Count == 2);
//Assert.True(schedule[9][0].Count == 3758);
}
internal void ParallelSchedulerTest()
{
ParallelScheduler ps = new ParallelScheduler();
int[] nodes = Util.ArrayInit(5, i => ps.NewNode());
ps.AddEdge(nodes[0], nodes[2]);
ps.AddEdge(nodes[1], nodes[2]);
ps.AddEdge(nodes[2], nodes[4]);
ps.AddEdge(nodes[3], nodes[4]);
var schedule = ps.GetScheduleWithBarriers(2);
ParallelScheduler.WriteSchedule(schedule);
// TODO: add assertion
}
public static List <List <List <int> > > ParallelSchedulerTest(int nodeCount, int parentCount)
{
Rand.Restart(0);
ParallelScheduler ps = new ParallelScheduler();
int[] nodes = Util.ArrayInit(nodeCount, i => ps.NewNode());
for (int i = 0; i < nodeCount; i++)
{
if (i > parentCount)
{
for (int j = 0; j < parentCount; j++)
{
int parent = Rand.Int(i);
if (!ps.ContainsEdge(nodes[parent], nodes[i]))
{
ps.AddEdge(nodes[parent], nodes[i]);
}
}
}
}
var schedule = ps.GetScheduleWithBarriers(2);
return(schedule);
}
private int[][][] parallelScheduleTest(int numThreads, int nodeCount, out IReadOnlyList <Gaussian> xMarginal, out Gaussian shiftMarginal, out IReadOnlyList <int[]> variablesUsedByNode)
{
int maxParentCount = 1;
variablesUsedByNode = GenerateVariablesUsedByNode(nodeCount, maxParentCount);
ParallelScheduler ps = new ParallelScheduler();
ps.CreateGraph(variablesUsedByNode);
var schedule = ps.GetScheduleWithBarriers(numThreads);
ParallelScheduler.WriteSchedule(schedule, true);
var schedulePerThread = ps.ConvertToSchedulePerThread(schedule, numThreads);
var nodeCountVar = Variable.Observed(nodeCount).Named("nodeCount");
Range node = new Range(nodeCountVar).Named("node");
node.AddAttribute(new Sequential()
{
BackwardPass = true
});
var x = Variable.Array <double>(node).Named("x");
x[node] = Variable.GaussianFromMeanAndPrecision(0, 1).ForEach(node);
var parentCount = Variable.Observed(variablesUsedByNode.Select(a => a.Length).ToArray(), node).Named("parentCount");
Range parent = new Range(parentCount[node]).Named("parent");
var indices = Variable.Observed(variablesUsedByNode.ToArray(), node, parent).Named("indices");
var shift = Variable.GaussianFromMeanAndPrecision(0, 1).Named("shift");
shift.AddAttribute(new PointEstimate());
using (Variable.ForEach(node))
{
var subArray = Variable.Subarray(x, indices[node]).Named("subArray");
using (Variable.If(parentCount[node] == 1))
{
Variable.ConstrainEqualRandom(subArray[0], Gaussian.FromMeanAndVariance(0, 1));
}
using (Variable.If(parentCount[node] == 2))
{
Variable.ConstrainEqual(subArray[0], subArray[1] + 1);
}
Variable.ConstrainEqualRandom(shift, new Gaussian(1, 2));
}
InferenceEngine engine = new InferenceEngine();
engine.NumberOfIterations = 2;
engine.OptimiseForVariables = new IVariable[] { x, shift };
var xExpected = engine.Infer(x);
//Console.WriteLine(xExpected);
var shiftExpected = engine.Infer(shift);
var threadCount = Variable.Observed(0).Named("threadCount");
Range thread = new Range(threadCount).Named("thread");
var blockCount = Variable.Observed(0).Named("blockCount");
Range gameBlock = new Range(blockCount).Named("block");
var gameCountInBlock = Variable.Observed(default(int[][]), thread, gameBlock).Named("GameCountInBlock");
Range gameInBlock = new Range(gameCountInBlock[thread][gameBlock]).Named("gameInBlock");
var gamesInBlock = Variable.Observed(default(int[][][]), thread, gameBlock, gameInBlock).Named("GamesInBlock");
node.AddAttribute(new ParallelSchedule(gamesInBlock));
threadCount.ObservedValue = schedulePerThread.Length;
blockCount.ObservedValue = (schedulePerThread.Length == 0) ? 0 : schedulePerThread[0].Length;
gameCountInBlock.ObservedValue = Util.ArrayInit(schedulePerThread.Length, t =>
Util.ArrayInit(schedulePerThread[t].Length, b => schedulePerThread[t][b].Length));
gamesInBlock.ObservedValue = schedulePerThread;
var xActual = engine.Infer <IReadOnlyList <Gaussian> >(x);
//Debug.WriteLine(xActual);
Assert.True(xExpected.Equals(xActual));
var shiftActual = engine.Infer <Gaussian>(shift);
Assert.True(shiftExpected.Equals(shiftActual));
xMarginal = xActual;
shiftMarginal = shiftActual;
return(schedulePerThread);
}