[210315] garbage collection을 찾아서

/**
  * 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);
}

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.
 */
private static MethodType mt = MethodType.methodType(
  int.class,
  ExecutionController.class,
  GarbageProducer.class,
  long.class,
  long.class,
  long.class,
  OOM_TYPE.class);

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();
    // 자세히보면 static method eatMemoryImpl을 호출한다는 것을 알 수 있다.
    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;
}