33 } |
33 } |
34 |
34 |
35 |
35 |
36 // Implementation of Heap |
36 // Implementation of Heap |
37 |
37 |
38 CodeHeap::CodeHeap() { |
38 CodeHeap::CodeHeap(const char* name, const int code_blob_type) |
|
39 : _code_blob_type(code_blob_type) { |
|
40 _name = name; |
39 _number_of_committed_segments = 0; |
41 _number_of_committed_segments = 0; |
40 _number_of_reserved_segments = 0; |
42 _number_of_reserved_segments = 0; |
41 _segment_size = 0; |
43 _segment_size = 0; |
42 _log2_segment_size = 0; |
44 _log2_segment_size = 0; |
43 _next_segment = 0; |
45 _next_segment = 0; |
44 _freelist = NULL; |
46 _freelist = NULL; |
45 _freelist_segments = 0; |
47 _freelist_segments = 0; |
46 _freelist_length = 0; |
48 _freelist_length = 0; |
|
49 _max_allocated_capacity = 0; |
|
50 _was_full = false; |
47 } |
51 } |
48 |
52 |
49 |
53 |
50 void CodeHeap::mark_segmap_as_free(size_t beg, size_t end) { |
54 void CodeHeap::mark_segmap_as_free(size_t beg, size_t end) { |
51 assert(0 <= beg && beg < _number_of_committed_segments, "interval begin out of bounds"); |
55 assert(0 <= beg && beg < _number_of_committed_segments, "interval begin out of bounds"); |
86 linux_wrap_code(base, size); |
90 linux_wrap_code(base, size); |
87 #endif |
91 #endif |
88 } |
92 } |
89 |
93 |
90 |
94 |
91 bool CodeHeap::reserve(size_t reserved_size, size_t committed_size, |
95 bool CodeHeap::reserve(ReservedSpace rs, size_t committed_size, size_t segment_size) { |
92 size_t segment_size) { |
96 assert(rs.size() >= committed_size, "reserved < committed"); |
93 assert(reserved_size >= committed_size, "reserved < committed"); |
|
94 assert(segment_size >= sizeof(FreeBlock), "segment size is too small"); |
97 assert(segment_size >= sizeof(FreeBlock), "segment size is too small"); |
95 assert(is_power_of_2(segment_size), "segment_size must be a power of 2"); |
98 assert(is_power_of_2(segment_size), "segment_size must be a power of 2"); |
96 |
99 |
97 _segment_size = segment_size; |
100 _segment_size = segment_size; |
98 _log2_segment_size = exact_log2(segment_size); |
101 _log2_segment_size = exact_log2(segment_size); |
99 |
102 |
100 // Reserve and initialize space for _memory. |
103 // Reserve and initialize space for _memory. |
101 const size_t page_size = os::can_execute_large_page_memory() ? |
104 const size_t page_size = os::can_execute_large_page_memory() ? |
102 os::page_size_for_region(committed_size, reserved_size, 8) : |
105 os::page_size_for_region(committed_size, rs.size(), 8) : |
103 os::vm_page_size(); |
106 os::vm_page_size(); |
104 const size_t granularity = os::vm_allocation_granularity(); |
107 const size_t granularity = os::vm_allocation_granularity(); |
105 const size_t r_align = MAX2(page_size, granularity); |
|
106 const size_t r_size = align_size_up(reserved_size, r_align); |
|
107 const size_t c_size = align_size_up(committed_size, page_size); |
108 const size_t c_size = align_size_up(committed_size, page_size); |
108 |
109 |
109 const size_t rs_align = page_size == (size_t) os::vm_page_size() ? 0 : |
110 os::trace_page_sizes(_name, committed_size, rs.size(), page_size, |
110 MAX2(page_size, granularity); |
|
111 ReservedCodeSpace rs(r_size, rs_align, rs_align > 0); |
|
112 os::trace_page_sizes("code heap", committed_size, reserved_size, page_size, |
|
113 rs.base(), rs.size()); |
111 rs.base(), rs.size()); |
114 if (!_memory.initialize(rs, c_size)) { |
112 if (!_memory.initialize(rs, c_size)) { |
115 return false; |
113 return false; |
116 } |
114 } |
117 |
115 |
180 |
178 |
181 if (block != NULL) { |
179 if (block != NULL) { |
182 assert(block->length() >= number_of_segments && block->length() < number_of_segments + CodeCacheMinBlockLength, "sanity check"); |
180 assert(block->length() >= number_of_segments && block->length() < number_of_segments + CodeCacheMinBlockLength, "sanity check"); |
183 assert(!block->free(), "must be marked free"); |
181 assert(!block->free(), "must be marked free"); |
184 DEBUG_ONLY(memset((void*)block->allocated_space(), badCodeHeapNewVal, instance_size)); |
182 DEBUG_ONLY(memset((void*)block->allocated_space(), badCodeHeapNewVal, instance_size)); |
|
183 _max_allocated_capacity = MAX2(_max_allocated_capacity, allocated_capacity()); |
185 return block->allocated_space(); |
184 return block->allocated_space(); |
186 } |
185 } |
187 |
186 |
188 // Ensure minimum size for allocation to the heap. |
187 // Ensure minimum size for allocation to the heap. |
189 number_of_segments = MAX2((int)CodeCacheMinBlockLength, (int)number_of_segments); |
188 number_of_segments = MAX2((int)CodeCacheMinBlockLength, (int)number_of_segments); |
201 mark_segmap_as_used(_next_segment, _next_segment + number_of_segments); |
200 mark_segmap_as_used(_next_segment, _next_segment + number_of_segments); |
202 HeapBlock* b = block_at(_next_segment); |
201 HeapBlock* b = block_at(_next_segment); |
203 b->initialize(number_of_segments); |
202 b->initialize(number_of_segments); |
204 _next_segment += number_of_segments; |
203 _next_segment += number_of_segments; |
205 DEBUG_ONLY(memset((void *)b->allocated_space(), badCodeHeapNewVal, instance_size)); |
204 DEBUG_ONLY(memset((void *)b->allocated_space(), badCodeHeapNewVal, instance_size)); |
|
205 _max_allocated_capacity = MAX2(_max_allocated_capacity, allocated_capacity()); |
206 return b->allocated_space(); |
206 return b->allocated_space(); |
207 } else { |
207 } else { |
208 return NULL; |
208 return NULL; |
209 } |
209 } |
210 } |
210 } |