src/share/vm/services/memReporter.cpp
Index Unified diffs Context diffs Sdiffs Wdiffs Patch New Old Previous File Next File hotspot Sdiff src/share/vm/services

src/share/vm/services/memReporter.cpp

Print this page




 173   _outputer.done_category_summary();
 174 }
 175 
 176 void BaselineReporter::diff_callsites(const MemBaseline& cur, const MemBaseline& prev) {
 177   _outputer.start_callsite();
 178   MemBaseline* pBL_cur = const_cast<MemBaseline*>(&cur);
 179   MemBaseline* pBL_prev = const_cast<MemBaseline*>(&prev);
 180 
 181   // walk malloc callsites
 182   MemPointerArrayIteratorImpl cur_malloc_itr(pBL_cur->_malloc_cs);
 183   MemPointerArrayIteratorImpl prev_malloc_itr(pBL_prev->_malloc_cs);
 184 
 185   MallocCallsitePointer*      cur_malloc_callsite =
 186                   (MallocCallsitePointer*)cur_malloc_itr.current();
 187   MallocCallsitePointer*      prev_malloc_callsite =
 188                   (MallocCallsitePointer*)prev_malloc_itr.current();
 189 
 190   while (cur_malloc_callsite != NULL || prev_malloc_callsite != NULL) {
 191     if (prev_malloc_callsite == NULL ||
 192         cur_malloc_callsite->addr() < prev_malloc_callsite->addr()) {

 193       _outputer.diff_malloc_callsite(cur_malloc_callsite->addr(),
 194         amount_in_current_scale(cur_malloc_callsite->amount()),
 195         cur_malloc_callsite->count(),
 196         diff_in_current_scale(cur_malloc_callsite->amount(), 0),
 197         diff(cur_malloc_callsite->count(), 0));
 198       cur_malloc_callsite = (MallocCallsitePointer*)cur_malloc_itr.next();
 199     } else if (prev_malloc_callsite == NULL ||
 200                cur_malloc_callsite->addr() > prev_malloc_callsite->addr()) {
 201       _outputer.diff_malloc_callsite(cur_malloc_callsite->addr(),
 202         amount_in_current_scale(prev_malloc_callsite->amount()),
 203         prev_malloc_callsite->count(),
 204         diff_in_current_scale(0, prev_malloc_callsite->amount()),
 205         diff(0, prev_malloc_callsite->count()));
 206       prev_malloc_callsite = (MallocCallsitePointer*)prev_malloc_itr.next();
 207     } else {  // the same callsite
 208       _outputer.diff_malloc_callsite(cur_malloc_callsite->addr(),
 209         amount_in_current_scale(cur_malloc_callsite->amount()),
 210         cur_malloc_callsite->count(),
 211         diff_in_current_scale(cur_malloc_callsite->amount(), prev_malloc_callsite->amount()),
 212         diff(cur_malloc_callsite->count(), prev_malloc_callsite->count()));
 213       cur_malloc_callsite = (MallocCallsitePointer*)cur_malloc_itr.next();
 214       prev_malloc_callsite = (MallocCallsitePointer*)prev_malloc_itr.next();
 215     }
 216   }
 217 
 218   // walk virtual memory callsite
 219   MemPointerArrayIteratorImpl cur_vm_itr(pBL_cur->_vm_cs);
 220   MemPointerArrayIteratorImpl prev_vm_itr(pBL_prev->_vm_cs);
 221   VMCallsitePointer*          cur_vm_callsite = (VMCallsitePointer*)cur_vm_itr.current();
 222   VMCallsitePointer*          prev_vm_callsite = (VMCallsitePointer*)prev_vm_itr.current();
 223   while (cur_vm_callsite != NULL || prev_vm_callsite != NULL) {
 224     if (prev_vm_callsite == NULL || cur_vm_callsite->addr() < prev_vm_callsite->addr()) {

 225       _outputer.diff_virtual_memory_callsite(cur_vm_callsite->addr(),
 226         amount_in_current_scale(cur_vm_callsite->reserved_amount()),
 227         amount_in_current_scale(cur_vm_callsite->committed_amount()),
 228         diff_in_current_scale(cur_vm_callsite->reserved_amount(), 0),
 229         diff_in_current_scale(cur_vm_callsite->committed_amount(), 0));
 230       cur_vm_callsite = (VMCallsitePointer*)cur_vm_itr.next();
 231     } else if (cur_vm_callsite == NULL || cur_vm_callsite->addr() > prev_vm_callsite->addr()) {

 232       _outputer.diff_virtual_memory_callsite(prev_vm_callsite->addr(),
 233         amount_in_current_scale(prev_vm_callsite->reserved_amount()),
 234         amount_in_current_scale(prev_vm_callsite->committed_amount()),
 235         diff_in_current_scale(0, prev_vm_callsite->reserved_amount()),
 236         diff_in_current_scale(0, prev_vm_callsite->committed_amount()));
 237       prev_vm_callsite = (VMCallsitePointer*)prev_vm_itr.next();
 238     } else { // the same callsite
 239       _outputer.diff_virtual_memory_callsite(cur_vm_callsite->addr(),
 240         amount_in_current_scale(cur_vm_callsite->reserved_amount()),
 241         amount_in_current_scale(cur_vm_callsite->committed_amount()),
 242         diff_in_current_scale(cur_vm_callsite->reserved_amount(), prev_vm_callsite->reserved_amount()),
 243         diff_in_current_scale(cur_vm_callsite->committed_amount(), prev_vm_callsite->committed_amount()));
 244       cur_vm_callsite  = (VMCallsitePointer*)cur_vm_itr.next();
 245       prev_vm_callsite = (VMCallsitePointer*)prev_vm_itr.next();
 246     }
 247   }
 248 
 249   _outputer.done_callsite();
 250 }
 251 
 252 size_t BaselineReporter::amount_in_current_scale(size_t amt) const {
 253   return (size_t)(((float)amt/(float)_scale) + 0.5);
 254 }




 173   _outputer.done_category_summary();
 174 }
 175 
 176 void BaselineReporter::diff_callsites(const MemBaseline& cur, const MemBaseline& prev) {
 177   _outputer.start_callsite();
 178   MemBaseline* pBL_cur = const_cast<MemBaseline*>(&cur);
 179   MemBaseline* pBL_prev = const_cast<MemBaseline*>(&prev);
 180 
 181   // walk malloc callsites
 182   MemPointerArrayIteratorImpl cur_malloc_itr(pBL_cur->_malloc_cs);
 183   MemPointerArrayIteratorImpl prev_malloc_itr(pBL_prev->_malloc_cs);
 184 
 185   MallocCallsitePointer*      cur_malloc_callsite =
 186                   (MallocCallsitePointer*)cur_malloc_itr.current();
 187   MallocCallsitePointer*      prev_malloc_callsite =
 188                   (MallocCallsitePointer*)prev_malloc_itr.current();
 189 
 190   while (cur_malloc_callsite != NULL || prev_malloc_callsite != NULL) {
 191     if (prev_malloc_callsite == NULL ||
 192         cur_malloc_callsite->addr() < prev_malloc_callsite->addr()) {
 193       // this is a new callsite
 194       _outputer.diff_malloc_callsite(cur_malloc_callsite->addr(),
 195         amount_in_current_scale(cur_malloc_callsite->amount()),
 196         cur_malloc_callsite->count(),
 197         diff_in_current_scale(cur_malloc_callsite->amount(), 0),
 198         diff(cur_malloc_callsite->count(), 0));
 199       cur_malloc_callsite = (MallocCallsitePointer*)cur_malloc_itr.next();
 200     } else if (cur_malloc_callsite == NULL ||
 201                cur_malloc_callsite->addr() > prev_malloc_callsite->addr()) {
 202       // this callsite is already gone
 203       _outputer.diff_malloc_callsite(prev_malloc_callsite->addr(),
 204         amount_in_current_scale(0), 0,
 205         diff_in_current_scale(0, prev_malloc_callsite->amount()),
 206         diff(0, prev_malloc_callsite->count()));
 207       prev_malloc_callsite = (MallocCallsitePointer*)prev_malloc_itr.next();
 208     } else {  // the same callsite
 209       _outputer.diff_malloc_callsite(cur_malloc_callsite->addr(),
 210         amount_in_current_scale(cur_malloc_callsite->amount()),
 211         cur_malloc_callsite->count(),
 212         diff_in_current_scale(cur_malloc_callsite->amount(), prev_malloc_callsite->amount()),
 213         diff(cur_malloc_callsite->count(), prev_malloc_callsite->count()));
 214       cur_malloc_callsite = (MallocCallsitePointer*)cur_malloc_itr.next();
 215       prev_malloc_callsite = (MallocCallsitePointer*)prev_malloc_itr.next();
 216     }
 217   }
 218 
 219   // walk virtual memory callsite
 220   MemPointerArrayIteratorImpl cur_vm_itr(pBL_cur->_vm_cs);
 221   MemPointerArrayIteratorImpl prev_vm_itr(pBL_prev->_vm_cs);
 222   VMCallsitePointer*          cur_vm_callsite = (VMCallsitePointer*)cur_vm_itr.current();
 223   VMCallsitePointer*          prev_vm_callsite = (VMCallsitePointer*)prev_vm_itr.current();
 224   while (cur_vm_callsite != NULL || prev_vm_callsite != NULL) {
 225     if (prev_vm_callsite == NULL || cur_vm_callsite->addr() < prev_vm_callsite->addr()) {
 226       // this is a new callsite
 227       _outputer.diff_virtual_memory_callsite(cur_vm_callsite->addr(),
 228         amount_in_current_scale(cur_vm_callsite->reserved_amount()),
 229         amount_in_current_scale(cur_vm_callsite->committed_amount()),
 230         diff_in_current_scale(cur_vm_callsite->reserved_amount(), 0),
 231         diff_in_current_scale(cur_vm_callsite->committed_amount(), 0));
 232       cur_vm_callsite = (VMCallsitePointer*)cur_vm_itr.next();
 233     } else if (cur_vm_callsite == NULL || cur_vm_callsite->addr() > prev_vm_callsite->addr()) {
 234       // this callsite is already gone
 235       _outputer.diff_virtual_memory_callsite(prev_vm_callsite->addr(),
 236         amount_in_current_scale(0),
 237         amount_in_current_scale(0),
 238         diff_in_current_scale(0, prev_vm_callsite->reserved_amount()),
 239         diff_in_current_scale(0, prev_vm_callsite->committed_amount()));
 240       prev_vm_callsite = (VMCallsitePointer*)prev_vm_itr.next();
 241     } else { // the same callsite
 242       _outputer.diff_virtual_memory_callsite(cur_vm_callsite->addr(),
 243         amount_in_current_scale(cur_vm_callsite->reserved_amount()),
 244         amount_in_current_scale(cur_vm_callsite->committed_amount()),
 245         diff_in_current_scale(cur_vm_callsite->reserved_amount(), prev_vm_callsite->reserved_amount()),
 246         diff_in_current_scale(cur_vm_callsite->committed_amount(), prev_vm_callsite->committed_amount()));
 247       cur_vm_callsite  = (VMCallsitePointer*)cur_vm_itr.next();
 248       prev_vm_callsite = (VMCallsitePointer*)prev_vm_itr.next();
 249     }
 250   }
 251 
 252   _outputer.done_callsite();
 253 }
 254 
 255 size_t BaselineReporter::amount_in_current_scale(size_t amt) const {
 256   return (size_t)(((float)amt/(float)_scale) + 0.5);
 257 }


src/share/vm/services/memReporter.cpp
Index Unified diffs Context diffs Sdiffs Wdiffs Patch New Old Previous File Next File