58     private static final WhiteBox WHITE_BOX = WhiteBox.getWhiteBox();
  59 
  60     public static void main(String[] args) {
  61         EnumSet<BlobType> blobTypes = BlobType.getAvailable();
  62         for (BlobType type : blobTypes) {
  63             new OverflowCodeCacheTest(type).test();
  64         }
  65     }
  66 
  67     private final BlobType type;
  68     private final MemoryPoolMXBean bean;
  69     private OverflowCodeCacheTest(BlobType type) {
  70         this.type = type;
  71         this.bean = type.getMemoryPool();
  72     }
  73 
  74     private void test() {
  75         System.out.printf("type %s%n", type);
  76         System.out.println("allocating till possible...");
  77         ArrayList<Long> blobs = new ArrayList<>();

  78         try {
  79             long addr;
  80             int size = (int) (getHeapSize() >> 7);
  81             while ((addr = WHITE_BOX.allocateCodeBlob(size, type.id)) != 0) {
  82                 blobs.add(addr);
  83 
  84                 BlobType actualType = CodeBlob.getCodeBlob(addr).code_blob_type;
  85                 if (actualType != type) {
  86                     // check we got allowed overflow handling
  87                     Asserts.assertTrue(type.allowTypeWhenOverflow(actualType),
  88                             type + " doesn't allow using " + actualType + " when overflow");
  89                 }
  90             }
  91             Asserts.assertNotEquals(WHITE_BOX.getCompilationActivityMode(), 1 /* run_compilation*/,
  92                     "Compilation must be disabled when CodeCache(CodeHeap) overflows");

  93         } finally {
  94             for (Long blob : blobs) {
  95                 WHITE_BOX.freeCodeBlob(blob);
  96             }
  97         }


  98     }
  99 
 100     private long getHeapSize() {
 101         return bean.getUsage().getMax();
 102     }
 103 
 104 }

  58     private static final WhiteBox WHITE_BOX = WhiteBox.getWhiteBox();
  59 
  60     public static void main(String[] args) {
  61         EnumSet<BlobType> blobTypes = BlobType.getAvailable();
  62         for (BlobType type : blobTypes) {
  63             new OverflowCodeCacheTest(type).test();
  64         }
  65     }
  66 
  67     private final BlobType type;
  68     private final MemoryPoolMXBean bean;
  69     private OverflowCodeCacheTest(BlobType type) {
  70         this.type = type;
  71         this.bean = type.getMemoryPool();
  72     }
  73 
  74     private void test() {
  75         System.out.printf("type %s%n", type);
  76         System.out.println("allocating till possible...");
  77         ArrayList<Long> blobs = new ArrayList<>();
  78         int compilationActivityMode = -1;
  79         try {
  80             long addr;
  81             int size = (int) (getHeapSize() >> 7);
  82             while ((addr = WHITE_BOX.allocateCodeBlob(size, type.id)) != 0) {
  83                 blobs.add(addr);
  84 
  85                 BlobType actualType = CodeBlob.getCodeBlob(addr).code_blob_type;
  86                 if (actualType != type) {
  87                     // check we got allowed overflow handling
  88                     Asserts.assertTrue(type.allowTypeWhenOverflow(actualType),
  89                             type + " doesn't allow using " + actualType + " when overflow");
  90                 }
  91             }
  92             /* now, remember compilationActivityMode to check it later, after freeing, since we
  93                possibly have no free cache for futher work */
  94             compilationActivityMode = WHITE_BOX.getCompilationActivityMode();
  95         } finally {
  96             for (Long blob : blobs) {
  97                 WHITE_BOX.freeCodeBlob(blob);
  98             }
  99         }
 100         Asserts.assertNotEquals(compilationActivityMode, 1 /* run_compilation*/,
 101                 "Compilation must be disabled when CodeCache(CodeHeap) overflows");
 102     }
 103 
 104     private long getHeapSize() {
 105         return bean.getUsage().getMax();
 106     }
 107 
 108 }