[llvm] r228434 - Use estimated number of optimized insns in unroll-threshold computation.

Tue Feb 10 05:53:55 PST 2015

----- Original Message -----
> From: "Michael Zolotukhin" <mzolotukhin at apple.com>
> To: "Hal J. Finkel" <hfinkel at anl.gov>
> Cc: llvm-commits at cs.uiuc.edu
> Sent: Monday, February 9, 2015 2:49:40 PM
> Subject: Re: [llvm] r228434 - Use estimated number of optimized insns in unroll-threshold computation.
> 
> 
> 
> Hi Hal,
> 
> Could you please take a look at the attached test? Does it cover the
> new features enough, or did I miss anything?
> 

I think this looks good. Please commit it.

 -Hal

> 
> Thanks,
> Michael
> 
> > On Feb 6, 2015, at 12:31 PM, Hal Finkel <hfinkel at anl.gov> wrote:
> > 
> > As you stated in your follow-up e-mail ;) -- this needs a test
> > case.
> > 
> > -Hal
> > 
> > ----- Original Message -----
> >> From: "Michael Zolotukhin" <mzolotukhin at apple.com>
> >> To: llvm-commits at cs.uiuc.edu
> >> Sent: Friday, February 6, 2015 2:20:40 PM
> >> Subject: [llvm] r228434 - Use estimated number of optimized insns
> >> in unroll-threshold computation.
> >> 
> >> Author: mzolotukhin
> >> Date: Fri Feb 6 14:20:40 2015
> >> New Revision: 228434
> >> 
> >> URL: http://llvm.org/viewvc/llvm-project?rev=228434&view=rev
> >> Log:
> >> Use estimated number of optimized insns in unroll-threshold
> >> computation.
> >> 
> >> If complete-unroll could help us to optimize away N% of
> >> instructions,
> >> we
> >> might want to do this even if the final size would exceed
> >> loop-unroll
> >> threshold. However, we don't want to unroll huge loop, and we are
> >> add
> >> AbsoluteThreshold to avoid that - this threshold will never be
> >> crossed,
> >> even if we expect to optimize 99% instructions after that.
> >> 
> >> Modified:
> >> llvm/trunk/include/llvm/Analysis/TargetTransformInfo.h
> >> llvm/trunk/lib/Transforms/Scalar/LoopUnrollPass.cpp
> >> 
> >> Modified: llvm/trunk/include/llvm/Analysis/TargetTransformInfo.h
> >> URL:
> >> http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/Analysis/TargetTransformInfo.h?rev=228434&r1=228433&r2=228434&view=diff
> >> ==============================================================================
> >> --- llvm/trunk/include/llvm/Analysis/TargetTransformInfo.h
> >> (original)
> >> +++ llvm/trunk/include/llvm/Analysis/TargetTransformInfo.h Fri Feb
> >> 6
> >> 14:20:40 2015
> >> @@ -217,6 +217,13 @@ public:
> >> /// exceed this cost. Set this to UINT_MAX to disable the loop
> >> body cost
> >> /// restriction.
> >> unsigned Threshold;
> >> + /// If complete unrolling could help other optimizations (e.g.
> >> InstSimplify)
> >> + /// to remove N% of instructions, then we can go beyond unroll
> >> threshold.
> >> + /// This value set the minimal percent for allowing that.
> >> + unsigned MinPercentOfOptimized;
> >> + /// The absolute cost threshold. We won't go beyond this even if
> >> complete
> >> + /// unrolling could result in optimizing out 90% of
> >> instructions.
> >> + unsigned AbsoluteThreshold;
> >> /// The cost threshold for the unrolled loop when optimizing for
> >> size (set
> >> /// to UINT_MAX to disable).
> >> unsigned OptSizeThreshold;
> >> 
> >> Modified: llvm/trunk/lib/Transforms/Scalar/LoopUnrollPass.cpp
> >> URL:
> >> http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Scalar/LoopUnrollPass.cpp?rev=228434&r1=228433&r2=228434&view=diff
> >> ==============================================================================
> >> --- llvm/trunk/lib/Transforms/Scalar/LoopUnrollPass.cpp (original)
> >> +++ llvm/trunk/lib/Transforms/Scalar/LoopUnrollPass.cpp Fri Feb 6
> >> 14:20:40 2015
> >> @@ -45,6 +45,17 @@ static cl::opt<unsigned> UnrollMaxIterat
> >> cl::desc("Don't allow loop unrolling to simulate more than this
> >> number of"
> >> "iterations when checking full unroll profitability"));
> >> 
> >> +static cl::opt<unsigned> UnrollMinPercentOfOptimized(
> >> + "unroll-percent-of-optimized-for-complete-unroll", cl::init(20),
> >> cl::Hidden,
> >> + cl::desc("If complete unrolling could trigger further
> >> optimizations, and, "
> >> + "by that, remove the given percent of instructions,
> >> perform the "
> >> + "complete unroll even if it's beyond the threshold"));
> >> +
> >> +static cl::opt<unsigned> UnrollAbsoluteThreshold(
> >> + "unroll-absolute-threshold", cl::init(2000), cl::Hidden,
> >> + cl::desc("Don't unroll if the unrolled size is bigger than this
> >> threshold,"
> >> + " even if we can remove big portion of instructions
> >> later."));
> >> +
> >> static cl::opt<unsigned>
> >> UnrollCount("unroll-count", cl::init(0), cl::Hidden,
> >> cl::desc("Use this unroll count for all loops including those with
> >> "
> >> @@ -70,11 +81,16 @@ namespace {
> >> static char ID; // Pass ID, replacement for typeid
> >> LoopUnroll(int T = -1, int C = -1, int P = -1, int R = -1) :
> >> LoopPass(ID) {
> >> CurrentThreshold = (T == -1) ? UnrollThreshold : unsigned(T);
> >> + CurrentAbsoluteThreshold = UnrollAbsoluteThreshold;
> >> + CurrentMinPercentOfOptimized = UnrollMinPercentOfOptimized;
> >> CurrentCount = (C == -1) ? UnrollCount : unsigned(C);
> >> CurrentAllowPartial = (P == -1) ? UnrollAllowPartial :
> >> (bool)P;
> >> CurrentRuntime = (R == -1) ? UnrollRuntime : (bool)R;
> >> 
> >> UserThreshold = (T != -1) ||
> >> (UnrollThreshold.getNumOccurrences() > 0);
> >> + UserAbsoluteThreshold =
> >> (UnrollAbsoluteThreshold.getNumOccurrences() > 0);
> >> + UserPercentOfOptimized =
> >> + (UnrollMinPercentOfOptimized.getNumOccurrences() > 0);
> >> UserAllowPartial = (P != -1) ||
> >> (UnrollAllowPartial.getNumOccurrences() >
> >> 0);
> >> UserRuntime = (R != -1) || (UnrollRuntime.getNumOccurrences()
> >>> 0);
> >> @@ -98,10 +114,16 @@ namespace {
> >> 
> >> unsigned CurrentCount;
> >> unsigned CurrentThreshold;
> >> + unsigned CurrentAbsoluteThreshold;
> >> + unsigned CurrentMinPercentOfOptimized;
> >> bool CurrentAllowPartial;
> >> bool CurrentRuntime;
> >> bool UserCount; // CurrentCount is
> >> user-specified.
> >> bool UserThreshold; // CurrentThreshold is
> >> user-specified.
> >> + bool UserAbsoluteThreshold; // CurrentAbsoluteThreshold is
> >> + // user-specified.
> >> + bool UserPercentOfOptimized; // CurrentMinPercentOfOptimized
> >> is
> >> + // user-specified.
> >> bool UserAllowPartial; // CurrentAllowPartial is
> >> user-specified.
> >> bool UserRuntime; // CurrentRuntime is
> >> user-specified.
> >> 
> >> @@ -133,6 +155,8 @@ namespace {
> >> void getUnrollingPreferences(Loop *L, const TargetTransformInfo
> >> &TTI,
> >> TargetTransformInfo::UnrollingPreferences
> >> &UP) {
> >> UP.Threshold = CurrentThreshold;
> >> + UP.AbsoluteThreshold = CurrentAbsoluteThreshold;
> >> + UP.MinPercentOfOptimized = CurrentMinPercentOfOptimized;
> >> UP.OptSizeThreshold = OptSizeUnrollThreshold;
> >> UP.PartialThreshold = CurrentThreshold;
> >> UP.PartialOptSizeThreshold = OptSizeUnrollThreshold;
> >> @@ -160,13 +184,32 @@ namespace {
> >> void selectThresholds(const Loop *L, bool HasPragma,
> >> const
> >> TargetTransformInfo::UnrollingPreferences
> >> &UP,
> >> unsigned &Threshold, unsigned
> >> &PartialThreshold,
> >> - unsigned NumberOfSimplifiedInstructions) {
> >> + unsigned NumberOfOptimizedInstructions) {
> >> // Determine the current unrolling threshold. While this is
> >> // normally set from UnrollThreshold, it is overridden to a
> >> // smaller value if the current function is marked as
> >> // optimize-for-size, and the unroll threshold was not user
> >> // specified.
> >> Threshold = UserThreshold ? CurrentThreshold : UP.Threshold;
> >> +
> >> + // If we are allowed to completely unroll if we can remove M%
> >> of
> >> + // instructions, and we know that with complete unrolling
> >> we'll be able
> >> + // to kill N instructions, then we can afford to completely
> >> unroll loops
> >> + // with unrolled size up to N*100/M.
> >> + // Adjust the threshold according to that:
> >> + unsigned PercentOfOptimizedForCompleteUnroll =
> >> + UserPercentOfOptimized ? CurrentMinPercentOfOptimized
> >> + : UP.MinPercentOfOptimized;
> >> + unsigned AbsoluteThreshold = UserAbsoluteThreshold
> >> + ? CurrentAbsoluteThreshold
> >> + : UP.AbsoluteThreshold;
> >> + if (PercentOfOptimizedForCompleteUnroll)
> >> + Threshold = std::max<unsigned>(Threshold,
> >> + NumberOfOptimizedInstructions
> >> * 100 /
> >> +
> >> PercentOfOptimizedForCompleteUnroll);
> >> + // But don't allow unrolling loops bigger than absolute
> >> threshold.
> >> + Threshold = std::min<unsigned>(Threshold, AbsoluteThreshold);
> >> +
> >> PartialThreshold = UserThreshold ? CurrentThreshold :
> >> UP.PartialThreshold;
> >> if (!UserThreshold &&
> >> L->getHeader()->getParent()->getAttributes().
> >> @@ -186,7 +229,6 @@ namespace {
> >> PartialThreshold =
> >> std::max<unsigned>(PartialThreshold,
> >> PragmaUnrollThreshold);
> >> }
> >> - Threshold += NumberOfSimplifiedInstructions;
> >> }
> >> };
> >> }
> >> 
> >> 
> >> _______________________________________________
> >> llvm-commits mailing list
> >> llvm-commits at cs.uiuc.edu
> >> http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits
> >> 
> > 
> > --
> > Hal Finkel
> > Assistant Computational Scientist
> > Leadership Computing Facility
> > Argonne National Laboratory
> 
> 

-- 
Hal Finkel
Assistant Computational Scientist
Leadership Computing Facility
Argonne National Laboratory