Java 分发处理时通常会有多少开销?
对于不耐烦的读者:这是一个正在进行的工作,我要求 帮助,在这个过程中。请不要根据我的判断来判断工具 临时数据,因为它们可以在我尝试获得更好结果时更改 我们正处于一个工具的决策过程中,用于分析共同模拟输出的工具。 作为这一过程的一部分,我被要求编写一个基准测试工具,并获取关于几个分布式处理框架的速度的数据 我测试的框架有:ApacheSark、ApacheFlink、Hazelcast Jet。作为比较基准,使用纯Java 我使用的测试用例是一个简单的“这里是一个pojo列表,pojo中的一个字段是一个双倍值。找到最小(min)值” 简单、直截了当,希望具有很高的可比性 四分之三的测试使用一个简单的比较器,第四个(flink)使用一个与比较器基本相同的减速机。分析函数如下所示:Java 分发处理时通常会有多少开销?,java,performance,apache-spark,apache-flink,hazelcast-jet,Java,Performance,Apache Spark,Apache Flink,Hazelcast Jet,对于不耐烦的读者:这是一个正在进行的工作,我要求 帮助,在这个过程中。请不要根据我的判断来判断工具 临时数据,因为它们可以在我尝试获得更好结果时更改 我们正处于一个工具的决策过程中,用于分析共同模拟输出的工具。 作为这一过程的一部分,我被要求编写一个基准测试工具,并获取关于几个分布式处理框架的速度的数据 我测试的框架有:ApacheSark、ApacheFlink、Hazelcast Jet。作为比较基准,使用纯Java 我使用的测试用例是一个简单的“这里是一个pojo列表,pojo中的一个字段
Java: double min = logs.stream().min(new LogPojo.Comp()).get().getValue();
Spark: JavaRDD<LogPojo> logData = sc.parallelize(logs, num_partitions);
double min = logData.min(new LogPojo.Comp()).getValue();
Hazel: IStreamList<LogPojo> iLogs = jet.getList("logs");
iLogs.addAll(logs);
double min = iLogs.stream().min(new LogPojo.Comp()).get().getValue();
Flink: DataSet<LogPojo> logSet = env.fromCollection(logs);
double min = logSet.reduce(new LogReducer()).collect().get(0).getValue();
最有趣的部分是:
- 最好的结果都来自纯本地测试(一个实例)
- 任何使用分布式机制(附加节点等)的测试都要慢一个数量级(例如,如果分布式的话,spark要慢2.5)
1 mio objects, 256 tasks, 64 cpus local[*]
java:
Instances:
List:
Process: 622, 448, 68, 45, 22, 32, 15, 27, 22, 29,
spark:
Instances: 4865, 186, 160, 133, 121, 112, 106, 78, 121, 106,
List: 310, 2, 2, 1, 2, 4, 2, 1, 2, 1,
Process: 8190, 4433, 4200, 4073, 4201, 4092, 3822, 3852, 3921, 4051,
10 mio objects, 256 tasks, 64 cpus local[*]
java:
Instances:
List:
Process: 2329, 144, 50, 65, 75, 70, 69, 66, 66, 66,
spark:
Instances: 20345,
List: 258, 2, 1, 1, 1, 4, 1, 1, 1, 1,
Process: 55671, 49629, 48612, 48090, 47897, 47857, 48319, 48274, 48199, 47516
1 mio objects, 5.2k tasks, 64 cpus local, 32 cpus each on 1+1 Spark machines (different rack)
java:
Instances:
List:
Process: 748, 376, 70, 31, 69, 64, 46, 17, 50, 53,
spark:
Instances: 4631,
List: 249, 1, 2, 2, 3, 3, 1, 1, 2, 1,
Process: 12273, 7471, 6314, 6083, 6228, 6158, 5990, 5953, 5981, 5972
1 mio objects, 5.2k tasks, 64 cpus local, 32 cpus each on 7+1 Spark machines (different rack)
java:
Instances:
List:
Process: 820, 494, 66, 29, 5, 30, 29, 43, 45, 21,
spark:
Instances: 4513,
List: 254, 2, 2, 2, 2, 4, 2, 2, 1, 1,
Process: 17007, 6545, 7174, 7040, 6356, 6502, 6482, 6348, 7067, 6335
10 mio objects, 52k tasks, 64 cpus local, 32 cpus each on 7+1 Spark machines (different rack)
java Process: 3037, 78, 48, 45, 53, 73, 72, 73, 74, 64,
spark:
Instances: 20181,
List: 264, 3, 2, 2, 1, 4, 2, 2, 1, 1,
Process: 77830, 67563, 65389, 63321, 61416, 63007, 64760, 63341, 63440, 65320
1 mio objects, 224*i tasks, 64 cpus local, 32 cpus each on 7+1 Spark machines (different rack), i =0 to 100
java Process: 722, 631, 62, 26, 25, 42, 26, 11, 12, 29, 40, 16, 14, 23, 29, 18, 14, 11, 71, 76, 37, 52, 32, 15, 51, 54, 19, 74, 62, 54, 7, 60, 37, 54, 42, 3, 7, 60, 33, 44, 50, 50, 39, 34, 34, 13, 47, 63, 46, 4, 52, 20, 19, 24, 6, 53, 4, 3, 68, 10, 59, 52, 48, 3, 48, 37, 5, 38, 10, 47, 4, 53, 36, 41, 31, 57, 7, 64, 45, 33, 14, 53, 5, 41, 40, 48, 4, 60, 49, 37, 20, 34, 53, 4, 58, 36, 12, 35, 35, 4,
spark:
Instances: 4612,
List: 279, 3, 2, 1, 2, 5, 3, 1, 1, 1, 2, 1, 1, 1, 1, 2, 2, 1, 1, 1, 1, 2, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 0, 2, 1, 1, 1, 1, 1, 0, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1,
Process: 16300, 6577, 5802, 6136, 5389, 5912, 5885, 6157, 5440, 6199, 5902, 6299, 5919, 6066, 5803, 6612, 6120, 6775, 6585, 6146, 6860, 6955, 6661, 6819, 6868, 6700, 7140, 7532, 7077, 7180, 7360, 7526, 7770, 7877, 8048, 7678, 8260, 8131, 7837, 7526, 8261, 8404, 8431, 8340, 9000, 8825, 8624, 9340, 9418, 8677, 8480, 8678, 9003, 9036, 8912, 9235, 9401, 9577, 9808, 9485, 9955, 10029, 9506, 9387, 9794, 9998, 9580, 9963, 9273, 9411, 10113, 10004, 10369, 9880, 10532, 10815, 11039, 10717, 11251, 11475, 10854, 11468, 11530, 11488, 11077, 11245, 10936, 11274, 11233, 11409, 11527, 11897, 11743, 11786, 11086, 11782, 12001, 11795, 12075, 12422
2 mio objects, 224*i tasks, 64 cpus local, 32 cpus each on 7+1 Spark machines (different rack), i = 0 to 30
java Process: 1759, 82, 31, 18, 30, 41, 47, 28, 27, 13, 28, 46, 5, 72, 50, 81, 66, 44, 36, 72, 44, 11, 65, 67, 58, 47, 54, 60, 46, 34,
spark:
Instances: 6316,
List: 265, 3, 3, 2, 2, 6, 1, 2, 1, 1, 1, 2, 2, 1, 1, 1, 1, 1, 2, 1, 1, 5, 1, 1, 1, 1, 2, 1, 1, 1,
Process: 24084, 13041, 11451, 11274, 10919, 10972, 10677, 11048, 10659, 10984, 10820, 11057, 11355, 10874, 10896, 11725, 11580, 11149, 11823, 11799, 12414, 11265, 11617, 11762, 11561, 12443, 12448, 11809, 11928, 12095
10 mio objects, 224*i tasks, 64 cpus local, 32 cpus each on 7+1 Spark machines (different rack), i = 5 to 30
java Process: 1753, 91, 57, 71, 86, 86, 151, 80, 85, 72, 61, 78, 80, 87, 93, 89, 70, 83, 166, 84, 87, 94, 90, 88, 92, 89, 196, 96, 97, 89,
spark:
Instances: 21192,
List: 282, 3, 2, 2, 3, 4, 2, 2, 1, 0, 1, 1, 1, 1, 2, 2, 1, 1, 1, 1, 1, 2, 2, 1, 1, 1,
Process: 60552, 53960, 53166, 54971, 52827, 54196, 51153, 52626, 54138, 51134, 52427, 53618, 50815, 50807, 52398, 54315, 54411, 51176, 53843, 54736, 55313, 56267, 50837, 54996, 52230, 52845
结果:无论有多少硬件被抛出,任务如何聚集,使用spark在列表中每百万POJO中花费5-6秒
另一方面,Java处理同样的量需要5-30毫秒,所以基本上是200-1000倍
有没有人对如何“加速”完成如此简单的工作有什么建议
更新榛子:
现在我开始给人留下深刻印象了。虽然我仍在与一些奇怪的问题作斗争,但至少Hazelcast Jet似乎明白,如果可能的话,本地数据可以在本地处理。只有100%(因数x2)的开销,这是完全可以接受的
1000万物体
java:
Instances:
List: 68987,
Process: 2288, 99, 54, 52, 54, 64, 89, 83, 79, 88,
hazel:
Instances: 6136,
List: 97225,
Process: 1112, 375, 131, 123, 148, 131, 137, 119, 176, 140
更新Flink:
现在把它从基准测试中删除了,因为它造成了太多的麻烦,却没有带来好的结果
编辑:整个基准可以在以下位置找到:
spark的集群设置使用spark-2.1.0-bin-hadoop2.7,因为它是现成的。spark_env.sh中有一个微小的变化:spark_NO_DAEMONIZE=true
使其在集群上工作所需的唯一更改是将SparcProc第25行中的“localhost”替换为“localhost”spark://I_cant_give_you_my_cluster_IP.doo“当您在群集框架中计算某些内容时,如Spark或Flink,框架:
- 序列化您的代码
- 发送资源请求
- 通过网络发送您的代码
- 计划执行
- 等待结果
- 可以将计算拆分为小任务,这些任务可以并行完成
- 有太多的数据需要在一台机器上处理,或者在一台机器上处理可能太慢—磁盘I/O、项目或计算中的其他一些特定因素非常具体,需要许多CPU,通常不止一台机器—但是计算一部分数据必须非常长
- 用户在具有许多引用的类中写入lambda-所有其他类都是序列化的,序列化需要很多时间
- 任务并不是真正并行的——它们必须相互等待,或者必须处理大部分数据
- 数据偏斜-对象可能具有适当的
实现,并且hashCode
会导致所有数据到达一个分区=一个节点HashPartitioner
- 分区数量不正确-您可以再添加1000台计算机,但如果您仍然有4个分区,则一次最多可以归档4个并行任务
- 太多的网络通信-在您的情况下,这不是问题,但有时用户正在进行大量的
和加入
减少
在您的示例中,Spark在
local
-上运行,这意味着只有一个线程!至少使用本地[*]
或其他群集管理器。您在这个答案中列出了开销,并且只有一个线程是否有一种方法可以共享您的代码?例如,关于Github私有回购协议,我将在这里附上最重要的部分。老实说,这只是基本的东西,就在框架tuts/手册中。@AndersBernard在我的回答中添加了重要的编辑-你正在运行local
,这意味着只有一个worker线程nod,正如前面所说,这是最快的。当然,我也用非本地测试过。。。而这更糟糕。我不会出版我们的实习生cl
java:
Instances:
List: 68987,
Process: 2288, 99, 54, 52, 54, 64, 89, 83, 79, 88,
hazel:
Instances: 6136,
List: 97225,
Process: 1112, 375, 131, 123, 148, 131, 137, 119, 176, 140