1 /*
2 * Copyright (c) 2016, 2018, 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. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 package jdk.jfr.startupargs;
27
28 import java.util.List;
29 import java.util.ArrayList;
30
31 import jdk.jfr.internal.Options;
32 import jdk.test.lib.process.OutputAnalyzer;
33 import jdk.test.lib.process.ProcessTools;
34 import jdk.internal.misc.Unsafe;
35
36 /*
37 * @test
38 * @key jfr
39 * @library /test/lib
40 * @modules jdk.jfr/jdk.jfr.internal
41 * java.base/jdk.internal.misc
42 * @run main/timeout=900 jdk.jfr.startupargs.TestMemoryOptions
43 */
44 public class TestMemoryOptions {
45
46 public enum Unit {
47 b('b'), k('k'), m('m'), g('g');
48
49 private char unit;
50
51 Unit(char unit) {
52 this.unit = unit;
53 }
54
55 char getUnit() {
56 return unit;
57 }
58 };
59
60 static class Option implements Comparable<Option> {
61 static final long MIN_GLOBAL_BUFFER_COUNT = 2;
62 static final long DEFAULT_GLOBAL_BUFFER_COUNT = 20;
63 static final long MIN_GLOBAL_BUFFER_SIZE = 64 * 1024;
64 static long DEFAULT_GLOBAL_BUFFER_SIZE = 524288;
65 static final long MIN_MEMORY_SIZE = 1024 * 1024;
66 static final long DEFAULT_MEMORY_SIZE = DEFAULT_GLOBAL_BUFFER_COUNT * DEFAULT_GLOBAL_BUFFER_SIZE;
67 static final long MIN_THREAD_BUFFER_SIZE = 4 * 1024;
68 static long DEFAULT_THREAD_BUFFER_SIZE;
69 static final long PAGE_SIZE;
70 static final long UNDEFINED = -1;
71
72 static {
73 PAGE_SIZE = Unsafe.getUnsafe().pageSize();
74 if (PAGE_SIZE == MIN_THREAD_BUFFER_SIZE) {
75 DEFAULT_THREAD_BUFFER_SIZE = PAGE_SIZE * 2;
76 } else {
77 DEFAULT_THREAD_BUFFER_SIZE = PAGE_SIZE;
78 }
79 if (PAGE_SIZE > DEFAULT_GLOBAL_BUFFER_SIZE) {
80 DEFAULT_GLOBAL_BUFFER_SIZE = PAGE_SIZE;
81 }
82 }
83
84 final private long min;
85 final private long max;
86 final private String paramName;
87
88 private long input;
89 private Unit inputUnit;
90 private long result;
91 private Unit resultUnit;
92
93 private long getValueAsUnit(long value, Unit unit) {
94 switch (unit) {
95 case b:
96 return value;
97 case k:
98 return value / 1024;
99 case m:
100 return value / (1024 * 1024);
101 case g:
102 return value / (1024 * 1024 * 1024);
103 }
104 return value;
105 }
106
107 private long getRawValue(long value, Unit unit) {
108 switch (unit) {
109 case b:
110 return value;
111 case k:
112 return value * 1024;
113 case m:
114 return value * (1024 * 1024);
115 case g:
116 return value * (1024 * 1024 * 1024);
117 }
118 return value;
119 }
120
121 private long parseValue(String valueString, char unit) {
122 if (Character.isLetter(unit)) {
123 unit = Character.toLowerCase(unit);
124 return getRawValue(Long.parseLong(valueString.substring(0, valueString.length() - 1), 10),
125 Unit.valueOf(String.valueOf(unit)));
126 }
127 // does not have a unit, default is bytes
128 return Long.parseLong(valueString.substring(0, valueString.length()), 10);
129 }
130
131 public Option(String minString, String maxString, String paramName) {
132 if (minString == null) {
133 this.min = UNDEFINED;
134 } else {
135 char unit = minString.charAt(minString.length() - 1);
136 this.min = parseValue(minString, unit);
137 }
138 if (maxString == null) {
139 this.max = UNDEFINED;
140 } else {
141 char unit = maxString.charAt(maxString.length() - 1);
142 this.max = parseValue(maxString, unit);
143 }
144 this.input = UNDEFINED;
145 this.result = UNDEFINED;
146 this.paramName = paramName;
147 }
148
149 private Option(long value, char unit) {
150 this.resultUnit = Unit.valueOf(String.valueOf(unit));
151 this.result = getRawValue(value, this.resultUnit);
152 this.min = UNDEFINED;
153 this.max = UNDEFINED;
154 this.paramName = "";
155 }
156
157 public void setInput(long value, char unit) {
158 this.inputUnit = Unit.valueOf(String.valueOf(unit));
159 this.input = getRawValue(value, this.inputUnit);
160 }
161
162 public long getInput() {
163 return input;
164 }
165
166 public void setResult(long value, char unit) {
167 this.resultUnit = Unit.valueOf(String.valueOf(unit));
168 this.result = getRawValue(value, this.resultUnit);
169 }
170
171 public long getResult() {
172 return result;
173 }
174
175 public long getResultAs(Unit unit) {
176 return getValueAsUnit(this.result, unit);
177 }
178
179 public String getOptionParamName() {
180 return paramName;
181 }
182
183 public String getOptionParamString() {
184 if (input == UNDEFINED) {
185 return null;
186 }
187 char unit = inputUnit.getUnit();
188 String unitString = Character.compare(unit, 'b') == 0 ? "" : String.valueOf(unit);
189 return getOptionParamName() + "=" + Long.toString(getValueAsUnit(input, inputUnit)) + unitString;
190 }
191
192 public boolean predictedToStartVM() {
193 if (input == UNDEFINED) {
194 // option not set
195 return true;
196 }
197 if (input >= 0) {
198 if (min != UNDEFINED) {
199 if (max != UNDEFINED) {
200 return input >= min && input <= max;
201 }
202 return input >= min;
203 }
204 if (max != UNDEFINED) {
205 if (min != UNDEFINED) {
206 return input <= max && input >= min;
207 }
208 }
209 return true;
210 }
211 return false;
212 }
213
214 public boolean isSet() {
215 return input != UNDEFINED;
216 }
217
218 public boolean validate() throws IllegalArgumentException {
219 // a result memory options should be page aligned
220 if (getResult() > PAGE_SIZE) {
221 if (getResult() % PAGE_SIZE != 0) {
222 throw new IllegalArgumentException("Result value: "
223 + getResult() + " for option " + getOptionParamName() + " is not aligned to page size " + PAGE_SIZE);
224 }
225 }
226 // if min is defined, the result value should be gteq
227 if (min != UNDEFINED) {
228 if (getResult() < min) {
229 throw new IllegalArgumentException("Result value: "
230 + getResult() + " for option " + getOptionParamName() + " is less than min: " + min);
231 }
232 }
233 // if max is defined, the result values should be lteq
234 if (max != UNDEFINED) {
235 if (getResult() > max) {
236 throw new IllegalArgumentException("Result value: "
237 + getResult() + " for option " + getOptionParamName() + " is greater than max: " + max);
238 }
239 }
240 return true;
241 }
242
243 @Override
244 public int compareTo(Option obj) {
245 if (getResult() == obj.getResult()) {
246 return 0;
247 }
248 return getResult() > obj.getResult() ? 1 : -1;
249 }
250
251 @Override
252 public boolean equals(Object obj) {
253 if (obj == null) {
254 return false;
255 }
256 if (!Option.class.isAssignableFrom(obj.getClass())) {
257 return false;
258 }
259 final Option other = (Option) obj;
260
261 return getResult() == other.getResult();
262 }
263
264 @Override
265 public int hashCode() {
266 long hash = 3;
267 hash = 53 * hash * getResult();
268 return (int)hash;
269 }
270
271 @Override
272 public String toString() {
273 return Long.toString(getResult());
274 }
275
276 public Option multiply(Option rhsFactor) {
277 return new Option(getResult() * rhsFactor.getResult(), 'b');
278 }
279
280 public Option divide(Option rhsDivisor) {
281 long divisor = rhsDivisor.getResult();
282 if (divisor == 0) {
283 return new Option(0, 'b');
284 }
285 return new Option(getResult() / divisor, 'b');
286 }
287
288 boolean isLessThanOrEqual(Option rhs) {
289 return getResult() <= rhs.getResult();
290 }
291
292 boolean isGreaterThanOrEqual(Option rhs) {
293 return getResult() >= rhs.getResult();
294 }
295 }
296
297 private static class TestCase {
298 private static final int MEMORYSIZE = 0;
299 private static final int GLOBALBUFFERSIZE = 1;
300 private static final int GLOBALBUFFERCOUNT = 2;
301 private static final int THREADBUFFERSIZE = 3;
302
303 final private List<Option> optionList = new ArrayList<Option>();
304 final private String testName;
305
306 public TestCase(String testName, boolean runTest) {
307 this.testName = testName;
308 Option memorySize = new Option(Long.toString(Option.MIN_MEMORY_SIZE), null, "memorysize");
309 optionList.add(memorySize);
310
311 Option globalBufferSize = new Option(Long.toString(Option.MIN_GLOBAL_BUFFER_SIZE),
312 null, "globalbuffersize");
313 optionList.add(globalBufferSize);
314
315 Option globalBufferCount = new Option(Long.toString(Option.MIN_GLOBAL_BUFFER_COUNT), null, "numglobalbuffers");
316 optionList.add(globalBufferCount);
317
318 Option threadBufferSize = new Option(Long.toString(Option.MIN_THREAD_BUFFER_SIZE), null, "threadbuffersize");
319 optionList.add(threadBufferSize);
320
321 if (runTest) {
322 populateResults();
323 validateNodes();
324 validateEdges();
325 }
326 }
327
328 public String getTestString() {
329 String optionString = "-XX:FlightRecorderOptions=";
330 for (Option o : optionList) {
331 String optionParamString = o.getOptionParamString();
332 if (optionParamString == null) {
333 continue;
334 }
335 optionString = optionString.concat(optionParamString);
336 optionString = optionString.concat(",");
337 }
338 if (optionString.equals("-XX:FlightRecorderOptions=")) {
339 return null;
340 }
341 // strip last ","
342 optionString = optionString.substring(0, optionString.length() - 1);
343 return optionString;
344 }
345
346 public String getTestName() {
347 return this.testName;
348 }
349
350 private void setInputForIndex(int index, long size, char unit) {
351 optionList.get(index).setInput(size, unit);
352 }
353
354 private void setResultForIndex(int index, long size, char unit) {
355 optionList.get(index).setResult(size, unit);
356 }
357
358 public void setMemorySizeTestParam(long size, char unit) {
359 setInputForIndex(MEMORYSIZE, size, unit);
360 }
361
362 public void setMemorySizeTestResult(long size, char unit) {
363 setResultForIndex(MEMORYSIZE, size, unit);
364 }
365
366 public void setGlobalBufferSizeTestParam(long size, char unit) {
367 setInputForIndex(GLOBALBUFFERSIZE, size, unit);
368 }
369
370 public void setGlobalBufferSizeTestResult(long size, char unit) {
371 setResultForIndex(GLOBALBUFFERSIZE, size, unit);
372 }
373
374 public void setGlobalBufferCountTestParam(long size, char unit) {
375 setInputForIndex(GLOBALBUFFERCOUNT, size, unit);
376 }
377
378 public void setGlobalBufferCountTestResult(long size, char unit) {
379 setResultForIndex(GLOBALBUFFERCOUNT, size, unit);
380 }
381
382 public void setThreadBufferSizeTestParam(long size, char unit) {
383 setInputForIndex(THREADBUFFERSIZE, size, unit);
384 }
385
386 public void setThreadBufferSizeTestResult(long size, char unit) {
387 setResultForIndex(THREADBUFFERSIZE, size, unit);
388 }
389
390 public void validateNodes() {
391 for (Option o : optionList) {
392 o.validate();
393 }
394 }
395
396 public void validateEdges() {
397 final Option memorySize = optionList.get(MEMORYSIZE);
398 final Option globalBufferSize = optionList.get(GLOBALBUFFERSIZE);
399 final Option globalBufferCount = optionList.get(GLOBALBUFFERCOUNT);
400 final Option threadBufferSize = optionList.get(THREADBUFFERSIZE);
401
402 if (!memorySize.divide(globalBufferCount).equals(globalBufferSize)) {
403 throw new IllegalArgumentException(getTestName() + " failure: " + memorySize.getOptionParamName() + " (" + memorySize.getResult() + ") / " +
404 globalBufferCount.getOptionParamName() + " (" + globalBufferCount.getResult() +
405 ") (" + memorySize.divide(globalBufferCount).getResult() + ") != " +
406 globalBufferSize.getOptionParamName() + " (" + globalBufferSize.getResult() + ")");
407 }
408
409 if (!globalBufferSize.multiply(globalBufferCount).equals(memorySize)) {
410 throw new IllegalArgumentException(getTestName() + " failure: " + globalBufferSize.getOptionParamName() + ": " +
411 globalBufferSize.getResult() +
412 " * " + globalBufferCount.getOptionParamName() + ": " + globalBufferCount.getResult() +
413 " != " + memorySize.getOptionParamName() + ": " + memorySize.getResult());
414 }
415
416 if (!threadBufferSize.isLessThanOrEqual(globalBufferSize)) {
417 throw new IllegalArgumentException(getTestName() + " failure: " + threadBufferSize.getOptionParamName() + ": " + threadBufferSize.getResult() +
418 " is larger than " + globalBufferSize.getOptionParamName() + ": " + globalBufferSize.getResult());
419 }
420 }
421
422 public void print() {
423 System.out.println("Printing information for testcase : " + getTestName());
424 for (Option o : optionList) {
425 System.out.println("Parameter name: " + o.getOptionParamName());
426 System.out.println("Parameter test value : " + o.getOptionParamString() != null ? o.getOptionParamString() : "not enabled for input testing");
427 String inputString = o.getInput() == Option.UNDEFINED ? "N/A" : Long.toString(o.getInput());
428 System.out.println("Input value: " + inputString);
429 System.out.println("Predicted to start VM: " + (o.predictedToStartVM() ? "true" : "false"));
430 }
431 }
432
433 private void populateResults() {
434 optionList.get(MEMORYSIZE).setResult(Options.getMemorySize(), 'b');
435 optionList.get(GLOBALBUFFERSIZE).setResult(Options.getGlobalBufferSize(), 'b');
436 optionList.get(GLOBALBUFFERCOUNT).setResult(Options.getGlobalBufferCount(), 'b');
437 optionList.get(THREADBUFFERSIZE).setResult(Options.getThreadBufferSize(), 'b');
438 }
439
440 public boolean predictedToStartVM() {
441 // check each individual option
442 for (Option o : optionList) {
443 if (!o.predictedToStartVM()) {
444 return false;
445 }
446 }
447
448 // check known invalid combinations that will not allow the VM to start
449
450 // GLOBALBUFFERSIZE * GLOBALBUFFERCOUNT == MEMORYSIZE
451 if (optionList.get(GLOBALBUFFERSIZE).isSet() && optionList.get(GLOBALBUFFERCOUNT).isSet()
452 && optionList.get(MEMORYSIZE).isSet()) {
453 long calculatedMemorySize = optionList.get(GLOBALBUFFERSIZE).getInput() * optionList.get(GLOBALBUFFERCOUNT).getInput();
454 if (optionList.get(MEMORYSIZE).getInput() != calculatedMemorySize) {
455 return false;
456 }
457 }
458 // GLOBALBUFFERSIZE * GLOBALBUFFERCOUNT >= MIN_MEMORY_SIZE
459 if (optionList.get(GLOBALBUFFERSIZE).isSet() && optionList.get(GLOBALBUFFERCOUNT).isSet()
460 && !optionList.get(MEMORYSIZE).isSet()) {
461 long calculatedMemorySize = optionList.get(GLOBALBUFFERSIZE).getInput() * optionList.get(GLOBALBUFFERCOUNT).getInput();
462 if (Option.MIN_MEMORY_SIZE > calculatedMemorySize) {
463 return false;
464 }
465 }
466 // GLOBALBUFFERSIZE >= THREADBUFFERSIZE
467 if (optionList.get(GLOBALBUFFERSIZE).isSet() && optionList.get(THREADBUFFERSIZE).isSet()) {
468 if (optionList.get(GLOBALBUFFERSIZE).getInput() < optionList.get(THREADBUFFERSIZE).getInput()) {
469 return false;
470 }
471 }
472 return true;
473 }
474 }
475
476 public static class SUT {
477 public static void main(String[] args) {
478 TestCase tc = new TestCase(args[0], true);
479 }
480 }
481
482 private static class Driver {
483 private static void launchTestVM(TestCase tc) throws Exception {
484 final String flightRecorderOptions = tc.getTestString();
485 ProcessBuilder pb;
486 if (flightRecorderOptions != null) {
487 pb = ProcessTools.createJavaProcessBuilder(true,
488 "--add-exports=jdk.jfr/jdk.jfr.internal=ALL-UNNAMED",
489 "--add-exports=java.base/jdk.internal.misc=ALL-UNNAMED",
490 flightRecorderOptions,
491 "-XX:StartFlightRecording",
492 SUT.class.getName(),
493 tc.getTestName());
494 } else {
495 // default, no FlightRecorderOptions passed
496 pb = ProcessTools.createJavaProcessBuilder(true,
497 "--add-exports=jdk.jfr/jdk.jfr.internal=ALL-UNNAMED",
498 "--add-exports=java.base/jdk.internal.misc=ALL-UNNAMED",
499 "-XX:StartFlightRecording",
500 SUT.class.getName(),
501 tc.getTestName());
502 }
503
504 System.out.println("Driver launching SUT with string: " + flightRecorderOptions != null ? flightRecorderOptions : "default");
505 System.out.println("SUT VM " + (tc.predictedToStartVM() ? "is" : "is not") + " expected to start");
506 tc.print();
507
508 OutputAnalyzer out = ProcessTools.executeProcess(pb);
509
510 if (tc.predictedToStartVM()) {
511 out.shouldHaveExitValue(0);
512 } else {
513 out.shouldContain("Failed to start tracing backend.");
514 out.shouldHaveExitValue(1);
515 }
516 }
517
518 public static void runTestCase(TestCase tc) throws Exception {
519 launchTestVM(tc);
520 }
521 }
522
523 static private List<TestCase> testCases = new ArrayList<TestCase>();
524
525 static {
526 // positive example-based tests
527 TestCase tc = new TestCase("DefaultOptionsPositive", false);
528 // defaults, no options explicitly set
529 testCases.add(tc);
530
531 // explicit defaults passed as parameters
532 tc = new TestCase("MemorySizePositive", false);
533 tc.setMemorySizeTestParam(10, 'm');
534 testCases.add(tc);
535
536 tc = new TestCase("GlobalBufferSizePositive", false);
537 tc.setGlobalBufferSizeTestParam(512, 'k');
538 testCases.add(tc);
539
540 tc = new TestCase("BufferCountPositive", false);
541 tc.setGlobalBufferCountTestParam(20, 'b');
542 testCases.add(tc);
543
544 tc = new TestCase("ThreadBufferSizePositive", false);
545 tc.setThreadBufferSizeTestParam(Option.DEFAULT_THREAD_BUFFER_SIZE, 'b');
546 testCases.add(tc);
547
548 // negative example-based tests, each individual option below minimum size
549 tc = new TestCase("MemorySizeBelowMinNegative", false);
550 tc.setMemorySizeTestParam(Option.MIN_MEMORY_SIZE - 1, 'b');
551 testCases.add(tc);
552
553 tc = new TestCase("GlobalBufferSizeBelowMinNegative", false);
554 tc.setGlobalBufferSizeTestParam(Option.MIN_GLOBAL_BUFFER_SIZE - 1, 'b');
555 testCases.add(tc);
556
557 tc = new TestCase("BufferCountBelowMinNegative", false);
558 tc.setGlobalBufferCountTestParam(Option.MIN_GLOBAL_BUFFER_COUNT - 1, 'b');
559 testCases.add(tc);
560
561 tc = new TestCase("ThreadBufferSizeBelowMinNegative", false);
562 tc.setThreadBufferSizeTestParam(Option.MIN_THREAD_BUFFER_SIZE - 1, 'b');
563 testCases.add(tc);
564
565 // Memory size permutations
566 // a few single memorysize option for deduction
567 tc = new TestCase("MemorySizeValue1Positive", false);
568 tc.setMemorySizeTestParam(48128, 'k'); // 47mb
569 testCases.add(tc);
570
571 tc = new TestCase("MemorySizeValue2Positive", false);
572 tc.setMemorySizeTestParam(17391, 'k'); // 17808384 bytes
573 testCases.add(tc);
574
575 tc = new TestCase("MemorySizeValue3Positive", false);
576 tc.setMemorySizeTestParam(Option.MIN_MEMORY_SIZE + 17, 'b');
577 testCases.add(tc);
578
579 // positive example-based-tests, memory size combined with other options
580 tc = new TestCase("MemorySizeGlobalBufferSizePositive", false);
581 tc.setMemorySizeTestParam(14680064, 'b'); // 14mb
582 tc.setGlobalBufferSizeTestParam(720, 'k');
583 testCases.add(tc);
584
585 tc = new TestCase("MemorySizeGlobalBufferCountPositive", false);
586 tc.setMemorySizeTestParam(14674581, 'b'); // 14mb - 5483 bytes
587 tc.setGlobalBufferCountTestParam(17, 'b');
588 testCases.add(tc);
589
590 tc = new TestCase("MemorySizeThreadBufferSizePositive", false);
591 tc.setMemorySizeTestParam(14586853, 'b'); // 14mb - 93211 bytes
592 tc.setThreadBufferSizeTestParam(Option.DEFAULT_THREAD_BUFFER_SIZE, 'b');
593 testCases.add(tc);
594
595 tc = new TestCase("MemorySizeGlobalBufferSizeBufferCountPositive", false);
596 tc.setMemorySizeTestParam(12240, 'k');
597 tc.setGlobalBufferSizeTestParam(720, 'k'); // 720 k * 17 == 12240 k
598 tc.setGlobalBufferCountTestParam(17, 'b');
599 testCases.add(tc);
600
601 tc = new TestCase("MemorySizeGlobalBufferSizeBufferCountThreadBufferSizePositive", false);
602 tc.setMemorySizeTestParam(12240, 'k');
603 tc.setGlobalBufferSizeTestParam(720, 'k'); // 720 k * 17 == 12240 k
604 tc.setGlobalBufferCountTestParam(17, 'b');
605 tc.setThreadBufferSizeTestParam(600, 'k');
606 testCases.add(tc);
607
608 // negative example-based test, create an ambiguous situtation
609 tc = new TestCase("MemorySizeGlobalBufferSizeBufferCountAmbiguousNegative", false);
610 tc.setMemorySizeTestParam(12240, 'k');
611 tc.setGlobalBufferSizeTestParam(720, 'k'); // 720 k * 19 != 12240 k
612 tc.setGlobalBufferCountTestParam(19, 'b');
613 testCases.add(tc);
614
615 // Global buffer size permutations
616 tc = new TestCase("GlobalBufferSizeBufferCountPositive", false);
617 tc.setGlobalBufferSizeTestParam(917, 'k');
618 tc.setGlobalBufferCountTestParam(31, 'b');
619 testCases.add(tc);
620
621 tc = new TestCase("GlobalBufferSizeBufferCountThreadBufferSizePositive", false);
622 tc.setGlobalBufferSizeTestParam(917, 'k');
623 tc.setGlobalBufferCountTestParam(31, 'b');
624 tc.setThreadBufferSizeTestParam(760832, 'b'); // 743 k
625 testCases.add(tc);
626
627 // negative example-based test, let thread buffer size > global buffer size
628 tc = new TestCase("GlobalBufferSizeLessThanThreadBufferSizeNegative", false);
629 tc.setGlobalBufferSizeTestParam(917, 'k');
630 tc.setThreadBufferSizeTestParam(1317, 'k');
631 testCases.add(tc);
632
633 // explicitly specifying global buffer size and global buffer count must be gteq min memorysize
634 tc = new TestCase("GlobalBufferSizeTimesGlobalBufferCountLessThanMinMemorySizeNegative", false);
635 tc.setGlobalBufferSizeTestParam(67857, 'b');
636 tc.setGlobalBufferCountTestParam(3, 'b');
637 testCases.add(tc);
638
639 // absolute minimum size
640 tc = new TestCase("GlobalBufferSizeTimesGlobalBufferCountEqualToMinMemorySizePositive", false);
641 tc.setGlobalBufferSizeTestParam(64, 'k');
642 tc.setGlobalBufferCountTestParam(16, 'b');
643 testCases.add(tc);
644 }
645
646 public static void main(String[] args) throws Exception {
647 System.out.println("Testing " + testCases.size() + " number of testcases");
648 for (TestCase tc : testCases) {
649 Driver.runTestCase(tc);
650 }
651 }
652 }