https://github.com/zyn0217 created https://github.com/llvm/llvm-project/pull/188421
The concept parameter mapping patch significantly impacted performance in scenarios where concepts are heavily used, even with the addition of atomic-expression-level caching. After normalization, we often end up with large atomic expressions containing numerous duplicate and complex template parameter mappings. Previously, we were substituting and checking these repeatedly, which was highly inefficient. We now cache these substitution results within TemplateInstantiator. This provides us some performance improvement, as in these regression cases: |Regressions | clang-21 |clang-22 | This patch |--|--|--|--| usb_ids_gen.cpp | 1.41s | 3.90s | 2.45s inspector_style_resolver.cpp | 18.21s | 22.43s | 19.01s While performance has not yet so good as clang-21, I think there is still room for future improvements. E.g. We can cache invalid results for SFINAE diagnostics and avoiding redundant pack unpacking, etc. >From 58b0a6978f604aeab04e0fb027ea3b2c896e38a6 Mon Sep 17 00:00:00 2001 From: Younan Zhang <[email protected]> Date: Tue, 24 Mar 2026 19:09:11 +0800 Subject: [PATCH] [Clang] Improve concept performance 1/N The concept parameter mapping patch significantly impacted performance in scenarios where concepts are heavily used, even with the addition of atomic-expression-level caching. After normalization, we often end up with large atomic expressions containing numerous duplicate and complex template parameter mappings. Previously, we were substituting and checking these repeatedly, which was highly inefficient. We now cache these substitution results within TemplateInstantiator. This provides us some performance improvement, as in these regression cases: Regressions clang-21 clang-22 This patch usb_ids_gen.cpp 1.41s 3.90s 2.45s inspector_style_resolver.cpp 18.21s 22.43s 19.01s While performance has not yet so good as clang-21, I think there is still room for future improvements. E.g. We can cache invalid results for SFINAE diagnostics and avoiding redundant pack unpacking, etc. --- clang/include/clang/Sema/Sema.h | 3 +++ clang/lib/Sema/SemaConcept.cpp | 7 +++++++ clang/lib/Sema/SemaTemplateInstantiate.cpp | 23 +++++++++++++++++++++- 3 files changed, 32 insertions(+), 1 deletion(-) diff --git a/clang/include/clang/Sema/Sema.h b/clang/include/clang/Sema/Sema.h index a214a7aa9147b..3f18c97fbc4d4 100644 --- a/clang/include/clang/Sema/Sema.h +++ b/clang/include/clang/Sema/Sema.h @@ -15091,6 +15091,9 @@ class Sema final : public SemaBase { UnsubstitutedConstraintSatisfactionCacheResult> UnsubstitutedConstraintSatisfactionCache; + llvm::DenseMap<llvm::FoldingSetNodeID, TemplateArgumentLoc> + *CurrentCachedTemplateArgs = nullptr; + private: /// Caches pairs of template-like decls whose associated constraints were /// checked for subsumption and whether or not the first's constraints did in diff --git a/clang/lib/Sema/SemaConcept.cpp b/clang/lib/Sema/SemaConcept.cpp index 9c4f52dd7150c..6ae678fe23700 100644 --- a/clang/lib/Sema/SemaConcept.cpp +++ b/clang/lib/Sema/SemaConcept.cpp @@ -487,6 +487,10 @@ class ConstraintSatisfactionChecker { // right context. ConceptDecl *ParentConcept = nullptr; +public: + llvm::DenseMap<llvm::FoldingSetNodeID, TemplateArgumentLoc> + CachedTemplateArgs; + private: ExprResult EvaluateAtomicConstraint(const Expr *AtomicExpr, @@ -658,6 +662,9 @@ ConstraintSatisfactionChecker::SubstitutionInTemplateArguments( ? Constraint.getPackSubstitutionIndex() : PackSubstitutionIndex); + llvm::SaveAndRestore PushTemplateArgsCache(S.CurrentCachedTemplateArgs, + &CachedTemplateArgs); + if (S.SubstTemplateArgumentsInParameterMapping( Constraint.getParameterMapping(), Constraint.getBeginLoc(), MLTAL, SubstArgs)) { diff --git a/clang/lib/Sema/SemaTemplateInstantiate.cpp b/clang/lib/Sema/SemaTemplateInstantiate.cpp index 34ed5dffa11b4..194d5ef0ba06a 100644 --- a/clang/lib/Sema/SemaTemplateInstantiate.cpp +++ b/clang/lib/Sema/SemaTemplateInstantiate.cpp @@ -1329,6 +1329,8 @@ namespace { // Whether an incomplete substituion should be treated as an error. bool BailOutOnIncomplete; + std::optional<llvm::FoldingSetNodeID> TemplateArgsHashValue; + // CWG2770: Function parameters should be instantiated when they are // needed by a satisfaction check of an atomic constraint or // (recursively) by another function parameter. @@ -1358,7 +1360,12 @@ namespace { SourceLocation Loc, const MultiLevelTemplateArgumentList &TemplateArgs) : inherited(SemaRef), TemplateArgs(TemplateArgs), Loc(Loc), - BailOutOnIncomplete(false) {} + BailOutOnIncomplete(false) { + auto &V = TemplateArgsHashValue.emplace(); + for (auto &Level : TemplateArgs) + for (auto &Arg : Level.Args) + Arg.Profile(V, SemaRef.Context); + } /// Determine whether the given type \p T has already been /// transformed. @@ -1611,6 +1618,7 @@ namespace { } return Type; } + // Override the default version to handle a rewrite-template-arg-pack case // for building a deduction guide. bool TransformTemplateArgument(const TemplateArgumentLoc &Input, @@ -1618,6 +1626,19 @@ namespace { bool Uneval = false) { const TemplateArgument &Arg = Input.getArgument(); std::vector<TemplateArgument> TArgs; + if (auto *Cache = SemaRef.CurrentCachedTemplateArgs; + TemplateArgsHashValue && Cache) { + llvm::FoldingSetNodeID ID = *TemplateArgsHashValue; + Input.getArgument().Profile(ID, SemaRef.Context); + if (auto Iter = Cache->find(ID); Iter != Cache->end()) { + Output = Iter->second; + return false; + } + bool Ret = inherited::TransformTemplateArgument(Input, Output, Uneval); + if (!Ret) + Cache->insert({ID, Output}); + return Ret; + } switch (Arg.getKind()) { case TemplateArgument::Pack: assert(SemaRef.CodeSynthesisContexts.empty() || _______________________________________________ cfe-commits mailing list [email protected] https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
