--- old/src/hotspot/share/gc/shenandoah/shenandoahConcurrentMark.cpp	2018-07-17 22:23:35.107515144 +0200
+++ new/src/hotspot/share/gc/shenandoah/shenandoahConcurrentMark.cpp	2018-07-17 22:23:34.917518443 +0200
@@ -54,15 +54,17 @@
 private:
   ShenandoahObjToScanQueue* _queue;
   ShenandoahHeap* _heap;
+  ShenandoahMarkingContext* const _mark_context;
 
   template <class T>
   inline void do_oop_work(T* p) {
-    ShenandoahConcurrentMark::mark_through_ref<T, UPDATE_REFS, false /* string dedup */>(p, _heap, _queue);
+    ShenandoahConcurrentMark::mark_through_ref<T, UPDATE_REFS, false /* string dedup */>(p, _heap, _queue, _mark_context);
   }
 
 public:
   ShenandoahInitMarkRootsClosure(ShenandoahObjToScanQueue* q) :
-    _queue(q), _heap(ShenandoahHeap::heap()) {};
+    _queue(q), _heap(ShenandoahHeap::heap()),
+    _mark_context(_heap->next_marking_context()) {};
 
   void do_oop(narrowOop* p) { do_oop_work(p); }
   void do_oop(oop* p)       { do_oop_work(p); }
@@ -71,7 +73,8 @@
 ShenandoahMarkRefsSuperClosure::ShenandoahMarkRefsSuperClosure(ShenandoahObjToScanQueue* q, ReferenceProcessor* rp) :
   MetadataVisitingOopIterateClosure(rp),
   _queue(q),
-  _heap(ShenandoahHeap::heap())
+  _heap(ShenandoahHeap::heap()),
+  _mark_context(_heap->next_marking_context())
 { }
 
 
@@ -545,15 +548,17 @@
 private:
   ShenandoahObjToScanQueue* _queue;
   ShenandoahHeap* _heap;
+  ShenandoahMarkingContext* const _mark_context;
 
   template <class T>
   inline void do_oop_work(T* p) {
-    ShenandoahConcurrentMark::mark_through_ref<T, NONE, false /* string dedup */>(p, _heap, _queue);
+    ShenandoahConcurrentMark::mark_through_ref<T, NONE, false /* string dedup */>(p, _heap, _queue, _mark_context);
   }
 
 public:
   ShenandoahCMKeepAliveClosure(ShenandoahObjToScanQueue* q) :
-    _queue(q), _heap(ShenandoahHeap::heap()) {}
+    _queue(q), _heap(ShenandoahHeap::heap()),
+    _mark_context(_heap->next_marking_context()) {}
 
   void do_oop(narrowOop* p) { do_oop_work(p); }
   void do_oop(oop* p)       { do_oop_work(p); }
@@ -563,15 +568,17 @@
 private:
   ShenandoahObjToScanQueue* _queue;
   ShenandoahHeap* _heap;
+  ShenandoahMarkingContext* const _mark_context;
 
   template <class T>
   inline void do_oop_work(T* p) {
-    ShenandoahConcurrentMark::mark_through_ref<T, SIMPLE, false /* string dedup */>(p, _heap, _queue);
+    ShenandoahConcurrentMark::mark_through_ref<T, SIMPLE, false /* string dedup */>(p, _heap, _queue, _mark_context);
   }
 
 public:
   ShenandoahCMKeepAliveUpdateClosure(ShenandoahObjToScanQueue* q) :
-    _queue(q), _heap(ShenandoahHeap::heap()) {}
+    _queue(q), _heap(ShenandoahHeap::heap()),
+    _mark_context(_heap->next_marking_context()) {}
 
   void do_oop(narrowOop* p) { do_oop_work(p); }
   void do_oop(oop* p)       { do_oop_work(p); }
@@ -767,15 +774,17 @@
 private:
   ShenandoahObjToScanQueue* _queue;
   ShenandoahHeap* _heap;
+  ShenandoahMarkingContext* const _mark_context;
 
   template <class T>
   inline void do_oop_work(T* p) {
-    ShenandoahConcurrentMark::mark_through_ref<T, CONCURRENT, false /* string dedup */>(p, _heap, _queue);
+    ShenandoahConcurrentMark::mark_through_ref<T, CONCURRENT, false /* string dedup */>(p, _heap, _queue, _mark_context);
   }
 
 public:
   ShenandoahPrecleanKeepAliveUpdateClosure(ShenandoahObjToScanQueue* q) :
-    _queue(q), _heap(ShenandoahHeap::heap()) {}
+    _queue(q), _heap(ShenandoahHeap::heap()),
+    _mark_context(_heap->next_marking_context()) {}
 
   void do_oop(narrowOop* p) { do_oop_work(p); }
   void do_oop(oop* p)       { do_oop_work(p); }
--- old/src/hotspot/share/gc/shenandoah/shenandoahConcurrentMark.hpp	2018-07-17 22:23:35.815502850 +0200
+++ new/src/hotspot/share/gc/shenandoah/shenandoahConcurrentMark.hpp	2018-07-17 22:23:35.626506132 +0200
@@ -96,10 +96,10 @@
   void clear_claim_codecache();
 
   template<class T, UpdateRefsMode UPDATE_REFS>
-  static inline void mark_through_ref(T* p, ShenandoahHeap* heap, ShenandoahObjToScanQueue* q);
+  static inline void mark_through_ref(T* p, ShenandoahHeap* heap, ShenandoahObjToScanQueue* q, ShenandoahMarkingContext* const mark_context);
 
   template<class T, UpdateRefsMode UPDATE_REFS, bool STRING_DEDUP>
-  static inline void mark_through_ref(T* p, ShenandoahHeap* heap, ShenandoahObjToScanQueue* q);
+  static inline void mark_through_ref(T* p, ShenandoahHeap* heap, ShenandoahObjToScanQueue* q, ShenandoahMarkingContext* const mark_context);
 
   void mark_from_roots();
 
--- old/src/hotspot/share/gc/shenandoah/shenandoahConcurrentMark.inline.hpp	2018-07-17 22:23:36.503490902 +0200
+++ new/src/hotspot/share/gc/shenandoah/shenandoahConcurrentMark.inline.hpp	2018-07-17 22:23:36.311494237 +0200
@@ -209,9 +209,11 @@
 private:
   ShenandoahObjToScanQueue* _queue;
   ShenandoahHeap* _heap;
+  ShenandoahMarkingContext* const _mark_context;
 public:
   ShenandoahSATBBufferClosure(ShenandoahObjToScanQueue* q) :
-    _queue(q), _heap(ShenandoahHeap::heap())
+    _queue(q), _heap(ShenandoahHeap::heap()),
+    _mark_context(_heap->next_marking_context())
   {
   }
 
@@ -227,18 +229,18 @@
   void do_buffer_impl(void **buffer, size_t size) {
     for (size_t i = 0; i < size; ++i) {
       oop *p = (oop *) &buffer[i];
-      ShenandoahConcurrentMark::mark_through_ref<oop, UPDATE_REFS>(p, _heap, _queue);
+      ShenandoahConcurrentMark::mark_through_ref<oop, UPDATE_REFS>(p, _heap, _queue, _mark_context);
     }
   }
 };
 
 template<class T, UpdateRefsMode UPDATE_REFS>
-inline void ShenandoahConcurrentMark::mark_through_ref(T *p, ShenandoahHeap* heap, ShenandoahObjToScanQueue* q) {
-  ShenandoahConcurrentMark::mark_through_ref<T, UPDATE_REFS, false /* string dedup */>(p, heap, q);
+inline void ShenandoahConcurrentMark::mark_through_ref(T *p, ShenandoahHeap* heap, ShenandoahObjToScanQueue* q, ShenandoahMarkingContext* const mark_context) {
+  ShenandoahConcurrentMark::mark_through_ref<T, UPDATE_REFS, false /* string dedup */>(p, heap, q, mark_context);
 }
 
 template<class T, UpdateRefsMode UPDATE_REFS, bool STRING_DEDUP>
-inline void ShenandoahConcurrentMark::mark_through_ref(T *p, ShenandoahHeap* heap, ShenandoahObjToScanQueue* q) {
+inline void ShenandoahConcurrentMark::mark_through_ref(T *p, ShenandoahHeap* heap, ShenandoahObjToScanQueue* q, ShenandoahMarkingContext* const mark_context) {
   T o = RawAccess<>::oop_load(p);
   if (!CompressedOops::is_null(o)) {
     oop obj = CompressedOops::decode_not_null(o);
@@ -266,7 +268,7 @@
       shenandoah_assert_not_forwarded(p, obj);
       shenandoah_assert_not_in_cset_except(p, obj, heap->cancelled_gc());
 
-      if (heap->next_marking_context()->mark(obj)) {
+      if (mark_context->mark(obj)) {
         bool pushed = q->push(ShenandoahMarkTask(obj));
         assert(pushed, "overflow queue should always succeed pushing");
 
--- old/src/hotspot/share/gc/shenandoah/shenandoahOopClosures.hpp	2018-07-17 22:23:37.187479025 +0200
+++ new/src/hotspot/share/gc/shenandoah/shenandoahOopClosures.hpp	2018-07-17 22:23:36.997482324 +0200
@@ -40,6 +40,7 @@
 private:
   ShenandoahObjToScanQueue* _queue;
   ShenandoahHeap* _heap;
+  ShenandoahMarkingContext* const _mark_context;
 
 protected:
   template <class T, UpdateRefsMode UPDATE_MODE, bool STRING_DEDUP>
@@ -229,12 +230,15 @@
   ShenandoahTraversalGC* const _traversal_gc;
   Thread* const _thread;
   ShenandoahObjToScanQueue* const _queue;
+  ShenandoahMarkingContext* const _mark_context;
   oop _base_obj;
 protected:
   ShenandoahTraversalSuperClosure(ShenandoahObjToScanQueue* q, ReferenceProcessor* rp) :
     MetadataVisitingOopIterateClosure(rp),
     _traversal_gc(ShenandoahHeap::heap()->traversal_gc()),
-    _thread(Thread::current()), _queue(q), _base_obj(NULL) {
+    _thread(Thread::current()), _queue(q),
+    _mark_context(ShenandoahHeap::heap()->next_marking_context()),
+    _base_obj(NULL) {
   }
 
   template <class T, bool STRING_DEDUP, bool DEGEN, bool MATRIX>
--- old/src/hotspot/share/gc/shenandoah/shenandoahOopClosures.inline.hpp	2018-07-17 22:23:37.877467043 +0200
+++ new/src/hotspot/share/gc/shenandoah/shenandoahOopClosures.inline.hpp	2018-07-17 22:23:37.692470256 +0200
@@ -30,7 +30,7 @@
 
 template<class T, UpdateRefsMode UPDATE_REFS, bool STRING_DEDUP>
 inline void ShenandoahMarkRefsSuperClosure::work(T *p) {
-  ShenandoahConcurrentMark::mark_through_ref<T, UPDATE_REFS, STRING_DEDUP>(p, _heap, _queue);
+  ShenandoahConcurrentMark::mark_through_ref<T, UPDATE_REFS, STRING_DEDUP>(p, _heap, _queue, _mark_context);
 }
 
 template <class T, bool UPDATE_MATRIX>
@@ -45,7 +45,7 @@
 
 template <class T, bool STRING_DEDUP, bool DEGEN, bool MATRIX>
 inline void ShenandoahTraversalSuperClosure::work(T* p) {
-  _traversal_gc->process_oop<T, STRING_DEDUP, DEGEN, MATRIX>(p, _thread, _queue, _base_obj);
+  _traversal_gc->process_oop<T, STRING_DEDUP, DEGEN, MATRIX>(p, _thread, _queue, _mark_context, _base_obj);
 }
 
 #endif // SHARE_VM_GC_SHENANDOAH_SHENANDOAHOOPCLOSURES_INLINE_HPP
--- old/src/hotspot/share/gc/shenandoah/shenandoahTraversalGC.cpp	2018-07-17 22:23:38.582454801 +0200
+++ new/src/hotspot/share/gc/shenandoah/shenandoahTraversalGC.cpp	2018-07-17 22:23:38.395458048 +0200
@@ -839,15 +839,18 @@
   ShenandoahObjToScanQueue* _queue;
   Thread* _thread;
   ShenandoahTraversalGC* _traversal_gc;
+  ShenandoahMarkingContext* const _mark_context;
+
   template <class T>
   inline void do_oop_work(T* p) {
-    _traversal_gc->process_oop<T, false /* string dedup */, false /* degen */, false /* matrix */>(p, _thread, _queue, NULL);
+    _traversal_gc->process_oop<T, false /* string dedup */, false /* degen */, false /* matrix */>(p, _thread, _queue, _mark_context, NULL);
   }
 
 public:
   ShenandoahTraversalKeepAliveUpdateClosure(ShenandoahObjToScanQueue* q) :
     _queue(q), _thread(Thread::current()),
-    _traversal_gc(ShenandoahHeap::heap()->traversal_gc()) {}
+    _traversal_gc(ShenandoahHeap::heap()->traversal_gc()),
+    _mark_context(ShenandoahHeap::heap()->next_marking_context()) {}
 
   void do_oop(narrowOop* p) { do_oop_work(p); }
   void do_oop(oop* p)       { do_oop_work(p); }
@@ -858,15 +861,18 @@
   ShenandoahObjToScanQueue* _queue;
   Thread* _thread;
   ShenandoahTraversalGC* _traversal_gc;
+  ShenandoahMarkingContext* const _mark_context;
+
   template <class T>
   inline void do_oop_work(T* p) {
-    _traversal_gc->process_oop<T, false /* string dedup */, true /* degen */, false /* matrix */>(p, _thread, _queue, NULL);
+    _traversal_gc->process_oop<T, false /* string dedup */, true /* degen */, false /* matrix */>(p, _thread, _queue, _mark_context, NULL);
   }
 
 public:
   ShenandoahTraversalKeepAliveUpdateDegenClosure(ShenandoahObjToScanQueue* q) :
     _queue(q), _thread(Thread::current()),
-    _traversal_gc(ShenandoahHeap::heap()->traversal_gc()) {}
+    _traversal_gc(ShenandoahHeap::heap()->traversal_gc()),
+    _mark_context(ShenandoahHeap::heap()->next_marking_context()) {}
 
   void do_oop(narrowOop* p) { do_oop_work(p); }
   void do_oop(oop* p)       { do_oop_work(p); }
@@ -877,16 +883,19 @@
   ShenandoahObjToScanQueue* _queue;
   Thread* _thread;
   ShenandoahTraversalGC* _traversal_gc;
+  ShenandoahMarkingContext* const _mark_context;
+
   template <class T>
   inline void do_oop_work(T* p) {
     // TODO: Need to somehow pass base_obj here?
-    _traversal_gc->process_oop<T, false /* string dedup */, false /* degen */, true /* matrix */>(p, _thread, _queue, NULL);
+    _traversal_gc->process_oop<T, false /* string dedup */, false /* degen */, true /* matrix */>(p, _thread, _queue, _mark_context, NULL);
   }
 
 public:
   ShenandoahTraversalKeepAliveUpdateMatrixClosure(ShenandoahObjToScanQueue* q) :
     _queue(q), _thread(Thread::current()),
-    _traversal_gc(ShenandoahHeap::heap()->traversal_gc()) {}
+    _traversal_gc(ShenandoahHeap::heap()->traversal_gc()),
+    _mark_context(ShenandoahHeap::heap()->next_marking_context()) {}
 
   void do_oop(narrowOop* p) { do_oop_work(p); }
   void do_oop(oop* p)       { do_oop_work(p); }
@@ -897,16 +906,19 @@
   ShenandoahObjToScanQueue* _queue;
   Thread* _thread;
   ShenandoahTraversalGC* _traversal_gc;
+  ShenandoahMarkingContext* const _mark_context;
+
   template <class T>
   inline void do_oop_work(T* p) {
     // TODO: Need to somehow pass base_obj here?
-    _traversal_gc->process_oop<T, false /* string dedup */, true /* degen */, true /* matrix */>(p, _thread, _queue, NULL);
+    _traversal_gc->process_oop<T, false /* string dedup */, true /* degen */, true /* matrix */>(p, _thread, _queue, _mark_context, NULL);
   }
 
 public:
   ShenandoahTraversalKeepAliveUpdateDegenMatrixClosure(ShenandoahObjToScanQueue* q) :
     _queue(q), _thread(Thread::current()),
-    _traversal_gc(ShenandoahHeap::heap()->traversal_gc()) {}
+    _traversal_gc(ShenandoahHeap::heap()->traversal_gc()),
+    _mark_context(ShenandoahHeap::heap()->next_marking_context()) {}
 
   void do_oop(narrowOop* p) { do_oop_work(p); }
   void do_oop(oop* p)       { do_oop_work(p); }
--- old/src/hotspot/share/gc/shenandoah/shenandoahTraversalGC.hpp	2018-07-17 22:23:39.302442298 +0200
+++ new/src/hotspot/share/gc/shenandoah/shenandoahTraversalGC.hpp	2018-07-17 22:23:39.086446049 +0200
@@ -71,7 +71,7 @@
   void final_traversal_collection();
 
   template <class T, bool STRING_DEDUP, bool DEGEN, bool UPDATE_MATRIX>
-  inline void process_oop(T* p, Thread* thread, ShenandoahObjToScanQueue* queue, oop base_obj);
+  inline void process_oop(T* p, Thread* thread, ShenandoahObjToScanQueue* queue, ShenandoahMarkingContext* const mark_context, oop base_obj);
 
   bool check_and_handle_cancelled_gc(ParallelTaskTerminator* terminator);
 
--- old/src/hotspot/share/gc/shenandoah/shenandoahTraversalGC.inline.hpp	2018-07-17 22:23:39.989430369 +0200
+++ new/src/hotspot/share/gc/shenandoah/shenandoahTraversalGC.inline.hpp	2018-07-17 22:23:39.805433564 +0200
@@ -37,7 +37,7 @@
 #include "oops/oop.inline.hpp"
 
 template <class T, bool STRING_DEDUP, bool DEGEN, bool UPDATE_MATRIX>
-void ShenandoahTraversalGC::process_oop(T* p, Thread* thread, ShenandoahObjToScanQueue* queue, oop base_obj) {
+void ShenandoahTraversalGC::process_oop(T* p, Thread* thread, ShenandoahObjToScanQueue* queue, ShenandoahMarkingContext* const mark_context, oop base_obj) {
   T o = RawAccess<>::oop_load(p);
   if (!CompressedOops::is_null(o)) {
     oop obj = CompressedOops::decode_not_null(o);
@@ -77,7 +77,7 @@
       }
     }
 
-    if (_heap->next_marking_context()->mark(obj)) {
+    if (mark_context->mark(obj)) {
       bool succeeded = queue->push(ShenandoahMarkTask(obj));
       assert(succeeded, "must succeed to push to task queue");