10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25 #include "precompiled.hpp"
26 #include "gc/parallel/objectStartArray.inline.hpp"
27 #include "gc/parallel/parallelScavengeHeap.hpp"
28 #include "gc/parallel/psAdaptiveSizePolicy.hpp"
29 #include "gc/parallel/psCardTable.hpp"
30 #include "gc/parallel/psMarkSweepDecorator.hpp"
31 #include "gc/parallel/psOldGen.hpp"
32 #include "gc/shared/cardTableBarrierSet.hpp"
33 #include "gc/shared/gcLocker.hpp"
34 #include "gc/shared/spaceDecorator.hpp"
35 #include "logging/log.hpp"
36 #include "oops/oop.inline.hpp"
37 #include "runtime/java.hpp"
38 #include "utilities/align.hpp"
39
40 inline const char* PSOldGen::select_name() {
41 return UseParallelOldGC ? "ParOldGen" : "PSOldGen";
42 }
43
44 PSOldGen::PSOldGen(ReservedSpace rs, size_t alignment,
45 size_t initial_size, size_t min_size, size_t max_size,
46 const char* perf_data_name, int level):
47 _name(select_name()), _init_gen_size(initial_size), _min_gen_size(min_size),
48 _max_gen_size(max_size)
49 {
54 size_t min_size, size_t max_size,
55 const char* perf_data_name, int level):
56 _name(select_name()), _init_gen_size(initial_size), _min_gen_size(min_size),
57 _max_gen_size(max_size)
58 {}
59
60 void PSOldGen::initialize(ReservedSpace rs, size_t alignment,
61 const char* perf_data_name, int level) {
62 initialize_virtual_space(rs, alignment);
63 initialize_work(perf_data_name, level);
64
65 // The old gen can grow to gen_size_limit(). _reserve reflects only
66 // the current maximum that can be committed.
67 assert(_reserved.byte_size() <= gen_size_limit(), "Consistency check");
68
69 initialize_performance_counters(perf_data_name, level);
70 }
71
72 void PSOldGen::initialize_virtual_space(ReservedSpace rs, size_t alignment) {
73
74 _virtual_space = new PSVirtualSpace(rs, alignment);
75 if (!_virtual_space->expand_by(_init_gen_size)) {
76 vm_exit_during_initialization("Could not reserve enough space for "
77 "object heap");
78 }
79 }
80
81 void PSOldGen::initialize_work(const char* perf_data_name, int level) {
82 //
83 // Basic memory initialization
84 //
85
86 MemRegion limit_reserved((HeapWord*)virtual_space()->low_boundary(),
87 heap_word_size(_max_gen_size));
88 assert(limit_reserved.byte_size() == _max_gen_size,
89 "word vs bytes confusion");
90 //
91 // Object start stuff
92 //
93
94 start_array()->initialize(limit_reserved);
|
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25 #include "precompiled.hpp"
26 #include "gc/parallel/objectStartArray.inline.hpp"
27 #include "gc/parallel/parallelScavengeHeap.hpp"
28 #include "gc/parallel/psAdaptiveSizePolicy.hpp"
29 #include "gc/parallel/psCardTable.hpp"
30 #include "gc/parallel/psFileBackedVirtualspace.hpp"
31 #include "gc/parallel/psMarkSweepDecorator.hpp"
32 #include "gc/parallel/psOldGen.hpp"
33 #include "gc/shared/cardTableBarrierSet.hpp"
34 #include "gc/shared/gcLocker.hpp"
35 #include "gc/shared/spaceDecorator.hpp"
36 #include "logging/log.hpp"
37 #include "oops/oop.inline.hpp"
38 #include "runtime/java.hpp"
39 #include "utilities/align.hpp"
40
41 inline const char* PSOldGen::select_name() {
42 return UseParallelOldGC ? "ParOldGen" : "PSOldGen";
43 }
44
45 PSOldGen::PSOldGen(ReservedSpace rs, size_t alignment,
46 size_t initial_size, size_t min_size, size_t max_size,
47 const char* perf_data_name, int level):
48 _name(select_name()), _init_gen_size(initial_size), _min_gen_size(min_size),
49 _max_gen_size(max_size)
50 {
55 size_t min_size, size_t max_size,
56 const char* perf_data_name, int level):
57 _name(select_name()), _init_gen_size(initial_size), _min_gen_size(min_size),
58 _max_gen_size(max_size)
59 {}
60
61 void PSOldGen::initialize(ReservedSpace rs, size_t alignment,
62 const char* perf_data_name, int level) {
63 initialize_virtual_space(rs, alignment);
64 initialize_work(perf_data_name, level);
65
66 // The old gen can grow to gen_size_limit(). _reserve reflects only
67 // the current maximum that can be committed.
68 assert(_reserved.byte_size() <= gen_size_limit(), "Consistency check");
69
70 initialize_performance_counters(perf_data_name, level);
71 }
72
73 void PSOldGen::initialize_virtual_space(ReservedSpace rs, size_t alignment) {
74
75 if(AllocateOldGenAt != NULL) {
76 _virtual_space = new PSFileBackedVirtualSpace(rs, alignment, AllocateOldGenAt);
77 if (!(static_cast <PSFileBackedVirtualSpace*>(_virtual_space))->initialize()) {
78 vm_exit_during_initialization("Could not map space for PSOldGen at given AllocateOldGenAt path");
79 }
80 } else {
81 _virtual_space = new PSVirtualSpace(rs, alignment);
82 }
83 if (!_virtual_space->expand_by(_init_gen_size)) {
84 vm_exit_during_initialization("Could not reserve enough space for "
85 "object heap");
86 }
87 }
88
89 void PSOldGen::initialize_work(const char* perf_data_name, int level) {
90 //
91 // Basic memory initialization
92 //
93
94 MemRegion limit_reserved((HeapWord*)virtual_space()->low_boundary(),
95 heap_word_size(_max_gen_size));
96 assert(limit_reserved.byte_size() == _max_gen_size,
97 "word vs bytes confusion");
98 //
99 // Object start stuff
100 //
101
102 start_array()->initialize(limit_reserved);
|