1.内存限制的功能改动

1.1 变量添加

内存限制新特性添加了4个新的变量，具体的含义和取值如下表所示。

variable_name	含义
global_connection_memory_limit	全局connection的内存限制 [1, 18446744073709551615]
connection_memory_limit	单个connection的内存限制 [1, 18446744073709551615]
connection_memory_chunk_size	内存统计的最小变更单位，用于控制更新频率 [1, 10241024512]，默认8912
global_connection_memory_tracking	开关，用于控制全局内存计数器的启用和追踪

MySQL [(none)]> show variables where variable_name in ('global_connection_memory_limit', 'connection_memory_limit', 'connection_memory_chunk_size', 'global_connection_memory_tracking'); # 内存限制变量
+-----------------------------------+----------------------+
| Variable_name                     | Value                |
+-----------------------------------+----------------------+
| connection_memory_chunk_size      | 8912                 |
| connection_memory_limit           | 18446744073709551615 |
| global_connection_memory_limit    | 18446744073709551615 |
| global_connection_memory_tracking | OFF                  |
+-----------------------------------+----------------------+
MySQL [(none)]> show status like "Global_connection_memory"; # 内存使用量
+--------------------------+-------+
| Variable_name            | Value |
+--------------------------+-------+
| Global_connection_memory | 0     |
    +--------------------------+-------+

1.2 数据结构变更

该特性对部分已有的数据结构做了变更，新增了与内存使用量统计信息相关的成员对象，修改了PFS_thread、PSI_thread_service_v5、THD这3个类型。

class PFS_thread {
...
+ THD *m_cnt_thd // 用于更新内存计数器的THD
...
};
// ------------------------------------------------------------- //
struct PSI_thread_service_v5 {
...
+ set_mem_cnt_THD_v1_t set_mem_cnt_THD;
};
typedef void (*set_mem_cnt_THD_v1_t)(THD *thd, THD **backup_thd);
// ------------------------------------------------------------- //
class THD {
...
+ Thd_mem_cnt *mem_cnt;    // 内存计数器对象
+ bool enable_mem_cnt();   // 启用内存计数器
+ void disable_mem_cnt();  // 关闭内存计数器
...
};

THD可以简单理解为一个连接的上下文信息，m_cnt_thd是负责更新内存计数信息的THD对象，在组提交等操作中存在THD转换的问题，该成员可以确保转换时内存统计信息的正确性。
接口set_mem_cnt_THD()是协助完成THD转换的函数，分别对m_thd和m_cnt_thd进行设置，大部分情况下两者是相同的。
Thd_mem_cnt是内存计数器对象，THD结构中新增的mem_cnt成员在初始化时为Thd_mem_cnt_noop（空操作计数器），在connnection建立的prepare阶段通过调用enable_mem_cnt()创建为Thd_mem_cnt_conn（真正具备计数功能）；在THD析构阶段调用disable_mem_cnt()释放该计数器。Thd_mem_cnt_noop和Thd_mem_cnt_conn都是Thd_mem_cnt的子类。

// Thd_mem_cnt_conn创建
thd_prepare_connection()
|   thd->enable_mem_cnt() {
|   | Thd_mem_cnt *tmp_mem_cnt = new Thd_mem_cnt_conn(this);
|   | mem_cnt = tmp_mem_cnt;
|   }
// Thd_mem_cnt_conn释放
～THD()
|   THD::release_resources()
|   |   disable_mem_cnt() {
|   |   |  mem_cnt->flush(); // 清空当前THD的内存计数信息并扣除对应的gloabl数据
|   |   |  delete mem_cnt;
|   |   }

1.3 数据结构添加

如前文所述，内存计数器对象Thd_mem_cnt是该WL中引入的最重要的数据结构，负责保存、更新相关的内存使用信息。在内存限制的过程，真正起到作用的是其子类Thd_mem_cnt_conn，下面对此展开进一步介绍。

1.3.1 数据结构

在介绍Thd_mem_cnt_conn之前，首先需要知道引入的计数模式，不同的模式下，计数操作和错误处理是有差异的；通过位运算可以实现多种模式的组合。

enum enum_mem_cnt_mode {
  MEM_CNT_DEFAULT = 0U, // 不计数
  MEM_CNT_UPDATE_GLOBAL_COUNTER = (1U << 0), // 更新global信息
  MEM_CNT_GENERATE_ERROR = (1U << 1), // 产生OOM错误信息
  MEM_CNT_GENERATE_LOG_ERROR = (1U << 2) // 产生OOM错误信息写入日志
};

Thd_mem_cnt_conn的关键数据结构如上图所示，mem_count、max_conn_mem、glob_mem_counter分别指代connection已申请的内存、connection的最大内存（该值并不是一个指定值，会随mem_count变化）和该连接传递给global计数器的值。参数的联系和变化过程如下图所示，mem_count和连接实际的内存使用量相关，glob_mem_counter则是单位化增长，增长的值和connection_memory_chunk_size这个参数相关。

答：全局计数信息的变更需要保证原子性，频繁地变更会造成全局计数器锁的争用，影响并发度。参数connection_memory_chunk_size的意义是每次汇总到全局内存计数器的内存数据是chunk_size的整数倍，也就是说glob_mem_counter = connection_memory_chunk_size * n，并且以connection_memory_chunk_size * m的大小增加。每个连接提前传递足够多数量的内存计数到global中可以减少变更全局计数器的次数，避免每次增加零散内存数量带来的全局数据的频繁改动。只有mem_count > glob_mem_counter时才对global数据进行写入，同时将glob_mem_counter加上connection_memory_chunk_size的整数倍。因此说，connection_memory_chunk_size能够控制全局计数器更新的频率。connection_memory_chunk_size设置的较大时，每次汇总到全局计数器的内存信息数据就会很大，会被误认为有OOM的风险，提前引发OOM的报错，因此connection_memory_chunk_size不宜设置的太大；但这个值也不能设置的太小，否则就会导致全局计数器频繁更新。

mode参数是enum_mem_cnt_mode中的组合，例如SUPER用户在连接建立时的mode是MEM_CNT_UPDATE_GLOBAL_COUNTER，而普通的用户的mode则是MEM_CNT_UPDATE_GLOBAL_COUNTER ｜ MEM_CNT_GENERATE_ERROR | MEM_CNT_GENERATE_LOG_ERROR。在进行内存计数时会使用这个判断位，决定是否产生错误并kill connection。换言之，SUPER用户在执行查询等操作时是不会受到limit参数的限制的，而普通用户则会受这些参数的影响。

static void prepare_new_connection_state(THD *thd) {
    ...
    thd->mem_cnt->set_orig_mode(is_admin_conn ? MEM_CNT_UPDATE_GLOBAL_COUNTER // 根据身份设置mode
                                                : (MEM_CNT_UPDATE_GLOBAL_COUNTER |
                                                   MEM_CNT_GENERATE_ERROR |
                                                   MEM_CNT_GENERATE_LOG_ERROR));
    ...
}

1.3.2 关键接口

alloc_cnt()

修改mem_counter、max_conn_mem和glob_mem_counter。max_conn_mem随mem_counter更新，glob_mem_counter以lazy方式添加到全局内存计数器中（只有满足max_conn_mem > glob_mem_counter才会插值delta到全局计数器）。由于访问全局计数器需要加一把全局的大锁，这样的操作可以减少变更和加锁的次数。

修改mem_counter、max_conn_mem和glob_mem_counter。max_conn_mem随mem_counter更新，glob_mem_counter以lazy方式添加到全局内存计数器中（只有满足max_conn_mem > glob_mem_counter才会插值delta到全局计数器）。由于访问全局计数器需要加一把全局的大锁，这样的操作可以减少变更和加锁的次数。
产生错误信息，包括connection级别的和global级别的错误信息。generate_error会根据错误信息，给THD设置THD::KILL_CONNECTION状态，随后连接会在状态检测的位点killed。连接被kill后，物理内存下降、THD析构（THD上的计数器对象析构），统计信息随之更新。

bool Thd_mem_cnt_conn::alloc_cnt(size_t size) {
  mem_counter += size;
  max_conn_mem = std::max(max_conn_mem, mem_counter);
  // connection级别的报错
  if (mem_counter > m_thd->variables.conn_mem_limit) {
      (void)generate_error(ER_DA_CONN_LIMIT, m_thd->variables.conn_mem_limit,
                            mem_counter);
  }
  // 三个条件分别指代：开启全局更新、开启内存追踪、存量大于提前量
  if ((curr_mode & MEM_CNT_UPDATE_GLOBAL_COUNTER) &&
      m_thd->variables.conn_global_mem_tracking &&
      max_conn_mem > glob_mem_counter) {
    // 控制全局计数器更新频率
    const ulonglong curr_mem =
        (max_conn_mem / m_thd->variables.conn_mem_chunk_size + 1) *
        m_thd->variables.conn_mem_chunk_size;
    ulonglong delta = curr_mem - glob_mem_counter;
    ulonglong global_conn_mem_counter_save;
    ulonglong global_conn_mem_limit_save;
    {
      MUTEX_LOCK(lock, &LOCK_global_conn_mem_limit);
      global_conn_mem_counter += delta;
      global_conn_mem_counter_save = global_conn_mem_counter;
      global_conn_mem_limit_save = global_conn_mem_limit;
    }
    glob_mem_counter = curr_mem;
    max_conn_mem = std::max(max_conn_mem, glob_mem_counter);
      
    // global级别的报错
    if (global_conn_mem_counter_save > global_conn_mem_limit_save) {
      (void)generate_error(ER_DA_GLOBAL_CONN_LIMIT, global_conn_mem_limit_save,
                            global_conn_mem_counter_save);
    }
  }
  return true;
}

free_cnt()

和统计信息增加的方式不同，该函数的功能单一，只对connection级别的mem_counter做减法。那全局的计数信息如何减少呢？全局数据的修改在reset()函数中完成，这样做的目的同样是为了减少全局资源的竞用。显而易见，大多数情况下，全局的计数信息将会滞后于连接计数信息。

void Thd_mem_cnt_conn::free_cnt(size_t size) {
  mem_counter -= size;
}

free_cnt()操作只是减去了连接级别的内存计数，

free_cnt()操作只是减去了连接级别的内存计数，全局的计数数据更新在reset()函数中完成，该函数保证了当前global处于最新的状态。主要做了以下几件事：

重置mode，此前的一些操作可能会将计数器的mode进行修改（例如在prepare connection阶段），这里要确保更新前counter处于正确的模式，避免出现不同权限操作出错（如此前的SUPER和普通用户等）。
更新三个计数数据，当glob_mem_counter > mem_counter时，表明此前有free_cnt操作减少了mem_counter，此处对glob_mem_counter和全局数据进行更新；反之表明存在未加入全局内存统计的连接级别内存信息，也需要将差值补全。在reset()过程中也可能出现内存不足的情况，同样需要调用错误产生函数对错误信息进行报告，对THD设置killed标志。

int Thd_mem_cnt_conn::reset() {
  // 重置mode
  restore_mode();
  max_conn_mem = mem_counter;
  // 更新计数数据信息
  if (m_thd->variables.conn_global_mem_tracking &&
      (curr_mode & MEM_CNT_UPDATE_GLOBAL_COUNTER)) {
    ulonglong delta;
    ulonglong global_conn_mem_counter_save;
    ulonglong global_conn_mem_limit_save;
    if (glob_mem_counter > mem_counter) {
      delta = glob_mem_counter - mem_counter;
      MUTEX_LOCK(lock, &LOCK_global_conn_mem_limit);
      assert(global_conn_mem_counter >= delta);
      global_conn_mem_counter -= delta;
      global_conn_mem_counter_save = global_conn_mem_counter;
      global_conn_mem_limit_save = global_conn_mem_limit;
    } else {
      delta = mem_counter - glob_mem_counter;
      MUTEX_LOCK(lock, &LOCK_global_conn_mem_limit);
      global_conn_mem_counter += delta;
      global_conn_mem_counter_save = global_conn_mem_counter;
      global_conn_mem_limit_save = global_conn_mem_limit;
    }
    glob_mem_counter = mem_counter;
    if (is_connection_stage &&
        (global_conn_mem_counter_save > global_conn_mem_limit_save))
      return generate_error(ER_DA_GLOBAL_CONN_LIMIT, global_conn_mem_limit_save,
                            global_conn_mem_counter_save);
  }
  if (is_connection_stage && (mem_counter > m_thd->variables.conn_mem_limit))
    return generate_error(ER_DA_CONN_LIMIT, m_thd->variables.conn_mem_limit,
                          mem_counter);
  is_connection_stage = false;
  return 0;
}

flush()

该函数清空当前连接的内存计数，同时扣除全局的内存计数。在删除计数器对象前，必须要先调用此函数，确保计数信息正确。

void Thd_mem_cnt_conn::flush() {
  max_conn_mem = mem_counter = 0;
  if (glob_mem_counter > 0) {
    MUTEX_LOCK(lock, &LOCK_global_conn_mem_limit);
    global_conn_mem_counter -= glob_mem_counter;
  }
  glob_mem_counter = 0;
}

2. 内存限制的过程

2.1 执行流程

以最简单的handle_connection为例（非线程池模型），连接建立、执行语句和连接关闭过程对应的内存限制操作如下图所示：

...
if (thd_prepare_connection(thd))
  handler_manager->inc_aborted_connects();
else {
  while (thd_connection_alive(thd)) {
    if (do_command(thd)) break;
  }
  end_connection(thd);
}
close_connection(thd, 0, false, false);
...

2.2 关键函数

2.2.1 my_malloc()

构建内存块头部，其中保存了size、magic、psi_memory_key等信息；
构建内存块头部，其中保存了size、magic、psi_memory_key等信息；
调用PSI_thread_service_v5服务中的pfs_memory_alloc_vc()接口对key进行赋值，实际的计数器更新就在这个接口中进行。

void *my_malloc(PSI_memory_key key, size_t size, myf flags) {
  // malloc出一块包含header信息的内存块
  my_memory_header *mh;
  size_t raw_size;
  raw_size = PSI_HEADER_SIZE + size;
  mh = (my_memory_header *)my_raw_malloc(raw_size, flags);
  // 对header数据结构初始化，调用pfs_memory_alloc_vc对head->key进行赋值
  if (likely(mh != nullptr)) {
    void *user_ptr;
    mh->m_magic = PSI_MEMORY_MAGIC;
    mh->m_size = size;
    // 调用服务
    mh->m_key = PSI_MEMORY_CALL(memory_alloc)(key, raw_size, &mh->m_owner);
    user_ptr = HEADER_TO_USER(mh);
    MEM_MALLOCLIKE_BLOCK(user_ptr, size, 0, (flags & MY_ZEROFILL));
    return user_ptr;
  }
  return nullptr;
}

2.2.2 pfs_memory_alloc_vc()

根据key找到对应的PFS_memory_class；
根据key找到对应的PFS_memory_class；
获取PFS_thread，在启用了计数器的情况下，对统计数据进行更新。PFS_memory_key类型只要执行了注册memory_class逻辑（register_memory_class），就会启用计数器对象；
返回key值，若启用计数器，此时的key值是经过PSI_MEM_CNT_BIT（1 << 31）标记的。

PSI_memory_key pfs_memory_alloc_vc(PSI_memory_key key, size_t size,
                                    PSI_thread **owner) {
  // 获取key对应的PFS_memory_class
  PSI_memory_key result_key = key;
  ...
  PFS_memory_class *klass = find_memory_class(key);
  // 启动thread监控维度、非全局监控模式
  if (flag_thread_instrumentation && !klass->is_global()) {
    PFS_thread *pfs_thread = my_thread_get_THR_PFS();
    // 判断是否启用计数器，在PFS_memory_class初始化阶段
    if (klass->has_memory_cnt()) {
      if (pfs_thread->m_cnt_thd != nullptr && pfs_thread->mem_cnt_alloc(size)) // 内存信息增加的入口
        // 标志位，标记key是否经过计数器的处理
        result_key |= PSI_MEM_CNT_BIT;
    }
    // 统计信息更新
    ...
    *owner_thread = pfs_thread;
  } else {
    // 统计信息更新
    ...
    *owner_thread = nullptr;
  }
  return result_key;
}

2.2.3 my_free() && pfs_memory_free_vc()

问：哪些内存会被计数器进行统计呢？

答：在psi_memory_key.cc中，新特性引入的PSI_FLAG_MEM_COLLECT标志位，对all_server_memory数组中需要进行限制的内存打上了标签。

3. 内存限制的简单测试

3.1 测试准备

创建普通用户RDS_test；
构建大数据记录；
设置较小的connection_memory_limit。

create user RDS_test identified by 'RDS_test';
grant select on test.* to RDS_test;
use test;
create table t(id int primary key, c longtext);
insert t values (1, lpad('RDS', 6000000, 'test'));
set global connection_memory_limit=1024 * 1024 * 2;

3.2 测试

普通用户执行

MySQL [test]> show variables like "connection_memory_limit";
+-------------------------+---------+
| Variable_name           | Value   |
+-------------------------+---------+
| connection_memory_limit | 2097152 |
+-------------------------+---------+
MySQL [test]> select count(c) from t group by c;
ERROR 4082 (HY000): Connection closed. Connection memory limit 2097152 bytes exceeded. Consumed 7079568 bytes.

SUPER用户执行

MySQL [test]> show variables like "connection_memory_limit";
+-------------------------+---------+
| Variable_name           | Value   |
+-------------------------+---------+
| connection_memory_limit | 2097152 |
+-------------------------+---------+
MySQL [test]> select count(c) from t group by c;
+----------+
| count(c) |
+----------+
|        1 |
+----------+

3.3 测试结果

引入了这个功能后，普通用户的内存使用受到限制，超出限定值直接被kill，但SUPER用户还是不受限制的。

4. 总结展望

MySQL 8.0.28中带来的内存限制新特性，总结来说有以下几点：

对于SUPER用户和普通用户，内存限制有差别，前者不做限制，可能会引发OOM。
global数据的更新总是滞后于connection，减少了全局锁的争用。内存统计数据增加阶段，使用connection_memory_chunk_size来控制更新频率；内存统计数据减少阶段，connection和global级别的信息分别通过free_cnt()和reset()完成更新。
connection_memory_chunk_size设置的较大的情况下，容易提前报告OOM错误导致connection被kill；设置的较小则可能会导致全局锁的频繁访问。
内存统计和限制操作依赖于PFS_thread，计数器数据的更新首先通过该对象传递。

结合上篇和中篇，不难发现，InnoDB中的内存基本可控，大多数的内存都有指定的sizeƒ进行控制，额外产生的内存也能粗略的推断出。在MySQL服务过程中，还有许多无法准确估量的内存损耗，如果没有很好地对其进行控制，可能就会引发OOM。官方引入的connection/global的内存使用限制对这个情况进行了优化，降低了发生OOM的风险，但OOM的问题还无法完全避免，有待进一步优化。在最新的MySQL 8.0.31的release notes中可以看到，官方对于内存限制增加了一些监控信息，相信在后续也会推出相关的新功能、新特性，RDS MySQL内核团队也会持续对OOM问题进行优化。

此外，MySQL中的其它结构如net_buffer、join_buffer、sort_buffer等会在运行中占据不小内存，同时在Server启动的阶段也会产生许多临时性的内存如recovery、初始化等所需的内存，都值得研究和讨论。

参考

作者信息：

宋华雄（桦雄）RDS MySQL内核组

上篇在这里《【走进RDS】之MySQL内存分配与管理（上）》

中篇在这里《【走进RDS】之MySQL内存分配与管理（中）》

走进RDS之MySQL内存分配与管理（下）