为什么在大约10个内核之后添加内核会减慢我的java程序？

Question

My program uses fork/join as shown below to run thousands of tasks:

private static class Generator extends RecursiveTask<Long> {
    final MyHelper mol;
    final static SatChecker satCheck = new SatChecker();

    public Generator(final MyHelper mol) {
        super();
        this.mol = mol;
    }

    @Override
    protected Long compute() {
        long count = 0;
        try {
            if (mol.isComplete(satCheck)) {
                count = 1;
            }
            ArrayList<MyHelper> molList = mol.extend();
            List<Generator> tasks = new ArrayList<>();
            for (final MyHelper child : molList) {
                tasks.add(new Generator(child)); 
            }
            for(final Generator task : invokeAll(tasks)) { 
                count += task.join(); 
            }
        } catch (Exception e){
            e.printStackTrace();
        }       
        return count;           
    }
}

My program makes heavy use of a third party library for isComplete and extend methods. The extend method also uses a native library. As far as the MyHelper class is concerned, there is no shared variable or synchronization between the tasks.

I use the taskset command from linux to restrict the number of cores used by my application. I get the best speed by using around 10 cores (say around 60 seconds). It means that using more than 10 cores results in slowing down the application, such that 16 cores finishes in the same time as 6 cores (around 90 seconds).

I am more confused because the selected cores are 100% busy (except for garbage collection every now and then). Does anyone know what could cause such a slow down? And where should I look to solve this problem?

PS: I have made also implementations in Scala/akka and using ThreadPoolExecutor, but with similar results (although slower than fork/join)

PPS: My guess is that down deep in MyHelper or SatCheck, someone crosses the memory barrier (poisoning the cache). But how can I find that and fix or go about it?

Answer 1

There might be an overload due to assigning threads/tasks to the different cores. Also, are you sure that your program is entirely parallelizable? Indeed, some program cannot always use 100% efficiently all the cpus available and the time taken to dispatch the tasks might slow down the program more than it helps it.

Answer 2

I think that you should use a threshold on the size of your molList (or mol ) variable to avoid forking on too small sets of data.

I'd been playing a bit with fork/join just to understand framework and my first examples did not take the threshold into consideration. Obviously i got awful perfomances. Fixing a proper limit on size of problem did the trick.

Finding the right value for the threshold requires you spend a bit of time trying different values and see how performances changes.

So, put an if at the very beginning of the compute method like this:

@Override
protected Long compute() {
    if (mol.getSize() < THRESHOLD) //getSize or whatever gives you size of problem
         return noForkJoinCompute(mol); //noForkJoinCompute gives you count without FJ

    long count = 0;
    try {
        if (mol.isComplete(satCheck)) {
            count = 1;
        }
    ...