/// <summary> /// Executes provided closure job on a node in this grid projection. /// </summary> /// <param name="clo">Job to run.</param> /// <param name="arg">Job argument.</param> /// <returns>Job result for this execution.</returns> public Future <TJobRes> Apply <TArg, TJobRes>(IComputeFunc <TArg, TJobRes> clo, TArg arg) { IgniteArgumentCheck.NotNull(clo, "clo"); return(ExecuteClosures0(new ComputeSingleClosureTask <TArg, TJobRes, TJobRes>(), new ComputeFuncJob(clo.ToNonGeneric(), arg), null, false)); }
/// <summary> /// Broadcasts given closure job with passed in argument to all nodes in grid projection. /// Every participating node will return a job result. /// </summary> /// <param name="clo">Job to broadcast to all projection nodes.</param> /// <param name="arg">Job closure argument.</param> /// <returns>Collection of results for this execution.</returns> public Future <ICollection <TJobRes> > Broadcast <TArg, TJobRes>(IComputeFunc <TArg, TJobRes> clo, TArg arg) { IgniteArgumentCheck.NotNull(clo, "clo"); return(ExecuteClosures0(new ComputeMultiClosureTask <object, TJobRes, ICollection <TJobRes> >(1), new ComputeFuncJob(clo.ToNonGeneric(), arg), null, true)); }
/// <summary> /// Executes provided job on a node in this grid projection. The result of the /// job execution is returned from the result closure. /// </summary> /// <param name="clo">Job to execute.</param> /// <returns>Job result for this execution.</returns> public Future <TJobRes> Execute <TJobRes>(IComputeFunc <TJobRes> clo) { IgniteArgumentCheck.NotNull(clo, "clo"); return(ExecuteClosures0(new ComputeSingleClosureTask <object, TJobRes, TJobRes>(), new ComputeOutFuncJob(clo.ToNonGeneric()), null, false)); }
/// <summary> /// Broadcasts given job to all nodes in grid projection. Every participating node will return a job result. /// </summary> /// <param name="clo">Job to broadcast to all projection nodes.</param> /// <returns>Collection of results for this execution.</returns> public IFuture <ICollection <TR> > Broadcast <TR>(IComputeFunc <TR> clo) { IgniteArgumentCheck.NotNull(clo, "clo"); return(ExecuteClosures0(new ComputeMultiClosureTask <object, TR, ICollection <TR> >(1), new ComputeOutFuncJob(clo.ToNonGeneric()), null, true)); }
/// <summary> /// Executes given job on the node where data for provided affinity key is located /// (a.k.a. affinity co-location). /// </summary> /// <param name="cacheName">Name of the cache to use for affinity co-location.</param> /// <param name="affinityKey">Affinity key.</param> /// <param name="clo">Job to execute.</param> /// <returns>Job result for this execution.</returns> /// <typeparam name="TJobRes">Type of job result.</typeparam> public Future <TJobRes> AffinityCall <TJobRes>(string cacheName, object affinityKey, IComputeFunc <TJobRes> clo) { IgniteArgumentCheck.NotNull(clo, "clo"); return(ExecuteClosures0(new ComputeSingleClosureTask <object, TJobRes, TJobRes>(), new ComputeOutFuncJob(clo.ToNonGeneric()), opId: OpAffinity, writeAction: w => WriteAffinity(w, cacheName, affinityKey))); }
/// <summary> /// Executes provided closure job on nodes within this grid projection. A new job is executed for /// every argument in the passed in collection. The number of actual job executions will be /// equal to size of the job arguments collection. /// </summary> /// <param name="clo">Job to run.</param> /// <param name="args">Job arguments.</param> /// <returns>Collection of job results.</returns> public IFuture <ICollection <TR> > Apply <T, TR>(IComputeFunc <T, TR> clo, IEnumerable <T> args) { IgniteArgumentCheck.NotNull(clo, "clo"); IgniteArgumentCheck.NotNull(clo, "clo"); var jobs = new List <IComputeJob>(GetCountOrZero(args)); var func = clo.ToNonGeneric(); foreach (T arg in args) { jobs.Add(new ComputeFuncJob(func, arg)); } return(ExecuteClosures0(new ComputeMultiClosureTask <T, TR, ICollection <TR> >(jobs.Count), null, jobs, false)); }
/// <summary> /// Executes provided closure job on nodes within this grid projection. A new job is executed for /// every argument in the passed in collection. The number of actual job executions will be /// equal to size of the job arguments collection. The returned job results will be reduced /// into an individual result by provided reducer. /// </summary> /// <param name="clo">Job to run.</param> /// <param name="args">Job arguments.</param> /// <param name="rdc">Reducer to reduce all job results into one individual return value.</param> /// <returns>Reduced job result for this execution.</returns> public Future <TReduceRes> Apply <TArg, TJobRes, TReduceRes>(IComputeFunc <TArg, TJobRes> clo, IEnumerable <TArg> args, IComputeReducer <TJobRes, TReduceRes> rdc) { IgniteArgumentCheck.NotNull(clo, "clo"); IgniteArgumentCheck.NotNull(clo, "clo"); IgniteArgumentCheck.NotNull(clo, "clo"); ICollection <IComputeJob> jobs = new List <IComputeJob>(GetCountOrZero(args)); var func = clo.ToNonGeneric(); foreach (TArg arg in args) { jobs.Add(new ComputeFuncJob(func, arg)); } return(ExecuteClosures0(new ComputeReducingClosureTask <TArg, TJobRes, TReduceRes>(rdc), null, jobs, false)); }