/*
 * Copyright (c) 2007, 2018, Oracle and/or its affiliates. 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_VM_GC_G1_G1MEMORYPOOL_HPP
#define SHARE_VM_GC_G1_G1MEMORYPOOL_HPP

#include "gc/g1/g1MonitoringSupport.hpp"
#include "services/memoryPool.hpp"
#include "services/memoryUsage.hpp"

// This file contains definitions for two memory pool models for the G1 heap
// spaces. Which to use is determined by the G1UseLegacyMonitoring switch.  If
// true, we use a model that defines three pools, G1EdenPool, G1SurvivorPool
// and G1OldPool. If false (the default), we use a more accurate model
// that defines two additional pools, G1HumongousPool and G1ArchivePool.
//
// In G1, unlike our other GCs, we do not have a contiguous virtual address
// space for each pool. The pools are logical spaces in G1, and each pool
// consists of a non-contiguous region set allocated out of a single region
// pool which covers the entire heap. This is also reflected in the way we
// map them to memory pools here. The easiest way to have done this would
// have been to map the entire G1 heap to a single memory pool. However, it
// is helpful to show how large each space gets, as their sizes affect G1's
// performance and behavior.
//
// See comments in g1MonitoringSupport.hpp for additional details on this
// model.

class G1CollectedHeap;

// This class is shared by all G1 memory pool classes: G1EdenPool,
// G1SurvivorPool, G1OldPool, G1HumongousPool, and G1ArchivePool
class G1MemoryPoolSuper : public CollectedMemoryPool {
protected:
  G1MonitoringSupport* _g1mm;

  // Would only be called from subclasses.
  G1MemoryPoolSuper(G1CollectedHeap* g1h,
                    const char* name,
                    size_t init_size,
                    size_t max_size,
                    bool support_usage_threshold);
};

// In legacy mode, G1EdenPool, G1SurvivorPool, and G1OldPool represent
// the G1 memory pools, and G1OldPool includes regions occupied by
// humongous and archive objects.

// Memory pool that represents the G1 eden space
class G1EdenPool : public G1MemoryPoolSuper {
public:
  G1EdenPool(G1CollectedHeap* g1h, size_t initial_size);
  size_t used_in_bytes() { return _g1mm->eden_space_used(); }
  MemoryUsage get_memory_usage();
};

// Memory pool that represents the G1 survivor space
class G1SurvivorPool : public G1MemoryPoolSuper {
public:
  G1SurvivorPool(G1CollectedHeap* g1h, size_t initial_size);
  size_t used_in_bytes() { return _g1mm->survivor_space_used(); }
  MemoryUsage get_memory_usage();
};

// Memory pool that represents the G1 old generation (legacy)
// or G1 old space (default)
class G1OldPool : public G1MemoryPoolSuper {
public:
  G1OldPool(G1CollectedHeap* g1h, size_t initial_size, size_t max_size);
  size_t used_in_bytes() { return _g1mm->old_space_used(); }
  MemoryUsage get_memory_usage();
};

// The default model includes the three legacy pools plus G1ArchivePool
// and G1HumongousPool, and G1OldPool does not include regions occupied
// by humongous and archive objects. Instead, humongous and archive
// objects each get their own pool.

// Memory pool that represents the G1 archive space. The archive space
// contains read-only class metadata from the class data sharing archives.
class G1ArchivePool : public G1MemoryPoolSuper {
public:
  G1ArchivePool(G1CollectedHeap* g1h, size_t initial_size);
  size_t used_in_bytes() { return _g1mm->archive_space_used(); }
  MemoryUsage get_memory_usage();
};

// Memory pool that represents the G1 humongous space
class G1HumongousPool : public G1MemoryPoolSuper {
public:
  G1HumongousPool(G1CollectedHeap* g1h, size_t initial_size);
  size_t used_in_bytes() { return _g1mm->humongous_space_used(); }
  MemoryUsage get_memory_usage();
};

#endif // SHARE_VM_GC_G1_G1MEMORYPOOL_HPP