Java ForkJoinPool 未利用所有 CPU 核心

Question

我正在虚拟墙的节点上运行以下代码。该节点拥有 32 个 Intel Xeon E7/E5 内核和 128GB RAM。监控 CPU 使用率表明该节点远未达到满负荷运行。由于节点大小的原因，该问题与大多数 fork-join 问题不同。有时，节点的多个核心上的 CPU 负载超过 20%，显示出并行性的迹象，但我似乎无法让它使用更多资源。

提供一些背景信息；该问题是 111 个节点的图中的最大化问题 (Parcs/parken)。每个公园内都隐藏着许多鸡蛋。随着每一秒的过去，这个数字呈指数下降。目标是在时间到期之前获得尽可能多的鸡蛋。 “opl”是我使用贪婪算法找到的解决方案，因此为了缩小我们的递归树，我只允许当我们发现最多 5 个鸡蛋比我们的贪婪算法同时发现的鸡蛋少时才允许递归。

我熟悉(多)线程，但距离专家还很远。我以前没有使用过很多ForkJoinPools。我还尝试将 ForkJoinPool 参数设置为 16/32，但没有成功。

Example of current core-load

主要:

Algoritmes.AlgoritmeRecursive.run(new AlgoritmeRecursive(parken, tabel, opl, 22, 1000, 0, 0)));

类(class):

public static class AlgoritmeRecursive extends RecursiveTask<Double> {
    private ArrayList<Park> parken = new ArrayList<Park>();
    private double[][] afstandenTabel;
    private double[][] oplossing;
    private int startpark;
    private double duur;
    private double eieren;
    private int time;

    AlgoritmeRecursive(ArrayList<Park> parken, double[][] afstandenTabel, double[][] oplossing, int startpark, double duur, double eieren, int time) {
        for (Park p : parken) {
            this.parken.add(new Park(p));
        }
        this.afstandenTabel = afstandenTabel;
        this.oplossing = oplossing;
        this.startpark = startpark;
        this.duur = duur;
        this.eieren = eieren;
        this.time = time;
    }

    public static double run(AlgoritmeRecursive ar) {
        ForkJoinPool pool= new ForkJoinPool();
        return pool.invoke(ar);
    }

    protected Double compute() {
        if (duur < 1.0) return eieren;

        double gevonden = 0;

        /* startpark zoeken adhv gegeven naam */
        for (Park p : parken) {
            if (p.getId() == startpark) {
                gevonden = p.verwachtAantalEieren(40, 0);
                p.updateEggs(p.getEggs() * exp((-1.0/10800.0) * ((p.getStartEggs()/20.0) + 40.0)));
            }
            else {
                p.updateEggs(p.getEggs() * exp((-1.0/10800.0) * (p.getStartEggs()/20.0)));
            }
        }
        double score = eieren;
        for (Park p : parken) {
            if (p.getId() == startpark && eieren >= (oplossing[1000-(int)duur][1] - 5)) {
                AlgoritmeRecursive ar = new AlgoritmeRecursive(parken, afstandenTabel, oplossing, startpark, duur-1, eieren + gevonden, time+1);
                ar.fork();
                double res = ar.join();
                if(res > score) score = res;
            }
            else if (duur-afstandenTabel[startpark][p.getId()] > 60.0 && time > 120.0 && eieren >= oplossing[1000-(int)duur][1] && gevonden < p.verwachtAantalEieren(40,afstandenTabel[startpark][p.getId()])){
                AlgoritmeRecursive ar = new AlgoritmeRecursive(parken, afstandenTabel, oplossing, p.getId(), duur-afstandenTabel[startpark][p.getId()], eieren, 0);
                for (Park p2 : ar.parken) {
                    p2.updateEggs(p2.getEggs() * exp((-1.0/10800.0) * (p2.getStartEggs()/20.0) * (afstandenTabel[startpark][p.getId()]-1)));
                }
                ar.fork();
                double res = ar.join();
                if(res > score) score = res;
            }
        }
        return score;
    }
    public double exp(double x) {
          x = 1d + x / 256d;
          x *= x; x *= x; x *= x; x *= x;
          x *= x; x *= x; x *= x; x *= x;
          return x;
    }
}

Answer 1

我自己对此也不是很熟悉，但是对 ar.join() 的调用是否会让您的 RecursiveTask 等待子任务完成？如果是这种情况，您的其他任务将不会在前一个任务运行完成之前开始。

您可以尝试将正在运行的任务存储在列表中，然后再将它们加入。这有望确保所有子任务在等待之前就开始运行。

类似这样的东西(修改compute中的第二个循环):

List<AlgoritmeRecursive> tasks = new ArrayList<>();

for (Park p : parken) {
    if (p.getId() == startpark && eieren >= (oplossing[1000-(int)duur][1] - 5)) {

        AlgoritmeRecursive ar = new AlgoritmeRecursive(parken, afstandenTabel, oplossing, startpark, duur-1, eieren + gevonden, time+1);
        ar.fork();
        tasks.add(ar); // Adding the running task to the list.

    } else if (duur-afstandenTabel[startpark][p.getId()] > 60.0 && time > 120.0 && eieren >= oplossing[1000-(int)duur][1] && gevonden < p.verwachtAantalEieren(40,afstandenTabel[startpark][p.getId()])){

        AlgoritmeRecursive ar = new AlgoritmeRecursive(parken, afstandenTabel, oplossing, p.getId(), duur-afstandenTabel[startpark][p.getId()], eieren, 0);
        for (Park p2 : ar.parken) {
            p2.updateEggs(p2.getEggs() * exp((-1.0/10800.0) * (p2.getStartEggs()/20.0) * (afstandenTabel[startpark][p.getId()]-1)));
        }
        ar.fork();
        tasks.add(ar); // Adding the running task to the list.

    }
}

double score = eieren;
for(AlgoritmeRecursive task : tasks) {
    double res = ar.join();
    if(res > score) score = res;
}

return score;