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

[Michael Zolotukhin]

> On Feb 10, 2015, at 5:53 AM, Hal Finkel <hfinkel at anl.gov> wrote:
> 
> ----- Original Message -----
>> From: "Michael Zolotukhin" <mzolotukhin at apple.com <mailto:mzolotukhin at apple.com>>
>> To: "Hal J. Finkel" <hfinkel at anl.gov <mailto:hfinkel at anl.gov>>
>> Cc: llvm-commits at cs.uiuc.edu <mailto: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.
Thanks, committed in r228713.

Michael
> 
> -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

-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.llvm.org/pipermail/llvm-commits/attachments/20150210/12b0fc11/attachment.html>