org.gridgain.grid.spi.loadbalancing
Interface GridLoadBalancingSpi

All Superinterfaces:

GridSpi

All Known Implementing Classes:

GridAdaptiveLoadBalancingSpi, GridAffinityLoadBalancingSpi, GridCoherenceLoadBalancingSpi, GridRoundRobinLoadBalancingSpi, GridWeightedRandomLoadBalancingSpi

@Apache20LicenseCompatible
public interface GridLoadBalancingSpi
extends GridSpi

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 GridTask.map(List, Object) invocation.

Coding Examples

If you are using GridTaskSplitAdapter 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 GridTaskSplitAdapter<Object,Object> {
    @Override
    protected Collection<? extends GridJob> split(int gridSize, Object arg) throws GridException {
        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 GridTaskAdapter. 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 GridTaskAdapter<String,String> {
    // Inject load balancer.
    @GridLoadBalancerResource
    GridLoadBalancer balancer;

    // Map jobs to grid nodes.
    public Map<? extends GridJob, GridNode> map(List<GridNode> subgrid, String arg) throws GridException {
        Map<MyFooBarJob, GridNode> jobs = new HashMap<MyFooBarJob, GridNode>(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.
            jobs.put(new MyFooBarJob(arg), balancer.getBalancedNode())
        }

        return jobs;
    }

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

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

        return buf.toString();
    }
 } 
 

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

• GridAffinityLoadBalancingSpi
• GridCoherenceLoadBalancingSpi
• GridAdaptiveLoadBalancingSpi
• GridWeightedRandomLoadBalancingSpi
• GridRoundRobinLoadBalancingSpi

See Also:

Documentation
Email Support
Online Forums
Issue Tracking

Author: 2005-2008 Copyright © GridGain Systems. All Rights Reserved. ver. 2.1.0

	Nikita Ivanov, GridGain Systems nivanov@gridgain.com
	Dmitriy Setrakyan, GridGain Systems dsetrakyan@gridgain.com
	Alexander Magdenko, GridGain Systems amagdenko@gridgain.com
	Boris Suchodoev, GridGain Systems bsuchodoev@gridgain.com
	Denis Kharlamov, GridGain Systems dkharlamov@gridgain.com
	close

Method Summary

GridNode

getBalancedNode(GridTaskSession ses, List<GridNode> top, GridJob job) Gets balanced node for specified job within given task session.

Methods inherited from interface org.gridgain.grid.spi.GridSpi

getName, getNodeAttributes, onContextDestroyed, onContextInitialized, spiStart, spiStop

Method Detail

getBalancedNode

GridNode getBalancedNode(GridTaskSession ses,
                         List<GridNode> top,
                         GridJob job)
                         throws GridException

Gets balanced node for specified job within given task session.

Throws:

GridException - If failed to get next balanced node.

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.