Flink内存管理

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 BuffersMemoryManagerFree 三个区域。

  • 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的内存效率和性能。

你可能感兴趣的:(Flink内存管理)