1 /*
   2  * Copyright (c) 2015, 2018, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  */
  23 
  24 #ifndef SHARE_GC_Z_ZVALUE_HPP
  25 #define SHARE_GC_Z_ZVALUE_HPP
  26 
  27 #include "memory/allocation.hpp"
  28 #include "gc/z/zCPU.hpp"
  29 #include "gc/z/zGlobals.hpp"
  30 #include "gc/z/zNUMA.hpp"
  31 #include "gc/z/zThread.hpp"
  32 #include "gc/z/zUtils.hpp"
  33 #include "utilities/align.hpp"
  34 
  35 template <typename S>
  36 class ZValueStorage : public AllStatic {
  37 private:
  38   static uintptr_t _top;
  39   static uintptr_t _end;
  40 
  41 public:
  42   static const size_t offset = 4 * K;
  43 
  44   static uintptr_t alloc(size_t size) {
  45     guarantee(size <= offset, "Allocation too large");
  46 
  47     // Allocate entry in existing memory block
  48     const uintptr_t addr = align_up(_top, S::alignment());
  49     _top = addr + size;
  50 
  51     if (_top < _end) {
  52       // Success
  53       return addr;
  54     }
  55 
  56     // Allocate new block of memory
  57     const size_t block_alignment = offset;
  58     const size_t block_size = offset * S::count();
  59     _top = ZUtils::alloc_aligned(block_alignment, block_size);
  60     _end = _top + offset;
  61 
  62     // Retry allocation
  63     return alloc(size);
  64   }
  65 };
  66 
  67 template <typename T> uintptr_t ZValueStorage<T>::_end = 0;
  68 template <typename T> uintptr_t ZValueStorage<T>::_top = 0;
  69 
  70 class ZContendedStorage : public ZValueStorage<ZContendedStorage> {
  71 public:
  72   static size_t alignment() {
  73     return ZCacheLineSize;
  74   }
  75 
  76   static uint32_t count() {
  77     return 1;
  78   }
  79 
  80   static uint32_t id() {
  81     return 0;
  82   }
  83 };
  84 
  85 class ZPerCPUStorage : public ZValueStorage<ZPerCPUStorage> {
  86 public:
  87   static size_t alignment() {
  88     return sizeof(uintptr_t);
  89   }
  90 
  91   static uint32_t count() {
  92     return ZCPU::count();
  93   }
  94 
  95   static uint32_t id() {
  96     return ZCPU::id();
  97   }
  98 };
  99 
 100 class ZPerNUMAStorage : public ZValueStorage<ZPerNUMAStorage> {
 101 public:
 102   static size_t alignment() {
 103     return sizeof(uintptr_t);
 104   }
 105 
 106   static uint32_t count() {
 107     return ZNUMA::count();
 108   }
 109 
 110   static uint32_t id() {
 111     return ZNUMA::id();
 112   }
 113 };
 114 
 115 class ZPerWorkerStorage : public ZValueStorage<ZPerWorkerStorage> {
 116 public:
 117   static size_t alignment() {
 118     return sizeof(uintptr_t);
 119   }
 120 
 121   static uint32_t count() {
 122     return MAX2(ParallelGCThreads, ConcGCThreads);
 123   }
 124 
 125   static uint32_t id() {
 126     return ZThread::worker_id();
 127   }
 128 };
 129 
 130 template <typename S, typename T>
 131 class ZValueIterator;
 132 
 133 template <typename S, typename T>
 134 class ZValue : public CHeapObj<mtGC> {
 135 private:
 136   const uintptr_t _addr;
 137 
 138   uintptr_t value_addr(uint32_t value_id) const {
 139     return _addr + (value_id * S::offset);
 140   }
 141 
 142 public:
 143   ZValue() :
 144       _addr(S::alloc(sizeof(T))) {
 145     // Initialize all instances
 146     ZValueIterator<S, T> iter(this);
 147     for (T* addr; iter.next(&addr);) {
 148       ::new (addr) T;
 149     }
 150   }
 151 
 152   ZValue(const T& value) :
 153       _addr(S::alloc(sizeof(T))) {
 154     // Initialize all instances
 155     ZValueIterator<S, T> iter(this);
 156     for (T* addr; iter.next(&addr);) {
 157       ::new (addr) T(value);
 158     }
 159   }
 160 
 161   // Not implemented
 162   ZValue(const ZValue<S, T>& value);
 163   ZValue<S, T>& operator=(const ZValue<S, T>& value);
 164 
 165   const T* addr(uint32_t value_id = S::id()) const {
 166     return reinterpret_cast<const T*>(value_addr(value_id));
 167   }
 168 
 169   T* addr(uint32_t value_id = S::id()) {
 170     return reinterpret_cast<T*>(value_addr(value_id));
 171   }
 172 
 173   const T& get(uint32_t value_id = S::id()) const {
 174     return *addr(value_id);
 175   }
 176 
 177   T& get(uint32_t value_id = S::id()) {
 178     return *addr(value_id);
 179   }
 180 
 181   void set(const T& value, uint32_t value_id = S::id()) {
 182     get(value_id) = value;
 183   }
 184 
 185   void set_all(const T& value) {
 186     ZValueIterator<S, T> iter(this);
 187     for (T* addr; iter.next(&addr);) {
 188       *addr = value;
 189     }
 190   }
 191 };
 192 
 193 template <typename T>
 194 class ZContended : public ZValue<ZContendedStorage, T> {
 195 public:
 196   ZContended() :
 197       ZValue<ZContendedStorage, T>() {}
 198 
 199   ZContended(const T& value) :
 200       ZValue<ZContendedStorage, T>(value) {}
 201 
 202   using ZValue<ZContendedStorage, T>::operator=;
 203 };
 204 
 205 template <typename T>
 206 class ZPerCPU : public ZValue<ZPerCPUStorage, T> {
 207 public:
 208   ZPerCPU() :
 209       ZValue<ZPerCPUStorage, T>() {}
 210 
 211   ZPerCPU(const T& value) :
 212       ZValue<ZPerCPUStorage, T>(value) {}
 213 
 214   using ZValue<ZPerCPUStorage, T>::operator=;
 215 };
 216 
 217 template <typename T>
 218 class ZPerNUMA : public ZValue<ZPerNUMAStorage, T> {
 219 public:
 220   ZPerNUMA() :
 221       ZValue<ZPerNUMAStorage, T>() {}
 222 
 223   ZPerNUMA(const T& value) :
 224       ZValue<ZPerNUMAStorage, T>(value) {}
 225 
 226   using ZValue<ZPerNUMAStorage, T>::operator=;
 227 };
 228 
 229 template <typename T>
 230 class ZPerWorker : public ZValue<ZPerWorkerStorage, T> {
 231 public:
 232   ZPerWorker() :
 233       ZValue<ZPerWorkerStorage, T>() {}
 234 
 235   ZPerWorker(const T& value) :
 236       ZValue<ZPerWorkerStorage, T>(value) {}
 237 
 238   using ZValue<ZPerWorkerStorage, T>::operator=;
 239 };
 240 
 241 template <typename S, typename T>
 242 class ZValueIterator {
 243 private:
 244   ZValue<S, T>* const _value;
 245   uint32_t            _value_id;
 246 
 247 public:
 248   ZValueIterator(ZValue<S, T>* value) :
 249       _value(value),
 250       _value_id(0) {}
 251 
 252   bool next(T** value) {
 253     if (_value_id < S::count()) {
 254       *value = _value->addr(_value_id++);
 255       return true;
 256     }
 257     return false;
 258   }
 259 };
 260 
 261 template <typename T>
 262 class ZPerCPUIterator : public ZValueIterator<ZPerCPUStorage, T> {
 263 public:
 264   ZPerCPUIterator(ZPerCPU<T>* value) :
 265       ZValueIterator<ZPerCPUStorage, T>(value) {}
 266 };
 267 
 268 template <typename T>
 269 class ZPerNUMAIterator : public ZValueIterator<ZPerNUMAStorage, T> {
 270 public:
 271   ZPerNUMAIterator(ZPerNUMA<T>* value) :
 272       ZValueIterator<ZPerNUMAStorage, T>(value) {}
 273 };
 274 
 275 template <typename T>
 276 class ZPerWorkerIterator : public ZValueIterator<ZPerWorkerStorage, T> {
 277 public:
 278   ZPerWorkerIterator(ZPerWorker<T>* value) :
 279       ZValueIterator<ZPerWorkerStorage, T>(value) {}
 280 };
 281 
 282 template <typename S, typename T>
 283 class ZValueConstIterator {
 284 private:
 285   const ZValue<S, T>* const _value;
 286   uint32_t                  _value_id;
 287 
 288 public:
 289   ZValueConstIterator(const ZValue<S, T>* value) :
 290       _value(value),
 291       _value_id(0) {}
 292 
 293   bool next(const T** value) {
 294     if (_value_id < S::count()) {
 295       *value = _value->addr(_value_id++);
 296       return true;
 297     }
 298     return false;
 299   }
 300 };
 301 
 302 template <typename T>
 303 class ZPerCPUConstIterator : public ZValueConstIterator<ZPerCPUStorage, T> {
 304 public:
 305   ZPerCPUConstIterator(const ZPerCPU<T>* value) :
 306       ZValueConstIterator<ZPerCPUStorage, T>(value) {}
 307 };
 308 
 309 template <typename T>
 310 class ZPerNUMAConstIterator : public ZValueConstIterator<ZPerNUMAStorage, T> {
 311 public:
 312   ZPerNUMAConstIterator(const ZPerNUMA<T>* value) :
 313       ZValueConstIterator<ZPerNUMAStorage, T>(value) {}
 314 };
 315 
 316 template <typename T>
 317 class ZPerWorkerConstIterator : public ZValueConstIterator<ZPerWorkerStorage, T> {
 318 public:
 319   ZPerWorkerConstIterator(const ZPerWorker<T>* value) :
 320       ZValueConstIterator<ZPerWorkerStorage, T>(value) {}
 321 };
 322 
 323 #endif // SHARE_GC_Z_ZVALUE_HPP
--- EOF ---