--- a/hotspot/src/share/vm/gc_interface/collectedHeap.cpp Wed Dec 10 23:46:10 2008 -0800
+++ b/hotspot/src/share/vm/gc_interface/collectedHeap.cpp Thu Dec 11 12:05:08 2008 -0800
@@ -30,12 +30,21 @@
int CollectedHeap::_fire_out_of_memory_count = 0;
#endif
+size_t CollectedHeap::_filler_array_max_size = 0;
+
// Memory state functions.
-CollectedHeap::CollectedHeap() :
- _reserved(), _barrier_set(NULL), _is_gc_active(false),
- _total_collections(0), _total_full_collections(0),
- _gc_cause(GCCause::_no_gc), _gc_lastcause(GCCause::_no_gc) {
+CollectedHeap::CollectedHeap()
+{
+ const size_t max_len = size_t(arrayOopDesc::max_array_length(T_INT));
+ const size_t elements_per_word = HeapWordSize / sizeof(jint);
+ _filler_array_max_size = align_object_size(filler_array_hdr_size() +
+ max_len * elements_per_word);
+
+ _barrier_set = NULL;
+ _is_gc_active = false;
+ _total_collections = _total_full_collections = 0;
+ _gc_cause = _gc_lastcause = GCCause::_no_gc;
NOT_PRODUCT(_promotion_failure_alot_count = 0;)
NOT_PRODUCT(_promotion_failure_alot_gc_number = 0;)
@@ -128,6 +137,95 @@
return obj;
}
+size_t CollectedHeap::filler_array_hdr_size() {
+ return size_t(arrayOopDesc::header_size(T_INT));
+}
+
+size_t CollectedHeap::filler_array_min_size() {
+ return align_object_size(filler_array_hdr_size());
+}
+
+size_t CollectedHeap::filler_array_max_size() {
+ return _filler_array_max_size;
+}
+
+#ifdef ASSERT
+void CollectedHeap::fill_args_check(HeapWord* start, size_t words)
+{
+ assert(words >= min_fill_size(), "too small to fill");
+ assert(words % MinObjAlignment == 0, "unaligned size");
+ assert(Universe::heap()->is_in_reserved(start), "not in heap");
+ assert(Universe::heap()->is_in_reserved(start + words - 1), "not in heap");
+}
+
+void CollectedHeap::zap_filler_array(HeapWord* start, size_t words)
+{
+ if (ZapFillerObjects) {
+ Copy::fill_to_words(start + filler_array_hdr_size(),
+ words - filler_array_hdr_size(), 0XDEAFBABE);
+ }
+}
+#endif // ASSERT
+
+void
+CollectedHeap::fill_with_array(HeapWord* start, size_t words)
+{
+ assert(words >= filler_array_min_size(), "too small for an array");
+ assert(words <= filler_array_max_size(), "too big for a single object");
+
+ const size_t payload_size = words - filler_array_hdr_size();
+ const size_t len = payload_size * HeapWordSize / sizeof(jint);
+
+ // Set the length first for concurrent GC.
+ ((arrayOop)start)->set_length((int)len);
+ post_allocation_setup_common(Universe::fillerArrayKlassObj(), start,
+ words);
+ DEBUG_ONLY(zap_filler_array(start, words);)
+}
+
+void
+CollectedHeap::fill_with_object_impl(HeapWord* start, size_t words)
+{
+ assert(words <= filler_array_max_size(), "too big for a single object");
+
+ if (words >= filler_array_min_size()) {
+ fill_with_array(start, words);
+ } else if (words > 0) {
+ assert(words == min_fill_size(), "unaligned size");
+ post_allocation_setup_common(SystemDictionary::object_klass(), start,
+ words);
+ }
+}
+
+void CollectedHeap::fill_with_object(HeapWord* start, size_t words)
+{
+ DEBUG_ONLY(fill_args_check(start, words);)
+ HandleMark hm; // Free handles before leaving.
+ fill_with_object_impl(start, words);
+}
+
+void CollectedHeap::fill_with_objects(HeapWord* start, size_t words)
+{
+ DEBUG_ONLY(fill_args_check(start, words);)
+ HandleMark hm; // Free handles before leaving.
+
+#ifdef LP64
+ // A single array can fill ~8G, so multiple objects are needed only in 64-bit.
+ // First fill with arrays, ensuring that any remaining space is big enough to
+ // fill. The remainder is filled with a single object.
+ const size_t min = min_fill_size();
+ const size_t max = filler_array_max_size();
+ while (words > max) {
+ const size_t cur = words - max >= min ? max : max - min;
+ fill_with_array(start, cur);
+ start += cur;
+ words -= cur;
+ }
+#endif
+
+ fill_with_object_impl(start, words);
+}
+
oop CollectedHeap::new_store_barrier(oop new_obj) {
// %%% This needs refactoring. (It was imported from the server compiler.)
guarantee(can_elide_tlab_store_barriers(), "store barrier elision not supported");