public NetworkChannel(Group ctx, Place networkFrom, Place networkTo) : base(ctx)
{
NetworkFrom = networkFrom;
NetworkTo = networkTo;
RegisterNode(nameof(SendT));
RegisterNode(nameof(SendR));
RegisterNode(nameof(ReceiveT));
RegisterNode(nameof(ReceiveR));
RegisterNode(nameof(ChannelS));
RegisterNode(nameof(ChannelR));
SendT.Action <OneToOne <Package> >()
.In <Package>(NetworkFrom)
.Out <Package>(ChannelS);
SendR.Action <OneToOne <Package> >()
.In <Package>(ChannelS)
.Out <Package>(NetworkTo);
ReceiveT.Action <OneToOne <Package> >()
.In <Package>(NetworkTo)
.Out <Package>(ChannelR);
ReceiveR.Action <OneToOne <Package> >()
.In <Package>(ChannelR)
.Out <Package>(NetworkFrom);
}
public SimpleSubgroup()
{
Move.Action <OneToOne <Mark> >()
.In <Mark>(A)
.Out <Mark>(B);
Marks = Extensions.At(A, MarkType.Create <Mark>());
}
public Sample()
{
Summ.Action <Add>()
.In <Mark>(A)
.In <Mark>(B)
.Out <Mark>(C);
Marks = Extensions.At(A, MarkType.Create <Mark>(5))
.At(B, MarkType.Create <Mark>(6));
}
public GustafsonLaw(float time, int processors,
Fraction seialFraction)
{
var serialTime = Fraction.FromDoubleRounded(time) * seialFraction;
var parallelTime = Fraction.FromDoubleRounded(time) - serialTime;
var timeStep = Extensions.GreatestCommonDivisor(serialTime, parallelTime);
var linearTasks = serialTime / timeStep;
var parallelTasks = processors * (parallelTime / timeStep);
Extensions.InitListOfNodes(this, nameof(ParallelBalancedWorkers), processors);
//Marks are representing tasks
for (var i = 0; i < linearTasks; i++)
{
Extensions.At(LinearTasks, MarkType.Create <Mark>());
}
for (var i = 0; i < parallelTasks; i++)
{
Extensions.At(ParallelTasks, MarkType.Create <Mark>());
}
//After all is done we want to check that no tasks are left behind
DoneChecker.Action <GenerateOne <Mark> >()
.In <Mark>(LinearTasks, Link.Count.None)
.In <Mark>(ParallelTasks, Link.Count.None)
.Out <Mark>(Done);
//And we make sure DoneChecker would wast as low time as possible
DoneChecker.TimeScale = timeStep;
LinearWorker.Action <OneToOne <Mark> >()
.In <Mark>(LinearTasks)
.Out <Mark>(DoneTasks);
LinearWorker.TimeScale = timeStep;
//Note that ParallelBalancedWorkers are empty when parallelTasks < processors
for (var i = 0; i < processors; i++)
{
var cw = ParallelBalancedWorkers[i];
//Await Linear tasks, run at one step of the time
cw.Action <OneToOne <Mark> >()
.In <Mark>(LinearTasks, Link.Count.None)
.In <Mark>(ParallelTasks)
.Out <Mark>(DoneTasks);
cw.TimeScale = timeStep;
}
Descriptor.Refresh();
}
private void transitionState(Storage state, Transition transition, TTrigger trigger, TMemory memory)
{
var currentState = state.state;
var nextState = transition.Next;
state.state = transition.Next;
if (transition.Action != null)
{
transition.Action(currentState, trigger, nextState, memory);
}
if (onAnyTransitionAction != null)
{
onAnyTransitionAction(currentState, trigger, nextState, memory);
}
}
public SimpleTwoHostNetwork()
{
DecomposeA.Action <Decompose>()
.In <Message>(ServiceA)
.Out <SimpleNetwork.Package>(FromA.NetworkFrom);
ComposeB.Action <Compose>()
.In <SimpleNetwork.Package>(FromA.NetworkTo, Link.Count.All)
.Out <Message>(ServiceB);
DecomposeB.Action <Decompose>()
.In <Message>(ServiceB)
.Out <SimpleNetwork.Package>(FromB.NetworkFrom, Link.Count.All);
ComposeA.Action <Compose>()
.In <SimpleNetwork.Package>(FromB.NetworkTo, Link.Count.All)
.Out <Message>(ServiceA);
Marks = At(ServiceA, MarkType.Create <Message>(128))
.At(ServiceB, MarkType.Create <Message>(256))
.At(ServiceB, MarkType.Create <Message>(128))
;
}
public AmdahlLaw(int tasks, int processors,
Fraction parallelPart)
{
//There are two kinds of tasks: linear and parallel
var parallelTasks = (tasks * parallelPart).ToInt32();
var linearTasks = tasks - parallelTasks;
// From parallel tasks some are balanced between CPUs and have same time scale as linear tasks, while some tasks are speed up by spreading between nodes
var squizeTasks = parallelTasks % processors;
var parallelBalancedTasks = parallelTasks - squizeTasks;
//There are #processors represented via Workers, and one worker for linear tasks
Extensions.InitListOfNodes(this, nameof(ParallelBalancedWorkers), processors);
Extensions.InitListOfNodes(this, nameof(SquizeParallelWorkers), processors);
//Marks are representing tasks
for (var i = 0; i < linearTasks; i++)
{
Extensions.At(LinearTasks, MarkType.Create <Mark>());
}
for (var i = 0; i < parallelBalancedTasks; i++)
{
Extensions.At(ParallelBalancedTasks, MarkType.Create <Mark>());
}
for (var i = 0; i < squizeTasks; i++)
{
Extensions.At(SquizeParallelTasks, MarkType.Create <Mark>());
}
//After all is done we want to check that no tasks are left behind
DoneChecker.Action <GenerateOne <Mark> >()
.In <Mark>(LinearTasks, Link.Count.None)
.In <Mark>(ParallelBalancedTasks, Link.Count.None)
.In <Mark>(SquizeParallelTasks, Link.Count.None)
.Out <Mark>(Done);
//And we make sure DoneChecker would wast as low time as possible
DoneChecker.TimeScale = new Fraction(1, processors);
LinearWorker.Action <OneToOne <Mark> >()
.In <Mark>(LinearTasks)
.Out <Mark>(DoneTasks);
//Note that ParallelBalancedWorkers are empty when parallelTasks < processors
for (var i = 0; i < processors; i++)
{
var cw = ParallelBalancedWorkers[i];
//Await Linear tasks, run at one step of the time
cw.Action <OneToOne <Mark> >()
.In <Mark>(LinearTasks, Link.Count.None)
.In <Mark>(ParallelBalancedTasks)
.Out <Mark>(DoneTasks);
}
// Fire squize tasks when balanced and linear tasks are done
var squizeTimeScale = new Fraction(squizeTasks, processors)
+ LinearWorker.TimeScale * linearTasks
+ ParallelBalancedWorkers.First().TimeScale *(parallelBalancedTasks / processors);
for (var i = 0; i < processors; i++)
{
var cw = SquizeParallelWorkers[i];
//Await Linear and Equally Balanced tasks, run at reduced time step
cw.Action <OneToOne <Mark> >()
.In <Mark>(LinearTasks, Link.Count.None)
.In <Mark>(ParallelBalancedTasks, Link.Count.None)
.In <Mark>(SquizeParallelTasks)
.Out <Mark>(DoneTasks);
cw.TimeScale = squizeTimeScale;
}
Descriptor.Refresh();
}
