diff -r c1c71107d45f -r 3396ae214e7d jdk/src/java.base/share/classes/java/lang/StackStreamFactory.java
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/src/java.base/share/classes/java/lang/StackStreamFactory.java	Mon Nov 23 12:44:50 2015 -0800
@@ -0,0 +1,1106 @@
+/*
+ * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code 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 General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package java.lang;
+
+import sun.misc.VM;
+
+import java.io.PrintStream;
+import java.lang.StackWalker.Option;
+import java.lang.StackWalker.StackFrame;
+
+import java.lang.annotation.Native;
+import java.lang.reflect.Method;
+import java.security.AccessController;
+import java.security.PrivilegedAction;
+import java.util.Arrays;
+import java.util.EnumSet;
+import java.util.HashSet;
+import java.util.NoSuchElementException;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.Set;
+import java.util.Spliterator;
+import java.util.function.Consumer;
+import java.util.function.Function;
+import java.util.stream.Stream;
+import java.util.stream.StreamSupport;
+
+import static java.lang.StackStreamFactory.WalkerState.*;
+
+/**
+ * StackStreamFactory class provides static factory methods
+ * to get different kinds of stack walker/traverser.
+ *
+ * AbstractStackWalker provides the basic stack walking support
+ * fetching stack frames from VM in batches.
+ *
+ * AbstractStackWalker subclass is specialized for a specific kind of stack traversal
+ * to avoid overhead of Stream/Lambda
+ * 1. Support traversing Stream<StackFrame>
+ * 2. StackWalker::getCallerClass
+ * 3. Throwable::init and Throwable::getStackTrace
+ * 4. AccessControlContext getting ProtectionDomain
+ */
+final class StackStreamFactory {
+    private StackStreamFactory() {}
+
+    // Stack walk implementation classes to be excluded during stack walking
+    // lazily add subclasses when they are loaded.
+    private final static Set<Class<?>> stackWalkImplClasses = init();
+
+    private static final int SMALL_BATCH       = 8;
+    private static final int BATCH_SIZE        = 32;
+    private static final int LARGE_BATCH_SIZE  = 256;
+    private static final int MIN_BATCH_SIZE    = SMALL_BATCH;
+
+    // These flags must match the values maintained in the VM
+    @Native private static final int DEFAULT_MODE              = 0x0;
+    @Native private static final int FILL_CLASS_REFS_ONLY      = 0x2;
+    @Native private static final int FILTER_FILL_IN_STACKTRACE = 0x10;
+    @Native private static final int SHOW_HIDDEN_FRAMES        = 0x20;  // LambdaForms are hidden by the VM
+    @Native private static final int FILL_LIVE_STACK_FRAMES    = 0x100;
+
+    /*
+     * For Throwable to use StackWalker, set useNewThrowable to true.
+     * Performance work and extensive testing is needed to replace the
+     * VM built-in backtrace filled in Throwable with the StackWalker.
+     */
+    final static boolean useNewThrowable = getProperty("stackwalk.newThrowable", false);
+    final static boolean isDebug = getProperty("stackwalk.debug", false);
+
+    static <T> StackFrameTraverser<T>
+        makeStackTraverser(StackWalker walker, Function<? super Stream<StackFrame>, ? extends T> function)
+    {
+        if (walker.hasLocalsOperandsOption())
+            return new LiveStackInfoTraverser<T>(walker, function);
+        else
+            return new StackFrameTraverser<T>(walker, function);
+    }
+
+    /**
+     * Gets a stack stream to find caller class.
+     */
+    static CallerClassFinder makeCallerFinder(StackWalker walker) {
+        return new CallerClassFinder(walker);
+    }
+
+    static boolean useStackTrace(Throwable t) {
+        if (t instanceof VirtualMachineError)
+            return false;
+
+        return VM.isBooted() && StackStreamFactory.useNewThrowable;
+    }
+
+    /*
+     * This should only be used by Throwable::<init>.
+     */
+    static StackTrace makeStackTrace(Throwable ex) {
+        return StackTrace.dump(ex);
+    }
+
+    /*
+     * This creates StackTrace for Thread::dumpThread to use.
+     */
+    static StackTrace makeStackTrace() {
+        return StackTrace.dump();
+    }
+
+    enum WalkerState {
+        NEW,     // the stream is new and stack walking has not started
+        OPEN,    // the stream is open when it is being traversed.
+        CLOSED;  // the stream is closed when the stack walking is done
+    }
+
+    static abstract class AbstractStackWalker<T> {
+        protected final StackWalker walker;
+        protected final Thread thread;
+        protected final int maxDepth;
+        protected final long mode;
+        protected int depth;                 // traversed stack depth
+        protected FrameBuffer frameBuffer;   // buffer for VM to fill in
+        protected long anchor;
+
+        // buffers to fill in stack frame information
+        protected AbstractStackWalker(StackWalker walker, int mode) {
+            this(walker, mode, Integer.MAX_VALUE);
+        }
+        protected AbstractStackWalker(StackWalker walker, int mode, int maxDepth) {
+            this.thread = Thread.currentThread();
+            this.mode = toStackWalkMode(walker, mode);
+            this.walker = walker;
+            this.maxDepth = maxDepth;
+            this.depth = 0;
+        }
+
+        private int toStackWalkMode(StackWalker walker, int mode) {
+            int newMode = mode;
+            if (walker.hasOption(Option.SHOW_HIDDEN_FRAMES) &&
+                    !fillCallerClassOnly(newMode) /* don't show hidden frames for getCallerClass */)
+                newMode |= SHOW_HIDDEN_FRAMES;
+            if (walker.hasLocalsOperandsOption())
+                newMode |= FILL_LIVE_STACK_FRAMES;
+            return newMode;
+        }
+
+        private boolean fillCallerClassOnly(int mode) {
+            return (mode|FILL_CLASS_REFS_ONLY) != FILL_CLASS_REFS_ONLY;
+        }
+        /**
+         * A callback method to consume the stack frames.  This method is invoked
+         * once stack walking begins (i.e. it is only invoked when walkFrames is called).
+         *
+         * Each specialized AbstractStackWalker subclass implements the consumeFrames method
+         * to control the following:
+         * 1. fetch the subsequent batches of stack frames
+         * 2. reuse or expand the allocated buffers
+         * 3. create specialized StackFrame objects
+         *
+         * @return the number of consumed frames
+         */
+         protected abstract T consumeFrames();
+
+        /**
+         * Initialize FrameBuffer.  Subclass should implement this method to
+         * create its custom frame buffers.
+         */
+         protected abstract void initFrameBuffer();
+
+        /**
+         * Returns the suggested next batch size.
+         *
+         * Subclass should override this method to change the batch size
+         *
+         * @param lastBatchFrameCount number of frames in the last batch; or zero
+         * @return suggested batch size
+         */
+        protected abstract int batchSize(int lastBatchFrameCount);
+
+        /*
+         * Returns the next batch size, always >= minimum batch size (32)
+         *
+         * Subclass may override this method if the minimum batch size is different.
+         */
+        protected int getNextBatchSize() {
+            int lastBatchSize = depth == 0 ? 0 : frameBuffer.curBatchFrameCount();
+            int nextBatchSize = batchSize(lastBatchSize);
+            if (isDebug) {
+                System.err.println("last batch size = " + lastBatchSize +
+                                   " next batch size = " + nextBatchSize);
+            }
+            return nextBatchSize >= MIN_BATCH_SIZE ? nextBatchSize : MIN_BATCH_SIZE;
+        }
+
+        /*
+         * Checks if this stream is in the given state. Otherwise, throws IllegalStateException.
+         *
+         * VM also validates this stream if it's anchored for stack walking
+         * when stack frames are fetched for each batch.
+         */
+        final void checkState(WalkerState state) {
+            if (thread != Thread.currentThread()) {
+                throw new IllegalStateException("Invalid thread walking this stack stream: " +
+                        Thread.currentThread().getName() + " " + thread.getName());
+            }
+            switch (state) {
+                case NEW:
+                    if (this.anchor != 0) {
+                        throw new IllegalStateException("This stack stream is being reused.");
+                    }
+                    break;
+                case OPEN:
+                    if (this.anchor <= 0) {
+                        throw new IllegalStateException("This stack stream is not valid for walking");
+                    }
+                    break;
+                case CLOSED:
+                    if (this.anchor != -1L) {
+                        throw new IllegalStateException("This stack stream is not closed.");
+                    }
+            }
+        }
+
+        /*
+         * Close this stream.  This stream becomes invalid to walk.
+         */
+        private void close() {
+            this.anchor = -1L;
+        }
+
+        /*
+         * Walks stack frames until {@link #consumeFrames} is done consuming
+         * the frames it is interested in.
+         */
+        final T walk() {
+            checkState(NEW);
+            try {
+                // VM will need to stablize the stack before walking.  It will invoke
+                // the AbstractStackWalker::doStackWalk method once it fetches the first batch.
+                // the callback will be invoked within the scope of the callStackWalk frame.
+                return beginStackWalk();
+            } finally {
+                close();  // done traversal; close the stream
+            }
+        }
+
+        private boolean skipReflectionFrames() {
+            return !walker.hasOption(Option.SHOW_REFLECT_FRAMES) &&
+                       !walker.hasOption(Option.SHOW_HIDDEN_FRAMES);
+        }
+
+        /*
+         * Returns {@code Class} object at the current frame;
+         * or {@code null} if no more frame. If advanceToNextBatch is true,
+         * it will only fetch the next batch.
+         */
+        final Class<?> peekFrame() {
+            while (frameBuffer.isActive() && depth < maxDepth) {
+                if (frameBuffer.isEmpty()) {
+                    // fetch another batch of stack frames
+                    getNextBatch();
+                } else {
+                    Class<?> c = frameBuffer.get();
+                    if (skipReflectionFrames() && isReflectionFrame(c)) {
+                        if (isDebug)
+                            System.err.println("  skip: frame " + frameBuffer.getIndex() + " " + c);
+
+                        frameBuffer.next();
+                        depth++;
+                        continue;
+                    } else {
+                        return c;
+                    }
+                }
+            }
+            return null;
+        }
+
+        /*
+         * This method is only invoked by VM.
+         *
+         * It will invoke the consumeFrames method to start the stack walking
+         * with the first batch of stack frames.  Each specialized AbstractStackWalker
+         * subclass implements the consumeFrames method to control the following:
+         * 1. fetch the subsequent batches of stack frames
+         * 2. reuse or expand the allocated buffers
+         * 3. create specialized StackFrame objects
+         */
+        private Object doStackWalk(long anchor, int skipFrames, int batchSize,
+                                                int bufStartIndex, int bufEndIndex) {
+            checkState(NEW);
+
+            frameBuffer.check(skipFrames);
+
+            if (isDebug) {
+                System.err.format("doStackWalk: skip %d start %d end %d%n",
+                        skipFrames, bufStartIndex, bufEndIndex);
+            }
+
+            this.anchor = anchor;  // set anchor for this bulk stack frame traversal
+            frameBuffer.setBatch(bufStartIndex, bufEndIndex);
+
+            // traverse all frames and perform the action on the stack frames, if specified
+            return consumeFrames();
+        }
+
+        /*
+         * Get next batch of stack frames.
+         */
+        private int getNextBatch() {
+            int nextBatchSize = Math.min(maxDepth - depth, getNextBatchSize());
+            if (!frameBuffer.isActive() || nextBatchSize <= 0) {
+                if (isDebug) {
+                    System.out.format("  more stack walk done%n");
+                }
+                frameBuffer.freeze();   // stack walk done
+                return 0;
+            }
+
+            return fetchStackFrames(nextBatchSize);
+        }
+
+        /*
+         * This method traverses the next stack frame and returns the Class
+         * invoking that stack frame.
+         *
+         * This method can only be called during the walk method.  This is intended
+         * to be used to walk the stack frames in one single invocation and
+         * this stack stream will be invalidated once walk is done.
+         *
+         * @see #tryNextFrame
+         */
+        final Class<?> nextFrame() {
+            if (!hasNext()) {
+                return null;
+            }
+
+            Class<?> c = frameBuffer.next();
+            depth++;
+            return c;
+        }
+
+        /*
+         * Returns true if there is next frame to be traversed.
+         * This skips hidden frames unless this StackWalker has
+         * {@link Option#SHOW_REFLECT_FRAMES}
+         */
+        final boolean hasNext() {
+            return peekFrame() != null;
+        }
+
+        /**
+         * Begin stack walking - pass the allocated arrays to the VM to fill in
+         * stack frame information.
+         *
+         * VM first anchors the frame of the current thread.  A traversable stream
+         * on this thread's stack will be opened.  The VM will fetch the first batch
+         * of stack frames and call AbstractStackWalker::doStackWalk to invoke the
+         * stack walking function on each stack frame.
+         *
+         * If all fetched stack frames are traversed, AbstractStackWalker::fetchStackFrames will
+         * fetch the next batch of stack frames to continue.
+         */
+        private T beginStackWalk() {
+            // initialize buffers for VM to fill the stack frame info
+            initFrameBuffer();
+
+            return callStackWalk(mode, 0,
+                                 frameBuffer.curBatchFrameCount(),
+                                 frameBuffer.startIndex(),
+                                 frameBuffer.classes,
+                                 frameBuffer.stackFrames);
+        }
+
+        /*
+         * Fetches stack frames.
+         *
+         * @params batchSize number of elements of the frame  buffers for this batch
+         * @returns number of frames fetched in this batch
+         */
+        private int fetchStackFrames(int batchSize) {
+            int startIndex = frameBuffer.startIndex();
+            frameBuffer.resize(startIndex, batchSize);
+
+            int endIndex = fetchStackFrames(mode, anchor, batchSize,
+                                            startIndex,
+                                            frameBuffer.classes,
+                                            frameBuffer.stackFrames);
+            if (isDebug) {
+                System.out.format("  more stack walk requesting %d got %d to %d frames%n",
+                                  batchSize, frameBuffer.startIndex(), endIndex);
+            }
+            int numFrames = endIndex - startIndex;
+            if (numFrames == 0) {
+                frameBuffer.freeze(); // done stack walking
+            } else {
+                frameBuffer.setBatch(startIndex, endIndex);
+            }
+            return numFrames;
+        }
+
+        /**
+         * Begins stack walking.  This method anchors this frame and invokes
+         * AbstractStackWalker::doStackWalk after fetching the firt batch of stack frames.
+         *
+         * @param mode        mode of stack walking
+         * @param skipframes  number of frames to be skipped before filling the frame buffer.
+         * @param batchSize   the batch size, max. number of elements to be filled in the frame buffers.
+         * @param startIndex  start index of the frame buffers to be filled.
+         * @param classes     Classes buffer of the stack frames
+         * @param frames      StackFrame buffer, or null
+         * @return            Result of AbstractStackWalker::doStackWalk
+         */
+        private native T callStackWalk(long mode, int skipframes,
+                                       int batchSize, int startIndex,
+                                       Class<?>[] classes,
+                                       StackFrame[] frames);
+
+        /**
+         * Fetch the next batch of stack frames.
+         *
+         * @param mode        mode of stack walking
+         * @param anchor
+         * @param batchSize   the batch size, max. number of elements to be filled in the frame buffers.
+         * @param startIndex  start index of the frame buffers to be filled.
+         * @param classes     Classes buffer of the stack frames
+         * @param frames      StackFrame buffer, or null
+         *
+         * @return the end index to the frame buffers
+         */
+        private native int fetchStackFrames(long mode, long anchor,
+                                            int batchSize, int startIndex,
+                                            Class<?>[] classes,
+                                            StackFrame[] frames);
+
+
+        /*
+         * Frame buffer
+         *
+         * Each specialized AbstractStackWalker subclass may subclass the FrameBuffer.
+         */
+        class FrameBuffer {
+            static final int START_POS = 2;     // 0th and 1st elements are reserved
+
+            // buffers for VM to fill stack frame info
+            int currentBatchSize;    // current batch size
+            Class<?>[] classes;      // caller class for fast path
+
+            StackFrame[] stackFrames;
+
+            int origin;         // index to the current traversed stack frame
+            int fence;          // index to the last frame in the current batch
+
+            FrameBuffer(int initialBatchSize) {
+                if (initialBatchSize < MIN_BATCH_SIZE) {
+                    throw new IllegalArgumentException(initialBatchSize + " < minimum batch size: " + MIN_BATCH_SIZE);
+                }
+                this.origin = START_POS;
+                this.fence = 0;
+                this.currentBatchSize = initialBatchSize;
+                this.classes = new Class<?>[currentBatchSize];
+            }
+
+            int curBatchFrameCount() {
+                return currentBatchSize-START_POS;
+            }
+
+            /*
+             * Tests if this frame buffer is empty.  All frames are fetched.
+             */
+            final boolean isEmpty() {
+                return origin >= fence || (origin == START_POS && fence == 0);
+            }
+
+            /*
+             * Freezes this frame buffer.  The stack stream source is done fetching.
+             */
+            final void freeze() {
+                origin = 0;
+                fence = 0;
+            }
+
+            /*
+             * Tests if this frame buffer is active.  It is inactive when
+             * it is done for traversal.  All stack frames have been traversed.
+             */
+            final boolean isActive() {
+                return origin > 0 && (fence == 0 || origin < fence || fence == currentBatchSize);
+            }
+
+            /**
+             * Gets the class at the current frame and move to the next frame.
+             */
+            final Class<?> next() {
+                if (isEmpty()) {
+                    throw new NoSuchElementException("origin=" + origin + " fence=" + fence);
+                }
+                Class<?> c = classes[origin++];
+                if (isDebug) {
+                    int index = origin-1;
+                    System.out.format("  next frame at %d: %s (origin %d fence %d)%n", index,
+                                      Objects.toString(c), index, fence);
+                }
+                return c;
+            }
+
+            /**
+             * Gets the class at the current frame.
+             */
+            final Class<?> get() {
+                if (isEmpty()) {
+                    throw new NoSuchElementException("origin=" + origin + " fence=" + fence);
+                }
+                return classes[origin];
+            }
+
+            /*
+             * Returns the index of the current frame.
+             */
+            final int getIndex() {
+                return origin;
+            }
+
+            /*
+             * Set the start and end index of a new batch of stack frames that have
+             * been filled in this frame buffer.
+             */
+            final void setBatch(int startIndex, int endIndex) {
+                if (startIndex <= 0 || endIndex <= 0)
+                    throw new IllegalArgumentException("startIndex=" + startIndex + " endIndex=" + endIndex);
+
+                this.origin = startIndex;
+                this.fence = endIndex;
+                if (depth == 0 && fence > 0) {
+                    // filter the frames due to the stack stream implementation
+                    for (int i = START_POS; i < fence; i++) {
+                        Class<?> c = classes[i];
+                        if (isDebug) System.err.format("  frame %d: %s%n", i, c);
+                        if (filterStackWalkImpl(c)) {
+                            origin++;
+                        } else {
+                            break;
+                        }
+                    }
+                }
+            }
+
+            /*
+             * Checks if the origin is the expected start index.
+             */
+            final void check(int skipFrames) {
+                int index = skipFrames + START_POS;
+                if (origin != index) {
+                    // stack walk must continue with the previous frame depth
+                    throw new IllegalStateException("origin " + origin + " != " + index);
+                }
+            }
+
+            // ------ subclass may override the following methods -------
+            /**
+             * Resizes the buffers for VM to fill in the next batch of stack frames.
+             * The next batch will start at the given startIndex with the maximum number
+             * of elements.
+             *
+             * <p> Subclass may override this method to manage the allocated buffers.
+             *
+             * @param startIndex the start index for the first frame of the next batch to fill in.
+             * @param elements the number of elements for the next batch to fill in.
+             *
+             */
+            void resize(int startIndex, int elements) {
+                if (!isActive())
+                    throw new IllegalStateException("inactive frame buffer can't be resized");
+
+                int size = startIndex+elements;
+                if (classes.length < size) {
+                    // copy the elements in classes array to the newly allocated one.
+                    // classes[0] is a Thread object
+                    Class<?>[] prev = classes;
+                    classes = new Class<?>[size];
+                    System.arraycopy(prev, 0, classes, 0, START_POS);
+                }
+                currentBatchSize = size;
+            }
+
+            /*
+             * Returns the start index for this frame buffer is refilled.
+             *
+             * This implementation reuses the allocated buffer for the next batch
+             * of stack frames.  For subclass to retain the fetched stack frames,
+             * it should override this method to return the index at which the frame
+             * should be filled in for the next batch.
+             */
+            int startIndex() {
+                return START_POS;
+            }
+
+            /**
+             * Returns next StackFrame object in the current batch of stack frames
+             */
+            StackFrame nextStackFrame() {
+                throw new InternalError("should not reach here");
+            }
+        }
+    }
+
+    /*
+     * This StackFrameTraverser supports {@link Stream} traversal.
+     *
+     * This class implements Spliterator::forEachRemaining and Spliterator::tryAdvance.
+     */
+    static class StackFrameTraverser<T> extends AbstractStackWalker<T>
+            implements Spliterator<StackFrame>
+    {
+        static {
+            stackWalkImplClasses.add(StackFrameTraverser.class);
+        }
+        private static final int CHARACTERISTICS = Spliterator.ORDERED | Spliterator.IMMUTABLE;
+        class Buffer extends FrameBuffer {
+            Buffer(int initialBatchSize) {
+                super(initialBatchSize);
+
+                this.stackFrames = new StackFrame[initialBatchSize];
+                for (int i = START_POS; i < initialBatchSize; i++) {
+                    stackFrames[i] = new StackFrameInfo(walker);
+                }
+            }
+
+            @Override
+            void resize(int startIndex, int elements) {
+                super.resize(startIndex, elements);
+
+                int size = startIndex+elements;
+                if (stackFrames.length < size) {
+                    stackFrames = new StackFrame[size];
+                }
+                for (int i = startIndex(); i < size; i++) {
+                    stackFrames[i] = new StackFrameInfo(walker);
+                }
+            }
+
+            @Override
+            StackFrame nextStackFrame() {
+                if (isEmpty()) {
+                    throw new NoSuchElementException("origin=" + origin + " fence=" + fence);
+                }
+
+                StackFrame frame = stackFrames[origin];
+                origin++;
+                return frame;
+            }
+        }
+
+        final Function<? super Stream<StackFrame>, ? extends T> function;  // callback
+
+        StackFrameTraverser(StackWalker walker,
+                            Function<? super Stream<StackFrame>, ? extends T> function) {
+            this(walker, function, DEFAULT_MODE);
+        }
+        StackFrameTraverser(StackWalker walker,
+                            Function<? super Stream<StackFrame>, ? extends T> function,
+                            int mode) {
+            super(walker, mode);
+            this.function = function;
+        }
+
+        /**
+         * Returns next StackFrame object in the current batch of stack frames;
+         * or null if no more stack frame.
+         */
+        StackFrame nextStackFrame() {
+            if (!hasNext()) {
+                return null;
+            }
+
+            StackFrame frame = frameBuffer.nextStackFrame();
+            depth++;
+            return frame;
+        }
+
+        @Override
+        protected T consumeFrames() {
+            checkState(OPEN);
+            Stream<StackFrame> stream = StreamSupport.stream(this, false);
+            if (function != null) {
+                return function.apply(stream);
+            } else
+                throw new UnsupportedOperationException();
+        }
+
+        @Override
+        protected void initFrameBuffer() {
+            this.frameBuffer = new Buffer(getNextBatchSize());
+        }
+
+        @Override
+        protected int batchSize(int lastBatchFrameCount) {
+            if (lastBatchFrameCount == 0) {
+                // First batch, use estimateDepth if not exceed the large batch size
+                // and not too small
+                int initialBatchSize = Math.max(walker.estimateDepth(), SMALL_BATCH);
+                return Math.min(initialBatchSize, LARGE_BATCH_SIZE);
+            } else {
+                if (lastBatchFrameCount > BATCH_SIZE) {
+                    return lastBatchFrameCount;
+                } else {
+                    return Math.min(lastBatchFrameCount*2, BATCH_SIZE);
+                }
+            }
+        }
+
+        // ------- Implementation of Spliterator
+
+        @Override
+        public Spliterator<StackFrame> trySplit() {
+            return null;   // ordered stream and do not allow to split
+        }
+
+        @Override
+        public long estimateSize() {
+            return maxDepth;
+        }
+
+        @Override
+        public int characteristics() {
+            return CHARACTERISTICS;
+        }
+
+        @Override
+        public void forEachRemaining(Consumer<? super StackFrame> action) {
+            checkState(OPEN);
+            for (int n = 0; n < maxDepth; n++) {
+                StackFrame frame = nextStackFrame();
+                if (frame == null) break;
+
+                action.accept(frame);
+            }
+        }
+
+        @Override
+        public boolean tryAdvance(Consumer<? super StackFrame> action) {
+            checkState(OPEN);
+
+            int index = frameBuffer.getIndex();
+            if (hasNext()) {
+                StackFrame frame = nextStackFrame();
+                action.accept(frame);
+                if (isDebug) {
+                    System.err.println("tryAdvance: " + index + " " + frame);
+                }
+                return true;
+            }
+            if (isDebug) {
+                System.err.println("tryAdvance: " + index + " NO element");
+            }
+            return false;
+        }
+    }
+
+    /*
+     * CallerClassFinder is specialized to return Class<?> for each stack frame.
+     * StackFrame is not requested.
+     */
+    static class CallerClassFinder extends AbstractStackWalker<Integer> {
+        static {
+            stackWalkImplClasses.add(CallerClassFinder.class);
+        }
+
+        private Class<?> caller;
+
+        CallerClassFinder(StackWalker walker) {
+            super(walker, FILL_CLASS_REFS_ONLY);
+        }
+
+        Class<?> findCaller() {
+            walk();
+            return caller;
+        }
+
+        @Override
+        protected Integer consumeFrames() {
+            checkState(OPEN);
+            int n = 0;
+            Class<?>[] frames = new Class<?>[2];
+            // skip the API calling this getCallerClass method
+            // 0: StackWalker::getCallerClass
+            // 1: caller-sensitive method
+            // 2: caller class
+            while (n < 2 && (caller = nextFrame()) != null) {
+                if (isMethodHandleFrame(caller)) continue;
+                frames[n++] = caller;
+            }
+
+            if (frames[1] == null)
+                throw new IllegalStateException("no caller frame");
+            return n;
+        }
+
+        @Override
+        protected void initFrameBuffer() {
+            this.frameBuffer = new FrameBuffer(getNextBatchSize());
+        }
+
+        @Override
+        protected int batchSize(int lastBatchFrameCount) {
+            return MIN_BATCH_SIZE;
+        }
+
+        @Override
+        protected int getNextBatchSize() {
+            return MIN_BATCH_SIZE;
+        }
+    }
+
+    /*
+     * StackTrace caches all frames in the buffer.  StackTraceElements are
+     * created lazily when Throwable::getStackTrace is called.
+     */
+    static class StackTrace extends AbstractStackWalker<Integer> {
+        static {
+            stackWalkImplClasses.add(StackTrace.class);
+        }
+
+        class GrowableBuffer extends FrameBuffer {
+            GrowableBuffer(int initialBatchSize) {
+                super(initialBatchSize);
+
+                this.stackFrames = new StackFrame[initialBatchSize];
+                for (int i = START_POS; i < initialBatchSize; i++) {
+                    stackFrames[i] = new StackFrameInfo(walker);
+                }
+            }
+
+            /*
+             * Returns the next index to fill
+             */
+            @Override
+            int startIndex() {
+                return origin;
+            }
+
+            /**
+             * Initialize the buffers for VM to fill in the stack frame information.
+             * The next batch will start at the given startIndex to
+             * the length of the buffer.
+             */
+            @Override
+            void resize(int startIndex, int elements) {
+                // Expand the frame buffer.
+                // Do not call super.resize that will reuse the filled elements
+                // in this frame buffer
+                int size = startIndex+elements;
+                if (classes.length < size) {
+                    // resize the frame buffer
+                    classes = Arrays.copyOf(classes, size);
+                    stackFrames = Arrays.copyOf(stackFrames, size);
+                }
+                for (int i = startIndex; i < size; i++) {
+                    stackFrames[i] = new StackFrameInfo(walker);
+                }
+                currentBatchSize = size;
+            }
+
+            StackTraceElement get(int index) {
+                return new StackTraceElement(classes[index].getName(), "unknown", null, -1);
+            }
+
+            /**
+             * Returns an array of StackTraceElement for all stack frames cached in
+             * this StackTrace object.
+             * <p>
+             * This method is intended for Throwable::getOurStackTrace use only.
+             */
+            StackTraceElement[] toStackTraceElements() {
+                int startIndex = START_POS;
+                for (int i = startIndex; i < classes.length; i++) {
+                    if (classes[i] != null && filterStackWalkImpl(classes[i])) {
+                        startIndex++;
+                    } else {
+                        break;
+                    }
+                }
+
+                // VM fills in the method name, filename, line number info
+                StackFrameInfo.fillInStackFrames(0, stackFrames, startIndex, startIndex + depth);
+
+                StackTraceElement[] stes = new StackTraceElement[depth];
+                for (int i = startIndex, j = 0; i < classes.length && j < depth; i++, j++) {
+                    if (isDebug) {
+                        System.err.println("StackFrame: " + i + " " + stackFrames[i]);
+                    }
+                    stes[j] = stackFrames[i].toStackTraceElement();
+                }
+                return stes;
+            }
+        }
+
+        private static final int MAX_STACK_FRAMES = 1024;
+        private static final StackWalker STACKTRACE_WALKER =
+            StackWalker.newInstanceNoCheck(EnumSet.of(Option.SHOW_REFLECT_FRAMES));
+
+        private StackTraceElement[] stes;
+        static StackTrace dump() {
+            return new StackTrace();
+        }
+
+        static StackTrace dump(Throwable ex) {
+            return new StackTrace(ex);
+        }
+
+        private StackTrace() {
+            this(STACKTRACE_WALKER, DEFAULT_MODE);
+        }
+
+        /*
+         * Throwable::fillInStackTrace and <init> of Throwable and subclasses
+         * are filtered in the VM.
+         */
+        private StackTrace(Throwable ex) {
+            this(STACKTRACE_WALKER, FILTER_FILL_IN_STACKTRACE);  // skip Throwable::init frames
+            if (isDebug) {
+                System.err.println("dump stack for " + ex.getClass().getName());
+            }
+        }
+
+        StackTrace(StackWalker walker, int mode) {
+            super(walker, mode, MAX_STACK_FRAMES);
+
+            // snapshot the stack trace
+            walk();
+        }
+
+        @Override
+        protected Integer consumeFrames() {
+            // traverse all frames and perform the action on the stack frames, if specified
+            int n = 0;
+            while (n < maxDepth && nextFrame() != null) {
+                n++;
+            }
+            return n;
+        }
+
+        @Override
+        protected void initFrameBuffer() {
+            this.frameBuffer = new GrowableBuffer(getNextBatchSize());
+        }
+
+        // TODO: implement better heuristic
+        @Override
+        protected int batchSize(int lastBatchFrameCount) {
+            // chunk size of VM backtrace is 32
+            return lastBatchFrameCount == 0 ? 32 : 32;
+        }
+
+        /**
+         * Returns an array of StackTraceElement for all stack frames cached in
+         * this StackTrace object.
+         * <p>
+         * This method is intended for Throwable::getOurStackTrace use only.
+         */
+        synchronized StackTraceElement[] getStackTraceElements() {
+            if (stes == null) {
+                stes = ((GrowableBuffer) frameBuffer).toStackTraceElements();
+                // release the frameBuffer memory
+                frameBuffer = null;
+            }
+            return stes;
+        }
+
+        /*
+         * Prints stack trace to the given PrintStream.
+         *
+         * Further implementation could skip creating StackTraceElement objects
+         * print directly to the PrintStream.
+         */
+        void printStackTrace(PrintStream s) {
+            StackTraceElement[] stes = getStackTraceElements();
+            synchronized (s) {
+                s.println("Stack trace");
+                for (StackTraceElement traceElement : stes)
+                    s.println("\tat " + traceElement);
+            }
+        }
+    }
+
+    static class LiveStackInfoTraverser<T> extends StackFrameTraverser<T> {
+        static {
+            stackWalkImplClasses.add(LiveStackInfoTraverser.class);
+        }
+        // VM will fill in all method info and live stack info directly in StackFrameInfo
+        class Buffer extends FrameBuffer {
+            Buffer(int initialBatchSize) {
+                super(initialBatchSize);
+                this.stackFrames = new StackFrame[initialBatchSize];
+                for (int i = START_POS; i < initialBatchSize; i++) {
+                    stackFrames[i] = new LiveStackFrameInfo(walker);
+                }
+            }
+
+            @Override
+            void resize(int startIndex, int elements) {
+                super.resize(startIndex, elements);
+                int size = startIndex + elements;
+
+                if (stackFrames.length < size) {
+                    this.stackFrames = new StackFrame[size];
+                }
+
+                for (int i = startIndex(); i < size; i++) {
+                    stackFrames[i] = new LiveStackFrameInfo(walker);
+                }
+            }
+
+            @Override
+            StackFrame nextStackFrame() {
+                if (isEmpty()) {
+                    throw new NoSuchElementException("origin=" + origin + " fence=" + fence);
+                }
+
+                StackFrame frame = stackFrames[origin];
+                origin++;
+                return frame;
+            }
+        }
+
+        LiveStackInfoTraverser(StackWalker walker,
+                               Function<? super Stream<StackFrame>, ? extends T> function) {
+            super(walker, function, DEFAULT_MODE);
+        }
+
+        @Override
+        protected void initFrameBuffer() {
+            this.frameBuffer = new Buffer(getNextBatchSize());
+        }
+    }
+
+    private static native boolean checkStackWalkModes();
+
+    // avoid loading other subclasses as they may not be used
+    private static Set<Class<?>> init() {
+        if (!checkStackWalkModes()) {
+            throw new InternalError("StackWalker mode values do not match with JVM");
+        }
+
+        Set<Class<?>> classes = new HashSet<>();
+        classes.add(StackWalker.class);
+        classes.add(StackStreamFactory.class);
+        classes.add(AbstractStackWalker.class);
+        return classes;
+    }
+
+    private static boolean filterStackWalkImpl(Class<?> c) {
+        return stackWalkImplClasses.contains(c) ||
+                c.getName().startsWith("java.util.stream.");
+    }
+
+    // MethodHandle frames are not hidden and CallerClassFinder has
+    // to filter them out
+    private static boolean isMethodHandleFrame(Class<?> c) {
+        return c.getName().startsWith("java.lang.invoke.");
+    }
+
+    private static boolean isReflectionFrame(Class<?> c) {
+        if (c.getName().startsWith("sun.reflect") &&
+                !sun.reflect.MethodAccessor.class.isAssignableFrom(c)) {
+            throw new InternalError("Not sun.reflect.MethodAccessor: " + c.toString());
+        }
+        // ## should filter all @Hidden frames?
+        return c == Method.class ||
+                sun.reflect.MethodAccessor.class.isAssignableFrom(c) ||
+                c.getName().startsWith("java.lang.invoke.LambdaForm");
+    }
+
+    private static boolean getProperty(String key, boolean value) {
+        String s = AccessController.doPrivileged(new PrivilegedAction<>() {
+            @Override
+            public String run() {
+                return System.getProperty(key);
+            }
+        });
+        if (s != null) {
+            return Boolean.valueOf(s);
+        }
+        return value;
+    }
+}