patch1.diff

diff --git a/compiler-rt/lib/fuzzer/FuzzerCorpus.h b/compiler-rt/lib/fuzzer/FuzzerCorpus.h
index 6a95ef3a8e64..9b9139b98eb0 100644
--- a/compiler-rt/lib/fuzzer/FuzzerCorpus.h
+++ b/compiler-rt/lib/fuzzer/FuzzerCorpus.h
@@ -21,6 +21,7 @@
 #include <numeric>
 #include <random>
 #include <unordered_set>
+#include <unordered_map>
 
 namespace fuzzer {
 
@@ -38,12 +39,103 @@ struct InputInfo {
   bool HasFocusFunction = false;
   Vector<uint32_t> UniqFeatureSet;
   Vector<uint8_t> DataFlowTraceForFocusFunction;
+  // size_t NumOfMutationAttempts = 0;
+  size_t SeedID=0;
+  // Power schedule.
+  bool NeedsEnergyUpdate = false;
+  double Energy = 0.0;
+  size_t SumIncidence = 0;
+  Vector<std::pair<uint32_t, uint16_t>> FeatureFreqs;
+  // Delete feature Idx and its frequency from FeatureFreqs.
+  bool DeleteFeatureFreq(uint32_t Idx) {
+    if (FeatureFreqs.empty())
+      return false;
+
+    // Binary search over local feature frequencies sorted by index.
+    auto Lower = std::lower_bound(FeatureFreqs.begin(), FeatureFreqs.end(),
+                                  std::pair<uint32_t, uint16_t>(Idx, 0));
+
+    if (Lower != FeatureFreqs.end() && Lower->first == Idx) {
+      FeatureFreqs.erase(Lower);
+      return true;
+    }
+    return false;
+  }
+
+  // Assign more energy to a high-entropy seed, i.e., that reveals more
+  // information about the globally rare features in the neighborhood
+  // of the seed. Since we do not know the entropy of a seed that has
+  // never been executed we assign fresh seeds maximum entropy and
+  // let II->Energy approach the true entropy from above.
+  void UpdateEnergy(size_t GlobalNumberOfFeatures) {
+    Energy = 0.0;
+    SumIncidence = 0;
+
+    // Apply add-one smoothing to locally discovered features.
+    for (auto F : FeatureFreqs) {
+      size_t LocalIncidence = F.second + 1;
+      Energy -= LocalIncidence * logl(LocalIncidence);
+      SumIncidence += LocalIncidence;
+    }
+
+    // Apply add-one smoothing to locally undiscovered features.
+    //   PreciseEnergy -= 0; // since logl(1.0) == 0)
+    SumIncidence += (GlobalNumberOfFeatures - FeatureFreqs.size());
+
+    // Add a single locally abundant feature apply add-one smoothing.
+    size_t AbdIncidence = NumExecutedMutations + 1;
+    Energy -= AbdIncidence * logl(AbdIncidence);
+    SumIncidence += AbdIncidence;
+
+    // Normalize.
+    if (SumIncidence != 0)
+      Energy = (Energy / SumIncidence) + logl(SumIncidence);
+  }
+
+  // Increment the frequency of the feature Idx.
+  void UpdateFeatureFrequency(uint32_t Idx) {
+    NeedsEnergyUpdate = true;
+
+    // The local feature frequencies is an ordered vector of pairs.
+    // If there are no local feature frequencies, push_back preserves order.
+    // Set the feature frequency for feature Idx32 to 1.
+    if (FeatureFreqs.empty()) {
+      FeatureFreqs.push_back(std::pair<uint32_t, uint16_t>(Idx, 1));
+      return;
+    }
+
+    // Binary search over local feature frequencies sorted by index.
+    auto Lower = std::lower_bound(FeatureFreqs.begin(), FeatureFreqs.end(),
+                                  std::pair<uint32_t, uint16_t>(Idx, 0));
+
+    // If feature Idx32 already exists, increment its frequency.
+    // Otherwise, insert a new pair right after the next lower index.
+    if (Lower != FeatureFreqs.end() && Lower->first == Idx) {
+      Lower->second++;
+    } else {
+      FeatureFreqs.insert(Lower, std::pair<uint32_t, uint16_t>(Idx, 1));
+    }
+  }
+};
+
+struct EntropicOptions {
+  bool Enabled;
+  size_t NumberOfRarestFeatures;
+  size_t FeatureFrequencyThreshold;
 };
 
 class InputCorpus {
-  static const size_t kFeatureSetSize = 1 << 21;
- public:
-  InputCorpus(const std::string &OutputCorpus) : OutputCorpus(OutputCorpus) {
+  static const uint32_t kFeatureSetSize = 1 << 21;
+  static const uint8_t kMaxMutationFactor = 20;
+  static const size_t kSparseEnergyUpdates = 100;
+
+  size_t NumExecutedMutations = 0;
+
+  EntropicOptions Entropic;
+
+public:
+  InputCorpus(const std::string &OutputCorpus, EntropicOptions Entropic)
+      : Entropic(Entropic), OutputCorpus(OutputCorpus) {
     memset(InputSizesPerFeature, 0, sizeof(InputSizesPerFeature));
     memset(SmallestElementPerFeature, 0, sizeof(SmallestElementPerFeature));
   }
@@ -71,6 +163,187 @@ class InputCorpus {
     return Res;
   }
 
+  size_t Nextprint = 100;
+  size_t Measurements = 0;
+  uint8_t SeedsCounter = 0; // When counter reaches 10 (paths discovered), fork fuzzer
+  uint8_t ForksCounter = 0; // fork counter
+  size_t MutationsInFork = 0; // In the fork, number of mutations it took to reach next path
+  size_t MaxMutationsInFork = 0; // try max fork muts
+  size_t AvgMutationsInFork = 0; // try average fork muts
+  bool ForkSuccessful = false; // whether fork was successful
+  const uint8_t SeedsLimit = 1; // number of seeds after which to fork
+  const uint8_t ForkLimit = 10; // number of forks to perform
+  bool ForkMode = false;
+  // std::unordered_map<size_t,size_t> SeedTrialMap;
+  std::unordered_map<size_t,size_t> TmpSeedTrialMap;
+  size_t NewFeaturesDuringMeasurement = 0;
+  Vector<size_t> GlobalFailsVector; // fails until cur seed, only choose attempted seeds
+  size_t TrialsToSuccess=0;
+  size_t GlobalSeedID=0;
+  size_t GlobalFeats = 0;
+  size_t GlobalLLaplace =0;
+  size_t GlobalLGT=0;
+  size_t GlobalMaxForkMutations=0; // max mutations in fork
+  size_t GlobalAvgForkMutations=0; // avg of mutations in fork
+  size_t GlobalExecRate=0; // record exec rate every few successful mutations
+  uint8_t SetNewFeaturesDuringMeasurement = 0;
+
+  void CalcEst() { // call this every time we append to GlobalFails vector
+    long double laplace = 0;
+    long double local_gt = 0;
+    
+    for (size_t i = 0; i < Inputs.size(); i++) {
+      auto &II = *Inputs[i];
+      DistributionNeedsUpdate = true;
+      Random Rand(0);
+      UpdateCorpusDistribution(Rand);
+      double weight = CorpusDistribution.densities()[i]; 
+      if (II.NumExecutedMutations == 0) {
+        laplace  += weight;
+        local_gt += weight;
+      } else {
+        size_t localSingletonsForII = 0;
+        for (auto entry : II.FeatureFreqs) {
+          if (entry.second == 1)
+            localSingletonsForII ++;
+        }
+        if (localSingletonsForII > 0)
+          local_gt += weight * (localSingletonsForII / (long double) II.NumExecutedMutations);
+        else
+          local_gt += weight / (long double) (II.NumExecutedMutations + 2);
+
+        size_t globalSingletonsForII = 0;
+        for (uint32_t Idx : RareFeatures) {
+          if (GlobalFeatureFreqs[Idx] == 1) {
+            if (II.FeatureFreqs.empty())  continue;
+            // Binary search over local feature frequencies sorted by index.
+            auto Lower = std::lower_bound(II.FeatureFreqs.begin(), II.FeatureFreqs.end(),
+                                          std::pair<uint32_t, uint16_t>(Idx, 0));
+            if (Lower != II.FeatureFreqs.end() && Lower->first == Idx) {
+              globalSingletonsForII++;
+            }
+          }
+        }
+        if (globalSingletonsForII > 0)
+          laplace += weight * (globalSingletonsForII / (long double) II.NumExecutedMutations);
+        else
+          laplace += weight / (long double) (II.NumExecutedMutations + 2);
+      }
+    }
+    laplace *= NumExecutedMutations;
+    local_gt *= NumExecutedMutations;
+    size_t Laplace = (size_t)std::round(laplace);
+    size_t LocalGt = (size_t)std::round(local_gt);
+    GlobalLLaplace = Laplace;
+    GlobalLGT = LocalGt;
+  }
+
+  void IncrementNumExecutedMutations() {
+    // SetNewFeaturesDuringMeasurement = 0;
+    // if (Measurements > 0) { // blackbox measurement, never reached
+    //   Measurements--;
+    //   UnsuccMutations = 0; // don't want to record anymore
+    //   if (Measurements == 0) {
+    //     PrintCSV();
+    //   }
+    // else { // greybox measurement
+    NumExecutedMutations++;
+    if (NumExecutedMutations == Nextprint) {
+      // Measurements = NumExecutedMutations; //stopping blackbox 
+      // if(UnsuccMutations != 0) { // at the end of GB, if there any left
+      //   GlobalTrialsVector.push_back(UnsuccMutations);
+      //   GlobalFeatsVector.push_back(0);
+      //   CalcEst(); 
+      //   UnsuccMutations = 0; // reset fails after this success
+      // }
+      NewFeaturesDuringMeasurement = 0;
+      memset(BlackboxFeatureFreqs, 0, sizeof BlackboxFeatureFreqs);
+      BlackboxSingletons.clear();
+      Nextprint *= 2;
+      // PrintCSV();
+    }
+  }
+
+  void PrintCSV() {
+    // Find singletons, etc.
+    // size_t Xtons[4] = {};
+    // size_t Vtons[4] = {};
+    // for (uint32_t Idx : RareFeatures) {
+    //   for (uint8_t i = 0; i < 4; i++) {
+    //     if (GlobalFeatureFreqs[Idx] == i + 1)
+    //       Xtons[i]++;
+    //     if (ValentinFeatureFreqs[Idx] == i + 1)
+    //       Vtons[i]++;
+    //   }
+    // }
+    // long double laplace = 0;
+    // long double local_gt = 0;
+    // for (size_t i = 0; i < Inputs.size(); i++) {
+    //   auto &II = *Inputs[i];
+    //   DistributionNeedsUpdate = true;
+    //   Random Rand(0);
+    //   UpdateCorpusDistribution(Rand);
+    //   double weight = CorpusDistribution.densities()[i]; 
+    //   if (II.NumExecutedMutations == 0) {
+    //     laplace  += weight;
+    //     local_gt += weight;
+    //   } else {
+    //     size_t localSingletonsForII = 0;
+    //     for (auto entry : II.FeatureFreqs) {
+    //       if (entry.second == 1)
+    //         localSingletonsForII ++;
+    //     }
+    //     if (localSingletonsForII > 0)
+    //       local_gt += weight * (localSingletonsForII / (long double) II.NumExecutedMutations);
+    //     else
+    //       local_gt += weight / (long double) (II.NumExecutedMutations + 2);
+    //     size_t globalSingletonsForII = 0;
+    //     for (uint32_t Idx : RareFeatures) {
+    //       if (GlobalFeatureFreqs[Idx] == 1) {
+    //         if (II.FeatureFreqs.empty())  continue;
+    //         // Binary search over local feature frequencies sorted by index.
+    //         auto Lower = std::lower_bound(II.FeatureFreqs.begin(), II.FeatureFreqs.end(),
+    //                                       std::pair<uint32_t, uint16_t>(Idx, 0));
+    //         if (Lower != II.FeatureFreqs.end() && Lower->first == Idx) {
+    //           globalSingletonsForII++;
+    //         }
+    //       }
+    //     }
+    //     if (globalSingletonsForII > 0)
+    //       laplace += weight * (globalSingletonsForII / (long double) II.NumExecutedMutations);
+    //     else
+    //       laplace += weight / (long double) (II.NumExecutedMutations + 2);
+    //   }
+    // }
+    // laplace *= NumExecutedMutations;
+    // local_gt *= NumExecutedMutations;
+    // double reset10 = NumExecutedMutations * Reset10F1 / (double) (NumExecutedMutations - Reset10Time);
+    // double reset1 = NumExecutedMutations * Reset1F1 / (double) (NumExecutedMutations - Reset1Time);
+    // size_t Laplace = (size_t)std::round(laplace);
+    // size_t LocalGt = (size_t)std::round(local_gt);
+    // size_t Reset10 = (size_t)std::round(reset10);
+    // size_t Reset1 = (size_t)std::round(reset1);
+    // Printf("__STATS__ %zd,%zd,%zd  %zd, %zd, %zd, %zd, %zd,  %zd,%zd,%zd,%zd,%zd,%zd,%zd,%zd,  %zd\n",
+    //   NumExecutedMutations, NewFeaturesDuringMeasurement,
+    //   Laplace, LocalGt, Reset1, Reset10, BlackboxSingletons.size(),
+    //   Xtons[0], Xtons[1], Xtons[2], Xtons[3],
+    //   Vtons[0], Vtons[1], Vtons[2], Vtons[3], MaxInputsReqOverall);
+    
+    Printf("__SUCCS__ %zd, %zd\n", NumExecutedMutations,TrialsToSuccess);
+    Printf("__FAILS__ %zd, ", NumExecutedMutations);
+    for(auto& x: GlobalFailsVector){
+      Printf("%zd, ", x);
+    }
+    Printf("\n");
+    Printf("__FEATS__ %zd, %zd\n", NumExecutedMutations,GlobalFeats);
+    Printf("__LLAPL__ %zd, %zd\n", NumExecutedMutations,GlobalLLaplace);
+    Printf("__LGDTU__ %zd, %zd\n", NumExecutedMutations,GlobalLGT);
+    Printf("__MXFRK__ %zd, %zd\n", NumExecutedMutations, GlobalMaxForkMutations);
+    Printf("__AVFRK__ %zd, %zd\n", NumExecutedMutations, GlobalAvgForkMutations);
+    Printf("__RATES__ %zd, %zd\n", NumExecutedMutations, GlobalExecRate);
+    GlobalFailsVector.clear();
+  }
+
   size_t NumInputsThatTouchFocusFunction() {
     return std::count_if(Inputs.begin(), Inputs.end(), [](const InputInfo *II) {
       return II->HasFocusFunction;
@@ -83,12 +356,19 @@ class InputCorpus {
     });
   }
 
+  size_t Reset10Time = 0;
+  size_t Reset1Time = 0;
+  size_t Reset10F1 = 0;
+  size_t Reset1F1 = 0;
   bool empty() const { return Inputs.empty(); }
   const Unit &operator[] (size_t Idx) const { return Inputs[Idx]->U; }
   InputInfo *AddToCorpus(const Unit &U, size_t NumFeatures, bool MayDeleteFile,
                          bool HasFocusFunction,
                          const Vector<uint32_t> &FeatureSet,
                          const DataFlowTrace &DFT, const InputInfo *BaseII) {
+
+    if (Measurements > 0) return NULL;
+
     assert(!U.empty());
     if (FeatureDebug)
       Printf("ADD_TO_CORPUS %zd NF %zd\n", Inputs.size(), NumFeatures);
@@ -99,6 +379,11 @@ class InputCorpus {
     II.MayDeleteFile = MayDeleteFile;
     II.UniqFeatureSet = FeatureSet;
     II.HasFocusFunction = HasFocusFunction;
+    II.SeedID = GlobalSeedID++;
+    // Assign maximal energy to the new seed.
+    II.Energy = RareFeatures.empty() ? 1.0 : log(RareFeatures.size());
+    II.SumIncidence = RareFeatures.size();
+    II.NeedsEnergyUpdate = false;
     std::sort(II.UniqFeatureSet.begin(), II.UniqFeatureSet.end());
     ComputeSHA1(U.data(), U.size(), II.Sha1);
     auto Sha1Str = Sha1ToString(II.Sha1);
@@ -111,8 +396,41 @@ class InputCorpus {
     // But if we don't, we'll use the DFT of its base input.
     if (II.DataFlowTraceForFocusFunction.empty() && BaseII)
       II.DataFlowTraceForFocusFunction = BaseII->DataFlowTraceForFocusFunction;
-    UpdateCorpusDistribution();
+    DistributionNeedsUpdate = true;
     PrintCorpus();
+
+    if (!(std::rand() % 10)) {
+      Reset10Time = NumExecutedMutations;
+      Reset10F1 = 0;
+      uint64_t *y = (uint64_t*)Reset10FeatureFreqs;
+      uint32_t i = kFeatureSetSize / 4;
+      while (i--) {
+        if (*y) {
+          uint16_t* z = (uint16_t*) y;
+          if (z[0] == 1) Reset10F1 ++;
+          if (z[1] == 1) Reset10F1 ++;
+          if (z[2] == 1) Reset10F1 ++;
+          if (z[3] == 1) Reset10F1 ++;
+        }
+        y++;
+      }
+      memset(Reset10FeatureFreqs, 0, sizeof Reset10FeatureFreqs);
+    }
+    Reset1Time = NumExecutedMutations;
+    Reset1F1 = 0;
+    uint64_t *y = (uint64_t*)Reset1FeatureFreqs;
+    uint32_t i = kFeatureSetSize / 4;
+    while (i--) {
+      if (*y) {
+        uint16_t* z = (uint16_t*) y;
+        if (z[0] == 1) Reset1F1 ++;
+        if (z[1] == 1) Reset1F1 ++;
+        if (z[2] == 1) Reset1F1 ++;
+        if (z[3] == 1) Reset1F1 ++;
+      }
+      y++;
+    } 
+    memset(Reset1FeatureFreqs, 0, sizeof Reset1FeatureFreqs);
     // ValidateFeatureSet();
     return &II;
   }
@@ -155,6 +473,7 @@ class InputCorpus {
   }
 
   void Replace(InputInfo *II, const Unit &U) {
+    if (Measurements > 0) return;
     assert(II->U.size() > U.size());
     Hashes.erase(Sha1ToString(II->Sha1));
     DeleteFile(*II);
@@ -162,7 +481,7 @@ class InputCorpus {
     Hashes.insert(Sha1ToString(II->Sha1));
     II->U = U;
     II->Reduced = true;
-    UpdateCorpusDistribution();
+    DistributionNeedsUpdate = true;
   }
 
   bool HasUnit(const Unit &U) { return Hashes.count(Hash(U)); }
@@ -175,6 +494,7 @@ class InputCorpus {
 
   // Returns an index of random unit from the corpus to mutate.
   size_t ChooseUnitIdxToMutate(Random &Rand) {
+    UpdateCorpusDistribution(Rand);
     size_t Idx = static_cast<size_t>(CorpusDistribution(Rand));
     assert(Idx < Inputs.size());
     return Idx;
@@ -202,23 +522,87 @@ class InputCorpus {
   }
 
   void DeleteFile(const InputInfo &II) {
-    if (!OutputCorpus.empty() && II.MayDeleteFile)
+    if (!OutputCorpus.empty() && II.MayDeleteFile) {
       RemoveFile(DirPlusFile(OutputCorpus, Sha1ToString(II.Sha1)));
+    }
   }
 
   void DeleteInput(size_t Idx) {
     InputInfo &II = *Inputs[Idx];
+    // SeedTrialMap.erase(II.SeedID);
     DeleteFile(II);
     Unit().swap(II.U);
+    II.Energy = 0.0;
+    II.NeedsEnergyUpdate = false;
+    DistributionNeedsUpdate = true;
     if (FeatureDebug)
       Printf("EVICTED %zd\n", Idx);
   }
 
+  void AddRareFeature(uint32_t Idx) {
+    // Maintain *at least* TopXRarestFeatures many rare features
+    // and all features with a frequency below ConsideredRare.
+    // Remove all other features.
+    while (RareFeatures.size() > Entropic.NumberOfRarestFeatures &&
+           FreqOfMostAbundantRareFeature > Entropic.FeatureFrequencyThreshold) {
+
+      // Find most and second most abbundant feature.
+      uint32_t MostAbundantRareFeatureIndices[2] = {RareFeatures[0],
+                                                    RareFeatures[0]};
+      size_t Delete = 0;
+      for (size_t i = 0; i < RareFeatures.size(); i++) {
+        uint32_t Idx2 = RareFeatures[i];
+        if (GlobalFeatureFreqs[Idx2] >=
+            GlobalFeatureFreqs[MostAbundantRareFeatureIndices[0]]) {
+          MostAbundantRareFeatureIndices[1] = MostAbundantRareFeatureIndices[0];
+          MostAbundantRareFeatureIndices[0] = Idx2;
+          Delete = i;
+        }
+      }
+
+      // Remove most abundant rare feature.
+      RareFeatures[Delete] = RareFeatures.back();
+      RareFeatures.pop_back();
+
+      for (auto II : Inputs) {
+        if (II->DeleteFeatureFreq(MostAbundantRareFeatureIndices[0]))
+          II->NeedsEnergyUpdate = true;
+      }
+
+      // Set 2nd most abundant as the new most abundant feature count.
+      FreqOfMostAbundantRareFeature =
+          GlobalFeatureFreqs[MostAbundantRareFeatureIndices[1]];
+    }
+
+    // Add rare feature, handle collisions, and update energy.
+    RareFeatures.push_back(Idx);
+    GlobalFeatureFreqs[Idx] = 0;
+    for (auto II : Inputs) {
+      II->DeleteFeatureFreq(Idx);
+
+      // Apply add-one smoothing to this locally undiscovered feature.
+      // Zero energy seeds will never be fuzzed and remain zero energy.
+      if (II->Energy > 0.0) {
+        II->SumIncidence += 1;
+        II->Energy += logl(II->SumIncidence) / II->SumIncidence;
+      }
+    }
+
+    DistributionNeedsUpdate = true;
+  }
+
   bool AddFeature(size_t Idx, uint32_t NewSize, bool Shrink) {
+
+    // if (Measurements > 0) return false;
     assert(NewSize);
     Idx = Idx % kFeatureSetSize;
     uint32_t OldSize = GetFeature(Idx);
     if (OldSize == 0 || (Shrink && OldSize > NewSize)) {
+      if (ForkMode) {
+        ForkSuccessful = true;
+        return false;
+      }
+      
       if (OldSize > 0) {
         size_t OldIdx = SmallestElementPerFeature[Idx];
         InputInfo &II = *Inputs[OldIdx];
@@ -228,6 +612,8 @@ class InputCorpus {
           DeleteInput(OldIdx);
       } else {
         NumAddedFeatures++;
+        //if (Entropic.Enabled)
+          AddRareFeature((uint32_t)Idx);
       }
       NumUpdatedFeatures++;
       if (FeatureDebug)
@@ -239,8 +625,58 @@ class InputCorpus {
     return false;
   }
 
+  // Increment frequency of feature Idx globally and locally.
+  void UpdateFeatureFrequency(InputInfo *II, size_t Idx) {
+    uint32_t Idx32 = Idx % kFeatureSetSize;
+    
+    if (BlackboxFeatureFreqs[Idx32] < 2) {
+      if (BlackboxFeatureFreqs[Idx32] == 0) {
+        BlackboxSingletons.push_back(Idx32);
+        BlackboxFeatureFreqs[Idx32] = 1;
+      } else {
+        BlackboxSingletons.erase(std::remove(BlackboxSingletons.begin(), BlackboxSingletons.end(), Idx32), BlackboxSingletons.end());
+        BlackboxFeatureFreqs[Idx32] = 2;
+      }
+    }
+
+    // Saturated increment.
+    if (GlobalFeatureFreqs[Idx32] == 0xFFFF)
+      return;
+    if (ForkMode) return;
+    if (Measurements > 0) {
+      if (GlobalFeatureFreqs[Idx32] == 0 && !SetNewFeaturesDuringMeasurement) {
+        NewFeaturesDuringMeasurement++;
+        SetNewFeaturesDuringMeasurement = 1;
+      }
+      return;
+    }
+
+    uint16_t Freq = GlobalFeatureFreqs[Idx32]++;
+    Reset10FeatureFreqs[Idx32]++;
+    Reset1FeatureFreqs[Idx32]++;
+
+    // TODO DELME Only increment if II does not have this in its UniqFeatureSet
+    if (!Entropic.Enabled && (!II || std::find(II->UniqFeatureSet.begin(), II->UniqFeatureSet.end(), Idx32) == II->UniqFeatureSet.end()))
+        ValentinFeatureFreqs[Idx32]++;
+
+    // Skip if abundant.
+    if (Freq > FreqOfMostAbundantRareFeature ||
+        std::find(RareFeatures.begin(), RareFeatures.end(), Idx32) ==
+            RareFeatures.end())
+      return;
+
+    // Update global frequencies.
+    if (Freq == FreqOfMostAbundantRareFeature)
+      FreqOfMostAbundantRareFeature++;
+
+    // Update local frequencies.
+    if (II)
+      II->UpdateFeatureFrequency(Idx32);
+  }
+
   size_t NumFeatures() const { return NumAddedFeatures; }
   size_t NumFeatureUpdates() const { return NumUpdatedFeatures; }
+  size_t NumExMuts() const { return NumExecutedMutations; }
 
 private:
 
@@ -265,19 +701,60 @@ private:
   // Updates the probability distribution for the units in the corpus.
   // Must be called whenever the corpus or unit weights are changed.
   //
-  // Hypothesis: units added to the corpus last are more interesting.
-  //
-  // Hypothesis: inputs with infrequent features are more interesting.
-  void UpdateCorpusDistribution() {
+  // Hypothesis: inputs that maximize information about globally rare features
+  // are interesting.
+  void UpdateCorpusDistribution(Random &Rand) {
+    // Skip update if no seeds or rare features were added/deleted.
+    // Sparse updates for local change of feature frequencies,
+    // i.e., randomly do not skip.
+    if (!DistributionNeedsUpdate &&
+        (!Entropic.Enabled || Rand(kSparseEnergyUpdates)))
+      return;
+
+    DistributionNeedsUpdate = false;
+
     size_t N = Inputs.size();
     assert(N);
     Intervals.resize(N + 1);
     Weights.resize(N);
     std::iota(Intervals.begin(), Intervals.end(), 0);
-    for (size_t i = 0; i < N; i++)
-      Weights[i] = Inputs[i]->NumFeatures
-                       ? (i + 1) * (Inputs[i]->HasFocusFunction ? 1000 : 1)
-                       : 0.;
+
+    bool VanillaSchedule = true;
+    if (Entropic.Enabled) {
+      for (auto II : Inputs) {
+        if (II->NeedsEnergyUpdate && II->Energy != 0.0) {
+          II->NeedsEnergyUpdate = false;
+          II->UpdateEnergy(RareFeatures.size());
+        }
+      }
+
+      for (size_t i = 0; i < N; i++) {
+
+        if (Inputs[i]->NumFeatures == 0) {
+          // If the seed doesn't represent any features, assign zero energy.
+          Weights[i] = 0.;
+        } else if (Inputs[i]->NumExecutedMutations / kMaxMutationFactor >
+                   NumExecutedMutations / Inputs.size()) {
+          // If the seed was fuzzed a lot more than average, assign zero energy.
+          Weights[i] = 0.;
+        } else {
+          // Otherwise, simply assign the computed energy.
+          Weights[i] = Inputs[i]->Energy;
+        }
+
+        // If energy for all seeds is zero, fall back to vanilla schedule.
+        if (Weights[i] > 0.0)
+          VanillaSchedule = false;
+      }
+    }
+
+    if (VanillaSchedule) {
+      for (size_t i = 0; i < N; i++)
+        Weights[i] = Inputs[i]->NumFeatures
+                         ? (i + 1) * (Inputs[i]->HasFocusFunction ? 1000 : 1)
+                         : 0.;
+    }
+
     if (FeatureDebug) {
       for (size_t i = 0; i < N; i++)
         Printf("%zd ", Inputs[i]->NumFeatures);
@@ -302,6 +779,16 @@ private:
   uint32_t InputSizesPerFeature[kFeatureSetSize];
   uint32_t SmallestElementPerFeature[kFeatureSetSize];
 
+  bool DistributionNeedsUpdate = true;
+  uint16_t FreqOfMostAbundantRareFeature = 0;
+  uint16_t GlobalFeatureFreqs[kFeatureSetSize] = {};
+  uint16_t ValentinFeatureFreqs[kFeatureSetSize] = {};
+  uint16_t BlackboxFeatureFreqs[kFeatureSetSize] = {};
+  uint16_t Reset1FeatureFreqs[kFeatureSetSize] = {};
+  uint16_t Reset10FeatureFreqs[kFeatureSetSize] = {};
+  Vector<uint32_t> RareFeatures;
+  Vector<uint32_t> BlackboxSingletons;
+
   std::string OutputCorpus;
 };
 
diff --git a/compiler-rt/lib/fuzzer/FuzzerDriver.cpp b/compiler-rt/lib/fuzzer/FuzzerDriver.cpp
index 0d4e468a674b..1a0b2580c5b7 100644
--- a/compiler-rt/lib/fuzzer/FuzzerDriver.cpp
+++ b/compiler-rt/lib/fuzzer/FuzzerDriver.cpp
@@ -708,6 +708,26 @@ int FuzzerDriver(int *argc, char ***argv, UserCallback Callback) {
     Options.CollectDataFlow = Flags.collect_data_flow;
   if (Flags.stop_file)
     Options.StopFile = Flags.stop_file;
+  Options.Entropic = Flags.entropic;
+  Options.EntropicFeatureFrequencyThreshold =
+      (size_t)Flags.entropic_feature_frequency_threshold;
+  Options.EntropicNumberOfRarestFeatures =
+      (size_t)Flags.entropic_number_of_rarest_features;
+  if (Options.Entropic) {
+    if (!Options.FocusFunction.empty()) {
+      Printf("ERROR: The parameters `--entropic` and `--focus_function` cannot "
+             "be used together.\n");
+      exit(1);
+    }
+    Printf("INFO: Running with entropic power schedule (0x%X, %d).\n",
+           Options.EntropicFeatureFrequencyThreshold,
+           Options.EntropicNumberOfRarestFeatures);
+  }
+  struct EntropicOptions Entropic;
+  Entropic.Enabled = Options.Entropic;
+  Entropic.FeatureFrequencyThreshold =
+      Options.EntropicFeatureFrequencyThreshold;
+  Entropic.NumberOfRarestFeatures = Options.EntropicNumberOfRarestFeatures;
 
   unsigned Seed = Flags.seed;
   // Initialize Seed.
@@ -728,7 +748,7 @@ int FuzzerDriver(int *argc, char ***argv, UserCallback Callback) {
 
   Random Rand(Seed);
   auto *MD = new MutationDispatcher(Rand, Options);
-  auto *Corpus = new InputCorpus(Options.OutputCorpus);
+  auto *Corpus = new InputCorpus(Options.OutputCorpus, Entropic);
   auto *F = new Fuzzer(Callback, *Corpus, *MD, Options);
 
   for (auto &U: Dictionary)
diff --git a/compiler-rt/lib/fuzzer/FuzzerFlags.def b/compiler-rt/lib/fuzzer/FuzzerFlags.def
index a67415743032..e4c99772c88a 100644
--- a/compiler-rt/lib/fuzzer/FuzzerFlags.def
+++ b/compiler-rt/lib/fuzzer/FuzzerFlags.def
@@ -153,6 +153,14 @@ FUZZER_FLAG_STRING(focus_function, "Experimental. "
      "Fuzzing will focus on inputs that trigger calls to this function. "
      "If -focus_function=auto and -data_flow_trace is used, libFuzzer "
      "will choose the focus functions automatically.")
+FUZZER_FLAG_INT(entropic, 0, "Experimental. Enables entropic power schedule.")
+FUZZER_FLAG_INT(entropic_feature_frequency_threshold, 0xFF, "Experimental. If "
+     "entropic is enabled, all features which are observed less often than "
+     "the specified value are considered as rare.")
+FUZZER_FLAG_INT(entropic_number_of_rarest_features, 100, "Experimental. If "
+     "entropic is enabled, we keep track of the frequencies only for the "
+     "Top-X least abundant features (union features that are considered as "
+     "rare).")
 
 FUZZER_FLAG_INT(analyze_dict, 0, "Experimental")
 FUZZER_DEPRECATED_FLAG(use_clang_coverage)
diff --git a/compiler-rt/lib/fuzzer/FuzzerFork.cpp b/compiler-rt/lib/fuzzer/FuzzerFork.cpp
index d9e6b79443e0..df439efd056b 100644
--- a/compiler-rt/lib/fuzzer/FuzzerFork.cpp
+++ b/compiler-rt/lib/fuzzer/FuzzerFork.cpp
@@ -21,6 +21,8 @@
 #include <chrono>
 #include <condition_variable>
 #include <fstream>
+#include <sys/stat.h>
+#include <iostream>
 #include <memory>
 #include <mutex>
 #include <queue>
@@ -33,6 +35,7 @@ struct Stats {
   size_t number_of_executed_units = 0;
   size_t peak_rss_mb = 0;
   size_t average_exec_per_sec = 0;
+  std::string data = "";
 };
 
 static Stats ParseFinalStatsFromLog(const std::string &LogPath) {
@@ -49,7 +52,12 @@ static Stats ParseFinalStatsFromLog(const std::string &LogPath) {
       {nullptr, nullptr},
   };
   while (std::getline(In, Line, '\n')) {
+    printf("%s\n", Line.c_str());
     if (Line.find("stat::") != 0) continue;
+    if (Line.find("stat::csv:") == 0) {
+      Res.data = Line.substr(11);
+      continue;
+    }
     std::istringstream ISS(Line);
     std::string Name;
     size_t Val;
@@ -70,6 +78,8 @@ struct FuzzJob {
   std::string SeedListPath;
   std::string CFPath;
   size_t      JobId;
+  bool        Executing = false;
+  Vector<std::string> CopiedSeeds;
 
   int         DftTimeInSeconds = 0;
 
@@ -124,7 +134,6 @@ struct GlobalEnv {
     Cmd.addFlag("reload", "0");  // working in an isolated dir, no reload.
     Cmd.addFlag("print_final_stats", "1");
     Cmd.addFlag("print_funcs", "0");  // no need to spend time symbolizing.
-    Cmd.addFlag("max_total_time", std::to_string(std::min((size_t)300, JobId)));
     Cmd.addFlag("stop_file", StopFile());
     if (!DataFlowBinary.empty()) {
       Cmd.addFlag("data_flow_trace", DFTDir);
@@ -133,11 +142,10 @@ struct GlobalEnv {
     }
     auto Job = new FuzzJob;
     std::string Seeds;
-    if (size_t CorpusSubsetSize =
-            std::min(Files.size(), (size_t)sqrt(Files.size() + 2))) {
+    if (size_t CorpusSubsetSize = Files.size()) {
       auto Time1 = std::chrono::system_clock::now();
       for (size_t i = 0; i < CorpusSubsetSize; i++) {
-        auto &SF = Files[Rand->SkewTowardsLast(Files.size())];
+        auto &SF = Files[i];
         Seeds += (Seeds.empty() ? "" : ",") + SF;
         CollectDFT(SF);
       }
@@ -206,18 +214,28 @@ struct GlobalEnv {
            NumRuns, Cov.size(), Features.size(), Files.size(),
            Stats.average_exec_per_sec, NumOOMs, NumTimeouts, NumCrashes,
            secondsSinceProcessStartUp(), Job->JobId, Job->DftTimeInSeconds);
-
+    Printf("%s\n", Stats.data.c_str());
     if (MergeCandidates.empty()) return;
 
     Vector<std::string> FilesToAdd;
     Set<uint32_t> NewFeatures, NewCov;
     CrashResistantMerge(Args, {}, MergeCandidates, &FilesToAdd, Features,
                         &NewFeatures, Cov, &NewCov, Job->CFPath, false);
+    RemoveFile(Job->CFPath);
+
     for (auto &Path : FilesToAdd) {
-      auto U = FileToVector(Path);
-      auto NewPath = DirPlusFile(MainCorpusDir, Hash(U));
-      WriteToFile(U, NewPath);
-      Files.push_back(NewPath);
+      // Only merge files that have not been merged already.
+      if (std::find(Job->CopiedSeeds.begin(), Job->CopiedSeeds.end(), Path) == Job->CopiedSeeds.end()) {
+        // NOT THREAD SAFE: Fast check whether file still exists.
+        struct stat buffer;
+        if (stat (Path.c_str(), &buffer) == 0) {
+          auto U = FileToVector(Path);
+          auto NewPath = DirPlusFile(MainCorpusDir, Hash(U));
+          WriteToFile(U, NewPath);
+          Files.push_back(NewPath);
+          Job->CopiedSeeds.push_back(Path);
+        }
+      }
     }
     Features.insert(NewFeatures.begin(), NewFeatures.end());
     Cov.insert(NewCov.begin(), NewCov.end());
@@ -271,10 +289,20 @@ struct JobQueue {
   }
 };
 
-void WorkerThread(JobQueue *FuzzQ, JobQueue *MergeQ) {
+void WorkerThread(GlobalEnv *Env, JobQueue *FuzzQ, JobQueue *MergeQ) {
   while (auto Job = FuzzQ->Pop()) {
     // Printf("WorkerThread: job %p\n", Job);
+    Job->Executing = true;
+    int Sleep_ms = 300000;
+    std::thread([=]() {
+      std::this_thread::sleep_for(std::chrono::milliseconds(Sleep_ms));
+      while (Job->Executing) {
+        Env->RunOneMergeJob(Job);
+        std::this_thread::sleep_for(std::chrono::milliseconds(Sleep_ms));
+      }
+    }).detach();
     Job->ExitCode = ExecuteCommand(Job->Cmd);
+    Job->Executing = false;
     MergeQ->Push(Job);
   }
 }
@@ -331,7 +359,7 @@ void FuzzWithFork(Random &Rand, const FuzzingOptions &Options,
   size_t JobId = 1;
   Vector<std::thread> Threads;
   for (int t = 0; t < NumJobs; t++) {
-    Threads.push_back(std::thread(WorkerThread, &FuzzQ, &MergeQ));
+    Threads.push_back(std::thread(WorkerThread, &Env, &FuzzQ, &MergeQ));
     FuzzQ.Push(Env.CreateNewJob(JobId++));
   }
 
diff --git a/compiler-rt/lib/fuzzer/FuzzerLoop.cpp b/compiler-rt/lib/fuzzer/FuzzerLoop.cpp
index 273c62919e89..ce68459ba92f 100644
--- a/compiler-rt/lib/fuzzer/FuzzerLoop.cpp
+++ b/compiler-rt/lib/fuzzer/FuzzerLoop.cpp
@@ -324,6 +324,10 @@ void Fuzzer::PrintStats(const char *Where, const char *End, size_t Units,
   size_t ExecPerSec = execPerSec();
   if (!Options.Verbosity)
     return;
+  if (!Options.Entropic) {
+    return;
+  }
+  return; // hiding logs
   Printf("#%zd\t%s", TotalNumberOfRuns, Where);
   if (size_t N = TPC.GetTotalPCCoverage())
     Printf(" cov: %zd", N);
@@ -350,6 +354,7 @@ void Fuzzer::PrintStats(const char *Where, const char *End, size_t Units,
   Printf(" exec/s: %zd", ExecPerSec);
   Printf(" rss: %zdMb", GetPeakRSSMb());
   Printf("%s", End);
+
 }
 
 void Fuzzer::PrintFinalStats() {
@@ -475,6 +480,8 @@ bool Fuzzer::RunOne(const uint8_t *Data, size_t Size, bool MayDeleteFile,
   TPC.CollectFeatures([&](size_t Feature) {
     if (Corpus.AddFeature(Feature, Size, Options.Shrink))
       UniqFeatureSetTmp.push_back(Feature);
+    //if (Options.Entropic)
+      Corpus.UpdateFeatureFrequency(II, Feature);
     if (Options.ReduceInputs && II)
       if (std::binary_search(II->UniqFeatureSet.begin(),
                              II->UniqFeatureSet.end(), Feature))
@@ -484,11 +491,52 @@ bool Fuzzer::RunOne(const uint8_t *Data, size_t Size, bool MayDeleteFile,
     *FoundUniqFeatures = FoundUniqFeaturesOfII;
   PrintPulseAndReportSlowInput(Data, Size);
   size_t NumNewFeatures = Corpus.NumFeatureUpdates() - NumUpdatesBefore;
+  if (Corpus.ForkMode) {    
+    if (Corpus.ForkSuccessful) {
+      Corpus.MaxMutationsInFork = Corpus.MaxMutationsInFork>Corpus.MutationsInFork ?  Corpus.MaxMutationsInFork : Corpus.MutationsInFork;
+      Corpus.AvgMutationsInFork += Corpus.MutationsInFork; 
+      Corpus.MutationsInFork = 0;
+      Corpus.ForksCounter++;
+      Corpus.ForkSuccessful = false;
+    }
+    if(Corpus.ForksCounter >= Corpus.ForkLimit) { // reset,
+      Corpus.GlobalMaxForkMutations = Corpus.MaxMutationsInFork; // just add max fork val
+      Corpus.AvgMutationsInFork /= Corpus.ForkLimit; // average it
+      Corpus.GlobalAvgForkMutations = Corpus.AvgMutationsInFork; // just add average fork val
+      Corpus.ForksCounter = 0;
+      Corpus.SeedsCounter = 0;
+      Corpus.ForkMode = false;
+      Corpus.MaxMutationsInFork = 0;
+      Corpus.AvgMutationsInFork = 0;
+    }
+    return false;
+  }
+
   if (NumNewFeatures) {
+    if(II) {
+        Corpus.SeedsCounter++;
+        if(Corpus.SeedsCounter >= Corpus.SeedsLimit) {
+          Corpus.ForkMode = true; // start fork mode from next seed
+          Corpus.GlobalExecRate = execPerSec();
+        }
+        
+        for (auto el : Corpus.TmpSeedTrialMap) {
+          if(el.first != II->SeedID)
+            Corpus.GlobalFailsVector.push_back(el.second); // Store updated fails except current seed
+        }
+        Corpus.TrialsToSuccess = Corpus.TmpSeedTrialMap[II->SeedID];
+        Corpus.GlobalFeats = NumNewFeatures;
+        Corpus.CalcEst();
+        // II->NumOfMutationAttempts = 0; // reset the mutation attempts only for that seed
+        // Corpus.SeedTrialMap[II->SeedID] = 0; // and reset it in the map
+        Corpus.PrintCSV();
+        Corpus.TmpSeedTrialMap.clear();
+    }
     TPC.UpdateObservedPCs();
     auto NewII = Corpus.AddToCorpus({Data, Data + Size}, NumNewFeatures,
                                     MayDeleteFile, TPC.ObservedFocusFunction(),
                                     UniqFeatureSetTmp, DFT, II);
+    if (!NewII) return false;
     WriteFeatureSetToFile(Options.FeaturesDir, Sha1ToString(NewII->Sha1),
                           NewII->UniqFeatureSet);
     return true;
@@ -551,7 +599,7 @@ void Fuzzer::ExecuteCallback(const uint8_t *Data, size_t Size) {
     ScopedEnableMsanInterceptorChecks S;
     AllocTracer.Start(Options.TraceMalloc);
     UnitStartTime = system_clock::now();
-    TPC.ResetMaps();
+    TPC.ResetMaps();  
     RunningUserCallback = true;
     int Res = CB(DataCopy, Size);
     RunningUserCallback = false;
@@ -592,9 +640,12 @@ void Fuzzer::WriteUnitToFileWithPrefix(const Unit &U, const char *Prefix) {
 }
 
 void Fuzzer::PrintStatusForNewUnit(const Unit &U, const char *Text) {
+  return; // blocking this for now
   if (!Options.PrintNEW)
     return;
   PrintStats(Text, "");
+  if (!Options.Entropic)
+    return;
   if (Options.Verbosity) {
     Printf(" L: %zd/%zd ", U.size(), Corpus.MaxInputSize());
     MD.PrintMutationSequence();
@@ -674,8 +725,7 @@ void Fuzzer::MutateAndTestOne() {
 
   size_t CurrentMaxMutationLen =
       Min(MaxMutationLen, Max(U.size(), TmpMaxMutationLen));
-  assert(CurrentMaxMutationLen > 0);
-
+  assert(CurrentMaxMutationLen > 0);  
   for (int i = 0; i < Options.MutateDepth; i++) {
     if (TotalNumberOfRuns >= Options.MaxNumberOfRuns)
       break;
@@ -692,7 +742,14 @@ void Fuzzer::MutateAndTestOne() {
     assert(NewSize > 0 && "Mutator returned empty unit");
     assert(NewSize <= CurrentMaxMutationLen && "Mutator return oversized unit");
     Size = NewSize;
-    II.NumExecutedMutations++;
+    if (Corpus.ForkMode)
+      Corpus.MutationsInFork++;
+    else {
+      Corpus.TmpSeedTrialMap[II.SeedID]++;
+      // II.NumOfMutationAttempts++;
+      II.NumExecutedMutations++;
+      Corpus.IncrementNumExecutedMutations();
+    }
 
     bool FoundUniqFeatures = false;
     bool NewCov = RunOne(CurrentUnitData, Size, /*MayDeleteFile=*/true, &II,
@@ -706,6 +763,7 @@ void Fuzzer::MutateAndTestOne() {
     if (Options.ReduceDepth && !FoundUniqFeatures)
       break;
   }
+  II.NeedsEnergyUpdate = true;
 }
 
 void Fuzzer::PurgeAllocator() {
diff --git a/compiler-rt/lib/fuzzer/FuzzerOptions.h b/compiler-rt/lib/fuzzer/FuzzerOptions.h
index beecc980380b..9d975bd61fe7 100644
--- a/compiler-rt/lib/fuzzer/FuzzerOptions.h
+++ b/compiler-rt/lib/fuzzer/FuzzerOptions.h
@@ -44,6 +44,9 @@ struct FuzzingOptions {
   size_t MaxNumberOfRuns = -1L;
   int ReportSlowUnits = 10;
   bool OnlyASCII = false;
+  bool Entropic = false;
+  size_t EntropicFeatureFrequencyThreshold = 0xFF;
+  size_t EntropicNumberOfRarestFeatures = 100;
   std::string OutputCorpus;
   std::string ArtifactPrefix = "./";
   std::string ExactArtifactPath;
diff --git a/compiler-rt/lib/fuzzer/FuzzerTracePC.cpp b/compiler-rt/lib/fuzzer/FuzzerTracePC.cpp
index 86649f9e095c..451afec2e13e 100644
--- a/compiler-rt/lib/fuzzer/FuzzerTracePC.cpp
+++ b/compiler-rt/lib/fuzzer/FuzzerTracePC.cpp
@@ -180,12 +180,12 @@ void TracePC::UpdateObservedPCs() {
     }
   }
 
-  for (size_t i = 0, N = Min(CoveredFuncs.size(), NumPrintNewFuncs); i < N;
-       i++) {
-    Printf("\tNEW_FUNC[%zd/%zd]: ", i + 1, CoveredFuncs.size());
-    PrintPC("%p %F %L", "%p", GetNextInstructionPc(CoveredFuncs[i]));
-    Printf("\n");
-  }
+  //for (size_t i = 0, N = Min(CoveredFuncs.size(), NumPrintNewFuncs); i < N;
+  //     i++) {
+  //  Printf("\tNEW_FUNC[%zd/%zd]: ", i + 1, CoveredFuncs.size());
+  //  PrintPC("%p %F %L", "%p", GetNextInstructionPc(CoveredFuncs[i]));
+  //  Printf("\n");
+  //}
 }
 
 uintptr_t TracePC::PCTableEntryIdx(const PCTableEntry *TE) {
diff --git a/compiler-rt/lib/fuzzer/tests/FuzzerUnittest.cpp b/compiler-rt/lib/fuzzer/tests/FuzzerUnittest.cpp
index 7fc4b9a55b08..b480e9f0fff5 100644
--- a/compiler-rt/lib/fuzzer/tests/FuzzerUnittest.cpp
+++ b/compiler-rt/lib/fuzzer/tests/FuzzerUnittest.cpp
@@ -592,7 +592,8 @@ TEST(FuzzerUtil, Base64) {
 TEST(Corpus, Distribution) {
   DataFlowTrace DFT;
   Random Rand(0);
-  std::unique_ptr<InputCorpus> C(new InputCorpus(""));
+  struct EntropicOptions Entropic = {false, 0xFF, 100};
+  std::unique_ptr<InputCorpus> C(new InputCorpus("", Entropic));
   size_t N = 10;
   size_t TriesPerUnit = 1<<16;
   for (size_t i = 0; i < N; i++)
@@ -1050,6 +1051,68 @@ TEST(FuzzerCommand, SetOutput) {
   EXPECT_EQ(CmdLine, makeCmdLine("", ">thud 2>&1"));
 }
 
+TEST(Entropic, UpdateFrequency) {
+  const size_t One = 1, Two = 2;
+  const size_t FeatIdx1 = 0, FeatIdx2 = 42, FeatIdx3 = 12, FeatIdx4 = 26;
+  size_t Index;
+  // Create input corpus with default entropic configuration
+  struct EntropicOptions Entropic = {true, 0xFF, 100};
+  std::unique_ptr<InputCorpus> C(new InputCorpus("", Entropic));
+  InputInfo *II = new InputInfo();
+
+  C->AddRareFeature(FeatIdx1);
+  C->UpdateFeatureFrequency(II, FeatIdx1);
+  EXPECT_EQ(II->FeatureFreqs.size(), One);
+  C->AddRareFeature(FeatIdx2);
+  C->UpdateFeatureFrequency(II, FeatIdx1);
+  C->UpdateFeatureFrequency(II, FeatIdx2);
+  EXPECT_EQ(II->FeatureFreqs.size(), Two);
+  EXPECT_EQ(II->FeatureFreqs[0].second, 2);
+  EXPECT_EQ(II->FeatureFreqs[1].second, 1);
+
+  C->AddRareFeature(FeatIdx3);
+  C->AddRareFeature(FeatIdx4);
+  C->UpdateFeatureFrequency(II, FeatIdx3);
+  C->UpdateFeatureFrequency(II, FeatIdx3);
+  C->UpdateFeatureFrequency(II, FeatIdx3);
+  C->UpdateFeatureFrequency(II, FeatIdx4);
+
+  for (Index = 1; Index < II->FeatureFreqs.size(); Index++)
+    EXPECT_LT(II->FeatureFreqs[Index - 1].first, II->FeatureFreqs[Index].first);
+
+  II->DeleteFeatureFreq(FeatIdx3);
+  for (Index = 1; Index < II->FeatureFreqs.size(); Index++)
+    EXPECT_LT(II->FeatureFreqs[Index - 1].first, II->FeatureFreqs[Index].first);
+}
+
+double SubAndSquare(double X, double Y) {
+  double R = X - Y;
+  R = R * R;
+  return R;
+}
+
+TEST(Entropic, ComputeEnergy) {
+  const double Precision = 0.01;
+  struct EntropicOptions Entropic = {true, 0xFF, 100};
+  std::unique_ptr<InputCorpus> C(new InputCorpus("", Entropic));
+  InputInfo *II = new InputInfo();
+  Vector<std::pair<uint32_t, uint16_t>> FeatureFreqs = {{1, 3}, {2, 3}, {3, 3}};
+  II->FeatureFreqs = FeatureFreqs;
+  II->NumExecutedMutations = 0;
+  II->UpdateEnergy(4);
+  EXPECT_LT(SubAndSquare(II->Energy, 1.450805), Precision);
+
+  II->NumExecutedMutations = 9;
+  II->UpdateEnergy(5);
+  EXPECT_LT(SubAndSquare(II->Energy, 1.525496), Precision);
+
+  II->FeatureFreqs[0].second++;
+  II->FeatureFreqs.push_back(std::pair<uint32_t, uint16_t>(42, 6));
+  II->NumExecutedMutations = 20;
+  II->UpdateEnergy(10);
+  EXPECT_LT(SubAndSquare(II->Energy, 1.792831), Precision);
+}
+
 int main(int argc, char **argv) {
   testing::InitGoogleTest(&argc, argv);
   return RUN_ALL_TESTS();