146 FreeHeap(p);
147 }
148
149 template <MEMFLAGS F> void CHeapObj<F>::operator delete [](void* p){
150 FreeHeap(p);
151 }
152
153 template <class E, MEMFLAGS F>
154 size_t ArrayAllocator<E, F>::size_for_malloc(size_t length) {
155 return length * sizeof(E);
156 }
157
158 template <class E, MEMFLAGS F>
159 size_t ArrayAllocator<E, F>::size_for_mmap(size_t length) {
160 size_t size = length * sizeof(E);
161 int alignment = os::vm_allocation_granularity();
162 return align_size_up(size, alignment);
163 }
164
165 template <class E, MEMFLAGS F>
166 E* ArrayAllocator<E, F>::allocate_malloc(size_t length) {
167 return (E*)AllocateHeap(size_for_malloc(length), F);
168 }
169
170 template <class E, MEMFLAGS F>
171 E* ArrayAllocator<E, F>::allocate_mmap(size_t length) {
172 size_t size = size_for_mmap(length);
173 int alignment = os::vm_allocation_granularity();
174
175 char* addr = os::reserve_memory(size, NULL, alignment, F);
176 if (addr == NULL) {
177 vm_exit_out_of_memory(size, OOM_MMAP_ERROR, "Allocator (reserve)");
178 }
179
180 os::commit_memory_or_exit(addr, size, !ExecMem, "Allocator (commit)");
181
182 return (E*)addr;
183 }
184
185 template <class E, MEMFLAGS F>
198 : NULL;
199
200 if (new_addr != NULL && old_addr != NULL) {
201 memcpy(new_addr, old_addr, MIN2(old_length, new_length) * sizeof(E));
202 }
203
204 if (old_addr != NULL) {
205 free(old_addr, old_length);
206 }
207
208 return new_addr;
209 }
210
211 template<class E, MEMFLAGS F>
212 void ArrayAllocator<E, F>::free_malloc(E* addr, size_t /*length*/) {
213 FreeHeap(addr);
214 }
215
216 template<class E, MEMFLAGS F>
217 void ArrayAllocator<E, F>::free_mmap(E* addr, size_t length) {
218 os::release_memory((char*)addr, size_for_mmap(length));
219 }
220
221 template<class E, MEMFLAGS F>
222 void ArrayAllocator<E, F>::free(E* addr, size_t length) {
223 if (addr != NULL) {
224 if (should_use_malloc(size_for_malloc(length))) {
225 free_malloc(addr, length);
226 } else {
227 free_mmap(addr, length);
228 }
229 }
230 }
231
232 #endif // SHARE_VM_MEMORY_ALLOCATION_INLINE_HPP
|
146 FreeHeap(p);
147 }
148
149 template <MEMFLAGS F> void CHeapObj<F>::operator delete [](void* p){
150 FreeHeap(p);
151 }
152
153 template <class E, MEMFLAGS F>
154 size_t ArrayAllocator<E, F>::size_for_malloc(size_t length) {
155 return length * sizeof(E);
156 }
157
158 template <class E, MEMFLAGS F>
159 size_t ArrayAllocator<E, F>::size_for_mmap(size_t length) {
160 size_t size = length * sizeof(E);
161 int alignment = os::vm_allocation_granularity();
162 return align_size_up(size, alignment);
163 }
164
165 template <class E, MEMFLAGS F>
166 bool ArrayAllocator<E, F>::should_use_malloc(size_t length) {
167 return size_for_malloc(length) < ArrayAllocatorMallocLimit;
168 }
169
170 template <class E, MEMFLAGS F>
171 E* ArrayAllocator<E, F>::allocate_malloc(size_t length) {
172 return (E*)AllocateHeap(size_for_malloc(length), F);
173 }
174
175 template <class E, MEMFLAGS F>
176 E* ArrayAllocator<E, F>::allocate_mmap(size_t length) {
177 size_t size = size_for_mmap(length);
178 int alignment = os::vm_allocation_granularity();
179
180 char* addr = os::reserve_memory(size, NULL, alignment, F);
181 if (addr == NULL) {
182 vm_exit_out_of_memory(size, OOM_MMAP_ERROR, "Allocator (reserve)");
183 }
184
185 os::commit_memory_or_exit(addr, size, !ExecMem, "Allocator (commit)");
186
187 return (E*)addr;
188 }
189
190 template <class E, MEMFLAGS F>
203 : NULL;
204
205 if (new_addr != NULL && old_addr != NULL) {
206 memcpy(new_addr, old_addr, MIN2(old_length, new_length) * sizeof(E));
207 }
208
209 if (old_addr != NULL) {
210 free(old_addr, old_length);
211 }
212
213 return new_addr;
214 }
215
216 template<class E, MEMFLAGS F>
217 void ArrayAllocator<E, F>::free_malloc(E* addr, size_t /*length*/) {
218 FreeHeap(addr);
219 }
220
221 template<class E, MEMFLAGS F>
222 void ArrayAllocator<E, F>::free_mmap(E* addr, size_t length) {
223 bool result = os::release_memory((char*)addr, size_for_mmap(length));
224 assert(result, "Failed to release memory");
225 }
226
227 template<class E, MEMFLAGS F>
228 void ArrayAllocator<E, F>::free(E* addr, size_t length) {
229 if (addr != NULL) {
230 if (should_use_malloc(length)) {
231 free_malloc(addr, length);
232 } else {
233 free_mmap(addr, length);
234 }
235 }
236 }
237
238 #endif // SHARE_VM_MEMORY_ALLOCATION_INLINE_HPP
|