/*

 * $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.Inline;

import org.jnode.annotation.MagicPermission;

import org.jnode.vm.BootableObject;

import org.jnode.vm.memmgr.generational.trigger.ComparatorGCTrigger;

import org.jnode.vm.memmgr.generational.trigger.CompoundGCTrigger;

import org.jnode.vm.memmgr.generational.trigger.CounterGCTrigger;

import org.jnode.vm.memmgr.generational.trigger.FalseGCTrigger;

import org.jnode.vm.memmgr.generational.trigger.GCTrigger;

import org.jnode.vm.memmgr.generational.trigger.TimerGCTrigger;

/**

 * 

 * @author loic rouchon

 * 

 */

@MagicPermission

public final class GenGCTriggerManager implements BootableObject {

    /**

     * When this percentage of the free memory has been allocated, a GC is

     * triggered (0..1.0)

     */

    public static float GC_TRIGGER_PERCENTAGE = 0.75f;

    private final static long youngSpaceTimerTrigger = 2000L;

    private final static long tenuredSpaceTimerTrigger = 60000L;

    private final static long sweepTimerTrigger = 5000L;

    private final static int youngSpaceCounterTrigger = 100000;

    private final static int tenuredSpaceCounterTrigger = 250000;

    private final static int sweepCounterTrigger = 200000;

    /**

     * The GC thread

     */

    private GenGCThread gcThread;

    /**

     * The GC free thread

     */

    private GenGCSweepThread gcSweepThread;

    /**

     * GC young space triggers

     */

    private final GCTrigger gcYoungSpaceFalseTrigger = new FalseGCTrigger();

    private GCTrigger gcYoungSpaceRealTrigger;

    private GCTrigger gcYoungSpaceCurrentTrigger;

    /**

     * GC tenured space triggers

     */

    private final GCTrigger gcTenuredSpaceFalseTrigger = new FalseGCTrigger();

    private GCTrigger gcTenuredSpaceRealTrigger;

    private GCTrigger gcTenuredSpaceCurrentTrigger;

    /**

     * GCSweep triggers

     */

    private final GCTrigger gcSweepFalseTrigger = new FalseGCTrigger();

    private GCTrigger gcSweepRealTrigger;

    private GCTrigger gcSweepCurrentTrigger;

    /**

     * GC Allocated size trigger

     */

    private final ComparatorGCTrigger allocatedSizeTrigger = new ComparatorGCTrigger(

            Integer.MAX_VALUE);

    private boolean traceTriggers = true;

    public GenGCTriggerManager() {

        disableGCTriggers();

    }

    public void initialize(GenGCThread gcThread, GenGCSweepThread gcSweepThread,

            boolean traceTriggers) {

        this.gcThread = gcThread;

        this.gcSweepThread = gcSweepThread;

        this.traceTriggers = traceTriggers;

        initializeTriggers();

    }

    private void initializeTriggers() {

        intializeGCYoungSpaceTriggers();

        intializeGCTenuredSpaceTriggers();

        intializeGCSweepTriggers();

        disableGCTriggers();

    }

    public void check() {

        checkGCTenuredSpaceTriggers();

        checkGCYoungSpaceTriggers();

        checkGCSweepTriggers();

    }

    public void enableGCTriggers() {

        // gcYoungSpaceCurrentTrigger = gcYoungSpaceRealTrigger;

        gcTenuredSpaceCurrentTrigger = gcTenuredSpaceRealTrigger;

        gcSweepCurrentTrigger = gcSweepRealTrigger;

        reset();

    }

    public void disableGCTriggers() {

        gcYoungSpaceCurrentTrigger = gcYoungSpaceFalseTrigger;

        gcTenuredSpaceCurrentTrigger = gcTenuredSpaceFalseTrigger;

        gcSweepCurrentTrigger = gcSweepFalseTrigger;

    }

    public void setFreeMemory(long freeMemory) {

        allocatedSizeTrigger.setLimit((int) Math.min(Integer.MAX_VALUE, freeMemory

                * GC_TRIGGER_PERCENTAGE));

    }

    public void incrementAllocatedSizeSinceLastGCBy(int value) {

        allocatedSizeTrigger.incrementCounterValue(value);

    }

    private void reset() {

        gcYoungSpaceCurrentTrigger.reset();

        gcTenuredSpaceCurrentTrigger.reset();

        gcSweepCurrentTrigger.reset();

    }

    private void intializeGCYoungSpaceTriggers() {

        final GCTrigger triggers[] = { new TimerGCTrigger(youngSpaceTimerTrigger),

                new CounterGCTrigger(youngSpaceCounterTrigger), allocatedSizeTrigger };

        gcYoungSpaceRealTrigger = new CompoundGCTrigger(triggers);

    }

    private void intializeGCTenuredSpaceTriggers() {

        final GCTrigger triggers[] = { new TimerGCTrigger(tenuredSpaceTimerTrigger),

                new CounterGCTrigger(tenuredSpaceCounterTrigger), allocatedSizeTrigger };

        gcTenuredSpaceRealTrigger = new CompoundGCTrigger(triggers);

    }

    private void intializeGCSweepTriggers() {

        final GCTrigger triggers[] = { new TimerGCTrigger(sweepTimerTrigger),

                new CounterGCTrigger(sweepCounterTrigger) };

        gcSweepRealTrigger = new CompoundGCTrigger(triggers);

    }

    @Inline

    private void checkGCYoungSpaceTriggers() {

        if (gcYoungSpaceCurrentTrigger.check()) {

            debug("<alloc:GC trigger/>");

            gcThread.triggerMinor(false);

        }

    }

    @Inline

    private void checkGCTenuredSpaceTriggers() {

        if (gcTenuredSpaceCurrentTrigger.check()) {

            debug("<alloc:GC young space trigger/>");

            gcYoungSpaceCurrentTrigger.reset();

            gcThread.triggerMinor(true);

            debug("<alloc:GC tenured space trigger/>");

            gcThread.triggerMajor(false);

        }

    }

    @Inline

    private void checkGCSweepTriggers() {

        if (gcSweepCurrentTrigger.check()) {

            debug("<alloc:GC Sweep trigger/>");

            gcSweepThread.trigger(false);

        }

    }

    @Inline

    private void debug(String txt) {

        if (traceTriggers) {

            debug(txt);

        }

    }

}