src/hotspot/share/gc/z/zNMethodTable.cpp

*** 1,7 ****
  /*
!  * Copyright (c) 2017, 2018, 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.
--- 1,7 ----
  /*
!  * Copyright (c) 2017, 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.
*** 25,44 ****
  #include "code/relocInfo.hpp"
  #include "code/nmethod.hpp"
  #include "code/icBuffer.hpp"
  #include "gc/shared/barrierSet.hpp"
  #include "gc/shared/barrierSetNMethod.hpp"
- #include "gc/z/zArray.inline.hpp"
  #include "gc/z/zGlobals.hpp"
  #include "gc/z/zHash.inline.hpp"
  #include "gc/z/zLock.inline.hpp"
  #include "gc/z/zNMethodTable.hpp"
  #include "gc/z/zOopClosures.inline.hpp"
  #include "gc/z/zTask.hpp"
  #include "gc/z/zWorkers.hpp"
  #include "logging/log.hpp"
! #include "memory/allocation.inline.hpp"
  #include "memory/resourceArea.hpp"
  #include "runtime/atomic.hpp"
  #include "runtime/orderAccess.hpp"
  #include "utilities/debug.hpp"
  
--- 25,44 ----
  #include "code/relocInfo.hpp"
  #include "code/nmethod.hpp"
  #include "code/icBuffer.hpp"
  #include "gc/shared/barrierSet.hpp"
  #include "gc/shared/barrierSetNMethod.hpp"
  #include "gc/z/zGlobals.hpp"
  #include "gc/z/zHash.inline.hpp"
  #include "gc/z/zLock.inline.hpp"
+ #include "gc/z/zNMethodAllocator.hpp"
  #include "gc/z/zNMethodTable.hpp"
  #include "gc/z/zOopClosures.inline.hpp"
  #include "gc/z/zTask.hpp"
  #include "gc/z/zWorkers.hpp"
  #include "logging/log.hpp"
! #include "memory/allocation.hpp"
  #include "memory/resourceArea.hpp"
  #include "runtime/atomic.hpp"
  #include "runtime/orderAccess.hpp"
  #include "utilities/debug.hpp"
  
*** 70,85 ****
  
  ZNMethodDataOops* ZNMethodDataOops::create(const GrowableArray<oop*>& immediates, bool has_non_immediates) {
    // Allocate memory for the ZNMethodDataOops object
    // plus the immediate oop* array that follows right after.
    const size_t size = ZNMethodDataOops::header_size() + (sizeof(oop*) * immediates.length());
!   void* const data = NEW_C_HEAP_ARRAY(uint8_t, size, mtGC);
!   return ::new (data) ZNMethodDataOops(immediates, has_non_immediates);
  }
  
  void ZNMethodDataOops::destroy(ZNMethodDataOops* oops) {
!   ZNMethodTable::safe_delete(oops);
  }
  
  ZNMethodDataOops::ZNMethodDataOops(const GrowableArray<oop*>& immediates, bool has_non_immediates) :
      _nimmediates(immediates.length()),
      _has_non_immediates(has_non_immediates) {
--- 70,85 ----
  
  ZNMethodDataOops* ZNMethodDataOops::create(const GrowableArray<oop*>& immediates, bool has_non_immediates) {
    // Allocate memory for the ZNMethodDataOops object
    // plus the immediate oop* array that follows right after.
    const size_t size = ZNMethodDataOops::header_size() + (sizeof(oop*) * immediates.length());
!   void* const mem = ZNMethodAllocator::allocate(size);
!   return ::new (mem) ZNMethodDataOops(immediates, has_non_immediates);
  }
  
  void ZNMethodDataOops::destroy(ZNMethodDataOops* oops) {
!   ZNMethodAllocator::free(oops);
  }
  
  ZNMethodDataOops::ZNMethodDataOops(const GrowableArray<oop*>& immediates, bool has_non_immediates) :
      _nimmediates(immediates.length()),
      _has_non_immediates(has_non_immediates) {
*** 122,138 ****
    ZNMethodDataOops* oops() const;
    ZNMethodDataOops* swap_oops(ZNMethodDataOops* oops);
  };
  
  ZNMethodData* ZNMethodData::create(nmethod* nm) {
!   void* const method = NEW_C_HEAP_ARRAY(uint8_t, sizeof(ZNMethodData), mtGC);
!   return ::new (method) ZNMethodData(nm);
  }
  
  void ZNMethodData::destroy(ZNMethodData* data) {
!   ZNMethodDataOops::destroy(data->oops());
!   ZNMethodTable::safe_delete(data);
  }
  
  ZNMethodData::ZNMethodData(nmethod* nm) :
      _lock(),
      _oops(NULL) {}
--- 122,138 ----
    ZNMethodDataOops* oops() const;
    ZNMethodDataOops* swap_oops(ZNMethodDataOops* oops);
  };
  
  ZNMethodData* ZNMethodData::create(nmethod* nm) {
!   void* const mem = ZNMethodAllocator::allocate(sizeof(ZNMethodData));
!   return ::new (mem) ZNMethodData(nm);
  }
  
  void ZNMethodData::destroy(ZNMethodData* data) {
!   ZNMethodAllocator::free(data->oops());
!   ZNMethodAllocator::free(data);
  }
  
  ZNMethodData::ZNMethodData(nmethod* nm) :
      _lock(),
      _oops(NULL) {}
*** 159,189 ****
  
  ZNMethodTableEntry* ZNMethodTable::_table = NULL;
  size_t ZNMethodTable::_size = 0;
  ZNMethodTableEntry* ZNMethodTable::_iter_table = NULL;
  size_t ZNMethodTable::_iter_table_size = 0;
- ZArray<void*> ZNMethodTable::_iter_deferred_deletes;
  size_t ZNMethodTable::_nregistered = 0;
  size_t ZNMethodTable::_nunregistered = 0;
  volatile size_t ZNMethodTable::_claimed = 0;
  
- void ZNMethodTable::safe_delete(void* data) {
-   assert(CodeCache_lock->owned_by_self(), "Lock must be held");
- 
-   if (data == NULL) {
-     return;
-   }
- 
-   if (_iter_table != NULL) {
-     // Iteration in progress, defer delete
-     _iter_deferred_deletes.add(data);
-   } else {
-     // Iteration not in progress, delete now
-     FREE_C_HEAP_ARRAY(uint8_t, data);
-   }
- }
- 
  void ZNMethodTable::attach_gc_data(nmethod* nm) {
    GrowableArray<oop*> immediate_oops;
    bool non_immediate_oops = false;
  
    // Find all oops relocations
--- 159,172 ----
*** 477,491 ****
  }
  
  void ZNMethodTable::nmethods_do_begin() {
    MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
  
    // Prepare iteration
    _iter_table = _table;
    _iter_table_size = _size;
    _claimed = 0;
-   assert(_iter_deferred_deletes.is_empty(), "Should be emtpy");
  }
  
  void ZNMethodTable::nmethods_do_end() {
    MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
  
--- 460,476 ----
  }
  
  void ZNMethodTable::nmethods_do_begin() {
    MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
  
+   // Make sure we don't free data while iterating
+   ZNMethodAllocator::activate_deferred_frees();
+ 
    // Prepare iteration
    _iter_table = _table;
    _iter_table_size = _size;
    _claimed = 0;
  }
  
  void ZNMethodTable::nmethods_do_end() {
    MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
  
*** 495,510 ****
    }
    _iter_table = NULL;
  
    assert(_claimed >= _iter_table_size, "Failed to claim all table entries");
  
!   // Process deferred deletes
!   ZArrayIterator<void*> iter(&_iter_deferred_deletes);
!   for (void* data; iter.next(&data);) {
!     FREE_C_HEAP_ARRAY(uint8_t, data);
!   }
!   _iter_deferred_deletes.clear();
  
    // Notify iteration done
    CodeCache_lock->notify_all();
  }
  
--- 480,491 ----
    }
    _iter_table = NULL;
  
    assert(_claimed >= _iter_table_size, "Failed to claim all table entries");
  
!   // Process deferred frees
!   ZNMethodAllocator::deactivate_and_process_deferred_frees();
  
    // Notify iteration done
    CodeCache_lock->notify_all();
  }