infernap12/jdk
1
0
Fork 0
mirror of https://github.com/openjdk/jdk.git synced 2026-02-15 04:45:25 +00:00
Code Issues Packages Projects Releases Wiki Activity

8151534: Refactor ArrayAllocator for easier reuse

Browse Source 
Reviewed-by: tschatzl, brutisso
This commit is contained in:
Stefan Karlsson 2016-03-09 17:03:04 +01:00
parent 32165d2889
commit 3fa2f0cd11
2 changed files with 64 additions and 25 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

25
hotspot/src/share/vm/memory/allocation.hpp
View File

@ -716,9 +716,6 @@ class ArrayAllocator : public AllStatic {
private:
static bool should_use_malloc(size_t length);
static size_t size_for_malloc(size_t length);
static size_t size_for_mmap(size_t length);
static E* allocate_malloc(size_t length);
static E* allocate_mmap(size_t length);
@ -731,4 +728,26 @@ class ArrayAllocator : public AllStatic {
static void free(E* addr, size_t length);
};
// Uses mmaped memory for all allocations. All allocations are initially
// zero-filled. No pre-touching.
template <class E, MEMFLAGS F>
class MmapArrayAllocator : public AllStatic {
private:
static size_t size_for(size_t length);
public:
static E* allocate(size_t length);
static void free(E* addr, size_t length);
};
// Uses malloc:ed memory for all allocations.
template <class E, MEMFLAGS F>
class MallocArrayAllocator : public AllStatic {
public:
static size_t size_for(size_t length);
static E* allocate(size_t length);
static void free(E* addr, size_t length);
};
#endif // SHARE_VM_MEMORY_ALLOCATION_HPP

64
hotspot/src/share/vm/memory/allocation.inline.hpp
View File

@ -151,30 +151,15 @@ template <MEMFLAGS F> void CHeapObj<F>::operator delete [](void* 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 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>
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);
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);
@ -187,6 +172,42 @@ E* ArrayAllocator<E, F>::allocate_mmap(size_t length) {
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)) {
@ -214,14 +235,13 @@ E* ArrayAllocator<E, F>::reallocate(E* old_addr, size_t old_length, size_t new_l
}
template<class E, MEMFLAGS F>
void ArrayAllocator<E, F>::free_malloc(E* addr, size_t /*length*/) {
FreeHeap(addr);
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) {
bool result = os::release_memory((char*)addr, size_for_mmap(length));
assert(result, "Failed to release memory");
MmapArrayAllocator<E, F>::free(addr, length);
}
template<class E, MEMFLAGS F>