src/share/vm/memory/allocation.inline.hpp

*** 149,182 ****
  template <MEMFLAGS F> void CHeapObj<F>::operator delete [](void* p){
      FreeHeap(p);
  }
  
  template <class E, MEMFLAGS F>
! size_t ArrayAllocator<E, F>::size_for_malloc(size_t length) {
!   return length * sizeof(E);
! }
! 
! template <class E, MEMFLAGS F>
! size_t ArrayAllocator<E, F>::size_for_mmap(size_t length) {
    size_t size = length * sizeof(E);
    int alignment = os::vm_allocation_granularity();
    return align_size_up(size, alignment);
  }
  
  template <class E, MEMFLAGS F>
! bool ArrayAllocator<E, F>::should_use_malloc(size_t length) {
!   return size_for_malloc(length) < ArrayAllocatorMallocLimit;
! }
! 
! template <class E, MEMFLAGS F>
! E* ArrayAllocator<E, F>::allocate_malloc(size_t length) {
!   return (E*)AllocateHeap(size_for_malloc(length), F);
! }
! 
! template <class E, MEMFLAGS F>
! E* ArrayAllocator<E, F>::allocate_mmap(size_t length) {
!   size_t size = size_for_mmap(length);
    int alignment = os::vm_allocation_granularity();
  
    char* addr = os::reserve_memory(size, NULL, alignment, F);
    if (addr == NULL) {
      vm_exit_out_of_memory(size, OOM_MMAP_ERROR, "Allocator (reserve)");
--- 149,167 ----
  template <MEMFLAGS F> void CHeapObj<F>::operator delete [](void* p){
      FreeHeap(p);
  }
  
  template <class E, MEMFLAGS F>
! size_t MmapArrayAllocator<E, F>::size_for(size_t length) {
    size_t size = length * sizeof(E);
    int alignment = os::vm_allocation_granularity();
    return align_size_up(size, alignment);
  }
  
  template <class E, MEMFLAGS F>
! E* MmapArrayAllocator<E, F>::allocate(size_t length) {
!   size_t size = size_for(length);
    int alignment = os::vm_allocation_granularity();
  
    char* addr = os::reserve_memory(size, NULL, alignment, F);
    if (addr == NULL) {
      vm_exit_out_of_memory(size, OOM_MMAP_ERROR, "Allocator (reserve)");
*** 186,195 ****
--- 171,216 ----
  
    return (E*)addr;
  }
  
  template <class E, MEMFLAGS F>
+ void MmapArrayAllocator<E, F>::free(E* addr, size_t length) {
+   bool result = os::release_memory((char*)addr, size_for(length));
+   assert(result, "Failed to release memory");
+ }
+ 
+ template <class E, MEMFLAGS F>
+ size_t MallocArrayAllocator<E, F>::size_for(size_t length) {
+   return length * sizeof(E);
+ }
+ 
+ template <class E, MEMFLAGS F>
+ E* MallocArrayAllocator<E, F>::allocate(size_t length) {
+   return (E*)AllocateHeap(size_for(length), F);
+ }
+ 
+ template<class E, MEMFLAGS F>
+ void MallocArrayAllocator<E, F>::free(E* addr, size_t /*length*/) {
+   FreeHeap(addr);
+ }
+ 
+ template <class E, MEMFLAGS F>
+ bool ArrayAllocator<E, F>::should_use_malloc(size_t length) {
+   return MallocArrayAllocator<E, F>::size_for(length) < ArrayAllocatorMallocLimit;
+ }
+ 
+ template <class E, MEMFLAGS F>
+ E* ArrayAllocator<E, F>::allocate_malloc(size_t length) {
+   return MallocArrayAllocator<E, F>::allocate(length);
+ }
+ 
+ template <class E, MEMFLAGS F>
+ E* ArrayAllocator<E, F>::allocate_mmap(size_t length) {
+   return MmapArrayAllocator<E, F>::allocate(length);
+ }
+ 
+ template <class E, MEMFLAGS F>
  E* ArrayAllocator<E, F>::allocate(size_t length) {
    if (should_use_malloc(length)) {
      return allocate_malloc(length);
    }
  
*** 212,229 ****
  
    return new_addr;
  }
  
  template<class E, MEMFLAGS F>
! void ArrayAllocator<E, F>::free_malloc(E* addr, size_t /*length*/) {
!   FreeHeap(addr);
  }
  
  template<class E, MEMFLAGS F>
  void ArrayAllocator<E, F>::free_mmap(E* addr, size_t length) {
!   bool result = os::release_memory((char*)addr, size_for_mmap(length));
!   assert(result, "Failed to release memory");
  }
  
  template<class E, MEMFLAGS F>
  void ArrayAllocator<E, F>::free(E* addr, size_t length) {
    if (addr != NULL) {
--- 233,249 ----
  
    return new_addr;
  }
  
  template<class E, MEMFLAGS F>
! void ArrayAllocator<E, F>::free_malloc(E* addr, size_t length) {
!   MallocArrayAllocator<E, F>::free(addr, length);
  }
  
  template<class E, MEMFLAGS F>
  void ArrayAllocator<E, F>::free_mmap(E* addr, size_t length) {
!   MmapArrayAllocator<E, F>::free(addr, length);
  }
  
  template<class E, MEMFLAGS F>
  void ArrayAllocator<E, F>::free(E* addr, size_t length) {
    if (addr != NULL) {