Dividing two chrono::durations to get fraction

Question

To calculate the possible speedup (Amdahl) I need the fraction of the parallelizable part of my code compared to the total sequential runtime. I timed the execution using the chrono.h library and got the total sequential runtime and parallelizable part runtime as chrono::duration in nanoseconds.

Now I need to divide these two durations to get the percentage of possible parallelizable part.

e.g.

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

   // Some code, non parallelizable

auto parStartTime = std::chrono::steady_clock::now();
   // Parallelizable sequential code
auto parEndTime = std::chrono::steady_clock::now();

auto timeTakenPar = std::chrono::duration_cast<std::chrono::nanoseconds>(parEndTime - parStartTime);


   // More sequential code possible

auto seqEndTime = std::chrono::steady_clock::now();
auto timeTakenSeq = std::chrono::duration_cast<std::chrono::nanoseconds>(seqEndTime - seqStartTime);

// auto frac = timeTakenPar / timeTakenSeq (??)

Any idea how to do that?

Simply dividing won't do the trick, since as far as I understood, this only returns the number of times the right hand side duration after conversion fits into the left hand side duration. In this case obviously zero, since the total runtime is on the rhs and parallelizable part runtime on the lhs.

I also tried using .count() before dividing, but still ended up with 0 as result.

Any help is highly appreciated!

"this only returns the number of times the right hand side duration after conversion fits into the left hand side duration" if thats not what you want, then it is not clear what you want. — 463035818_is_not_an_ai, Jun 21 '23 at 10:25
oh... I think you want floating point arithmetics rather than integer arithmetics. Cast one of them to `double` — 463035818_is_not_an_ai, Jun 21 '23 at 10:25
Since it was marked as a duplicate, I cannot post it as an answer, but you can use `std::chrono::duration dnsecs;` then you will get "native" floating pointer arithmetics with the ease of `std::chrono`. — Quimby, Jun 21 '23 at 10:30
@Quimby I wasnt sure about the dupe. As this is somewhat `chrono` specific, a reopen seems appropriate — 463035818_is_not_an_ai, Jun 21 '23 at 10:35
related https://stackoverflow.com/questions/4857091/dividing-integers — 463035818_is_not_an_ai, Jun 21 '23 at 10:35
Just adding `0.s` to either of the differences is an easy way to get things into `double`. E.g. `auto timeTakenSeq = seqEndTime - seqStartTime + 0.s;`. — Howard Hinnant, Jun 21 '23 at 12:20

Quimby · Accepted Answer · 2023-06-21T11:04:37.067

<chrono> supports different numerical representations, including double, there is even support for literals like 2.5ms. Unfortunately there is no nanoseconds<double> shortcut and the cast is more wordy.

#include <chrono>
#include <iostream>

using namespace std::chrono;
using namespace std::chrono_literals;

int main() {
    auto parStartTime = std::chrono::steady_clock::now();
    auto parEndTime = parStartTime + 12ns;  // Dummy value

    using dnanoseconds = std::chrono::duration<long double, std::nano>;
    auto dur = parEndTime - parStartTime;

    std::cout << "Int/int nanoseconds:" << dur / (24ns) << '\n';
    std::cout << "Int/double nanoseconds:" << dur / (24.0ns) << '\n';
    std::cout << "Double/double nanoseconds:"
              << std::chrono::duration_cast<dnanoseconds>(dur) / (24.0ns) << '\n';
    std::cout << "Double/int nanoseconds:"
              << std::chrono::duration_cast<dnanoseconds>(dur) / 24ns << '\n';
}

outputs:

Int/int nanoseconds:0
Int/double nanoseconds:0.5
Double/double nanoseconds:0.5
Double/int nanoseconds:0.5

score 2 · Answer 2 · answered Jun 21 '23 at 11:08

You can use a floating-point duration instead. This would give you two advantages:

Use floating-point arithmetic for your division
Get rid of std::chrono::duration_cast

Your code would become:

auto seqStartTime = std::chrono::steady_clock::now();
// Some code, non parallelizable

auto parStartTime = std::chrono::steady_clock::now();
// Parallelizable sequential code
auto parEndTime = std::chrono::steady_clock::now();
std::chrono::duration<long double, std::nano> timeTakenPar = parEndTime - parStartTime;

// More sequential code possible

auto seqEndTime = std::chrono::steady_clock::now();
std::chrono::duration<long double, std::nano> timeTakenSeq = seqEndTime - seqStartTime;

long double frac = timeTakenPar / timeTakenSeq;

Dividing two chrono::durations to get fraction

2 Answers2