1365 // Too early to use gclog_or_tty
1366 tty->print_cr("CMS ergo set OldSize: " SIZE_FORMAT, OldSize);
1367 }
1368 }
1369 }
1370 }
1371 }
1372 // Unless explicitly requested otherwise, definitely
1373 // promote all objects surviving "tenuring_default" scavenges.
1374 if (FLAG_IS_DEFAULT(MaxTenuringThreshold) &&
1375 FLAG_IS_DEFAULT(SurvivorRatio)) {
1376 FLAG_SET_ERGO(uintx, MaxTenuringThreshold, tenuring_default);
1377 }
1378 // If we decided above (or user explicitly requested)
1379 // `promote all' (via MaxTenuringThreshold := 0),
1380 // prefer minuscule survivor spaces so as not to waste
1381 // space for (non-existent) survivors
1382 if (FLAG_IS_DEFAULT(SurvivorRatio) && MaxTenuringThreshold == 0) {
1383 FLAG_SET_ERGO(uintx, SurvivorRatio, MAX2((uintx)1024, SurvivorRatio));
1384 }
1385 // If OldPLABSize is set and CMSParPromoteBlocksToClaim is not,
1386 // set CMSParPromoteBlocksToClaim equal to OldPLABSize.
1387 // This is done in order to make ParNew+CMS configuration to work
1388 // with YoungPLABSize and OldPLABSize options.
1389 // See CR 6362902.
1390 if (!FLAG_IS_DEFAULT(OldPLABSize)) {
1391 if (FLAG_IS_DEFAULT(CMSParPromoteBlocksToClaim)) {
1392 // OldPLABSize is not the default value but CMSParPromoteBlocksToClaim
1393 // is. In this situation let CMSParPromoteBlocksToClaim follow
1394 // the value (either from the command line or ergonomics) of
1395 // OldPLABSize. Following OldPLABSize is an ergonomics decision.
1396 FLAG_SET_ERGO(uintx, CMSParPromoteBlocksToClaim, OldPLABSize);
1397 } else {
1398 // OldPLABSize and CMSParPromoteBlocksToClaim are both set.
1399 // CMSParPromoteBlocksToClaim is a collector-specific flag, so
1400 // we'll let it to take precedence.
1401 jio_fprintf(defaultStream::error_stream(),
1402 "Both OldPLABSize and CMSParPromoteBlocksToClaim"
1403 " options are specified for the CMS collector."
1404 " CMSParPromoteBlocksToClaim will take precedence.\n");
1405 }
1406 }
1407 if (!FLAG_IS_DEFAULT(ResizeOldPLAB) && !ResizeOldPLAB) {
1408 // OldPLAB sizing manually turned off: Use a larger default setting,
1409 // unless it was manually specified. This is because a too-low value
1410 // will slow down scavenges.
1411 if (FLAG_IS_DEFAULT(CMSParPromoteBlocksToClaim)) {
1412 FLAG_SET_ERGO(uintx, CMSParPromoteBlocksToClaim, 50); // default value before 6631166
1413 }
1414 }
1415 // Overwrite OldPLABSize which is the variable we will internally use everywhere.
1416 FLAG_SET_ERGO(uintx, OldPLABSize, CMSParPromoteBlocksToClaim);
1417 // If either of the static initialization defaults have changed, note this
1418 // modification.
1419 if (!FLAG_IS_DEFAULT(CMSParPromoteBlocksToClaim) || !FLAG_IS_DEFAULT(OldPLABWeight)) {
1420 CFLS_LAB::modify_initialization(OldPLABSize, OldPLABWeight);
1421 }
1422 if (PrintGCDetails && Verbose) {
1423 tty->print_cr("MarkStackSize: %uk MarkStackSizeMax: %uk",
1424 (unsigned int) (MarkStackSize / K), (uint) (MarkStackSizeMax / K));
1425 tty->print_cr("ConcGCThreads: %u", (uint) ConcGCThreads);
1426 }
1427 }
1428 #endif // INCLUDE_ALL_GCS
1429
1430 void set_object_alignment() {
1431 // Object alignment.
1432 assert(is_power_of_2(ObjectAlignmentInBytes), "ObjectAlignmentInBytes must be power of 2");
1433 MinObjAlignmentInBytes = ObjectAlignmentInBytes;
1434 assert(MinObjAlignmentInBytes >= HeapWordsPerLong * HeapWordSize, "ObjectAlignmentInBytes value is too small");
1435 MinObjAlignment = MinObjAlignmentInBytes / HeapWordSize;
1436 assert(MinObjAlignmentInBytes == MinObjAlignment * HeapWordSize, "ObjectAlignmentInBytes value is incorrect");
1437 MinObjAlignmentInBytesMask = MinObjAlignmentInBytes - 1;
1438
1439 LogMinObjAlignmentInBytes = exact_log2(ObjectAlignmentInBytes);
3205 FLAG_SET_CMDLINE(uintx, MaxTenuringThreshold, markOopDesc::max_age + 1);
3206 } else if (match_option(option, "-XX:+AlwaysTenure")) {
3207 FLAG_SET_CMDLINE(bool, NeverTenure, false);
3208 FLAG_SET_CMDLINE(bool, AlwaysTenure, true);
3209 FLAG_SET_CMDLINE(uintx, MaxTenuringThreshold, 0);
3210 } else if (match_option(option, "-XX:MaxTenuringThreshold=", &tail)) {
3211 uintx max_tenuring_thresh = 0;
3212 if(!parse_uintx(tail, &max_tenuring_thresh, 0)) {
3213 jio_fprintf(defaultStream::error_stream(),
3214 "Invalid MaxTenuringThreshold: %s\n", option->optionString);
3215 }
3216 FLAG_SET_CMDLINE(uintx, MaxTenuringThreshold, max_tenuring_thresh);
3217
3218 if (MaxTenuringThreshold == 0) {
3219 FLAG_SET_CMDLINE(bool, NeverTenure, false);
3220 FLAG_SET_CMDLINE(bool, AlwaysTenure, true);
3221 } else {
3222 FLAG_SET_CMDLINE(bool, NeverTenure, false);
3223 FLAG_SET_CMDLINE(bool, AlwaysTenure, false);
3224 }
3225 } else if (match_option(option, "-XX:+CMSPermGenSweepingEnabled") ||
3226 match_option(option, "-XX:-CMSPermGenSweepingEnabled")) {
3227 jio_fprintf(defaultStream::error_stream(),
3228 "Please use CMSClassUnloadingEnabled in place of "
3229 "CMSPermGenSweepingEnabled in the future\n");
3230 } else if (match_option(option, "-XX:+UseGCTimeLimit")) {
3231 FLAG_SET_CMDLINE(bool, UseGCOverheadLimit, true);
3232 jio_fprintf(defaultStream::error_stream(),
3233 "Please use -XX:+UseGCOverheadLimit in place of "
3234 "-XX:+UseGCTimeLimit in the future\n");
3235 } else if (match_option(option, "-XX:-UseGCTimeLimit")) {
3236 FLAG_SET_CMDLINE(bool, UseGCOverheadLimit, false);
3237 jio_fprintf(defaultStream::error_stream(),
3238 "Please use -XX:-UseGCOverheadLimit in place of "
3239 "-XX:-UseGCTimeLimit in the future\n");
3240 // The TLE options are for compatibility with 1.3 and will be
3241 // removed without notice in a future release. These options
3242 // are not to be documented.
3243 } else if (match_option(option, "-XX:MaxTLERatio=", &tail)) {
3244 // No longer used.
3245 } else if (match_option(option, "-XX:+ResizeTLE")) {
3246 FLAG_SET_CMDLINE(bool, ResizeTLAB, true);
3247 } else if (match_option(option, "-XX:-ResizeTLE")) {
3248 FLAG_SET_CMDLINE(bool, ResizeTLAB, false);
3249 } else if (match_option(option, "-XX:+PrintTLE")) {
3250 FLAG_SET_CMDLINE(bool, PrintTLAB, true);
3251 } else if (match_option(option, "-XX:-PrintTLE")) {
3252 FLAG_SET_CMDLINE(bool, PrintTLAB, false);
3253 } else if (match_option(option, "-XX:TLEFragmentationRatio=", &tail)) {
3254 // No longer used.
3255 } else if (match_option(option, "-XX:TLESize=", &tail)) {
3256 julong long_tlab_size = 0;
3257 ArgsRange errcode = parse_memory_size(tail, &long_tlab_size, 1);
3258 if (errcode != arg_in_range) {
3259 jio_fprintf(defaultStream::error_stream(),
3260 "Invalid TLAB size: %s\n", option->optionString);
3261 describe_range_error(errcode);
3262 return JNI_EINVAL;
3263 }
3264 FLAG_SET_CMDLINE(uintx, TLABSize, long_tlab_size);
3265 } else if (match_option(option, "-XX:TLEThreadRatio=", &tail)) {
3266 // No longer used.
3267 } else if (match_option(option, "-XX:+UseTLE")) {
3268 FLAG_SET_CMDLINE(bool, UseTLAB, true);
3269 } else if (match_option(option, "-XX:-UseTLE")) {
3270 FLAG_SET_CMDLINE(bool, UseTLAB, false);
3271 } else if (match_option(option, "-XX:+DisplayVMOutputToStderr")) {
3272 FLAG_SET_CMDLINE(bool, DisplayVMOutputToStdout, false);
3273 FLAG_SET_CMDLINE(bool, DisplayVMOutputToStderr, true);
3274 } else if (match_option(option, "-XX:+DisplayVMOutputToStdout")) {
3275 FLAG_SET_CMDLINE(bool, DisplayVMOutputToStderr, false);
3276 FLAG_SET_CMDLINE(bool, DisplayVMOutputToStdout, true);
3277 } else if (match_option(option, "-XX:+ExtendedDTraceProbes")) {
3278 #if defined(DTRACE_ENABLED)
3279 FLAG_SET_CMDLINE(bool, ExtendedDTraceProbes, true);
3280 FLAG_SET_CMDLINE(bool, DTraceMethodProbes, true);
3281 FLAG_SET_CMDLINE(bool, DTraceAllocProbes, true);
3282 FLAG_SET_CMDLINE(bool, DTraceMonitorProbes, true);
3283 #else // defined(DTRACE_ENABLED)
3284 jio_fprintf(defaultStream::error_stream(),
3285 "ExtendedDTraceProbes flag is not applicable for this configuration\n");
3286 return JNI_EINVAL;
3287 #endif // defined(DTRACE_ENABLED)
3288 #ifdef ASSERT
3289 } else if (match_option(option, "-XX:+FullGCALot")) {
3290 FLAG_SET_CMDLINE(bool, FullGCALot, true);
3291 // disable scavenge before parallel mark-compact
3292 FLAG_SET_CMDLINE(bool, ScavengeBeforeFullGC, false);
3293 #endif
3294 } else if (match_option(option, "-XX:CMSParPromoteBlocksToClaim=", &tail)) {
3295 julong cms_blocks_to_claim = (julong)atol(tail);
3296 FLAG_SET_CMDLINE(uintx, CMSParPromoteBlocksToClaim, cms_blocks_to_claim);
3297 jio_fprintf(defaultStream::error_stream(),
3298 "Please use -XX:OldPLABSize in place of "
3299 "-XX:CMSParPromoteBlocksToClaim in the future\n");
3300 } else if (match_option(option, "-XX:ParCMSPromoteBlocksToClaim=", &tail)) {
3301 julong cms_blocks_to_claim = (julong)atol(tail);
3302 FLAG_SET_CMDLINE(uintx, CMSParPromoteBlocksToClaim, cms_blocks_to_claim);
3303 jio_fprintf(defaultStream::error_stream(),
3304 "Please use -XX:OldPLABSize in place of "
3305 "-XX:ParCMSPromoteBlocksToClaim in the future\n");
3306 } else if (match_option(option, "-XX:ParallelGCOldGenAllocBufferSize=", &tail)) {
3307 julong old_plab_size = 0;
3308 ArgsRange errcode = parse_memory_size(tail, &old_plab_size, 1);
3309 if (errcode != arg_in_range) {
3310 jio_fprintf(defaultStream::error_stream(),
3311 "Invalid old PLAB size: %s\n", option->optionString);
3312 describe_range_error(errcode);
3313 return JNI_EINVAL;
3314 }
3315 FLAG_SET_CMDLINE(uintx, OldPLABSize, old_plab_size);
3316 jio_fprintf(defaultStream::error_stream(),
3317 "Please use -XX:OldPLABSize in place of "
3318 "-XX:ParallelGCOldGenAllocBufferSize in the future\n");
3319 } else if (match_option(option, "-XX:ParallelGCToSpaceAllocBufferSize=", &tail)) {
3320 julong young_plab_size = 0;
3321 ArgsRange errcode = parse_memory_size(tail, &young_plab_size, 1);
3322 if (errcode != arg_in_range) {
3323 jio_fprintf(defaultStream::error_stream(),
3324 "Invalid young PLAB size: %s\n", option->optionString);
3325 describe_range_error(errcode);
3326 return JNI_EINVAL;
3327 }
3328 FLAG_SET_CMDLINE(uintx, YoungPLABSize, young_plab_size);
3329 jio_fprintf(defaultStream::error_stream(),
3330 "Please use -XX:YoungPLABSize in place of "
3331 "-XX:ParallelGCToSpaceAllocBufferSize in the future\n");
3332 } else if (match_option(option, "-XX:CMSMarkStackSize=", &tail) ||
3333 match_option(option, "-XX:G1MarkStackSize=", &tail)) {
3334 julong stack_size = 0;
3335 ArgsRange errcode = parse_memory_size(tail, &stack_size, 1);
3336 if (errcode != arg_in_range) {
3337 jio_fprintf(defaultStream::error_stream(),
3338 "Invalid mark stack size: %s\n", option->optionString);
3339 describe_range_error(errcode);
3340 return JNI_EINVAL;
3341 }
3342 FLAG_SET_CMDLINE(uintx, MarkStackSize, stack_size);
3343 } else if (match_option(option, "-XX:CMSMarkStackSizeMax=", &tail)) {
3344 julong max_stack_size = 0;
3345 ArgsRange errcode = parse_memory_size(tail, &max_stack_size, 1);
3346 if (errcode != arg_in_range) {
3347 jio_fprintf(defaultStream::error_stream(),
3348 "Invalid maximum mark stack size: %s\n",
3349 option->optionString);
3350 describe_range_error(errcode);
3351 return JNI_EINVAL;
3352 }
3353 FLAG_SET_CMDLINE(uintx, MarkStackSizeMax, max_stack_size);
3354 } else if (match_option(option, "-XX:ParallelMarkingThreads=", &tail) ||
3355 match_option(option, "-XX:ParallelCMSThreads=", &tail)) {
3356 uintx conc_threads = 0;
3357 if (!parse_uintx(tail, &conc_threads, 1)) {
3358 jio_fprintf(defaultStream::error_stream(),
3359 "Invalid concurrent threads: %s\n", option->optionString);
3360 return JNI_EINVAL;
3361 }
3362 FLAG_SET_CMDLINE(uintx, ConcGCThreads, conc_threads);
3363 } else if (match_option(option, "-XX:MaxDirectMemorySize=", &tail)) {
3364 julong max_direct_memory_size = 0;
3365 ArgsRange errcode = parse_memory_size(tail, &max_direct_memory_size, 0);
3366 if (errcode != arg_in_range) {
3367 jio_fprintf(defaultStream::error_stream(),
3368 "Invalid maximum direct memory size: %s\n",
3369 option->optionString);
3370 describe_range_error(errcode);
3371 return JNI_EINVAL;
3372 }
3373 FLAG_SET_CMDLINE(uintx, MaxDirectMemorySize, max_direct_memory_size);
3374 #if !INCLUDE_MANAGEMENT
3375 } else if (match_option(option, "-XX:+ManagementServer")) {
3376 jio_fprintf(defaultStream::error_stream(),
3377 "ManagementServer is not supported in this VM.\n");
3378 return JNI_ERR;
3379 #endif // INCLUDE_MANAGEMENT
3380 } else if (match_option(option, "-XX:", &tail)) { // -XX:xxxx
3381 // Skip -XX:Flags= since that case has already been handled
|
1365 // Too early to use gclog_or_tty
1366 tty->print_cr("CMS ergo set OldSize: " SIZE_FORMAT, OldSize);
1367 }
1368 }
1369 }
1370 }
1371 }
1372 // Unless explicitly requested otherwise, definitely
1373 // promote all objects surviving "tenuring_default" scavenges.
1374 if (FLAG_IS_DEFAULT(MaxTenuringThreshold) &&
1375 FLAG_IS_DEFAULT(SurvivorRatio)) {
1376 FLAG_SET_ERGO(uintx, MaxTenuringThreshold, tenuring_default);
1377 }
1378 // If we decided above (or user explicitly requested)
1379 // `promote all' (via MaxTenuringThreshold := 0),
1380 // prefer minuscule survivor spaces so as not to waste
1381 // space for (non-existent) survivors
1382 if (FLAG_IS_DEFAULT(SurvivorRatio) && MaxTenuringThreshold == 0) {
1383 FLAG_SET_ERGO(uintx, SurvivorRatio, MAX2((uintx)1024, SurvivorRatio));
1384 }
1385
1386 // OldPLABSize is interpreted in CMS as not the size of the PLAB in words,
1387 // but rather the number of free blocks of a given size that are used when
1388 // replenishing the local per-worker free list caches.
1389 if (FLAG_IS_DEFAULT(OldPLABSize)) {
1390 if (!FLAG_IS_DEFAULT(ResizeOldPLAB) && !ResizeOldPLAB) {
1391 // OldPLAB sizing manually turned off: Use a larger default setting,
1392 // unless it was manually specified. This is because a too-low value
1393 // will slow down scavenges.
1394 FLAG_SET_ERGO(uintx, OldPLABSize, CFLS_LAB::_default_static_old_plab_size); // default value before 6631166
1395 } else {
1396 FLAG_SET_DEFAULT(OldPLABSize, CFLS_LAB::_default_dynamic_old_plab_size); // old CMSParPromoteBlocksToClaim default
1397 }
1398 }
1399
1400 // If either of the static initialization defaults have changed, note this
1401 // modification.
1402 if (!FLAG_IS_DEFAULT(OldPLABSize) || !FLAG_IS_DEFAULT(OldPLABWeight)) {
1403 CFLS_LAB::modify_initialization(OldPLABSize, OldPLABWeight);
1404 }
1405 if (PrintGCDetails && Verbose) {
1406 tty->print_cr("MarkStackSize: %uk MarkStackSizeMax: %uk",
1407 (unsigned int) (MarkStackSize / K), (uint) (MarkStackSizeMax / K));
1408 tty->print_cr("ConcGCThreads: %u", (uint) ConcGCThreads);
1409 }
1410 }
1411 #endif // INCLUDE_ALL_GCS
1412
1413 void set_object_alignment() {
1414 // Object alignment.
1415 assert(is_power_of_2(ObjectAlignmentInBytes), "ObjectAlignmentInBytes must be power of 2");
1416 MinObjAlignmentInBytes = ObjectAlignmentInBytes;
1417 assert(MinObjAlignmentInBytes >= HeapWordsPerLong * HeapWordSize, "ObjectAlignmentInBytes value is too small");
1418 MinObjAlignment = MinObjAlignmentInBytes / HeapWordSize;
1419 assert(MinObjAlignmentInBytes == MinObjAlignment * HeapWordSize, "ObjectAlignmentInBytes value is incorrect");
1420 MinObjAlignmentInBytesMask = MinObjAlignmentInBytes - 1;
1421
1422 LogMinObjAlignmentInBytes = exact_log2(ObjectAlignmentInBytes);
3188 FLAG_SET_CMDLINE(uintx, MaxTenuringThreshold, markOopDesc::max_age + 1);
3189 } else if (match_option(option, "-XX:+AlwaysTenure")) {
3190 FLAG_SET_CMDLINE(bool, NeverTenure, false);
3191 FLAG_SET_CMDLINE(bool, AlwaysTenure, true);
3192 FLAG_SET_CMDLINE(uintx, MaxTenuringThreshold, 0);
3193 } else if (match_option(option, "-XX:MaxTenuringThreshold=", &tail)) {
3194 uintx max_tenuring_thresh = 0;
3195 if(!parse_uintx(tail, &max_tenuring_thresh, 0)) {
3196 jio_fprintf(defaultStream::error_stream(),
3197 "Invalid MaxTenuringThreshold: %s\n", option->optionString);
3198 }
3199 FLAG_SET_CMDLINE(uintx, MaxTenuringThreshold, max_tenuring_thresh);
3200
3201 if (MaxTenuringThreshold == 0) {
3202 FLAG_SET_CMDLINE(bool, NeverTenure, false);
3203 FLAG_SET_CMDLINE(bool, AlwaysTenure, true);
3204 } else {
3205 FLAG_SET_CMDLINE(bool, NeverTenure, false);
3206 FLAG_SET_CMDLINE(bool, AlwaysTenure, false);
3207 }
3208 } else if (match_option(option, "-XX:+DisplayVMOutputToStderr")) {
3209 FLAG_SET_CMDLINE(bool, DisplayVMOutputToStdout, false);
3210 FLAG_SET_CMDLINE(bool, DisplayVMOutputToStderr, true);
3211 } else if (match_option(option, "-XX:+DisplayVMOutputToStdout")) {
3212 FLAG_SET_CMDLINE(bool, DisplayVMOutputToStderr, false);
3213 FLAG_SET_CMDLINE(bool, DisplayVMOutputToStdout, true);
3214 } else if (match_option(option, "-XX:+ExtendedDTraceProbes")) {
3215 #if defined(DTRACE_ENABLED)
3216 FLAG_SET_CMDLINE(bool, ExtendedDTraceProbes, true);
3217 FLAG_SET_CMDLINE(bool, DTraceMethodProbes, true);
3218 FLAG_SET_CMDLINE(bool, DTraceAllocProbes, true);
3219 FLAG_SET_CMDLINE(bool, DTraceMonitorProbes, true);
3220 #else // defined(DTRACE_ENABLED)
3221 jio_fprintf(defaultStream::error_stream(),
3222 "ExtendedDTraceProbes flag is not applicable for this configuration\n");
3223 return JNI_EINVAL;
3224 #endif // defined(DTRACE_ENABLED)
3225 #ifdef ASSERT
3226 } else if (match_option(option, "-XX:+FullGCALot")) {
3227 FLAG_SET_CMDLINE(bool, FullGCALot, true);
3228 // disable scavenge before parallel mark-compact
3229 FLAG_SET_CMDLINE(bool, ScavengeBeforeFullGC, false);
3230 #endif
3231 } else if (match_option(option, "-XX:CMSMarkStackSize=", &tail) ||
3232 match_option(option, "-XX:G1MarkStackSize=", &tail)) {
3233 julong stack_size = 0;
3234 ArgsRange errcode = parse_memory_size(tail, &stack_size, 1);
3235 if (errcode != arg_in_range) {
3236 jio_fprintf(defaultStream::error_stream(),
3237 "Invalid mark stack size: %s\n", option->optionString);
3238 describe_range_error(errcode);
3239 return JNI_EINVAL;
3240 }
3241 jio_fprintf(defaultStream::error_stream(),
3242 "Please use -XX:MarkStackSize in place of "
3243 "-XX:CMSMarkStackSize or -XX:G1MarkStackSize in the future\n");
3244 FLAG_SET_CMDLINE(uintx, MarkStackSize, stack_size);
3245 } else if (match_option(option, "-XX:CMSMarkStackSizeMax=", &tail)) {
3246 julong max_stack_size = 0;
3247 ArgsRange errcode = parse_memory_size(tail, &max_stack_size, 1);
3248 if (errcode != arg_in_range) {
3249 jio_fprintf(defaultStream::error_stream(),
3250 "Invalid maximum mark stack size: %s\n",
3251 option->optionString);
3252 describe_range_error(errcode);
3253 return JNI_EINVAL;
3254 }
3255 jio_fprintf(defaultStream::error_stream(),
3256 "Please use -XX:MarkStackSizeMax in place of "
3257 "-XX:CMSMarkStackSizeMax in the future\n");
3258 FLAG_SET_CMDLINE(uintx, MarkStackSizeMax, max_stack_size);
3259 } else if (match_option(option, "-XX:ParallelMarkingThreads=", &tail) ||
3260 match_option(option, "-XX:ParallelCMSThreads=", &tail)) {
3261 uintx conc_threads = 0;
3262 if (!parse_uintx(tail, &conc_threads, 1)) {
3263 jio_fprintf(defaultStream::error_stream(),
3264 "Invalid concurrent threads: %s\n", option->optionString);
3265 return JNI_EINVAL;
3266 }
3267 jio_fprintf(defaultStream::error_stream(),
3268 "Please use -XX:ConcGCThreads in place of "
3269 "-XX:ParallelMarkingThreads or -XX:ParallelCMSThreads in the future\n");
3270 FLAG_SET_CMDLINE(uintx, ConcGCThreads, conc_threads);
3271 } else if (match_option(option, "-XX:MaxDirectMemorySize=", &tail)) {
3272 julong max_direct_memory_size = 0;
3273 ArgsRange errcode = parse_memory_size(tail, &max_direct_memory_size, 0);
3274 if (errcode != arg_in_range) {
3275 jio_fprintf(defaultStream::error_stream(),
3276 "Invalid maximum direct memory size: %s\n",
3277 option->optionString);
3278 describe_range_error(errcode);
3279 return JNI_EINVAL;
3280 }
3281 FLAG_SET_CMDLINE(uintx, MaxDirectMemorySize, max_direct_memory_size);
3282 #if !INCLUDE_MANAGEMENT
3283 } else if (match_option(option, "-XX:+ManagementServer")) {
3284 jio_fprintf(defaultStream::error_stream(),
3285 "ManagementServer is not supported in this VM.\n");
3286 return JNI_ERR;
3287 #endif // INCLUDE_MANAGEMENT
3288 } else if (match_option(option, "-XX:", &tail)) { // -XX:xxxx
3289 // Skip -XX:Flags= since that case has already been handled
|