Convert duration units (#163)

This PR adds a pass to convert the units of all operations/types within
a QUIR program to a target unit type.

Author: taalexander

include/Dialect/QUIR/IR/QUIRAttributes.td

@@ -58,7 +58,24 @@ def QUIR_DurationAttr : QUIR_Attr<"Duration", "duration"> {
                         "APFloat":$duration);
 
   let extraClassDeclaration = [{
+
+        /// Get the scheduling timestep length (in seconds) from the input scheduling rate (in seconds).
+        static double getDtFromSchedulingRate(const double schedulingRate);
+        /// Get the scheduling rate (in seconds) from the input scheduling timestep length (in seconds).
+        static double getSchedulingRateFromDt(const double dt);
+
+        /// Convert duration of inputUnits to outputUnits
+        static double convertUnitsToUnits(double value, TimeUnits inputUnits, TimeUnits outputUnits, const double dt);
+
+        /// Convert the duration attribute to an integer number
+        /// of scheduling samples based on the input scheduling
+        /// timestep length, dt.
         uint64_t getSchedulingCycles(const double dt);
+        /// Convert this duration attribute's value to the target units.
+        double convertUnits(const TimeUnits targetUnits, const double dt);
+        /// Convert this duration attribute to a new duration attribute
+        /// with the target units.
+        DurationAttr getConvertedDurationAttr(const TimeUnits targetUnits, const double dt);
     }];
 
   let assemblyFormat = "`<` $duration `:` $type `>`";

include/Dialect/QUIR/Transforms/ConvertDurationUnits.h

@@ -0,0 +1,81 @@
+//===- ConvertDurationUnits.h - Convert Duration Unis  ----------*- C++ -*-===//
+//
+// (C) Copyright IBM 2023.
+//
+// This code is part of Qiskit.
+//
+// This code is licensed under the Apache License, Version 2.0 with LLVM
+// Exceptions. You may obtain a copy of this license in the LICENSE.txt
+// file in the root directory of this source tree.
+//
+// Any modifications or derivative works of this code must retain this
+// copyright notice, and modified files need to carry a notice indicating
+// that they have been altered from the originals.
+//
+//===----------------------------------------------------------------------===//
+///
+///  This file declares the pass for converting the units of Durations
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef QUIR_CONVERT_DURATION_UNITS_H
+#define QUIR_CONVERT_DURATION_UNITS_H
+
+#include "Dialect/QUIR/IR/QUIREnums.h"
+
+#include "mlir/Pass/Pass.h"
+
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Support/CommandLine.h"
+
+namespace mlir::quir {
+
+/// @brief This pass will convert all standard usage of durations
+/// within QUIR to the input target units. It is useful for canonicalizing
+/// durations within a program to uniform base unit such as the target
+/// timestep "dt".
+struct ConvertDurationUnitsPass
+    : public PassWrapper<ConvertDurationUnitsPass, OperationPass<>> {
+
+  ConvertDurationUnitsPass() = default;
+  ConvertDurationUnitsPass(const ConvertDurationUnitsPass &pass)
+      : PassWrapper(pass) {}
+  ConvertDurationUnitsPass(const TimeUnits inUnits,
+                           const double inDtTimestep = 1.) {
+    units = inUnits;
+    dtTimestep = inDtTimestep;
+  }
+
+  Option<TimeUnits> units{
+      *this,
+      "units",
+      llvm::cl::desc("Target units to convert to"),
+      llvm::cl::values(
+          clEnumValN(TimeUnits::dt, "dt", "Scheduling sample rate"),
+          clEnumValN(TimeUnits::s, "s", "seconds"),
+          clEnumValN(TimeUnits::ms, "ms", "milliseconds"),
+          clEnumValN(TimeUnits::us, "us", "microseconds"),
+          clEnumValN(TimeUnits::ns, "ns", "nanoseconds"),
+          clEnumValN(TimeUnits::ps, "ps", "picoseconds"),
+          clEnumValN(TimeUnits::fs, "fs", "femtoseconds")),
+      llvm::cl::value_desc("enum"),
+      llvm::cl::init(TimeUnits::dt)};
+
+  Option<double> dtTimestep{
+      *this, "dt-timestep",
+      llvm::cl::desc("Duration of dt (the scheduling timestep) in seconds. "
+                     "Defaults to 1s."),
+      llvm::cl::value_desc("num"), llvm::cl::init(1.)};
+
+  void runOnOperation() override;
+
+  virtual TimeUnits getTargetConvertUnits() const;
+  virtual double getDtTimestep();
+  llvm::StringRef getArgument() const override;
+  llvm::StringRef getDescription() const override;
+
+}; // struct ConvertDurationUnitsPass
+
+} // end namespace mlir::quir
+
+#endif // QUIR_CONVERT_DURATION_UNITS_H

include/Dialect/QUIR/Transforms/Passes.h

@@ -20,6 +20,7 @@
 #include "AddShotLoop.h"
 #include "AngleConversion.h"
 #include "BreakReset.h"
+#include "ConvertDurationUnits.h"
 #include "FunctionArgumentSpecialization.h"
 #include "LoadElimination.h"
 #include "MergeCircuits.h"

lib/Dialect/QUIR/IR/QUIRAttributes.cpp

@@ -22,34 +22,106 @@
 using namespace mlir;
 using namespace mlir::quir;
 
-uint64_t mlir::quir::DurationAttr::getSchedulingCycles(const double dt) {
-  double duration = getDuration().convertToDouble();
+//===----------------------------------------------------------------------===//
+// DurationAttr
+//===----------------------------------------------------------------------===//
 
-  auto type = getType().dyn_cast<DurationType>();
+namespace {
+/// Convert input value (in units of inputUnits) to target units
+double convertToSeconds(const double value, const TimeUnits inputUnits,
+                        const double dt = 1.) {
+  switch (inputUnits) {
+  case TimeUnits::dt:
+    return value * dt;
+    break;
+  case TimeUnits::fs:
+    return value / 1.e15;
+    break;
+  case TimeUnits::ps:
+    return value / 1.e12;
+    break;
+  case TimeUnits::ns:
+    return value / 1.e9;
+    break;
+  case TimeUnits::us:
+    return value / 1.e6;
+    break;
+  case TimeUnits::ms:
+    return value / 1.e3;
+    break;
+  case TimeUnits::s:
+    return value;
+    break;
+  }
+  llvm_unreachable("unhandled TimeUnits conversion.");
+}
 
-  // Convert through int64_t first to handle platform dependence
-  switch (type.getUnits()) {
+/// Convert input value (in units of seconds) to target outputUnits
+double convertFromSeconds(const double value, const TimeUnits outputUnits,
+                          const double dt = 1.) {
+  switch (outputUnits) {
   case TimeUnits::dt:
-    return static_cast<int64_t>(duration);
+    return value / dt;
     break;
   case TimeUnits::fs:
-    return static_cast<int64_t>(duration / (1e15 * dt));
+    return value * 1.e15;
     break;
   case TimeUnits::ps:
-    return static_cast<int64_t>(duration / (1e12 * dt));
+    return value * 1.e12;
     break;
   case TimeUnits::ns:
-    return static_cast<int64_t>(duration / (1e9 * dt));
+    return value * 1.e9;
     break;
   case TimeUnits::us:
-    return static_cast<int64_t>(duration / (1e6 * dt));
+    return value * 1.e6;
     break;
   case TimeUnits::ms:
-    return static_cast<int64_t>(duration / (1e3 * dt));
+    return value * 1.e3;
     break;
   case TimeUnits::s:
-    return static_cast<int64_t>(duration / dt);
+    return value;
     break;
   }
   llvm_unreachable("unhandled TimeUnits conversion.");
 }
+
+} // anonymous namespace
+
+double DurationAttr::getDtFromSchedulingRate(const double schedulingRate) {
+  return 1. / schedulingRate;
+}
+
+double DurationAttr::getSchedulingRateFromDt(const double dt) {
+  return 1. / dt;
+}
+
+double DurationAttr::convertUnitsToUnits(double value, TimeUnits inputUnits,
+                                         TimeUnits outputUnits,
+                                         const double dt) {
+  // Check if we can avoid the conversion.
+  if (inputUnits == outputUnits)
+    return value;
+  double seconds = convertToSeconds(value, inputUnits, dt);
+  return convertFromSeconds(seconds, outputUnits, dt);
+}
+
+uint64_t DurationAttr::getSchedulingCycles(const double dt) {
+  double duration = convertUnits(TimeUnits::dt, dt);
+
+  // Convert through int64_t first to handle platform dependence
+  return static_cast<int64_t>(duration);
+}
+
+double DurationAttr::convertUnits(const TimeUnits targetUnits,
+                                  const double dt) {
+  double duration = getDuration().convertToDouble();
+  return DurationAttr::convertUnitsToUnits(
+      duration, getType().dyn_cast<DurationType>().getUnits(), targetUnits, dt);
+}
+
+DurationAttr DurationAttr::getConvertedDurationAttr(const TimeUnits targetUnits,
+                                                    const double dt) {
+  return DurationAttr::get(getContext(),
+                           DurationType::get(getContext(), targetUnits),
+                           llvm::APFloat(convertUnits(targetUnits, dt)));
+}

lib/Dialect/QUIR/Transforms/CMakeLists.txt

@@ -15,6 +15,7 @@ add_mlir_dialect_library(MLIRQUIRTransforms
     AddShotLoop.cpp
     AngleConversion.cpp
     BreakReset.cpp
+    ConvertDurationUnits.cpp
     FunctionArgumentSpecialization.cpp
     LoadElimination.cpp
     MergeCircuits.cpp