std::chrono::duration mit variabler ratio



  • also so wie ich das sehe, misst du die benötigte zeit überhaupt nicht. ich habe jetzt mal für dich gesucht und unter http://www.cplusplus.com/reference/chrono/high_resolution_clock/now/ ein beispiel für eine zeitmessung gefunden. im prinzip musst du das nur anpassen.



  • auto next = std::chrono::high_resolution_clock::now() + Framerate{1};
    

    Was denkst du tut diese Zeile? Bitte lies dir den Eröffnungsbeitrag noch einmal vernünftig und mit beiden Augen durch.
    Zur eigentlichen Frage:
    Hab die Lösung gefunden

    auto framerate = std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::duration<double>(1.0 / fps));
    


  • @pikkolini sagte in std::chrono::duration mit variabler ratio:

    Was denkst du tut diese Zeile?
    ehrlich gesagt einen bestimmten zeitraum festlegen, jedoch nicht die tatsächliche zeitspanne zum durchlaufen der funktion ermitteln. wenn du wirklich richtig liegst, sei doch bitte so nett, mir (zu lernzwecken) zu erklären, wo genau du ermittelst, wie lange der funktionsaufruf dauert und wo du die von mir erläuterte anpassung der verzögerung durchführst. wirklich: ich möchte etwas lernen.



  • @hansklaus sagte in std::chrono::duration mit variabler ratio:
    jedoch nicht die tatsächliche zeitspanne zum durchlaufen der funktion ermitteln.

    Das will er doch gar nicht.



  • muss er doch aber. wie will er die funktion sonst exakt 60mal in der sekunde aufrufen?


  • Mod

    @hansklaus sagte in std::chrono::duration mit variabler ratio:

    muss er doch aber. wie will er die funktion sonst exakt 60mal in der sekunde aufrufen?

    So wie gezeigt.

    Umgekehrt würde mich mal interessieren, wie du es machen willst. Gegeben ein Stück Code, das dir sagt, wie lange etwas braucht. Wie machst du nun damit etwas, das eine Funktion 60x in der Sekunde aufruft?



  • naja

    schleife:

     1. zeitpunkt ermitteln
    
     funktion aufrufen
    
     2. zeitpunkt ermitteln
    
     verzögerungszeitraum ausrechnen: 1/60s - (2.zeitpunkt - 1. zeitpunkt)
    
     verzögerung durchführen
    

    schleife ende

    genau das war doch gefragt, oder verstehe ich die deutsche sprache jetzt nicht mehr?



  • @hansklaus sagte in std::chrono::duration mit variabler ratio:

    genau das war doch gefragt, oder verstehe ich die deutsche sprache jetzt nicht mehr?

    Nein, gefragt war wie man aus einer chrono kompatiblen Zeit (keine Ahnung wie ich das nennen soll) die zur compiletime bekannt sein muss, eine chrono kompatible Zeit machen kann, die man erst zur Laufzeit kennen muss. Ist vielleicht blöd formuliert und wer anders kann das besser erklären.
    Mein Code macht folgendes:

    nächster Zeitpunkt = jetzt + 1/60s
    while (...)
        warte bis nächster Zeitpunkt erreicht ist (sleep_until)
        nächster Zeitpunkt = nächster Zeitpunkt + 1/60s
    


  • Möglicherweise ist std::chrono::duration<double> eine Lösung?

    #include <iostream>
    #include <chrono>
    
    int main()
    {
      const auto fps = 50;
      using Framerate = std::chrono::duration<std::chrono::high_resolution_clock::rep, std::ratio<1, fps>>;
      using Framerate2 = std::chrono::duration<double>;
      auto start = std::chrono::high_resolution_clock::now();
      auto end = start + Framerate{1};
      auto end2 = start + Framerate2{ 1. / fps };
      
      std::cout << std::chrono::duration_cast<std::chrono::microseconds>(end - start).count() << "\n";
      std::cout << std::chrono::duration_cast<std::chrono::microseconds>(end2 - start).count() << "\n";
    }
    


  • @manni66 Danke, das funktioniert auch bestens. Wie ich gerade gemerkt habe ist der duration_cast in meiner Lösung gar nicht nötig.
    Gibt es irgendein Grund eine der beiden folgenden Zeilen vorzuziehen?

    auto framerate = std::chrono::duration<double>{1.0 / fps};
    
    using Framerate = std::chrono::duration<double>
    // und dann Framerate{1.0 / fps} benutzen
    


  • naja, das eine (using) ist einalias des Typs und das andere (auto) ist ein konkretes Objekt.

    Da es in deinem Fall ja einer dauerhaft konstante duration ist, kannst du dir den Umweg über den alias auch sparen; es spricht allerdings auch nichts dagegen einfach beides zu verwenden 😉

    using Framerate = std::chrono::duration<double>;
    auto framerate = Framerate{1.0 / fps};
    

    wobei ich das hier schöner finde:

    using Framerate = std::chrono::duration<double>;
    Framerate framerate{1.0 / fps};
    

Anmelden zum Antworten