udpif_revalidator(void *arg)
{
    /* Used by all revalidators. */
    struct revalidator *revalidator = arg;
    struct udpif *udpif = revalidator->udpif;
    bool leader = revalidator == &udpif->revalidators[0];

    /* Used only by the leader. */
    long long int start_time = 0;
    uint64_t last_reval_seq = 0;
    size_t n_flows = 0;

    revalidator->id = ovsthread_id_self();
    for (;;) {
        if (leader) {
            // recirc_run()回收释放struct recirc_id_node内的struct recirc_state结构
            recirc_run()；
            // 在dpif层(datapath)读取流的总数，udpif->n_flows_timestamp记录了上一次读取操作的
            // 时间，udpif->n_flows记录了上一次读取的值，如果当前时间与上一次读取操作的时间间隔
            // 不超过100ms，则继续使用上一次读取的值。否则执行一次新的读取操作
            n_flows = udpif_get_n_flows(udpif);
            
            udpif->pause = latch_is_set(&udpif->pause_latch);
            udpif->reval_exit = latch_is_set(&udpif->exit_latch);
            start_time = time_msec();
            if (!udpif->reval_exit) {
                bool terse_dump;

                terse_dump = udpif_use_ufid(udpif);
                // dpif_flow_dump_create()创建一个dump上下文
                udpif->dump = dpif_flow_dump_create(udpif->dpif, terse_dump,
                                                    NULL);
            }
        }
        /* Wait for the leader to start the flow dump. */
        ovs_barrier_block(&udpif->reval_barrier);
        if (udpif->pause) {
            revalidator_pause(revalidator);
        }
        // 更改线程数量时候，这里会退出
        if (udpif->reval_exit) {
            break;
        }
        // 最重要的地方，进行验证，决定megaflow是否删除，修改
        revalidate(revalidator);

        /* Wait for all flows to have been dumped before we garbage collect. */
        ovs_barrier_block(&udpif->reval_barrier);
        // 上边的revalidate只能重验证datapath里面有的flow，但是有些被删了，
        // 可是ukey还存在，sweep就是清除残余无用的ukey
        revalidator_sweep(revalidator);
        
        ovs_barrier_block(&udpif->reval_barrier);

        if (leader) {
            unsigned int flow_limit;
            long long int duration;

            atomic_read_relaxed(&udpif->flow_limit, &flow_limit);

            dpif_flow_dump_destroy(udpif->dump);
            // 这里会dump_seq++
            seq_change(udpif->dump_seq);
            // 默认ofproto_flow_reduce_point=2000ms， ofproto_flow_quater_point=1300ms
            // 1. 如果revalidate时间大于2秒，就将flow_limit调小duration/1000倍
            // 2. 如果revalidate时间大于1.3秒，就将flow_limit调成3/4
            // 3. 如果revalidate时间小于1秒并且flow_limit小于实际上1秒可以revalidate的数量，就+1000
            duration = MAX(time_msec() - start_time, 1);
            udpif->dump_duration = duration;
            if (duration > ofproto_flow_reduce_point) { 
                flow_limit /= duration / 1000;
            } else if (duration > ofproto_flow_quater_point) {
                flow_limit = flow_limit * 3 / 4;
            } else if (duration < 1000 &&
                       flow_limit < n_flows * 1000 / duration) {
                flow_limit += 1000;
            }
            flow_limit = MIN(ofproto_flow_limit, MAX(flow_limit, 1000));
            atomic_store_relaxed(&udpif->flow_limit, flow_limit);

            if (duration > 2000) {
                VLOG_INFO("Spent an unreasonably long %lldms dumping flows",
                          duration);
            }
            // 这里就会用上设置的max_revalidator，比如设置了4秒，其中进行revalidate花费了2秒，就会再睡眠2秒
            // 表示4秒进行一次revalidate
            poll_timer_wait_until(start_time + MIN(ofproto_max_idle,
                                                   ofproto_max_revalidator));
            seq_wait(udpif->reval_seq, last_reval_seq);
            latch_wait(&udpif->exit_latch);
            latch_wait(&udpif->pause_latch);
            poll_block();

            if (!latch_is_set(&udpif->pause_latch) &&
                !latch_is_set(&udpif->exit_latch)) {
                long long int now = time_msec();
                /* Block again if we are woken up within 5ms of the last start
                 * time. */
                start_time += 5;
                // 如果上边的revalidate什么的加一起5ms内搞完，就再block着
                if (now < start_time) {
                    poll_timer_wait_until(start_time);
                    latch_wait(&udpif->exit_latch);
                    latch_wait(&udpif->pause_latch);
                    poll_block();
                }
            }
        }
    }

    return NULL;
}