1 /*
  2  * Copyright (c) 2015, 2019, 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 #include "precompiled.hpp"
 25 #include "gc/z/zHeap.inline.hpp"
 26 #include "gc/z/zLiveMap.inline.hpp"
 27 #include "gc/z/zStat.hpp"
 28 #include "gc/z/zThread.inline.hpp"
 29 #include "logging/log.hpp"
 30 #include "runtime/atomic.hpp"
 31 #include "runtime/orderAccess.hpp"
 32 #include "utilities/debug.hpp"
 33 
 34 static const ZStatCounter ZCounterMarkSeqNumResetContention("Contention", "Mark SeqNum Reset Contention", ZStatUnitOpsPerSecond);
 35 static const ZStatCounter ZCounterMarkSegmentResetContention("Contention", "Mark Segment Reset Contention", ZStatUnitOpsPerSecond);
 36 
 37 static size_t bitmap_size(uint32_t size, size_t nsegments) {
 38   // We need at least one bit per segment
 39   return MAX2<size_t>(size, nsegments) * 2;
 40 }
 41 
 42 ZLiveMap::ZLiveMap(uint32_t size) :
 43     _seqnum(0),
 44     _live_objects(0),
 45     _live_bytes(0),
 46     _segment_live_bits(0),
 47     _segment_claim_bits(0),
 48     _bitmap(bitmap_size(size, nsegments)),
 49     _segment_shift(exact_log2(segment_size())) {}
 50 
 51 void ZLiveMap::reset(size_t index) {
 52   const uint32_t seqnum_initializing = (uint32_t)-1;
 53   bool contention = false;
 54 
 55   // Multiple threads can enter here, make sure only one of them
 56   // resets the marking information while the others busy wait.
 57   for (uint32_t seqnum = OrderAccess::load_acquire(&_seqnum);
 58        seqnum != ZGlobalSeqNum;
 59        seqnum = OrderAccess::load_acquire(&_seqnum)) {
 60     if ((seqnum != seqnum_initializing) &&
 61         (Atomic::cmpxchg(seqnum_initializing, &_seqnum, seqnum) == seqnum)) {
 62       // Reset marking information
 63       _live_bytes = 0;
 64       _live_objects = 0;
 65 
 66       // Clear segment claimed/live bits
 67       segment_live_bits().clear();
 68       segment_claim_bits().clear();
 69 
 70       assert(_seqnum == seqnum_initializing, "Invalid");
 71 
 72       // Make sure the newly reset marking information is ordered
 73       // before the update of the page seqnum, such that when the
 74       // up-to-date seqnum is load acquired, the bit maps will not
 75       // contain stale information.
 76       OrderAccess::release_store(&_seqnum, ZGlobalSeqNum);
 77       break;
 78     }
 79 
 80     // Mark reset contention
 81     if (!contention) {
 82       // Count contention once
 83       ZStatInc(ZCounterMarkSeqNumResetContention);
 84       contention = true;
 85 
 86       log_trace(gc)("Mark seqnum reset contention, thread: " PTR_FORMAT " (%s), map: " PTR_FORMAT ", bit: " SIZE_FORMAT,
 87                     ZThread::id(), ZThread::name(), p2i(this), index);
 88     }
 89   }
 90 }
 91 
 92 void ZLiveMap::reset_segment(BitMap::idx_t segment) {
 93   bool contention = false;
 94 
 95   if (!claim_segment(segment)) {
 96     // Already claimed, wait for live bit to be set
 97     while (!is_segment_live(segment)) {
 98       // Mark reset contention
 99       if (!contention) {
100         // Count contention once
101         ZStatInc(ZCounterMarkSegmentResetContention);
102         contention = true;
103 
104         log_trace(gc)("Mark segment reset contention, thread: " PTR_FORMAT " (%s), map: " PTR_FORMAT ", segment: " SIZE_FORMAT,
105                       ZThread::id(), ZThread::name(), p2i(this), segment);
106       }
107     }
108 
109     // Segment is live
110     return;
111   }
112 
113   // Segment claimed, clear it
114   const BitMap::idx_t start_index = segment_start(segment);
115   const BitMap::idx_t end_index   = segment_end(segment);
116   if (segment_size() / BitsPerWord >= 32) {
117     _bitmap.clear_large_range(start_index, end_index);
118   } else {
119     _bitmap.clear_range(start_index, end_index);
120   }
121 
122   // Set live bit
123   const bool success = set_segment_live_atomic(segment);
124   assert(success, "Should never fail");
125 }
126 
127 void ZLiveMap::resize(uint32_t size) {
128   const size_t new_bitmap_size = bitmap_size(size, nsegments);
129   if (_bitmap.size() != new_bitmap_size) {
130     _bitmap.reinitialize(new_bitmap_size, false /* clear */);
131     _segment_shift = exact_log2(segment_size());
132   }
133 }