1 /* 2 * Copyright (c) 2020, 2021, Oracle and/or its affiliates. All rights reserved. 3 * Copyright (c) 2020, 2021 SAP SE. All rights reserved. 4 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 5 * 6 * This code is free software; you can redistribute it and/or modify it 7 * under the terms of the GNU General Public License version 2 only, as 8 * published by the Free Software Foundation. 9 * 10 * This code is distributed in the hope that it will be useful, but WITHOUT 11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 13 * version 2 for more details (a copy is included in the LICENSE file that 14 * accompanied this code). 15 * 16 * You should have received a copy of the GNU General Public License version 17 * 2 along with this work; if not, write to the Free Software Foundation, 18 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 19 * 20 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 21 * or visit www.oracle.com if you need additional information or have any 22 * questions. 23 * 24 */ 25 26 #include "precompiled.hpp" 27 #include "memory/metaspace/metaspaceAlignment.hpp" 28 #include "memory/metaspace/metaspaceArena.hpp" 29 #include "memory/metaspace/metaspaceArenaGrowthPolicy.hpp" 30 #include "memory/metaspace/metaspaceContext.hpp" 31 #include "memory/metaspace/testHelpers.hpp" 32 #include "runtime/mutexLocker.hpp" 33 #include "utilities/debug.hpp" 34 #include "utilities/globalDefinitions.hpp" 35 #include "utilities/ostream.hpp" 36 37 namespace metaspace { 38 39 ///// MetaspaceTestArena ////// 40 41 MetaspaceTestArena::MetaspaceTestArena(Mutex* lock, MetaspaceArena* arena) : 42 _lock(lock), 43 _arena(arena) 44 {} 45 46 MetaspaceTestArena::~MetaspaceTestArena() { 47 delete _arena; 48 delete _lock; 49 } 50 51 MetaWord* MetaspaceTestArena::allocate(size_t word_size) { 52 return _arena->allocate(word_size); 53 } 54 55 void MetaspaceTestArena::deallocate(MetaWord* p, size_t word_size) { 56 return _arena->deallocate(p, word_size); 57 } 58 59 ///// MetaspaceTestArea ////// 60 61 MetaspaceTestContext::MetaspaceTestContext(const char* name, size_t commit_limit, size_t reserve_limit) : 62 _name(name), 63 _reserve_limit(reserve_limit), 64 _commit_limit(commit_limit), 65 _context(NULL), 66 _commit_limiter(commit_limit == 0 ? max_uintx : commit_limit), // commit_limit == 0 -> no limit 67 _used_words_counter(), 68 _rs() 69 { 70 assert(is_aligned(reserve_limit, Metaspace::reserve_alignment_words()), "reserve_limit (" SIZE_FORMAT ") " 71 "not aligned to metaspace reserve alignment (" SIZE_FORMAT ")", 72 reserve_limit, Metaspace::reserve_alignment_words()); 73 if (reserve_limit > 0) { 74 // have reserve limit -> non-expandable context 75 _rs = ReservedSpace(reserve_limit * BytesPerWord, Metaspace::reserve_alignment(), os::vm_page_size()); 76 _context = MetaspaceContext::create_nonexpandable_context(name, _rs, &_commit_limiter); 77 } else { 78 // no reserve limit -> expandable vslist 79 _context = MetaspaceContext::create_expandable_context(name, &_commit_limiter); 80 } 81 82 } 83 84 MetaspaceTestContext::~MetaspaceTestContext() { 85 DEBUG_ONLY(verify();) 86 MutexLocker fcl(Metaspace_lock, Mutex::_no_safepoint_check_flag); 87 delete _context; 88 if (_rs.is_reserved()) { 89 _rs.release(); 90 } 91 } 92 93 // Create an arena, feeding off this area. 94 MetaspaceTestArena* MetaspaceTestContext::create_arena(Metaspace::MetaspaceType type) { 95 const ArenaGrowthPolicy* growth_policy = ArenaGrowthPolicy::policy_for_space_type(type, false); 96 Mutex* lock = new Mutex(Monitor::nosafepoint, "MetaspaceTestArea_lock"); 97 MetaspaceArena* arena = NULL; 98 { 99 MutexLocker ml(lock, Mutex::_no_safepoint_check_flag); 100 arena = new MetaspaceArena(_context->cm(), growth_policy, MetaspaceMinAlignmentWords, 101 lock, &_used_words_counter, _name); 102 } 103 return new MetaspaceTestArena(lock, arena); 104 } 105 106 void MetaspaceTestContext::purge_area() { 107 _context->cm()->purge(); 108 } 109 110 #ifdef ASSERT 111 void MetaspaceTestContext::verify() const { 112 if (_context != NULL) { 113 _context->verify(); 114 } 115 } 116 #endif 117 118 void MetaspaceTestContext::print_on(outputStream* st) const { 119 _context->print_on(st); 120 } 121 122 } // namespace metaspace 123