Mercurial > hg > truffle
comparison src/share/vm/runtime/arguments.cpp @ 489:2494ab195856
6653214: MemoryPoolMXBean.setUsageThreshold() does not support large heap sizes.
Reviewed-by: ysr, mchung
author | swamyv |
---|---|
date | Mon, 15 Dec 2008 13:58:57 -0800 |
parents | 0f773163217d |
children | 2328d1d3f8cf 323728917cf4 |
comparison
equal
deleted
inserted
replaced
487:80206b8a9128 | 489:2494ab195856 |
---|---|
442 os::closedir(dir); | 442 os::closedir(dir); |
443 return path; | 443 return path; |
444 } | 444 } |
445 | 445 |
446 // Parses a memory size specification string. | 446 // Parses a memory size specification string. |
447 static bool atomll(const char *s, jlong* result) { | 447 static bool atomull(const char *s, julong* result) { |
448 jlong n = 0; | 448 julong n = 0; |
449 int args_read = sscanf(s, os::jlong_format_specifier(), &n); | 449 int args_read = sscanf(s, os::julong_format_specifier(), &n); |
450 if (args_read != 1) { | 450 if (args_read != 1) { |
451 return false; | 451 return false; |
452 } | 452 } |
453 while (*s != '\0' && isdigit(*s)) { | 453 while (*s != '\0' && isdigit(*s)) { |
454 s++; | 454 s++; |
458 return false; | 458 return false; |
459 } | 459 } |
460 switch (*s) { | 460 switch (*s) { |
461 case 'T': case 't': | 461 case 'T': case 't': |
462 *result = n * G * K; | 462 *result = n * G * K; |
463 // Check for overflow. | |
464 if (*result/((julong)G * K) != n) return false; | |
463 return true; | 465 return true; |
464 case 'G': case 'g': | 466 case 'G': case 'g': |
465 *result = n * G; | 467 *result = n * G; |
468 if (*result/G != n) return false; | |
466 return true; | 469 return true; |
467 case 'M': case 'm': | 470 case 'M': case 'm': |
468 *result = n * M; | 471 *result = n * M; |
472 if (*result/M != n) return false; | |
469 return true; | 473 return true; |
470 case 'K': case 'k': | 474 case 'K': case 'k': |
471 *result = n * K; | 475 *result = n * K; |
476 if (*result/K != n) return false; | |
472 return true; | 477 return true; |
473 case '\0': | 478 case '\0': |
474 *result = n; | 479 *result = n; |
475 return true; | 480 return true; |
476 default: | 481 default: |
477 return false; | 482 return false; |
478 } | 483 } |
479 } | 484 } |
480 | 485 |
481 Arguments::ArgsRange Arguments::check_memory_size(jlong size, jlong min_size) { | 486 Arguments::ArgsRange Arguments::check_memory_size(julong size, julong min_size) { |
482 if (size < min_size) return arg_too_small; | 487 if (size < min_size) return arg_too_small; |
483 // Check that size will fit in a size_t (only relevant on 32-bit) | 488 // Check that size will fit in a size_t (only relevant on 32-bit) |
484 if ((julong) size > max_uintx) return arg_too_big; | 489 if (size > max_uintx) return arg_too_big; |
485 return arg_in_range; | 490 return arg_in_range; |
486 } | 491 } |
487 | 492 |
488 // Describe an argument out of range error | 493 // Describe an argument out of range error |
489 void Arguments::describe_range_error(ArgsRange errcode) { | 494 void Arguments::describe_range_error(ArgsRange errcode) { |
520 return false; | 525 return false; |
521 } | 526 } |
522 | 527 |
523 | 528 |
524 static bool set_numeric_flag(char* name, char* value, FlagValueOrigin origin) { | 529 static bool set_numeric_flag(char* name, char* value, FlagValueOrigin origin) { |
525 jlong v; | 530 julong v; |
526 intx intx_v; | 531 intx intx_v; |
527 bool is_neg = false; | 532 bool is_neg = false; |
528 // Check the sign first since atomll() parses only unsigned values. | 533 // Check the sign first since atomull() parses only unsigned values. |
529 if (*value == '-') { | 534 if (*value == '-') { |
530 if (!CommandLineFlags::intxAt(name, &intx_v)) { | 535 if (!CommandLineFlags::intxAt(name, &intx_v)) { |
531 return false; | 536 return false; |
532 } | 537 } |
533 value++; | 538 value++; |
534 is_neg = true; | 539 is_neg = true; |
535 } | 540 } |
536 if (!atomll(value, &v)) { | 541 if (!atomull(value, &v)) { |
537 return false; | 542 return false; |
538 } | 543 } |
539 intx_v = (intx) v; | 544 intx_v = (intx) v; |
540 if (is_neg) { | 545 if (is_neg) { |
541 intx_v = -intx_v; | 546 intx_v = -intx_v; |
1675 } | 1680 } |
1676 return false; | 1681 return false; |
1677 } | 1682 } |
1678 | 1683 |
1679 Arguments::ArgsRange Arguments::parse_memory_size(const char* s, | 1684 Arguments::ArgsRange Arguments::parse_memory_size(const char* s, |
1680 jlong* long_arg, | 1685 julong* long_arg, |
1681 jlong min_size) { | 1686 julong min_size) { |
1682 if (!atomll(s, long_arg)) return arg_unreadable; | 1687 if (!atomull(s, long_arg)) return arg_unreadable; |
1683 return check_memory_size(*long_arg, min_size); | 1688 return check_memory_size(*long_arg, min_size); |
1684 } | 1689 } |
1685 | 1690 |
1686 // Parse JavaVMInitArgs structure | 1691 // Parse JavaVMInitArgs structure |
1687 | 1692 |
1855 // -Xbatch | 1860 // -Xbatch |
1856 } else if (match_option(option, "-Xbatch", &tail)) { | 1861 } else if (match_option(option, "-Xbatch", &tail)) { |
1857 FLAG_SET_CMDLINE(bool, BackgroundCompilation, false); | 1862 FLAG_SET_CMDLINE(bool, BackgroundCompilation, false); |
1858 // -Xmn for compatibility with other JVM vendors | 1863 // -Xmn for compatibility with other JVM vendors |
1859 } else if (match_option(option, "-Xmn", &tail)) { | 1864 } else if (match_option(option, "-Xmn", &tail)) { |
1860 jlong long_initial_eden_size = 0; | 1865 julong long_initial_eden_size = 0; |
1861 ArgsRange errcode = parse_memory_size(tail, &long_initial_eden_size, 1); | 1866 ArgsRange errcode = parse_memory_size(tail, &long_initial_eden_size, 1); |
1862 if (errcode != arg_in_range) { | 1867 if (errcode != arg_in_range) { |
1863 jio_fprintf(defaultStream::error_stream(), | 1868 jio_fprintf(defaultStream::error_stream(), |
1864 "Invalid initial eden size: %s\n", option->optionString); | 1869 "Invalid initial eden size: %s\n", option->optionString); |
1865 describe_range_error(errcode); | 1870 describe_range_error(errcode); |
1867 } | 1872 } |
1868 FLAG_SET_CMDLINE(uintx, MaxNewSize, (size_t) long_initial_eden_size); | 1873 FLAG_SET_CMDLINE(uintx, MaxNewSize, (size_t) long_initial_eden_size); |
1869 FLAG_SET_CMDLINE(uintx, NewSize, (size_t) long_initial_eden_size); | 1874 FLAG_SET_CMDLINE(uintx, NewSize, (size_t) long_initial_eden_size); |
1870 // -Xms | 1875 // -Xms |
1871 } else if (match_option(option, "-Xms", &tail)) { | 1876 } else if (match_option(option, "-Xms", &tail)) { |
1872 jlong long_initial_heap_size = 0; | 1877 julong long_initial_heap_size = 0; |
1873 ArgsRange errcode = parse_memory_size(tail, &long_initial_heap_size, 1); | 1878 ArgsRange errcode = parse_memory_size(tail, &long_initial_heap_size, 1); |
1874 if (errcode != arg_in_range) { | 1879 if (errcode != arg_in_range) { |
1875 jio_fprintf(defaultStream::error_stream(), | 1880 jio_fprintf(defaultStream::error_stream(), |
1876 "Invalid initial heap size: %s\n", option->optionString); | 1881 "Invalid initial heap size: %s\n", option->optionString); |
1877 describe_range_error(errcode); | 1882 describe_range_error(errcode); |
1880 set_initial_heap_size((size_t) long_initial_heap_size); | 1885 set_initial_heap_size((size_t) long_initial_heap_size); |
1881 // Currently the minimum size and the initial heap sizes are the same. | 1886 // Currently the minimum size and the initial heap sizes are the same. |
1882 set_min_heap_size(initial_heap_size()); | 1887 set_min_heap_size(initial_heap_size()); |
1883 // -Xmx | 1888 // -Xmx |
1884 } else if (match_option(option, "-Xmx", &tail)) { | 1889 } else if (match_option(option, "-Xmx", &tail)) { |
1885 jlong long_max_heap_size = 0; | 1890 julong long_max_heap_size = 0; |
1886 ArgsRange errcode = parse_memory_size(tail, &long_max_heap_size, 1); | 1891 ArgsRange errcode = parse_memory_size(tail, &long_max_heap_size, 1); |
1887 if (errcode != arg_in_range) { | 1892 if (errcode != arg_in_range) { |
1888 jio_fprintf(defaultStream::error_stream(), | 1893 jio_fprintf(defaultStream::error_stream(), |
1889 "Invalid maximum heap size: %s\n", option->optionString); | 1894 "Invalid maximum heap size: %s\n", option->optionString); |
1890 describe_range_error(errcode); | 1895 describe_range_error(errcode); |
1913 } else { | 1918 } else { |
1914 FLAG_SET_CMDLINE(uintx, MinHeapFreeRatio, minf); | 1919 FLAG_SET_CMDLINE(uintx, MinHeapFreeRatio, minf); |
1915 } | 1920 } |
1916 // -Xss | 1921 // -Xss |
1917 } else if (match_option(option, "-Xss", &tail)) { | 1922 } else if (match_option(option, "-Xss", &tail)) { |
1918 jlong long_ThreadStackSize = 0; | 1923 julong long_ThreadStackSize = 0; |
1919 ArgsRange errcode = parse_memory_size(tail, &long_ThreadStackSize, 1000); | 1924 ArgsRange errcode = parse_memory_size(tail, &long_ThreadStackSize, 1000); |
1920 if (errcode != arg_in_range) { | 1925 if (errcode != arg_in_range) { |
1921 jio_fprintf(defaultStream::error_stream(), | 1926 jio_fprintf(defaultStream::error_stream(), |
1922 "Invalid thread stack size: %s\n", option->optionString); | 1927 "Invalid thread stack size: %s\n", option->optionString); |
1923 describe_range_error(errcode); | 1928 describe_range_error(errcode); |
1929 // -Xoss | 1934 // -Xoss |
1930 } else if (match_option(option, "-Xoss", &tail)) { | 1935 } else if (match_option(option, "-Xoss", &tail)) { |
1931 // HotSpot does not have separate native and Java stacks, ignore silently for compatibility | 1936 // HotSpot does not have separate native and Java stacks, ignore silently for compatibility |
1932 // -Xmaxjitcodesize | 1937 // -Xmaxjitcodesize |
1933 } else if (match_option(option, "-Xmaxjitcodesize", &tail)) { | 1938 } else if (match_option(option, "-Xmaxjitcodesize", &tail)) { |
1934 jlong long_ReservedCodeCacheSize = 0; | 1939 julong long_ReservedCodeCacheSize = 0; |
1935 ArgsRange errcode = parse_memory_size(tail, &long_ReservedCodeCacheSize, | 1940 ArgsRange errcode = parse_memory_size(tail, &long_ReservedCodeCacheSize, |
1936 InitialCodeCacheSize); | 1941 (size_t)InitialCodeCacheSize); |
1937 if (errcode != arg_in_range) { | 1942 if (errcode != arg_in_range) { |
1938 jio_fprintf(defaultStream::error_stream(), | 1943 jio_fprintf(defaultStream::error_stream(), |
1939 "Invalid maximum code cache size: %s\n", | 1944 "Invalid maximum code cache size: %s\n", |
1940 option->optionString); | 1945 option->optionString); |
1941 describe_range_error(errcode); | 1946 describe_range_error(errcode); |
2236 } else if (match_option(option, "-XX:-PrintTLE", &tail)) { | 2241 } else if (match_option(option, "-XX:-PrintTLE", &tail)) { |
2237 FLAG_SET_CMDLINE(bool, PrintTLAB, false); | 2242 FLAG_SET_CMDLINE(bool, PrintTLAB, false); |
2238 } else if (match_option(option, "-XX:TLEFragmentationRatio=", &tail)) { | 2243 } else if (match_option(option, "-XX:TLEFragmentationRatio=", &tail)) { |
2239 // No longer used. | 2244 // No longer used. |
2240 } else if (match_option(option, "-XX:TLESize=", &tail)) { | 2245 } else if (match_option(option, "-XX:TLESize=", &tail)) { |
2241 jlong long_tlab_size = 0; | 2246 julong long_tlab_size = 0; |
2242 ArgsRange errcode = parse_memory_size(tail, &long_tlab_size, 1); | 2247 ArgsRange errcode = parse_memory_size(tail, &long_tlab_size, 1); |
2243 if (errcode != arg_in_range) { | 2248 if (errcode != arg_in_range) { |
2244 jio_fprintf(defaultStream::error_stream(), | 2249 jio_fprintf(defaultStream::error_stream(), |
2245 "Invalid TLAB size: %s\n", option->optionString); | 2250 "Invalid TLAB size: %s\n", option->optionString); |
2246 describe_range_error(errcode); | 2251 describe_range_error(errcode); |
2291 jio_fprintf(defaultStream::error_stream(), | 2296 jio_fprintf(defaultStream::error_stream(), |
2292 "Please use -XX:CMSParPromoteBlocksToClaim in place of " | 2297 "Please use -XX:CMSParPromoteBlocksToClaim in place of " |
2293 "-XX:ParCMSPromoteBlocksToClaim in the future\n"); | 2298 "-XX:ParCMSPromoteBlocksToClaim in the future\n"); |
2294 } else | 2299 } else |
2295 if (match_option(option, "-XX:ParallelGCOldGenAllocBufferSize=", &tail)) { | 2300 if (match_option(option, "-XX:ParallelGCOldGenAllocBufferSize=", &tail)) { |
2296 jlong old_plab_size = 0; | 2301 julong old_plab_size = 0; |
2297 ArgsRange errcode = parse_memory_size(tail, &old_plab_size, 1); | 2302 ArgsRange errcode = parse_memory_size(tail, &old_plab_size, 1); |
2298 if (errcode != arg_in_range) { | 2303 if (errcode != arg_in_range) { |
2299 jio_fprintf(defaultStream::error_stream(), | 2304 jio_fprintf(defaultStream::error_stream(), |
2300 "Invalid old PLAB size: %s\n", option->optionString); | 2305 "Invalid old PLAB size: %s\n", option->optionString); |
2301 describe_range_error(errcode); | 2306 describe_range_error(errcode); |
2302 return JNI_EINVAL; | 2307 return JNI_EINVAL; |
2303 } | 2308 } |
2304 FLAG_SET_CMDLINE(uintx, OldPLABSize, (julong)old_plab_size); | 2309 FLAG_SET_CMDLINE(uintx, OldPLABSize, old_plab_size); |
2305 jio_fprintf(defaultStream::error_stream(), | 2310 jio_fprintf(defaultStream::error_stream(), |
2306 "Please use -XX:OldPLABSize in place of " | 2311 "Please use -XX:OldPLABSize in place of " |
2307 "-XX:ParallelGCOldGenAllocBufferSize in the future\n"); | 2312 "-XX:ParallelGCOldGenAllocBufferSize in the future\n"); |
2308 } else | 2313 } else |
2309 if (match_option(option, "-XX:ParallelGCToSpaceAllocBufferSize=", &tail)) { | 2314 if (match_option(option, "-XX:ParallelGCToSpaceAllocBufferSize=", &tail)) { |
2310 jlong young_plab_size = 0; | 2315 julong young_plab_size = 0; |
2311 ArgsRange errcode = parse_memory_size(tail, &young_plab_size, 1); | 2316 ArgsRange errcode = parse_memory_size(tail, &young_plab_size, 1); |
2312 if (errcode != arg_in_range) { | 2317 if (errcode != arg_in_range) { |
2313 jio_fprintf(defaultStream::error_stream(), | 2318 jio_fprintf(defaultStream::error_stream(), |
2314 "Invalid young PLAB size: %s\n", option->optionString); | 2319 "Invalid young PLAB size: %s\n", option->optionString); |
2315 describe_range_error(errcode); | 2320 describe_range_error(errcode); |
2316 return JNI_EINVAL; | 2321 return JNI_EINVAL; |
2317 } | 2322 } |
2318 FLAG_SET_CMDLINE(uintx, YoungPLABSize, (julong)young_plab_size); | 2323 FLAG_SET_CMDLINE(uintx, YoungPLABSize, young_plab_size); |
2319 jio_fprintf(defaultStream::error_stream(), | 2324 jio_fprintf(defaultStream::error_stream(), |
2320 "Please use -XX:YoungPLABSize in place of " | 2325 "Please use -XX:YoungPLABSize in place of " |
2321 "-XX:ParallelGCToSpaceAllocBufferSize in the future\n"); | 2326 "-XX:ParallelGCToSpaceAllocBufferSize in the future\n"); |
2322 } else | 2327 } else |
2323 if (match_option(option, "-XX:", &tail)) { // -XX:xxxx | 2328 if (match_option(option, "-XX:", &tail)) { // -XX:xxxx |