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(); }