/*
 * Copyright (C) 2011 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package java.lang;

import android.compat.annotation.UnsupportedAppUsage;
import android.system.Os;
import android.system.OsConstants;

import java.lang.invoke.MethodHandles;
import java.lang.invoke.VarHandle;
import java.lang.ref.Cleaner;
import java.lang.ref.FinalizerReference;
import java.lang.ref.Reference;
import java.lang.ref.ReferenceQueue;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeoutException;
import java.util.concurrent.atomic.AtomicInteger;
import libcore.util.EmptyArray;

import dalvik.system.VMRuntime;
import dalvik.system.VMDebug;

import jdk.internal.ref.CleanerImpl;

/**
 * Calls Object.finalize() on objects in the finalizer reference queue. The VM
 * will abort if any finalize() call takes more than the maximum finalize time
 * to complete.
 *
 * @hide
 */
public final class Daemons {
    private static final int NANOS_PER_MILLI = 1000 * 1000;

    // This used to be final. IT IS NOW ONLY WRITTEN. We now update it when we look at the command
    // line argument, for the benefit of mis-behaved apps that might read it.  SLATED FOR REMOVAL.
    // There is no reason to use this: Finalizers should not rely on the value. If a finalizer takes
    // appreciable time, the work should be done elsewhere.  Based on disassembly of Daemons.class,
    // the value is effectively inlined, so changing the field never did have an effect.
    // DO NOT USE. FOR ANYTHING. THIS WILL BE REMOVED SHORTLY.
    @UnsupportedAppUsage
    private static long MAX_FINALIZE_NANOS = 10L * 1000 * NANOS_PER_MILLI;

    private static final Daemon[] DAEMONS = new Daemon[] {
            HeapTaskDaemon.INSTANCE,
            ReferenceQueueDaemon.INSTANCE,
            FinalizerDaemon.INSTANCE,
            FinalizerWatchdogDaemon.INSTANCE,
    };
    private static CountDownLatch zygoteStartLatch;

    private static boolean postZygoteFork = false;

    @UnsupportedAppUsage
    public static void start() {
        zygoteStartLatch = new CountDownLatch(DAEMONS.length);
        for (Daemon daemon : DAEMONS) {
            daemon.start();
        }
    }

    public static void startPostZygoteFork() {
        postZygoteFork = true;
        start();
    }

    @UnsupportedAppUsage
    public static void stop() {
        for (Daemon daemon : DAEMONS) {
            daemon.stop();
        }
    }

    private static void waitForDaemonStart() throws Exception {
        zygoteStartLatch.await();
    }

    /**
     * A background task that provides runtime support to the application.
     * Daemons can be stopped and started, but only so that the zygote can be a
     * single-threaded process when it forks.
     */
    private static abstract class Daemon implements Runnable {
        @UnsupportedAppUsage
        private Thread thread;
        private String name;

        protected Daemon(String name) {
            this.name = name;
        }

        @UnsupportedAppUsage
        public synchronized void start() {
            startInternal();
        }

        public void startInternal() {
            if (thread != null) {
                throw new IllegalStateException("already running");
            }
            thread = new Thread(ThreadGroup.systemThreadGroup, this, name);
            thread.setDaemon(true);
            thread.setSystemDaemon(true);
            thread.start();
        }

        public final void run() {
            if (postZygoteFork) {
                // We don't set the priority before the Thread.start() call above because
                // Thread.start() will call SetNativePriority and overwrite the desired native
                // priority. We (may) use a native priority that doesn't have a corresponding
                // java.lang.Thread-level priority (native priorities are more coarse-grained.)
                VMRuntime.getRuntime().setSystemDaemonThreadPriority();
            }
            zygoteStartLatch.countDown();
            try {
                runInternal();
                // This thread is about to exit, and we may have to wait for it to do so.
                // Terminate the underlying system thread as quickly as possible.
                // Mirroring setSystemDaemonThreadPriority, we only touch the native priority,
                // bypassing the rest of setPriority().
                Thread.currentThread().setPriority0(Thread.MAX_PRIORITY);
            } catch (Throwable ex) {
                // Usually caught in runInternal. May not o.w. get reported, e.g. in zygote.
                // Risk logging redundantly, rather than losing it.
                System.logE("Uncaught exception in system thread " + name, ex);
                throw ex;
            }
        }

        /*
         * Do the actual work. Returns normally when asked to stop.
         */
        public abstract void runInternal();

        /**
         * Returns true while the current thread should continue to run; false
         * when it should return.
         */
        @UnsupportedAppUsage
        protected synchronized boolean isRunning() {
            return thread != null;
        }

        public synchronized void interrupt() {
            interrupt(thread);
        }

        public synchronized void interrupt(Thread thread) {
            if (thread == null) {
                throw new IllegalStateException("not running");
            }
            thread.interrupt();
        }

        /**
         * Waits for the runtime thread to stop. This interrupts the thread
         * currently running the runnable and then waits for it to exit.
         */
        @UnsupportedAppUsage
        public void stop() {
            // This can be called on shutdown with the GC already disabled.
            // Allocation either here or while handling the request in the
            // daemon thread should be minimized.
            Thread threadToStop;
            synchronized (this) {
                threadToStop = thread;
                thread = null;
            }
            if (threadToStop == null) {
                throw new IllegalStateException("not running");
            }
            interrupt(threadToStop);
            while (true) {
                try {
                    threadToStop.join();
                    return;
                } catch (InterruptedException ignored) {
                } catch (OutOfMemoryError ignored) {
                    // An OOME may be thrown if allocating the InterruptedException failed.
                }
            }
        }

        /**
         * Returns the current stack trace of the thread, or an empty stack trace
         * if the thread is not currently running.
         */
        public synchronized StackTraceElement[] getStackTrace() {
            return thread != null ? thread.getStackTrace() : EmptyArray.STACK_TRACE_ELEMENT;
        }
    }

    // Allocate these strings on start-up.
    // Don't declare them private, to minimize chances that the compiler can defer allocation.
    /**
     * @hide
     */
    public static final String FD_OOM_MESSAGE = "Ignoring unexpected OOME in FinalizerDaemon";
    /**
     * @hide
     */
    public static final String RQD_OOM_MESSAGE = "Ignoring unexpected OOME in ReferenceQueueDaemon";

    /**
     * This heap management thread moves elements from the garbage collector's
     * pending list to the managed reference queue.
     */
    private static class ReferenceQueueDaemon extends Daemon {
        @UnsupportedAppUsage
        private static final ReferenceQueueDaemon INSTANCE = new ReferenceQueueDaemon();

        // Monitored by FinalizerWatchdogDaemon to make sure we're still working.
        private final AtomicInteger progressCounter = new AtomicInteger(0);

        ReferenceQueueDaemon() {
            super("ReferenceQueueDaemon");
        }

        @Override public void runInternal() {
            FinalizerWatchdogDaemon.INSTANCE.monitoringNeeded(FinalizerWatchdogDaemon.RQ_DAEMON);

            // Call once early to reduce later allocation, and hence chance of OOMEs.
            FinalizerWatchdogDaemon.INSTANCE.resetTimeouts();

            while (isRunning()) {
                Reference<?> list;
                try {
                    synchronized (ReferenceQueue.class) {
                        if (ReferenceQueue.unenqueued == null) {
                            FinalizerWatchdogDaemon.INSTANCE.monitoringNotNeeded(
                                    FinalizerWatchdogDaemon.RQ_DAEMON);
                            // Increment after above call. If watchdog saw it active, it should see
                            // the counter update.
                            progressCounter.incrementAndGet();
                            do {
                               ReferenceQueue.class.wait();
                            } while (ReferenceQueue.unenqueued == null);
                            progressCounter.incrementAndGet();
                            FinalizerWatchdogDaemon.INSTANCE.monitoringNeeded(
                                    FinalizerWatchdogDaemon.RQ_DAEMON);
                        }
                        list = ReferenceQueue.unenqueued;
                        ReferenceQueue.unenqueued = null;
                    }
                    ReferenceQueue.enqueuePending(list, progressCounter);
                    FinalizerWatchdogDaemon.INSTANCE.resetTimeouts();
                } catch (InterruptedException e) {
                    // Happens when we are asked to stop.
                } catch (OutOfMemoryError ignored) {
                    // Very unlikely. Cleaner.clean OOMEs are caught elsewhere, and nothing else
                    // should allocate regularly. Could result in enqueuePending dropping
                    // references. Does occur in tests that run out of memory.
                    System.logW(RQD_OOM_MESSAGE);
                }
            }
        }

        Object currentlyProcessing() {
          return ReferenceQueue.getCurrentTarget();
        }
    }

    private static class FinalizerDaemon extends Daemon {
        @UnsupportedAppUsage
        private static final FinalizerDaemon INSTANCE = new FinalizerDaemon();
        private final ReferenceQueue<Object> queue = FinalizerReference.queue;
        private final AtomicInteger progressCounter = new AtomicInteger(0);
        // Object (not reference!) being finalized. Accesses may race!
        @UnsupportedAppUsage
        private Object finalizingObject = null;

        // Track if we are currently logging an exception. We don't want to time out
        // in the middle.
        public static int NONE = 0;
        public static int LOGGING = 1;
        public static int TIMED_OUT = 2;
        public volatile int exceptionLoggingState = NONE;

        FinalizerDaemon() {
            super("FinalizerDaemon");
        }

        @Override public void runInternal() {
            // This loop may be performance critical, since we need to keep up with mutator
            // generation of finalizable objects.
            // We minimize the amount of work we do per finalizable object. For example, we avoid
            // reading the current time here, since that involves a kernel call per object.  We
            // limit fast path communication with FinalizerWatchDogDaemon to what's unavoidable: A
            // non-volatile store to communicate the current finalizable object, e.g. for
            // reporting, and a release store (lazySet) to a counter.
            // We do stop the  FinalizerWatchDogDaemon if we have nothing to do for a
            // potentially extended period.  This prevents the device from waking up regularly
            // during idle times.

            // Local copy of progressCounter; saves a fence per increment on ARM.
            int localProgressCounter = progressCounter.get();

            FinalizerWatchdogDaemon.INSTANCE.monitoringNeeded(
                    FinalizerWatchdogDaemon.FINALIZER_DAEMON);
            while (isRunning()) {
                try {
                    // Use non-blocking poll to avoid FinalizerWatchdogDaemon communication
                    // when busy.
                    Object nextReference = queue.poll();
                    if (nextReference != null) {
                        progressCounter.lazySet(++localProgressCounter);
                        processReference(nextReference);
                    } else {
                        finalizingObject = null;
                        // Slow path; block.
                        FinalizerWatchdogDaemon.INSTANCE.monitoringNotNeeded(
                                FinalizerWatchdogDaemon.FINALIZER_DAEMON);
                        // Increment after above call. If watchdog saw it active, it should see
                        // the counter update.
                        progressCounter.set(++localProgressCounter);
                        nextReference = queue.remove();
                        progressCounter.set(++localProgressCounter);
                        FinalizerWatchdogDaemon.INSTANCE.monitoringNeeded(
                                FinalizerWatchdogDaemon.FINALIZER_DAEMON);
                        processReference(nextReference);
                    }
                } catch (InterruptedException e) {
                    // Happens when we are asked to stop.
                } catch (OutOfMemoryError ignored) {
                    // An  OOME here is unlikely to be actionable. Bravely/foolishly continue.
                    System.logW(FD_OOM_MESSAGE);
                }
            }
        }

        private void processReference(Object ref) {
            if (ref instanceof FinalizerReference finalizingReference) {
                finalizingObject = finalizingReference.get();
                try {
                    doFinalize(finalizingReference);
                } finally {
                    // Make really sure we delay any PhantomReference enqueueing until we are
                    // really done. Possibly redundant, but the rules are complex.
                    Reference.reachabilityFence(finalizingObject);
                }
            } else if (ref instanceof Cleaner.Cleanable cleanableReference) {
                finalizingObject = cleanableReference;
                doClean(cleanableReference);
            } else {
                throw new AssertionError("Unknown class was placed into queue: " + ref);
            }
        }

        @FindBugsSuppressWarnings("FI_EXPLICIT_INVOCATION")
        private void doFinalize(FinalizerReference<?> reference) {
            FinalizerReference.remove(reference);
            Object object = reference.get();
            reference.clear();
            try {
                object.finalize();
            } catch (Throwable ex) {
                // The RI silently swallows these, but Android has always logged.
                exceptionLoggingState = LOGGING;
                System.logE("Uncaught exception thrown by finalizer", ex);
                if (exceptionLoggingState == TIMED_OUT) {
                  // We would have timed out. Attempt to crash the process here to leave a trace.
                  throw new AssertionError("Timed out logging finalizer exception", ex);
                }
            } finally {
                // Done finalizing, stop holding the object as live.
                finalizingObject = null;
                exceptionLoggingState = NONE;
            }
        }

        private void doClean(Cleaner.Cleanable cleanable) {
            try {
                cleanable.clean();
                // We only get here for SystemCleaner, and are thus not constrained to ignore
                // exceptions/errors.
            } finally {
                finalizingObject = null;
            }
        }
    }

    /**
     * The watchdog exits the VM if either the FinalizerDaemon, or the ReferenceQueueDaemon
     * gets stuck. We consider the finalizer to be stuck if it spends more than
     * MAX_FINALIZATION_MILLIS on one instance. We consider ReferenceQueueDaemon to be
     * potentially stuck if it spends more than MAX_FINALIZATION_MILLIS processing a single
     * Cleaner or transferring objects into a single queue, but only report if this happens
     * a few times in a row, to compensate for the fact that multiple Cleaners may be involved.
     */
    private static class FinalizerWatchdogDaemon extends Daemon {
        // Single bit values to identify daemon to be watched.
        static final int FINALIZER_DAEMON = 1;
        static final int RQ_DAEMON = 2;

        @UnsupportedAppUsage
        private static final FinalizerWatchdogDaemon INSTANCE = new FinalizerWatchdogDaemon();
        private static final VarHandle VH_ACTION;
        static {
            try {
                VH_ACTION = MethodHandles
                        .privateLookupIn(
                                CleanerImpl.PhantomCleanableRef.class, MethodHandles.lookup())
                        .findVarHandle(
                                CleanerImpl.PhantomCleanableRef.class, "action", Runnable.class);
            } catch (NoSuchFieldException | IllegalAccessException e) {
                throw new AssertionError("PhantomCleanableRef should have action field", e);
            }
        }

        private int activeWatchees;  // Only synchronized accesses.

        private long finalizerTimeoutNs = 0;  // Lazily initialized.

        // We tolerate this many timeouts during an enqueuePending call.
        // This number is > 1, since we may only report enqueuePending progress rarely.
        private static final int TOLERATED_REFERENCE_QUEUE_TIMEOUTS = 5;
        private static final AtomicInteger observedReferenceQueueTimeouts = new AtomicInteger(0);

        FinalizerWatchdogDaemon() {
            super("FinalizerWatchdogDaemon");
        }

        void resetTimeouts() {
            observedReferenceQueueTimeouts.lazySet(0);
        }

        @Override public void runInternal() {
            while (isRunning()) {
                if (!sleepUntilNeeded()) {
                    // We have been interrupted, need to see if this daemon has been stopped.
                    continue;
                }
                final TimeoutException exception = waitForProgress();
                if (exception != null && !VMDebug.isDebuggerConnected()) {
                    timedOut(exception);
                    break;
                }
            }
        }

        /**
         * Wait until something is ready to be finalized.
         * Return false if we have been interrupted
         * See also http://code.google.com/p/android/issues/detail?id=22778.
         */
        private synchronized boolean sleepUntilNeeded() {
            while (activeWatchees == 0) {
                try {
                    wait();
                } catch (InterruptedException e) {
                    // Daemon.stop may have interrupted us.
                    return false;
                } catch (OutOfMemoryError e) {
                    return false;
                }
            }
            return true;
        }

        /**
         * Notify daemon that it's OK to sleep until notified that something is ready to be
         * finalized.
         */
        private synchronized void monitoringNotNeeded(int whichDaemon) {
            activeWatchees &= ~whichDaemon;
        }

        /**
         * Notify daemon that there is something ready to be finalized.
         */
        private synchronized void monitoringNeeded(int whichDaemon) {
            int oldWatchees = activeWatchees;
            activeWatchees |= whichDaemon;

            if (oldWatchees == 0) {
                notify();
            }
        }

        private synchronized boolean isActive(int whichDaemon) {
            return (activeWatchees & whichDaemon) != 0;
        }

        /**
         * Sleep for the given number of nanoseconds, or slightly longer.
         * @return false if we were interrupted.
         */
        private boolean sleepForNanos(long durationNanos) {
            // It's important to base this on nanoTime(), not currentTimeMillis(), since
            // the former stops counting when the processor isn't running.
            long startNanos = System.nanoTime();
            while (true) {
                long elapsedNanos = System.nanoTime() - startNanos;
                long sleepNanos = durationNanos - elapsedNanos;
                if (sleepNanos <= 0) {
                    return true;
                }
                // Ensure the nano time is always rounded up to the next whole millisecond,
                // ensuring the delay is >= the requested delay.
                long sleepMillis = (sleepNanos + NANOS_PER_MILLI - 1) / NANOS_PER_MILLI;
                try {
                    Thread.sleep(sleepMillis);
                } catch (InterruptedException e) {
                    if (!isRunning()) {
                        return false;
                    }
                } catch (OutOfMemoryError ignored) {
                    if (!isRunning()) {
                        return false;
                    }
                }
            }
        }


        /**
         * Return null (normal case) or an exception describing what timed out.
         * Wait VMRuntime.getFinalizerTimeoutMs.  If the FinalizerDaemon took essentially the
         * whole time processing a single reference, or the ReferenceQueueDaemon failed to make
         * visible progress during that time, return an exception.  Only called from a single
         * thread.
         */
        private TimeoutException waitForProgress() {
            if (finalizerTimeoutNs == 0) {
                finalizerTimeoutNs =
                        NANOS_PER_MILLI * VMRuntime.getRuntime().getFinalizerTimeoutMs();
                // Temporary app backward compatibility. Remove eventually.
                MAX_FINALIZE_NANOS = finalizerTimeoutNs;
            }
            // Read the counter before we read the "active" state the first time, and after
            // we read it the last time, to guarantee that if the state was ever inactive,
            // we'll see a changed counter.
            int finalizerStartCount = FinalizerDaemon.INSTANCE.progressCounter.get();
            boolean monitorFinalizer = isActive(FINALIZER_DAEMON);
            int refQueueStartCount = ReferenceQueueDaemon.INSTANCE.progressCounter.get();
            boolean monitorRefQueue = isActive(RQ_DAEMON);
            // Avoid remembering object being finalized, so as not to keep it alive.
            final long startMillis = System.currentTimeMillis();
            final long startNanos = System.nanoTime();

            // Rather than just sleeping for finalizerTimeoutNs and checking whether we made
            // progress, we sleep repeatedly. This means that if our process makes no progress,
            // e.g. because it is frozen, the watchdog also won't, making it less likely we will
            // spuriously time out. It does mean that in the normal case, we will go to sleep
            // and wake up twice per timeout period, rather than once.
            final int NUM_WAKEUPS = 5;
            for (int i = 1; i <= NUM_WAKEUPS; ++i) {
                if (!sleepForNanos(finalizerTimeoutNs / NUM_WAKEUPS)) {
                    // Don't report possibly spurious timeout if we are interrupted.
                    return null;
                }
                if (monitorFinalizer && isActive(FINALIZER_DAEMON)
                    && FinalizerDaemon.INSTANCE.progressCounter.get() == finalizerStartCount) {
                    // Still working on same finalizer or Java 9 Cleaner.
                    continue;
                }
                if (monitorRefQueue && isActive(RQ_DAEMON)
                    && ReferenceQueueDaemon.INSTANCE.progressCounter.get() == refQueueStartCount) {
                    // Still working on same ReferenceQueue or sun.misc.Cleaner.
                    continue;
                }
                // Everything that could make progress, already did. Just sleep for the rest of the
                // timeout interval.
                if (i < NUM_WAKEUPS) {
                    sleepForNanos((finalizerTimeoutNs  / NUM_WAKEUPS) * (NUM_WAKEUPS - i));
                    return null;
                }
            }
            // Either a state change to inactive, or a task completion would have caused us to see a
            // counter change. Thus at least one of the daemons appears stuck.
            if (monitorFinalizer && isActive(FINALIZER_DAEMON)
                && FinalizerDaemon.INSTANCE.progressCounter.get() == finalizerStartCount) {
                if (FinalizerDaemon.INSTANCE.exceptionLoggingState == FinalizerDaemon.LOGGING) {
                    // Try to let it finish and crash. We will time out if we get here again.
                    FinalizerDaemon.INSTANCE.exceptionLoggingState = FinalizerDaemon.TIMED_OUT;
                }
                // The finalizingObject field was set just before the counter increment, which
                // preceded the doFinalize() or doClean() call.  Thus we are guaranteed to get the
                // correct finalizing value below, unless doFinalize() just finished as we were
                // timing out, in which case we may get null or a later one.
                Object finalizing = FinalizerDaemon.INSTANCE.finalizingObject;
                System.logE("Was finalizing " + finalizingObjectAsString(finalizing)
                    + ", now finalizing "
                    + finalizingObjectAsString(FinalizerDaemon.INSTANCE.finalizingObject));
                // Print both time of day and monotonic time differences:
                System.logE("Total elapsed millis: "
                    + (System.currentTimeMillis() - startMillis));
                System.logE("Total elapsed nanos: " + (System.nanoTime() - startNanos));
                return finalizerTimeoutException(finalizing);
            }
            if (monitorRefQueue && isActive(RQ_DAEMON)
                && ReferenceQueueDaemon.INSTANCE.progressCounter.get() == refQueueStartCount) {
                // Report RQD timeouts only if they occur repeatedly.
                // TODO: Consider changing that, but we have historically been more tolerant here,
                // since we may not increment the reference counter for every processed queue
                // element.
                Object current = ReferenceQueueDaemon.INSTANCE.currentlyProcessing();
                String currentTarget = current == null ? "unknown" : current.toString();
                System.logE("ReferenceQueueDaemon timed out while targeting " + currentTarget
                        + ". Total nanos: " + (System.nanoTime() - startNanos));
                if (observedReferenceQueueTimeouts.incrementAndGet()
                        > TOLERATED_REFERENCE_QUEUE_TIMEOUTS) {
                    return refQueueTimeoutException(currentTarget);
                }
            }
            return null;
        }

        private static TimeoutException finalizerTimeoutException(Object object) {
            if (object == null) {
                return new TimeoutException("Unknown finalizer timed out");
            }
            StringBuilder messageBuilder = new StringBuilder();

            if (object instanceof Cleaner.Cleanable) {
                messageBuilder.append(VH_ACTION.get(object).getClass().getName());
            } else {
                messageBuilder.append(object.getClass().getName()).append(".finalize()");
            }

            messageBuilder.append(" timed out after ")
                    .append(VMRuntime.getRuntime().getFinalizerTimeoutMs() / 1000)
                    .append(" seconds");
            TimeoutException syntheticException = new TimeoutException(messageBuilder.toString());
            // We use the stack from where finalize() was running to show where it was stuck.
            syntheticException.setStackTrace(FinalizerDaemon.INSTANCE.getStackTrace());
            return syntheticException;
        }

        private static String finalizingObjectAsString(Object obj) {
            if (obj == null) {
                return "unknown";
            }
            if (obj instanceof Cleaner.Cleanable) {
                return VH_ACTION.get(obj).toString();
            } else {
                return obj.toString();
            }
        }

        private static TimeoutException refQueueTimeoutException(String target) {
            String message = "ReferenceQueueDaemon timed out while targeting " + target;
            return new TimeoutException(message);
        }

        private static void timedOut(TimeoutException exception) {
            // Send SIGQUIT to get native stack traces.
            try {
                Os.kill(Os.getpid(), OsConstants.SIGQUIT);
                // Sleep a few seconds to let the stack traces print.
                Thread.sleep(5000);
            } catch (Exception e) {
                System.logE("failed to send SIGQUIT", e);
            } catch (OutOfMemoryError ignored) {
                // May occur while trying to allocate the exception.
            }

            // Ideally, we'd want to do this if this Thread had no handler to dispatch to.
            // Unfortunately, it's extremely to messy to query whether a given Thread has *some*
            // handler to dispatch to, either via a handler set on itself, via its ThreadGroup
            // object or via the defaultUncaughtExceptionHandler.
            //
            // As an approximation, we log by hand and exit if there's no pre-exception handler nor
            // a default uncaught exception handler.
            //
            // Note that this condition will only ever be hit by ART host tests and standalone
            // dalvikvm invocations. All zygote forked process *will* have a pre-handler set
            // in RuntimeInit and they cannot subsequently override it.
            if (Thread.getUncaughtExceptionPreHandler() == null &&
                    Thread.getDefaultUncaughtExceptionHandler() == null) {
                // If we have no handler, log and exit.
                System.logE(exception.getMessage(), exception);
                System.exit(2);
            }

            // Otherwise call the handler to do crash reporting.
            // We don't just throw because we're not the thread that
            // timed out; we're the thread that detected it.
            Thread.currentThread().dispatchUncaughtException(exception);
        }
    }

    // Adds a heap trim task to the heap event processor, not called from java. Left for
    // compatibility purposes due to reflection.
    @UnsupportedAppUsage
    public static void requestHeapTrim() {
        VMRuntime.getRuntime().requestHeapTrim();
    }

    // Adds a concurrent GC request task ot the heap event processor, not called from java. Left
    // for compatibility purposes due to reflection.
    public static void requestGC() {
        VMRuntime.getRuntime().requestConcurrentGC();
    }

    private static class HeapTaskDaemon extends Daemon {
        private static final HeapTaskDaemon INSTANCE = new HeapTaskDaemon();

        HeapTaskDaemon() {
            super("HeapTaskDaemon");
        }

        // Overrides the Daemon.interupt method which is called from Daemons.stop.
        public synchronized void interrupt(Thread thread) {
            VMRuntime.getRuntime().stopHeapTaskProcessor();
        }

        @Override public void runInternal() {
            synchronized (this) {
                if (isRunning()) {
                  // Needs to be synchronized or else we there is a race condition where we start
                  // the thread, call stopHeapTaskProcessor before we start the heap task
                  // processor, resulting in a deadlock since startHeapTaskProcessor restarts it
                  // while the other thread is waiting in Daemons.stop().
                  VMRuntime.getRuntime().startHeapTaskProcessor();
                }
            }
            // This runs tasks until we are stopped and there is no more pending task.
            VMRuntime.getRuntime().runHeapTasks();
        }
    }
}