/*

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

import org.jnode.vm.scheduler.Monitor;

/**

 * @author Ewout Prangsma (epr@users.sourceforge.net)

 */

final class GenGCThread extends Thread {

    /**

     * The manager

     */

    private final GenGCManager manager;

    /**

     * Monitor for synchronizing access to my fields

     */

    private Monitor heapMonitor;

    /**

     * Is a GC run requested?

     */

    private boolean runMajorNeeded;

    private boolean runMinorNeeded;

    /**

     * Is the GC currently active

     */

    private boolean gcActive;

    /**

     * Initialize this instance.

     * 

     * @param manager

     */

    public GenGCThread(GenGCManager manager, Monitor heapMonitor) {

        super("gc-thread");

        this.manager = manager;

        this.heapMonitor = heapMonitor;

    }

    /**

     * Trigger a major GC run.

     * 

     * @param waitToFinish

     *            If true, block until the run is ready, if false, return

     *            immediately.

     */

    public final void trigger(boolean waitToFinish) {

        triggerMajor(waitToFinish);

    }

    /**

     * Trigger a major GC run.

     * 

     * @param waitToFinish

     *            If true, block until the run is ready, if false, return

     *            immediately.

     */

    public final void triggerMajor(boolean waitToFinish) {

        if (runMajorNeeded && !waitToFinish) {

            return;

        }

        heapMonitor.enter();

        try {

            runMajorNeeded = true;

            heapMonitor.NotifyAll();

            if (waitToFinish) {

                waitForMajorCollectionEnd();

            }

        } finally {

            heapMonitor.exit();

        }

    }

    /**

     * Trigger a minor GC run.

     * 

     * @param waitToFinish

     *            If true, block until the run is ready, if false, return

     *            immediately.

     */

    public final void triggerMinor(boolean waitToFinish) {

        if (runMinorNeeded && !waitToFinish) {

            return;

        }

        heapMonitor.enter();

        try {

            runMinorNeeded = true;

            heapMonitor.NotifyAll();

            if (waitToFinish) {

                waitForMinorCollectionEnd();

            }

        } finally {

            heapMonitor.exit();

        }

    }

    /**

     * Continue to GC.

     * 

     * @see java.lang.Runnable#run()

     */

    @Override

    public final void run() {

        while (true) {

            try {

                waitForGcStart();

                callGc();

                notifyGcEnd();

            } catch (Throwable ex) {

                try {

                    Unsafe.debug(ex.getMessage());

                    Unsafe.debug('\n');

                    Unsafe.debugStackTrace(ex);

                    Unsafe.die("GCThread failed");

                } catch (Throwable ex2) {

                    continue;

                }

            }

        }

    }

    private void waitForMajorCollectionEnd() {

        while (runMajorNeeded || gcActive) {

            try {

                heapMonitor.Wait(0L);

            } catch (InterruptedException ex) {

                continue;

            }

        }

    }

    private void waitForMinorCollectionEnd() {

        while (runMinorNeeded || gcActive) {

            try {

                heapMonitor.Wait(0L);

            } catch (InterruptedException ex) {

                continue;

            }

        }

    }

    private final void waitForGcStart() throws InterruptedException {

        heapMonitor.enter();

        try {

            while (!runMajorNeeded) {

                heapMonitor.Wait(0L);

            }

            gcActive = true;

        } finally {

            heapMonitor.exit();

        }

    }

    private final void callGc() throws InterruptedException {

        if (runMajorNeeded) {

            Unsafe.debug("GenGCThread.callGc(major)\n");

            manager.majorGC();

            runMinorNeeded = false;

        } else {

            Unsafe.debug("GenGCThread.callGc(minor)\n");

            manager.minorGC();

            runMinorNeeded = false;

        }

    }

    private final void notifyGcEnd() {

        gcActive = false;

        heapMonitor.enter();

        try {

            heapMonitor.NotifyAll();

        } finally {

            heapMonitor.exit();

        }

    }

}