Method do_memory_iterations

vmm/src/lib.rs:1203–1247

Performs the initial memory transmission (iteration zero) plus a variable number of memory iterations with the goal to eventually migrate the VM in a reasonably small downtime. This returns as soon as the precopy migration indicates it is converged (e.g., reasonably small downtime) is reached.

(
        vm: &mut Vm,
        socket: &mut SocketStream,
        ctx: &mut MemoryMigrationContext,
        is_converged: impl Fn(&MemoryMigrationContext) -> result::Result<bool, MigratableError>,
   

    /// This returns as soon as the precopy migration indicates it is converged
    /// (e.g., reasonably small downtime) is reached.
    fn do_memory_iterations(
        vm: &mut Vm,
        socket: &mut SocketStream,
        ctx: &mut MemoryMigrationContext,
        is_converged: impl Fn(&MemoryMigrationContext) -> result::Result<bool, MigratableError>,
        mem_send: &mut SendAdditionalConnections,
    ) -> result::Result<MemoryRangeTable /* remaining */, MigratableError> {
        loop {
            let iteration_begin = Instant::now();

            let iteration_table = if ctx.iteration == 0 {
                vm.memory_range_table()?
            } else {
                // TODO do this in a thread #7816
                vm.dirty_log()?
            };

            ctx.update_metrics_before_transfer(iteration_begin, &iteration_table);
            if is_converged(ctx)? {
                debug!("Precopy converged: {ctx}");
                break Ok(iteration_table);
            }

            // Send the current dirty pages
            let transfer_begin = Instant::now();
            mem_send.send_memory(iteration_table, socket)?;
            let transfer_duration = transfer_begin.elapsed();
            ctx.update_metrics_after_transfer(transfer_begin, transfer_duration);

            // Log progress of the current iteration
            debug!("Precopy: {ctx}");

            // Enables management software (e.g., libvirt) to easily track forward progress.
            event!(
                "vm",
                "migration-memory-iteration",
                "id",
                ctx.iteration.to_string()
            );

            // Increment iteration last: This way we ensure that the logging
            // above matches the actual iteration.
            ctx.iteration += 1;
        }
    }

    /// Checks whether the precopy memory migration has converged and it is safe
    /// to proceed to the final (paused) memory iteration.