/*

 * $Id$

 *

 * Copyright (C) 2003-2009 JNode.org

 *

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

 * under the terms of the GNU Lesser General Public License as published

 * by the Free Software Foundation; either version 2.1 of the License, or

 * (at your option) any later version.

 *

 * This library 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 Lesser General Public 

 * License for more details.

 *

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

 * along with this library; If not, write to the Free Software Foundation, Inc., 

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

 */

package org.jnode.vm.memmgr.generational;

import java.io.PrintWriter;

import org.jnode.annotation.Inline;

import org.jnode.annotation.MagicPermission;

import org.jnode.vm.MemoryBlockManager;

import org.jnode.vm.ObjectVisitor;

import org.jnode.vm.Unsafe;

import org.jnode.vm.VmArchitecture;

import org.jnode.vm.VmMagic;

import org.jnode.vm.classmgr.ObjectFlags;

import org.jnode.vm.classmgr.ObjectLayout;

import org.jnode.vm.classmgr.VmClassLoader;

import org.jnode.vm.classmgr.VmClassType;

import org.jnode.vm.classmgr.VmNormalClass;

import org.jnode.vm.classmgr.VmType;

import org.jnode.vm.memmgr.GCStatistics;

import org.jnode.vm.memmgr.HeapHelper;

import org.jnode.vm.memmgr.HeapStatistics;

import org.jnode.vm.memmgr.VmHeapManager;

import org.jnode.vm.scheduler.Monitor;

import org.jnode.vm.scheduler.VmProcessor;

import org.vmmagic.unboxed.Address;

import org.vmmagic.unboxed.Extent;

import org.vmmagic.unboxed.Word;

/**

 * 

 * @author ismael

 * 

 */

@MagicPermission

public final class GenHeapManager extends VmHeapManager {

    /**

     * The GC thread

     */

    private GenGCThread gcThread;

    /**

     * The GC free thread

     */

    private GenGCSweepThread gcSweepThread;

    private Monitor heapMonitor;

    private GenGCManager gcManager;

    private final GenGCYellowObjectManager yellowObjectManager;

    private final GenGCTriggerManager triggerManager = new GenGCTriggerManager();

    /**

     * Default size in bytes of a new heap

     */

    public static final int DEFAULT_HEAP_SIZE = 16 * 1024 * 1024;

    /**

     * The boot heap

     */

    private final VmBootHeap bootHeap;

    /**

     * Are we low on memory

     */

    private boolean lowOnMemory;

    /**

     * Linked list of all heaps.

     */

    private VmDefaultHeap heapList;

    /**

     * The first heap.

     */

    private final VmDefaultHeap firstNormalHeap;

    /**

     * The heap currently used for allocation

     */

    private VmDefaultHeap currentHeap;

    /**

     * The heap used for allocations during a GC

     */

    private VmDefaultHeap gcHeap;

    /**

     * The class of the default heap type. Set by initialize

     */

    private final VmNormalClass<VmDefaultHeap> defaultHeapClass;

    private boolean gcActive;

    private boolean gcManagerLoaded = false;

    /**

     * Make this private, so we cannot be instantiated

     */

    @SuppressWarnings("unchecked")

    public GenHeapManager(VmClassLoader loader, HeapHelper helper) throws ClassNotFoundException {

        super(helper);

        this.bootHeap = new VmBootHeap(getHelper());

        setWriteBarrier(null);

        this.firstNormalHeap = new VmDefaultHeap(getHelper());

        this.currentHeap = firstNormalHeap;

        this.heapList = firstNormalHeap;

        this.defaultHeapClass = (VmNormalClass<VmDefaultHeap>) loader.loadClass(VmDefaultHeap.class

                .getName(), true);

        this.yellowObjectManager = new GenGCYellowObjectManager(getHelper());

    }

    @Override

    public void start() {

        Unsafe.debug("GenHeapManager.start()\n");

        final VmArchitecture arch = VmProcessor.current().getArchitecture();

        heapMonitor = new Monitor();

        gcManager = new GenGCManager(this, arch);

        gcManagerLoaded = true;

        gcThread = new GenGCThread(gcManager, heapMonitor);

        gcSweepThread = new GenGCSweepThread(gcManager, heapMonitor);

        Unsafe.debug("GenHeapManager.start(create write barrier)\n");

        setWriteBarrier(new GenWriteBarrier(getHelper(), firstNormalHeap.nbRefOffset));

        Unsafe.debug("GenHeapManager.start(start threads)\n");

        gcThread.start();

        gcSweepThread.start();

        Unsafe.debug("GenHeapManager.start(gcSweepThread started)\n");

        final boolean traceTriggers = (heapFlags & TRACE_TRIGGER) != 0;

        triggerManager.initialize(gcThread, gcSweepThread, traceTriggers);

        triggerManager.enableGCTriggers();

        gcManagerLoaded = true;

        Unsafe.debug("GenHeapManager.start(ended)\n");

    }

    /**

     * Is the given address the address of an allocated object on this heap?

     * 

     * @param ptr

     *            The address to examine.

     * @return True if the given address if a valid starting address of an

     *         object, false otherwise.

     */

    @Override

    @Inline

    public final boolean isObject(Address ptr) {

        if (!ptr.toWord().and(Word.fromIntZeroExtend(ObjectLayout.OBJECT_ALIGN - 1)).isZero()) {

            // The object is not at an object aligned boundary

            return false;

        }

        if (bootHeap.isObject(ptr)) {

            return true;

        }

        VmDefaultHeap heap = heapList;

        while (heap != null) {

            if (heap.isObject(ptr)) {

                return true;

            }

            heap = heap.getNext();

        }

        return false;

    }

    /**

     * Is the system low on memory?

     * 

     * @return boolean

     */

    @Override

    public boolean isLowOnMemory() {

        return lowOnMemory;

    }

    /**

     * Start a garbage collection process

     */

    @Override

    public void gc() {

        gcThread.trigger(false);

    }

    /**

     * Gets the size of free memory in bytes.

     * 

     * @return long

     */

    @Override

    public long getFreeMemory() {

        Extent size = Extent.zero();

        VmDefaultHeap h = firstNormalHeap;

        while (h != null) {

            size = size.add(h.getFreeSize());

            h = h.getNext();

        }

        // size += (Unsafe.addressToLong(heapEnd) -

        // Unsafe.addressToLong(nextHeapPtr));

        size = size.add(Extent.fromLong(MemoryBlockManager.getFreeMemory()));

        return size.toLong();

    }

    /**

     * Gets the size of all memory in bytes.

     * 

     * @return the size of all memory in bytes

     */

    @Override

    public long getTotalMemory() {

        long size = bootHeap.getSize();

        VmDefaultHeap h = firstNormalHeap;

        while (h != null) {

            size += h.getSize();

            h = h.getNext();

        }

        // size += (Unsafe.addressToLong(heapEnd) -

        // Unsafe.addressToLong(nextHeapPtr));

        size += MemoryBlockManager.getFreeMemory();

        return size;

    }

    /**

     * Gets the first heap. All other heaps can be iterated through the

     * <code>getNext()</code> method.

     * 

     * @return the first heap

     */

    public final VmDefaultHeap getHeapList() {

        return heapList;

    }

    /**

     * @see org.jnode.vm.memmgr.VmHeapManager#createProcessorHeapData(org.jnode.vm.scheduler.VmProcessor)

     */

    @Override

    public Object createProcessorHeapData(VmProcessor cpu) {

        // No need here, so return null.

        return null;

    }

    /**

     * @see org.jnode.vm.memmgr.VmHeapManager#notifyClassResolved(org.jnode.vm.classmgr.VmType)

     */

    @Override

    public void notifyClassResolved(VmType<?> vmType) {

        // Do nothing

    }

    /**

     * @see org.jnode.vm.memmgr.VmHeapManager#loadClasses(org.jnode.vm.classmgr.VmClassLoader)

     */

    @Override

    public void loadClasses(VmClassLoader loader) throws ClassNotFoundException {

        loader.loadClass("org.jnode.vm.memmgr.generational.VmBootHeap", true);

        loader.loadClass("org.jnode.vm.memmgr.generational.VmDefaultHeap", true);

    }

    /**

     * Print the statics on this object on out.

     */

    @Override

    public void dumpStatistics(PrintWriter out) {

        out.println("WriteBarrier: " + getWriteBarrier());

    }

    @Override

    public GCStatistics getStatistics() {

        return gcManager.getStatistics();

    }

    @Override

    public HeapStatistics getHeapStatistics() {

        final GenHeapStatistics heapStatistics = new GenHeapStatistics();

        final GenHeapStatisticsVisitor heapStatisticsVisitor = new GenHeapStatisticsVisitor(

                heapStatistics);

        accept(heapStatisticsVisitor, false);

        return heapStatistics;

    }

    public final void doMinorGC() {

        heapMonitor.enter();

        gcThread.triggerMinor(true);

        heapMonitor.exit();

    }

    public final void doMajorGC() {

        gcThread.triggerMajor(true);

    }

    public final void doSweepAndCleanup() {

        heapMonitor.enter();

        gcSweepThread.trigger(true);

        heapMonitor.exit();

    }

    final GenGCYellowObjectManager getYellowObjectManager() {

        return yellowObjectManager;

    }

    /**

     * @return Returns the bootHeap.

     */

    final VmBootHeap getBootHeap() {

        return this.bootHeap;

    }

    /**

     * @param gcActive

     *            The gcActive to set.

     */

    final void setGcActive(boolean gcActive) {

        this.gcActive = gcActive;

    }

    /**

     * Sets the currentHeap to the first heap.

     */

    final void resetCurrentHeap() {

        this.currentHeap = this.firstNormalHeap;

        // Recalculate the trigger size

        triggerManager.setFreeMemory(getFreeMemory());

    }

    // ------------------------------------------

    // Private natives

    // ------------------------------------------

    @Override

    protected void initialize() {

        Unsafe.debug("GenHeapManager.initialize()\n");

        // Set the basic fields

        helper.bootArchitecture(false);

        Unsafe.debug("GenHeapManager.initialize(load architecture)\n");

        final VmArchitecture arch = VmProcessor.current().getArchitecture();

        Unsafe.debug("GenHeapManager.initialize(load slot size)\n");

        final int slotSize = arch.getReferenceSize();

        VmDefaultHeap.initializeSizeOffset(slotSize);

        // Initialize the boot heap.

        Unsafe.debug("GenHeapManager.initialize(boot heap)\n");

        bootHeap.initialize(helper.getBootHeapStart(), helper.getBootHeapEnd(), slotSize);

        // Initialize the first normal heap

        Unsafe.debug("GenHeapManager.initialize(first normal heap)\n");

        final Address ptr = helper.allocateBlock(Extent.fromIntZeroExtend(DEFAULT_HEAP_SIZE));

        firstNormalHeap.initialize(ptr, ptr.add(DEFAULT_HEAP_SIZE), slotSize);

        // Initialize the GC heap

        Unsafe.debug("GenHeapManager.initialize(gc heap)\n");

        gcHeap = allocHeap(Extent.fromIntZeroExtend(DEFAULT_HEAP_SIZE), false);

        gcHeap.append(firstNormalHeap);

        // Initialize the total heap list.

        heapList = gcHeap;

        Unsafe.debug("GenHeapManager.initialize(ended)\n");

    }

    /**

     * Allocate a new instance for the given class. Not that this method cannot

     * be synchronized, since obtaining a monitor might require creating one,

     * which in turn needs this method.

     * 

     * @param vmClass

     * @param size

     * @return Object

     */

    @Override

    protected Object allocObject(VmClassType<?> vmClass, int size) {

        // Make sure the class is initialized

        vmClass.initialize();

        final int alignedSize = ObjectLayout.objectAlign(size);

        // final Monitor mon = heapMonitor;

        VmDefaultHeap heap = currentHeap;

        Object result = null;

        int oomCount = 0;

        final Monitor m = heapMonitor;

        // final Monitor m = null;

        if (m != null) {

            m.enter();

        }

        try {

            if (gcActive) {

                if ((heapFlags & TRACE_ALLOC) != 0) {

                    debug("Using GC Heap type ");

                    debug(vmClass.getName());

                }

                result = gcHeap.alloc(vmClass, alignedSize);

                if (result == null) {

                    helper.die("Out of GC heap memory.");

                }

            } else {

                while (result == null) {

                    // The current heap is full

                    if (heap == null) {

                        // Unsafe.debug("allocHeap in allocObject(");

                        // Unsafe.debug(alignedSize);

                        // Unsafe.debug(") ");

                        int newHeapSize = DEFAULT_HEAP_SIZE;

                        if (size > newHeapSize) {

                            // this is a BIG object, try to allocate a new

                            // heap

                            // only for it

                            newHeapSize = size;

                        }

                        if ((heap = allocHeap(Extent.fromIntZeroExtend(newHeapSize), true)) == null) {

                            lowOnMemory = true;

                            // It was not possible to allocate another heap.

                            // First try to GC, if we've done that before

                            // in this allocation, then we're in real panic.

                            if (oomCount == 0) {

                                oomCount++;

                                if ((heapFlags & TRACE_OOM) != 0) {

                                    debug("<oom/>");

                                }

                                gcThread.trigger(true);

                                heap = firstNormalHeap;

                                currentHeap = firstNormalHeap;

                            } else {

                                if ((heapFlags & TRACE_OOM) != 0) {

                                    debug("Out of memory in allocObject(");

                                    debug(size);

                                    debug(")");

                                }

                                throw OOME;

                                // Unsafe.die();

                            }

                        } else {

                            // Unsafe.debug("AO.G");

                            // We successfully allocated a new heap, set it

                            // to current, so we'll use it for the following

                            // allocations.

                            currentHeap = heap;

                        }

                    }

                    result = heap.alloc(vmClass, alignedSize);

                    if (result == null) {

                        heap = (VmDefaultHeap) heap.getNext();

                    }

                }

                lowOnMemory = false;

                triggerManager.incrementAllocatedSizeSinceLastGCBy(alignedSize);

                //triggerManager.check();

            }

            vmClass.incInstanceCount();

            // Allocated objects are initially black.

            VmMagic.setObjectFlags(result, Word.fromIntZeroExtend(ObjectFlags.GC_DEFAULT_COLOR));

            //add object to young objects

            if (gcManagerLoaded) {

                // Unsafe.debug("GenHeapManager.allocObject(young)\n");

                gcManager.addToYoungObjects(result);

            } else {

                // Unsafe.debug("GenHeapManager.allocObject(old)\n");

                helper.setOld(result);

            }

            // Unsafe.debug("GenHeapManager.allocObject(done)\n");

        } finally {

            if (m != null) {

                m.exit();

            }

        }

        return result;

    }

    /**

     * Allocate a new heap with a given size. The heap object itself is

     * allocated on the new heap, so this method can be called even if all other

     * heaps are full.

     * 

     * @param size

     * @return The heap

     */

    private VmDefaultHeap allocHeap(Extent size, boolean addToHeapList) {

        // Unsafe.debug("[begin] allocHeap\n");

        final Address start = helper.allocateBlock(size);

        // final Address start = MemoryBlockManager.allocateBlock(size);

        if (start == null) {

            return null;

        }

        final Address end = start.add(size);

        final int slotSize = VmProcessor.current().getArchitecture().getReferenceSize();

        final VmDefaultHeap heap = VmDefaultHeap.setupHeap(helper, start, defaultHeapClass,

                slotSize);

        heap.initialize(start, end, slotSize);

        if (addToHeapList) {

            heapList.append(heap);

        }

        // Unsafe.debug("[end successful] allocHeap\n");

        return heap;

    }

    private void accept(ObjectVisitor visitor, boolean locking) {

        VmDefaultHeap heap = firstNormalHeap;

        final Word zero = Word.zero();

        while (heap != null) {

            heap.walk(visitor, locking, zero, zero);

            heap = heap.getNext();

        }

    }

}