Method throttleWait

gui/qt/emuthread.cpp:185–227

}

void EmuThread::throttleWait() {
    int speed;
    bool throttle;
    {
        std::unique_lock<std::mutex> lockSpeed(m_mutexSpeed);
        speed = m_speed;
        throttle = m_throttle;
        if (!speed && throttle) {
            emit sendSpeed(0);
            m_cvSpeed.wait(lockSpeed, [this] { return m_speed != 0 || !m_throttle; });
            speed = m_speed;
            throttle = m_throttle;
            m_lastTime = std::chrono::steady_clock::now();
        }
    }
    double run_rate = sched_get_clock_rate_precise(CLOCK_RUN);
    std::chrono::steady_clock::time_point cur_time = std::chrono::steady_clock::now();
    if (!throttle) {
        m_lastTime = cur_time;
        std::this_thread::yield();
    } else {
        std::chrono::steady_clock::duration interval(std::chrono::duration_cast<std::chrono::steady_clock::duration>
                                                     (std::chrono::duration<double>(100 / (speed * run_rate))));
        std::chrono::steady_clock::time_point next_time = m_lastTime + interval;
        std::chrono::steady_clock::time_point tolerance_time = m_lastTime + std::chrono::milliseconds(40);
        if (cur_time < std::max(next_time, tolerance_time)) {
            m_lastTime = next_time;
            if (cur_time < next_time) {
                std::this_thread::sleep_until(next_time);
            }
        } else {
            m_lastTime = cur_time;
            std::this_thread::yield();
        }
    }
    std::chrono::steady_clock::time_point timeNUnitsAgo = m_perfArray[m_perfIndex];
    m_perfArray[m_perfIndex] = m_lastTime;
    if (++m_perfIndex == PerfArraySize) {
        m_perfIndex = 0;
    }
    std::chrono::duration<double> diff = m_lastTime - timeNUnitsAgo;
    emit sendSpeed(diff.count() * run_rate * (1.0 / PerfArraySize));
}

void EmuThread::unblock() {
    m_mutex.lock();