[argprom] Assessing impact of number of arguments promoted on compiler performance

[teamiceberg]

Summary

Our initial hypothesis is that changes to the magic value of max_elements in argumentpromotion.cpp file can
lead to changes in compiler performance. To assess such changes, we have to introduce a global variable in the argumentpromotion.h header file. Then, we supply different values for this global variable by having a command line flag (-numargspromoted) bound to this global variable via the cl::opt interface. Initial analysis of compiler performance using the built in test suite demonstrate some significant changes in compile time as well as run time.
However, we are in the process of validating if these changes are real or just noise induced by other means. More experiments and sample runs need to be run, to be sure. However, we are setting up this initial patch as a way to learn how to setup a pipeline to enable the use of global variables to simulate magic values. Also, we are designing LIT tests to ensure that we submit a patch that conforms to built-in argument promotion tests in llvm/test folder.

[teamiceberg]

Want to put in a different baseline

[lebedev.ri]

Why is there a limit in the first place?

.gitignore

 /.idea
 
 #==============================================================================#
 # Directories to ignore (do not add trailing '/'s, they skip symlinks).
 #==============================================================================#
 # VS2017 and VSCode config files.
 .vscode
 .vs
+.code-workspace
 # clangd index
 .clangd

llvm/include/llvm/Transforms/IPO/ArgumentPromotion.h

 //===- ArgumentPromotion.h - Promote by-reference arguments -----*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TRANSFORMS_IPO_ARGUMENTPROMOTION_H
 #define LLVM_TRANSFORMS_IPO_ARGUMENTPROMOTION_H
 
 #include "llvm/Analysis/CGSCCPassManager.h"
 #include "llvm/Analysis/LazyCallGraph.h"
 #include "llvm/IR/PassManager.h"
 
 namespace llvm {
 class TargetTransformInfo;
-
+static unsigned GL_NUMPROMARGS = 3; //opt flag (if supplied) populates this Global Variable 
 /// Argument promotion pass.
 ///
 /// This pass walks the functions in each SCC and for each one tries to
 /// transform it and all of its callers to replace indirect arguments with
 /// direct (by-value) arguments.
 class ArgumentPromotionPass : public PassInfoMixin<ArgumentPromotionPass> {
   unsigned MaxElements;
 
 public:
-  ArgumentPromotionPass(unsigned MaxElements = 3u) : MaxElements(MaxElements) {}
+  ArgumentPromotionPass(unsigned MaxElements = GL_NUMPROMARGS) : MaxElements(MaxElements) {}
 
   /// Check if callers and the callee \p F agree how promoted arguments would be
   /// passed. The ones that they do not agree on are eliminated from the sets but
   /// the return value has to be observed as well.
   static bool areFunctionArgsABICompatible(
       const Function &F, const TargetTransformInfo &TTI,
       SmallPtrSetImpl<Argument *> &ArgsToPromote,
       SmallPtrSetImpl<Argument *> &ByValArgsToTransform);

llvm/lib/Transforms/IPO/ArgumentPromotion.cpp

 //===- ArgumentPromotion.cpp - Promote by-reference arguments -------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //

 #include <string>
 #include <utility>
 #include <vector>
 
 using namespace llvm;
 
 #define DEBUG_TYPE "argpromotion"
 
+//opt flag to capture user supplied value for GV: GL_NUMPROMARGS
+cl::opt<unsigned, true> argmax("numargspromoted", cl::desc("Specify number of args to promote"), cl::value_desc("numargs"), cl::location(llvm::GL_NUMPROMARGS));
+
 STATISTIC(NumArgumentsPromoted, "Number of pointer arguments promoted");
 STATISTIC(NumAggregatesPromoted, "Number of aggregate arguments promoted");
 STATISTIC(NumByValArgsPromoted, "Number of byval arguments promoted");
 STATISTIC(NumArgumentsDead, "Number of dead pointer args eliminated");
 
 /// A vector used to hold the indices of a single GEP instruction
 using IndicesVector = std::vector<uint64_t>;
 

 INITIALIZE_PASS_DEPENDENCY(AssumptionCacheTracker)
 INITIALIZE_PASS_DEPENDENCY(CallGraphWrapperPass)
 INITIALIZE_PASS_DEPENDENCY(TargetLibraryInfoWrapperPass)
 INITIALIZE_PASS_DEPENDENCY(TargetTransformInfoWrapperPass)
 INITIALIZE_PASS_END(ArgPromotion, "argpromotion",
                     "Promote 'by reference' arguments to scalars", false, false)
 
 Pass *llvm::createArgumentPromotionPass(unsigned MaxElements) {
-  return new ArgPromotion(MaxElements);
+  return new ArgPromotion(GL_NUMPROMARGS);
 }
 
 bool ArgPromotion::runOnSCC(CallGraphSCC &SCC) {
   if (skipSCC(SCC))
     return false;
 
   // Get the callgraph information that we need to update to reflect our
   // changes.

llvm/test/Transforms/ArgumentPromotion/magic-values/basictest.ll

+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --scrub-attributes
+; NOTE: three scenarios: 1) zero arguments promoted, 2) Baseline (current state = 3 args promoted), 3) infinite arguments promoted 
+; RUN: opt < %s  -basicaa -argpromotion -numargspromoted=0 -mem2reg -S | FileCheck %s
+; RUN: opt < %s  -basicaa -argpromotion -mem2reg -S | FileCheck %s
+; RUN: opt < %s  -basicaa -argpromotion -numargspromoted=2147483647 -mem2reg -S | FileCheck %s
+target datalayout = "E-p:64:64:64-a0:0:8-f32:32:32-f64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-v64:64:64-v128:128:128"
+
+define internal i32 @test(i32* %X, i32* %Y) {
+; CHECK-LABEL: define {{[^@]+}}@test
+; CHECK-SAME: (i32 [[X_VAL:%.*]], i32 [[Y_VAL:%.*]])
+; CHECK-NEXT:    [[C:%.*]] = add i32 [[X_VAL]], [[Y_VAL]]
+; CHECK-NEXT:    ret i32 [[C]]
+;
+  %A = load i32, i32* %X
+  %B = load i32, i32* %Y
+  %C = add i32 %A, %B
+  ret i32 %C
+}
+
+define internal i32 @caller(i32* %B) {
+; CHECK-LABEL: define {{[^@]+}}@caller
+; CHECK-SAME: (i32 [[B_VAL1:%.*]])
+; CHECK-NEXT:    [[C:%.*]] = call i32 @test(i32 1, i32 [[B_VAL1]])
+; CHECK-NEXT:    ret i32 [[C]]
+;
+  %A = alloca i32
+  store i32 1, i32* %A
+  %C = call i32 @test(i32* %A, i32* %B)
+  ret i32 %C
+}
+
+define i32 @callercaller() {
+; CHECK-LABEL: define {{[^@]+}}@callercaller()
+; CHECK-NEXT:    [[X:%.*]] = call i32 @caller(i32 2)
+; CHECK-NEXT:    ret i32 [[X]]
+;
+  %B = alloca i32
+  store i32 2, i32* %B
+  %X = call i32 @caller(i32* %B)
+  ret i32 %X
+}
+

llvm/test/Transforms/ArgumentPromotion/magic-values/lit.local.cfg

+if not 'X86' in config.root.targets:
+    config.unsupported = True