8317535: Shenandoah: Remove unused code

Reviewed-by: rkennke, ysr

Author: William Kemper

src/hotspot/share/gc/shenandoah/c2/shenandoahBarrierSetC2.cpp

@@ -530,7 +530,7 @@ Node* ShenandoahBarrierSetC2::store_at_resolved(C2Access& access, C2AccessValue&
 Node* ShenandoahBarrierSetC2::load_at_resolved(C2Access& access, const Type* val_type) const {
   // 1: non-reference load, no additional barrier is needed
   if (!access.is_oop()) {
-    return BarrierSetC2::load_at_resolved(access, val_type);;
+    return BarrierSetC2::load_at_resolved(access, val_type);
   }
 
   Node* load = BarrierSetC2::load_at_resolved(access, val_type);

src/hotspot/share/gc/shenandoah/heuristics/shenandoahAdaptiveHeuristics.cpp

@@ -353,10 +353,6 @@ bool ShenandoahAllocationRate::is_spiking(double rate, double threshold) const {
   return false;
 }
 
-double ShenandoahAllocationRate::instantaneous_rate(size_t allocated) const {
-  return instantaneous_rate(os::elapsedTime(), allocated);
-}
-
 double ShenandoahAllocationRate::instantaneous_rate(double time, size_t allocated) const {
   size_t last_value = _last_sample_value;
   double last_time = _last_sample_time;

src/hotspot/share/gc/shenandoah/heuristics/shenandoahAdaptiveHeuristics.hpp

@@ -37,7 +37,6 @@ class ShenandoahAllocationRate : public CHeapObj<mtGC> {
 
   double sample(size_t allocated);
 
-  double instantaneous_rate(size_t allocated) const;
   double upper_bound(double sds) const;
   bool is_spiking(double rate, double threshold) const;
 

src/hotspot/share/gc/shenandoah/shenandoahClosures.inline.hpp

@@ -220,4 +220,4 @@ void ShenandoahAssertNotForwardedClosure::do_oop(narrowOop* p) { do_oop_work(p);
 void ShenandoahAssertNotForwardedClosure::do_oop(oop* p)       { do_oop_work(p); }
 #endif
 
-#endif // SHARE_GC_SHENANDOAH_SHENANDOAHCLOSURES_HPP
+#endif // SHARE_GC_SHENANDOAH_SHENANDOAHCLOSURES_INLINE_HPP

src/hotspot/share/gc/shenandoah/shenandoahCodeRoots.cpp

@@ -36,70 +36,6 @@
 #include "runtime/atomic.hpp"
 #include "utilities/powerOfTwo.hpp"
 
-ShenandoahParallelCodeCacheIterator::ShenandoahParallelCodeCacheIterator(const GrowableArray<CodeHeap*>* heaps) {
-  _length = heaps->length();
-  _iters = NEW_C_HEAP_ARRAY(ShenandoahParallelCodeHeapIterator, _length, mtGC);
-  for (int h = 0; h < _length; h++) {
-    _iters[h] = ShenandoahParallelCodeHeapIterator(heaps->at(h));
-  }
-}
-
-ShenandoahParallelCodeCacheIterator::~ShenandoahParallelCodeCacheIterator() {
-  FREE_C_HEAP_ARRAY(ParallelCodeHeapIterator, _iters);
-}
-
-void ShenandoahParallelCodeCacheIterator::parallel_blobs_do(CodeBlobClosure* f) {
-  for (int c = 0; c < _length; c++) {
-    _iters[c].parallel_blobs_do(f);
-  }
-}
-
-ShenandoahParallelCodeHeapIterator::ShenandoahParallelCodeHeapIterator(CodeHeap* heap) :
-        _heap(heap), _claimed_idx(0), _finished(false) {
-}
-
-void ShenandoahParallelCodeHeapIterator::parallel_blobs_do(CodeBlobClosure* f) {
-  assert(SafepointSynchronize::is_at_safepoint(), "Must be at safepoint");
-
-  /*
-   * Parallel code heap walk.
-   *
-   * This code makes all threads scan all code heaps, but only one thread would execute the
-   * closure on given blob. This is achieved by recording the "claimed" blocks: if a thread
-   * had claimed the block, it can process all blobs in it. Others have to fast-forward to
-   * next attempt without processing.
-   *
-   * Late threads would return immediately if iterator is finished.
-   */
-
-  if (_finished) {
-    return;
-  }
-
-  int stride = 256; // educated guess
-  int stride_mask = stride - 1;
-  assert (is_power_of_2(stride), "sanity");
-
-  int count = 0;
-  bool process_block = true;
-
-  for (CodeBlob *cb = CodeCache::first_blob(_heap); cb != nullptr; cb = CodeCache::next_blob(_heap, cb)) {
-    int current = count++;
-    if ((current & stride_mask) == 0) {
-      process_block = (current >= _claimed_idx) &&
-                      (Atomic::cmpxchg(&_claimed_idx, current, current + stride, memory_order_relaxed) == current);
-    }
-    if (process_block) {
-      f->do_code_blob(cb);
-#ifdef ASSERT
-      if (cb->is_nmethod())
-        Universe::heap()->verify_nmethod((nmethod*)cb);
-#endif
-    }
-  }
-
-  _finished = true;
-}
 
 ShenandoahNMethodTable* ShenandoahCodeRoots::_nmethod_table;
 int ShenandoahCodeRoots::_disarmed_value = 1;
@@ -303,7 +239,6 @@ void ShenandoahCodeRoots::purge() {
 }
 
 ShenandoahCodeRootsIterator::ShenandoahCodeRootsIterator() :
-        _par_iterator(CodeCache::heaps()),
         _table_snapshot(nullptr) {
   assert(SafepointSynchronize::is_at_safepoint(), "Must be at safepoint");
   MutexLocker locker(CodeCache_lock, Mutex::_no_safepoint_check_flag);

src/hotspot/share/gc/shenandoah/shenandoahCodeRoots.hpp

@@ -39,38 +39,9 @@ class ShenandoahNMethodTable;
 class ShenandoahNMethodTableSnapshot;
 class WorkerThreads;
 
-class ShenandoahParallelCodeHeapIterator {
-  friend class CodeCache;
-private:
-  CodeHeap*     _heap;
-  shenandoah_padding(0);
-  volatile int  _claimed_idx;
-  volatile bool _finished;
-  shenandoah_padding(1);
-public:
-  ShenandoahParallelCodeHeapIterator(CodeHeap* heap);
-  void parallel_blobs_do(CodeBlobClosure* f);
-};
-
-class ShenandoahParallelCodeCacheIterator {
-  friend class CodeCache;
-private:
-  ShenandoahParallelCodeHeapIterator* _iters;
-  int                       _length;
-
-  NONCOPYABLE(ShenandoahParallelCodeCacheIterator);
-
-public:
-  ShenandoahParallelCodeCacheIterator(const GrowableArray<CodeHeap*>* heaps);
-  ~ShenandoahParallelCodeCacheIterator();
-  void parallel_blobs_do(CodeBlobClosure* f);
-};
-
 class ShenandoahCodeRootsIterator {
   friend class ShenandoahCodeRoots;
 protected:
-  ShenandoahParallelCodeCacheIterator _par_iterator;
-  ShenandoahSharedFlag _seq_claimed;
   ShenandoahNMethodTableSnapshot* _table_snapshot;
 
 public:
@@ -88,7 +59,6 @@ class ShenandoahCodeRoots : public AllStatic {
   static void initialize();
   static void register_nmethod(nmethod* nm);
   static void unregister_nmethod(nmethod* nm);
-  static void flush_nmethod(nmethod* nm);
 
   static ShenandoahNMethodTable* table() {
     return _nmethod_table;

src/hotspot/share/gc/shenandoah/shenandoahConcurrentMark.cpp

@@ -58,7 +58,6 @@ class ShenandoahConcurrentMarkingTask : public WorkerTask {
     ShenandoahHeap* heap = ShenandoahHeap::heap();
     ShenandoahConcurrentWorkerSession worker_session(worker_id);
     ShenandoahSuspendibleThreadSetJoiner stsj(ShenandoahSuspendibleWorkers);
-    ShenandoahObjToScanQueue* q = _cm->get_queue(worker_id);
     ShenandoahReferenceProcessor* rp = heap->ref_processor();
     assert(rp != nullptr, "need reference processor");
     StringDedup::Requests requests;

src/hotspot/share/gc/shenandoah/shenandoahFreeSet.cpp

@@ -279,7 +279,7 @@ HeapWord* ShenandoahFreeSet::allocate_contiguous(ShenandoahAllocRequest& req) {
     }
 
     end++;
-  };
+  }
 
   size_t remainder = words_size & ShenandoahHeapRegion::region_size_words_mask();
 

src/hotspot/share/gc/shenandoah/shenandoahGC.cpp

@@ -66,7 +66,6 @@ class ShenandoahUpdateRootsTask : public WorkerTask {
     assert(ShenandoahSafepoint::is_at_shenandoah_safepoint(), "Must be at a safepoint");
     ShenandoahParallelWorkerSession worker_session(worker_id);
 
-    ShenandoahHeap* heap = ShenandoahHeap::heap();
     ShenandoahUpdateRefsClosure cl;
     if (_check_alive) {
       ShenandoahForwardedIsAliveClosure is_alive;

src/hotspot/share/gc/shenandoah/shenandoahHeap.cpp

@@ -1893,14 +1893,6 @@ address ShenandoahHeap::in_cset_fast_test_addr() {
   return (address) heap->collection_set()->biased_map_address();
 }
 
-address ShenandoahHeap::cancelled_gc_addr() {
-  return (address) ShenandoahHeap::heap()->_cancelled_gc.addr_of();
-}
-
-address ShenandoahHeap::gc_state_addr() {
-  return (address) ShenandoahHeap::heap()->_gc_state.addr_of();
-}
-
 size_t ShenandoahHeap::bytes_allocated_since_gc_start() const {
   return Atomic::load(&_bytes_allocated_since_gc_start);
 }