Load Balance didn't work

[kentbill]

Hello, everyone!

I have a scenario where I need to allocate jobs to resources and determine the number of jobs in each resource.
I defined a class Allocation that generates a list of Allocation objects by taking the Cartesian product of the jobs and resources. Allocation has a planning variable allocatedQty, which is the quantity of jobs a resource should handle. This variable's value (which I define as quantityRange) ranges from 0 to the quantity of jobs. The code snippet for the Allocation class is as follows:

@PlanningEntity
public class Allocation extends AbstractPersistable {

    @PlanningId
    private Long id;

    private Job job;

    private Resource resource;

    @PlanningVariable(valueRangeProviderRefs = {"qtyRange"})
    private Integer allocatedQty;


    @ValueRangeProvider(id = "qtyRange")
    private List<Integer> quantityRange;


    public Allocation() {
    }

    public Allocation(Long id, String code, Job job, Resource resource) {
        this.id = id;
        this.job = job;
        this.resource = resource;
        this.createQuantityRange();
    }

   // create the quantity range
    private void createQuantityRange() {
        int lowBound = 0;
        int upBound = this.job.getQuantity();
        this.quantityRange = IntStream.rangeClosed(lowBound, upBound)
                .boxed()
                .collect(Collectors.toList());
    }

.
.
.
}

I have only two constraints: "Ensure that the sum of the quantities of a job allocated to each resource equals the quantity of jobs" - method name "jobQuantityAlignment".
And another constraint is "Make the quantities of a job allocated to each resource as balanced as possible" - method name "resourceQuantityBalance".
The code for these two constraints is as follows:

Constraint jobQuantityAlignment(ConstraintFactory constraintFactory) {
        return constraintFactory.forEach(Allocation.class)
                .groupBy(Allocation::getOrderItem, sum(Allocation::getQuantity))
                .filter((orderItem, assignedQuantity) -> assignedQuantity != orderItem.getQuantity())
                .penalize(HardMediumSoftBigDecimalScore.ONE_MEDIUM,
                        (orderItem, assignedQuantity) -> Math.abs(assignedQuantity - orderItem.getQuantity()))
                .asConstraint("Align job quantity");
    }


Constraint resourceQuantityBalance(ConstraintFactory constraintFactory) {
        return constraintFactory.forEach(Allocation.class)
                .groupBy(Allocation::getResource, ConstraintCollectors.sum(Allocation::getAllocatedQty))
                .complement(Resource.class, e -> 0) 
                .groupBy(ConstraintCollectors.loadBalance((resource, allocatedQty) -> resource,
                        (resource, allocatedQty) -> allocatedQty))
                .penalizeBigDecimal(HardMediumSoftBigDecimalScore.ONE_SOFT, LoadBalance::unfairness)
                .asConstraint("Balance resource job allocation");
 }

For instance, there are 2 jobs, Job A with quantity 10, and Job B with quantity 20.
And there are 3 resources: Resource 1, Resource 2, Resource 3, and Resource 4.

For Job A, the resources that can be allocated are Resource 1 and Resource 2.
For Job B, the available resources are Resource 3 and Resource 4. This will result in four allocations:

Allocation A1 - from Job A and Resource 1, with a quantity range of 0 to 10
Allocation A2 - from Job A and Resource 2, with a quantity range of 0 to 10
Allocation B3 - from Job B and Resource 3, with a quantity range of 0 to 20
Allocation B4 - from Job B and Resource 4, with a quantity range of 0 to 20

My desired solution is:

Allocation A1: 5
Allocation A2: 5
Allocation B3: 10
Allocation B4: 10

But now, the solution is:

Allocation A1: 10
Allocation A2: 0
Allocation B3: 20
Allocation B4: 0

The log looks like this:

23:46:39.459 [l-3-thread-1] DEBUG     LS step (72574), time spent (20113), score (0hard/0medium/-37.4166soft),     best score (0hard/0medium/-37.4166soft), accepted/selected move count (1/12), picked move (Job-116041448087749974->Mold-7879:0 {0} <-> Job-116041448087749974->Mold-7878:20 {20}).
23:46:39.459 [l-3-thread-1] TRACE         Move index (0), score (0hard/-6medium/-36.2146soft), accepted (false), move (Job-116041448087749976->Mold-7884:0 {0 -> 6}).
23:46:39.459 [l-3-thread-1] TRACE         Move index (1), score (0hard/-15medium/-36.0122soft), accepted (false), move (Job-116041448087749974->Mold-7879:20 {20 -> 5}).
23:46:39.459 [l-3-thread-1] TRACE         Move index (2), score (0hard/-60medium/-37.4166soft), accepted (false), move (Job-116041448087749976->Mold-7885:30 {30} <-> Job-116041448087749975->Mold-7881:0 {0}).
23:46:39.459 [l-3-thread-1] TRACE         Move index (3), score (0hard/-16medium/-36.1109soft), accepted (false), move (Job-116041448087749974->Mold-7879:20 {20 -> 4}).
23:46:39.459 [l-3-thread-1] TRACE         Move index (4), score (0hard/-24medium/-37.7359soft), accepted (false), move (Job-116041448087749975->Mold-7881:0 {0 -> 24}).
23:46:39.459 [l-3-thread-1] TRACE         Move (Job-116041448087749974->Mold-7878:0 {0 -> 0}) filtered out by a selection filter (Doable moves only).
23:46:39.459 [l-3-thread-1] TRACE         Move index (5), score (0hard/-12medium/-35.8608soft), accepted (false), move (Job-116041448087749974->Mold-7878:0 {0 -> 12}).
23:46:39.459 [l-3-thread-1] TRACE         Move (Job-116041448087749974->Mold-7878:0 {0} <-> Job-116041448087749975->Mold-7881:0 {0}) filtered out by a selection filter (Doable moves only).
23:46:39.459 [l-3-thread-1] TRACE         Move index (6), score (0hard/0medium/-37.4166soft), accepted (true), move (Job-116041448087749976->Mold-7885:30 {30} <-> Job-116041448087749976->Mold-7884:0 {0}).
23:46:39.459 [l-3-thread-1] DEBUG     LS step (72575), time spent (20113), score (0hard/0medium/-37.4166soft),     best score (0hard/0medium/-37.4166soft), accepted/selected move count (1/7), picked move (Job-116041448087749976->Mold-7885:30 {30} <-> Job-116041448087749976->Mold-7884:0 {0}).
23:46:39.459 [l-3-thread-1] TRACE         Move index (0), score (0hard/-28medium/-39.0640soft), accepted (false), move (Job-116041448087749975->Mold-7880:0 {0 -> 28}).
23:46:39.459 [l-3-thread-1] TRACE         Move index (1), score (0hard/-12medium/-32.3419soft), accepted (false), move (Job-116041448087749976->Mold-7884:30 {30 -> 18}).
23:46:39.459 [l-3-thread-1] TRACE         Move index (2), score (0hard/-2medium/-36.9256soft), accepted (false), move (Job-116041448087749976->Mold-7886:0 {0 -> 2}).
23:46:39.459 [l-3-thread-1] TRACE         Move index (3), score (0hard/-17medium/-36.2336soft), accepted (false), move (Job-116041448087749975->Mold-7880:0 {0 -> 17}).
23:46:39.461 [l-3-thread-1] TRACE         Move index (4), score (0hard/-5medium/-34.9553soft), accepted (false), move (Job-116041448087749975->Mold-7882:30 {30 -> 25}).
23:46:39.461 [l-3-thread-1] DEBUG     LS step (72576), time spent (20115), score (0hard/-2medium/-36.9256soft),     best score (0hard/0medium/-37.4166soft), accepted/selected move count (0/5), picked move (Job-116041448087749976->Mold-7886:0 {0 -> 2}).

Why is this? The resourceQuantityBalance score has been consistently difficult to optimize.

Thanks in advance!