1 /*
2  * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4  *
5  * This code is free software; you can redistribute it and/or modify it
6  * under the terms of the GNU General Public License version 2 only, as
7  * published by the Free Software Foundation.
8  *
9  * This code is distributed in the hope that it will be useful, but WITHOUT
10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
12  * version 2 for more details (a copy is included in the LICENSE file that
13  * accompanied this code).
14  *
15  * You should have received a copy of the GNU General Public License version
16  * 2 along with this work; if not, write to the Free Software Foundation,
17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18  *
19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20  * or visit www.oracle.com if you need additional information or have any
21  * questions.
22  */
23 
24 /**
25  * @test
26  * @bug 6857566
27  * @summary DirectByteBuffer garbage creation can outpace reclamation
28  *
29  * @run main/othervm -XX:MaxDirectMemorySize=128m -XX:-ExplicitGCInvokesConcurrent DirectBufferAllocTest
30  */
31 
32 import java.nio.ByteBuffer;
33 import java.util.List;
34 import java.util.concurrent.*;
35 import java.util.stream.Collectors;
36 import java.util.stream.IntStream;
37 
38 public class DirectBufferAllocTest {
39     // defaults
40     static final int RUN_TIME_SECONDS = 5;
41     static final int MIN_THREADS = 4;
42     static final int MAX_THREADS = 64;
43     static final int CAPACITY = 1024 * 1024; // bytes
44 
45     /**
46      * This test spawns multiple threads that constantly allocate direct
47      * {@link ByteBuffer}s in a loop, trying to provoke {@link OutOfMemoryError}.<p>
48      * When run without command-line arguments, it runs as a regression test
49      * for at most 5 seconds.<p>
50      * Command line arguments:
51      * <pre>
52      * -r run-time-seconds <i>(duration of successful test - default 5 s)</i>
53      * -t threads <i>(default is 2 * # of CPUs, at least 4 but no more than 64)</i>
54      * -c capacity <i>(of direct buffers in bytes - default is 1MB)</i>
55      * -p print-alloc-time-batch-size <i>(every "batch size" iterations,
56      *                                 average time per allocation is printed)</i>
57      * </pre>
58      * Use something like the following to run a 10 minute stress test and
59      * print allocation times as it goes:
60      * <pre>
61      * java -XX:MaxDirectMemorySize=128m DirectBufferAllocTest -r 600 -t 32 -p 5000
62      * </pre>
63      */
main(String[] args)64     public static void main(String[] args) throws Exception {
65         int runTimeSeconds = RUN_TIME_SECONDS;
66         int threads = Math.max(
67             Math.min(
68                 Runtime.getRuntime().availableProcessors() * 2,
69                 MAX_THREADS
70             ),
71             MIN_THREADS
72         );
73         int capacity = CAPACITY;
74         int printBatchSize = 0;
75 
76         // override with command line arguments
77         for (int i = 0; i < args.length; i++) {
78             switch (args[i]) {
79                 case "-r":
80                     runTimeSeconds = Integer.parseInt(args[++i]);
81                     break;
82                 case "-t":
83                     threads = Integer.parseInt(args[++i]);
84                     break;
85                 case "-c":
86                     capacity = Integer.parseInt(args[++i]);
87                     break;
88                 case "-p":
89                     printBatchSize = Integer.parseInt(args[++i]);
90                     break;
91                 default:
92                     System.err.println(
93                         "Usage: java" +
94                         " [-XX:MaxDirectMemorySize=XXXm]" +
95                         " DirectBufferAllocTest" +
96                         " [-r run-time-seconds]" +
97                         " [-t threads]" +
98                         " [-c capacity-of-direct-buffers]" +
99                         " [-p print-alloc-time-batch-size]"
100                     );
101                     System.exit(-1);
102             }
103         }
104 
105         System.out.printf(
106             "Allocating direct ByteBuffers with capacity %d bytes, using %d threads for %d seconds...\n",
107             capacity, threads, runTimeSeconds
108         );
109 
110         ExecutorService executor = Executors.newFixedThreadPool(threads);
111 
112         int pbs = printBatchSize;
113         int cap = capacity;
114 
115         List<Future<Void>> futures =
116             IntStream.range(0, threads)
117                      .mapToObj(
118                          i -> (Callable<Void>) () -> {
119                              long t0 = System.nanoTime();
120                              loop:
121                              while (true) {
122                                  for (int n = 0; pbs == 0 || n < pbs; n++) {
123                                      if (Thread.interrupted()) {
124                                          break loop;
125                                      }
126                                      ByteBuffer.allocateDirect(cap);
127                                  }
128                                  long t1 = System.nanoTime();
129                                  if (pbs > 0) {
130                                      System.out.printf(
131                                          "Thread %2d: %5.2f ms/allocation\n",
132                                          i, ((double) (t1 - t0) / (1_000_000d * pbs))
133                                      );
134                                  }
135                                  t0 = t1;
136                              }
137                              return null;
138                          }
139                      )
140                      .map(executor::submit)
141                      .collect(Collectors.toList());
142 
143         for (int i = 0; i < runTimeSeconds; i++) {
144             if (futures.stream().anyMatch(Future::isDone)) {
145                 break;
146             }
147             Thread.sleep(1000L);
148         }
149 
150         Exception exception = null;
151         for (Future<Void> future : futures) {
152             if (future.isDone()) {
153                 try {
154                     future.get();
155                 } catch (ExecutionException e) {
156                     if (exception == null) {
157                         exception = new RuntimeException("Errors encountered!");
158                     }
159                     exception.addSuppressed(e.getCause());
160                 }
161             } else {
162                 future.cancel(true);
163             }
164         }
165 
166         executor.shutdown();
167 
168         if (exception != null) {
169             throw exception;
170         } else {
171             System.out.printf("No errors after %d seconds.\n", runTimeSeconds);
172         }
173     }
174 }
175