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

equal deleted inserted replaced

-:13588c901957
+:9cf78a70fa4f
 /*
-* 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/metadata/jfrSerializer.hpp"
-#include "jfr/recorder/checkpoint/types/jfrTypeSetWriter.hpp"
+#include "jfr/writers/jfrTypeWriterHost.hpp"
 #include "oops/oop.inline.hpp"
 #include "oops/symbol.hpp"
 #include "utilities/growableArray.hpp"
 template <typename Data>
 typename,
 template<typename, typename> class,
 typename,
 size_t>
 friend class HashTableHost;
-typedef HashTableHost<const ObjectSampleFieldInfo*, traceid, Entry, FieldTable, 109> FieldInfoTable;
+typedef HashTableHost<const ObjectSampleFieldInfo*, traceid, JfrHashtableEntry, FieldTable, 109> FieldInfoTable;
 public:
 typedef FieldInfoTable::HashEntry FieldInfoEntry;
 private:
 static traceid _field_id_counter;
 FieldInfoTable* _table;
+const ObjectSampleFieldInfo* _lookup;
-void assign_id(FieldInfoEntry* entry) {
+void on_link(FieldInfoEntry* entry) {
 assert(entry != NULL, "invariant");
 entry->set_id(++_field_id_counter);
 }
-bool equals(const ObjectSampleFieldInfo* query, uintptr_t hash, const FieldInfoEntry* entry) {
+bool on_equals(uintptr_t hash, const FieldInfoEntry* entry) {
 assert(hash == entry->hash(), "invariant");
-assert(query != NULL, "invariant");
+assert(_lookup != NULL, "invariant");
-const ObjectSampleFieldInfo* stored = entry->literal();
+return entry->literal()->_field_modifiers == _lookup->_field_modifiers;
-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 on_unlink(FieldInfoEntry* entry) {
-}
+assert(entry != NULL, "invariant");
+// nothing
-public:
+}
-FieldTable() : _table(new FieldInfoTable(this)) {}
+public:
+FieldTable() : _table(new FieldInfoTable(this)), _lookup(NULL) {}
 ~FieldTable() {
 assert(_table != NULL, "invariant");
 delete _table;
 }
 traceid store(const ObjectSampleFieldInfo* field_info) {
 assert(field_info != NULL, "invariant");
-const FieldInfoEntry& entry =_table->lookup_put(field_info,
+_lookup = field_info;
-field_info->_field_name_symbol->identity_hash());
+const FieldInfoEntry& entry = _table->lookup_put(field_info->_field_name_symbol->identity_hash(), field_info);
 return entry.id();
 }
 size_t size() const {
 return _table->cardinality();
 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) :
+}
+class RootSystemType : public JfrSerializer {
+public:
+void serialize(JfrCheckpointWriter& writer) {
+const u4 nof_root_systems = OldObjectRoot::_number_of_systems;
+writer.write_count(nof_root_systems);
+for (u4 i = 0; i < nof_root_systems; ++i) {
+writer.write_key(i);
+writer.write(OldObjectRoot::system_description((OldObjectRoot::System)i));
+}
+}
+};
+class RootType : public JfrSerializer {
+public:
+void serialize(JfrCheckpointWriter& writer) {
+const u4 nof_root_types = OldObjectRoot::_number_of_types;
+writer.write_count(nof_root_types);
+for (u4 i = 0; i < nof_root_types; ++i) {
+writer.write_key(i);
+writer.write(OldObjectRoot::type_description((OldObjectRoot::Type)i));
+}
+}
+};
+static void register_serializers() {
+static bool is_registered = false;
+if (!is_registered) {
+JfrSerializer::register_serializer(TYPE_OLDOBJECTROOTSYSTEM, false, true, new RootSystemType());
+JfrSerializer::register_serializer(TYPE_OLDOBJECTROOTTYPE, false, true, new RootType());
+is_registered = true;
+}
+}
+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");
+register_serializers();
 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	datagramsocketimpl-branch
changeset 58678	9cf78a70fa4f
parent 50113	caf115bb98ad
child 58679	9c3209ff7550