inline void GCTraceTimeImpl::log_stop(jlong start_counter, jlong stop_counter) {
double duration_in_ms = TimeHelper::counter_to_millis(stop_counter - start_counter);
double start_time_in_secs = TimeHelper::counter_to_seconds(start_counter);
double stop_time_in_secs = TimeHelper::counter_to_seconds(stop_counter);
LogStream out(_out_stop);
out.print("%s", _title);
if (_gc_cause != GCCause::_no_gc) {
out.print(" (%s)", GCCause::to_string(_gc_cause));
}
if (_heap_usage_before != SIZE_MAX) {
CollectedHeap* heap = Universe::heap();
size_t used_before_m = _heap_usage_before / M;
size_t used_m = heap->used() / M;
size_t capacity_m = heap->capacity() / M;
out.print(" " LOG_STOP_HEAP_FORMAT, used_before_m, used_m, capacity_m);
}
out.print_cr(" " LOG_STOP_TIME_FORMAT, start_time_in_secs, stop_time_in_secs, duration_in_ms);
}
void SharedUserData::task(){
#ifdef AZ_PROXIED
// Static variables store peak values seen during the life of the run.
static volatile sud_jvm_heap_rev1_t peak_jvm_heap;
static sud_io_rev1_t io_stats;
static volatile bool initialized = false;
if (!initialized) {
memset ((void*)(&peak_jvm_heap), 0, sizeof(peak_jvm_heap));
initialized = true;
}
if (SafepointSynchronize::is_at_safepoint()) return;
CollectedHeap *heap = Universe::heap();
if (!heap) return;
size_t l = heap->last_gc_live_bytes();
size_t u=heap->used();
size_t c = heap->capacity();
size_t m = heap->max_capacity();
size_t pu = heap->permanent_used();
size_t pc = heap->permanent_capacity();
// Make sure that the numbers make sense when graphing.
c = (u > c) ? u : c;
m = (c > m) ? c : m;
pc = (pu > pc) ? pu : pc;
sud_jvm_heap_rev1_t jvm_heap;
memset(&jvm_heap, 0, sizeof(jvm_heap));
jvm_heap.revision = SUD_JVM_HEAP_REVISION;
switch (heap->kind()) {
case CollectedHeap::GenCollectedHeap: strcpy(jvm_heap.name, "GenCollectedHeap"); break;
case CollectedHeap::ParallelScavengeHeap: strcpy(jvm_heap.name, "ParallelScavengeHeap"); break;
case CollectedHeap::PauselessHeap: strcpy(jvm_heap.name, "PauselessHeap"); break;
default: strcpy(jvm_heap.name, "");
}
if (heap->supports_tlab_allocation()) jvm_heap.flags |= SUD_JVM_HEAP_FLAG_TLAB_ALLOCATION;
if (heap->supports_inline_contig_alloc()) jvm_heap.flags |= SUD_JVM_HEAP_FLAG_INLINE_CONTIG_ALLOC;
uint64_t now = (uint64_t) os::javaTimeMillis();
jvm_heap.timestamp_ms = now;
jvm_heap.live_bytes = l;
jvm_heap.used_bytes = u;
jvm_heap.capacity_bytes = c;
jvm_heap.max_capacity_bytes = m;
jvm_heap.permanent_used_bytes = pu;
jvm_heap.permanent_capacity_bytes = pc;
jvm_heap.total_collections = heap->total_collections();
libos::AccountInfo ai;
az_allocid_t allocid = process_get_allocationid();
sys_return_t ret = ai.inspectProcess (allocid);
if (ret == SYSERR_NONE) {
// Copy memory_accounting information into the sud structure.
// Take care not to overflow the accounts past the maximum storable.
const account_info_t *account_info = ai.getAccountInfo();
uint64_t count =
(account_info->ac_count < SUD_MAX_ACCOUNTS) ?
account_info->ac_count :
SUD_MAX_ACCOUNTS;
jvm_heap.account_info.ac_count = count;
for (uint64_t i = 0; i < count; i++) {
jvm_heap.account_info.ac_array[i] = account_info->ac_array[i];
}
}
else {
warning("Failed to inspect memory accounting info (%d)",ret);
}
#define UPDATE_PEAK(struct_member,value) \
if (peak_jvm_heap.peak_ ## struct_member ## _bytes < value) { \
peak_jvm_heap.peak_ ## struct_member ## _bytes = value; \
peak_jvm_heap.peak_ ## struct_member ## _timestamp_ms = now; \
} \
jvm_heap.peak_ ## struct_member ## _bytes = peak_jvm_heap.peak_ ## struct_member ## _bytes; \
jvm_heap.peak_ ## struct_member ## _timestamp_ms = peak_jvm_heap.peak_ ## struct_member ## _timestamp_ms;
UPDATE_PEAK (live,l);
UPDATE_PEAK (used,u);
UPDATE_PEAK (capacity,c);
UPDATE_PEAK (max_capacity,m);
UPDATE_PEAK (permanent_used,pu);
UPDATE_PEAK (permanent_capacity,pc);
UPDATE_PEAK (allocated,ai.getAllocatedBytes());
UPDATE_PEAK (funded,ai.getFundedBytes());
UPDATE_PEAK (overdraft,ai.getOverdraftBytes());
UPDATE_PEAK (footprint,ai.getFootprintBytes());
UPDATE_PEAK (committed,ai.getCommittedBytes());
UPDATE_PEAK (grant,ai.getGrantBytes());
UPDATE_PEAK (allocated_from_committed,ai.getAllocatedFromCommittedBytes());
UPDATE_PEAK (default_allocated,ai.getDefaultAllocatedBytes());
UPDATE_PEAK (default_committed,ai.getDefaultCommittedBytes());
UPDATE_PEAK (default_footprint,ai.getDefaultFootprintBytes());
UPDATE_PEAK (default_grant,ai.getDefaultGrantBytes());
UPDATE_PEAK (heap_allocated,ai.getHeapAllocatedBytes());
UPDATE_PEAK (heap_committed,ai.getHeapCommittedBytes());
UPDATE_PEAK (heap_footprint,ai.getHeapFootprintBytes());
UPDATE_PEAK (heap_grant,ai.getHeapGrantBytes());
ret = shared_user_data_set_jvm_heap_rev1 (allocid, &jvm_heap);
if (ret != SYSERR_NONE) warning("Failed to set jvm_heap shared user data (%d)", ret);
memset ((void*)(&io_stats), 0, sizeof(io_stats));
io_stats.revision = SUD_IO_REVISION;
atcpn_stats_get_io_rev1(&io_stats);
ret = shared_user_data_set_io_rev1 (allocid, &io_stats);
if (ret != SYSERR_NONE) warning("Failed to set io_stats shared user data (%d)", ret);
#endif // AZ_PROXIED
}
