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/metaspaceArena.hpp" 28 #include "memory/metaspace/metaspaceArenaGrowthPolicy.hpp" 29 #include "memory/metaspace/metaspaceContext.hpp" 30 #include "memory/metaspace/testHelpers.hpp" 31 #include "runtime/mutexLocker.hpp" 32 #include "utilities/debug.hpp" 33 #include "utilities/globalDefinitions.hpp" 34 #include "utilities/ostream.hpp" 35 36 namespace metaspace { 37 38 ///// MetaspaceTestArena ////// 39 40 MetaspaceTestArena::MetaspaceTestArena(Mutex* lock, MetaspaceArena* arena) : 41 _lock(lock), 42 _arena(arena) 43 {} 44 45 MetaspaceTestArena::~MetaspaceTestArena() { 46 delete _arena; 47 delete _lock; 48 } 49 50 MetaWord* MetaspaceTestArena::allocate(size_t word_size) { 51 return _arena->allocate(word_size); 52 } 53 54 void MetaspaceTestArena::deallocate(MetaWord* p, size_t word_size) { 55 return _arena->deallocate(p, word_size); 56 } 57 58 ///// MetaspaceTestArea ////// 59 60 MetaspaceTestContext::MetaspaceTestContext(const char* name, size_t commit_limit, size_t reserve_limit) : 61 _name(name), 62 _reserve_limit(reserve_limit), 63 _commit_limit(commit_limit), 64 _context(NULL), 65 _commit_limiter(commit_limit == 0 ? max_uintx : commit_limit), // commit_limit == 0 -> no limit 66 _used_words_counter(), 67 _rs() 68 { 69 assert(is_aligned(reserve_limit, Metaspace::reserve_alignment_words()), "reserve_limit (" SIZE_FORMAT ") " 70 "not aligned to metaspace reserve alignment (" SIZE_FORMAT ")", 71 reserve_limit, Metaspace::reserve_alignment_words()); 72 if (reserve_limit > 0) { 73 // have reserve limit -> non-expandable context 74 _rs = ReservedSpace(reserve_limit * BytesPerWord, Metaspace::reserve_alignment(), os::vm_page_size()); 75 _context = MetaspaceContext::create_nonexpandable_context(name, _rs, &_commit_limiter); 76 } else { 77 // no reserve limit -> expandable vslist 78 _context = MetaspaceContext::create_expandable_context(name, &_commit_limiter); 79 } 80 81 } 82 83 MetaspaceTestContext::~MetaspaceTestContext() { 84 DEBUG_ONLY(verify();) 85 MutexLocker fcl(Metaspace_lock, Mutex::_no_safepoint_check_flag); 86 delete _context; 87 if (_rs.is_reserved()) { 88 _rs.release(); 89 } 90 } 91 92 // Create an arena, feeding off this area. 93 MetaspaceTestArena* MetaspaceTestContext::create_arena(Metaspace::MetaspaceType type) { 94 const ArenaGrowthPolicy* growth_policy = ArenaGrowthPolicy::policy_for_space_type(type, false); 95 Mutex* lock = new Mutex(Monitor::nosafepoint, "MetaspaceTestArea_lock"); 96 MetaspaceArena* arena = NULL; 97 { 98 MutexLocker ml(lock, Mutex::_no_safepoint_check_flag); 99 arena = new MetaspaceArena(_context->cm(), growth_policy, lock, &_used_words_counter, _name); 100 } 101 return new MetaspaceTestArena(lock, arena); 102 } 103 104 void MetaspaceTestContext::purge_area() { 105 _context->cm()->purge(); 106 } 107 108 #ifdef ASSERT 109 void MetaspaceTestContext::verify() const { 110 if (_context != NULL) { 111 _context->verify(); 112 } 113 } 114 #endif 115 116 void MetaspaceTestContext::print_on(outputStream* st) const { 117 _context->print_on(st); 118 } 119 120 } // namespace metaspace 121