hotspot/src/share/vm/gc_interface/collectedHeap.cpp
author jcoomes
Thu, 18 Dec 2008 01:27:04 -0800
changeset 1681 9df064a8f4ca
parent 1668 8ec481b8f514
child 2141 e9a644aaff87
child 2105 347008ce7984
permissions -rw-r--r--
6786195: many nsk.monitoring tests fail with -server -Xcomp Summary: remove Universe::_fillerArrayKlassObj and associated code Reviewed-by: jmasa, tonyp
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
670
ddf3e9583f2f 6719955: Update copyright year
xdono
parents: 360
diff changeset
     2
 * Copyright 2001-2008 Sun Microsystems, Inc.  All Rights Reserved.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     3
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     4
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     5
 * This code is free software; you can redistribute it and/or modify it
489c9b5090e2 Initial load
duke
parents:
diff changeset
     6
 * under the terms of the GNU General Public License version 2 only, as
489c9b5090e2 Initial load
duke
parents:
diff changeset
     7
 * published by the Free Software Foundation.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     8
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     9
 * This code is distributed in the hope that it will be useful, but WITHOUT
489c9b5090e2 Initial load
duke
parents:
diff changeset
    10
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
489c9b5090e2 Initial load
duke
parents:
diff changeset
    11
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
489c9b5090e2 Initial load
duke
parents:
diff changeset
    12
 * version 2 for more details (a copy is included in the LICENSE file that
489c9b5090e2 Initial load
duke
parents:
diff changeset
    13
 * accompanied this code).
489c9b5090e2 Initial load
duke
parents:
diff changeset
    14
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    15
 * You should have received a copy of the GNU General Public License version
489c9b5090e2 Initial load
duke
parents:
diff changeset
    16
 * 2 along with this work; if not, write to the Free Software Foundation,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    17
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    18
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    19
 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    20
 * CA 95054 USA or visit www.sun.com if you need additional information or
489c9b5090e2 Initial load
duke
parents:
diff changeset
    21
 * have any questions.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    22
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    23
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
    24
489c9b5090e2 Initial load
duke
parents:
diff changeset
    25
# include "incls/_precompiled.incl"
489c9b5090e2 Initial load
duke
parents:
diff changeset
    26
# include "incls/_collectedHeap.cpp.incl"
489c9b5090e2 Initial load
duke
parents:
diff changeset
    27
489c9b5090e2 Initial load
duke
parents:
diff changeset
    28
489c9b5090e2 Initial load
duke
parents:
diff changeset
    29
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
    30
int CollectedHeap::_fire_out_of_memory_count = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    31
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
    32
1668
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
    33
size_t CollectedHeap::_filler_array_max_size = 0;
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
    34
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    35
// Memory state functions.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    36
1668
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
    37
CollectedHeap::CollectedHeap()
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
    38
{
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
    39
  const size_t max_len = size_t(arrayOopDesc::max_array_length(T_INT));
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
    40
  const size_t elements_per_word = HeapWordSize / sizeof(jint);
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
    41
  _filler_array_max_size = align_object_size(filler_array_hdr_size() +
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
    42
                                             max_len * elements_per_word);
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
    43
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
    44
  _barrier_set = NULL;
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
    45
  _is_gc_active = false;
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
    46
  _total_collections = _total_full_collections = 0;
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
    47
  _gc_cause = _gc_lastcause = GCCause::_no_gc;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    48
  NOT_PRODUCT(_promotion_failure_alot_count = 0;)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    49
  NOT_PRODUCT(_promotion_failure_alot_gc_number = 0;)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    50
489c9b5090e2 Initial load
duke
parents:
diff changeset
    51
  if (UsePerfData) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    52
    EXCEPTION_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    53
489c9b5090e2 Initial load
duke
parents:
diff changeset
    54
    // create the gc cause jvmstat counters
489c9b5090e2 Initial load
duke
parents:
diff changeset
    55
    _perf_gc_cause = PerfDataManager::create_string_variable(SUN_GC, "cause",
489c9b5090e2 Initial load
duke
parents:
diff changeset
    56
                             80, GCCause::to_string(_gc_cause), CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    57
489c9b5090e2 Initial load
duke
parents:
diff changeset
    58
    _perf_gc_lastcause =
489c9b5090e2 Initial load
duke
parents:
diff changeset
    59
                PerfDataManager::create_string_variable(SUN_GC, "lastCause",
489c9b5090e2 Initial load
duke
parents:
diff changeset
    60
                             80, GCCause::to_string(_gc_lastcause), CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    61
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    62
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    63
489c9b5090e2 Initial load
duke
parents:
diff changeset
    64
489c9b5090e2 Initial load
duke
parents:
diff changeset
    65
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
    66
void CollectedHeap::check_for_bad_heap_word_value(HeapWord* addr, size_t size) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    67
  if (CheckMemoryInitialization && ZapUnusedHeapArea) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    68
    for (size_t slot = 0; slot < size; slot += 1) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    69
      assert((*(intptr_t*) (addr + slot)) != ((intptr_t) badHeapWordVal),
489c9b5090e2 Initial load
duke
parents:
diff changeset
    70
             "Found badHeapWordValue in post-allocation check");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    71
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    72
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    73
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    74
489c9b5090e2 Initial load
duke
parents:
diff changeset
    75
void CollectedHeap::check_for_non_bad_heap_word_value(HeapWord* addr, size_t size)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    76
 {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    77
  if (CheckMemoryInitialization && ZapUnusedHeapArea) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    78
    for (size_t slot = 0; slot < size; slot += 1) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    79
      assert((*(intptr_t*) (addr + slot)) == ((intptr_t) badHeapWordVal),
489c9b5090e2 Initial load
duke
parents:
diff changeset
    80
             "Found non badHeapWordValue in pre-allocation check");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    81
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    82
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    83
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    84
#endif // PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
    85
489c9b5090e2 Initial load
duke
parents:
diff changeset
    86
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
    87
void CollectedHeap::check_for_valid_allocation_state() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    88
  Thread *thread = Thread::current();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    89
  // How to choose between a pending exception and a potential
489c9b5090e2 Initial load
duke
parents:
diff changeset
    90
  // OutOfMemoryError?  Don't allow pending exceptions.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    91
  // This is a VM policy failure, so how do we exhaustively test it?
489c9b5090e2 Initial load
duke
parents:
diff changeset
    92
  assert(!thread->has_pending_exception(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
    93
         "shouldn't be allocating with pending exception");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    94
  if (StrictSafepointChecks) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    95
    assert(thread->allow_allocation(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
    96
           "Allocation done by thread for which allocation is blocked "
489c9b5090e2 Initial load
duke
parents:
diff changeset
    97
           "by No_Allocation_Verifier!");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    98
    // Allocation of an oop can always invoke a safepoint,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    99
    // hence, the true argument
489c9b5090e2 Initial load
duke
parents:
diff changeset
   100
    thread->check_for_valid_safepoint_state(true);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   101
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   102
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   103
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   104
489c9b5090e2 Initial load
duke
parents:
diff changeset
   105
HeapWord* CollectedHeap::allocate_from_tlab_slow(Thread* thread, size_t size) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   106
489c9b5090e2 Initial load
duke
parents:
diff changeset
   107
  // Retain tlab and allocate object in shared space if
489c9b5090e2 Initial load
duke
parents:
diff changeset
   108
  // the amount free in the tlab is too large to discard.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   109
  if (thread->tlab().free() > thread->tlab().refill_waste_limit()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   110
    thread->tlab().record_slow_allocation(size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   111
    return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   112
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   113
489c9b5090e2 Initial load
duke
parents:
diff changeset
   114
  // Discard tlab and allocate a new one.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   115
  // To minimize fragmentation, the last TLAB may be smaller than the rest.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   116
  size_t new_tlab_size = thread->tlab().compute_size(size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   117
489c9b5090e2 Initial load
duke
parents:
diff changeset
   118
  thread->tlab().clear_before_allocation();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   119
489c9b5090e2 Initial load
duke
parents:
diff changeset
   120
  if (new_tlab_size == 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   121
    return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   122
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   123
489c9b5090e2 Initial load
duke
parents:
diff changeset
   124
  // Allocate a new TLAB...
489c9b5090e2 Initial load
duke
parents:
diff changeset
   125
  HeapWord* obj = Universe::heap()->allocate_new_tlab(new_tlab_size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   126
  if (obj == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   127
    return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   128
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   129
  if (ZeroTLAB) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   130
    // ..and clear it.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   131
    Copy::zero_to_words(obj, new_tlab_size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   132
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   133
    // ...and clear just the allocated object.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   134
    Copy::zero_to_words(obj, size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   135
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   136
  thread->tlab().fill(obj, obj + size, new_tlab_size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   137
  return obj;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   138
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   139
1668
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   140
size_t CollectedHeap::filler_array_hdr_size() {
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   141
  return size_t(arrayOopDesc::header_size(T_INT));
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   142
}
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   143
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   144
size_t CollectedHeap::filler_array_min_size() {
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   145
  return align_object_size(filler_array_hdr_size());
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   146
}
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   147
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   148
size_t CollectedHeap::filler_array_max_size() {
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   149
  return _filler_array_max_size;
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   150
}
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   151
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   152
#ifdef ASSERT
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   153
void CollectedHeap::fill_args_check(HeapWord* start, size_t words)
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   154
{
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   155
  assert(words >= min_fill_size(), "too small to fill");
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   156
  assert(words % MinObjAlignment == 0, "unaligned size");
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   157
  assert(Universe::heap()->is_in_reserved(start), "not in heap");
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   158
  assert(Universe::heap()->is_in_reserved(start + words - 1), "not in heap");
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   159
}
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   160
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   161
void CollectedHeap::zap_filler_array(HeapWord* start, size_t words)
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   162
{
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   163
  if (ZapFillerObjects) {
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   164
    Copy::fill_to_words(start + filler_array_hdr_size(),
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   165
                        words - filler_array_hdr_size(), 0XDEAFBABE);
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   166
  }
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   167
}
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   168
#endif // ASSERT
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   169
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   170
void
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   171
CollectedHeap::fill_with_array(HeapWord* start, size_t words)
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   172
{
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   173
  assert(words >= filler_array_min_size(), "too small for an array");
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   174
  assert(words <= filler_array_max_size(), "too big for a single object");
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   175
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   176
  const size_t payload_size = words - filler_array_hdr_size();
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   177
  const size_t len = payload_size * HeapWordSize / sizeof(jint);
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   178
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   179
  // Set the length first for concurrent GC.
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   180
  ((arrayOop)start)->set_length((int)len);
1681
9df064a8f4ca 6786195: many nsk.monitoring tests fail with -server -Xcomp
jcoomes
parents: 1668
diff changeset
   181
  post_allocation_setup_common(Universe::intArrayKlassObj(), start, words);
1668
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   182
  DEBUG_ONLY(zap_filler_array(start, words);)
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   183
}
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   184
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   185
void
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   186
CollectedHeap::fill_with_object_impl(HeapWord* start, size_t words)
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   187
{
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   188
  assert(words <= filler_array_max_size(), "too big for a single object");
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   189
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   190
  if (words >= filler_array_min_size()) {
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   191
    fill_with_array(start, words);
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   192
  } else if (words > 0) {
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   193
    assert(words == min_fill_size(), "unaligned size");
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   194
    post_allocation_setup_common(SystemDictionary::object_klass(), start,
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   195
                                 words);
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   196
  }
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   197
}
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   198
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   199
void CollectedHeap::fill_with_object(HeapWord* start, size_t words)
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   200
{
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   201
  DEBUG_ONLY(fill_args_check(start, words);)
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   202
  HandleMark hm;  // Free handles before leaving.
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   203
  fill_with_object_impl(start, words);
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   204
}
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   205
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   206
void CollectedHeap::fill_with_objects(HeapWord* start, size_t words)
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   207
{
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   208
  DEBUG_ONLY(fill_args_check(start, words);)
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   209
  HandleMark hm;  // Free handles before leaving.
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   210
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   211
#ifdef LP64
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   212
  // A single array can fill ~8G, so multiple objects are needed only in 64-bit.
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   213
  // First fill with arrays, ensuring that any remaining space is big enough to
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   214
  // fill.  The remainder is filled with a single object.
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   215
  const size_t min = min_fill_size();
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   216
  const size_t max = filler_array_max_size();
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   217
  while (words > max) {
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   218
    const size_t cur = words - max >= min ? max : max - min;
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   219
    fill_with_array(start, cur);
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   220
    start += cur;
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   221
    words -= cur;
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   222
  }
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   223
#endif
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   224
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   225
  fill_with_object_impl(start, words);
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   226
}
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   227
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   228
oop CollectedHeap::new_store_barrier(oop new_obj) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   229
  // %%% This needs refactoring.  (It was imported from the server compiler.)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   230
  guarantee(can_elide_tlab_store_barriers(), "store barrier elision not supported");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   231
  BarrierSet* bs = this->barrier_set();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   232
  assert(bs->has_write_region_opt(), "Barrier set does not have write_region");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   233
  int new_size = new_obj->size();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   234
  bs->write_region(MemRegion((HeapWord*)new_obj, new_size));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   235
  return new_obj;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   236
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   237
489c9b5090e2 Initial load
duke
parents:
diff changeset
   238
HeapWord* CollectedHeap::allocate_new_tlab(size_t size) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   239
  guarantee(false, "thread-local allocation buffers not supported");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   240
  return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   241
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   242
489c9b5090e2 Initial load
duke
parents:
diff changeset
   243
void CollectedHeap::fill_all_tlabs(bool retire) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   244
  assert(UseTLAB, "should not reach here");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   245
  // See note in ensure_parsability() below.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   246
  assert(SafepointSynchronize::is_at_safepoint() ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
   247
         !is_init_completed(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   248
         "should only fill tlabs at safepoint");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   249
  // The main thread starts allocating via a TLAB even before it
489c9b5090e2 Initial load
duke
parents:
diff changeset
   250
  // has added itself to the threads list at vm boot-up.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   251
  assert(Threads::first() != NULL,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   252
         "Attempt to fill tlabs before main thread has been added"
489c9b5090e2 Initial load
duke
parents:
diff changeset
   253
         " to threads list is doomed to failure!");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   254
  for(JavaThread *thread = Threads::first(); thread; thread = thread->next()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   255
     thread->tlab().make_parsable(retire);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   256
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   257
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   258
489c9b5090e2 Initial load
duke
parents:
diff changeset
   259
void CollectedHeap::ensure_parsability(bool retire_tlabs) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   260
  // The second disjunct in the assertion below makes a concession
489c9b5090e2 Initial load
duke
parents:
diff changeset
   261
  // for the start-up verification done while the VM is being
489c9b5090e2 Initial load
duke
parents:
diff changeset
   262
  // created. Callers be careful that you know that mutators
489c9b5090e2 Initial load
duke
parents:
diff changeset
   263
  // aren't going to interfere -- for instance, this is permissible
489c9b5090e2 Initial load
duke
parents:
diff changeset
   264
  // if we are still single-threaded and have either not yet
489c9b5090e2 Initial load
duke
parents:
diff changeset
   265
  // started allocating (nothing much to verify) or we have
489c9b5090e2 Initial load
duke
parents:
diff changeset
   266
  // started allocating but are now a full-fledged JavaThread
489c9b5090e2 Initial load
duke
parents:
diff changeset
   267
  // (and have thus made our TLAB's) available for filling.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   268
  assert(SafepointSynchronize::is_at_safepoint() ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
   269
         !is_init_completed(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   270
         "Should only be called at a safepoint or at start-up"
489c9b5090e2 Initial load
duke
parents:
diff changeset
   271
         " otherwise concurrent mutator activity may make heap "
489c9b5090e2 Initial load
duke
parents:
diff changeset
   272
         " unparsable again");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   273
  if (UseTLAB) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   274
    fill_all_tlabs(retire_tlabs);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   275
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   276
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   277
489c9b5090e2 Initial load
duke
parents:
diff changeset
   278
void CollectedHeap::accumulate_statistics_all_tlabs() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   279
  if (UseTLAB) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   280
    assert(SafepointSynchronize::is_at_safepoint() ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
   281
         !is_init_completed(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   282
         "should only accumulate statistics on tlabs at safepoint");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   283
489c9b5090e2 Initial load
duke
parents:
diff changeset
   284
    ThreadLocalAllocBuffer::accumulate_statistics_before_gc();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   285
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   286
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   287
489c9b5090e2 Initial load
duke
parents:
diff changeset
   288
void CollectedHeap::resize_all_tlabs() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   289
  if (UseTLAB) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   290
    assert(SafepointSynchronize::is_at_safepoint() ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
   291
         !is_init_completed(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   292
         "should only resize tlabs at safepoint");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   293
489c9b5090e2 Initial load
duke
parents:
diff changeset
   294
    ThreadLocalAllocBuffer::resize_all_tlabs();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   295
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   296
}