Is there a better way to convert quantity time to chrono nanoseconds?

[ManuelMeraz]

I'm currently converting frequency to a chrono time period doing the following

  ...
  spin_wait(units::isq::Frequency auto frequency)
  {
    units::isq::Time auto time_in_seconds = units::dimensionless<units::one, std::int64_t>(1) / frequency;
    units::isq::Time auto time_in_nanoseconds = units::quantity_cast<units::isq::si::nanosecond>(time_in_seconds);
    m_wait_time = std::chrono::nanoseconds(time_in_nanoseconds.number()); // std::chrono::nanoseconds
  }

Is there a more succinct way of achieving this?

[JohelEGP]

  ...
  spin_wait(units::isq::Frequency auto frequency)
  {
    m_wait_time = std::chrono::nanoseconds(units::quantity_cast<units::isq::si::nanosecond>(std::int64_t{1} / frequency).number());
  }

[chiphogg]

In fact, I can prove that the accepted answer will truncate an integer frequency down to 0, even in the modern version of mp-units:

https://godbolt.org/z/4nhdMnPfo

[chiphogg]

Here's a start towards a better solution in today's library:

std::chrono::nanoseconds invert_in_ns(QuantityOf<isq::frequency> auto f)
{
    return to_chrono_duration((1 * one).in(f.unit * si::nano<si::second>) / f);
}

I don't know how idiomatic this is, but as I said, I think it's a good start. In this case, if you pass 250 * si::hertz, it'll do integer division and produce 4000000ns.

You can non-invasively make this a utility function in your project. That said, I would recommend adding safety checks and handling for various use cases, including floating point input types. You'll also want to figure out how to handle input units that are so large that you'll have truncation when you invert (for example, imagine converting integral quantities of GHz to ns!).

Good luck!

Godbolt: https://godbolt.org/z/aKdPcead1

[mpusz]

It doesn't look like this utility solves this use case

Right, my bad. I was in a hurry and I scoped on the new interface rather than dimensional correctness. If I have spent more time to implement the main() function my code would not compile because of dimension-related checks.

[mpusz]

Done!

void spin_wait(const QuantityOf<isq::frequency> auto& frequency)
{
  std::chrono::duration m_wait_time = to_chrono_duration(inverse<si::nano<si::second>>(frequency));
}

https://godbolt.org/z/M9beo5Mv3

Thanks, @chiphogg, for suggesting adding such a utility to the library and proposing an interface and resolution.

[chiphogg]

Nice... now I need to edit the part of my talk where I say Au is the only library that has this! 😁

[chiphogg]

@ManuelMeraz, I think there's room for a potential improvement to the library here. Au, the units library I wrote, has unit-aware inverse functions. When combined with implicit conversions with the chrono library, you could automatically generate code which, under the hood, divides your frequency value into 1'000'000'000 --- all without leaving the integer domain!

void spin_wait(au::QuantityI64<au::Hertz> frequency) {
    m_wait_time = au::inverse_as(au::nano(au::seconds), frequency);
}

Assuming m_wait_time is some pre-existing member with a type of std::chrono::nanoseconds, then this would Just Work.

It may be worth considering a similar addition to mp-units.