< prev index next >
src/hotspot/share/gc/shared/collectedHeap.cpp
Print this page
rev 48551 : [mq]: heap8
rev 48552 : [mq]: heap10a
rev 48553 : [mq]: heap14_rebased
rev 48557 : [mq]: heap17
rev 48562 : [mq]: heap23
*** 36,45 ****
--- 36,46 ----
#include "logging/log.hpp"
#include "memory/metaspace.hpp"
#include "memory/resourceArea.hpp"
#include "oops/instanceMirrorKlass.hpp"
#include "oops/oop.inline.hpp"
+ #include "runtime/heapMonitoring.hpp"
#include "runtime/init.hpp"
#include "runtime/thread.inline.hpp"
#include "runtime/threadSMR.hpp"
#include "services/heapDumper.hpp"
#include "utilities/align.hpp"
*** 287,297 ****
--- 288,335 ----
thread->check_for_valid_safepoint_state(true);
}
}
#endif
+
+ void CollectedHeap::sample_allocation(Thread* thread, HeapWord* obj,
+ size_t size, size_t overflowed_words) {
+ // Object is allocated, sample it now.
+ HeapMonitoring::object_alloc_do_sample(thread,
+ reinterpret_cast<oopDesc*>(obj),
+ size * HeapWordSize);
+ // Pick a next sample in this case, we allocated right.
+ thread->tlab().pick_next_sample(overflowed_words);
+ }
+
+ HeapWord* CollectedHeap::allocate_sampled_object(Thread* thread, size_t size) {
+ thread->tlab().set_back_allocation_end();
+
+ // The tlab could still have space after this sample.
+ return thread->tlab().allocate(size);
+ }
+
HeapWord* CollectedHeap::allocate_from_tlab_slow(Klass* klass, Thread* thread, size_t size) {
+ // In case the tlab changes, remember if this one wanted a sample.
+ bool should_sample = HeapMonitoring::enabled() && thread->tlab().should_sample();
+
+ HeapWord* obj = NULL;
+ if (should_sample) {
+ // Remember the tlab end to fix up the sampling rate.
+ HeapWord* tlab_old_end = thread->tlab().current_end();
+ obj = allocate_sampled_object(thread, size);
+
+ // If we did allocate in this tlab, sample it. Otherwise, we wait for the
+ // new tlab's first allocation at the end of this method.
+ if (obj != NULL) {
+ // Fix sample rate by removing the extra words allocated in this last
+ // sample.
+ size_t overflowed_words = pointer_delta(thread->tlab().top(), tlab_old_end);
+ sample_allocation(thread, obj, size, overflowed_words);
+ return obj;
+ }
+ }
// Retain tlab and allocate object in shared space if
// the amount free in the tlab is too large to discard.
if (thread->tlab().free() > thread->tlab().refill_waste_limit()) {
thread->tlab().record_slow_allocation(size);
*** 307,317 ****
if (new_tlab_size == 0) {
return NULL;
}
// Allocate a new TLAB...
! HeapWord* obj = Universe::heap()->allocate_new_tlab(new_tlab_size);
if (obj == NULL) {
return NULL;
}
AllocTracer::send_allocation_in_new_tlab(klass, obj, new_tlab_size * HeapWordSize, size * HeapWordSize, thread);
--- 345,355 ----
if (new_tlab_size == 0) {
return NULL;
}
// Allocate a new TLAB...
! obj = Universe::heap()->allocate_new_tlab(new_tlab_size);
if (obj == NULL) {
return NULL;
}
AllocTracer::send_allocation_in_new_tlab(klass, obj, new_tlab_size * HeapWordSize, size * HeapWordSize, thread);
*** 328,337 ****
--- 366,380 ----
size_t hdr_size = oopDesc::header_size();
Copy::fill_to_words(obj + hdr_size, new_tlab_size - hdr_size, badHeapWordVal);
#endif // ASSERT
}
thread->tlab().fill(obj, obj + size, new_tlab_size);
+
+ // Did we initially want to sample?
+ if (should_sample) {
+ sample_allocation(thread, obj, size);
+ }
return obj;
}
void CollectedHeap::flush_deferred_store_barrier(JavaThread* thread) {
MemRegion deferred = thread->deferred_card_mark();
< prev index next >