/*

 * Copyright (c) 2018, 2019, Oracle and/or its affiliates. All rights reserved.

 * Copyright (c) 2018, 2019 SAP SE. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 *

 */

#ifndef SHARE_MEMORY_METASPACE_SPACEMANAGER_HPP

#define SHARE_MEMORY_METASPACE_SPACEMANAGER_HPP

#include "memory/allocation.hpp"

#include "memory/metaspace.hpp"

#include "memory/metaspace/blockFreelist.hpp"

#include "memory/metaspace/chunkAllocSequence.hpp"

#include "memory/metaspace/chunkManager.hpp"

#include "memory/metaspace/metachunk.hpp"

#include "memory/metaspace/metaspaceCommon.hpp"

class outputStream;

class Mutex;

namespace metaspace {

class BlockFreeList;

class LeftOverManager;

struct sm_stats_t;

// The SpaceManager:

// - keeps a list of chunks-in-use by the class loader, as well as a current chunk used

//   to allocate from

// - keeps a dictionary of free MetaBlocks. Those can be remnants of a retired chunk or

//   allocations which were not needed anymore for some reason (e.g. releasing half-allocated

//   structures when class loading fails)

class SpaceManager : public CHeapObj<mtClass> {

  // Lock handed down from the associated ClassLoaderData.

  //  Protects allocations from this space.

  Mutex* const _lock;

  // The chunk manager to allocate chunks from.

  ChunkManager* const _chunk_manager;

  // The chunk allocation strategy to use.

  const ChunkAllocSequence* const _chunk_alloc_sequence;

  // List of chunks in use by this SpaceManager.  Allocations

  // are done from the current chunk. The list is used for deallocating

  // chunks when the SpaceManager is freed.

  MetachunkList _chunks;

  Metachunk* current_chunk()              { return _chunks.first(); }

  const Metachunk* current_chunk() const  { return _chunks.first(); }

  BlockFreelist* _block_freelist;

  LeftOverManager* _lom;

  // Points to outside size counter which we are to increase/decrease when we allocate memory

  // on behalf of a user or when we are destroyed.

  SizeAtomicCounter* const _total_used_words_counter;

  const char* const _name;

  // Whether or not this is a "micro loader" which is not expected to load more than one class.

  const bool _is_micro_loader;

  Mutex* lock() const                           { return _lock; }

  ChunkManager* chunk_manager() const           { return _chunk_manager; }

  const ChunkAllocSequence* chunk_alloc_sequence() const    { return _chunk_alloc_sequence; }

  BlockFreelist* block_freelist() const         { return _block_freelist; }

  void create_block_freelist();

  void add_allocation_to_block_freelist(MetaWord* p, size_t word_size);

  LeftOverManager* lom() const                  { return _lom; }

  void create_lom();

  void add_allocation_to_lom(MetaWord* p, size_t word_size);

  // The remaining committed free space in the current chunk is chopped up and stored in the block

  // free list for later use. As a result, the current chunk will remain current but completely

  // used up. This is a preparation for calling allocate_new_current_chunk().

  void retire_current_chunk();

  // Given a requested word size, will allocate a chunk large enough to at least fit that

  // size, but may be larger according to internal heuristics.

  //

  // On success, it will replace the current chunk with the newly allocated one, which will

  // become the current chunk. The old current chunk should be retired beforehand.

  //

  // May fail if we could not allocate a new chunk. In that case the current chunk remains

  // unchanged and false is returned.

  bool allocate_new_current_chunk(size_t requested_word_size);

  // Prematurely returns a metaspace allocation to the _block_freelists

  // because it is not needed anymore (requires CLD lock to be active).

  void deallocate_locked(MetaWord* p, size_t word_size);

  // Returns true if the area indicated by pointer and size have actually been allocated

  // from this space manager.

  DEBUG_ONLY(bool is_valid_area(MetaWord* p, size_t word_size) const;)

public:

  SpaceManager(ChunkManager* chunk_manager,

               const ChunkAllocSequence* alloc_sequence,

               Mutex* lock,

               SizeAtomicCounter* total_used_words_counter,

               const char* name,

               bool is_micro_loader);

  ~SpaceManager();

  // Allocate memory from Metaspace.

  // 1) Attempt to allocate from the dictionary of deallocated blocks.

  // 2) Attempt to allocate from the current chunk.

  // 3) Attempt to enlarge the current chunk in place if it is too small.

  // 4) Attempt to get a new chunk and allocate from that chunk.

  // At any point, if we hit a commit limit, we return NULL.

  MetaWord* allocate(size_t word_size);

  // Prematurely returns a metaspace allocation to the _block_freelists because it is not

  // needed anymore.

  void deallocate(MetaWord* p, size_t word_size);

  // Update statistics. This walks all in-use chunks.

  void add_to_statistics(sm_stats_t* out) const;

  DEBUG_ONLY(void verify() const;)

  DEBUG_ONLY(void verify_locked() const;)

};

} // namespace metaspace

#endif // SHARE_MEMORY_METASPACE_SPACEMANAGER_HPP