Flink内存管理
1.简介
自从2003-2006年，Google发表了三篇著名的大数据相关论文（Google FS，MapReduce，Big Table）后，内存问题一直困扰大数据工程师们。
这一问题从MR1.0一直延续到Spark时代，从Spark晚期版本试图由应用程序自行管理内存后，人们才初步解决了内存问题。
使用原生的JVM内存管理会带来如下的致命问题：
- JVM对象存储密度低，在32位系统或开启指针压缩的64位系统中，普通对象（非数组）对象头占用64bit，尾部还需要8字节对齐。
- JVM GC导致的毛刺和性能问题，由于计算引擎会频繁创建对象，小对象会被创建在新生代导致频繁的minor GC和STW，大对象会被直接创建在老年代导致大量的并发式GC（CMS）或混合式GC（G1），并且GC的触发和执行完全由JVM控制，计算引擎无法干预。
- 潜在的OOM风险，OOM发生的时机不可控。
在Apache Flink中，taskManager自行管理的内存，避免了JVM原生内存管理的缺陷，本文将详细介绍相关逻辑。
2.内存模型
Task manager管理的JVM内存主要分为Network Buffers、MemoryManager 和 Free 三个区域。
- Network Buffers，shuffle / broadcost网络活动相关的内存
- MemoryManager，cache / sorting / hashing 计算相关的内存
- Free，存放用户代码产生的对象
3.代码分析
3.1 TaskManagerOptions
内存管理的相关配置
- MEMORY_SEGMENT_SIZE——内存段大小，默认32kb。内存段（segment）是Flink内存管理的基本模型。
- MANAGED_MEMORY_SIZE——task manager管理的内存大小，如果不设置则使用MANAGED_MEMORY_FRACTION
- MANAGED_MEMORY_FRACTION——task manager管理的内存占比，默认0.7f
- MEMORY_OFF_HEAP——是否使用堆外内存，默认false即使用堆内内存
- MANAGED_MEMORY_PRE_ALLOCATE——task manager启动时是否预分配，默认false
- NETWORK_NUM_BUFFERS——网络缓冲区的segment数量，默认2048
- NETWORK_BUFFERS_MEMORY_FRACTION——网络缓冲区的内存占比，默认0.1
- NETWORK_BUFFERS_MEMORY_MIN——网络缓冲区的最小size，默认64MB
- NETWORK_BUFFERS_MEMORY_MAX——网络缓冲区的最大size，默认1GB
3.2 MemoryPool
静态抽象类MemoryPool定义了内存池的方法，它有两个实现类HybridHeapMemoryPool和HybridOffHeapMemoryPool，堆内内存池和堆外内存池。
abstract static class MemoryPool {
abstract int getNumberOfAvailableMemorySegments();
abstract MemorySegment allocateNewSegment(Object owner);
abstract MemorySegment requestSegmentFromPool(Object owner);
abstract void returnSegmentToPool(MemorySegment segment);
abstract void clear();
}
3.3 MemoryManager
MemoryManager 类负责管理sorting,、hashing、caching使用的内存，主要方法有allocatePages（申请内存段）和release（释放内存段）
public void allocatePages(Object owner, List target, int numPages)
throws MemoryAllocationException {
... 入参校验
// -------------------- BEGIN CRITICAL SECTION -------------------
synchronized (lock) {
if (isShutDown) {
throw new IllegalStateException("Memory manager has been shut down.");
}
// 可用内存校验
if (numPages > (memoryPool.getNumberOfAvailableMemorySegments() + numNonAllocatedPages)) {
throw new MemoryAllocationException("Could not allocate " + numPages + " pages. Only " +
(memoryPool.getNumberOfAvailableMemorySegments() + numNonAllocatedPages)
+ " pages are remaining.");
}
// allocatedSegments是个HashMap>，key是owner，值是此owner占用的segment列表
Set segmentsForOwner = allocatedSegments.get(owner);
if (segmentsForOwner == null) {
segmentsForOwner = new HashSet(numPages);
allocatedSegments.put(owner, segmentsForOwner);
}
if (isPreAllocated) {
for (int i = numPages; i > 0; i--) {
MemorySegment segment = memoryPool.requestSegmentFromPool(owner);
target.add(segment);
segmentsForOwner.add(segment);
}
}
else {
for (int i = numPages; i > 0; i--) {
MemorySegment segment = memoryPool.allocateNewSegment(owner);
target.add(segment);
segmentsForOwner.add(segment);
}
numNonAllocatedPages -= numPages;
}
}
// -------------------- END CRITICAL SECTION -------------------
}
3.4 MemorySegment
MemorySegment类管理Flink中的一个内存页，MemorySegment是抽象类有两个实现类HeapMemorySegment和HybridMemorySegment。
MemorySegment定义了Segment的基本操作：
// 返回segment字节数
public int size();
// segment是否已释放
public boolean isFreed();
// 释放segment
public void free();
// 是否使用堆外内存
public boolean isOffHeap();
// 返回堆内内存的数组
public byte[] getArray();
// 返回堆外内存的地址
public long getAddress();
// 返回指定区域的数据，并封装成ByteBuffer
public abstract ByteBuffer wrap(int offset, int length);
// 返回segment owner
public Object getOwner();
// 随机读写API
public abstract byte get(int index);
public abstract void put(int index, byte b);
public abstract void get(int index, byte[] dst);
public abstract void put(int index, byte[] src);
public abstract void get(int index, byte[] dst, int offset, int length);
public abstract void put(int index, byte[] src, int offset, int length);
public abstract boolean getBoolean(int index);
public abstract void putBoolean(int index, boolean value);
public final char getChar(int index);
public final char getCharLittleEndian(int index);
public final char getCharBigEndian(int index);
public final void putChar(int index, char value);
public final void putCharLittleEndian(int index, char value);
public final void putCharBigEndian(int index, char value);
public final short getShort(int index);
public final short getShortLittleEndian(int index);
public final short getShortBigEndian(int index);
public final void putShort(int index, short value);
public final void putShortLittleEndian(int index, short value);
public final void putShortBigEndian(int index, short value);
public final int getInt(int index);
public final int getIntLittleEndian(int index);
public final int getIntBigEndian(int index);
public final void putInt(int index, int value);
public final void putIntLittleEndian(int index, int value);
public final void putIntBigEndian(int index, int value);
public final long getLong(int index);
public final long getLongLittleEndian(int index);
public final long getLongBigEndian(int index);
public final void putLong(int index, long value);
public final void putLongLittleEndian(int index, long value);
public final void putLongBigEndian(int index, long value);
public final float getFloat(int index);
public final float getFloatLittleEndian(int index);
public final float getFloatBigEndian(int index);
public final void putFloat(int index, float value);
public final void putFloatLittleEndian(int index, float value);
public final void putFloatBigEndian(int index, float value);
public final double getDouble(int index);
public final double getDoubleLittleEndian(int index);
public final double getDoubleBigEndian(int index);
public final void putDouble(int index, double value);
public final void putDoubleLittleEndian(int index, double value);
public final void putDoubleBigEndian(int index, double value);
public abstract void get(DataOutput out, int offset, int length) throws IOException;
public abstract void put(DataInput in, int offset, int length) throws IOException;
public abstract void get(int offset, ByteBuffer target, int numBytes);
public abstract void put(int offset, ByteBuffer source, int numBytes);
// 拷贝数据到目标segment
public final void copyTo(int offset, MemorySegment target, int targetOffset, int numBytes);
// 比较两个segment的数据
public final int compare(MemorySegment seg2, int offset1, int offset2, int len);
// 交互两个segment的数据
public final void swapBytes(byte[] tempBuffer, MemorySegment seg2, int offset1, int offset2, int len);
4. 总结
通过MemoryManager、MemoryPool、MemorySegment等类，Flink实现了应用层级对于内存的管理，规避了JVM原生内存管理带来的诸多问题，有效的提升了Flink的内存效率和性能。