--- a/src/hotspot/share/jfr/recorder/checkpoint/types/jfrTypeManager.cpp Tue Sep 17 12:41:45 2019 +0200
+++ b/src/hotspot/share/jfr/recorder/checkpoint/types/jfrTypeManager.cpp Tue Sep 17 13:32:27 2019 +0200
@@ -75,35 +75,106 @@
return _id;
}
- void invoke(JfrCheckpointWriter& writer) const;
+ void on_rotation() const {
+ _serializer->on_rotation();
+ }
- void on_rotation() const;
+ void invoke(JfrCheckpointWriter& writer) const {
+ if (_cache.valid()) {
+ writer.increment();
+ _cache->write(writer);
+ return;
+ }
+ const JfrCheckpointContext ctx = writer.context();
+ // serialize the type id before invoking callback
+ writer.write_type(_id);
+ const intptr_t start = writer.current_offset();
+ // invoke the serializer routine
+ _serializer->serialize(writer);
+ if (start == writer.current_offset()) {
+ // the serializer implementation did nothing, rewind to restore
+ writer.set_context(ctx);
+ return;
+ }
+ if (_permit_cache) {
+ _cache = writer.copy(&ctx);
+ }
+ }
};
-void JfrSerializerRegistration::invoke(JfrCheckpointWriter& writer) const {
- if (_cache.valid()) {
- writer.increment();
- _cache->write(writer);
+static void serialize_threads(JfrCheckpointWriter& writer) {
+ JfrThreadConstantSet thread_set;
+ writer.write_type(TYPE_THREAD);
+ thread_set.serialize(writer);
+}
+
+static void serialize_thread_groups(JfrCheckpointWriter& writer) {
+ JfrThreadGroupConstant thread_group_set;
+ writer.write_type(TYPE_THREADGROUP);
+ thread_group_set.serialize(writer);
+}
+
+void JfrTypeManager::write_threads(JfrCheckpointWriter& writer) {
+ serialize_threads(writer);
+ serialize_thread_groups(writer);
+}
+
+void JfrTypeManager::create_thread_blob(Thread* t) {
+ assert(t != NULL, "invariant");
+ ResourceMark rm(t);
+ HandleMark hm(t);
+ JfrThreadConstant type_thread(t);
+ JfrCheckpointWriter writer(t, true, THREADS);
+ writer.write_type(TYPE_THREAD);
+ type_thread.serialize(writer);
+ // create and install a checkpoint blob
+ t->jfr_thread_local()->set_thread_blob(writer.move());
+ assert(t->jfr_thread_local()->has_thread_blob(), "invariant");
+}
+
+void JfrTypeManager::write_thread_checkpoint(Thread* t) {
+ assert(t != NULL, "invariant");
+ ResourceMark rm(t);
+ HandleMark hm(t);
+ JfrThreadConstant type_thread(t);
+ JfrCheckpointWriter writer(t, true, THREADS);
+ writer.write_type(TYPE_THREAD);
+ type_thread.serialize(writer);
+}
+
+size_t JfrTypeManager::flush_type_set() {
+ JfrCheckpointWriter writer;
+ FlushTypeSet flush;
+ flush.serialize(writer);
+ return flush.elements();
+}
+
+void JfrTypeManager::write_type_set() {
+ if (!LeakProfiler::is_running()) {
+ JfrCheckpointWriter writer;
+ TypeSet set;
+ set.serialize(writer);
return;
}
- const JfrCheckpointContext ctx = writer.context();
- // serialize the type id before invoking callback
- writer.write_type(_id);
- const intptr_t start = writer.current_offset();
- // invoke the serializer routine
- _serializer->serialize(writer);
- if (start == writer.current_offset() ) {
- // the serializer implementation did nothing, rewind to restore
- writer.set_context(ctx);
- return;
- }
- if (_permit_cache) {
- _cache = writer.copy(&ctx);
- }
+ JfrCheckpointWriter leakp_writer;
+ JfrCheckpointWriter writer;
+ TypeSet set(&leakp_writer);
+ set.serialize(writer);
+ ObjectSampleCheckpoint::on_type_set(leakp_writer);
}
-void JfrSerializerRegistration::on_rotation() const {
- _serializer->on_rotation();
+void JfrTypeManager::write_type_set_for_unloaded_classes() {
+ JfrCheckpointWriter writer;
+ const JfrCheckpointContext ctx = writer.context();
+ ClassUnloadTypeSet class_unload_set;
+ class_unload_set.serialize(writer);
+ if (LeakProfiler::is_running()) {
+ ObjectSampleCheckpoint::on_type_set_unload(writer);
+ }
+ if (!Jfr::is_recording()) {
+ // discard anything written
+ writer.set_context(ctx);
+ }
}
class SerializerRegistrationGuard : public StackObj {
@@ -135,34 +206,6 @@
}
}
-static bool new_registration = false;
-
-void JfrTypeManager::write_types(JfrCheckpointWriter& writer) {
- SerializerRegistrationGuard guard;
- const Iterator iter(types);
- while (iter.has_next()) {
- iter.next()->invoke(writer);
- }
- new_registration = false;
-}
-
-static void serialize_threads(JfrCheckpointWriter& writer) {
- JfrThreadConstantSet thread_set;
- writer.write_type(TYPE_THREAD);
- thread_set.serialize(writer);
-}
-
-static void serialize_thread_groups(JfrCheckpointWriter& writer) {
- JfrThreadGroupConstant thread_group_set;
- writer.write_type(TYPE_THREADGROUP);
- thread_group_set.serialize(writer);
-}
-
-void JfrTypeManager::write_threads(JfrCheckpointWriter& writer) {
- serialize_threads(writer);
- serialize_thread_groups(writer);
-}
-
void JfrTypeManager::on_rotation() {
const Iterator iter(types);
while (iter.has_next()) {
@@ -170,64 +213,6 @@
}
}
-void JfrTypeManager::write_type_set() {
- if (!LeakProfiler::is_running()) {
- JfrCheckpointWriter writer;
- TypeSet set;
- set.serialize(writer);
- return;
- }
- JfrCheckpointWriter leakp_writer;
- JfrCheckpointWriter writer;
- TypeSet set(&leakp_writer);
- set.serialize(writer);
- ObjectSampleCheckpoint::on_type_set(leakp_writer);
-}
-
-void JfrTypeManager::write_type_set_for_unloaded_classes() {
- JfrCheckpointWriter writer;
- const JfrCheckpointContext ctx = writer.context();
- ClassUnloadTypeSet class_unload_set;
- class_unload_set.serialize(writer);
- if (LeakProfiler::is_running()) {
- ObjectSampleCheckpoint::on_type_set_unload(writer);
- }
- if (!Jfr::is_recording()) {
- // discard anything written
- writer.set_context(ctx);
- }
-}
-
-size_t JfrTypeManager::flush_type_set() {
- JfrCheckpointWriter writer;
- FlushTypeSet flush;
- flush.serialize(writer);
- return flush.elements();
-}
-
-void JfrTypeManager::create_thread_blob(Thread* t) {
- assert(t != NULL, "invariant");
- ResourceMark rm(t);
- HandleMark hm(t);
- JfrThreadConstant type_thread(t);
- JfrCheckpointWriter writer(t, true, THREADS);
- writer.write_type(TYPE_THREAD);
- type_thread.serialize(writer);
- // create and install a checkpoint blob
- t->jfr_thread_local()->set_thread_blob(writer.move());
- assert(t->jfr_thread_local()->has_thread_blob(), "invariant");
-}
-
-void JfrTypeManager::write_thread_checkpoint(Thread* t) {
- assert(t != NULL, "invariant");
- ResourceMark rm(t);
- HandleMark hm(t);
- JfrThreadConstant type_thread(t);
- JfrCheckpointWriter writer(t, true, THREADS);
- writer.write_type(TYPE_THREAD);
- type_thread.serialize(writer);
-}
-
#ifdef ASSERT
static void assert_not_registered_twice(JfrTypeId id, List& list) {
const Iterator iter(list);
@@ -237,14 +222,15 @@
}
#endif
-static bool register_type(JfrTypeId id, bool permit_cache, JfrSerializer* serializer) {
+static bool new_registration = false;
+
+static bool register_static_type(JfrTypeId id, bool permit_cache, JfrSerializer* serializer) {
assert(serializer != NULL, "invariant");
JfrSerializerRegistration* const registration = new JfrSerializerRegistration(id, permit_cache, serializer);
if (registration == NULL) {
delete serializer;
return false;
}
-
assert(!types.in_list(registration), "invariant");
DEBUG_ONLY(assert_not_registered_twice(id, types);)
if (Jfr::is_recording()) {
@@ -258,30 +244,30 @@
bool JfrTypeManager::initialize() {
SerializerRegistrationGuard guard;
- register_type(TYPE_FLAGVALUEORIGIN, true, new FlagValueOriginConstant());
- register_type(TYPE_INFLATECAUSE, true, new MonitorInflateCauseConstant());
- register_type(TYPE_GCCAUSE, true, new GCCauseConstant());
- register_type(TYPE_GCNAME, true, new GCNameConstant());
- register_type(TYPE_GCWHEN, true, new GCWhenConstant());
- register_type(TYPE_GCTHRESHOLDUPDATER, true, new GCThresholdUpdaterConstant());
- register_type(TYPE_METADATATYPE, true, new MetadataTypeConstant());
- register_type(TYPE_METASPACEOBJECTTYPE, true, new MetaspaceObjectTypeConstant());
- register_type(TYPE_REFERENCETYPE, true, new ReferenceTypeConstant());
- register_type(TYPE_NARROWOOPMODE, true, new NarrowOopModeConstant());
- register_type(TYPE_COMPILERPHASETYPE, true, new CompilerPhaseTypeConstant());
- register_type(TYPE_CODEBLOBTYPE, true, new CodeBlobTypeConstant());
- register_type(TYPE_VMOPERATIONTYPE, true, new VMOperationTypeConstant());
- register_type(TYPE_THREADSTATE, true, new ThreadStateConstant());
+ register_static_type(TYPE_FLAGVALUEORIGIN, true, new FlagValueOriginConstant());
+ register_static_type(TYPE_INFLATECAUSE, true, new MonitorInflateCauseConstant());
+ register_static_type(TYPE_GCCAUSE, true, new GCCauseConstant());
+ register_static_type(TYPE_GCNAME, true, new GCNameConstant());
+ register_static_type(TYPE_GCWHEN, true, new GCWhenConstant());
+ register_static_type(TYPE_GCTHRESHOLDUPDATER, true, new GCThresholdUpdaterConstant());
+ register_static_type(TYPE_METADATATYPE, true, new MetadataTypeConstant());
+ register_static_type(TYPE_METASPACEOBJECTTYPE, true, new MetaspaceObjectTypeConstant());
+ register_static_type(TYPE_REFERENCETYPE, true, new ReferenceTypeConstant());
+ register_static_type(TYPE_NARROWOOPMODE, true, new NarrowOopModeConstant());
+ register_static_type(TYPE_COMPILERPHASETYPE, true, new CompilerPhaseTypeConstant());
+ register_static_type(TYPE_CODEBLOBTYPE, true, new CodeBlobTypeConstant());
+ register_static_type(TYPE_VMOPERATIONTYPE, true, new VMOperationTypeConstant());
+ register_static_type(TYPE_THREADSTATE, true, new ThreadStateConstant());
return true;
}
// implementation for the static registration function exposed in the JfrSerializer api
bool JfrSerializer::register_serializer(JfrTypeId id, bool permit_cache, JfrSerializer* serializer) {
SerializerRegistrationGuard guard;
- return register_type(id, permit_cache, serializer);
+ return register_static_type(id, permit_cache, serializer);
}
-bool JfrTypeManager::is_new_constant_registered() {
+bool JfrTypeManager::has_new_static_type() {
if (new_registration) {
SerializerRegistrationGuard guard;
new_registration = false;
@@ -289,3 +275,12 @@
}
return false;
}
+
+void JfrTypeManager::write_static_types(JfrCheckpointWriter& writer) {
+ SerializerRegistrationGuard guard;
+ const Iterator iter(types);
+ while (iter.has_next()) {
+ iter.next()->invoke(writer);
+ }
+ new_registration = false;
+}