BlockFrequency: Bump up the entry frequency a bit.

This is a band-aid to fix the most severe regressions we're seeing from basing
spill decisions on block frequencies, until we have a better solution.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@184835 91177308-0d34-0410-b5e6-96231b3b80d8

include/llvm/Analysis/BlockFrequencyImpl.h

@@ -33,7 +33,7 @@ class BlockFrequencyInfo;
 class MachineBlockFrequencyInfo;
 
 /// BlockFrequencyImpl implements block frequency algorithm for IR and
-/// Machine Instructions. Algorithm starts with value 1024 (START_FREQ)
+/// Machine Instructions. Algorithm starts with value ENTRY_FREQ
 /// for the entry block and then propagates frequencies using branch weights
 /// from (Machine)BranchProbabilityInfo. LoopInfo is not required because
 /// algorithm can find "backedges" by itself.

include/llvm/Analysis/BlockFrequencyInfo.h

@@ -43,10 +43,10 @@ public:
   void print(raw_ostream &O, const Module *M) const;
 
   /// getblockFreq - Return block frequency. Return 0 if we don't have the
-  /// information. Please note that initial frequency is equal to 1024. It means
+  /// information. Please note that initial frequency is equal to ENTRY_FREQ. It
-  /// that we should not rely on the value itself, but only on the comparison to
+  /// means that we should not rely on the value itself, but only on the
-  /// the other block frequencies. We do this to avoid using of floating points.
+  /// comparison to the other block frequencies. We do this to avoid using of
-  ///
+  /// floating points.
   BlockFrequency getBlockFreq(const BasicBlock *BB) const;
 };
 

include/llvm/Support/BlockFrequency.h

@@ -25,7 +25,7 @@ class BranchProbability;
 class BlockFrequency {
 
   uint64_t Frequency;
-  static const int64_t ENTRY_FREQ = 1024;
+  static const int64_t ENTRY_FREQ = 1 << 14;
 
 public:
   BlockFrequency(uint64_t Freq = 0) : Frequency(Freq) { }

lib/Analysis/BlockFrequencyInfo.cpp

@@ -53,11 +53,6 @@ void BlockFrequencyInfo::print(raw_ostream &O, const Module *) const {
   if (BFI) BFI->print(O);
 }
 
-/// getblockFreq - Return block frequency. Return 0 if we don't have the
-/// information. Please note that initial frequency is equal to 1024. It means
-/// that we should not rely on the value itself, but only on the comparison to
-/// the other block frequencies. We do this to avoid using of floating points.
-///
 BlockFrequency BlockFrequencyInfo::getBlockFreq(const BasicBlock *BB) const {
   return BFI->getBlockFreq(BB);
 }

lib/CodeGen/MachineBlockFrequencyInfo.cpp

@@ -50,11 +50,6 @@ bool MachineBlockFrequencyInfo::runOnMachineFunction(MachineFunction &F) {
   return false;
 }
 
-/// getblockFreq - Return block frequency. Return 0 if we don't have the
-/// information. Please note that initial frequency is equal to 1024. It means
-/// that we should not rely on the value itself, but only on the comparison to
-/// the other block frequencies. We do this to avoid using of floating points.
-///
 BlockFrequency MachineBlockFrequencyInfo::
 getBlockFreq(const MachineBasicBlock *MBB) const {
   return MBFI->getBlockFreq(MBB);

test/Analysis/BlockFrequencyInfo/basic.ll

@@ -2,12 +2,12 @@
 
 define i32 @test1(i32 %i, i32* %a) {
 ; CHECK: Printing analysis {{.*}} for function 'test1'
-; CHECK: entry = 1024
+; CHECK: entry = 16384
 entry:
   br label %body
 
 ; Loop backedges are weighted and thus their bodies have a greater frequency.
-; CHECK: body = 31744
+; CHECK: body = 524288
 body:
   %iv = phi i32 [ 0, %entry ], [ %next, %body ]
   %base = phi i32 [ 0, %entry ], [ %sum, %body ]
@@ -18,29 +18,29 @@ body:
   %exitcond = icmp eq i32 %next, %i
   br i1 %exitcond, label %exit, label %body
 
-; CHECK: exit = 1024
+; CHECK: exit = 16384
 exit:
   ret i32 %sum
 }
 
 define i32 @test2(i32 %i, i32 %a, i32 %b) {
 ; CHECK: Printing analysis {{.*}} for function 'test2'
-; CHECK: entry = 1024
+; CHECK: entry = 16384
 entry:
   %cond = icmp ult i32 %i, 42
   br i1 %cond, label %then, label %else, !prof !0
 
 ; The 'then' branch is predicted more likely via branch weight metadata.
-; CHECK: then = 963
+; CHECK: then = 15420
 then:
   br label %exit
 
-; CHECK: else = 60
+; CHECK: else = 963
 else:
   br label %exit
 
-; FIXME: It may be a bug that we don't sum back to 1024.
+; FIXME: It may be a bug that we don't sum back to 16384.
-; CHECK: exit = 1023
+; CHECK: exit = 16383
 exit:
   %result = phi i32 [ %a, %then ], [ %b, %else ]
   ret i32 %result
@@ -50,36 +50,36 @@ exit:
 
 define i32 @test3(i32 %i, i32 %a, i32 %b, i32 %c, i32 %d, i32 %e) {
 ; CHECK: Printing analysis {{.*}} for function 'test3'
-; CHECK: entry = 1024
+; CHECK: entry = 16384
 entry:
   switch i32 %i, label %case_a [ i32 1, label %case_b
                                  i32 2, label %case_c
                                  i32 3, label %case_d
                                  i32 4, label %case_e ], !prof !1
 
-; CHECK: case_a = 51
+; CHECK: case_a = 819
 case_a:
   br label %exit
 
-; CHECK: case_b = 51
+; CHECK: case_b = 819
 case_b:
   br label %exit
 
 ; The 'case_c' branch is predicted more likely via branch weight metadata.
-; CHECK: case_c = 819
+; CHECK: case_c = 13107
 case_c:
   br label %exit
 
-; CHECK: case_d = 51
+; CHECK: case_d = 819
 case_d:
   br label %exit
 
-; CHECK: case_e = 51
+; CHECK: case_e = 819
 case_e:
   br label %exit
 
-; FIXME: It may be a bug that we don't sum back to 1024.
+; FIXME: It may be a bug that we don't sum back to 16384.
-; CHECK: exit = 1023
+; CHECK: exit = 16383
 exit:
   %result = phi i32 [ %a, %case_a ],
                     [ %b, %case_b ],