专栏首页大数据成神之路Spark Shuffle在网易的优化

Spark Shuffle在网易的优化

5万人关注的大数据成神之路,不来了解一下吗?

5万人关注的大数据成神之路,真的不来了解一下吗?

5万人关注的大数据成神之路,确定真的不来了解一下吗?

欢迎您关注《大数据成神之路》

本文结构

  • Background
  • 前言
  • Can Fetch
    • 描述
    • 优化方案
    • 相关链接
  • Fetch Efficiently
    • 描述
    • 优化方案
    • 相关链接
  • Reliable Fetch
    • Shuffle Write Phase
    • Shuffle Read Phase
    • 描述
    • 优化方案
    • 性能测试
    • 相关链接

Background

本文讲在网易工作将近一年来关于Spark Shuffle方面所做的三点优化。

前言

Spark是目前主流的大数据计算引擎,而Shuffle操作是Spark计算中的的核心操作,也往往是瓶颈所在。首先简单介绍下Shuffle操作。如下图所示.

map端负责对数据进行重新分区(Shuffle Write),可能有排序操作,而reduce端拉取数据各个mapper对应分区的数据(Shuffle Read),然后对这些数据进行计算。Shuffle过程中伴随着大量的数据传输。在大数据生产环境中,数据规模日益增长,数据量大了什么事情都有可能发生,可能会产生各种各样的问题,而大多数问题都与shuffle有关。由于Shuffle数据传输是由Shuffle read端fetch数据,因此本文使用fetch代表传输。

本文主要讲关于Spark Shuffle传输方面的三点优化。

  • 可以传输 Can Fetch.
  • 高效率传输 Fetch Efficiently.
  • 可靠的传输 Reliable Fetch.

Can Fetch

通常来说,Spark作为一个主流的大数据计算引擎,是可以传输大多数的Shuffle数据的。但是在大数据生产中,往往面临一些极端的shuffle情况。下面的案例是来自网易云音乐的用户。

描述

一天用户告诉我他有一个任务在Shuffle Read阶段出错,每天都要重试,有时候重试一次,有时候重试几次可以成功。任务报错如下:

1    WARN  [shuffle-client-6-2:TransportChannelHandler@78] - Exception in connection from hostName/hostIp:7337
2    java.lang.IllegalArgumentException: Too large frame: 2991947178
3        at org.spark_project.guava.base.Preconditions.checkArgument(Preconditions.java:119)
4        at org.apache.spark.network.util.TransportFrameDecoder.decodeNext(TransportFrameDecoder.java:133)
5        at org.apache.spark.network.util.TransportFrameDecoder.channelRead(TransportFrameDecoder.java:81)
6        at io.netty.channel.AbstractChannelHandlerContext.invokeChannelRead(AbstractChannelHandlerContext.java:362)

通过观察日志,我发现,是用户的一个MapTask发生了严重的数据倾斜,导致了这个MapTask写文件时有一个partition的数据量超过了2GB。而spark 使用netty进行数据传输,单个chunk有一个严格的2GB限制,因此这必然导致了在一次拉取单个partition shuffle 数据大于2GB时的失败。

那么用户又为什么任务可以重试成功呢?通过观察spark 日志页面.

可以发现此task在shuffle read端读取数据量为2.5GB,而从远端节点读取的数据量仅为42.5MB,原来是因为在该task失败之后,会进行重试,task可能重新调度到该oversize的partition所在的节点,这样数据就在本地,不用从网络中拉取,自然也不会触发到2GB的限制。

看来用户还是比较幸运的,重试之后可以刚好调度在数据所在节点执行task。那么如果有两个partition的数据都发生了严重的倾斜,而且这两个partition不在同一个节点之上,那样无论任务怎么重新调度,都必然至少有一个partition无法fetch,这必然造成了task的失败,进一步造成application的失败。

继续分析这个问题,spark有一个参数spark.maxRemoteBlockSizeFetchToMem,代表着可以从远端拉取数据放入内存的最大size。如果这一批要拉取的数据大小之和小于这个值,那么spark 使用fetch chunk的方式,都是一次拉取一整块的partition数据,然后放在内存里。如果一批要拉取数据大小之和大于这个size,就会才用fetchStream的方式,将这些partition数据流式拉取到本地保存为本地文件。

在spark2.4之前这个参数默认都是Long.MaxValue,这个值是超级大的,所以可以认为spark2.4之前如果你没有对这个参数进行额外设置,比如设置为2G,1500m,就可以说你的所有partition拉取都是一次进行。

而spark2.4之后,对该参数的默认值更改为Integet.MaxValue-512,也就是说,这样的参数就不会触发到一次性拉取一个大于2GB的数据了。

优化方案

问题已经分析的很明确。该问题的解决方案可以分为三种。

  • 通过设置spark.maxRemoteBlockSizeFetchToMem为小于2GB,来避免发生这个问题,这是最简单的
  • 或者是用户解决数据倾斜的问题
  • 从平台侧解决这个问题。

讲一下从平台侧对这个问题的解决,Spark作为一个大数据计算引擎,一个partition有超过2GB的数据并不过分,而作为一个大数据平台开发,自然要积极从平台侧出发。

而虽然能够通过配置spark.maxRemoteBlockSizeFetchToMem小于2GB来避免这个问题的发生,但是这也造成了即使我们在资源充足的情况下,也不能将这个参数设为一个大于2GB的值,而这也就造成了有时候即使我们内存资源充足,当我们一批fetch数据大于2GB时也要将这些数据进行落盘,新增了一些I/O开销。因此,我们能不能突破这个spark.maxRemoteBlockSizeFetchToMem不能设置大于2GB的限制,在任何设置下都能成功的取到数据呢?

其实一开始看到用户的任务可以通过重新调度到partition所在节点上解决之后,曾经想过使用调度优化来解决,但是前面也提过,如果有两个partition oversize,那么这个任务必定失败。

因此想到了对比较大的partition进行划分,每次拉取一部分数据,这样就不会触发到netty的2GB限制。

首先描述一下目前Spark 在没有达到spark.maxRemoteBlockSizeFetchToMem限制时拉取数据的过程

如上图所示,可以看到,shuffle read端将每个partition对应的数据,作为一个ManagedBuffer拉取过来,存放在一个阻塞队列中,之后task会依次去取这些数据进行计算。这就是目前shuffle fetch的不足之处,不管对应的partition有多大,只要这批拉取数据量小于spark.maxRemoteBlockSizeFetchToMem都一次性去取过来。

我们针对此方案作出了优化:现简单描述如下:

  1. 设置Shuffle一次可以fetch的阈值SHUFFLE_FETCH_THRESHOLD为2GB
  2. 设置一个参数spark.shuffle.fetch.split来控制是否使用本方案拉取数据
  3. 在创建mapStatus阶段,计算每个partition需要被fetch的次数size/SHUFFLE_FETCH_THRESHOLD保存为map.为了节省内存空间只保存次数1次以上的, 从map中获取不到则为1次。
  4. 定义一种新的BlockId 为ShuffleBlockSegmentId,用来让shuffle 服务端来识别出来我们要使用什么样的方案获取数据。
  5. 在shuffle client端,根据spark.shuffle.fetch.split参数来创建我们要发送到shuffle 服务端的BlockID类型,如果是多次拉取,则创建ShuffleBlockSegmentId,否则还是之前的ShuffleBlockId.
  6. 对于一个ShuffleBlockID对应的partition数据,使用一个buf的Sequence来保存,而不是原来的只用一个buf来保存。
  7. 由于我们现在分多次拉取一个partition的数据,因此需要这个partition数据完全拉取结束之后才能进入原来的LinkedBlockingQueue, 因此我们使用一个PriorityBlockingQueue来存放一个partition对应的多块数据,而且优先级阻塞队列还提供了排序功能,我们可以保证一个partition的数据是按序排放。当该ShuffleBlockId对应的所有数据都拉取过来之后,将放在优先级队列中的buf出队,然后放入LinkedBlockingQueue中,供task用于取数据计算。
  8. 在shuffle服务端,通过识别我们发送的blockId类型来决定如何取数据,如果是ShuffleBlockSegmentId,则取一块数据,否则,取全部数据。新方案拉取过程如下图所示:

通过此方案,我们就可以突破spark.maxRemoteBlockSizeFetchToMem 2GB和单partition数据量大于2GB的限制,为所欲为。

相关链接

另外由于近期PR-SPARK-27665的合入,我对新的shuffle fetch消息类型,也进行了适配。

对应Jira SPARK-27876

对应PR SPARK-27876

Fetch Efficiently

除了上面的能够传输,我们还要高效率的传输。下面的案例来自考拉的一个用户。

描述

考拉的一个用户告诉我,他近期的部分任务大量延迟,虽然没有task失败,但是运行时间比平时多了很多。

还是看日志,通过观察日志,发现用户的任务中有大量的shuffle-client拉取数据超时,然后重试的操作。

1    2019-04-26 12:18:49,848 [25708] - INFO  [Executor task launch worker for task 1689:Logging$class@54] - Started reading broadcast variable 5
2    2019-04-26 12:18:49,906 [25766] - INFO  [Executor task launch worker for task 1689:TransportClientFactory@254] - Successfully created connection to hadoop3977.jd.163.org/hostIp:38939 after 1 ms (0 ms spent in bootstraps)
3    2019-04-26 12:18:50,291 [26151] - WARN  [shuffle-client-4-1:TransportChannelHandler@78] - Exception in connection from hadoop3977.jd.163.org/hostIp:38939
4    java.io.IOException: Connection reset by peer
5        at sun.nio.ch.FileDispatcherImpl.read0(Native Method)
6        at sun.nio.ch.SocketDispatcher.read(SocketDispatcher.java:39)
7        at sun.nio.ch.IOUtil.readIntoNativeBuffer(IOUtil.java:223)
8        at sun.nio.ch.IOUtil.read(IOUtil.java:192)
9

重试操作是spark shuffle 阶段的一个优化,这可以避免由于网络或者节点暂时繁忙而导致拉取数据失败,而是可以多重试几次,保证数据拉取的健壮性,避免贸然的失败。可以使用 spark.shuffle.io.maxRetriesspark.shuffle.io.retryWait来配置最大重试次数与重试时间间隔。

日志中是说,这个shuffle-client一直连接超时,然后不断重试,直到将重试次数用尽。如果我们配置的最大重试次数为15次,重试间隔为20s的话,这样一个task不断重试下来就要推迟五分钟,如果很多的task推迟,后果很严重。

首先介绍一下shuffle client, spark中有两种shuffle client。一种是blockTransferService,用于拉取由spark自身管理的数据;另外一种是 ExternalShuffleClient,是用于拉取外部shuffle 服务的数据。常用的ExternalShuffleService是yarn上的shuffle service,它独立运行在yarn集群上的每个nodemanager之上,用于管理spark在运行阶段生成的shuffle数据,因此spark上的executor就不用自己管理自己的shuffle 数据。这也就为executor的动态回收提供了可能,因此如果没有额外的shuffle Service帮助这些executor管理他们的shuffle数据, 如果一个executor回收掉了,那么这些shuffle数据也就不可见。因此在spark中,如果要使用executor动态回收,必须要有对应的外部shuffle Service。

前面说了有两种shuffle client,blockTransferService是用于拉取由spark自身管理的数据,现在有了ExternalShuffleService用于管理shuffle 数据,那么blockTransferService还有什么作用呢?那就是拉取Broadcast数据。

上面的日志也是说重试时发生在reading broadcast variable阶段。

通过对日志进行详细的分析,问题如下:

  1. executorA 要拉取Broadcast变量,向executorB建立连接,成功。
  2. 建立连接成功之后,由于executorB到达最大空闲时间,被动态回收。
  3. executorA取数据时候发生超时,然后重试,重试必然会失败。
  4. 不断重试,直到重试此处用尽,之后executorA向Driver索要数据,成功。

整个流程下来,这个task并没有失败,但是花费了大量的时间在不断的重试之上。

优化方案

通过对问题深入的分析,发现问题出现在RetryingBlockFetcher的重试逻辑。

其重试逻辑如下:

  1. 如果当前异常为IOException(网络也是一种IO)。
  2. 并且此时还有重试次数未用尽,那就继续重试。

但是当初设计这个重试逻辑的人可能忽略了ExecutorDynamicAllocation,因为executor很容易被回收,当fetch数据时相关的节点已经死掉时,也会抛出IO异常,因此这会触发RetryingBlockFetcher的重试逻辑,但是这样的重试显然是毫无意义的,因此你永远不可能向一个已经死掉的executor索要数据。

因此,我对此重试进行了优化。

  1. 设置一种新的消息类型, IsExecutorAlive.在BlockTransferService捕获到IOException时,发往driver。
  2. driver根据消息中的executorID来查找自己维护的一个以executorId为key的map,时间复杂度为o(1),如果此executorId在map中则代表存活,否则,该Executor已经被回收.
  3. 回复executorId对应的Executor状态给索要信息的executor。
  4. 根据返回结果,如果该executor依然存活,则重试,否则,抛出ExecutorDeadException,重试结束。

核心代码如下:

 1    try {
 2                new OneForOneBlockFetcher(client, appId, execId, blockIds, listener,
 3                  transportConf, tempFileManager).start()
 4              } catch {
 5                case e: IOException =>
 6                  Try {
 7                    driverEndPointRef.askSync[Boolean](IsExecutorAlive(execId))
 8                  } match {
 9                    case Success(v) if v == false =>
10                      throw new ExecutorDeadException(s"The relative remote executor(Id: $execId)," +
11                        " which maintains the block data to fetch is dead.")
12                    case _ => throw e
13                  }
14              }

通过对shuffle-client(blockTransferService)重试逻辑的优化,我们可以避免无意义的重试,高效率的进行数据传输,提高应用性能。

相关链接

该PR已经合入Spark master分支.

对应Jira SPARK-27637

对应PR SPARK-27637

Reliable Fetch

前面提到了Can fetch, fetch efficiently,保证了可以传输任何数据,可以高效率的传输数据,数据传输的可靠性也是必要的,最后一部分聊一聊我们针对spark shuffle数据传输的可靠性做的优化。

描述

前面已经讲过spark shuffle过程中有大量的网络传输,也讲过shuffle read端fetch数据的过程。既然有大量的网络传输,那么就可能会有数据传输出错,所以对数据的校验是必不可少的。

shuffle read端在拉取到数据之后,首先会进行数据校验,然后进行后续的计算,如果该校验没有校验出数据的问题,而在后续的计算过程中发现该数据已经损坏,那么就会导致该task失败。

会报以下类似异常.

118/11/13 08:10:08 INFO client.TransportClientFactory: Successfully created connection to 
2hadoop2997.lt.163.org/hostIp:7337 after 0 ms (0 ms spent in 
3bootstraps) 18/11/13 08:10:08 ERROR util.Utils: Aborting task 
4java.io.IOException: FAILED_TO_UNCOMPRESS(5) at 
5org.xerial.snappy.SnappyNative.throw_error(SnappyNative.java:98)
6 at org.xerial.snappy.SnappyNative.rawUncompress(Native Method) at
7 org.xerial.snappy.Snappy.rawUncompress(Snappy.java:474) at 

这个异常是在后续计算过程中报的,说明目前的spark shuffle 数据校验机制存在问题。

首先描述一下在一个相关PR SPARK-26089合入之前存在的问题.

  • 只校验使用数据压缩格式(例如snappy,lz4)的数据,而非压缩的数据不进行校验。
  • 只能校验小于maxBytesInFlight/3(默认maxBytesInflight为48M)的数据,大小有局限
  • 采用创建的一个outputStream,然后将InputStream传入,然后再基于这个outputStream创建inputStream的方式来校验,会浪费内存

相关PR SPARK-26089合入解决了部分问题:

  • 针对较大的数据,也可以校验,但是只校验开头的一小部分,后面的数据不进行校验,如果后面的数据出错依然会造成task失败
  • 采用新的校验方法取代之前的流拷贝校验方法,内存浪费情况得到改善。

但是依然存在以下问题:

  • 无法校验未使用数据压缩格式的数据,谁又能确定不使用压缩格式就不出错呢?
  • 针对较大的数据,只校验起始部分,依然存在后续数据corrupt的风险

优化方案

我们通过针对线上的流数据corrupt异常分析以及对目前spark的校验机制分析,提出了一个相较完善的Spark shuffle 数据校验机制。

首先,我们需要选择一种数据通信校验码。通过对比了md5, sha系列,以及crc32等几种校验码,我们选取了crc32,因此crc它快速而又简单,完全满足生产需求,hadoop也是使用crc来作为数据校验码.

我们的方案简单描述如下:

  • shuffle map阶段针对每个partition计算其crc值,将这些crc值存储
  • 在shuffle read阶段拉取数据时,将数据对应的crc值与数据一起发送
  • shuffle read端针对拉取的数据重新计算crc值,与原有的crc值进行比对,比对相同,则代表数据传输没有问题,反之,有问题。

下面是具体实现。

Shuffle Write Phase

首先简单介绍一下shuffle write。shuffle writer分为三种,BypassMergeSortShuffleWriter, SortShuffleWriterUnsafeShuffleWriter. BypassShuffleWriter最后写的shuffle block组织方式与后两种不同,后两种shuffle writer的shuffle block文件组织方式是相同的。

如下图所示.

由图可见,如果一个shuffle过程有m个mapper, n个reducer。那么BypassShuffleWriter会创建 m*n个shuffle文件,如果m和n都比较大,比如m=n=5000,那么就会创建2500万个文件,这很可怕,所以BypassShuffleWriter默认只会在reducer个数少于200的时候使用,可以通过spark.shuffle.sort.bypassMergeThreshold配置这个参数。

而SortShuffleWriter和UnsafeShuffleWriter的组织shuffle文件的方法是一样的,这是针对BypassShuffleWriter的改进。由图可见,这两种shuffleWriter只会针对一个mapTask创建一个shuffle文件,建立一个索引文件记录每个划分之后的partition数据在这个文件中的偏移量(BypassShuffleWriter也有这样的索引文件)。这样每个mapTask只创建了两个文件,一个数据文件,一个索引文件,大大减小了文件的数量,减小了系统的压力。

而我们会在shuffle阶段数据处理完成之后,根据索引文件中记录的每个partition的偏移量计算每个partition的crc值,这个计算过程是很快的,crc是一个高效的校验码,而且通常(后两种ShuffleWriter是通常使用的)我们只需打开一个输入流,从头计算到尾,这是一个很高效的过程。

计算完成之后,我们将这些计算的crc值也存到到前面提到的shuffle索引文件,组织方式如下图。

原有的index文件保存的是每个分区的偏移量,都是long类型,每个偏移量占用8字节,因此其长度是8的倍数。

如果我们在原有的index文件后面添加计算的crc值,我们会加一个标志位,占用一个字节,之后的每个crc32值都是一个long类型,占用8字节,这样新的index文件长度就是(8y+1),永远不可能是8的倍数,而原有的shuffle index文件长度一定是8的倍数,这样ExternalSHuffleService也能都轻易识别出我们是否使用了crc校验,和老版本的spark进行兼容。

Shuffle Read Phase

前面已经提到过shuffle fetch数据的过程,只不过这里会在读数据时候,将map阶段计算的对应partition部分的crc值也一起拉取过来,然后与拉取过来的数据重新计算得到的crc值进行对比。

前面也提到过,如果一批拉取的数据的量小于spark.maxRemoteBlockSizeFetchToMem是会将数据全部放在内存中的,只有超过这个数量才会将远端的数据先落磁盘然后之后再读取,因此保存在磁盘中的数据,包括本地的shuffle block文件与远端拉取落磁盘的文件。

针对远端拉取过来放在内存中的数据,由于其本身就在内存,因此对其计算crc值是十分迅速的,而且内存中inputStream支持reset操作,我们在计算crc之后,进行一下reset操作,就可以继续将这个inputStream用于后续的task计算。

而针对在磁盘中数据,我们对其计算crc值,前面提过了crc是一个高效的校验码,这个过程也是很快的, 在将从磁盘数据得到的inputStream计算完之后,只需要将该inputStream关掉,然后重新从这个磁盘文件创建一个新的inputStream用于后续的task计算。

而在整个map阶段和reduce阶段,计算crc值只需要一个几十kb的缓冲区。

在shuffle read端计算完crc值之后,可以跟原来的crc值对比,如果对比一致,则代表该数据没有问题,否则就要进行一系列的处理逻辑,此处不再赘述。

这样,我们的shuffle校验机制就针对目前的spark shuffle校验机制进行了完善,可以校验非压缩的数据,可以校验任意大小的数据,cover所有场景。

性能测试

我们使用tpcds测试工具,针对1t和10t的数据进行了该校验算法的性能测试,其测试结果表明该算法不会对spark本身的执行性能造成影响,且在10T测试数据下, 由于最老版本的shuffle校验采用流拷贝,可能开销比较重,我们的shuffle校验机制,对比其有轻微的性能提升。针对最近合入的相关PR SPARK-26089,我们还没有进行性能测试对比,但是相信,我们的shuffle校验机制对比其不会有性能下降。

本文分享自微信公众号 - 大数据技术与架构(import_bigdata),作者:王斐

原文出处及转载信息见文内详细说明,如有侵权,请联系 yunjia_community@tencent.com 删除。

原始发表时间:2019-06-10

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

我来说两句

0 条评论
登录 后参与评论

相关文章

  • 数据资产管理在腾讯游戏的实践

    每日传输量:17000亿条,约260TB,总存储量为100PB+,公司占比为20%。

    王知无
  • 滴滴敏捷数据中台实践

    场景描述:滴滴每天处理交通大数据超过4800TB,日均车辆定位数据超过150亿,每日处理路径规划请求400亿次,数据覆盖了交通路况、用户叫车信息、司机驾驶行为、...

    王知无
  • 以银行业为例谈数据治理

    股份制改革对我国银行业来说只是一个开始,企业在风险管理、创造价值等方面还有很长的路要走。风险管理要求提供精准的数据模型、创造价值要求充分银行数据资产,这是数据治...

    王知无
  • 互联网大数据指南 教你过个高逼格的七夕节

    互联网大数据指南 教你过个高逼格的七夕节 ↑ 七夕到了,七夕到了,七夕到了(重要的事情说三遍)…对于这个能给单身狗造成万吨直接伤害的节日,简直是情侣们秀恩爱的神...

    小莹莹
  • 大数据就是这么神奇!

    我是攻城师
  • 数据分析案例:用数据研究房地产,买到理想的房源

    买房,可以说是很多人一辈子最大的投资,几百万的代价那得慎之又慎,否则买到烂尾的、有质量问题、设施问题的房子那就实在不值了。另外,现在的市场房子楼盘还是很多的,房...

    沉默的白面书生
  • 大数据24小时 | 菜鸟网络推出“智慧物流+”项目,神州控股拟11.52亿元布局电信大数据

    神州控股拟11.52亿元“搞”收购,布局电信大数据领域 ? 近日,神州控股公司发布公告称,将拟11.52亿人民币收购移动通信网络优化服务商华苏科技96.03%股...

    数据猿
  • 金融科技&大数据产品推荐:金蜂巢大数据集成与脱敏系统

    敏感信息保护即对非生产数据中的敏感信息进行脱敏,对数据进行有效的变形,既保存数据结构的真实性,同时又跟原生产数据不一致,便于数据在非生产环境中使用,减少数据使用...

    数据猿
  • SSD固态硬盘的GC与Trim

    操作系统:其实并没有删除数据;  事实上,它只是在硬盘前的索引区里标记这块文件占用的区域为无效的,  所以等该区域被擦除后,下次数据将要再次写入的时候,可以写入...

    Christal_R
  • Chrome实用插件推荐

    使用脚本断点调试定位是否正确是一个方法,当时在我的实际工作中,元素定位代码的封装较深,所以修改查询元素的内容较麻烦,所以直接使用Xpath Helper可以方便...

    zx钟

扫码关注云+社区

领取腾讯云代金券