89 lines
3.3 KiB
C++
89 lines
3.3 KiB
C++
|
/*
|
||
|
|
* Copyright 2001-2006 Sun Microsystems, Inc. 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.
|
||
|
|
*
|
||
|
|
* This code is distributed in the hope that it will be useful, but WITHOUT
|
||
|
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||
|
|
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
||
|
|
* version 2 for more details (a copy is included in the LICENSE file that
|
||
|
|
* accompanied this code).
|
||
|
|
*
|
||
|
|
* You should have received a copy of the GNU General Public License version
|
||
|
|
* 2 along with this work; if not, write to the Free Software Foundation,
|
||
|
|
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
||
|
|
*
|
||
|
|
* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
|
||
|
|
* CA 95054 USA or visit www.sun.com if you need additional information or
|
||
|
|
* have any questions.
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
|
||
|
|
CompactibleSpace* DefNewGeneration::first_compaction_space() const {
|
||
|
|
return eden();
|
||
|
|
}
|
||
|
|
|
||
|
|
HeapWord* DefNewGeneration::allocate(size_t word_size,
|
||
|
|
bool is_tlab) {
|
||
|
|
// This is the slow-path allocation for the DefNewGeneration.
|
||
|
|
// Most allocations are fast-path in compiled code.
|
||
|
|
// We try to allocate from the eden. If that works, we are happy.
|
||
|
|
// Note that since DefNewGeneration supports lock-free allocation, we
|
||
|
|
// have to use it here, as well.
|
||
|
|
HeapWord* result = eden()->par_allocate(word_size);
|
||
|
|
if (result != NULL) {
|
||
|
|
return result;
|
||
|
|
}
|
||
|
|
do {
|
||
|
|
HeapWord* old_limit = eden()->soft_end();
|
||
|
|
if (old_limit < eden()->end()) {
|
||
|
|
// Tell the next generation we reached a limit.
|
||
|
|
HeapWord* new_limit =
|
||
|
|
next_gen()->allocation_limit_reached(eden(), eden()->top(), word_size);
|
||
|
|
if (new_limit != NULL) {
|
||
|
|
Atomic::cmpxchg_ptr(new_limit, eden()->soft_end_addr(), old_limit);
|
||
|
|
} else {
|
||
|
|
assert(eden()->soft_end() == eden()->end(),
|
||
|
|
"invalid state after allocation_limit_reached returned null");
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
// The allocation failed and the soft limit is equal to the hard limit,
|
||
|
|
// there are no reasons to do an attempt to allocate
|
||
|
|
assert(old_limit == eden()->end(), "sanity check");
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
// Try to allocate until succeeded or the soft limit can't be adjusted
|
||
|
|
result = eden()->par_allocate(word_size);
|
||
|
|
} while (result == NULL);
|
||
|
|
|
||
|
|
// If the eden is full and the last collection bailed out, we are running
|
||
|
|
// out of heap space, and we try to allocate the from-space, too.
|
||
|
|
// allocate_from_space can't be inlined because that would introduce a
|
||
|
|
// circular dependency at compile time.
|
||
|
|
if (result == NULL) {
|
||
|
|
result = allocate_from_space(word_size);
|
||
|
|
}
|
||
|
|
return result;
|
||
|
|
}
|
||
|
|
|
||
|
|
HeapWord* DefNewGeneration::par_allocate(size_t word_size,
|
||
|
|
bool is_tlab) {
|
||
|
|
return eden()->par_allocate(word_size);
|
||
|
|
}
|
||
|
|
|
||
|
|
void DefNewGeneration::gc_prologue(bool full) {
|
||
|
|
// Ensure that _end and _soft_end are the same in eden space.
|
||
|
|
eden()->set_soft_end(eden()->end());
|
||
|
|
}
|
||
|
|
|
||
|
|
size_t DefNewGeneration::tlab_capacity() const {
|
||
|
|
return eden()->capacity();
|
||
|
|
}
|
||
|
|
|
||
|
|
size_t DefNewGeneration::unsafe_max_tlab_alloc() const {
|
||
|
|
return unsafe_max_alloc_nogc();
|
||
|
|
}
|