Java 为什么我的Spark驱动程序这么慢？

我的问题是：我有一个模型引擎，它接受一个参数配置列表，并计算一个对应于该配置的度量的双精度值。我有六个参数，每个参数都可以根据列表而变化。我想通过蛮力找到最佳参数配置，考虑将为输出度量生成更高值的组合。由于我在学习Spark，我意识到使用笛卡尔积运算，我可以轻松地生成组合，并拆分RDD以并行处理。所以，我提出了这个驱动程序：

public static void main(String[] args) {

    String scriptName = "model.mry";

    String scriptStr = null;

    try {
        scriptStr = new String(Files.readAllBytes(Paths.get(scriptName)));
    } catch (IOException ex) {
        Logger.getLogger(BruteForceDriver.class.getName()).log(Level.SEVERE, null, ex);
        System.exit(1);
    }

    final String script = scriptStr;

    SparkConf conf = new SparkConf()
            .setAppName("wordCount")
            .setSparkHome("/home/danilo/bin/spark-2.2.0-bin-hadoop2.7")
            .setJars(new String[]{"/home/danilo/NetBeansProjects/SparkHello1/target/SparkHello1-1.0.jar",
        "/home/danilo/.m2/repository/org/modcs/mercury/4.7/mercury-4.7.jar"})
            .setMaster("spark://danilo-desktop:7077");

    String baseDir = "/home/danilo/NetBeansProjects/SimulationOptimization/workspace/";

    JavaSparkContext sc = new JavaSparkContext(conf);

    final int NUM_SERVICES = 6;
    final int QTD = 3;

    JavaRDD<Service>[] providers = new JavaRDD[NUM_SERVICES];

    for (int i = 1; i <= NUM_SERVICES; i++) {
        providers[i - 1] = sc.textFile(baseDir + "provider"
                + i
                + ".mat")
                .filter((t1) -> !t1.contains("#") && !t1.trim().isEmpty())
                .map(Service.createParser("" + i))
                .zipWithIndex().filter((t1) -> {
                    return t1._2 < QTD;
                }).keys();
    }

    JavaPairRDD c = null;
    JavaRDD<Service> p = providers[0];

    for (int i = 1; i < NUM_SERVICES; i++) {
        if (c == null) {
            c = p.cartesian(providers[i]);
        } else {
            c = c.cartesian(providers[i]);
        }
    }

    JavaRDD<List<Service>> cartesian = c.map(new FlattenTuple<>());

    final Broadcast<ModelEvaluator> model = sc.broadcast(new ModelEvaluator(script));

    JavaPairRDD<Double, List<Service>> results = cartesian.mapToPair(
            (t) -> {
                try {
                    double val = model.value().evaluateModel(t);
                    System.out.println(val);
                    return new Tuple2<>(val, t);
                } catch (Exception ex) {
                    return null;
                }
            }
    );

    results.sortByKey().collect().forEach((t) -> {
        System.out.println(t._1 + ", " + t._2);
    });

    sc.close();
}

publicstaticvoidmain（字符串[]args）{
字符串scriptName=“model.mry”；
字符串scriptStr=null；
试一试{
scriptStr=新字符串（Files.readAllBytes（path.get（scriptName））；
}捕获（IOEX异常）{
Logger.getLogger（BruteForceDriver.class.getName（））.log（Level.SEVERE，null，ex）；
系统出口（1）；
}
最后一个字符串脚本=scriptStr；
SparkConf conf=新的SparkConf（）
.setAppName（“字数”）
.setSparkHome（“/home/danilo/bin/spark-2.2.0-bin-hadoop2.7”）
.setJars（新字符串[]{”/home/danilo/NetBeansProjects/SparkHello1/target/SparkHello1-1.0.jar“，
“/home/danilo/.m2/repository/org/modcs/mercury/4.7/mercury-4.7.jar”}）
.setMaster（“spark://danilo-desktop:7077");
字符串baseDir=“/home/danilo/NetBeansProjects/SimulationOptimization/workspace/”；
JavaSparkContext sc=新的JavaSparkContext（conf）；
最终int NUM_服务=6；
最终int QTD=3；
JavaRDD[]providers=新的JavaRDD[NUM_服务]；
for（int i=1；i！t1.contains（“#”）&&！t1.trim（）.isEmpty（））
.map（Service.createParser（“+i））
.zipWithIndex（）.filter（（t1）->{
返回t1.2{
试一试{
double val=model.value（）.evaluateModel（t）；
系统输出打印项次（val）；
返回新的Tuple2（val，t）；
}捕获（例外情况除外）{
返回null；
}
}
);
results.sortByKey（）.collect（）.forEach（（t）->{
系统输出println（t.'u 1+，“+t.'u 2）；
});
sc.close（）；
}

“QTD”变量允许我控制每个参数变化的间隔大小。对于QTD=3，我将有3^6=729个组合。问题是计算所有这些组合需要很长时间。我编写了一个只使用普通Java线程的实现，运行时间约为40秒。使用我的Spark驱动程序，运行时间超过6分钟。为什么我的Spark程序比普通Java多线程程序慢

编辑：

我说：

results=results.cache（）

在对结果进行排序之前，现在的运行时间是2.5分钟

编辑2：

我用参数的笛卡尔积手工创建了一个RDD，而不是使用框架提供的操作。现在我的运行时是1'25'。现在这是有道理的，因为启动司机并将罐子移到工人手中需要一些开销