Влияет ли скорость приращения на тактовую частоту

Question

Рассмотрим цикл ниже. Это упрощенный пример проблемы, которую я пытаюсь решить. Я хочу ограничить количество вызовов функции doSomething каждую секунду. Поскольку цикл работает очень быстро, я подумал, что могу использовать ограничитель скорости. Предположим, что я нашел подходящее значение, запустив его с разными числами x .

      unsigned int incrementionRate = x;
unsigned int counter == 0;

while (true) {

    double seconds = getElapsedSeconds();
    print(seconds);

    counter = (counter + 1) % incrementionRate;
    if (counter == 0) {
        doSomething();
    }
}

Интересно, было бы количество вызовов функции doSomething меньше, если бы я работал на более низкой тактовой частоте . В этом случае я хотел бы ограничить количество вызовов функции doSomething до одного раза в секунду. Второй цикл, который я написал, ниже.

      float epsilon = 0.0001;
while (true) {

    double seconds = getElapsedSeconds();
    print(seconds);

    if (abs(seconds - floor(seconds)) <= epsilon) {
        doSomething();
    }
}

Подойдет ли это для разных тактовых циклов, или проблемы все еще есть? Кроме того, я хотел бы знать, есть ли лучший способ сделать это. Я никогда раньше не работал с тактовой частотой и пытался понять, чем отличаются проблемы при работе с ограниченными ресурсами.

Примечание. Использование сна не вариант.

Answer 1

Если я хорошо понимаю суть проблемы, вы можете использовать std::chrono::steady_clock что вы просто добавляете секунду каждый раз, когда проходит секунда.

Пример:

      #include <chrono>

auto end_time = std::chrono::steady_clock::now();

while (true) {
    // only call doSomething once a second
    if(end_time < std::chrono::steady_clock::now()) {
        doSomething();
        // set a new end time a second after the previous one
        end_time += std::chrono::seconds(1);
    }

    // do something else
}

Answer 2

Ted Lyngmo «S ответ хорошо , если вы действительно делаете что - то еще в цикле; если не менее, это приводит к занятому ожиданию , которые просто потребляют ваш процессор ничего.

В таком случае вам лучше позволить своему потоку спать:

          std::chrono::milliseconds offset(200);
    auto next = std::chrono::steady_clock::now();
    for(;;)
    {
        doSomething();
        next += offset;
        std::this_thread::sleep_until(next);
    }

Вам нужно будет включить chrono а также thread заголовки для.

Answer 3

В конце я решил пойти с гораздо более простым подходом. Использовал настраиваемый временной интервал и просто сохранял время последнего обновления без введения какого-либо нового механизма. Честно говоря, теперь я не знаю, почему я сначала не мог об этом подумать. Излишнее мышление - проблема. :)

      double lastUpdateTimestamp = 0;
const double updateInterval = 1.0;

while (true) {

    double seconds = getElapsedSeconds();
    print(seconds);

    if ((elapsedSeconds - lastUpdateTimestamp) >= updateInterval) {
        doSomething();
        lastUpdateTimestamp = elapsedSeconds;
    }
}