Merge branch 'main' into use-zstd-layers

Author: mitchdz

.github/workflows/config/validation_config.json

@@ -6,7 +6,6 @@
             "operating_systems": 
             [
                 "ubuntu:22.04",
-                "redhat/ubi8:8.10",
                 "fedora:42"
             ]
         },

include/cudaq/CMakeLists.txt

@@ -8,3 +8,4 @@
 
 include(HandleLLVMOptions)
 add_subdirectory(Optimizer)
+add_subdirectory(Support)

include/cudaq/Support/CMakeLists.txt

@@ -0,0 +1,10 @@
+# ============================================================================ #
+# Copyright (c) 2022 - 2025 NVIDIA Corporation & Affiliates.                   #
+# All rights reserved.                                                         #
+#                                                                              #
+# This source code and the accompanying materials are made available under     #
+# the terms of the Apache License 2.0 which accompanies this distribution.     #
+# ============================================================================ #
+
+# Install TargetConfig.h file
+install (FILES TargetConfig.h DESTINATION include/cudaq/Support)

include/cudaq/Support/TargetConfig.h

@@ -8,7 +8,6 @@
 
 #pragma once
 
-#include "llvm/Support/YAMLTraits.h"
 #include <optional>
 #include <string>
 #include <vector>
@@ -142,56 +141,3 @@ std::string processRuntimeArgs(const TargetConfig &config,
                                const std::vector<std::string> &targetArgv);
 } // namespace config
 } // namespace cudaq
-
-// These structs can be used in a vector.
-LLVM_YAML_IS_SEQUENCE_VECTOR(cudaq::config::TargetFeatureFlag)
-LLVM_YAML_IS_SEQUENCE_VECTOR(cudaq::config::TargetArgument)
-LLVM_YAML_IS_SEQUENCE_VECTOR(cudaq::config::ConditionalBuildConfig)
-LLVM_YAML_IS_SEQUENCE_VECTOR(cudaq::config::BackendFeatureMap)
-
-namespace llvm {
-namespace yaml {
-// YML serialization declarations.
-template <>
-struct ScalarBitSetTraits<cudaq::config::TargetFeatureFlag> {
-  static void bitset(IO &io, cudaq::config::TargetFeatureFlag &value);
-};
-
-template <>
-struct ScalarEnumerationTraits<cudaq::config::ArgumentType> {
-  static void enumeration(IO &io, cudaq::config::ArgumentType &value);
-};
-
-template <>
-struct MappingTraits<cudaq::config::TargetArgument> {
-  static void mapping(IO &io, cudaq::config::TargetArgument &info);
-};
-
-template <>
-struct BlockScalarTraits<cudaq::config::SimulationBackendSetting> {
-  static void output(const cudaq::config::SimulationBackendSetting &Value,
-                     void *Ctxt, llvm::raw_ostream &OS);
-  static StringRef input(StringRef Scalar, void *Ctxt,
-                         cudaq::config::SimulationBackendSetting &Value);
-};
-template <>
-struct MappingTraits<cudaq::config::ConditionalBuildConfig> {
-  static void mapping(IO &io, cudaq::config::ConditionalBuildConfig &info);
-};
-
-template <>
-struct MappingTraits<cudaq::config::BackendEndConfigEntry> {
-  static void mapping(IO &io, cudaq::config::BackendEndConfigEntry &info);
-};
-template <>
-struct MappingTraits<cudaq::config::BackendFeatureMap> {
-  static void mapping(IO &io, cudaq::config::BackendFeatureMap &info);
-};
-
-template <>
-struct MappingTraits<cudaq::config::TargetConfig> {
-  static void mapping(IO &io, cudaq::config::TargetConfig &info);
-};
-
-} // namespace yaml
-} // namespace llvm

include/cudaq/Support/TargetConfigYaml.h

@@ -0,0 +1,65 @@
+/****************************************************************-*- C++ -*-****
+ * Copyright (c) 2022 - 2025 NVIDIA Corporation & Affiliates.                  *
+ * All rights reserved.                                                        *
+ *                                                                             *
+ * This source code and the accompanying materials are made available under    *
+ * the terms of the Apache License 2.0 which accompanies this distribution.    *
+ ******************************************************************************/
+
+#pragma once
+
+#include "TargetConfig.h"
+#include "llvm/Support/YAMLTraits.h"
+
+// These structs can be used in a vector.
+LLVM_YAML_IS_SEQUENCE_VECTOR(cudaq::config::TargetFeatureFlag)
+LLVM_YAML_IS_SEQUENCE_VECTOR(cudaq::config::TargetArgument)
+LLVM_YAML_IS_SEQUENCE_VECTOR(cudaq::config::ConditionalBuildConfig)
+LLVM_YAML_IS_SEQUENCE_VECTOR(cudaq::config::BackendFeatureMap)
+
+namespace llvm {
+namespace yaml {
+// YML serialization declarations.
+template <>
+struct ScalarBitSetTraits<cudaq::config::TargetFeatureFlag> {
+  static void bitset(IO &io, cudaq::config::TargetFeatureFlag &value);
+};
+
+template <>
+struct ScalarEnumerationTraits<cudaq::config::ArgumentType> {
+  static void enumeration(IO &io, cudaq::config::ArgumentType &value);
+};
+
+template <>
+struct MappingTraits<cudaq::config::TargetArgument> {
+  static void mapping(IO &io, cudaq::config::TargetArgument &info);
+};
+
+template <>
+struct BlockScalarTraits<cudaq::config::SimulationBackendSetting> {
+  static void output(const cudaq::config::SimulationBackendSetting &Value,
+                     void *Ctxt, llvm::raw_ostream &OS);
+  static StringRef input(StringRef Scalar, void *Ctxt,
+                         cudaq::config::SimulationBackendSetting &Value);
+};
+template <>
+struct MappingTraits<cudaq::config::ConditionalBuildConfig> {
+  static void mapping(IO &io, cudaq::config::ConditionalBuildConfig &info);
+};
+
+template <>
+struct MappingTraits<cudaq::config::BackendEndConfigEntry> {
+  static void mapping(IO &io, cudaq::config::BackendEndConfigEntry &info);
+};
+template <>
+struct MappingTraits<cudaq::config::BackendFeatureMap> {
+  static void mapping(IO &io, cudaq::config::BackendFeatureMap &info);
+};
+
+template <>
+struct MappingTraits<cudaq::config::TargetConfig> {
+  static void mapping(IO &io, cudaq::config::TargetConfig &info);
+};
+
+} // namespace yaml
+} // namespace llvm

lib/Optimizer/Builder/Marshal.cpp

@@ -785,7 +785,8 @@ cudaq::opt::marshal::dropAnyHiddenArguments(MutableArrayRef<BlockArgument> args,
 std::pair<bool, func::FuncOp> cudaq::opt::marshal::lookupHostEntryPointFunc(
     StringRef mangledEntryPointName, ModuleOp module, func::FuncOp funcOp) {
   if (mangledEntryPointName == "BuilderKernel.EntryPoint" ||
-      mangledEntryPointName.contains("_PyKernelEntryPointRewrite")) {
+      mangledEntryPointName.contains("_PyKernelEntryPointRewrite") ||
+      funcOp.empty()) {
     // No host entry point needed.
     return {false, func::FuncOp{}};
   }

lib/Optimizer/Transforms/GenKernelExecution.cpp

@@ -869,14 +869,13 @@ class GenerateKernelExecution
     for (auto &op : *module.getBody())
       if (auto funcOp = dyn_cast<func::FuncOp>(op))
         if (funcOp.getName().startswith(cudaq::runtime::cudaqGenPrefixName) &&
-            cudaq::opt::marshal::hasLegalType(funcOp.getFunctionType()))
+            cudaq::opt::marshal::hasLegalType(funcOp.getFunctionType()) &&
+            !funcOp.empty() && !funcOp->hasAttr(cudaq::generatorAnnotation))
           workList.push_back(funcOp);
 
     LLVM_DEBUG(llvm::dbgs()
                << workList.size() << " kernel entry functions to process\n");
     for (auto funcOp : workList) {
-      if (funcOp->hasAttr(cudaq::generatorAnnotation))
-        continue;
       auto loc = funcOp.getLoc();
       [[maybe_unused]] auto className =
           funcOp.getName().drop_front(cudaq::runtime::cudaqGenPrefixLength);

lib/Optimizer/Transforms/LoopAnalysis.cpp

@@ -30,10 +30,10 @@ using namespace mlir;
 /// A \em monotonic loop: a loop that counts from $i$ up to (down to) $j$
 /// stepping by positive (negative) integral values; mathematically, it is a
 /// strictly monotonic sequence. If the step is a compile-time constant, $k$,
-/// then a closed iterval monotonic loop must execute exactly $\max(0, \floor{(j
-/// - i + k) / k})$ iterations. By normalizing a monotonic loop and constant
-/// folding and propagation, we may be able to convert it to static control
-/// flow.
+/// then a closed iterval definite monotonic loop must execute exactly $\max(0,
+/// \floor{(j - i + k) / k})$ iterations. By normalizing a monotonic loop and
+/// constant folding and propagation, we may be able to convert it to static
+/// control flow.
 ///
 /// For completeness, a \em{conditionally iterated} loop is a monotonic loop
 /// that has a second auxilliary condition to determine if a given loop
@@ -309,10 +309,9 @@ bool opt::isaCountedLoop(cc::LoopOp loop, bool allowClosedInterval) {
          isaConstant(c.compareValue);
 }
 
-bool opt::isaConstantUpperBoundLoop(cc::LoopOp loop, bool allowClosedInterval) {
+bool opt::isaIndefiniteCountedLoop(cc::LoopOp loop, bool allowClosedInterval) {
   LoopComponents c;
-  return isaInvariantLoop(loop, allowClosedInterval, /*allowEarlyExit=*/true,
-                          &c) &&
+  return isaIndefiniteInvariantLoop(loop, allowClosedInterval, &c) &&
          isaConstant(c.compareValue);
 }
 

lib/Optimizer/Transforms/LoopAnalysis.h

@@ -74,7 +74,9 @@ bool isSignedPredicate(mlir::arith::CmpIPredicate p);
 bool isaCountedLoop(cc::LoopOp op, bool allowClosedInterval = true);
 
 bool loopContainsBreak(cc::LoopOp op);
-bool isaConstantUpperBoundLoop(cc::LoopOp op, bool allowClosedInterval = true);
+
+/// An indefinite counted loop is a counted loop which may have early exits.
+bool isaIndefiniteCountedLoop(cc::LoopOp op, bool allowClosedInterval = true);
 
 /// An invariant loop is defined to be a loop that will execute some run-time
 /// invariant number of iterations. We recognize a normalized, semi-open
@@ -88,6 +90,23 @@ bool isaInvariantLoop(cc::LoopOp op, bool allowClosedInterval = true,
                       bool allowEarlyExit = false, LoopComponents *c = nullptr);
 bool isaInvariantLoop(const LoopComponents &c, bool allowClosedInterval);
 
+/// An indefinite invariant loop is an invariant loop which may have early
+/// exits. The number of iterations will be at most the upper bound expression.
+/// We recognize the normalized, semi-open interval loop such as
+/// ```
+///   for(i = 0; i < invariant_expression; ++i) {
+///     ...
+///       break;
+///     ...
+///   }
+/// ```
+/// is a canonical indefinite loop.
+inline bool isaIndefiniteInvariantLoop(cc::LoopOp op,
+                                       bool allowClosedInterval = true,
+                                       LoopComponents *c = nullptr) {
+  return isaInvariantLoop(op, allowClosedInterval, /*allowEarlyExit=*/true, c);
+}
+
 // We expect the loop control value to have the following form.
 //
 //   %final = cc.loop while ((%iter = %initial) -> (iN)) {
@@ -118,8 +137,9 @@ bool hasMonotonicControlInduction(cc::LoopOp loop, LoopComponents *c = nullptr);
 /// ```
 ///   for(i = start; i < stop; i += step)
 /// ```
-/// is a monotonic loop that must execute a number of iterations as given
-/// by the following equation. Early exits (break statements) are not permitted.
+/// is a (definite) monotonic loop that must execute a number of iterations as
+/// given by the following equation. Early exits (break statements) are
+/// permitted in \e indefinite monotonic loops.
 /// ```
 ///   let iterations = (stop - 1 - start + step) / step
 ///      iterations : if iterations > 0
@@ -130,6 +150,12 @@ bool hasMonotonicControlInduction(cc::LoopOp loop, LoopComponents *c = nullptr);
 bool isaMonotonicLoop(mlir::Operation *op, bool allowEarlyExit = false,
                       LoopComponents *c = nullptr);
 
+/// An indefinite monotonic loop is a monotonic loop that may have early exits.
+inline bool isaIndefiniteMonotonicLoop(mlir::Operation *op,
+                                       LoopComponents *c = nullptr) {
+  return isaMonotonicLoop(op, /*allowEarlyExit=*/true, c);
+}
+
 /// Recover the different subexpressions from the loop if it conforms to the
 /// pattern. Given a LoopOp where induction is in a register:
 /// ```

lib/Optimizer/Transforms/LoopUnrollPatterns.inc

@@ -72,7 +72,7 @@ struct UnrollCountedLoop : public OpRewritePattern<cudaq::cc::LoopOp> {
         loop.emitOpError("not a simple counted loop");
       return failure();
     }
-    if (allowBreak && !cudaq::opt::isaConstantUpperBoundLoop(loop)) {
+    if (allowBreak && !cudaq::opt::isaIndefiniteCountedLoop(loop)) {
       if (signalFailure)
         loop.emitOpError("not a constant upper bound loop");
       return failure();