--- /dev/null	2018-12-03 11:58:50.256341286 +0100
+++ new/src/hotspot/share/gc/shenandoah/shenandoahThreadLocalData.hpp	2018-12-03 17:47:48.518256842 +0100
@@ -0,0 +1,174 @@
+/*
+ * Copyright (c) 2018, Red Hat, Inc. All rights reserved.
+ *
+ * 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.
+ *
+ */
+
+#ifndef SHARE_GC_SHENANDOAH_SHENANDOAHTHREADLOCALDATA_HPP
+#define SHARE_GC_SHENANDOAH_SHENANDOAHTHREADLOCALDATA_HPP
+
+#include "gc/shared/plab.hpp"
+#include "gc/shenandoah/shenandoahBarrierSet.hpp"
+#include "gc/shenandoah/shenandoahSATBMarkQueueSet.hpp"
+#include "runtime/thread.hpp"
+#include "utilities/debug.hpp"
+#include "utilities/sizes.hpp"
+
+class ShenandoahThreadLocalData {
+public:
+  static const uint INVALID_WORKER_ID = uint(-1);
+
+private:
+  char _gc_state;
+  char _oom_during_evac;
+  ShenandoahSATBMarkQueue _satb_mark_queue;
+  PLAB* _gclab;
+  size_t _gclab_size;
+  uint  _worker_id;
+  bool _force_satb_flush;
+
+  ShenandoahThreadLocalData() :
+    _gc_state(0),
+    _oom_during_evac(0),
+    _satb_mark_queue(&ShenandoahBarrierSet::satb_mark_queue_set()),
+    _gclab(NULL),
+    _gclab_size(0),
+    _worker_id(INVALID_WORKER_ID),
+    _force_satb_flush(false) {
+  }
+
+  ~ShenandoahThreadLocalData() {
+    if (_gclab != NULL) {
+      delete _gclab;
+    }
+  }
+
+  static ShenandoahThreadLocalData* data(Thread* thread) {
+    assert(UseShenandoahGC, "Sanity");
+    return thread->gc_data<ShenandoahThreadLocalData>();
+  }
+
+  static ByteSize satb_mark_queue_offset() {
+    return Thread::gc_data_offset() + byte_offset_of(ShenandoahThreadLocalData, _satb_mark_queue);
+  }
+
+public:
+  static void create(Thread* thread) {
+    new (data(thread)) ShenandoahThreadLocalData();
+  }
+
+  static void destroy(Thread* thread) {
+    data(thread)->~ShenandoahThreadLocalData();
+  }
+
+  static SATBMarkQueue& satb_mark_queue(Thread* thread) {
+    return data(thread)->_satb_mark_queue;
+  }
+
+  static bool is_oom_during_evac(Thread* thread) {
+    return (data(thread)->_oom_during_evac & 1) == 1;
+  }
+
+  static void set_oom_during_evac(Thread* thread, bool oom) {
+    if (oom) {
+      data(thread)->_oom_during_evac |= 1;
+    } else {
+      data(thread)->_oom_during_evac &= ~1;
+    }
+  }
+
+  static void set_gc_state(Thread* thread, char gc_state) {
+    data(thread)->_gc_state = gc_state;
+  }
+
+  static char gc_state(Thread* thread) {
+    return data(thread)->_gc_state;
+  }
+
+  static void set_worker_id(Thread* thread, uint id) {
+    assert(thread->is_Worker_thread(), "Must be a worker thread");
+    data(thread)->_worker_id = id;
+  }
+
+  static uint worker_id(Thread* thread) {
+    assert(thread->is_Worker_thread(), "Must be a worker thread");
+    return data(thread)->_worker_id;
+  }
+
+  static void set_force_satb_flush(Thread* thread, bool v) {
+    data(thread)->_force_satb_flush = v;
+  }
+
+  static bool is_force_satb_flush(Thread* thread) {
+    return data(thread)->_force_satb_flush;
+  }
+
+  static void initialize_gclab(Thread* thread) {
+    assert (thread->is_Java_thread() || thread->is_Worker_thread(), "Only Java and GC worker threads are allowed to get GCLABs");
+    data(thread)->_gclab = new PLAB(PLAB::min_size());
+    data(thread)->_gclab_size = 0;
+  }
+
+  static PLAB* gclab(Thread* thread) {
+    return data(thread)->_gclab;
+  }
+
+  static size_t gclab_size(Thread* thread) {
+    return data(thread)->_gclab_size;
+  }
+
+  static void set_gclab_size(Thread* thread, size_t v) {
+    data(thread)->_gclab_size = v;
+  }
+
+#ifdef ASSERT
+  static void set_evac_allowed(Thread* thread, bool evac_allowed) {
+    if (evac_allowed) {
+      data(thread)->_oom_during_evac |= 2;
+    } else {
+      data(thread)->_oom_during_evac &= ~2;
+    }
+  }
+
+  static bool is_evac_allowed(Thread* thread) {
+    return (data(thread)->_oom_during_evac & 2) == 2;
+  }
+#endif
+
+  // Offsets
+  static ByteSize satb_mark_queue_active_offset() {
+    return satb_mark_queue_offset() + SATBMarkQueue::byte_offset_of_active();
+  }
+
+  static ByteSize satb_mark_queue_index_offset() {
+    return satb_mark_queue_offset() + SATBMarkQueue::byte_offset_of_index();
+  }
+
+  static ByteSize satb_mark_queue_buffer_offset() {
+    return satb_mark_queue_offset() + SATBMarkQueue::byte_offset_of_buf();
+  }
+
+  static ByteSize gc_state_offset() {
+    return Thread::gc_data_offset() + byte_offset_of(ShenandoahThreadLocalData, _gc_state);
+  }
+
+};
+
+#endif // SHARE_GC_SHENANDOAH_SHENANDOAHTHREADLOCALDATA_HPP