1 /* 2 * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved. 3 * Copyright (c) 2020 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 28 29 #include "memory/metaspace/msArena.hpp" 30 #include "memory/metaspace/msArenaGrowthPolicy.hpp" 31 #include "memory/metaspace/msContext.hpp" 32 #include "memory/metaspace/msTestHelpers.hpp" 33 #include "runtime/mutexLocker.hpp" 34 #include "utilities/debug.hpp" 35 #include "utilities/ostream.hpp" 36 #include "utilities/globalDefinitions.hpp" 37 38 namespace metaspace { 39 40 ///// MetaspaceTestArena ////// 41 42 MetaspaceTestArena::MetaspaceTestArena(Mutex* lock, MetaspaceArena* arena) 43 : _lock(lock), _arena(arena) {} 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), _reserve_limit(reserve_limit), _commit_limit(commit_limit), 62 _context(NULL), 63 _commit_limiter(commit_limit == 0 ? max_uintx : commit_limit), // commit_limit == 0 -> no limit 64 _used_words_counter(), 65 _rs() 66 { 67 assert(is_aligned(reserve_limit, Metaspace::reserve_alignment_words()), "reserve_limit (" SIZE_FORMAT ") " 68 "not aligned to metaspace reserve alignment (" SIZE_FORMAT ")", 69 reserve_limit, Metaspace::reserve_alignment_words()); 70 if (reserve_limit > 0) { 71 // have reserve limit -> non-expandable context 72 _rs = ReservedSpace(reserve_limit * BytesPerWord, Metaspace::reserve_alignment(), false); 73 _context = MetaspaceContext::create_nonexpandable_context(name, _rs, &_commit_limiter); 74 } else { 75 // no reserve limit -> expandable vslist 76 _context = MetaspaceContext::create_expandable_context(name, &_commit_limiter); 77 } 78 79 } 80 81 MetaspaceTestContext::~MetaspaceTestContext() { 82 DEBUG_ONLY(verify();) 83 MutexLocker fcl(MetaspaceExpand_lock, Mutex::_no_safepoint_check_flag); 84 delete _context; 85 if (_rs.is_reserved()) { 86 _rs.release(); 87 } 88 } 89 90 // Create an arena, feeding off this area. 91 MetaspaceTestArena* MetaspaceTestContext::create_arena(Metaspace::MetaspaceType type) { 92 const ArenaGrowthPolicy* growth_policy = ArenaGrowthPolicy::policy_for_space_type(type, false); 93 Mutex* lock = new Mutex(Monitor::native, "MetaspaceTestArea-lock", false, Monitor::_safepoint_check_never); 94 MetaspaceArena* arena = NULL; 95 { 96 MutexLocker ml(lock, Mutex::_no_safepoint_check_flag); 97 arena = new MetaspaceArena(_context->cm(), growth_policy, lock, &_used_words_counter, _name); 98 } 99 return new MetaspaceTestArena(lock, arena); 100 } 101 102 void MetaspaceTestContext::purge_area() { 103 _context->cm()->purge(); 104 } 105 106 #ifdef ASSERT 107 void MetaspaceTestContext::verify() const { 108 if (_context != NULL) { 109 _context->verify(); 110 } 111 } 112 #endif 113 114 void MetaspaceTestContext::print_on(outputStream* st) const { 115 _context->print_on(st); 116 } 117 118 } // namespace metaspace 119