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