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 } |