< prev index next >

src/hotspot/share/jfr/recorder/checkpoint/types/jfrTypeManager.cpp


140 
141 void JfrTypeManager::write_safepoint_types(JfrCheckpointWriter& writer) {                                                            
142   assert(SafepointSynchronize::is_at_safepoint(), "invariant");                                                                      
143   const Iterator iter(safepoint_types);                                                                                              
144   while (iter.has_next()) {                                                                                                          
145     iter.next()->invoke(writer);                                                                                                     
146   }                                                                                                                                  
147 }                                                                                                                                    
148 
149 void JfrTypeManager::write_type_set() {                                                                                              
150   // can safepoint here because of Module_lock                                                                                       
151   MutexLockerEx cld_lock(SafepointSynchronize::is_at_safepoint() ? NULL : ClassLoaderDataGraph_lock);                                
152   MutexLockerEx lock(SafepointSynchronize::is_at_safepoint() ? NULL : Module_lock);                                                  
153 
154   JfrCheckpointWriter writer(true, true, Thread::current());                                                                         
155   TypeSet set;                                                                                                                       
156   set.serialize(writer);                                                                                                             
157 }                                                                                                                                    
158 
159 void JfrTypeManager::write_type_set_for_unloaded_classes() {                                                                         
160   assert(SafepointSynchronize::is_at_safepoint(), "invariant");                                                                      
161   JfrCheckpointWriter writer(false, true, Thread::current());                                                                        
162   ClassUnloadTypeSet class_unload_set;                                                                                               
163   class_unload_set.serialize(writer);                                                                                                
164 }                                                                                                                                    
165 
166 void JfrTypeManager::create_thread_checkpoint(JavaThread* jt) {                                                                      
167   assert(jt != NULL, "invariant");                                                                                                   
168   JfrThreadConstant type_thread(jt);                                                                                                 
169   JfrCheckpointWriter writer(false, true, jt);                                                                                       
170   writer.write_type(TYPE_THREAD);                                                                                                    
171   type_thread.serialize(writer);                                                                                                     
172   // create and install a checkpoint blob                                                                                            
173   jt->jfr_thread_local()->set_thread_checkpoint(writer.checkpoint_blob());                                                           
174   assert(jt->jfr_thread_local()->has_thread_checkpoint(), "invariant");                                                              
175 }                                                                                                                                    
176 
177 void JfrTypeManager::write_thread_checkpoint(JavaThread* jt) {                                                                       
178   assert(jt != NULL, "JavaThread is NULL!");                                                                                         
179   ResourceMark rm(jt);                                                                                                               

140 
141 void JfrTypeManager::write_safepoint_types(JfrCheckpointWriter& writer) {
142   assert(SafepointSynchronize::is_at_safepoint(), "invariant");
143   const Iterator iter(safepoint_types);
144   while (iter.has_next()) {
145     iter.next()->invoke(writer);
146   }
147 }
148 
149 void JfrTypeManager::write_type_set() {
150   // can safepoint here because of Module_lock
151   MutexLockerEx cld_lock(SafepointSynchronize::is_at_safepoint() ? NULL : ClassLoaderDataGraph_lock);
152   MutexLockerEx lock(SafepointSynchronize::is_at_safepoint() ? NULL : Module_lock);
153 
154   JfrCheckpointWriter writer(true, true, Thread::current());
155   TypeSet set;
156   set.serialize(writer);
157 }
158 
159 void JfrTypeManager::write_type_set_for_unloaded_classes() {

160   JfrCheckpointWriter writer(false, true, Thread::current());
161   ClassUnloadTypeSet class_unload_set;
162   class_unload_set.serialize(writer);
163 }
164 
165 void JfrTypeManager::create_thread_checkpoint(JavaThread* jt) {
166   assert(jt != NULL, "invariant");
167   JfrThreadConstant type_thread(jt);
168   JfrCheckpointWriter writer(false, true, jt);
169   writer.write_type(TYPE_THREAD);
170   type_thread.serialize(writer);
171   // create and install a checkpoint blob
172   jt->jfr_thread_local()->set_thread_checkpoint(writer.checkpoint_blob());
173   assert(jt->jfr_thread_local()->has_thread_checkpoint(), "invariant");
174 }
175 
176 void JfrTypeManager::write_thread_checkpoint(JavaThread* jt) {
177   assert(jt != NULL, "JavaThread is NULL!");
178   ResourceMark rm(jt);
< prev index next >