Spark内存管理

前言

Spark作为一个基于内存的分布式计算引擎，程序在运行时可能会被集群中的任何资源阻塞：CPU | 网络带宽 | 内存。然而Spark的内存管理模块在整个系统中扮演着非常重要的角色。理解Spark内存管理的基本原理，有助于更好地开发Spark应用程序和进行性能调优

在提交一个Spark Application时，Spark集群会启动Driver和Executor两种JVM进程。Driver为主控进程，负责创建Context，提交Job，并将Job转化成Task，协调Executor间的Task执行。而Executor主要负责执行具体的计算任务，将结果返回Driver。由于Driver的内存管理比较简单，和一般的JVM程序区别不大，本文基于Spark2.12重点分析Executor的内存管理。

☞☞☞ 既然说到内存管理，接下来不得不说Spark任务开启后涉及的有哪些内存！！！

堆内存(on-heap)和堆外内存(off-heap)

• 堆内存(on-heap):

描述：在JVM堆上分配的内存，在GC范围内
①：Driver堆内存：通过--driver-memory 或者spark.driver.memory指定，默认大小1G；
②：Executor堆内存：通过--executor-memory 或者spark.executor.memory指定，默认大小1G

• 堆外内存(off-heap):

描述：在JVM之外分配的内存，不在GC范围内
①：Driver堆外内存：通过spark.driver.memoryOverhead指定，默认是Driver堆内存的0.1倍，最小是384MB；

Driver堆外内存 = max(Driver堆内存 * MEMORY_OVERHEAD_FACTOR ，MEMORY_OVERHEAD_MIN  )
注：MEMORY_OVERHEAD_FACTOR = 0.10 和  MEMORY_OVERHEAD_MIN = 384 如有需要的同学可以查看源码

②：Executor堆外内存 :通过spark.executor.memoryOverhead指定，默认是Executor堆内存的0.1倍，最小是384MB；

Executor堆外内存 = max(Executor堆内存 * MEMORY_OVERHEAD_FACTOR ，MEMORY_OVERHEAD_MIN )
注：MEMORY_OVERHEAD_FACTOR = 0.10 和  MEMORY_OVERHEAD_MIN = 384 如有需要的同学可以查看源码

• Driver和Executor内存:

①：Driver内存大小：Driver的堆内存 + Driver的堆外内存
②：Executor内存大小：Executor的堆内存 + Executor的堆外内存

☞☞☞ 走到这，大家应该对Spark中涉及的内存概念有一个简单的印象了，那在开发中我们给Spark任务一些资源后，它是怎么管理这些内存的呢？？？

内存空间分配

• 静态内存管理

在静态内存管理机制下，存储内存，执行内存和其它内存三部分的大小在Spark应用运行期间是固定的，但是用户可以在提交Spark应用之前进行配置。如果开发者不熟悉Spark的存储机制，或没有根据具体的数据规模和计算任务做相应的配置，很容易会造成资源没有得到合理的分配导致Spark任务失败。由于新的内存管理机制的出现，静态内存管理不在本文做详细介绍，有兴趣的同学可以参考网上的其它博客。

• 统一内存管理

Spark 1.6之后引入了统一内存管理机制，与静态内存管理的区别在于存储和执行内存共享同一块空间，可以动态占用对方的空闲区域。

堆内模型

描述：Executor内运行的并发任务共享JVM对内内存。

• Execution内存：主要用于存放Shuffle，Join，Sort，Aggregation等计算过程中的临时数据；
• Storage内存：主要用于存放Spark的cache数据，例如：RDD的缓存，unroll数据；
• 用户内存(User Memory):主要用于储存RDD转换操作所需要的数据，例如RDD依赖等信息；

• 预留内存(Reserved Memory):系统预留内存，会用来存储Spark内部对象。

  
  
  JVM On-heap Memory

• systemMemory：其实就是通过参数spark.executor.memory 或 --executor-memory配置的，在源码中可以发现，systemMemory也有其最小值：minSystemMemory = (reservedMemory * 1.5)，也就是最小是reservedMemory的1.5倍；

/**
   * Return the total amount of memory shared between execution and storage, in bytes.
   */
  private def getMaxMemory(conf: SparkConf): Long = {
    val systemMemory = conf.get(TEST_MEMORY)
    val reservedMemory = conf.getLong(TEST_RESERVED_MEMORY.key,
      if (conf.contains(IS_TESTING)) 0 else RESERVED_SYSTEM_MEMORY_BYTES)
     //SystemMemory最小值
    val minSystemMemory = (reservedMemory * 1.5).ceil.toLong
    if (systemMemory < minSystemMemory) {
      throw new IllegalArgumentException(s"System memory $systemMemory must " +
        s"be at least $minSystemMemory. Please increase heap size using the --driver-memory " +
        s"option or spark.driver.memory in Spark configuration.")
    }
    // SPARK-12759 Check executor memory to fail fast if memory is insufficient
    if (conf.contains(config.EXECUTOR_MEMORY)) {
      val executorMemory = conf.getSizeAsBytes(config.EXECUTOR_MEMORY.key)
      if (executorMemory < minSystemMemory) {
        throw new IllegalArgumentException(s"Executor memory $executorMemory must be at least " +
          s"$minSystemMemory. Please increase executor memory using the " +
          s"--executor-memory option or ${config.EXECUTOR_MEMORY.key} in Spark configuration.")
      }
    }
    //usableMemory计算逻辑
    val usableMemory = systemMemory - reservedMemory
    val memoryFraction = conf.get(config.MEMORY_FRACTION)
    (usableMemory * memoryFraction).toLong
  }

• reservedMemory:其值等于300MB，这个值平常线上开发是不做修改的；

// Set aside a fixed amount of memory for non-storage, non-execution purposes.
  // This serves a function similar to `spark.memory.fraction`, but guarantees that we reserve
  // sufficient memory for the system even for small heaps. E.g. if we have a 1GB JVM, then
  // the memory used for execution and storage will be (1024 - 300) * 0.6 = 434MB by default.
  private val RESERVED_SYSTEM_MEMORY_BYTES = 300 * 1024 * 1024

• usableMemory = systemMemory - reservedMemory，这个就是Spark的可用内存，具体可以在上面介绍systemMemory中找到这个值怎么计算的。

堆外模型

描述：相比对内内存，堆外内存的模型比较简单，只包括Storage内存和Execution内存，其分布如下图：

Off-heap Memory

☞☞☞ 上面大概说了说Spark中的堆内存和堆外内存怎么管理以及相关参数怎么得到和设置的，其中涉及了Execution和Storage内存动态占用的情景，那接下来聊一聊动态占用机制是怎么样的？？

动态占用机制

• Execution内存不够用的时候，可以去Storage内存中申请使用；
• Storage内存不够用的时候也可以去Execution区域中声明使用；
• 但是Storage内存在使用完占用的Execution内存之后，需要归还对方的内存，而Execution内存在使用完Storage内存是默认是不归还的。

动态占用

---

>>本篇文章仅仅记录自己的学习过程，文章中如有错误或不妥之处，请留言，谢谢！<<