hotspot/src/share/vm/gc/shared/blockOffsetTable.cpp
changeset 35469 17ea1b453dd5
parent 35061 be6025ebffea
child 46968 9119841280f4
--- a/hotspot/src/share/vm/gc/shared/blockOffsetTable.cpp	Sun Jan 10 20:02:50 2016 -0500
+++ b/hotspot/src/share/vm/gc/shared/blockOffsetTable.cpp	Mon Jan 11 09:14:01 2016 +0100
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2000, 2015, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2000, 2016, 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
@@ -87,7 +87,7 @@
 bool BlockOffsetSharedArray::is_card_boundary(HeapWord* p) const {
   assert(p >= _reserved.start(), "just checking");
   size_t delta = pointer_delta(p, _reserved.start());
-  return (delta & right_n_bits(LogN_words)) == (size_t)NoBits;
+  return (delta & right_n_bits((int)BOTConstants::LogN_words)) == (size_t)NoBits;
 }
 
 
@@ -104,7 +104,7 @@
   set_init_to_zero(init_to_zero_);
   if (!init_to_zero_) {
     // initialize cards to point back to mr.start()
-    set_remainder_to_point_to_start(mr.start() + N_words, mr.end());
+    set_remainder_to_point_to_start(mr.start() + BOTConstants::N_words, mr.end());
     _array->set_offset_array(0, 0);  // set first card to 0
   }
 }
@@ -160,7 +160,7 @@
   size_t start_card = _array->index_for(start);
   size_t end_card = _array->index_for(end-1);
   assert(start ==_array->address_for_index(start_card), "Precondition");
-  assert(end ==_array->address_for_index(end_card)+N_words, "Precondition");
+  assert(end ==_array->address_for_index(end_card)+BOTConstants::N_words, "Precondition");
   set_remainder_to_point_to_start_incl(start_card, end_card, reducing); // closed interval
 }
 
@@ -176,16 +176,16 @@
     return;
   }
   assert(start_card > _array->index_for(_bottom), "Cannot be first card");
-  assert(_array->offset_array(start_card-1) <= N_words,
+  assert(_array->offset_array(start_card-1) <= BOTConstants::N_words,
     "Offset card has an unexpected value");
   size_t start_card_for_region = start_card;
   u_char offset = max_jubyte;
-  for (int i = 0; i < N_powers; i++) {
+  for (uint i = 0; i < BOTConstants::N_powers; i++) {
     // -1 so that the the card with the actual offset is counted.  Another -1
     // so that the reach ends in this region and not at the start
     // of the next.
-    size_t reach = start_card - 1 + (power_to_cards_back(i+1) - 1);
-    offset = N_words + i;
+    size_t reach = start_card - 1 + (BOTConstants::power_to_cards_back(i+1) - 1);
+    offset = BOTConstants::N_words + i;
     if (reach >= end_card) {
       _array->set_offset_array(start_card_for_region, end_card, offset, reducing);
       start_card_for_region = reach + 1;
@@ -206,15 +206,15 @@
   if (end_card < start_card) {
     return;
   }
-  guarantee(_array->offset_array(start_card) == N_words, "Wrong value in second card");
-  u_char last_entry = N_words;
+  guarantee(_array->offset_array(start_card) == BOTConstants::N_words, "Wrong value in second card");
+  u_char last_entry = BOTConstants::N_words;
   for (size_t c = start_card + 1; c <= end_card; c++ /* yeah! */) {
     u_char entry = _array->offset_array(c);
     guarantee(entry >= last_entry, "Monotonicity");
-    if (c - start_card > power_to_cards_back(1)) {
-      guarantee(entry > N_words, "Should be in logarithmic region");
+    if (c - start_card > BOTConstants::power_to_cards_back(1)) {
+      guarantee(entry > BOTConstants::N_words, "Should be in logarithmic region");
     }
-    size_t backskip = entry_to_cards_back(entry);
+    size_t backskip = BOTConstants::entry_to_cards_back(entry);
     size_t landing_card = c - backskip;
     guarantee(landing_card >= (start_card - 1), "Inv");
     if (landing_card >= start_card) {
@@ -222,7 +222,7 @@
     } else {
       guarantee(landing_card == (start_card - 1), "Tautology");
       // Note that N_words is the maximum offset value
-      guarantee(_array->offset_array(landing_card) <= N_words, "Offset value");
+      guarantee(_array->offset_array(landing_card) <= BOTConstants::N_words, "Offset value");
     }
     last_entry = entry;  // remember for monotonicity test
   }
@@ -254,7 +254,7 @@
   uintptr_t start_ui = (uintptr_t)blk_start;
   // Calculate the last card boundary preceding end of blk
   intptr_t boundary_before_end = (intptr_t)end_ui;
-  clear_bits(boundary_before_end, right_n_bits(LogN));
+  clear_bits(boundary_before_end, right_n_bits((int)BOTConstants::LogN));
   if (start_ui <= (uintptr_t)boundary_before_end) {
     // blk starts at or crosses a boundary
     // Calculate index of card on which blk begins
@@ -267,7 +267,7 @@
     if (blk_start != boundary) {
       // blk starts strictly after boundary
       // adjust card boundary and start_index forward to next card
-      boundary += N_words;
+      boundary += BOTConstants::N_words;
       start_index++;
     }
     assert(start_index <= end_index, "monotonicity of index_for()");
@@ -284,8 +284,8 @@
         // We have finished marking the "offset card". We need to now
         // mark the subsequent cards that this blk spans.
         if (start_index < end_index) {
-          HeapWord* rem_st = _array->address_for_index(start_index) + N_words;
-          HeapWord* rem_end = _array->address_for_index(end_index) + N_words;
+          HeapWord* rem_st = _array->address_for_index(start_index) + BOTConstants::N_words;
+          HeapWord* rem_end = _array->address_for_index(end_index) + BOTConstants::N_words;
           set_remainder_to_point_to_start(rem_st, rem_end, reducing);
         }
         break;
@@ -450,8 +450,8 @@
         bool more = true;
         uint i = 1;
         // Fix the first power block with  back_by > num_pref_cards.
-        while (more && (i < N_powers)) {
-          size_t back_by = power_to_cards_back(i);
+        while (more && (i < BOTConstants::N_powers)) {
+          size_t back_by = BOTConstants::power_to_cards_back(i);
           size_t right_index = suff_index + back_by - 1;
           size_t left_index  = right_index - num_pref_cards + 1;
           if (right_index >= end_index - 1) { // last iteration
@@ -466,7 +466,7 @@
             // is non-null.
             if (left_index <= right_index) {
               _array->set_offset_array(left_index, right_index,
-                                     N_words + i - 1, true /* reducing */);
+                                       BOTConstants::N_words + i - 1, true /* reducing */);
             } else {
               more = false; // we are done
               assert((end_index - 1) == right_index, "Must be at the end.");
@@ -477,8 +477,8 @@
           i++;
         }
         // Fix the rest of the power blocks.
-        while (more && (i < N_powers)) {
-          size_t back_by = power_to_cards_back(i);
+        while (more && (i < BOTConstants::N_powers)) {
+          size_t back_by = BOTConstants::power_to_cards_back(i);
           size_t right_index = suff_index + back_by - 1;
           size_t left_index  = right_index - num_pref_cards + 1;
           if (right_index >= end_index - 1) { // last iteration
@@ -489,7 +489,7 @@
             more  = false;
           }
           assert(left_index <= right_index, "Error");
-          _array->set_offset_array(left_index, right_index, N_words + i - 1, true /* reducing */);
+          _array->set_offset_array(left_index, right_index, BOTConstants::N_words + i - 1, true /* reducing */);
           i++;
         }
       }
@@ -530,11 +530,11 @@
   HeapWord* q = _array->address_for_index(index);
 
   uint offset = _array->offset_array(index);    // Extend u_char to uint.
-  while (offset >= N_words) {
+  while (offset >= BOTConstants::N_words) {
     // The excess of the offset from N_words indicates a power of Base
     // to go back by.
-    size_t n_cards_back = entry_to_cards_back(offset);
-    q -= (N_words * n_cards_back);
+    size_t n_cards_back = BOTConstants::entry_to_cards_back(offset);
+    q -= (BOTConstants::N_words * n_cards_back);
     assert(q >= _sp->bottom(),
            "q = " PTR_FORMAT " crossed below bottom = " PTR_FORMAT,
            p2i(q), p2i(_sp->bottom()));
@@ -544,7 +544,7 @@
     index -= n_cards_back;
     offset = _array->offset_array(index);
   }
-  assert(offset < N_words, "offset too large");
+  assert(offset < BOTConstants::N_words, "offset too large");
   index--;
   q -= offset;
   assert(q >= _sp->bottom(),
@@ -599,14 +599,14 @@
   uint offset;
   do {
     offset = _array->offset_array(index);
-    if (offset < N_words) {
+    if (offset < BOTConstants::N_words) {
       q -= offset;
     } else {
-      size_t n_cards_back = entry_to_cards_back(offset);
-      q -= (n_cards_back * N_words);
+      size_t n_cards_back = BOTConstants::entry_to_cards_back(offset);
+      q -= (n_cards_back * BOTConstants::N_words);
       index -= n_cards_back;
     }
-  } while (offset >= N_words);
+  } while (offset >= BOTConstants::N_words);
   assert(q <= addr, "block start should be to left of arg");
   return q;
 }
@@ -668,22 +668,22 @@
   HeapWord* q = _array->address_for_index(index);
 
   uint offset = _array->offset_array(index);    // Extend u_char to uint.
-  while (offset > N_words) {
+  while (offset > BOTConstants::N_words) {
     // The excess of the offset from N_words indicates a power of Base
     // to go back by.
-    size_t n_cards_back = entry_to_cards_back(offset);
-    q -= (N_words * n_cards_back);
+    size_t n_cards_back = BOTConstants::entry_to_cards_back(offset);
+    q -= (BOTConstants::N_words * n_cards_back);
     assert(q >= _sp->bottom(), "Went below bottom!");
     index -= n_cards_back;
     offset = _array->offset_array(index);
   }
-  while (offset == N_words) {
+  while (offset == BOTConstants::N_words) {
     assert(q >= _sp->bottom(), "Went below bottom!");
-    q -= N_words;
+    q -= BOTConstants::N_words;
     index--;
     offset = _array->offset_array(index);
   }
-  assert(offset < N_words, "offset too large");
+  assert(offset < BOTConstants::N_words, "offset too large");
   q -= offset;
   HeapWord* n = q;
 
@@ -716,14 +716,14 @@
          "should be past threshold");
   assert(blk_start <= _next_offset_threshold,
          "blk_start should be at or before threshold");
-  assert(pointer_delta(_next_offset_threshold, blk_start) <= N_words,
+  assert(pointer_delta(_next_offset_threshold, blk_start) <= BOTConstants::N_words,
          "offset should be <= BlockOffsetSharedArray::N");
   assert(Universe::heap()->is_in_reserved(blk_start),
          "reference must be into the heap");
   assert(Universe::heap()->is_in_reserved(blk_end-1),
          "limit must be within the heap");
   assert(_next_offset_threshold ==
-         _array->_reserved.start() + _next_offset_index*N_words,
+         _array->_reserved.start() + _next_offset_index*BOTConstants::N_words,
          "index must agree with threshold");
 
   debug_only(size_t orig_next_offset_index = _next_offset_index;)
@@ -745,7 +745,7 @@
     HeapWord* rem_st  = _array->address_for_index(_next_offset_index + 1);
     // Calculate rem_end this way because end_index
     // may be the last valid index in the covered region.
-    HeapWord* rem_end = _array->address_for_index(end_index) +  N_words;
+    HeapWord* rem_end = _array->address_for_index(end_index) +  BOTConstants::N_words;
     set_remainder_to_point_to_start(rem_st, rem_end);
   }
 
@@ -753,7 +753,7 @@
   _next_offset_index = end_index + 1;
   // Calculate _next_offset_threshold this way because end_index
   // may be the last valid index in the covered region.
-  _next_offset_threshold = _array->address_for_index(end_index) + N_words;
+  _next_offset_threshold = _array->address_for_index(end_index) + BOTConstants::N_words;
   assert(_next_offset_threshold >= blk_end, "Incorrect offset threshold");
 
 #ifdef ASSERT
@@ -764,11 +764,11 @@
   assert((_array->offset_array(orig_next_offset_index) == 0 &&
           blk_start == boundary) ||
           (_array->offset_array(orig_next_offset_index) > 0 &&
-         _array->offset_array(orig_next_offset_index) <= N_words),
+         _array->offset_array(orig_next_offset_index) <= BOTConstants::N_words),
          "offset array should have been set");
   for (size_t j = orig_next_offset_index + 1; j <= end_index; j++) {
     assert(_array->offset_array(j) > 0 &&
-           _array->offset_array(j) <= (u_char) (N_words+N_powers-1),
+           _array->offset_array(j) <= (u_char) (BOTConstants::N_words+BOTConstants::N_powers-1),
            "offset array should have been set");
   }
 #endif