web-dev-qa-db-ja.com

C ++でループ内のFPSを制限する方法は？

クロノとスレッドでC++を使用して、交差チェックを実行しているループで1秒あたりのフレーム数を制限しようとしています。

これが私のコードです：

std::chrono::system_clock::time_point now = std::chrono::system_clock::now();
std::chrono::system_clock::time_point lastFrame = std::chrono::system_clock::now();

while (true)
{
    // Maintain designated frequency of 5 Hz (200 ms per frame)
    now = std::chrono::system_clock::now();
    std::chrono::duration<double, std::milli> delta = now - lastFrame;
    lastFrame = now;

    if (delta.count() < 200.0)
    {
        std::chrono::duration<double, std::milli> delta_ms(200.0 - delta.count());
        auto delta_ms_duration = std::chrono::duration_cast<std::chrono::milliseconds>(delta_ms);
        std::this_thread::sleep_for(std::chrono::milliseconds(delta_ms_duration.count()));
    }

    printf("Time: %f \n", delta.count());

    // Perform intersection test

}

私が抱えている問題は、deltaのその他すべての出力が、私が目指している〜200 ms /フレームではなく、ごくわずかな量を示していることです。

Time: 199.253200
Time: 2.067700
Time: 199.420400
Time: 2.408100
Time: 199.494200
Time: 2.306200
Time: 199.586800
Time: 2.253400
Time: 199.864000
Time: 2.156500
Time: 199.293800
Time: 2.075500
Time: 201.787500
Time: 4.426600
Time: 197.304100
Time: 4.530500
Time: 198.457200
Time: 3.482000
Time: 198.365300
Time: 3.415400
Time: 198.467400
Time: 3.595000
Time: 199.730100
Time: 3.373400

なぜこれが起こっているのかについての考えはありますか？

c++chrono
24
Irongrave

コードがどのように機能するかを考えると、コードが記述したとおりに機能することがわかります。コードの論理的な誤りのため、Deltaが発振します。

これは何が起こるかです：

  • _delta == 0_から始めます。
  • デルタは_200_よりも小さいため、コードはスリープ200 - delta(0) == 200 msです。
  • これで、デルタ自体が_200_に近づき（そのスリープ時間と実際の作業を測定したため）、200 - delta(200) == 0 msスリープします。
  • その後、サイクルが繰り返されます。

問題を解決するには、睡眠時間を測定する必要はありません。

これは、それを行う方法です。

_#include <iostream>
#include <cstdio>
#include <chrono>
#include <thread>

std::chrono::system_clock::time_point a = std::chrono::system_clock::now();
std::chrono::system_clock::time_point b = std::chrono::system_clock::now();

int main()
{
    while (true)
    {
        // Maintain designated frequency of 5 Hz (200 ms per frame)
        a = std::chrono::system_clock::now();
        std::chrono::duration<double, std::milli> work_time = a - b;

        if (work_time.count() < 200.0)
        {
            std::chrono::duration<double, std::milli> delta_ms(200.0 - work_time.count());
            auto delta_ms_duration = std::chrono::duration_cast<std::chrono::milliseconds>(delta_ms);
            std::this_thread::sleep_for(std::chrono::milliseconds(delta_ms_duration.count()));
        }

        b = std::chrono::system_clock::now();
        std::chrono::duration<double, std::milli> sleep_time = b - a;

        // Your code here

        printf("Time: %f \n", (work_time + sleep_time).count());
    }
}
_

このコードは私にデルタの安定したシーケンスを与えます：

_Time: 199.057206 
Time: 199.053581 
Time: 199.064718 
Time: 199.053515 
Time: 199.053307 
Time: 199.053415 
Time: 199.053164 
Time: 199.053511 
Time: 199.053280 
Time: 199.053283    
_
19
HolyBlackCat

これは Galikの回答 によく似ていますが、OPの質問の構文を保持し、C APIにドロップダウンしません。さらに、読みやすさにとって重要であると私が信じるフレーム期間のカスタム単位を作成します。

_#include <chrono>
#include <cstdint>
#include <iostream>
#include <thread>

int
main()
{
    using namespace std;
    using namespace std::chrono;

    using frames = duration<int64_t, ratio<1, 5>>;  // 5Hz
    auto nextFrame = system_clock::now();
    auto lastFrame = nextFrame - frames{1};;

    while (true)
    {
        // Perform intersection test

        this_thread::sleep_until(nextFrame);
        cout << "Time: "  // just for monitoring purposes
             << duration_cast<milliseconds>(system_clock::now() - lastFrame).count()
             << "ms\n";
        lastFrame = nextFrame;
        nextFrame += frames{1};
    }
}
_

これは私のために出力します：

_Time: 200ms
Time: 205ms
Time: 205ms
Time: 203ms
Time: 205ms
Time: 205ms
Time: 200ms
Time: 200ms
Time: 200ms
...
_

注意すべき重要な点：

  • 5Hzを文書化する簡潔な方法：_using frames = duration<int64_t, ratio<1, 5>>;_
  • _sleep_until_の代わりに_sleep_for_を使用します。これにより、実際の作業が完了するまでにかかる時間の長さが不明になります。
  • I/O以外の.count()の使用はありません これを取り除くためのライブラリがあります 。
  • 単位の手動変換はありません（例：_/ 1000_）。
  • 浮動小数点ユニットはありません、それで何か問題があるわけではありません。
  • 明示的な単位を指定または依存する必要が最小限。

期間I/Oライブラリ を追加すると、上記のコードがどのように変更されるかを次に示します。

_#include "chrono_io.h"
#include <chrono>
#include <cstdint>
#include <iostream>
#include <thread>

int
main()
{
    using namespace date;
    using namespace std;
    using namespace std::chrono;

    using frames = duration<int64_t, ratio<1, 5>>;  // 5Hz
    auto nextFrame = system_clock::now();
    auto lastFrame = nextFrame - frames{1};;

    while (true)
    {
        // Perform intersection test

        this_thread::sleep_until(nextFrame);
        // just for monitoring purposes
        cout << "Time: " << system_clock::now() - lastFrame << '\n';
        lastFrame = nextFrame;
        nextFrame += frames{1};
    }
}
_

出力はプラットフォームによって異なります（_system_clock_の「ネイティブ期間」によって異なります）。私のプラットフォームでは次のようになります：

_Time: 200042µs
Time: 205105µs
Time: 205107µs
Time: 200044µs
Time: 205105µs
Time: 200120µs
Time: 204307µs
Time: 205136µs
Time: 201978µs
...
_
12
Howard Hinnant

私は通常次のようなことをします：

#include <chrono>
#include <iostream>

int main()
{
    using clock = std::chrono::steady_clock;

    auto next_frame = clock::now();

    while(true)
    {
        next_frame += std::chrono::milliseconds(1000 / 5); // 5Hz

        // do stuff
        std::cout << std::time(0) << '\n'; // 5 for each second

        // wait for end of frame
        std::this_thread::sleep_until(next_frame);
    }
}

出力：（2番目の値ごとに5つ）

1470173964
1470173964
1470173964
1470173964
1470173964
1470173965
1470173965
1470173965
1470173965
1470173965
1470173966
1470173966
1470173966
1470173966
1470173966
8
Galik

交互のデルタ時間は論理的な問題から発生します。つまり、前のフレームの継続時間に基づいて1つのフレームに遅延を追加しています（フレームの継続時間の計算方法に関して）。これは、長いフレーム（約200ミリ秒）の後、遅延を適用せずに短いフレーム（数ミリ秒）を取得しないことを意味します。これにより、次のフレームで遅延がトリガーされ、長いフレームが生成されます。

4
Mike Dinsdale