diff -r 8b16701b4636 -r f5662bdbee4a src/hotspot/share/gc/z/zValue.hpp
--- a/src/hotspot/share/gc/z/zValue.hpp	Mon Oct 21 09:55:58 2019 +0200
+++ b/src/hotspot/share/gc/z/zValue.hpp	Mon Oct 21 09:56:43 2019 +0200
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, 2018, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2015, 2019, Oracle and/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
@@ -25,13 +25,11 @@
 #define SHARE_GC_Z_ZVALUE_HPP
 
 #include "memory/allocation.hpp"
-#include "gc/z/zCPU.hpp"
-#include "gc/z/zGlobals.hpp"
-#include "gc/z/zNUMA.hpp"
-#include "gc/z/zThread.hpp"
-#include "gc/z/zUtils.hpp"
-#include "runtime/globals.hpp"
-#include "utilities/align.hpp"
+#include "utilities/globalDefinitions.hpp"
+
+//
+// Storage
+//
 
 template <typename S>
 class ZValueStorage : public AllStatic {
@@ -42,202 +40,93 @@
 public:
   static const size_t offset = 4 * K;
 
-  static uintptr_t alloc(size_t size) {
-    guarantee(size <= offset, "Allocation too large");
-
-    // Allocate entry in existing memory block
-    const uintptr_t addr = align_up(_top, S::alignment());
-    _top = addr + size;
-
-    if (_top < _end) {
-      // Success
-      return addr;
-    }
-
-    // Allocate new block of memory
-    const size_t block_alignment = offset;
-    const size_t block_size = offset * S::count();
-    _top = ZUtils::alloc_aligned(block_alignment, block_size);
-    _end = _top + offset;
-
-    // Retry allocation
-    return alloc(size);
-  }
+  static uintptr_t alloc(size_t size);
 };
 
-template <typename T> uintptr_t ZValueStorage<T>::_end = 0;
-template <typename T> uintptr_t ZValueStorage<T>::_top = 0;
-
 class ZContendedStorage : public ZValueStorage<ZContendedStorage> {
 public:
-  static size_t alignment() {
-    return ZCacheLineSize;
-  }
-
-  static uint32_t count() {
-    return 1;
-  }
-
-  static uint32_t id() {
-    return 0;
-  }
+  static size_t alignment();
+  static uint32_t count();
+  static uint32_t id();
 };
 
 class ZPerCPUStorage : public ZValueStorage<ZPerCPUStorage> {
 public:
-  static size_t alignment() {
-    return sizeof(uintptr_t);
-  }
-
-  static uint32_t count() {
-    return ZCPU::count();
-  }
-
-  static uint32_t id() {
-    return ZCPU::id();
-  }
+  static size_t alignment();
+  static uint32_t count();
+  static uint32_t id();
 };
 
 class ZPerNUMAStorage : public ZValueStorage<ZPerNUMAStorage> {
 public:
-  static size_t alignment() {
-    return sizeof(uintptr_t);
-  }
-
-  static uint32_t count() {
-    return ZNUMA::count();
-  }
-
-  static uint32_t id() {
-    return ZNUMA::id();
-  }
+  static size_t alignment();
+  static uint32_t count();
+  static uint32_t id();
 };
 
 class ZPerWorkerStorage : public ZValueStorage<ZPerWorkerStorage> {
 public:
-  static size_t alignment() {
-    return sizeof(uintptr_t);
-  }
-
-  static uint32_t count() {
-    return MAX2(ParallelGCThreads, ConcGCThreads);
-  }
-
-  static uint32_t id() {
-    return ZThread::worker_id();
-  }
+  static size_t alignment();
+  static uint32_t count();
+  static uint32_t id();
 };
 
-template <typename S, typename T>
-class ZValueIterator;
+//
+// Value
+//
 
 template <typename S, typename T>
 class ZValue : public CHeapObj<mtGC> {
 private:
   const uintptr_t _addr;
 
-  uintptr_t value_addr(uint32_t value_id) const {
-    return _addr + (value_id * S::offset);
-  }
+  uintptr_t value_addr(uint32_t value_id) const;
 
 public:
-  ZValue() :
-      _addr(S::alloc(sizeof(T))) {
-    // Initialize all instances
-    ZValueIterator<S, T> iter(this);
-    for (T* addr; iter.next(&addr);) {
-      ::new (addr) T;
-    }
-  }
+  ZValue();
+  ZValue(const T& value);
 
-  ZValue(const T& value) :
-      _addr(S::alloc(sizeof(T))) {
-    // Initialize all instances
-    ZValueIterator<S, T> iter(this);
-    for (T* addr; iter.next(&addr);) {
-      ::new (addr) T(value);
-    }
-  }
-
-  // Not implemented
-  ZValue(const ZValue<S, T>& value);
-  ZValue<S, T>& operator=(const ZValue<S, T>& value);
+  const T* addr(uint32_t value_id = S::id()) const;
+  T* addr(uint32_t value_id = S::id());
 
-  const T* addr(uint32_t value_id = S::id()) const {
-    return reinterpret_cast<const T*>(value_addr(value_id));
-  }
-
-  T* addr(uint32_t value_id = S::id()) {
-    return reinterpret_cast<T*>(value_addr(value_id));
-  }
-
-  const T& get(uint32_t value_id = S::id()) const {
-    return *addr(value_id);
-  }
+  const T& get(uint32_t value_id = S::id()) const;
+  T& get(uint32_t value_id = S::id());
 
-  T& get(uint32_t value_id = S::id()) {
-    return *addr(value_id);
-  }
-
-  void set(const T& value, uint32_t value_id = S::id()) {
-    get(value_id) = value;
-  }
-
-  void set_all(const T& value) {
-    ZValueIterator<S, T> iter(this);
-    for (T* addr; iter.next(&addr);) {
-      *addr = value;
-    }
-  }
+  void set(const T& value, uint32_t value_id = S::id());
+  void set_all(const T& value);
 };
 
 template <typename T>
 class ZContended : public ZValue<ZContendedStorage, T> {
 public:
-  ZContended() :
-      ZValue<ZContendedStorage, T>() {}
-
-  ZContended(const T& value) :
-      ZValue<ZContendedStorage, T>(value) {}
-
-  using ZValue<ZContendedStorage, T>::operator=;
+  ZContended();
+  ZContended(const T& value);
 };
 
 template <typename T>
 class ZPerCPU : public ZValue<ZPerCPUStorage, T> {
 public:
-  ZPerCPU() :
-      ZValue<ZPerCPUStorage, T>() {}
-
-  ZPerCPU(const T& value) :
-      ZValue<ZPerCPUStorage, T>(value) {}
-
-  using ZValue<ZPerCPUStorage, T>::operator=;
+  ZPerCPU();
+  ZPerCPU(const T& value);
 };
 
 template <typename T>
 class ZPerNUMA : public ZValue<ZPerNUMAStorage, T> {
 public:
-  ZPerNUMA() :
-      ZValue<ZPerNUMAStorage, T>() {}
-
-  ZPerNUMA(const T& value) :
-      ZValue<ZPerNUMAStorage, T>(value) {}
-
-  using ZValue<ZPerNUMAStorage, T>::operator=;
+  ZPerNUMA();
+  ZPerNUMA(const T& value);
 };
 
 template <typename T>
 class ZPerWorker : public ZValue<ZPerWorkerStorage, T> {
 public:
-  ZPerWorker() :
-      ZValue<ZPerWorkerStorage, T>() {}
+  ZPerWorker();
+  ZPerWorker(const T& value);
+};
 
-  ZPerWorker(const T& value) :
-      ZValue<ZPerWorkerStorage, T>(value) {}
-
-  using ZValue<ZPerWorkerStorage, T>::operator=;
-};
+//
+// Iterator
+//
 
 template <typename S, typename T>
 class ZValueIterator {
@@ -246,38 +135,27 @@
   uint32_t            _value_id;
 
 public:
-  ZValueIterator(ZValue<S, T>* value) :
-      _value(value),
-      _value_id(0) {}
+  ZValueIterator(ZValue<S, T>* value);
 
-  bool next(T** value) {
-    if (_value_id < S::count()) {
-      *value = _value->addr(_value_id++);
-      return true;
-    }
-    return false;
-  }
+  bool next(T** value);
 };
 
 template <typename T>
 class ZPerCPUIterator : public ZValueIterator<ZPerCPUStorage, T> {
 public:
-  ZPerCPUIterator(ZPerCPU<T>* value) :
-      ZValueIterator<ZPerCPUStorage, T>(value) {}
+  ZPerCPUIterator(ZPerCPU<T>* value);
 };
 
 template <typename T>
 class ZPerNUMAIterator : public ZValueIterator<ZPerNUMAStorage, T> {
 public:
-  ZPerNUMAIterator(ZPerNUMA<T>* value) :
-      ZValueIterator<ZPerNUMAStorage, T>(value) {}
+  ZPerNUMAIterator(ZPerNUMA<T>* value);
 };
 
 template <typename T>
 class ZPerWorkerIterator : public ZValueIterator<ZPerWorkerStorage, T> {
 public:
-  ZPerWorkerIterator(ZPerWorker<T>* value) :
-      ZValueIterator<ZPerWorkerStorage, T>(value) {}
+  ZPerWorkerIterator(ZPerWorker<T>* value);
 };
 
 template <typename S, typename T>
@@ -287,38 +165,27 @@
   uint32_t                  _value_id;
 
 public:
-  ZValueConstIterator(const ZValue<S, T>* value) :
-      _value(value),
-      _value_id(0) {}
+  ZValueConstIterator(const ZValue<S, T>* value);
 
-  bool next(const T** value) {
-    if (_value_id < S::count()) {
-      *value = _value->addr(_value_id++);
-      return true;
-    }
-    return false;
-  }
+  bool next(const T** value);
 };
 
 template <typename T>
 class ZPerCPUConstIterator : public ZValueConstIterator<ZPerCPUStorage, T> {
 public:
-  ZPerCPUConstIterator(const ZPerCPU<T>* value) :
-      ZValueConstIterator<ZPerCPUStorage, T>(value) {}
+  ZPerCPUConstIterator(const ZPerCPU<T>* value);
 };
 
 template <typename T>
 class ZPerNUMAConstIterator : public ZValueConstIterator<ZPerNUMAStorage, T> {
 public:
-  ZPerNUMAConstIterator(const ZPerNUMA<T>* value) :
-      ZValueConstIterator<ZPerNUMAStorage, T>(value) {}
+  ZPerNUMAConstIterator(const ZPerNUMA<T>* value);
 };
 
 template <typename T>
 class ZPerWorkerConstIterator : public ZValueConstIterator<ZPerWorkerStorage, T> {
 public:
-  ZPerWorkerConstIterator(const ZPerWorker<T>* value) :
-      ZValueConstIterator<ZPerWorkerStorage, T>(value) {}
+  ZPerWorkerConstIterator(const ZPerWorker<T>* value);
 };
 
 #endif // SHARE_GC_Z_ZVALUE_HPP