infernap12/jdk
1
0
Fork 0
mirror of https://github.com/openjdk/jdk.git synced 2026-05-28 14:22:24 +00:00
Code Issues Packages Projects Releases Wiki Activity

8182169: ArrayAllocator should take MEMFLAGS as regular parameter

Browse Source 
Change ArrayAllocator memflags from template parameter to ordinary function parameters

Reviewed-by: kbarrett, tschatzl
This commit is contained in:
Milan Mimica 2017-07-21 21:01:59 -04:00 committed by Kim Barrett
parent 3fbf0c2e96
commit f647f78764
7 changed files with 62 additions and 62 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
hotspot/src/share/vm/gc/g1/g1CardLiveData.cpp
View File

@ -55,13 +55,13 @@ G1CardLiveData::~G1CardLiveData() {
G1CardLiveData::bm_word_t* G1CardLiveData::allocate_large_bitmap(size_t size_in_bits) {
size_t size_in_words = BitMap::calc_size_in_words(size_in_bits);
bm_word_t* map = MmapArrayAllocator<bm_word_t, mtGC>::allocate(size_in_words);
bm_word_t* map = MmapArrayAllocator<bm_word_t>::allocate(size_in_words, mtGC);
return map;
}
void G1CardLiveData::free_large_bitmap(bm_word_t* bitmap, size_t size_in_bits) {
MmapArrayAllocator<bm_word_t, mtGC>::free(bitmap, BitMap::calc_size_in_words(size_in_bits));
MmapArrayAllocator<bm_word_t>::free(bitmap, BitMap::calc_size_in_words(size_in_bits));
}
void G1CardLiveData::initialize(size_t max_capacity, uint num_max_regions) {

6
hotspot/src/share/vm/gc/g1/g1ConcurrentMark.cpp
View File

@ -144,7 +144,7 @@ bool G1CMMarkStack::resize(size_t new_capacity) {
assert(new_capacity <= _max_chunk_capacity,
"Trying to resize stack to " SIZE_FORMAT " chunks when the maximum is " SIZE_FORMAT, new_capacity, _max_chunk_capacity);
TaskQueueEntryChunk* new_base = MmapArrayAllocator<TaskQueueEntryChunk, mtGC>::allocate_or_null(new_capacity);
TaskQueueEntryChunk* new_base = MmapArrayAllocator<TaskQueueEntryChunk>::allocate_or_null(new_capacity, mtGC);
if (new_base == NULL) {
log_warning(gc)("Failed to reserve memory for new overflow mark stack with " SIZE_FORMAT " chunks and size " SIZE_FORMAT "B.", new_capacity, new_capacity * sizeof(TaskQueueEntryChunk));
@ -152,7 +152,7 @@ bool G1CMMarkStack::resize(size_t new_capacity) {
}
// Release old mapping.
if (_base != NULL) {
MmapArrayAllocator<TaskQueueEntryChunk, mtGC>::free(_base, _chunk_capacity);
MmapArrayAllocator<TaskQueueEntryChunk>::free(_base, _chunk_capacity);
}
_base = new_base;
@ -205,7 +205,7 @@ void G1CMMarkStack::expand() {
G1CMMarkStack::~G1CMMarkStack() {
if (_base != NULL) {
MmapArrayAllocator<TaskQueueEntryChunk, mtGC>::free(_base, _chunk_capacity);
MmapArrayAllocator<TaskQueueEntryChunk>::free(_base, _chunk_capacity);
}
}

4
hotspot/src/share/vm/gc/g1/g1HotCardCache.cpp
View File

@ -36,7 +36,7 @@ void G1HotCardCache::initialize(G1RegionToSpaceMapper* card_counts_storage) {
_use_cache = true;
_hot_cache_size = (size_t)1 << G1ConcRSLogCacheSize;
_hot_cache = ArrayAllocator<jbyte*, mtGC>::allocate(_hot_cache_size);
_hot_cache = ArrayAllocator<jbyte*>::allocate(_hot_cache_size, mtGC);
reset_hot_cache_internal();
@ -51,7 +51,7 @@ void G1HotCardCache::initialize(G1RegionToSpaceMapper* card_counts_storage) {
G1HotCardCache::~G1HotCardCache() {
if (default_use_cache()) {
assert(_hot_cache != NULL, "Logic");
ArrayAllocator<jbyte*, mtGC>::free(_hot_cache, _hot_cache_size);
ArrayAllocator<jbyte*>::free(_hot_cache, _hot_cache_size);
_hot_cache = NULL;
}
}

4
hotspot/src/share/vm/gc/shared/taskqueue.inline.hpp
View File

@ -44,13 +44,13 @@ inline GenericTaskQueueSet<T, F>::GenericTaskQueueSet(int n) : _n(n) {
template<class E, MEMFLAGS F, unsigned int N>
inline void GenericTaskQueue<E, F, N>::initialize() {
_elems = ArrayAllocator<E, F>::allocate(N);
_elems = ArrayAllocator<E>::allocate(N, F);
}
template<class E, MEMFLAGS F, unsigned int N>
inline GenericTaskQueue<E, F, N>::~GenericTaskQueue() {
assert(false, "This code is currently never called");
ArrayAllocator<E, F>::free(const_cast<E*>(_elems), N);
ArrayAllocator<E>::free(const_cast<E*>(_elems), N);
}
template<class E, MEMFLAGS F, unsigned int N>

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

@ -718,43 +718,43 @@ public:
// to mapped memory for large allocations. By default ArrayAllocatorMallocLimit
// is set so that we always use malloc except for Solaris where we set the
// limit to get mapped memory.
template <class E, MEMFLAGS F>
template <class E>
class ArrayAllocator : public AllStatic {
private:
static bool should_use_malloc(size_t length);
static E* allocate_malloc(size_t length);
static E* allocate_mmap(size_t length);
static E* allocate_malloc(size_t length, MEMFLAGS flags);
static E* allocate_mmap(size_t length, MEMFLAGS flags);
static void free_malloc(E* addr, size_t length);
static void free_mmap(E* addr, size_t length);
public:
static E* allocate(size_t length);
static E* reallocate(E* old_addr, size_t old_length, size_t new_length);
static E* allocate(size_t length, MEMFLAGS flags);
static E* reallocate(E* old_addr, size_t old_length, size_t new_length, MEMFLAGS flags);
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>
template <class E>
class MmapArrayAllocator : public AllStatic {
private:
static size_t size_for(size_t length);
public:
static E* allocate_or_null(size_t length);
static E* allocate(size_t length);
static E* allocate_or_null(size_t length, MEMFLAGS flags);
static E* allocate(size_t length, MEMFLAGS flags);
static void free(E* addr, size_t length);
};
// Uses malloc:ed memory for all allocations.
template <class E, MEMFLAGS F>
template <class E>
class MallocArrayAllocator : public AllStatic {
public:
static size_t size_for(size_t length);
static E* allocate(size_t length);
static E* allocate(size_t length, MEMFLAGS flags);
static void free(E* addr, size_t length);
};

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

@ -146,19 +146,19 @@ 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) {
template <class E>
size_t MmapArrayAllocator<E>::size_for(size_t length) {
size_t size = length * sizeof(E);
int alignment = os::vm_allocation_granularity();
return align_up(size, alignment);
}
template <class E, MEMFLAGS F>
E* MmapArrayAllocator<E, F>::allocate_or_null(size_t length) {
template <class E>
E* MmapArrayAllocator<E>::allocate_or_null(size_t length, MEMFLAGS flags) {
size_t size = size_for(length);
int alignment = os::vm_allocation_granularity();
char* addr = os::reserve_memory(size, NULL, alignment, F);
char* addr = os::reserve_memory(size, NULL, alignment, flags);
if (addr == NULL) {
return NULL;
}
@ -171,12 +171,12 @@ E* MmapArrayAllocator<E, F>::allocate_or_null(size_t length) {
}
}
template <class E, MEMFLAGS F>
E* MmapArrayAllocator<E, F>::allocate(size_t length) {
template <class E>
E* MmapArrayAllocator<E>::allocate(size_t length, MEMFLAGS flags) {
size_t size = size_for(length);
int alignment = os::vm_allocation_granularity();
char* addr = os::reserve_memory(size, NULL, alignment, F);
char* addr = os::reserve_memory(size, NULL, alignment, flags);
if (addr == NULL) {
vm_exit_out_of_memory(size, OOM_MMAP_ERROR, "Allocator (reserve)");
}
@ -186,55 +186,55 @@ E* MmapArrayAllocator<E, F>::allocate(size_t length) {
return (E*)addr;
}
template <class E, MEMFLAGS F>
void MmapArrayAllocator<E, F>::free(E* addr, size_t length) {
template <class E>
void MmapArrayAllocator<E>::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) {
template <class E>
size_t MallocArrayAllocator<E>::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>
E* MallocArrayAllocator<E>::allocate(size_t length, MEMFLAGS flags) {
return (E*)AllocateHeap(size_for(length), flags);
}
template<class E, MEMFLAGS F>
void MallocArrayAllocator<E, F>::free(E* addr, size_t /*length*/) {
template<class E>
void MallocArrayAllocator<E>::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>
bool ArrayAllocator<E>::should_use_malloc(size_t length) {
return MallocArrayAllocator<E>::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>
E* ArrayAllocator<E>::allocate_malloc(size_t length, MEMFLAGS flags) {
return MallocArrayAllocator<E>::allocate(length, flags);
}
template <class E, MEMFLAGS F>
E* ArrayAllocator<E, F>::allocate_mmap(size_t length) {
return MmapArrayAllocator<E, F>::allocate(length);
template <class E>
E* ArrayAllocator<E>::allocate_mmap(size_t length, MEMFLAGS flags) {
return MmapArrayAllocator<E>::allocate(length, flags);
}
template <class E, MEMFLAGS F>
E* ArrayAllocator<E, F>::allocate(size_t length) {
template <class E>
E* ArrayAllocator<E>::allocate(size_t length, MEMFLAGS flags) {
if (should_use_malloc(length)) {
return allocate_malloc(length);
return allocate_malloc(length, flags);
}
return allocate_mmap(length);
return allocate_mmap(length, flags);
}
template <class E, MEMFLAGS F>
E* ArrayAllocator<E, F>::reallocate(E* old_addr, size_t old_length, size_t new_length) {
template <class E>
E* ArrayAllocator<E>::reallocate(E* old_addr, size_t old_length, size_t new_length, MEMFLAGS flags) {
E* new_addr = (new_length > 0)
? allocate(new_length)
? allocate(new_length, flags)
: NULL;
if (new_addr != NULL && old_addr != NULL) {
@ -248,18 +248,18 @@ E* ArrayAllocator<E, F>::reallocate(E* old_addr, size_t old_length, size_t new_l
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>
void ArrayAllocator<E>::free_malloc(E* addr, size_t length) {
MallocArrayAllocator<E>::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>
void ArrayAllocator<E>::free_mmap(E* addr, size_t length) {
MmapArrayAllocator<E>::free(addr, length);
}
template<class E, MEMFLAGS F>
void ArrayAllocator<E, F>::free(E* addr, size_t length) {
template<class E>
void ArrayAllocator<E>::free(E* addr, size_t length) {
if (addr != NULL) {
if (should_use_malloc(length)) {
free_malloc(addr, length);

4
hotspot/src/share/vm/utilities/bitMap.cpp
View File

@ -48,10 +48,10 @@ class ResourceBitMapAllocator : StackObj {
class CHeapBitMapAllocator : StackObj {
public:
bm_word_t* allocate(size_t size_in_words) const {
return ArrayAllocator<bm_word_t, mtInternal>::allocate(size_in_words);
return ArrayAllocator<bm_word_t>::allocate(size_in_words, mtInternal);
}
void free(bm_word_t* map, idx_t size_in_words) const {
ArrayAllocator<bm_word_t, mtInternal>::free(map, size_in_words);
ArrayAllocator<bm_word_t>::free(map, size_in_words);
}
};