Class Blackhole


public final class Blackhole extends BlackholeL4
Black Hole.

Black hole "consumes" the values, conceiving no information to JIT whether the value is actually used afterwards. This can save from the dead-code elimination of the computations resulting in the given values.

  • Field Details

    • COMPILER_BLACKHOLE

      private static final boolean COMPILER_BLACKHOLE
    • consumedCPU

      private static volatile long consumedCPU
  • Constructor Details

    • Blackhole

      public Blackhole(String challengeResponse)
  • Method Details

    • evaporate

      public void evaporate(String challengeResponse)
      Make any consumed data begone. WARNING: This method should only be called by the infrastructure code, in clearly understood cases. Even though it is public, it is not supposed to be called by users.
      Parameters:
      challengeResponse - arbitrary string
    • consume

      public final void consume(Object obj)
      Consume object. This call provides a side effect preventing JIT to eliminate dependent computations.
      Parameters:
      obj - object to consume.
    • consume

      public final void consume(byte b)
      Consume object. This call provides a side effect preventing JIT to eliminate dependent computations.
      Parameters:
      b - object to consume.
    • consume

      public final void consume(boolean bool)
      Consume object. This call provides a side effect preventing JIT to eliminate dependent computations.
      Parameters:
      bool - object to consume.
    • consume

      public final void consume(char c)
      Consume object. This call provides a side effect preventing JIT to eliminate dependent computations.
      Parameters:
      c - object to consume.
    • consume

      public final void consume(short s)
      Consume object. This call provides a side effect preventing JIT to eliminate dependent computations.
      Parameters:
      s - object to consume.
    • consume

      public final void consume(int i)
      Consume object. This call provides a side effect preventing JIT to eliminate dependent computations.
      Parameters:
      i - object to consume.
    • consume

      public final void consume(long l)
      Consume object. This call provides a side effect preventing JIT to eliminate dependent computations.
      Parameters:
      l - object to consume.
    • consume

      public final void consume(float f)
      Consume object. This call provides a side effect preventing JIT to eliminate dependent computations.
      Parameters:
      f - object to consume.
    • consume

      public final void consume(double d)
      Consume object. This call provides a side effect preventing JIT to eliminate dependent computations.
      Parameters:
      d - object to consume.
    • consumeCompiler

      private static void consumeCompiler(boolean v)
    • consumeCompiler

      private static void consumeCompiler(byte v)
    • consumeCompiler

      private static void consumeCompiler(short v)
    • consumeCompiler

      private static void consumeCompiler(char v)
    • consumeCompiler

      private static void consumeCompiler(int v)
    • consumeCompiler

      private static void consumeCompiler(float v)
    • consumeCompiler

      private static void consumeCompiler(double v)
    • consumeCompiler

      private static void consumeCompiler(long v)
    • consumeCompiler

      private static void consumeCompiler(Object v)
    • consumeFull

      private void consumeFull(byte b)
    • consumeFull

      private void consumeFull(boolean bool)
    • consumeFull

      private void consumeFull(char c)
    • consumeFull

      private void consumeFull(short s)
    • consumeFull

      private void consumeFull(int i)
    • consumeFull

      private void consumeFull(long l)
    • consumeFull

      private void consumeFull(float f)
    • consumeFull

      private void consumeFull(double d)
    • consumeFull

      private void consumeFull(Object obj)
    • consumeCPU

      public static void consumeCPU(long tokens)
      Consume some amount of time tokens. This method does the CPU work almost linear to the number of tokens. The token cost may vary from system to system, and may change in future. (Translation: it is as reliable as we can get, but not absolutely reliable). See JMH samples for the complete demo, and core benchmarks for the performance assessments.
      Parameters:
      tokens - CPU tokens to consume