Mercurial > jdk8-mips64-public > hotspot / file comparison

comparison: src/share/vm/jfr/leakprofiler/checkpoint/objectSampleWriter.cpp

src/share/vm/jfr/leakprofiler/checkpoint/objectSampleWriter.cpp

changeset 9858
b985cbb00e68
child 9885
8e875c964f41
equal deleted inserted replaced
9727:c7a3e57fdf4a 9858:b985cbb00e68
1 /*
2 * Copyright (c) 2014, 2018, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25 #include "precompiled.hpp"
26 #include "jfrfiles/jfrTypes.hpp"
27 #include "jfr/leakprofiler/chains/edge.hpp"
28 #include "jfr/leakprofiler/chains/edgeStore.hpp"
29 #include "jfr/leakprofiler/chains/edgeUtils.hpp"
30 #include "jfr/leakprofiler/checkpoint/objectSampleDescription.hpp"
31 #include "jfr/leakprofiler/checkpoint/objectSampleWriter.hpp"
32 #include "jfr/leakprofiler/checkpoint/rootResolver.hpp"
33 #include "jfr/leakprofiler/sampling/objectSampler.hpp"
34 #include "jfr/leakprofiler/utilities/rootType.hpp"
35 #include "jfr/leakprofiler/utilities/unifiedOop.hpp"
36 #include "jfr/recorder/checkpoint/types/jfrTypeSetUtils.hpp"
37 #include "jfr/recorder/checkpoint/types/jfrTypeSetWriter.hpp"
38 #include "oops/oop.inline.hpp"
39 #include "oops/symbol.hpp"
40 #include "utilities/growableArray.hpp"
41
42 template <typename Data>
43 class ObjectSampleAuxInfo : public ResourceObj {
44 public:
45 Data _data;
46 traceid _id;
47 ObjectSampleAuxInfo() : _data(), _id(0) {}
48 };
49
50 class ObjectSampleArrayData {
51 public:
52 int _array_size;
53 int _array_index;
54 ObjectSampleArrayData() : _array_size(0), _array_index(0) {}
55 };
56
57 class ObjectSampleFieldInfo : public ResourceObj {
58 public:
59 const Symbol* _field_name_symbol;
60 jshort _field_modifiers;
61 ObjectSampleFieldInfo() : _field_name_symbol(NULL), _field_modifiers(0) {}
62 };
63
64 class ObjectSampleRootDescriptionData {
65 public:
66 const Edge* _root_edge;
67 const char* _description;
68 OldObjectRoot::System _system;
69 OldObjectRoot::Type _type;
70 ObjectSampleRootDescriptionData() : _root_edge(NULL),
71 _description(NULL),
72 _system(OldObjectRoot::_system_undetermined),
73 _type(OldObjectRoot::_type_undetermined) {}
74 };
75
76 class OldObjectSampleData {
77 public:
78 oop _object;
79 traceid _reference_id;
80 };
81
82 class ReferenceData {
83 public:
84 traceid _field_info_id;
85 traceid _array_info_id;
86 traceid _old_object_sample_id;
87 size_t _skip;
88 };
89
90 static int initial_storage_size = 16;
91
92 template <typename Data>
93 class SampleSet : public ResourceObj {
94 private:
95 GrowableArray<Data>* _storage;
96 public:
97 SampleSet() : _storage(NULL) {}
98
99 traceid store(Data data) {
100 assert(data != NULL, "invariant");
101 if (_storage == NULL) {
102 _storage = new GrowableArray<Data>(initial_storage_size);
103 }
104 assert(_storage != NULL, "invariant");
105 assert(_storage->find(data) == -1, "invariant");
106 _storage->append(data);
107 return data->_id;
108 }
109
110 size_t size() const {
111 return _storage != NULL ? (size_t)_storage->length() : 0;
112 }
113
114 template <typename Functor>
115 void iterate(Functor& functor) {
116 if (_storage != NULL) {
117 for (int i = 0; i < _storage->length(); ++i) {
118 functor(_storage->at(i));
119 }
120 }
121 }
122
123 const GrowableArray<Data>& storage() const {
124 return *_storage;
125 }
126 };
127
128 typedef ObjectSampleAuxInfo<ObjectSampleArrayData> ObjectSampleArrayInfo;
129 typedef ObjectSampleAuxInfo<ObjectSampleRootDescriptionData> ObjectSampleRootDescriptionInfo;
130 typedef ObjectSampleAuxInfo<OldObjectSampleData> OldObjectSampleInfo;
131 typedef ObjectSampleAuxInfo<ReferenceData> ReferenceInfo;
132
133 class FieldTable : public ResourceObj {
134 template <typename,
135 typename,
136 template<typename, typename> class,
137 typename,
138 size_t>
139 friend class HashTableHost;
140 typedef HashTableHost<const ObjectSampleFieldInfo*, traceid, Entry, FieldTable, 109> FieldInfoTable;
141 public:
142 typedef FieldInfoTable::HashEntry FieldInfoEntry;
143
144 private:
145 static traceid _field_id_counter;
146 FieldInfoTable* _table;
147
148 void assign_id(FieldInfoEntry* entry) {
149 assert(entry != NULL, "invariant");
150 entry->set_id(++_field_id_counter);
151 }
152
153 bool equals(const ObjectSampleFieldInfo* query, uintptr_t hash, const FieldInfoEntry* entry) {
154 assert(hash == entry->hash(), "invariant");
155 assert(query != NULL, "invariant");
156 const ObjectSampleFieldInfo* stored = entry->literal();
157 assert(stored != NULL, "invariant");
158 assert(((Symbol*)stored->_field_name_symbol)->identity_hash() == ((Symbol*)query->_field_name_symbol)->identity_hash(), "invariant");
159 return stored->_field_modifiers == query->_field_modifiers;
160 }
161
162 public:
163 FieldTable() : _table(new FieldInfoTable(this)) {}
164 ~FieldTable() {
165 assert(_table != NULL, "invariant");
166 delete _table;
167 }
168
169 traceid store(const ObjectSampleFieldInfo* field_info) {
170 assert(field_info != NULL, "invariant");
171 const FieldInfoEntry& entry =_table->lookup_put(field_info,
172 ((Symbol*)field_info->_field_name_symbol)->identity_hash());
173 return entry.id();
174 }
175
176 size_t size() const {
177 return _table->cardinality();
178 }
179
180 template <typename T>
181 void iterate(T& functor) const {
182 _table->iterate_entry<T>(functor);
183 }
184 };
185
186 traceid FieldTable::_field_id_counter = 0;
187
188 typedef SampleSet<const OldObjectSampleInfo*> SampleInfo;
189 typedef SampleSet<const ReferenceInfo*> RefInfo;
190 typedef SampleSet<const ObjectSampleArrayInfo*> ArrayInfo;
191 typedef SampleSet<const ObjectSampleRootDescriptionInfo*> RootDescriptionInfo;
192
193 static SampleInfo* sample_infos = NULL;
194 static RefInfo* ref_infos = NULL;
195 static ArrayInfo* array_infos = NULL;
196 static FieldTable* field_infos = NULL;
197 static RootDescriptionInfo* root_infos = NULL;
198
199 int __write_sample_info__(JfrCheckpointWriter* writer, JfrArtifactSet* unused, const void* si) {
200 assert(writer != NULL, "invariant");
201 assert(si != NULL, "invariant");
202 const OldObjectSampleInfo* const oosi = (const OldObjectSampleInfo*)si;
203 oop object = oosi->_data._object;
204 assert(object != NULL, "invariant");
205 writer->write(oosi->_id);
206 writer->write((u8)(const HeapWord*)object);
207 writer->write(const_cast<const Klass*>(object->klass()));
208 ObjectSampleDescription od(object);
209 writer->write(od.description());
210 writer->write(oosi->_data._reference_id);
211 return 1;
212 }
213
214 typedef JfrArtifactWriterImplHost<const OldObjectSampleInfo*, __write_sample_info__> SampleWriterImpl;
215 typedef JfrArtifactWriterHost<SampleWriterImpl, TYPE_OLDOBJECT> SampleWriter;
216
217 static void write_sample_infos(JfrCheckpointWriter& writer) {
218 if (sample_infos != NULL) {
219 SampleWriter sw(&writer, NULL, false);
220 sample_infos->iterate(sw);
221 }
222 }
223
224 int __write_reference_info__(JfrCheckpointWriter* writer, JfrArtifactSet* unused, const void* ri) {
225 assert(writer != NULL, "invariant");
226 assert(ri != NULL, "invariant");
227 const ReferenceInfo* const ref_info = (const ReferenceInfo*)ri;
228 writer->write(ref_info->_id);
229 writer->write(ref_info->_data._array_info_id);
230 writer->write(ref_info->_data._field_info_id);
231 writer->write(ref_info->_data._old_object_sample_id);
232 writer->write<s4>((s4)ref_info->_data._skip);
233 return 1;
234 }
235
236 typedef JfrArtifactWriterImplHost<const ReferenceInfo*, __write_reference_info__> ReferenceWriterImpl;
237 typedef JfrArtifactWriterHost<ReferenceWriterImpl, TYPE_REFERENCE> ReferenceWriter;
238
239 static void write_reference_infos(JfrCheckpointWriter& writer) {
240 if (ref_infos != NULL) {
241 ReferenceWriter rw(&writer, NULL, false);
242 ref_infos->iterate(rw);
243 }
244 }
245
246 int __write_array_info__(JfrCheckpointWriter* writer, JfrArtifactSet* unused, const void* ai) {
247 assert(writer != NULL, "invariant");
248 assert(ai != NULL, "invariant");
249 const ObjectSampleArrayInfo* const osai = (const ObjectSampleArrayInfo*)ai;
250 writer->write(osai->_id);
251 writer->write(osai->_data._array_size);
252 writer->write(osai->_data._array_index);
253 return 1;
254 }
255
256 static traceid get_array_info_id(const Edge& edge, traceid id) {
257 if (edge.is_root() || !EdgeUtils::is_array_element(edge)) {
258 return 0;
259 }
260 if (array_infos == NULL) {
261 array_infos = new ArrayInfo();
262 }
263 assert(array_infos != NULL, "invariant");
264
265 ObjectSampleArrayInfo* const osai = new ObjectSampleArrayInfo();
266 assert(osai != NULL, "invariant");
267 osai->_id = id;
268 osai->_data._array_size = EdgeUtils::array_size(edge);
269 osai->_data._array_index = EdgeUtils::array_index(edge);
270 return array_infos->store(osai);
271 }
272
273 typedef JfrArtifactWriterImplHost<const ObjectSampleArrayInfo*, __write_array_info__> ArrayWriterImpl;
274 typedef JfrArtifactWriterHost<ArrayWriterImpl, TYPE_OLDOBJECTARRAY> ArrayWriter;
275
276 static void write_array_infos(JfrCheckpointWriter& writer) {
277 if (array_infos != NULL) {
278 ArrayWriter aw(&writer, NULL, false);
279 array_infos->iterate(aw);
280 }
281 }
282
283 int __write_field_info__(JfrCheckpointWriter* writer, JfrArtifactSet* unused, const void* fi) {
284 assert(writer != NULL, "invariant");
285 assert(fi != NULL, "invariant");
286 const FieldTable::FieldInfoEntry* field_info_entry = (const FieldTable::FieldInfoEntry*)fi;
287 writer->write(field_info_entry->id());
288 const ObjectSampleFieldInfo* const osfi = field_info_entry->literal();
289 writer->write(osfi->_field_name_symbol->as_C_string());
290 writer->write(osfi->_field_modifiers);
291 return 1;
292 }
293
294 static traceid get_field_info_id(const Edge& edge) {
295 if (edge.is_root()) {
296 return 0;
297 }
298
299 assert(!EdgeUtils::is_array_element(edge), "invariant");
300 const Symbol* const field_name_symbol = EdgeUtils::field_name_symbol(edge);
301 if (field_name_symbol == NULL) {
302 return 0;
303 }
304
305 if (field_infos == NULL) {
306 field_infos = new FieldTable();
307 }
308 assert(field_infos != NULL, "invariant");
309
310 ObjectSampleFieldInfo* const osfi = new ObjectSampleFieldInfo();
311 assert(osfi != NULL, "invariant");
312 osfi->_field_name_symbol = field_name_symbol;
313 osfi->_field_modifiers = EdgeUtils::field_modifiers(edge);
314 return field_infos->store(osfi);
315 }
316
317 typedef JfrArtifactWriterImplHost<const FieldTable::FieldInfoEntry*, __write_field_info__> FieldWriterImpl;
318 typedef JfrArtifactWriterHost<FieldWriterImpl, TYPE_OLDOBJECTFIELD> FieldWriter;
319
320 static void write_field_infos(JfrCheckpointWriter& writer) {
321 if (field_infos != NULL) {
322 FieldWriter fw(&writer, NULL, false);
323 field_infos->iterate(fw);
324 }
325 }
326
327 static const char* description(const ObjectSampleRootDescriptionInfo* osdi) {
328 assert(osdi != NULL, "invariant");
329
330 if (osdi->_data._description == NULL) {
331 return NULL;
332 }
333
334 ObjectDescriptionBuilder description;
335 if (osdi->_data._system == OldObjectRoot::_threads) {
336 description.write_text("Thread Name: ");
337 }
338 description.write_text(osdi->_data._description);
339 return description.description();
340 }
341
342 int __write_root_description_info__(JfrCheckpointWriter* writer, JfrArtifactSet* unused, const void* di) {
343 assert(writer != NULL, "invariant");
344 assert(di != NULL, "invariant");
345 const ObjectSampleRootDescriptionInfo* const osdi = (const ObjectSampleRootDescriptionInfo*)di;
346 writer->write(osdi->_id);
347 writer->write(description(osdi));
348 writer->write<u8>(osdi->_data._system);
349 writer->write<u8>(osdi->_data._type);
350 return 1;
351 }
352
353 static traceid get_root_description_info_id(const Edge& edge, traceid id) {
354 assert(edge.is_root(), "invariant");
355 if (EdgeUtils::is_leak_edge(edge)) {
356 return 0;
357 }
358
359 if (root_infos == NULL) {
360 root_infos = new RootDescriptionInfo();
361 }
362 assert(root_infos != NULL, "invariant");
363 ObjectSampleRootDescriptionInfo* const oodi = new ObjectSampleRootDescriptionInfo();
364 oodi->_id = id;
365 oodi->_data._root_edge = &edge;
366 return root_infos->store(oodi);
367 }
368
369 typedef JfrArtifactWriterImplHost<const ObjectSampleRootDescriptionInfo*, __write_root_description_info__> RootDescriptionWriterImpl;
370 typedef JfrArtifactWriterHost<RootDescriptionWriterImpl, TYPE_OLDOBJECTGCROOT> RootDescriptionWriter;
371
372
373 int _edge_reference_compare_(uintptr_t lhs, uintptr_t rhs) {
374 return lhs > rhs ? 1 : (lhs < rhs) ? -1 : 0;
375 }
376
377 int _root_desc_compare_(const ObjectSampleRootDescriptionInfo*const & lhs, const ObjectSampleRootDescriptionInfo* const& rhs) {
378 const uintptr_t lhs_ref = (uintptr_t)lhs->_data._root_edge->reference();
379 const uintptr_t rhs_ref = (uintptr_t)rhs->_data._root_edge->reference();
380 return _edge_reference_compare_(lhs_ref, rhs_ref);
381 }
382
383 static int find_sorted(const RootCallbackInfo& callback_info,
384 const GrowableArray<const ObjectSampleRootDescriptionInfo*>* arr,
385 int length,
386 bool& found) {
387 assert(arr != NULL, "invariant");
388 assert(length >= 0, "invariant");
389 assert(length <= arr->length(), "invariant");
390
391 found = false;
392 int min = 0;
393 int max = length;
394 while (max >= min) {
395 const int mid = (int)(((uint)max + min) / 2);
396 int diff = _edge_reference_compare_((uintptr_t)callback_info._high,
397 (uintptr_t)arr->at(mid)->_data._root_edge->reference());
398 if (diff > 0) {
399 min = mid + 1;
400 } else if (diff < 0) {
401 max = mid - 1;
402 } else {
403 found = true;
404 return mid;
405 }
406 }
407 return min;
408 }
409
410 class RootResolutionSet : public ResourceObj, public RootCallback {
411 private:
412 GrowableArray<const ObjectSampleRootDescriptionInfo*>* _unresolved_roots;
413
414 const uintptr_t high() const {
415 return (uintptr_t)_unresolved_roots->top()->_data._root_edge->reference();
416 }
417
418 const uintptr_t low() const {
419 return (uintptr_t)_unresolved_roots->first()->_data._root_edge->reference();
420 }
421
422 bool in_set_address_range(const RootCallbackInfo& callback_info) const {
423 assert(callback_info._low == NULL, "invariant");
424 const uintptr_t addr = (uintptr_t)callback_info._high;
425 return low() <= addr && high() >= addr;
426 }
427
428 int compare_to_range(const RootCallbackInfo& callback_info) const {
429 assert(callback_info._high != NULL, "invariant");
430 assert(callback_info._low != NULL, "invariant");
431
432 for (int i = 0; i < _unresolved_roots->length(); ++i) {
433 const uintptr_t ref_addr = (uintptr_t)_unresolved_roots->at(i)->_data._root_edge->reference();
434 if ((uintptr_t)callback_info._low <= ref_addr && (uintptr_t)callback_info._high >= ref_addr) {
435 return i;
436 }
437 }
438 return -1;
439 }
440
441 int exact(const RootCallbackInfo& callback_info) const {
442 assert(callback_info._high != NULL, "invariant");
443 assert(in_set_address_range(callback_info), "invariant");
444
445 bool found;
446 const int idx = find_sorted(callback_info, _unresolved_roots, _unresolved_roots->length(), found);
447 return found ? idx : -1;
448 }
449
450 bool resolve_root(const RootCallbackInfo& callback_info, int idx) const {
451 assert(idx >= 0, "invariant");
452 assert(idx < _unresolved_roots->length(), "invariant");
453
454 ObjectSampleRootDescriptionInfo* const desc =
455 const_cast<ObjectSampleRootDescriptionInfo*>(_unresolved_roots->at(idx));
456 assert(desc != NULL, "invariant");
457 assert((uintptr_t)callback_info._high == (uintptr_t)desc->_data._root_edge->reference(), "invariant");
458
459 desc->_data._system = callback_info._system;
460 desc->_data._type = callback_info._type;
461
462 if (callback_info._system == OldObjectRoot::_threads) {
463 const JavaThread* jt = (const JavaThread*)callback_info._context;
464 assert(jt != NULL, "invariant");
465 desc->_data._description = jt->name();
466 }
467
468 _unresolved_roots->remove_at(idx);
469 return _unresolved_roots->is_empty();
470 }
471
472 public:
473 RootResolutionSet(RootDescriptionInfo* info) : _unresolved_roots(NULL) {
474 assert(info != NULL, "invariant");
475 // construct a sorted copy
476 const GrowableArray<const ObjectSampleRootDescriptionInfo*>& info_storage = info->storage();
477 const int length = info_storage.length();
478 _unresolved_roots = new GrowableArray<const ObjectSampleRootDescriptionInfo*>(length);
479 assert(_unresolved_roots != NULL, "invariant");
480
481 for (int i = 0; i < length; ++i) {
482 _unresolved_roots->insert_sorted<_root_desc_compare_>(info_storage.at(i));
483 }
484 }
485
486 bool process(const RootCallbackInfo& callback_info) {
487 if (NULL == callback_info._low) {
488 if (in_set_address_range(callback_info)) {
489 const int idx = exact(callback_info);
490 return idx == -1 ? false : resolve_root(callback_info, idx);
491 }
492 return false;
493 }
494 assert(callback_info._low != NULL, "invariant");
495 const int idx = compare_to_range(callback_info);
496 return idx == -1 ? false : resolve_root(callback_info, idx);
497 }
498
499 int entries() const {
500 return _unresolved_roots->length();
501 }
502
503 const void* at(int idx) const {
504 assert(idx >= 0, "invariant");
505 assert(idx < _unresolved_roots->length(), "invariant");
506 return _unresolved_roots->at(idx)->_data._root_edge->reference();
507 }
508 };
509
510 static void write_root_descriptors(JfrCheckpointWriter& writer) {
511 if (root_infos != NULL) {
512 // resolve roots
513 RootResolutionSet rrs(root_infos);
514 RootResolver::resolve(rrs);
515 // write roots
516 RootDescriptionWriter rw(&writer, NULL, false);
517 root_infos->iterate(rw);
518 }
519 }
520
521 static void add_old_object_sample_info(const Edge* current, traceid id) {
522 assert(current != NULL, "invariant");
523 if (sample_infos == NULL) {
524 sample_infos = new SampleInfo();
525 }
526 assert(sample_infos != NULL, "invariant");
527 OldObjectSampleInfo* const oosi = new OldObjectSampleInfo();
528 assert(oosi != NULL, "invariant");
529 oosi->_id = id;
530 oosi->_data._object = current->pointee();
531 oosi->_data._reference_id = current->is_root() ? (traceid)0 : id;
532 sample_infos->store(oosi);
533 }
534
535 static void add_reference_info(const RoutableEdge* current, traceid id, traceid parent_id) {
536 assert(current != NULL, "invariant");
537 if (ref_infos == NULL) {
538 ref_infos = new RefInfo();
539 }
540
541 assert(ref_infos != NULL, "invariant");
542 ReferenceInfo* const ri = new ReferenceInfo();
543 assert(ri != NULL, "invariant");
544
545 ri->_id = id;
546 ri->_data._array_info_id = !current->is_skip_edge() ? get_array_info_id(*current, id) : 0;
547 ri->_data._field_info_id = ri->_data._array_info_id == 0 && !current->is_skip_edge() ?
548 get_field_info_id(*current) : (traceid)0;
549 ri->_data._old_object_sample_id = parent_id;
550 ri->_data._skip = current->skip_length();
551 ref_infos->store(ri);
552 }
553
554 static traceid add_root_info(const Edge* root, traceid id) {
555 assert(root != NULL, "invariant");
556 assert(root->is_root(), "invariant");
557 return get_root_description_info_id(*root, id);
558 }
559
560 void ObjectSampleWriter::write(const RoutableEdge* edge) {
561 assert(edge != NULL, "invariant");
562 const traceid id = _store->get_id(edge);
563 add_old_object_sample_info(edge, id);
564 const RoutableEdge* parent = edge->logical_parent();
565 if (parent != NULL) {
566 add_reference_info(edge, id, _store->get_id(parent));
567 } else {
568 assert(edge->is_root(), "invariant");
569 add_root_info(edge, id);
570 }
571 }
572
573 ObjectSampleWriter::ObjectSampleWriter(JfrCheckpointWriter& writer, const EdgeStore* store) :
574 _writer(writer),
575 _store(store) {
576 assert(store != NULL, "invariant");
577 assert(store->number_of_entries() > 0, "invariant");
578 sample_infos = NULL;
579 ref_infos = NULL;
580 array_infos = NULL;
581 field_infos = NULL;
582 root_infos = NULL;
583 }
584
585 ObjectSampleWriter::~ObjectSampleWriter() {
586 write_sample_infos(_writer);
587 write_reference_infos(_writer);
588 write_array_infos(_writer);
589 write_field_infos(_writer);
590 write_root_descriptors(_writer);
591 }
592
593 void ObjectSampleWriter::write_chain(const RoutableEdge& edge) {
594 assert(EdgeUtils::is_leak_edge(edge), "invariant");
595 if (edge.processed()) {
596 return;
597 }
598 EdgeUtils::collapse_chain(edge);
599 const RoutableEdge* current = &edge;
600 while (current != NULL) {
601 if (current->processed()) {
602 return;
603 }
604 write(current);
605 current->set_processed();
606 current = current->logical_parent();
607 }
608 }
609
610 bool ObjectSampleWriter::operator()(const RoutableEdge& edge) {
611 if (EdgeUtils::is_leak_edge(edge)) {
612 write_chain(edge);
613 }
614 return true;
615 }

Mercurial Repository: jdk8-mips64-public/hotspot

mercurial