博客

spark.executor.logs.rolling.maxRetainedFiles

(none)

设置被系统保留的最近滚动日志文件的数量。更老的日志文件将被删除。默认没有开启。

spark.executor.logs.rolling.size.maxBytes

(none)

executor日志的最大滚动大小。默认情况下没有开启。值设置为字节

spark.executor.logs.rolling.strategy

(none)

设置executor日志的滚动(rolling)策略。默认情况下没有开启。可以配置为

time

和

size

。对于

time

，用

spark.executor.logs.rolling.time.interval

设置滚动间隔；对于

size

，用

spark.executor.logs.rolling.size.maxBytes

设置最大的滚动大小

spark.executor.logs.rolling.time.interval

daily

executor日志滚动的时间间隔。默认情况下没有开启。合法的值是

daily

,

hourly

,

minutely

以及任意的秒。

spark.files.userClassPathFirst

false

(实验性)当在Executors中加载类时，是否用户添加的jar比Spark自己的jar优先级高。这个属性可以降低Spark依赖和用户依赖的冲突。它现在还是一个实验性的特征。

spark.python.worker.memory

512m

在聚合期间，每个python worker进程使用的内存数。在聚合期间，如果内存超过了这个限制，它将会将数据塞进磁盘中

spark.python.profile

false

在Python worker中开启profiling。通过

sc.show_profiles()

展示分析结果。或者在driver退出前展示分析结果。可以通过

sc.dump_profiles(path)

将结果dump到磁盘中。如果一些分析结果已经手动展示，那么在driver退出前，它们再不会自动展示

spark.python.profile.dump

(none)

driver退出前保存分析结果的dump文件的目录。每个RDD都会分别dump一个文件。可以通过

ptats.Stats()

加载这些文件。如果指定了这个属性，分析结果不会自动展示

spark.python.worker.reuse

true

是否重用python worker。如果是，它将使用固定数量的Python workers，而不需要为每个任务

fork()

一个Python进程。如果有一个非常大的广播，这个设置将非常有用。因为，广播不需要为每个任务从JVM到Python worker传递一次

spark.executorEnv.[EnvironmentVariableName]

(none)

通过

EnvironmentVariableName

添加指定的环境变量到executor进程。用户可以指定多个

EnvironmentVariableName

，设置多个环境变量

spark.mesos.executor.home

driver side SPARK_HOME

设置安装在Mesos的executor上的Spark的目录。默认情况下，executors将使用driver的Spark本地（home）目录，这个目录对它们不可见。注意，如果没有通过

spark.executor.uri

指定Spark的二进制包，这个设置才起作用

spark.mesos.executor.memoryOverhead

executor memory * 0.07, 最小384m

这个值是

spark.executor.memory

的补充。它用来计算mesos任务的总内存。另外，有一个7%的硬编码设置。最后的值将选择

spark.mesos.executor.memoryOverhead

或者

spark.executor.memory

的7%二者之间的大者

spark.reducer.maxMbInFlight

48

从递归任务中同时获取的map输出数据的最大大小（mb）。因为每一个输出都需要我们创建一个缓存用来接收，这个设置代表每个任务固定的内存上限，所以除非你有更大的内存，将其设置小一点

spark.shuffle.blockTransferService

netty

实现用来在executor直接传递shuffle和缓存块。有两种可用的实现：

netty

和

nio

。基于netty的块传递在具有相同的效率情况下更简单

spark.shuffle.compress

true

是否压缩map操作的输出文件。一般情况下，这是一个好的选择。

spark.shuffle.consolidateFiles

false

如果设置为”true”，在shuffle期间，合并的中间文件将会被创建。创建更少的文件可以提供文件系统的shuffle的效 率。这些shuffle都伴随着大量递归任务。当用ext4和dfs文件系统时，推荐设置为”true”。在ext3中，因为文件系统的限制，这个选项可 能机器（大于8核）降低效率

spark.shuffle.file.buffer.kb

32

每个shuffle文件输出流内存内缓存的大小，单位是kb。这个缓存减少了创建只中间shuffle文件中磁盘搜索和系统访问的数量

spark.shuffle.io.maxRetries

3

Netty only，自动重试次数

spark.shuffle.io.numConnectionsPerPeer

1

Netty only

spark.shuffle.io.preferDirectBufs

true

Netty only

spark.shuffle.io.retryWait

5

Netty only

spark.shuffle.manager

sort

它的实现用于shuffle数据。有两种可用的实现：

sort

和

hash

。基于sort的shuffle有更高的内存使用率

spark.shuffle.memoryFraction

0.2

如果

spark.shuffle.spill

为 true，shuffle中聚合和合并组操作使用的java堆内存占总内存的比重。在任何时候，shuffles使用的所有内存内maps的集合大小都受 这个限制的约束。超过这个限制，spilling数据将会保存到磁盘上。如果spilling太过频繁，考虑增大这个值

spark.shuffle.sort.bypassMergeThreshold

200

当你使用

SortShuffleManager

时，如果的确不需要排序操作，那么建议将这个参数调大一些，大于shuffle read task的数量。

那么此时就会自动启用bypass机制，map-side就不会进行排序了，减少了排序的性能开销

spark.shuffle.spill

true

如果设置为”true”，通过将多出的数据写入磁盘来限制内存数。通过

spark.shuffle.memoryFraction

来指定spilling的阈值

spark.shuffle.spill.compress

true

在shuffle时，是否将spilling的数据压缩。压缩算法通过

spark.io.compression.codec

指定。

spark.broadcast.compress

true

在发送广播变量之前是否压缩它

spark.closure.serializer

org.apache.

spark.serializer.

JavaSerializer

闭包用到的序列化类。目前只支持java序列化器

spark.io.compression.codec

snappy

压缩诸如RDD分区、广播变量、shuffle输出等内部数据的编码解码器。默认情况下，Spark提供了三种选择：lz4、lzf和snappy，你也可以用完整的类名来制定。

spark.io.compression.lz4.block.size

32768

LZ4压缩中用到的块大小。降低这个块的大小也会降低shuffle内存使用率

spark.io.compression.snappy.block.size

32768

Snappy压缩中用到的块大小。降低这个块的大小也会降低shuffle内存使用率

spark.kryo.classesToRegister

(none)

如果你用Kryo序列化，给定的用逗号分隔的自定义类名列表表示要注册的类

spark.kryo.referenceTracking

true

当用Kryo序列化时，跟踪是否引用同一对象。如果你的对象图有环，这是必须的设置。如果他们包含相同对象的多个副本，这个设置对效率是有用的。如果你知道不在这两个场景，那么可以禁用它以提高效率

spark.kryo.registrationRequired

false

是否需要注册为Kyro可用。如果设置为true，然后如果一个没有注册的类序列化，Kyro会抛出异常。如果设置为false，Kryo将会同时写每个对象和其非注册类名。写类名可能造成显著地性能瓶颈。

spark.kryo.registrator

(none)

如果你用Kryo序列化，设置这个类去注册你的自定义类。如果你需要用自定义的方式注册你的类，那么这个属性是有用的。否则

spark.kryo.classesToRegister

会更简单。它应该设置一个继承自

KryoRegistrator

的类

spark.kryoserializer.buffer.max.mb

64

Kryo序列化缓存允许的最大值。这个值必须大于你尝试序列化的对象

spark.kryoserializer.buffer.mb

0.064

Kyro序列化缓存的大小。这样worker上的每个核都有一个缓存。如果有需要，缓存会涨到

spark.kryoserializer.buffer.max.mb

设置的值那么大。

spark.rdd.compress

true

是否压缩序列化的RDD分区。在花费一些额外的CPU时间的同时节省大量的空间

spark.serializer

org.apache.

spark.serializer.

JavaSerializer

序列化对象使用的类。默认的Java序列化类可以序列化任何可序列化的java对象但是它很慢。所有我们建议用

org.apache.spark.serializer.KryoSerializer

spark.serializer.objectStreamReset

100

当用

org.apache.spark.serializer.JavaSerializer

序列化时，序列化器通过缓存对象防止写多余的数据，然而这会造成这些对象的垃圾回收停止。通过请求’reset’，你从序列化器中flush这些信息并允许收集老的数据。为了关闭这个周期性的reset，你可以将值设为-1。默认情况下，每一百个对象reset一次

spark.broadcast.blockSize

4096

TorrentBroadcastFactory传输的块大小，太大值会降低并发，太小的值会出现性能瓶颈

spark.broadcast.factory

org.apache.spark.

broadcast.TorrentBroadcastFactory

broadcast实现类

spark.cleaner.ttl

(infinite)

spark记录任何元数据（stages生成、task生成等）的持续时间。定期清理可以确保将超期的元数据丢弃，这在运行长时间任务是很有用的，如运行7*24的sparkstreaming任务。RDD持久化在内存中的超期数据也会被清理

spark.default.parallelism

本地模式：机器核数；Mesos：8；其他：

max(executor的core，2)


如果用户不设置，系统使用集群中运行shuffle操作的默认任务数（groupByKey、 reduceByKey等）

spark.executor.heartbeatInterval

10000

executor 向 the driver 汇报心跳的时间间隔，单位毫秒

spark.files.fetchTimeout

60

driver 程序获取通过

SparkContext.addFile()

添加的文件时的超时时间，单位秒

spark.files.useFetchCache

true

获取文件时是否使用本地缓存

spark.files.overwrite

false

调用

SparkContext.addFile()

时候是否覆盖文件

spark.hadoop.cloneConf

false

每个task是否克隆一份hadoop的配置文件

spark.hadoop.validateOutputSpecs

true

是否校验输出

spark.storage.memoryFraction

0.6

Spark内存缓存的堆大小占用总内存比例，该值不能大于老年代内存大小，默认值为0.6，但是，如果你手动设置老年代大小，你可以增加该值

spark.storage.memoryMapThreshold

2097152

内存块大小

spark.storage.unrollFraction

0.2

Fraction of spark.storage.memoryFraction to use for unrolling blocks in memory.

spark.tachyonStore.baseDir

System.getProperty(“java.io.tmpdir”)

Tachyon File System临时目录

spark.tachyonStore.url

tachyon://localhost:19998

Tachyon File System URL

spark.driver.host

(local hostname)

driver监听的主机名或者IP地址。这用于和executors以及独立的master通信

spark.driver.port

(random)

driver监听的接口。这用于和executors以及独立的master通信

spark.fileserver.port

(random)

driver的文件服务器监听的端口

spark.broadcast.port

(random)

driver的HTTP广播服务器监听的端口

spark.replClassServer.port

(random)

driver的HTTP类服务器监听的端口

spark.blockManager.port

(random)

块管理器监听的端口。这些同时存在于driver和executors

spark.executor.port

(random)

executor监听的端口。用于与driver通信

spark.port.maxRetries

16

当绑定到一个端口，在放弃前重试的最大次数

spark.akka.frameSize

10

在”control plane”通信中允许的最大消息大小。如果你的任务需要发送大的结果到driver中，调大这个值

spark.akka.threads

4

通信的actor线程数。当driver有很多CPU核时，调大它是有用的

spark.akka.timeout

100

Spark节点之间的通信超时。单位是秒

spark.task.cpus

1

为每个任务分配的内核数

spark.task.maxFailures

4

Task的最大重试次数

spark.scheduler.mode

FIFO

Spark的任务调度模式，还有一种Fair模式

spark.cores.max

当应用程序运行在Standalone集群或者粗粒度共享模式Mesos集群时，应用程序向集群请求的最大CPU内核总数（不是指每 台机器，而是整个集群）。如果不设置，对于Standalone集群将使用spark.deploy.defaultCores中数值，而Mesos将使 用集群中可用的内核

spark.mesos.coarse

False

如果设置为true，在Mesos集群中运行时使用粗粒度共享模式

spark.speculation

False

以下几个参数是关于Spark推测执行机制的相关参数。此参数设定是否使用推测执行机制，如果设置为true则spark使用推测执行机制，对于Stage中拖后腿的Task在其他节点中重新启动，并将最先完成的Task的计算结果最为最终结果

spark.speculation.interval

100

Spark多长时间进行检查task运行状态用以推测，以毫秒为单位

spark.speculation.quantile

推测启动前，Stage必须要完成总Task的百分比

spark.speculation.multiplier

1.5

比已完成Task的运行速度中位数慢多少倍才启用推测

spark.locality.wait

3000

以下几个参数是关于Spark数据本地性的。本参数是以毫秒为单位启动本地数据task的等待时间，如果超出就启动下一本地优先级别 的task。该设置同样可以应用到各优先级别的本地性之间（本地进程 -> 本地节点 -> 本地机架 -> 任意节点 ），当然，也可以通过spark.locality.wait.node等参数设置不同优先级别的本地性

spark.locality.wait.process

spark.locality.wait

本地进程级别的本地等待时间

spark.locality.wait.node

spark.locality.wait

本地节点级别的本地等待时间

spark.locality.wait.rack

spark.locality.wait

本地机架级别的本地等待时间

spark.scheduler.revive.interval

1000

复活重新获取资源的Task的最长时间间隔（毫秒），发生在Task因为本地资源不足而将资源分配给其他Task运行后进入等待时间，如果这个等待时间内重新获取足够的资源就继续计算

false

当shuffle跟踪开启后，控制executor存储shuffle数据的超时时间