jdk-sandbox: comparison src/hotspot/share/jfr/leakprofiler/checkpoint/objectSampleWriter.cpp

equal deleted inserted replaced

-:84ef29ccac56
+:00860d9caf4d
 /*
-* Copyright (c) 2014, 2018, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 2014, 2019, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 #include "jfr/leakprofiler/checkpoint/objectSampleWriter.hpp"
 #include "jfr/leakprofiler/checkpoint/rootResolver.hpp"
 #include "jfr/leakprofiler/sampling/objectSampler.hpp"
 #include "jfr/leakprofiler/utilities/rootType.hpp"
 #include "jfr/leakprofiler/utilities/unifiedOop.hpp"
-#include "jfr/recorder/checkpoint/types/jfrTypeSetUtils.hpp"
+#include "jfr/writers/jfrTypeWriterHost.hpp"
-#include "jfr/recorder/checkpoint/types/jfrTypeSetWriter.hpp"
 #include "oops/oop.inline.hpp"
 #include "oops/symbol.hpp"
 #include "utilities/growableArray.hpp"
 template <typename Data>
 assert(stored != NULL, "invariant");
 assert(stored->_field_name_symbol->identity_hash() == query->_field_name_symbol->identity_hash(), "invariant");
 return stored->_field_modifiers == query->_field_modifiers;
 }
+void unlink(FieldInfoEntry* entry) {
+assert(entry != NULL, "invariant");
+// nothing
+}
 public:
 FieldTable() : _table(new FieldInfoTable(this)) {}
 ~FieldTable() {
 assert(_table != NULL, "invariant");
 delete _table;
 static RefInfo* ref_infos = NULL;
 static ArrayInfo* array_infos = NULL;
 static FieldTable* field_infos = NULL;
 static RootDescriptionInfo* root_infos = NULL;
-int __write_sample_info__(JfrCheckpointWriter* writer, JfrArtifactSet* unused, const void* si) {
+int __write_sample_info__(JfrCheckpointWriter* writer, const void* si) {
 assert(writer != NULL, "invariant");
 assert(si != NULL, "invariant");
 const OldObjectSampleInfo* const oosi = (const OldObjectSampleInfo*)si;
 oop object = oosi->_data._object;
 assert(object != NULL, "invariant");
 writer->write(od.description());
 writer->write(oosi->_data._reference_id);
 return 1;
 }
-typedef JfrArtifactWriterImplHost<const OldObjectSampleInfo*, __write_sample_info__> SampleWriterImpl;
+typedef JfrTypeWriterImplHost<const OldObjectSampleInfo*, __write_sample_info__> SampleWriterImpl;
-typedef JfrArtifactWriterHost<SampleWriterImpl, TYPE_OLDOBJECT> SampleWriter;
+typedef JfrTypeWriterHost<SampleWriterImpl, TYPE_OLDOBJECT> SampleWriter;
 static void write_sample_infos(JfrCheckpointWriter& writer) {
 if (sample_infos != NULL) {
-SampleWriter sw(&writer, NULL, false);
+SampleWriter sw(&writer);
 sample_infos->iterate(sw);
 }
 }
-int __write_reference_info__(JfrCheckpointWriter* writer, JfrArtifactSet* unused, const void* ri) {
+int __write_reference_info__(JfrCheckpointWriter* writer, const void* ri) {
 assert(writer != NULL, "invariant");
 assert(ri != NULL, "invariant");
 const ReferenceInfo* const ref_info = (const ReferenceInfo*)ri;
 writer->write(ref_info->_id);
 writer->write(ref_info->_data._array_info_id);
 writer->write(ref_info->_data._old_object_sample_id);
 writer->write<s4>((s4)ref_info->_data._skip);
 return 1;
 }
-typedef JfrArtifactWriterImplHost<const ReferenceInfo*, __write_reference_info__> ReferenceWriterImpl;
+typedef JfrTypeWriterImplHost<const ReferenceInfo*, __write_reference_info__> ReferenceWriterImpl;
-typedef JfrArtifactWriterHost<ReferenceWriterImpl, TYPE_REFERENCE> ReferenceWriter;
+typedef JfrTypeWriterHost<ReferenceWriterImpl, TYPE_REFERENCE> ReferenceWriter;
 static void write_reference_infos(JfrCheckpointWriter& writer) {
 if (ref_infos != NULL) {
-ReferenceWriter rw(&writer, NULL, false);
+ReferenceWriter rw(&writer);
 ref_infos->iterate(rw);
 }
 }
-int __write_array_info__(JfrCheckpointWriter* writer, JfrArtifactSet* unused, const void* ai) {
+int __write_array_info__(JfrCheckpointWriter* writer, const void* ai) {
 assert(writer != NULL, "invariant");
 assert(ai != NULL, "invariant");
 const ObjectSampleArrayInfo* const osai = (const ObjectSampleArrayInfo*)ai;
 writer->write(osai->_id);
 writer->write(osai->_data._array_size);
 osai->_data._array_size = EdgeUtils::array_size(edge);
 osai->_data._array_index = EdgeUtils::array_index(edge);
 return array_infos->store(osai);
 }
-typedef JfrArtifactWriterImplHost<const ObjectSampleArrayInfo*, __write_array_info__> ArrayWriterImpl;
+typedef JfrTypeWriterImplHost<const ObjectSampleArrayInfo*, __write_array_info__> ArrayWriterImpl;
-typedef JfrArtifactWriterHost<ArrayWriterImpl, TYPE_OLDOBJECTARRAY> ArrayWriter;
+typedef JfrTypeWriterHost<ArrayWriterImpl, TYPE_OLDOBJECTARRAY> ArrayWriter;
 static void write_array_infos(JfrCheckpointWriter& writer) {
 if (array_infos != NULL) {
-ArrayWriter aw(&writer, NULL, false);
+ArrayWriter aw(&writer);
 array_infos->iterate(aw);
 }
 }
-int __write_field_info__(JfrCheckpointWriter* writer, JfrArtifactSet* unused, const void* fi) {
+int __write_field_info__(JfrCheckpointWriter* writer, const void* fi) {
 assert(writer != NULL, "invariant");
 assert(fi != NULL, "invariant");
 const FieldTable::FieldInfoEntry* field_info_entry = (const FieldTable::FieldInfoEntry*)fi;
 writer->write(field_info_entry->id());
 const ObjectSampleFieldInfo* const osfi = field_info_entry->literal();
 osfi->_field_name_symbol = field_name_symbol;
 osfi->_field_modifiers = EdgeUtils::field_modifiers(edge);
 return field_infos->store(osfi);
 }
-typedef JfrArtifactWriterImplHost<const FieldTable::FieldInfoEntry*, __write_field_info__> FieldWriterImpl;
+typedef JfrTypeWriterImplHost<const FieldTable::FieldInfoEntry*, __write_field_info__> FieldWriterImpl;
-typedef JfrArtifactWriterHost<FieldWriterImpl, TYPE_OLDOBJECTFIELD> FieldWriter;
+typedef JfrTypeWriterHost<FieldWriterImpl, TYPE_OLDOBJECTFIELD> FieldWriter;
 static void write_field_infos(JfrCheckpointWriter& writer) {
 if (field_infos != NULL) {
-FieldWriter fw(&writer, NULL, false);
+FieldWriter fw(&writer);
 field_infos->iterate(fw);
 }
 }
 static const char* description(const ObjectSampleRootDescriptionInfo* osdi) {
 }
 description.write_text(osdi->_data._description);
 return description.description();
 }
-int __write_root_description_info__(JfrCheckpointWriter* writer, JfrArtifactSet* unused, const void* di) {
+int __write_root_description_info__(JfrCheckpointWriter* writer, const void* di) {
 assert(writer != NULL, "invariant");
 assert(di != NULL, "invariant");
 const ObjectSampleRootDescriptionInfo* const osdi = (const ObjectSampleRootDescriptionInfo*)di;
 writer->write(osdi->_id);
 writer->write(description(osdi));
 writer->write<u8>(osdi->_data._system);
 writer->write<u8>(osdi->_data._type);
 return 1;
 }
-static traceid get_root_description_info_id(const Edge& edge, traceid id) {
+static traceid get_gc_root_description_info_id(const Edge& edge, traceid id) {
 assert(edge.is_root(), "invariant");
 if (EdgeUtils::is_leak_edge(edge)) {
 return 0;
 }
 oodi->_id = id;
 oodi->_data._root_edge = &edge;
 return root_infos->store(oodi);
 }
-typedef JfrArtifactWriterImplHost<const ObjectSampleRootDescriptionInfo*, __write_root_description_info__> RootDescriptionWriterImpl;
+typedef JfrTypeWriterImplHost<const ObjectSampleRootDescriptionInfo*, __write_root_description_info__> RootDescriptionWriterImpl;
-typedef JfrArtifactWriterHost<RootDescriptionWriterImpl, TYPE_OLDOBJECTGCROOT> RootDescriptionWriter;
+typedef JfrTypeWriterHost<RootDescriptionWriterImpl, TYPE_OLDOBJECTGCROOT> RootDescriptionWriter;
 int _edge_reference_compare_(uintptr_t lhs, uintptr_t rhs) {
 return lhs > rhs ? 1 : (lhs < rhs) ? -1 : 0;
 }
 if (root_infos != NULL) {
 // resolve roots
 RootResolutionSet rrs(root_infos);
 RootResolver::resolve(rrs);
 // write roots
-RootDescriptionWriter rw(&writer, NULL, false);
+RootDescriptionWriter rw(&writer);
 root_infos->iterate(rw);
 }
 }
-static void add_old_object_sample_info(const Edge* current, traceid id) {
+static void add_old_object_sample_info(const StoredEdge* current, traceid id) {
 assert(current != NULL, "invariant");
 if (sample_infos == NULL) {
 sample_infos = new SampleInfo();
 }
 assert(sample_infos != NULL, "invariant");
 OldObjectSampleInfo* const oosi = new OldObjectSampleInfo();
 assert(oosi != NULL, "invariant");
 oosi->_id = id;
 oosi->_data._object = current->pointee();
-oosi->_data._reference_id = current->is_root() ? (traceid)0 : id;
+oosi->_data._reference_id = current->parent() == NULL ? (traceid)0 : id;
 sample_infos->store(oosi);
 }
-static void add_reference_info(const RoutableEdge* current, traceid id, traceid parent_id) {
+static void add_reference_info(const StoredEdge* current, traceid id, traceid parent_id) {
 assert(current != NULL, "invariant");
 if (ref_infos == NULL) {
 ref_infos = new RefInfo();
 }
 ReferenceInfo* const ri = new ReferenceInfo();
 assert(ri != NULL, "invariant");
 ri->_id = id;
 ri->_data._array_info_id =  !current->is_skip_edge() ? get_array_info_id(*current, id) : 0;
-ri->_data._field_info_id = ri->_data._array_info_id == 0 && !current->is_skip_edge() ?
+ri->_data._field_info_id = ri->_data._array_info_id == 0 && !current->is_skip_edge() ? get_field_info_id(*current) : (traceid)0;
-get_field_info_id(*current) : (traceid)0;
 ri->_data._old_object_sample_id = parent_id;
 ri->_data._skip = current->skip_length();
 ref_infos->store(ri);
 }
-static traceid add_root_info(const Edge* root, traceid id) {
+static bool is_gc_root(const StoredEdge* current) {
+assert(current != NULL, "invariant");
+return current->parent() == NULL && current->gc_root_id() != 0;
+}
+static traceid add_gc_root_info(const StoredEdge* root, traceid id) {
 assert(root != NULL, "invariant");
-assert(root->is_root(), "invariant");
+assert(is_gc_root(root), "invariant");
-return get_root_description_info_id(*root, id);
+return get_gc_root_description_info_id(*root, id);
 }
-void ObjectSampleWriter::write(const RoutableEdge* edge) {
+void ObjectSampleWriter::write(const StoredEdge* edge) {
 assert(edge != NULL, "invariant");
 const traceid id = _store->get_id(edge);
 add_old_object_sample_info(edge, id);
-const RoutableEdge* parent = edge->logical_parent();
+const StoredEdge* const parent = edge->parent();
 if (parent != NULL) {
 add_reference_info(edge, id, _store->get_id(parent));
 } else {
-assert(edge->is_root(), "invariant");
+if (is_gc_root(edge)) {
-add_root_info(edge, id);
+assert(edge->gc_root_id() == id, "invariant");
-}
+add_gc_root_info(edge, id);
 }
+}
-ObjectSampleWriter::ObjectSampleWriter(JfrCheckpointWriter& writer, const EdgeStore* store) :
+}
+ObjectSampleWriter::ObjectSampleWriter(JfrCheckpointWriter& writer, EdgeStore* store) :
 _writer(writer),
 _store(store) {
 assert(store != NULL, "invariant");
-assert(store->number_of_entries() > 0, "invariant");
+assert(!store->is_empty(), "invariant");
 sample_infos = NULL;
 ref_infos = NULL;
 array_infos = NULL;
 field_infos = NULL;
 root_infos = NULL;
 write_array_infos(_writer);
 write_field_infos(_writer);
 write_root_descriptors(_writer);
 }
-void ObjectSampleWriter::write_chain(const RoutableEdge& edge) {
+bool ObjectSampleWriter::operator()(StoredEdge& e) {
-assert(EdgeUtils::is_leak_edge(edge), "invariant");
+write(&e);
-if (edge.processed()) {
-return;
-}
-EdgeUtils::collapse_chain(edge);
-const RoutableEdge* current = &edge;
-while (current != NULL) {
-if (current->processed()) {
-return;
-}
-write(current);
-current->set_processed();
-current = current->logical_parent();
-}
-}
-bool ObjectSampleWriter::operator()(const RoutableEdge& edge) {
-if (EdgeUtils::is_leak_edge(edge)) {
-write_chain(edge);
-}
 return true;
 }

branch	JEP-349-branch
changeset 57870	00860d9caf4d
parent 50113	caf115bb98ad
child 57936	1b2d0f4c1e38