Package org.apache.ignite.spi.loadbalancing

## Interface LoadBalancingSpi

- All Superinterfaces:
    `IgniteSpi`
  All Known Implementing Classes:
    `AdaptiveLoadBalancingSpi`, `RoundRobinLoadBalancingSpi`, `WeightedRandomLoadBalancingSpi`

      public interface LoadBalancingSpi
      extends IgniteSpi

  Load balancing SPI provides the next best balanced node for job execution. This SPI is used either implicitly or explicitly whenever a job gets mapped to a node during `ComputeTask.map(List, Object)` invocation.

  # Coding Examples

  If you are using `ComputeTaskSplitAdapter` then load balancing logic is transparent to your code and is handled automatically by the adapter. Here is an example of how your task could look:

       public class MyFooBarTask extends ComputeTaskSplitAdapter<Object,Object> {
          @Override
          protected Collection<? extends ComputeJob> split(int gridSize, Object arg) throws IgniteCheckedException {
              List<MyFooBarJob> jobs = new ArrayList<MyFooBarJob>(gridSize);

              for (int i = 0; i < gridSize; i++) {
                  jobs.add(new MyFooBarJob(arg));
              }

              // Node assignment via load balancer
              // happens automatically.
              return jobs;
          }
          ...
       }

  If you need more fine-grained control over how some jobs within task get mapped to a node and use, for example, affinity load balancing for some other jobs within task, then you should use `ComputeTaskAdapter`. Here is an example of how your task could look. Note that in this case we manually inject load balancer and use it to pick the best node. Doing it in such way would allow user to map some jobs manually and for others use load balancer.

       public class MyFooBarTask extends ComputeTaskAdapter<String,String> {
          // Inject load balancer.
          @LoadBalancerResource
          ComputeLoadBalancer balancer;

          // Map jobs to grid nodes.
          public Map<? extends ComputeJob, ClusterNode> map(List<ClusterNode> subgrid, String arg) throws IgniteCheckedException {
              Map<MyFooBarJob, ClusterNode> jobs = new HashMap<MyFooBarJob, ClusterNode>(subgrid.size());

              // In more complex cases, you can actually do
              // more complicated assignments of jobs to nodes.
              for (int i = 0; i < subgrid.size(); i++) {
                  // Pick the next best balanced node for the job.
                  ComputeJob myJob = new MyFooBarJob(arg);

                  jobs.put(myJob, balancer.getBalancedNode(myJob, null));
              }

              return jobs;
          }

          // Aggregate results into one compound result.
          public String reduce(List<ComputeJobResult> results) throws IgniteCheckedException {
              // For the purpose of this example we simply
              // concatenate string representation of every
              // job result
              StringBuilder buf = new StringBuilder();

              for (ComputeJobResult res : results) {
                  // Append string representation of result
                  // returned by every job.
                  buf.append(res.getData().toString());
              }

              return buf.toString();
          }
       }

  Ignite comes with the following load balancing SPI implementations out of the box:

  - `RoundRobinLoadBalancingSpi` - default
  - `AdaptiveLoadBalancingSpi`
  - `WeightedRandomLoadBalancingSpi`
  NOTE: this SPI (i.e. methods in this interface) should never be used directly. SPIs provide internal view on the subsystem and is used internally by Ignite kernal. In rare use cases when access to a specific implementation of this SPI is required - an instance of this SPI can be obtained via `Ignite.configuration()` method to check its configuration properties or call other non-SPI methods. Note again that calling methods from this interface on the obtained instance can lead to undefined behavior and explicitly not supported.

- - ### Method Summary

    All Methods Instance Methods Abstract Methods
    Modifier and Type | Method | Description
    --- | --- | ---
    `ClusterNode` | `getBalancedNode​(ComputeTaskSession ses, List<ClusterNode> top, ComputeJob job)` | Gets balanced node for specified job within given task session.

    - ### Methods inherited from interface org.apache.ignite.spi.IgniteSpi

      `getName, getNodeAttributes, onClientDisconnected, onClientReconnected, onContextDestroyed, onContextInitialized, spiStart, spiStop`

- - ### Method Detail

    - #### getBalancedNode

          ClusterNode getBalancedNode​(ComputeTaskSession ses,
                                      List<ClusterNode> top,
                                      ComputeJob job)
                               throws IgniteException

      Gets balanced node for specified job within given task session.
      Parameters:
        `ses` - Grid task session for currently executing task.
        `top` - Topology of task nodes from which to pick the best balanced node for given job.
        `job` - Job for which to pick the best balanced node.
      Returns:
        Best balanced node for the given job within given task session.
      Throws:
        `IgniteException` - If failed to get next balanced node.