< prev index next >

src/hotspot/share/code/nmethod.cpp


1555 
1556 public:                                                                                                                              
1557   static bool is_unloading(uint8_t state) { return (state & _is_unloading_mask) >> _is_unloading_shift == 1; }                       
1558   static uint8_t unloading_cycle(uint8_t state) { return (state & _unloading_cycle_mask) >> _unloading_cycle_shift; }                
1559 
1560   static uint8_t create(bool is_unloading, uint8_t unloading_cycle) {                                                                
1561     uint8_t state = 0;                                                                                                               
1562     state = set_is_unloading(state, is_unloading);                                                                                   
1563     state = set_unloading_cycle(state, unloading_cycle);                                                                             
1564     return state;                                                                                                                    
1565   }                                                                                                                                  
1566 };                                                                                                                                   
1567 
1568 bool nmethod::is_unloading() {                                                                                                       
1569   uint8_t state = RawAccess<MO_RELAXED>::load(&_is_unloading_state);                                                                 
1570   bool state_is_unloading = IsUnloadingState::is_unloading(state);                                                                   
1571   uint8_t state_unloading_cycle = IsUnloadingState::unloading_cycle(state);                                                          
1572   if (state_is_unloading) {                                                                                                          
1573     return true;                                                                                                                     
1574   }                                                                                                                                  
1575   if (state_unloading_cycle == CodeCache::unloading_cycle()) {                                                                       
                                                                                                                                     
1576     return false;                                                                                                                    
1577   }                                                                                                                                  
1578 
1579   // The IsUnloadingBehaviour is responsible for checking if there are any dead                                                      
1580   // oops in the CompiledMethod, by calling oops_do on it.                                                                           
1581   state_unloading_cycle = CodeCache::unloading_cycle();                                                                              
1582 
1583   if (is_zombie()) {                                                                                                                 
1584     // Zombies without calculated unloading epoch are never unloading due to GC.                                                     
1585     state_is_unloading = false;                                                                                                      
1586   } else {                                                                                                                           
1587     state_is_unloading = IsUnloadingBehaviour::current()->is_unloading(this);                                                        
1588   }                                                                                                                                  
1589 
1590   state = IsUnloadingState::create(state_is_unloading, state_unloading_cycle);                                                       
1591 
1592   RawAccess<MO_RELAXED>::store(&_is_unloading_state, state);                                                                         
1593 
1594   return state_is_unloading;                                                                                                         
1595 }                                                                                                                                    
1596 
1597 void nmethod::clear_unloading_state() {                                                                                              
1598   uint8_t state = IsUnloadingState::create(false, CodeCache::unloading_cycle());                                                     
1599   RawAccess<MO_RELAXED>::store(&_is_unloading_state, state);                                                                         
1600 }                                                                                                                                    

1555 
1556 public:
1557   static bool is_unloading(uint8_t state) { return (state & _is_unloading_mask) >> _is_unloading_shift == 1; }
1558   static uint8_t unloading_cycle(uint8_t state) { return (state & _unloading_cycle_mask) >> _unloading_cycle_shift; }
1559 
1560   static uint8_t create(bool is_unloading, uint8_t unloading_cycle) {
1561     uint8_t state = 0;
1562     state = set_is_unloading(state, is_unloading);
1563     state = set_unloading_cycle(state, unloading_cycle);
1564     return state;
1565   }
1566 };
1567 
1568 bool nmethod::is_unloading() {
1569   uint8_t state = RawAccess<MO_RELAXED>::load(&_is_unloading_state);
1570   bool state_is_unloading = IsUnloadingState::is_unloading(state);
1571   uint8_t state_unloading_cycle = IsUnloadingState::unloading_cycle(state);
1572   if (state_is_unloading) {
1573     return true;
1574   }
1575   uint8_t current_cycle = CodeCache::unloading_cycle();
1576   if (state_unloading_cycle == current_cycle) {
1577     return false;
1578   }
1579 
1580   // The IsUnloadingBehaviour is responsible for checking if there are any dead
1581   // oops in the CompiledMethod, by calling oops_do on it.
1582   state_unloading_cycle = current_cycle;
1583 
1584   if (is_zombie()) {
1585     // Zombies without calculated unloading epoch are never unloading due to GC.
1586     state_is_unloading = false;
1587   } else {
1588     state_is_unloading = IsUnloadingBehaviour::current()->is_unloading(this);
1589   }
1590 
1591   state = IsUnloadingState::create(state_is_unloading, state_unloading_cycle);
1592 
1593   RawAccess<MO_RELAXED>::store(&_is_unloading_state, state);
1594 
1595   return state_is_unloading;
1596 }
1597 
1598 void nmethod::clear_unloading_state() {
1599   uint8_t state = IsUnloadingState::create(false, CodeCache::unloading_cycle());
1600   RawAccess<MO_RELAXED>::store(&_is_unloading_state, state);
1601 }
< prev index next >