我们知道QEMU的内存迁移分为pre-copy，post-copy，这通过内存拷贝的时间段来区分，当内存拷贝在目的虚机启动之前完成，称为pre-copy，反之称为post-copy。这两种迁移拷贝内存数据都在迁移线程中完成。multifd则不同，它发送内存数据在专门的线程中完成，每个线程都通过socket连接到目的端，建立一个发送通道，所有线程可以并行发送内存数据。 multifd迁移与普通迁移的主要区别在于以下两点： 连接建立方式 内存拷贝方式 multifd迁移流的开头通过一个初始包标识自己，这个包在每个multfd线程开始发送数据前传输给对端，用于确认迁移方式。 typedef struct {
uint32_t magic;
uint32_t version;
unsigned char uuid[16]; /* QemuUUID */
uint8_t id;
uint8_t unused1[7]; /* Reserved for future use */
uint64_t unused2[4]; /* Reserved for future use */
} __attribute__((packed)) MultiFDInit_t;
multifd线程一次性会发送多个物理页，最多可以累计至128个(4k页大小)，MultiFDPacket_t用于记录multifd线程本次发送物理页的元数据，这些元数据作为数据，在内存页数据发送之前，提前发送到对端。multifd线程会把MultiFDPacket_t结构作为流数据一起发送到对端。 /* This value needs to be a multiple of qemu_target_page_size() */
/* 一个 multifd 包大小为 512k, 如果每个offset[]数组元素描述一个 4k 页的地址
* 则 offset[] 数组大小为 512 / 4 = 128 个数组，当 offset 数组满，则发送数据
*/
#define MULTIFD_PACKET_SIZE (512 * 1024)
typedef struct {
uint32_t magic;
uint32_t version;
uint32_t flags;
/* maximum number of allocated pages */
/* 每个页作为一个iov向量写入侧通道的流中
* 多个页就有多个iov，multifd累计一定数量的内存页之后一起发送
* pages_alloc表示最大可累计的内存页数，QEMU在迁移准备阶段
* 会分配相应大小的iov数组 */
uint32_t pages_alloc;
/* 已经累计的内存页数目 */
uint32_t pages_used;
/* size of the next packet that contains pages */
/* 侧通道的流中既包含元数据又包含数据
* next_packet_size用于指示侧通道流中
* 下一次包含packet的位置 */
uint32_t next_packet_size;
/* 迁移线程每次交给multifd发送的内存页，都是许多个
* QEMU将一次性传输的多个内存页定义成一个packet
* multifd每发送一次就记录一下packet的数目
* packet_num用于记录发送包的数目 */
uint64_t packet_num;
uint64_t unused[4]; /* Reserved for future use */
/* 存放发送的内存页所在的RAMBlock的idstr */
char ramblock[256];
uint64_t offset[];
} __attribute__((packed)) MultiFDPacket_t;
MultiFDPages_t用于维护multifd线程一次性要发送的host物理页，multfd线程每次发送的物理页都属于同一个RAMBlock，同一个RAMBlock的物理页累计到128个页再发送(页大小4k)，不同的RAMBlock的物理页需要分开发送。因为每次multifd线程发送的物理页都属于同一个RAMBlock，因此MultiFDPages_t中设计了一个block结构指向发送物理页所属的RAMBlock。 如果连续发送同一个RAMBlock的物理页，需要累计128个物理页才能发送，因此发送的iov向量是个数组，初始化的数组大小为128，iov[]数组每个元素指向一个物理页。同理，还需要一个offset来保存iov[]数组中每个对应物理页在RAMBlock中的偏移。iov和offset域设计的目的在此。 typedef struct {
/* number of used pages */
/* iov数组中已经存放了物理页地址的元素个数 */
uint32_t used;
/* number of allocated pages */
/* iov数组的大小 */
uint32_t allocated;
/* global number of generated multifd packets */
uint64_t packet_num;
/* offset of each page */
/* iov数组每个元素指向的物理页在RAMBlock的偏移 */
ram_addr_t *offset;
/* pointer to each page */
/* 每个元素指向同一个RAMBlock的物理页 */
struct iovec *iov;
/* iov数组中指向的所有物理页所属的RAMBlock */
RAMBlock *block;
} MultiFDPages_t;
从上面三个数据结构可以大致勾勒出侧通道中发送的数据格式，如下图所示： Multifd的特点是启动多个线程，同时和对端建立socket连接并发送数据，每个线程的socket连接被QEMU封装成一个channel，channel需要发送的内存被维护在MultiFDPages_t中，每个multifd发送数据需要的所有参数被封装成MultiFDSendParams，它的核心数据就是一个channel和要发送的内存页，分别用c和pages表示。 MultiFDSendParams有部分信息用于线程同步，sem字段用于通知multfd线程发送数据，mutex字段用于保护MultiFDSendParams，因为迁移线程和multifd线程都要修改这个结构。quit字段用于指示multifd线程是否停止工作typedef struct {
/* this fields are not changed once the thread is created */
/* channel number */
uint8_t id;
/* channel thread name */
/* multifd发送线程名字，格式：multifdsend_%d */
char *name;
/* tls hostname */
char *tls_hostname;
/* channel thread id */
/* 指向multifd线程 */
QemuThread thread;
/* communication channel */
/* multifd数据发往的通道 */
QIOChannel *c;
/* sem where to wait for more work */
/* multifd睡眠在此信号量，直到被其它线程唤醒，开始工作，发送数据 */
QemuSemaphore sem;
/* this mutex protects the following parameters */
/* 以下的字段可能被迁移线程和multifd线程同时修改，mutex用于保护以下字段 */
QemuMutex mutex;
/* is this channel thread running */
bool running;
/* should this thread finish */
bool quit;
/* thread has work to do */
/* 当前multifd线程是否 */
int pending_job;
/* array of pages to sent */
/* 迁移线程准备好pages之后，与multifd线程交换指针
* multifd指向迁移线程准备好的pages，然后发送内存数据 */
MultiFDPages_t *pages;
/* packet allocated len */
uint32_t packet_len;
/* pointer to the packet */
MultiFDPacket_t *packet;
/* multifd flags for each packet */
uint32_t flags;
/* size of the next packet that contains pages */
uint32_t next_packet_size;
/* global number of generated multifd packets */
uint64_t packet_num;
/* thread local variables */
/* packets sent through this channel */
/* 记录通过此channel发送的物理页累积大小 */
uint64_t num_packets;
/* pages sent through this channel */
uint64_t num_pages;
/* syncs main thread and channels */
/* 迁移线程迭代发送数据时，每次结束时需要等待multifd线程完成发送
* 这时迁移线程睡眠在sem_sync，当multifd线程发送完成后通过
* sem_sync唤醒迁移线程 */
QemuSemaphore sem_sync;
/* used for compression methods */
void *data;
} MultiFDSendParams;
multifd_send_state是一个全局变量，它指向一个全局结构体，主要维护multifd线程的全局信息，包括每个fd线程的参数、迁移线程准备要发送的内存页、fd线程的状态等。struct {
/* fd线程发送内存需要的参数数组
* multifdsend_0对应params[0]
* multifdsend_1对应params[1]，以此类推
* */
MultiFDSendParams *params;
/* array of pages to sent */
/* 迁移线程找到脏页后封装成pages，临时存放在该字段
* 当需要让fd线程发送这些pages时，让fd线程指向的pages
* 与该字段指向的pages交换 */
MultiFDPages_t *pages;
/* global number of generated multifd packets */
uint64_t packet_num;
/* send channels ready */
/* 当fd线程中有任意一个准备好之后，会唤醒等待在该信号量
* 上的迁移线程，让迁移线程继续工作 */
QemuSemaphore channels_ready;
/*
* Have we already run terminate threads. There is a race when it
* happens that we got one error while we are exiting.
* We will use atomic operations. Only valid values are 0 and 1.
*/
int exiting;
/* multifd ops */
MultiFDMethods *ops;
} *multifd_send_state;
在介绍multifd流程之前，我们先尝试分析multifd迁移的发送原理，如果单独理解发送原理有问题，再跳到后面一节看迁移的核心流程。multifd迁移，顾名思义，多fd迁移，这里的fd就是创建socket连接或者其它连接返回的fd，总之，就是有多个通道可以并发地发送数据。每个通道专门启动了一个线程来负责发送数据。multifd发送示意图如下： 所有multifd线程发送需要的信息被封装成params数组，数组每个元素对应一个multifd线程需要的信息，param的核心数据是pages，即要发送的内存页指针，每个multifd线程都维护了这样一个信息，同时还有一个全局的公共的pages指针，指向迁移线程搜集的需要发送的内存页。 如果上层在内存迁移时指定N个multifd线程用于发送内存数据(libvirt通过–parallel-connections=N指定)，那么multifd线程就有N个，指向内存页指针的pages有N+1个(N个属于multifd线程，1个全局的但只有迁移线程会操作)。 如上图所示，当迁移线程进入迭代迁移阶段，每次迭代可以概括成两步，第一步是搜集可以发送的脏页内存，第二部发送脏页内存，迁移线程在第一步中将脏页内存的地址放到全局变量multifd_send_state的pages字段。然后查找空闲的multifd线程，将其pages指针与全局变量multifd_send_state的pages指针交换，这样空闲的multifd线程就获取了需要发送的物理页，然后迁移线程唤醒空闲multifd线程，开始工作。当进入下一次迭代时，迁移线程将新找到的脏页内存地址又放入multifd_send_state的pages字段，查找新的空闲multifd线程，继续发送物理页。 由上面的分析可知，multifd_send_state中的pages字段会依次与空闲multifd线程的pages字段交换内容，不断地在变换。迁移线程负责查找内存脏页，multifd线程负责发送脏页，当所有multifd都忙起来的时候，内存迁移发送数据的能力达到最大值，这时迁移线程如果再找到新的内存脏页，需要等待multifd线程空闲之后才能再次发送数据。 迁移线程迭代查找脏页内存，触发multifd线程发送内存数据的流程如下： /* 迁移线程入口点 */
migration_thread
migration_iteration_run
qemu_savevm_state_iterate
se->ops->save_live_iterate
/* 迁移迭代的入口点 */
ram_save_iterate
ram_find_and_save_block
ram_save_host_page
ram_save_target_page
ram_save_multifd_page
multifd_queue_page
multifd_queue_page函数将找到的脏页内存地方存放到multifd_send_state全局变量，分析其具体实现。/* 入参：
* f，迁移线程的主通道，在multifd中只用来已传输的数据长度
* block，内存脏页所在的RAMBlock，迁移线程是逐block查找的脏页内存
* offset，内存脏页通常只占用RAMBlock的一小段4k区间，offset表示内存脏页的起始地址 */
int multifd_queue_page(QEMUFile *f, RAMBlock *block, ram_addr_t offset)
{
/* 首先获取全局变量multifd_send_state中的pages字段 */
MultiFDPages_t *pages = multifd_send_state->pages;
/* pages字段存放的是与multifd线程pages交换的值，或者初始值
* 如果block为空，表示之前还没有发送过内存页 */
if (!pages->block) {
pages->block = block;
}
/* 如果当前迁移线程要发送的内存页与前一次发送的内存页所在
* RAMBlock相同，将内存页地址保存到iov[]的地址中，长度设置为页大小 */
if (pages->block == block) {
/* 保存发送页在RAMBlock中的偏移 */
pages->offset[pages->used] = offset;
/* 保存发送页的HVA */
pages->iov[pages->used].iov_base = block->host + offset;
/* 设置页大小 */
pages->iov[pages->used].iov_len = qemu_target_page_size();
/* 每填充一个页到iov数组，增加一次使用计数 */
pages->used++;
/* 如果累计的页没有到最大值，直接返回，这里的最大值为128个物理页，下文有介绍 */
if (pages->used < pages->allocated) {
return 1;
}
}
/* 有两种情况可以触发multifd线程发送物理页:
* 1. 当前发送的物理页所在RAMBlock与前一次发送的物理页所在RAMBlock不同
* 2. 当前发送的物理页个数累计达到了128个 */
if (multifd_send_pages(f) < 0) {
return -1;
}
/* 进入到这里只有一种情况
* 当前物理页所在RAMBlock与前一次发送的物理页所在RAMBlock互不相同
* 需要再次调用multifd_queue_page，将本次要发送的物理页真正地入队 */
if (pages->block != block) {
return multifd_queue_page(f, block, offset);
}
return 1;
}
multifd_send_pages的主要工作是遍历所有multifd线程，查找空闲的线程，将要发送的内存页地址传递给空闲线程，然后唤醒它，使其工作，流程如下：static int multifd_send_pages(QEMUFile *f)
{
/* 本次查找空闲线程的起始值，每次加1 */
static int next_channel;
MultiFDSendParams *p = NULL; /* make happy gcc */
MultiFDPages_t *pages = multifd_send_state->pages;
uint64_t transferred;
/* 首先睡眠在channels_ready信号量上，等待空闲的线程将自己唤醒 */
qemu_sem_wait(&multifd_send_state->channels_ready);
/*
* next_channel can remain from a previous migration that was
* using more channels, so ensure it doesn't overflow if the
* limit is lower now.
*/
next_channel %= migrate_multifd_channels();
/* 遍历所有multifd线程使用的连接通道，查找空闲的multifd线程 */
for (i = next_channel;; i = (i + 1) % migrate_multifd_channels()) {
p = &multifd_send_state->params[i];
qemu_mutex_lock(&p->mutex);
/* 如果线程没有任务，说明其空闲，找到目标 */
if (!p->pending_job) {
p->pending_job++;
next_channel = (i + 1) % migrate_multifd_channels();
break;
}
qemu_mutex_unlock(&p->mutex);
}
assert(!p->pages->used);
assert(!p->pages->block);
/* multifd线程发送的内存页被封装成packet的概念
* 每发送一次，增加packet的计数 */
p->packet_num = multifd_send_state->packet_num++;
/* 将全局变量中的页指针和找到的multifd空闲线程的内存页指针交换
* 通过这种方式，multifd线程得到了要发送的内存页
* 而全局变量中的页指针作为了一个中转站
* 用于存放迁移线程准备好的，需要让multifd线程发送的页指针 */
multifd_send_state->pages = p->pages;
p->pages = pages;
transferred = ((uint64_t) pages->used) * qemu_target_page_size()
+ p->packet_len;
qemu_file_update_transfer(f, transferred);
ram_counters.multifd_bytes += transferred;
ram_counters.transferred += transferred;
qemu_mutex_unlock(&p->mutex);
/* 所有准备工作完成之后，唤醒等待在sem上的multifd线程，让其开始工作 */
qemu_sem_post(&p->sem);
return 1;
}
multifd线程被创建出来之后，它的工作很简单，可以概括为：睡眠、被唤醒、发送数据、继续睡眠。循环如此，直到被通知停止工作。 static void *multifd_send_thread(void *opaque)
{
MultiFDSendParams *p = opaque;
Error *local_err = NULL;
int ret = 0;
uint32_t flags = 0;
/* 发送初始化包到对端，表明自己开始进行multifd数据发送 */
multifd_send_initial_packet(p, &local_err)
/* initial packet */
p->num_packets = 1;
/* 无限循环 */
while (true) {
/* 睡眠在sem信号量上，直到迁移线程准备好要发送的数据，将自己唤醒 */
qemu_sem_wait(&p->sem);
/* multifd线程被唤醒，如果被告知结束工作，则退出循环 */
if (qatomic_read(&multifd_send_state->exiting)) {
break;
}
qemu_mutex_lock(&p->mutex);
/* 如果迁移线程标记有等待的任务，则进入工作流程 */
if (p->pending_job) {
if (used) {
ret = multifd_send_state->ops->send_prepare(p, used,
&local_err);
}
/* 填充packet的元数据 */
multifd_send_fill_packet(p);
p->flags = 0;
p->num_packets++;
p->num_pages += used;
p->pages->used = 0;
p->pages->block = NULL;
qemu_mutex_unlock(&p->mutex);
/* 发送packet的元数据 */
ret = qio_channel_write_all(p->c, (void *)p->packet,
p->packet_len, &local_err);
/* 发送内存页 */
if (used) {
ret = multifd_send_state->ops->send_write(p, used, &local_err);
if (ret != 0) {
break;
}
}
qemu_mutex_lock(&p->mutex);
p->pending_job--;
qemu_mutex_unlock(&p->mutex);
/* 发送结束，将同步等待在sem_sync信号量上的线程唤醒 */
if (flags & MULTIFD_FLAG_SYNC) {
qemu_sem_post(&p->sem_sync);
}
/* 发送结束，将等待在channels_ready上的线程唤醒
* 表明自己准备好了，可以进行下一轮的数据传输 */
qemu_sem_post(&multifd_send_state->channels_ready);
}
}
......
}
multifd建立了两次连接，第一个是迁移命令下发的初始阶段，建立的主迁移通道，第二个是迁移准备阶段，建立的侧通道。初始阶段建立主迁移通道的代码路径如下： /* 上层发起内存迁移触发迁移命令 */
qmp_migrate
socket_start_outgoing_migration
socket_start_outgoing_migration_internal
/* 将对端的socket连接地址存放到全局变量outgoing_args中
* 建立侧通道连接时可以使用该地址 */
outgoing_args.saddr = saddr
/* 创建一个线程异步地创建socket连接，然后将其封装成一个QIOChannelSocket
* 它的父类是QIOChannel，QEMU通过操作QIOChannel来向对端发送内存数据
* 该函数首先创建socket连接，同时将该socket_outgoing_migration函数封装成
* 一个任务，当socket连接创建完成后，创建一个线程来执行该任务，因此
* socket_outgoing_migration在最后会在一个单独创建的线程中被执行 */
qio_channel_socket_connect_async(sioc,
saddr,
socket_outgoing_migration,
data,
socket_connect_data_free,
NULL);
qio_task_run_in_thread(task,
qio_channel_socket_connect_worker,
addrCopy,
(GDestroyNotify)qapi_free_SocketAddress,
context)
/* 创建socket连接 */
qio_channel_socket_connect_worker
qio_channel_socket_connect_sync
socket_connect
qio_channel_socket_set_fd
/* 创建线程异步执行qio_task_thread_worker */
qio_channel_socket_connect_async
qio_task_run_in_thread
qemu_thread_create(&thread,
"io-task-worker",
qio_task_thread_worker,
task,
QEMU_THREAD_DETACHED);
/* 设置socket连接完成之后需要回调的任务 */
qio_task_thread_worker
/* qio_task_thread_result为socket连接完成后要回调的函数
* 传入的task中有要执行的任务 */
g_source_set_callback(task->thread->completion,
qio_task_thread_result, task, NULL)
/* 执行迁移函数socket_outgoing_migration */
qio_task_thread_result
qio_task_complete(task)
task->func(task, task->opaque) <=> socket_outgoing_migration
/* 迁移发起入口点 */
socket_outgoing_migration
migration_channel_connect
migrate_fd_connect
/* 迁移前multifd相关准备 */
multifd_save_setup
qemu_thread_create(&s->thread, "live_migration", migration_thread, s,
QEMU_THREAD_JOINABLE);
/* multifd设置入口 */
multifd_save_setup
socket_send_channel_create(multifd_new_send_channel_async, p)
qio_channel_socket_connect_async(sioc, outgoing_args.saddr,
f, data, NULL, NULL)
qio_task_run_in_thread(task,
qio_channel_socket_connect_worker,
addrCopy,
(GDestroyNotify)qapi_free_SocketAddress,
context)
multifd迁移的准备工作主要在multifd_save_setup函数中完成，它负责初始化每个multifd线程需要的参数，创建multifd线程。如下： int multifd_save_setup(Error **errp)
{
/* 默认累计发送内存页的上限，128页，当同一个RAMBlock中累计到128个物理页
* multifd线程才开始传输数据，在这之前只是将要发送的内存页的地址存放在iov[]数组中 */
uint32_t page_count = MULTIFD_PACKET_SIZE / qemu_target_page_size();
/* 如果没有启用multifd迁移，直接返回 */
if (!migrate_use_multifd()) {
return 0;
}
s = migrate_get_current();
/* 获取上层设置的multifd线程数，默认为2 */
thread_count = migrate_multifd_channels();
/* 为全局数据结构multifd_send_state分配空间 */
multifd_send_state = g_malloc0(sizeof(*multifd_send_state));
/* 为每个multifd线程分配对应的params数据结构 */
multifd_send_state->params = g_new0(MultiFDSendParams, thread_count);
/* 初始化全局变量中的pages指针 */
multifd_send_state->pages = multifd_pages_init(page_count);
qemu_sem_init(&multifd_send_state->channels_ready, 0);
qatomic_set(&multifd_send_state->exiting, 0);
multifd_send_state->ops = multifd_ops[migrate_multifd_compression()];
/* 针对每个multifd线程对应的params参数 */
for (i = 0; i < thread_count; i++) {
MultiFDSendParams *p = &multifd_send_state->params[i];
qemu_mutex_init(&p->mutex);
qemu_sem_init(&p->sem, 0);
qemu_sem_init(&p->sem_sync, 0);
p->quit = false;
p->pending_job = 0;
p->id = i;
p->pages = multifd_pages_init(page_count);
p->packet_len = sizeof(MultiFDPacket_t)
+ sizeof(uint64_t) * page_count;
p->packet = g_malloc0(p->packet_len);
p->packet->magic = cpu_to_be32(MULTIFD_MAGIC);
p->packet->version = cpu_to_be32(MULTIFD_VERSION);
p->name = g_strdup_printf("multifdsend_%d", i);
p->tls_hostname = g_strdup(s->hostname);
/* 创建socket连接，同时创建对应的multifd线程，专门负责传输数据 */
socket_send_channel_create(multifd_new_send_channel_async, p);
}
......
}
/* 迁移迭代入口点 */
migration_iteration_run
qemu_savevm_state_iterate
se->ops->save_live_iterate <=> ram_save_iterate
/* 查找脏页然后异步发送*/
ram_find_and_save_block
/* 遍历所有RAMBlock，查找其中可以发送的内存脏页 */
do {
/* 查找包含脏页的block */
find_dirty_block
/* 异步发送脏页内容 */
ram_save_host_page
} while (!pages && again)
/* 等待multifd线程发送脏页结束，然后进入下一次迭代 */
multifd_send_sync_main
multifd 相比标准迁移可以更好的利用带宽，因此在 10Gb 或 25Gb 网络环境更能发挥优势。我们的测试分别在 10Gb 和 1Gb 网络环境进行，主要对比 multifd 和标准迁移，并说明适用场景。 测试虚机规格：32C64G 测试负载我们使用 sysbench 跑 mysql 数据库，命令如下： sysbench oltp_read_write --mysql-host=localhost --mysql-user=root --mysql-password='root@123HC!r0cks' --mysql-db=sbtest --report-interval=1 --threads=64 --tables=10 --table-size=10000000 --time=300
网络总带宽 非迁移情况下 mysql 性能基线数据 标准迁移 以下为迁移网络和存储网络共享 10Gb 带宽 mysql 性能基线数据，相同条件下重复 3 次测试。每次测试 300 秒，热迁移平均时长为 134s，热迁移过程中剩余带宽：4.73 Gb/s、占用带宽：4.67 Gb/s： 以下为使用 1Gb 网卡作为迁移网络，mysql 性能基线数据， 1 次测试，热迁移时长 911 s： 以下为迁移网络和存储网络共享 10Gb 网络的 mysql 性能基线数据，以下作为迁移网络 mysql 性能基线数据， 2 次测试，热迁移平均时长 135 s，4 fd: 剩余带宽： 1.87 Gb/s、占用带宽：7.53 Gb/s： 结果分析： 仅开启 multifd 不设置压缩，1fd、2fd、4fd、6fd、8fd下的性能曲线： zstd compression level: 0 , 1fd、2fd、4fd、6fd、8fd 下的性能曲线: zstd compression level: 1 , 1fd、2fd、4fd、6fd、8fd 下的性能曲线: 结果分析： zstd compression level: 1, 1fd、2fd、4fd、6fd、8fd 下的性能曲线: 结果分析：
扫一扫
1493
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
