diff a/src/hotspot/share/gc/shenandoah/heuristics/shenandoahGenerationalHeuristics.cpp b/src/hotspot/share/gc/shenandoah/heuristics/shenandoahGenerationalHeuristics.cpp
--- /dev/null
+++ b/src/hotspot/share/gc/shenandoah/heuristics/shenandoahGenerationalHeuristics.cpp
@@ -0,0 +1,290 @@
+/*
+ * Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ *
+ */
+
+#include "precompiled.hpp"
+
+#include "gc/shenandoah/heuristics/shenandoahGenerationalHeuristics.hpp"
+#include "gc/shenandoah/shenandoahCollectionSet.hpp"
+#include "gc/shenandoah/shenandoahCollectorPolicy.hpp"
+#include "gc/shenandoah/shenandoahGeneration.hpp"
+#include "gc/shenandoah/shenandoahGenerationalHeap.hpp"
+#include "gc/shenandoah/shenandoahHeapRegion.inline.hpp"
+#include "gc/shenandoah/shenandoahOldGeneration.hpp"
+#include "gc/shenandoah/shenandoahEvacInfo.hpp"
+#include "gc/shenandoah/shenandoahTrace.hpp"
+
+#include "logging/log.hpp"
+
+ShenandoahGenerationalHeuristics::ShenandoahGenerationalHeuristics(ShenandoahGeneration* generation)
+        : ShenandoahAdaptiveHeuristics(generation), _generation(generation) {
+}
+
+void ShenandoahGenerationalHeuristics::choose_collection_set(ShenandoahCollectionSet* collection_set) {
+  assert(collection_set->is_empty(), "Must be empty");
+
+  auto heap = ShenandoahGenerationalHeap::heap();
+  size_t region_size_bytes = ShenandoahHeapRegion::region_size_bytes();
+
+
+  // Check all pinned regions have updated status before choosing the collection set.
+  heap->assert_pinned_region_status();
+
+  // Step 1. Build up the region candidates we care about, rejecting losers and accepting winners right away.
+
+  size_t num_regions = heap->num_regions();
+
+  RegionData* candidates = _region_data;
+
+  size_t cand_idx = 0;
+  size_t preselected_candidates = 0;
+
+  size_t total_garbage = 0;
+
+  size_t immediate_garbage = 0;
+  size_t immediate_regions = 0;
+
+  size_t free = 0;
+  size_t free_regions = 0;
+
+  const uint tenuring_threshold = heap->age_census()->tenuring_threshold();
+
+  // This counts number of humongous regions that we intend to promote in this cycle.
+  size_t humongous_regions_promoted = 0;
+  // This counts number of regular regions that will be promoted in place.
+  size_t regular_regions_promoted_in_place = 0;
+  // This counts bytes of memory used by regular regions to be promoted in place.
+  size_t regular_regions_promoted_usage = 0;
+  // This counts bytes of memory free in regular regions to be promoted in place.
+  size_t regular_regions_promoted_free = 0;
+  // This counts bytes of garbage memory in regular regions to be promoted in place.
+  size_t regular_regions_promoted_garbage = 0;
+
+  for (size_t i = 0; i < num_regions; i++) {
+    ShenandoahHeapRegion* region = heap->get_region(i);
+    if (!_generation->contains(region)) {
+      continue;
+    }
+    size_t garbage = region->garbage();
+    total_garbage += garbage;
+    if (region->is_empty()) {
+      free_regions++;
+      free += region_size_bytes;
+    } else if (region->is_regular()) {
+      if (!region->has_live()) {
+        // We can recycle it right away and put it in the free set.
+        immediate_regions++;
+        immediate_garbage += garbage;
+        region->make_trash_immediate();
+      } else {
+        bool is_candidate;
+        // This is our candidate for later consideration.
+        if (collection_set->is_preselected(i)) {
+          assert(region->age() >= tenuring_threshold, "Preselection filter");
+          is_candidate = true;
+          preselected_candidates++;
+          // Set garbage value to maximum value to force this into the sorted collection set.
+          garbage = region_size_bytes;
+        } else if (region->is_young() && (region->age() >= tenuring_threshold)) {
+          // Note that for GLOBAL GC, region may be OLD, and OLD regions do not qualify for pre-selection
+
+          // This region is old enough to be promoted but it was not preselected, either because its garbage is below
+          // ShenandoahOldGarbageThreshold so it will be promoted in place, or because there is not sufficient room
+          // in old gen to hold the evacuated copies of this region's live data.  In both cases, we choose not to
+          // place this region into the collection set.
+          if (region->get_top_before_promote() != nullptr) {
+            // Region was included for promotion-in-place
+            regular_regions_promoted_in_place++;
+            regular_regions_promoted_usage += region->used_before_promote();
+            regular_regions_promoted_free += region->free();
+            regular_regions_promoted_garbage += region->garbage();
+          }
+          is_candidate = false;
+        } else {
+          is_candidate = true;
+        }
+        if (is_candidate) {
+          candidates[cand_idx].set_region_and_garbage(region, garbage);
+          cand_idx++;
+        }
+      }
+    } else if (region->is_humongous_start()) {
+      // Reclaim humongous regions here, and count them as the immediate garbage
+#ifdef ASSERT
+      bool reg_live = region->has_live();
+      bool bm_live = heap->complete_marking_context()->is_marked(cast_to_oop(region->bottom()));
+      assert(reg_live == bm_live,
+             "Humongous liveness and marks should agree. Region live: %s; Bitmap live: %s; Region Live Words: " SIZE_FORMAT,
+             BOOL_TO_STR(reg_live), BOOL_TO_STR(bm_live), region->get_live_data_words());
+#endif
+      if (!region->has_live()) {
+        heap->trash_humongous_region_at(region);
+
+        // Count only the start. Continuations would be counted on "trash" path
+        immediate_regions++;
+        immediate_garbage += garbage;
+      } else {
+        if (region->is_young() && region->age() >= tenuring_threshold) {
+          oop obj = cast_to_oop(region->bottom());
+          size_t humongous_regions = ShenandoahHeapRegion::required_regions(obj->size() * HeapWordSize);
+          humongous_regions_promoted += humongous_regions;
+        }
+      }
+    } else if (region->is_trash()) {
+      // Count in just trashed collection set, during coalesced CM-with-UR
+      immediate_regions++;
+      immediate_garbage += garbage;
+    }
+  }
+  heap->old_generation()->set_expected_humongous_region_promotions(humongous_regions_promoted);
+  heap->old_generation()->set_expected_regular_region_promotions(regular_regions_promoted_in_place);
+  log_info(gc, ergo)("Planning to promote in place " SIZE_FORMAT " humongous regions and " SIZE_FORMAT
+                     " regular regions, spanning a total of " SIZE_FORMAT " used bytes",
+                     humongous_regions_promoted, regular_regions_promoted_in_place,
+                     humongous_regions_promoted * ShenandoahHeapRegion::region_size_bytes() +
+                     regular_regions_promoted_usage);
+
+  // Step 2. Look back at garbage statistics, and decide if we want to collect anything,
+  // given the amount of immediately reclaimable garbage. If we do, figure out the collection set.
+
+  assert (immediate_garbage <= total_garbage,
+          "Cannot have more immediate garbage than total garbage: " SIZE_FORMAT "%s vs " SIZE_FORMAT "%s",
+          byte_size_in_proper_unit(immediate_garbage), proper_unit_for_byte_size(immediate_garbage),
+          byte_size_in_proper_unit(total_garbage), proper_unit_for_byte_size(total_garbage));
+
+  size_t immediate_percent = (total_garbage == 0) ? 0 : (immediate_garbage * 100 / total_garbage);
+
+  bool doing_promote_in_place = (humongous_regions_promoted + regular_regions_promoted_in_place > 0);
+  if (doing_promote_in_place || (preselected_candidates > 0) || (immediate_percent <= ShenandoahImmediateThreshold)) {
+    // Only young collections need to prime the collection set.
+    if (_generation->is_young()) {
+      heap->old_generation()->heuristics()->prime_collection_set(collection_set);
+    }
+
+    // Call the subclasses to add young-gen regions into the collection set.
+    choose_collection_set_from_regiondata(collection_set, candidates, cand_idx, immediate_garbage + free);
+  }
+
+  if (collection_set->has_old_regions()) {
+    heap->shenandoah_policy()->record_mixed_cycle();
+  }
+
+  size_t cset_percent = (total_garbage == 0) ? 0 : (collection_set->garbage() * 100 / total_garbage);
+  size_t collectable_garbage = collection_set->garbage() + immediate_garbage;
+  size_t collectable_garbage_percent = (total_garbage == 0) ? 0 : (collectable_garbage * 100 / total_garbage);
+
+  log_info(gc, ergo)("Collectable Garbage: " SIZE_FORMAT "%s (" SIZE_FORMAT "%%), "
+                     "Immediate: " SIZE_FORMAT "%s (" SIZE_FORMAT "%%), " SIZE_FORMAT " regions, "
+                     "CSet: " SIZE_FORMAT "%s (" SIZE_FORMAT "%%), " SIZE_FORMAT " regions",
+
+                     byte_size_in_proper_unit(collectable_garbage),
+                     proper_unit_for_byte_size(collectable_garbage),
+                     collectable_garbage_percent,
+
+                     byte_size_in_proper_unit(immediate_garbage),
+                     proper_unit_for_byte_size(immediate_garbage),
+                     immediate_percent,
+                     immediate_regions,
+
+                     byte_size_in_proper_unit(collection_set->garbage()),
+                     proper_unit_for_byte_size(collection_set->garbage()),
+                     cset_percent,
+                     collection_set->count());
+
+  if (collection_set->garbage() > 0) {
+    size_t young_evac_bytes = collection_set->get_young_bytes_reserved_for_evacuation();
+    size_t promote_evac_bytes = collection_set->get_young_bytes_to_be_promoted();
+    size_t old_evac_bytes = collection_set->get_old_bytes_reserved_for_evacuation();
+    size_t total_evac_bytes = young_evac_bytes + promote_evac_bytes + old_evac_bytes;
+    log_info(gc, ergo)("Evacuation Targets: YOUNG: " SIZE_FORMAT "%s, "
+                       "PROMOTE: " SIZE_FORMAT "%s, "
+                       "OLD: " SIZE_FORMAT "%s, "
+                       "TOTAL: " SIZE_FORMAT "%s",
+                       byte_size_in_proper_unit(young_evac_bytes), proper_unit_for_byte_size(young_evac_bytes),
+                       byte_size_in_proper_unit(promote_evac_bytes), proper_unit_for_byte_size(promote_evac_bytes),
+                       byte_size_in_proper_unit(old_evac_bytes), proper_unit_for_byte_size(old_evac_bytes),
+                       byte_size_in_proper_unit(total_evac_bytes), proper_unit_for_byte_size(total_evac_bytes));
+
+    ShenandoahEvacInfo evacInfo;
+    evacInfo.set_collection_set_regions(collection_set->count());
+    evacInfo.set_collection_set_used_before(collection_set->used());
+    evacInfo.set_collection_set_used_after(collection_set->live());
+    evacInfo.set_collected_old(old_evac_bytes);
+    evacInfo.set_collected_promoted(promote_evac_bytes);
+    evacInfo.set_collected_young(young_evac_bytes);
+    evacInfo.set_regions_promoted_humongous(humongous_regions_promoted);
+    evacInfo.set_regions_promoted_regular(regular_regions_promoted_in_place);
+    evacInfo.set_regular_promoted_garbage(regular_regions_promoted_garbage);
+    evacInfo.set_regular_promoted_free(regular_regions_promoted_free);
+    evacInfo.set_regions_immediate(immediate_regions);
+    evacInfo.set_immediate_size(immediate_garbage);
+    evacInfo.set_regions_freed(free_regions);
+
+    ShenandoahTracer().report_evacuation_info(&evacInfo);
+  }
+}
+
+
+size_t ShenandoahGenerationalHeuristics::add_preselected_regions_to_collection_set(ShenandoahCollectionSet* cset,
+                                                                                   const RegionData* data,
+                                                                                   size_t size) const {
+#ifdef ASSERT
+  const uint tenuring_threshold = ShenandoahGenerationalHeap::heap()->age_census()->tenuring_threshold();
+#endif
+
+  // cur_young_garbage represents the amount of memory to be reclaimed from young-gen.  In the case that live objects
+  // are known to be promoted out of young-gen, we count this as cur_young_garbage because this memory is reclaimed
+  // from young-gen and becomes available to serve future young-gen allocation requests.
+  size_t cur_young_garbage = 0;
+  for (size_t idx = 0; idx < size; idx++) {
+    ShenandoahHeapRegion* r = data[idx].get_region();
+    if (cset->is_preselected(r->index())) {
+      assert(r->age() >= tenuring_threshold, "Preselected regions must have tenure age");
+      // Entire region will be promoted, This region does not impact young-gen or old-gen evacuation reserve.
+      // This region has been pre-selected and its impact on promotion reserve is already accounted for.
+
+      // r->used() is r->garbage() + r->get_live_data_bytes()
+      // Since all live data in this region is being evacuated from young-gen, it is as if this memory
+      // is garbage insofar as young-gen is concerned.  Counting this as garbage reduces the need to
+      // reclaim highly utilized young-gen regions just for the sake of finding min_garbage to reclaim
+      // within young-gen memory.
+
+      cur_young_garbage += r->garbage();
+      cset->add_region(r);
+    }
+  }
+  return cur_young_garbage;
+}
+
+void ShenandoahGenerationalHeuristics::log_cset_composition(ShenandoahCollectionSet* cset) const {
+  size_t collected_old = cset->get_old_bytes_reserved_for_evacuation();
+  size_t collected_promoted = cset->get_young_bytes_to_be_promoted();
+  size_t collected_young = cset->get_young_bytes_reserved_for_evacuation();
+
+  log_info(gc, ergo)(
+          "Chosen CSet evacuates young: " SIZE_FORMAT "%s (of which at least: " SIZE_FORMAT "%s are to be promoted), "
+          "old: " SIZE_FORMAT "%s",
+          byte_size_in_proper_unit(collected_young), proper_unit_for_byte_size(collected_young),
+          byte_size_in_proper_unit(collected_promoted), proper_unit_for_byte_size(collected_promoted),
+          byte_size_in_proper_unit(collected_old), proper_unit_for_byte_size(collected_old));
+}
