/*

 * $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 org.jnode.annotation.MagicPermission;

import org.jnode.vm.Unsafe;

import org.jnode.vm.Vm;

import org.jnode.vm.VmArchitecture;

import org.jnode.vm.VmMagic;

import org.jnode.vm.VmSystemObject;

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.VmHeapManager;

import org.vmmagic.pragma.Uninterruptible;

import org.vmmagic.unboxed.Address;

import org.vmmagic.unboxed.ObjectReference;

import org.vmmagic.unboxed.Offset;

import org.vmmagic.unboxed.Word;

/**

 * 

 * @author ismael

 * 

 */

@MagicPermission

final class GenGCManager extends VmSystemObject implements Uninterruptible {

    private static final int MAX_AGE_FOR_YOUNG = 5;

    /**

     * The heap manager

     */

    private GenHeapManager heapManager;

    /**

     * The mark stack

     */

    private final GenGCStack markStack;

    /**

     * An object visitor used for marking

     */

    private final GenGCMarkVisitor markVisitor;

    /**

     * An object visitor used for sweeping

     */

    private final GenGCMarkForSweepVisitor markForSweepVisitor;

    /**

     * An object visitor used for sweeping

     */

    private final GenGCSweepVisitor sweepVisitor;

    /**

     * An object visitor used for setting objects to GC colour white

     */

    private final GenGCSetWhiteVisitor setWhiteVisitor;

    /**

     * The object visitor that verifies the correctness of the object tree

     */

    private final GenGCVerifyVisitor verifyVisitor;

    /**

     * My statistics

     */

    private final GenGCStatistics stats;

    /**

     * The low level helper

     */

    private HeapHelper helper;

    /**

     * The write barrier

     */

    private GenWriteBarrier writeBarrier;

    /**

     * Debug mode?

     */

    private final boolean debug;

    private GenGCYellowObjectManager yellowObjectManager;

    //private List<Object> youngObj = new ArrayList<Object>(4096);

    private GenGCStack youngObj = new GenGCStack();

    private GenGCStack youngTemp = new GenGCStack();

    public GenGCManager(GenHeapManager genHeapManager, VmArchitecture arch) {

        debug = true || Vm.getVm().isDebugMode();

        heapManager = genHeapManager;

        helper = heapManager.getHelper();

        yellowObjectManager = heapManager.getYellowObjectManager();

        writeBarrier = (GenWriteBarrier) heapManager.getWriteBarrier();

        markStack = new GenGCStack();

        markVisitor = new GenGCMarkVisitor(markStack, heapManager, arch);

        setWhiteVisitor = new GenGCSetWhiteVisitor(helper);

        verifyVisitor = new GenGCVerifyVisitor(heapManager, arch);

        markForSweepVisitor = new GenGCMarkForSweepVisitor(yellowObjectManager);

        sweepVisitor = new GenGCSweepVisitor(yellowObjectManager);

        stats = new GenGCStatistics();

        yellowObjectManager.setStats(stats);

    }

    /**

     * Do a garbage collection cycle for young objects or a full collection

     */

    final void gc() {

        Unsafe.debug("\n[Enter] GenGCManager.gc()\n");

        majorGC();

        Unsafe.debug("\n[Leave] GenGCManager.gc()\n");

    }

    /**

     * Do a garbage collection cycle for young objects

     */

    final void minorGC() {

        final long beginTime = GenGCStatistics.currentMillis();

        Unsafe.debug("\n[Enter] GenGCManager.minorGC()\n");

        // Prepare

        // final VmBootHeap bootHeap = heapManager.getBootHeap();

        final VmDefaultHeap firstHeap = heapManager.getHeapList();

        // final boolean locking = (writeBarrier != null);

        final boolean verbose = (heapManager.getHeapFlags() & VmHeapManager.TRACE_BASIC) != 0;

        helper.stopThreadsAtSafePoint();

        // heapManager.setGcActive(true);

        try {

            // Pre-GC verification

            if (debug) {

                if (false) {

                    // Turn back to true in case of problems in the GC.

                    if (verbose) {

                        heapManager.debug("<preverify/>");

                    }

                    // verify(bootHeap, firstHeap);

                }

            }

            // Analyse young objects

            if (verbose) {

                heapManager.debug("<collectYoungObjects/>");

            }

            collectYoungObjects(firstHeap);

            // Verification

            if (debug) {

                if (false) {

                    // Turn back to true in case of problems in the GC.

                    if (verbose) {

                        heapManager.debug("<verify/>");

                    }

                    // verify(bootHeap, firstHeap);

                }

            }

        } finally {

            // heapManager.setGcActive(false);

            // heapManager.resetCurrentHeap();

            final long duration = GenGCStatistics.getDuration(beginTime);

            stats.addMinorDuration(duration);

            helper.restartThreads();

        }

    }

    /**

     * Do a major garbage collection cycle (clean the full memory with

     * mark&sweep).

     */

    final void majorGC() {

        final long beginTime = GenGCStatistics.currentMillis();

        Unsafe.debug("\n[Enter] GenGCManager.majorGC()\n");

        // Prepare

        final VmBootHeap bootHeap = heapManager.getBootHeap();

        final VmDefaultHeap firstHeap = heapManager.getHeapList();

        final boolean locking = (writeBarrier != null);

        final boolean verbose = (heapManager.getHeapFlags() & VmHeapManager.TRACE_BASIC) != 0;

        helper.stopThreadsAtSafePoint();

        heapManager.setGcActive(true);

        try {

            // Pre-GC verification

            if (debug) {

                if (false) {

                    // Turn back to true in case of problems in the GC.

                    if (verbose) {

                        heapManager.debug("<preverify/>");

                    }

                    verify(bootHeap, firstHeap);

                }

            }

            // Mark

            // helper.stopThreadsAtSafePoint();

            // heapManager.setGcActive(true);

            try {

                if (verbose) {

                    heapManager.debug("<mark/>");

                }

                markHeap(bootHeap, firstHeap, locking);

            } finally {

                // heapManager.setGcActive(false);

                // helper.restartThreads();

            }

            // Mark for Sweep

            if (verbose) {

                heapManager.debug("<markForSweep/>");

            }

            markForSweep(firstHeap);

            // Verification

            if (debug) {

                if (false) {

                    // Turn back to true in case of problems in the GC.

                    if (verbose) {

                        heapManager.debug("<verify/>");

                    }

                    verify(bootHeap, firstHeap);

                }

            }

        } finally {

            heapManager.setGcActive(false);

            heapManager.resetCurrentHeap();

            final long duration = GenGCStatistics.getDuration(beginTime);

            stats.addMajorDuration(duration);

            helper.restartThreads();

        }

        // Start the finalization process

        // heapManager.triggerFinalization();

    }

    void cleanup() {

        final VmBootHeap bootHeap = heapManager.getBootHeap();

        final VmDefaultHeap firstHeap = heapManager.getHeapList();

        cleanup(bootHeap, firstHeap);

    }

    void sweep() {

        // Unsafe.debug("GenGCManager.sweep()\n");

        final long beginTime = GenGCStatistics.currentMillis();

        VmDefaultHeap heap = heapManager.getHeapList();

        sweepVisitor.resetMarkedObjectsSize();

        while (heap != null && yellowObjectManager.areObjectsYellow()) {

            heap.lock();

            sweepVisitor.setCurrentHeap(heap);

            heap.walk(sweepVisitor, false, Word.zero(), Word.zero());

            heap.unlock();

            heap = heap.getNext();

        }

        final long duration = GenGCStatistics.getDuration(beginTime);

        stats.addSweepDuration(duration);

        stats.lastFreedBytes = sweepVisitor.getMarkedObjectsSize();

    }

    // Young collection

    private final void collectYoungObjects(VmDefaultHeap firstHeap) {

        Object obj = null;

        boolean removed = false;

        long markedObjects = 0L;

        long markedObjectsSize = 0L;

        youngTemp.reset();

        //for (int i = 0, size = youngObj.size(); i < size; i++) {

        while(!youngObj.isEmpty()) {

            removed = false;

            obj = youngObj.pop();//get(i);

            if(helper.getNbRefs(obj) == 0) {

                walkObject(obj);

                yellowObjectManager.markObjectAsYellow(obj);

                markedObjectsSize += VmDefaultHeap.getObjectSize(obj);

                markedObjects++;

                removed = true;

            }

            else {

                int newAge = helper.incrementAge(obj);

                if (newAge > MAX_AGE_FOR_YOUNG) {

                    helper.setOld(obj);

                    removed = true;

                }

            }

            if(!removed) {

                youngTemp.push(obj);

            }

           /* if (removed) {

                youngObj.remove(i);

                i--;

                size = youngObj.size();

                removed = false;

            }*/

        }

        //swap young objects stacks

        GenGCStack s = youngObj;

        youngObj = youngTemp;

        youngTemp = s;

        //

        stats.lastMinorMarkedObjects = markedObjects;

        stats.lastMinorMarkedObjectsSize = markedObjectsSize;

    }

    private final boolean walkObject(Object object) {

        VmType<?> vmClass = null;

        try {

            vmClass = VmMagic.getObjectType(object);

        } catch (NullPointerException ex) {

            //

        }

        if (vmClass == null) {

            Unsafe.debug("Oops vmClass == null");

            helper.die("vmClass == null in walkObject()");

        } else if (vmClass.isArray()) {

            if (!vmClass.isPrimitiveArray()) {

                decrementRefCountForArrayElems(object);

            }

        } else {

            return decrementRefCountForFields(object, (VmNormalClass<?>) vmClass);

        }

        return false;

    }

    private void decrementRefCountForArrayElems(Object object) {

        try {

            final Object[] arr = (Object[]) object;

            final int length = arr.length;

            for (int i = 0; i < length; i++) {

                final Object child = arr[i];

                if (child != null) {

                    helper.decRef(child);                    

                }

            }

        } catch (ClassCastException ex) {

            throw ex;

        }

    }

    private final boolean decrementRefCountForFields(Object object, VmNormalClass<?> vmClass) {

        final int[] referenceOffsets = vmClass.getReferenceOffsets();

        final int cnt = referenceOffsets.length;

        if (cnt == 0) {

            return false;

        }

        boolean res = false;

        final int size = vmClass.getObjectSize();

        final Address objAddr = ObjectReference.fromObject(object).toAddress();

        for (int i = 0; i < cnt; i++) {

            final int offset = referenceOffsets[i];

            if ((offset < 0) || (offset >= size)) {

                Unsafe.debug("reference offset out of range!");

                Unsafe.debug(vmClass.getName());

                helper.die("Class internal error");

            } else {

                final ObjectReference child = objAddr.loadObjectReference(Offset

                        .fromIntZeroExtend(offset));

                if (child != null) {

                    helper.decRef(child);

                    res = true;

                }

            }

        }

        return res;

    }

    // Full collection

    /**

     * Mark all live objects in the heap.

     * 

     * @param bootHeap

     * @param firstHeap

     */

    private final void markHeap(VmBootHeap bootHeap, VmDefaultHeap firstHeap, boolean locking) {

        final long beginTime = GenGCStatistics.currentMillis();

        stats.lastMarkIterations = 0;

        if (writeBarrier != null) {

            writeBarrier.setActive(true);

        }

        long markedObjects = 0;

        boolean firstIteration = true;

        boolean wbChanged = false;

        do {

            // Do an iteration reset

            stats.lastMarkIterations++;

            markStack.reset();

            if (writeBarrier != null) {

                writeBarrier.resetChanged();

            }

            markVisitor.reset();

            markVisitor.setRootSet(true);

            // Mark all roots

            helper.visitAllRoots(markVisitor, heapManager);

            // statics.walk(markVisitor, resolver);

            // helper.visitAllThreads(threadMarkVisitor);

            // Mark every object in the rootset

            // bootHeap.walk(markVisitor, locking, 0, 0);

            if (!firstIteration) {

                // If there was an overflow in the last iteration,

                // we must also walk through the other heap to visit

                // all grey objects, since we must still mark

                // their children.

                markVisitor.setRootSet(false);

                bootHeap.walk(markVisitor, locking, Word.zero(), Word.zero());

                VmDefaultHeap heap = firstHeap;

                while ((heap != null) && (!markStack.isOverflow())) {

                    heap.walk(markVisitor, locking, Word.zero(), Word.zero());

                    heap = heap.getNext();

                }

            }

            // Test for an endless loop

            if ((markVisitor.getMarkedObjects() == 0) && markStack.isOverflow()) {

                // Oops... an endless loop

                Unsafe.debug("Endless loop in markHeap.... going to die");

                helper.die("GCManager.markHeap");

            }

            // Do some cleanup

            markedObjects += markVisitor.getMarkedObjects();

            firstIteration = false;

            if (writeBarrier != null) {

                wbChanged = writeBarrier.isChanged();

            }

        } while (markStack.isOverflow() || wbChanged);

        if (writeBarrier != null) {

            writeBarrier.setActive(false);

        }

        final long duration = GenGCStatistics.getDuration(beginTime);

        stats.addMarkDuration(duration);

        stats.lastMajorMarkedObjects = markedObjects;

    }

    /**

     * Sweep all heaps for dead objects.

     * 

     * @param firstHeap

     */

    private void markForSweep(VmDefaultHeap firstHeap) {

        final long beginTime = GenGCStatistics.currentMillis();

        VmDefaultHeap heap = firstHeap;

        markForSweepVisitor.resetMarkedObjectsSize();

        while (heap != null) {

            heap.lock();

            heap.walk(markForSweepVisitor, false, Word.zero(), Word.zero());

            heap.unlock();

            heap = heap.getNext();

        }

        final long duration = GenGCStatistics.getDuration(beginTime);

        stats.addMarkForSweepDuration(duration);

        stats.lastMajorMarkedObjectsSize = markForSweepVisitor.getMarkedObjectsSize();

    }

    /**

     * Mark all objects white, so a next GC action is valid

     * 

     * @param bootHeap

     * @param firstHeap

     */

    private void cleanup(VmBootHeap bootHeap, VmDefaultHeap firstHeap) {

        final long beginTime = GenGCStatistics.currentMillis();

        bootHeap.walk(setWhiteVisitor, true, Word.zero(), Word.zero());

        VmDefaultHeap heap = firstHeap;

        while (heap != null) {

            heap.defragment();

            // heap.walk(setWhiteVisitor, true);

            heap = heap.getNext();

        }

        final long duration = GenGCStatistics.getDuration(beginTime);

        stats.addCleanupDuration(duration);

    }

    /**

     * Verify all heaps.

     * 

     * @param bootHeap

     * @param firstHeap

     */

    private void verify(VmBootHeap bootHeap, VmDefaultHeap firstHeap) {

        final Word zero = Word.zero();

        verifyVisitor.reset();

        bootHeap.walk(verifyVisitor, true, zero, zero);

        VmDefaultHeap heap = firstHeap;

        while (heap != null) {

            heap.walk(verifyVisitor, true, zero, zero);

            heap = heap.getNext();

        }

        final int errorCount = verifyVisitor.getErrorCount();

        if (errorCount > 0) {

            Unsafe.debug(errorCount);

            Unsafe.debug(" verify errors. ");

            helper.die("Corrupted heap");

        }

    }

    public GCStatistics getStatistics() {

        return stats;

    }

    protected void addToYoungObjects(Object obj) {

        youngObj.push(obj);

    }

}