Load balancer is used for finding the best balanced node according
to load balancing policy. Internally load balancer will
query the
GridLoadBalancingSpito get the balanced node.
Load balancer can be used explicitly from inside
GridComputeTask#map(List,Object)method when you implement
GridComputeTask interface directly or use
GridComputeTaskAdapter. If you use
GridComputeTaskSplitAdapter then
load balancer is accessed implicitly by the adapter so you don't have
to use it directly in your logic.
Coding Examples
If you are using
GridComputeTaskSplitAdapter then load balancing logic
is transparent to your code and is handled automatically by the adapter.
Here is an example of how your task will look:
public class MyFooBarTask extends GridComputeTaskSplitAdapter<String> {
@Override
protected Collection<? extends GridComputeJob> split(int gridSize, String 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 affinity load balancing for some other jobs within task, then you should use
GridComputeTaskAdapter. Here is an example of how your task will 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 GridComputeTaskAdapter<String, String> {
// Inject load balancer.
@GridLoadBalancerResource
GridComputeLoadBalancer balancer;
// Map jobs to grid nodes.
public Map<? extends GridComputeJob, 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.
GridComputeJob myJob = new MyFooBarJob(arg);
jobs.put(myJob, balancer.getBalancedNode(myJob, null));
}
return jobs;
}
// Aggregate results into one compound result.
public String reduce(List<GridComputeJobResult> results) throws GridException {
// For the purpose of this example we simply
// concatenate string representation of every
// job result
StringBuilder buf = new StringBuilder();
for (GridComputeJobResult res : results) {
// Append string representation of result
// returned by every job.
buf.append(res.getData().toString());
}
return buf.toString();
}
}