GarbageUtils.java

/*
 * Copyright (c) 2007, 2019, 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.
 *
 * 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 nsk.share.gc.gp;

import java.io.IOException;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.lang.invoke.*;
import java.util.*;
import nsk.share.gc.gp.array.*;
import nsk.share.gc.gp.string.*;
import nsk.share.gc.gp.list.*;
import nsk.share.gc.gp.tree.*;
import nsk.share.gc.gp.misc.*;
import nsk.share.gc.gp.classload.*;
import nsk.share.gc.Memory;
import nsk.share.TestBug;
import nsk.share.test.*;

/**
 * Utility methods for garbage producers.
 */
public final class GarbageUtils {
        private static final int ALLOCATION_LIMIT = 50000000; //50 Mb
        private static GarbageProducers garbageProducers;
        private static List<GarbageProducer> primitiveArrayProducers;
        private static List<GarbageProducer> arrayProducers;
        private static final GarbageProducer  byteArrayProducer = new ByteArrayProducer();
        public static enum OOM_TYPE {
            ANY (),
            HEAP("Java heap space"),
            METASPACE("Metaspace", "Compressed class space");

            private final String[] expectedStrings;
            OOM_TYPE(String... expectedStrings) {
                this.expectedStrings = expectedStrings;
            }

            /**
             * Returns true if the given error message matches
             * one of expected strings.
             */
            public boolean accept(String errorMessage) {
                if (expectedStrings == null || expectedStrings.length == 0 || errorMessage == null) {
                    return true;
                }
                for (String s: expectedStrings) {
                    if (errorMessage.indexOf(s) != -1) {
                        return true;
                    }
                }
                return false;
            }
        };

        // Force loading of OOM_TYPE and calling of enum constructors when loading GarbageUtils class.
        public static final Object[] thisIsGarbageArray_theOnlyPurposeForCreatingItAndDeclaringItPublicIsToInitializeIntancesOfOOMEnumberation = new Object[] { OOM_TYPE.ANY, OOM_TYPE.HEAP, OOM_TYPE.METASPACE };

        // Force early loading of classes that might otherwise unexpectedly fail
        // class loading during testing due to high memory pressure.
        public static final StringWriter preloadStringWriter = new StringWriter(1);
        public static final PrintWriter preloadPrintWriter = new PrintWriter(preloadStringWriter);
        public static final Throwable preloadThrowable = new Throwable("preload");

        private GarbageUtils() {
        }

        /**
         * Eat memory using execution controller that waits for 2 minutes.
         * @return number of OOME occured
         */
        public static int eatMemory() {
                return eatMemory(2 * 60 * 1000);
        }

        /**
         * Eat memory using execution controller that waits for timeout.
         * @return number of OOME occured
         */
        public static int eatMemory(final long timeout) {
                return eatMemory(new ExecutionController() {
                        final long initialTime = System.currentTimeMillis();

                                @Override
                                public void start(long stdIterations) {}

                                @Override
                                public boolean iteration() {return false;}

                                @Override
                                public boolean continueExecution() {
                                        return System.currentTimeMillis() - initialTime < timeout;
                                }

                                @Override
                                public long getIteration() {return 0;}

                                @Override
                                public void finish() {}
                });
        }


        /**
         * Eat memory using given execution controller and garbage producer.
         *
         * @param stresser execution controller
         * @param gp garbage producer
         * @return number of OOME occured
         */
        public static int eatMemory(ExecutionController stresser) {
            return eatMemory(stresser, byteArrayProducer, 50, 100, 2, OOM_TYPE.ANY);
        }

        /**
         * Eat memory using given execution controller and garbage producer.
         *
         * @param stresser execution controller
         * @param gp garbage producer
         * @return number of OOME occured
         */
        public static int eatMemory(ExecutionController stresser, GarbageProducer gp) {
            return eatMemory(stresser, gp, 50, 100, 2, OOM_TYPE.ANY);
        }

        /**
         * Eat memory using given garbage producer and given factor.
         *
         * @param gp garbage producer
         * @param factor factor to divide the array size by
         * @return number of OOME occured
         */
        public static int eatMemory(ExecutionController stresser, GarbageProducer gp, long factor) {
            return eatMemory(stresser, gp, 50, 100, factor, OOM_TYPE.ANY);
        }

        /**
         * Eat memory using default(byte[]) garbage producer.
         *
         * Note that this method can throw Failure if any exception
         * is thrown while eating memory. To avoid OOM while allocating
         * exception we preallocate it before the lunch starts. It means
         * that exception stack trace does not correspond to the place
         * where exception is thrown, but points at start of the method.
         *
         * @param stresser stresser
         * @param initialFactor determines which portion of initial memory initial chunk will be
         * @param minMemoryChunk determines when to stop
         * @param factor factor to divide the array size by
         * @return number of OOME occured
         */
        public static int eatMemory(ExecutionController stresser,long initialFactor, long minMemoryChunk, long factor) {
            return eatMemory(stresser, byteArrayProducer, initialFactor, minMemoryChunk, factor, OOM_TYPE.ANY);
        }

        /**
         * Eat memory using given garbage producer.
         *
         * Note that this method can throw Failure if any exception
         * is thrown while eating memory. To avoid OOM while allocating
         * exception we preallocate it before the lunch starts. It means
         * that exception stack trace does not correspond to the place
         * where exception is thrown, but points at start of the method.
         *
         * @param stresser stresser to use
         * @param gp garbage producer
         * @param initialFactor determines which portion of initial memory initial chunk will be
         * @param minMemoryChunk determines when to stop
         * @param factor factor to divide the array size by. A value of 0 means that method returns after first  OOME
         * @param type of OutOfMemory Exception: Java heap space or Metadata space
         * @return number of OOME occured
         */
        public static int eatMemory(ExecutionController stresser, GarbageProducer gp, long initialFactor, long minMemoryChunk, long factor) {
            return eatMemory(stresser, gp, initialFactor, minMemoryChunk, factor, OOM_TYPE.ANY);
        }

         static int numberOfOOMEs = 0;

         /**
          * Minimal wrapper of the main implementation. Catches any OOM
          * that might be thrown when rematerializing Objects when deoptimizing.
          *
          * It is Important that the impl is not inlined.
          */

         public static int eatMemory(ExecutionController stresser, GarbageProducer gp, long initialFactor, long minMemoryChunk, long factor, OOM_TYPE type) {
            try {
               // Using a methodhandle invoke of eatMemoryImpl to prevent inlining of it
               MethodHandles.Lookup lookup = MethodHandles.lookup();
               MethodType mt = MethodType.methodType(
                     int.class,
                     ExecutionController.class,
                     GarbageProducer.class,
                     long.class,
                     long.class,
                     long.class,
                     OOM_TYPE.class);
               MethodHandle eat = lookup.findStatic(GarbageUtils.class, "eatMemoryImpl", mt);
               return (int) eat.invoke(stresser, gp, initialFactor, minMemoryChunk, factor, type);
            } catch (OutOfMemoryError e) {
               return numberOfOOMEs++;
            } catch (Throwable t) {
               throw new RuntimeException(t);
            }
         }

        /**
         * Eat memory using given garbage producer.
         *
         * Note that this method can throw Failure if any exception
         * is thrown while eating memory. To avoid OOM while allocating
         * exception we preallocate it before the lunch starts. It means
         * that exception stack trace does not correspond to the place
         * where exception is thrown, but points at start of the method.
         *
         * @param stresser stresser to use
         * @param gp garbage producer
         * @param initialFactor determines which portion of initial memory initial chunk will be
         * @param minMemoryChunk determines when to stop
         * @param factor factor to divide the array size by. A value of 0 means that method returns after first  OOME
         * @param type of OutOfMemory Exception: Java heap space or Metadata space
         * @return number of OOME occured
         */

         public static int eatMemoryImpl(ExecutionController stresser, GarbageProducer gp, long initialFactor, long minMemoryChunk, long factor, OOM_TYPE type) {
                numberOfOOMEs = 0;
                try {
                        byte[] someMemory = new byte[200000]; //200 Kb
                        try {
                                Runtime runtime = Runtime.getRuntime();
                                long maxMemory = runtime.maxMemory();
                                long maxMemoryChunk = maxMemory / initialFactor;
                                long chunk = maxMemoryChunk;
                                chunk = chunk > ALLOCATION_LIMIT ? ALLOCATION_LIMIT : chunk;
                                int allocations = 0;
                                List<Object> storage = new ArrayList<Object>();

                                while (chunk > minMemoryChunk && stresser.continueExecution()) {
                                        try {
                                                storage.add(gp.create(chunk));
                                                if (Thread.currentThread().isInterrupted()) {
                                                        return numberOfOOMEs;
                                                }
                                                // if we are able to eat chunk*factor let
                                                // try to increase size of chunk
                                                if (chunk * factor < maxMemoryChunk
                                                        && factor != 0 && allocations++ == factor + 1) {
                                                    chunk = chunk * factor;
                                                    allocations = 0;
                                                }
                                        } catch (OutOfMemoryError e) {
                                            someMemory = null;
                                            if (type != OOM_TYPE.ANY) {
                                                if (type.accept(e.toString())) {
                                                    numberOfOOMEs++;
                                                } else {
                                                    // Trying to catch situation when Java generates OOM different type that test trying to catch
                                                    throw new TestBug("Test throw OOM of unexpected type." + e.toString());
                                                }
                                            } else {
                                               numberOfOOMEs++;
                                            }
                                            allocations = 0;
                                            if (factor == 0) {
                                                return numberOfOOMEs;
                                            } else {
                                                chunk = chunk / factor;
                                            }
                                        }
                                }
                        } catch (OutOfMemoryError e) {
                            someMemory = null;
                            if (type != OOM_TYPE.ANY) {
                                if (type.accept(e.toString())) {
                                    numberOfOOMEs++;
                                } else {
                                    // Trying to catch situation when Java generates OOM different type that test trying to catch
                                    throw new TestBug("Test throw OOM of unexpected type." + e.toString());
                                }
                            } else {
                                numberOfOOMEs++;
                            }
                         // all memory is eaten now even before we start, just return
                        }
                } catch (OutOfMemoryError e) {
                        numberOfOOMEs++;
                }
                return numberOfOOMEs;
        }

        /**
         * Get all primitive array producers.
         */
        public static List<GarbageProducer> getPrimitiveArrayProducers() {
                return getGarbageProducers().getPrimitiveArrayProducers();
        }

        /**
         * Get all array producers.
         */
        public static List<GarbageProducer> getArrayProducers() {
                return getGarbageProducers().getArrayProducers();
        }

        /**
         * Determine size of each object in array which will occupy given
         * memory with distribution determined by given memory strategy.
         */
        public static long getArraySize(long memory, MemoryStrategy memoryStrategy) {
                return memoryStrategy.getSize(memory - Memory.getArrayExtraSize(), Memory.getReferenceSize());
        }

        /**
         * Determine object count in array which will occupy given
         * memory with distribution determined by given memory strategy.
         */
        public static int getArrayCount(long memory, MemoryStrategy memoryStrategy) {
                return memoryStrategy.getCount(memory - Memory.getArrayExtraSize(), Memory.getReferenceSize());
        }

        /**
         * Get garbage producer by identifier.
         *
         * @param id identifier
         * @return garbage producer for this identifier
         */
        public static GarbageProducer getGarbageProducer(String id) {
                if (id == null || id.equals("byteArr"))
                        return new ByteArrayProducer();
                else if (id.equals("booleanArr"))
                        return new BooleanArrayProducer();
                else if (id.equals("shortArr"))
                        return new ShortArrayProducer();
                else if (id.equals("charArr"))
                        return new CharArrayProducer();
                else if (id.equals("intArr"))
                        return new IntArrayProducer();
                else if (id.equals("longArr"))
                        return new LongArrayProducer();
                else if (id.equals("floatArr"))
                        return new FloatArrayProducer();
                else if (id.equals("doubleArr"))
                        return new DoubleArrayProducer();
                else if (id.equals("objectArr"))
                        return new ObjectArrayProducer();
                else if (id.equals("randomString"))
                        return new RandomStringProducer();
                else if (id.equals("simpleString"))
                        return new SimpleStringProducer();
                else if (id.startsWith("interned("))
                        return new InternedStringProducer(getGarbageProducer(getInBrackets(id)));
                else if (id.startsWith("linearList("))
                        return new LinearListProducer(MemoryStrategy.fromString(getInBrackets(id)));
                else if (id.startsWith("circularList("))
                        return new CircularListProducer(MemoryStrategy.fromString(getInBrackets(id)));
                else if (id.startsWith("nonbranchyTree("))
                        return new NonbranchyTreeProducer(MemoryStrategy.fromString(getInBrackets(id)));
                else if (id.equals("class"))
                        return new GeneratedClassProducer();
                else if (id.startsWith("hashed("))
                        return new HashedGarbageProducer(getGarbageProducer(getInBrackets(id)));
                else if (id.startsWith("random("))
                        return new RandomProducer(getGarbageProducerList(getInBrackets(id)));
                else if (id.startsWith("twofields("))
                        return new TwoFieldsObjectProducer(getGarbageProducer(getInBrackets(id)));
                else if (id.startsWith("arrayof("))
                        return new ArrayOfProducer(getGarbageProducer(getInBrackets(id)));
                else if (id.startsWith("trace("))
                        return new TraceProducer(getGarbageProducer(getInBrackets(id)));
                else
                        throw new TestBug("Invalid garbage producer identifier: " + id);
        }

        private static String getInBrackets(String s) {
                int n1 = s.indexOf('(');
                if (n1 == -1)
                        throw new TestBug("Opening bracket not found: " + s);
                int n2 = s.lastIndexOf(')');
                if (n2 == -1)
                        throw new TestBug("Closing bracket not found: " + s);
                return s.substring(n1 + 1, n2);
        }

        private static List<GarbageProducer> getGarbageProducerList(String s) {
                if (s.equals("primitiveArrays"))
                        return getPrimitiveArrayProducers();
                else if (s.equals("arrays"))
                        return getArrayProducers();
                else {
                        String[] ids = s.split(",");
                        List<GarbageProducer> garbageProducers = new ArrayList<GarbageProducer>(ids.length);
                        for (int i = 0; i < ids.length; ++i)
                                garbageProducers.add(getGarbageProducer(ids[i]));
                        return garbageProducers;
                        //throw new TestBug("Invalid id for list of garbage producers: " + id);
                }
        }

        public static GarbageProducers getGarbageProducers() {
                if (garbageProducers == null)
                        garbageProducers = new GarbageProducers();
                return garbageProducers;
        }
}