Changed name of blog

(Note: I've changed the name of this blog to avoid any association with the recent bombings. I disavow violence.)

At Amazon, the Principal most associated with "Scrum" and "Agile Development" used to say that you should not consider a software feature shipped until it was "Done Done Done" -- in other words, not just done, but done in all ways you can think of.

Hence, "Dunn Dunn Dunn".

Using C++11 in Travis CI

There are many strange solutions, but there is now a better way to do this.

    sudo: false
    language: cpp
    compiler:
      - gcc
      - clang
    install:
    - if [ "$CXX" = "g++" ]; then export CXX="g++-4.8" CC="gcc-4.8"; fi
    addons:
      apt:
        sources:
        - ubuntu-toolchain-r-test
        packages:
        - gcc-4.8
        - g++-4.8
        - clang

The explicit sudo: false will let it build in Docker (for speed) even if you have a pre-docker repo, according to Travis support.

Thanks to solarce at Travis support for noticing my error and fixing the docs.

• http://docs.travis-ci.com/user/apt/
• http://stackoverflow.com/a/30925448/263998

Deceptively simple interview questions

Someone posted this blog to reddit:

• 5 problems every programmer should know

Then, someone else posted this correction:

• Author posts invalid solution to #4

Embarrassingly, the original poster had stated:

I never said that you'll be hired if you know how to answer these problems, but I won't consider you if you can't.

Therefore, he would not hire himself!

The moral is not to assume that you know the answer to your own interview question. Be humble. Let the interview be a discussion. Maybe you will learn something.

git-fat for large files

GitHub recently added support for largefiles. If you want to share repos globally, that's fine. But for work within a corporate network, I like git-fat. It has few dependencies -- just plain python and rsync -- and caches files in /tmp. It's much simpler than alternatives like git-annex or git-lfs, which are better when you need the option to store files in S3, etc..

However, there is one problem with all these: They still deal with expensive checksums for many operations. This is partly to keep things simple -- letting git operate on files directly. But even just copying large files is slow, let alone checksumming. It's much faster to store URLs and to let the plugin update symlinks (or hardlinks) and handle caching. If you want a checksum, that can be encoded into the URL. Another advantage is that you can store whole directories, rather than individual files.

That is a plan I am working on with a friend. All large files would be read-only, unless explicitly "opened".

For now, git-fat works pretty well.

Google C++ Style Guide

• https://www.youtube.com/watch?v=NOCElcMcFik (Titus Winters at CppCon)

I am a big fan of this, mainly because I like to see side-effects clearly identified. There is an amazing amount of resistance. I don't think that the opposition can be moved, but maybe this reddit comment will at least convince managers of its value:

ericanderton 20 points 8 months ago* 

My $0.02:

I've done a lot of work using this style guide religiously, largely because it was what my team came together over. It was also the most cogent guide we could find online that was more than merely prescriptive. It's exactness was the overall deciding factor.

I hated using it at first. Overall, the guide is very regressive, and chops the legs off of C++ such that it's not much more than "C with namespaces and classes." You could even go as far as to say that most arguments in the guide reduce to "this isn't a problem in Java or Python because you can't make this mistake, so don't use feature X here at all." Ultimately, it keeps you from doing anything that would allow bugs to creep in by mistake or by misinterpretation, by keeping it all nice and simple. And this is where this style guide actually helps.

The problem is that C++ provides almost too much leverage. Left unchecked, developers will likely use the language to its limits, which inevitably will confound other members of the team. While the program may be a masterpiece of template code, move semantics, and other concepts, it's now unmaintainable by anyone but the original author. Business wise, it's vastly preferable to have an uninspired piece of software if it means you can fix bugs while half your staff has the flu.

Also, consider that the goals of the Google C++ style guide align incredibly well with Go. To me, this is a very salient case against using C++ if that guide is at all a good fit for new development. Go has a very tight language spec, and a (IMO) superior concurrency model that is easier to construct, reason about, and debug. And it's still a compiled language.

Anyway, I'm proud to say that I have delivered excellent results, and relatively bug free code using this guide. If left to my own devices I probably would have used too much template magic and other mechanics that, while are all valid C++, would be harder to debug and understand by other members of my team. The resulting codebase is boring as all hell to read, but stable, reliable, and works incredibly well.

The downside is that compared to conventional languages, the result still takes a long time to compile, is twice as much code as is needed (header files), and relies heavily on smart pointers to manage memory (may as well use a GC). Again, this is why I mentioned using Go earlier.

One last thing: this guide does not stress the importance of "const correctness" in class construction. Add that to your work and you'll really have some solid code to rely upon.

tl;dr: For new development, either forgo this guide completely, or just use Go. Otherwise, you'll just piss off experienced C++ developers by using this thing.

Edit: I forgot to mention that the GSG has a massive blind spot for exception safety. Just because your code doesn't use exceptions, doesn't mean that the libraries you use don't throw. This includes the STL; the guide should steer you away from throwing variants of STL functions/methods, but it doesn't. So be on the lookout for coders not throwing try/catch around third party code, and refusing to use basic RAII (also not mentioned in the guide) to make things airtight. Either that, or just except that every exception-based runtime fault should halt the program, and that it's an acceptable failure mode (probably not).

For a longer discussion, see:

• http://www.reddit.com/r/cpp/comments/289n27
• http://stackoverflow.com/questions/26441220/googles-style-guide-about-input-output-parameters-as-pointers/26441753#26441753
• http://stackoverflow.com/questions/7557258/jsoncpp-formating-problems/28521926

C++: STL Iterator confusion

Recently, folks at my last company got confused with STL iterators.

1. They used boost::python to create an InputIterator, using stl_iterator.
2. They used is_sorted() to check whether the underlying list was sorted (of course).
3. They then looped over their iterator.

That was a mistake. An InputIterator is single-pass, so someone obviously forgot to read the documentation.

But this highlights a problem with STL. is_sorted() actually requires a ForwardIterator. At that link, you can see that a ForwardIterator might be "mutable", meaning that it can be written into. But is_sorted() takes a copy of an iterator, and it certainly does not write into it. There can be no issue of side-effects, right?

Wrong. You can pass an InputIterator if you want, at your own risk. is_sorted() might still return the correct result, but the original iterator (which was copied for the call to is_sorted()) might now be invalid.

So the question became whether it was safe to pass an Inputerator to is_sorted(). In general, the answer is "No". Look at representative source code:

template <class ForwardIterator>
  bool is_sorted (ForwardIterator first, ForwardIterator last)
{
  if (first==last) return true;
  ForwardIterator next = first;
  while (++next!=last) {
    if (*next<*first)     // or, if (comp(*next,*first)) for version (2)
      return false;
    ++first;
  }
  return true;
}

That function requires a copy of the original "first" iterator. "first" and "next" must both be valid during the entire function, and that is not guaranteed for an InputIterator.

However, the boost::python InputIterator is actually a memoized iterator. If you increment it, then the next value for any copy will no longer be the value after what the copy points to. But the copy remains valid for reference. So is_sorted() is fine, as long as no further iteration is performed later.

The problem is that STL is missing a concept between ForwardIterator and InputIterator. So is_sorted() is given the more restrictive designation.

Another way to look at this is that C++ templates are insufficient for practical iterators. The following is closer to the function we really want:

template <class ForwardIterator>
  bool is_sorted (ForwardIterator first, ForwardIterator last)
{
  if (first==last) return true;
  ForwardIterator next = first;

  auto prev_value = *first;
  while (++next!=last) {

    auto next_value = *next;
    if (next_value<prev_value);
      return false;
    prev_value = next_value;;
  }
  return true;
}




But that has problems too. Suddenly, the underlying type must be copy-constructible, and those copies could be expensive. We could use a pointer, but a pointer to what? If we don't make a copy, then there is nothing to point to.

We need an extra version of this algorithm which can safely accept InputIterators, with the implication that there will be copies of the underlying data. But it would need a different function name, and it would confuse everyone.

What we really need is the concept of "Iterator with invariant current element (unless underlying container is modified) but possibly variant subsequent Iterator". Lots of iterators actually work that way. But it would probably confuse people even more.

Reactive Programming

This is hard for me to explain yet, but here are helpful links:

  http://www.reactivemanifesto.org/

  http://jlongster.com/Removing-User-Interface-Complexity,-or-Why-React-is-Awesome

  https://gist.github.com/staltz/868e7e9bc2a7b8c1f754

Basically, state is passed down, and events go up. Component A creates Component B, passing parts of A into B as immutable properties, and setting call-backs on B to call into A. Most components are re-created repeatedly.

Benefits:

• Data-flow is clear and consistent.
• Mutable state is isloated and minimal.
• The entire architecture is highly scalable.

Git: Rebase, then merge (--no-ff)

In case you think you should always either rebase or merge, check out this reddit post.

And this blog shows how to rebase a stale GitHub "pull request" (as opposed to using the "Merge Pull Request" button).

C++: copy elision

The C++ standard permits the compiler to skip (or "elide") a constructor under some circumstances, e.g. when a temporary is passed into a function by value. There is plenty of information on the web about this subject, but here is a concrete example.

What's interesting is that "copy elision" can actually alter semantics:

When certain criteria are met, an implementation is allowed to omit the copy/move construction of a class object, even if the copy/move constructor and/or destructor for the object have side effects.

Anyway, because of this feature, it can be wise to let a method accept an input by value rather than by const-reference, e.g.

table[key] = value;

The pattern should be considered whenever the method would have created an explicit copy, as for swapping.

Recursive memoization with Go

There are many odd solutions on the web to the "Web Crawler" exercise in the GoLang tutorial:
    https://tour.golang.org/concurrency/9
    http://soniacodes.wordpress.com/2011/10/09/a-tour-of-go-69-exercise-web-crawler/#comment-176

It's presented as a recursive function which requires memoization and parallelism. There are 2 main approaches:

1. Synchronization primitives, or
2. Callbacks

Both are needlessly complex. Here is my solution:
    https://gist.github.com/cdunn2001/a0caf94ce6c5f1da002b
 
Mine is simple because I dropped the recursion. If you see a producer/consumer pattern with recursion, you probably need synchronization primitives. But if you can drop the recursion, then the consumer can know exactly how many producers he created.

An interesting sidebar is how to memoize in Go.  A closure is probably the best way, but I didn't bother with that in my solution, to minimize diffs.

For another angle on the deceptive simplicity of gochannels, read this:
    http://www.jtolds.com/writing/2016/03/go-channels-are-bad-and-you-should-feel-bad/

Storing dotfiles in Git: symlink + worktree

I use 3 tricks:

1. core.worktree = /Users/cdunn
2. symlink .git -> dotfiles/.git/
3. In .gitignore: *

The beauty of my approach compared to many others is that regular git commands work directly in my home-directory. It's easier to explain with an example:

•   https://github.com/cdunn2001/dotfiles

To add new ones, pass the '-f' flag to 'git add'.

---

The Evil Unit Test

 (This is copied from the blog by Alberto Gutierrez, posted January 27th, 2012 at 7:54 am, on makinggoodsoftware.com, which recently vanished. I pulled this from the Google cache. I largely agree. ~cd)

(Addendum: I had a conversation on this point with Earl Everett, after his engaging talk at Agile Austin. The point of contention was whether an internal class can be considered a "product" to another developer. Think of an algorithm which you will present to others. You will test the algorithm thoroughly, with full branch coverage etc. Do you need to "unit-test" the underlying classes that were used to implement the algorithm?)

The evil unit test.

Written by Alberto Gutierrez

Unit tests can be evil, I know that sounds harsh, but I think there is a battle to be fought to make people understand that unit tests are not always good, and that they actually can become evil, specially when overused.
Think in a foreach, most languages have an implementation of this flow statement. Is the foreach a useful utility for programmers? Definitely! What about function pointers? or Design patterns? or ORM frameworks?… All of them are useful utilities, but can you imagine a programmer, or a book naming the following principles?

• You shall use a foreach every time you need to perform a loop.
• Every third method shall implement a design pattern.
• You will never access your database if you are not using an ORM.

Stupid, right? So why is it that there are programmers happy with statements like:

• Every public method shall have a unit test.
• Unit tests are not to be deleted. There is always a reason for a unit test to exist!
• Unit tests must be created before the code they test.
• Unit test coverage should be 100%.

Unit tests, as any other utility, tool, principle, philosophy etc. are only to be used when applicable and convenient, and not to be taken as religious dogmas. I have already made this point in my previous article, but since it generated so much controversy I thought it would be good to expand on it. If you can’t unit test a piece of code from a behaviour/black box perspective, then you probably shouldn’t write a unit test at all. Your unit test should check what your code is doing, not how. If you create a unit test that it only focus on how your code is, instead of what it does, then you are writing an evil test because:

1. Evil tests create a lock on how the code is implemented.

Every time the implementation of the method changes, even if its behaviour is maintained, the test becomes red. There is no reason to lock the implementation, because there is no advantage on doing so. If there is some code that is especially tricky, locking its implementation with tests won’t make it easier to understand or won’t force anyone to think twice before changing it.

2. Cause duplication.

The beauty of code with good unit tests is that they compliment each other; the code to be tested represents the implementation (the how), and the test guarantees behaviour (the what). On the other hand, evil unit tests look again into the how, so you will have two places where you state how do you think a problem should be solved, only that you will be using different expressions to do so. Is like saying: “2*3 = 2 + 2 + 2”, and then writing a test that says “Guarantee that 2*3 is the addition of 2 three times”, as opposite to “Guarantee that 2*3 is 6”. Testing the implementation and not the behaviour is a waste of time and serves no purpose since you can always go to the code to find what the implementation is.

3. Builds uncertainty on the tests (red is meaningless).

One of the main advantages of having an automated test suite is that feedback loops become shorter. It takes less time from creating a bug to detecting it. When the code gets polluted with bad unit tests, the automated tests seem to start getting broken randomly and this sometimes leads to a point where developers don’t care much anymore about having their tests passing as usual as they should.

4. Decrease productivity.

Given all the circumstances mentioned already, developers dealing with evil unit tests are faced with many inconveniences that forces them to expend time in unproductive tasks, like refactoring useless unit tests, writing them…

5. Discourage change.

Code bloated with bad unit tests is a nightmare to maintain, you make an implementation change, not a behaviour change, and you have to expend ages fixing tests, hence you minimize your implementation changes which is the core idea behind refactoring.
Consider the following principles then:
1. Delete evil tests. There seems to be a taboo around deleting unit tests, is like they are untouchables, well that’s no true, if the test is not adding value, then the test is an evil test and MUST be deleted.
2. Minimise the areas of your code that can’t be effectively unit tested. It is also true that sometimes the problem is that the code is written so that areas that should be unit testable are tied to components that make difficult the unit testing, in this case, the programmers needs to expend more time understanding the principles behind loose coupling and separation of concerns.
3. Write integrations tests for areas that are not unit testable. There is always going to be code in your application that is going to be legitimately not unit testable, for this code, simply don’t write a unit test, write an integration test.

Java: Viewing all global JVM settings

From StackOverflow:

 java  -XX:+UnlockDiagnosticVMOptions -XX:+PrintFlagsFinal

E.g.

[Global flags]
    uintx AdaptivePermSizeWeight                    = 20              {product}
    uintx AdaptiveSizeDecrementScaleFactor          = 4               {product}
    uintx AdaptiveSizeMajorGCDecayTimeScale         = 10              {product}
    uintx AdaptiveSizePausePolicy                   = 0               {product}
    uintx AdaptiveSizePolicyCollectionCostMargin    = 50              {product}
    uintx AdaptiveSizePolicyInitializingSteps       = 20              {product}
    uintx AdaptiveSizePolicyOutputInterval          = 0               {product}
    uintx AdaptiveSizePolicyWeight                  = 10              {product}
    uintx AdaptiveSizeThroughPutPolicy              = 0               {product}
    uintx AdaptiveTimeWeight                        = 25              {product}
     bool AdjustConcurrency                         = false           {product}
     bool AggressiveOpts                            = false           {product}
     intx AliasLevel                                = 3               {product}
     intx AllocateInstancePrefetchLines             = 1               {product}
     intx AllocatePrefetchDistance                  = 256             {product}
     intx AllocatePrefetchInstr                     = 0               {product}
     intx AllocatePrefetchLines                     = 3               {product}
     intx AllocatePrefetchStepSize                  = 64              {product}
     intx AllocatePrefetchStyle                     = 1               {product}
     bool AllowJNIEnvProxy                          = false           {product}
     bool AllowNonVirtualCalls                      = false           {product}
     bool AllowParallelDefineClass                  = false           {product}
     bool AllowUserSignalHandlers                   = false           {product}
     bool AlwaysActAsServerClassMachine             = false           {product}
     bool AlwaysCompileLoopMethods                  = false           {product}
     intx AlwaysInflate                             = 0               {product}
     bool AlwaysLockClassLoader                     = false           {product}
     bool AlwaysPreTouch                            = false           {product}
     bool AlwaysRestoreFPU                          = false           {product}
     bool AlwaysTenure                              = false           {product}
     bool AnonymousClasses                          = false           {product}
     bool AssertOnSuspendWaitFailure                = false           {product}
     intx Atomics                                   = 0               {product}
     intx AutoBoxCacheMax                           = 128             {C2 product}
    uintx AutoGCSelectPauseMillis                   = 5000            {product}
     intx BCEATraceLevel                            = 0               {product}
     intx BackEdgeThreshold                         = 100000          {pd product}
     bool BackgroundCompilation                     = true            {pd product}
    uintx BaseFootPrintEstimate                     = 268435456       {product}
     intx BiasedLockingBulkRebiasThreshold          = 20              {product}
     intx BiasedLockingBulkRevokeThreshold          = 40              {product}
     intx BiasedLockingDecayTime                    = 25000           {product}
     intx BiasedLockingStartupDelay                 = 4000            {product}
     bool BindCMSThreadToCPU                        = false           {diagnostic}
     bool BindGCTaskThreadsToCPUs                   = false           {product}
     bool BlockLayoutByFrequency                    = true            {C2 product}
     intx BlockLayoutMinDiamondPercentage           = 20              {C2 product}
     bool BlockLayoutRotateLoops                    = true            {C2 product}
     bool BlockOffsetArrayUseUnallocatedBlock       = true            {product}
     bool BranchOnRegister                          = false           {C2 product}
     bool BytecodeVerificationLocal                 = false           {product}
     bool BytecodeVerificationRemote                = true            {product}
     bool C1OptimizeVirtualCallProfiling            = true            {C1 product}
     bool C1ProfileBranches                         = true            {C1 product}
     bool C1ProfileCalls                            = true            {C1 product}
     bool C1ProfileCheckcasts                       = true            {C1 product}
     bool C1ProfileInlinedCalls                     = true            {C1 product}
     bool C1ProfileVirtualCalls                     = true            {C1 product}
     bool C1UpdateMethodData                        = true            {C1 product}
     intx CICompilerCount                           = 2               {product}
     bool CICompilerCountPerCPU                     = false           {product}
     bool CITime                                    = false           {product}
     bool CMSAbortSemantics                         = false           {product}
    uintx CMSAbortablePrecleanMinWorkPerIteration   = 100             {product}
     intx CMSAbortablePrecleanWaitMillis            = 100             {manageable}
    uintx CMSBitMapYieldQuantum                     = 10485760        {product}
    uintx CMSBootstrapOccupancy                     = 50              {product}
     bool CMSClassUnloadingEnabled                  = false           {product}
    uintx CMSClassUnloadingMaxInterval              = 0               {product}
     bool CMSCleanOnEnter                           = true            {product}
     bool CMSCompactWhenClearAllSoftRefs            = true            {product}
    uintx CMSConcMarkMultiple                       = 32              {product}
     bool CMSConcurrentMTEnabled                    = true            {product}
    uintx CMSCoordinatorYieldSleepCount             = 10              {product}
     bool CMSDumpAtPromotionFailure                 = false           {product}
    uintx CMSExpAvgFactor                           = 50              {product}
     bool CMSExtrapolateSweep                       = false           {product}
    uintx CMSFullGCsBeforeCompaction                = 0               {product}
    uintx CMSIncrementalDutyCycle                   = 10              {product}
    uintx CMSIncrementalDutyCycleMin                = 0               {product}
     bool CMSIncrementalMode                        = false           {product}
    uintx CMSIncrementalOffset                      = 0               {product}
     bool CMSIncrementalPacing                      = true            {product}
    uintx CMSIncrementalSafetyFactor                = 10              {product}
    uintx CMSIndexedFreeListReplenish               = 4               {product}
     intx CMSInitiatingOccupancyFraction            = -1              {product}
     intx CMSInitiatingPermOccupancyFraction        = -1              {product}
     intx CMSIsTooFullPercentage                    = 98              {product}
   double CMSLargeCoalSurplusPercent                = 0.950000        {product}
   double CMSLargeSplitSurplusPercent               = 1.000000        {product}
     bool CMSLoopWarn                               = false           {product}
    uintx CMSMaxAbortablePrecleanLoops              = 0               {product}
     intx CMSMaxAbortablePrecleanTime               = 5000            {product}
    uintx CMSOldPLABMax                             = 1024            {product}
    uintx CMSOldPLABMin                             = 16              {product}
    uintx CMSOldPLABNumRefills                      = 4               {product}
    uintx CMSOldPLABReactivityCeiling               = 10              {product}
    uintx CMSOldPLABReactivityFactor                = 2               {product}
     bool CMSOldPLABResizeQuicker                   = false           {product}
    uintx CMSOldPLABToleranceFactor                 = 4               {product}
     bool CMSPLABRecordAlways                       = true            {product}
    uintx CMSParPromoteBlocksToClaim                = 16              {product}
     bool CMSParallelRemarkEnabled                  = true            {product}
     bool CMSParallelSurvivorRemarkEnabled          = true            {product}
     bool CMSPermGenPrecleaningEnabled              = true            {product}
    uintx CMSPrecleanDenominator                    = 3               {product}
    uintx CMSPrecleanIter                           = 3               {product}
    uintx CMSPrecleanNumerator                      = 2               {product}
     bool CMSPrecleanRefLists1                      = true            {product}
     bool CMSPrecleanRefLists2                      = false           {product}
     bool CMSPrecleanSurvivors1                     = false           {product}
     bool CMSPrecleanSurvivors2                     = true            {product}
    uintx CMSPrecleanThreshold                      = 1000            {product}
     bool CMSPrecleaningEnabled                     = true            {product}
     bool CMSPrintChunksInDump                      = false           {product}
     bool CMSPrintObjectsInDump                     = false           {product}
    uintx CMSRemarkVerifyVariant                    = 1               {product}
     bool CMSReplenishIntermediate                  = true            {product}
    uintx CMSRescanMultiple                         = 32              {product}
    uintx CMSRevisitStackSize                       = 1048576         {product}
    uintx CMSSamplingGrain                          = 16384           {product}
     bool CMSScavengeBeforeRemark                   = false           {product}
    uintx CMSScheduleRemarkEdenPenetration          = 50              {product}
    uintx CMSScheduleRemarkEdenSizeThreshold        = 2097152         {product}
    uintx CMSScheduleRemarkSamplingRatio            = 5               {product}
   double CMSSmallCoalSurplusPercent                = 1.050000        {product}
   double CMSSmallSplitSurplusPercent               = 1.100000        {product}
     bool CMSSplitIndexedFreeListBlocks             = true            {product}
     intx CMSTriggerPermRatio                       = 80              {product}
     intx CMSTriggerRatio                           = 80              {product}
     bool CMSUseOldDefaults                         = false           {product}
     intx CMSWaitDuration                           = 2000            {manageable}
    uintx CMSWorkQueueDrainThreshold                = 10              {product}
     bool CMSYield                                  = true            {product}
    uintx CMSYieldSleepCount                        = 0               {product}
     intx CMSYoungGenPerWorker                      = 16777216        {product}
    uintx CMS_FLSPadding                            = 1               {product}
    uintx CMS_FLSWeight                             = 75              {product}
    uintx CMS_SweepPadding                          = 1               {product}
    uintx CMS_SweepTimerThresholdMillis             = 10              {product}
    uintx CMS_SweepWeight                           = 75              {product}
    uintx CPUForCMSThread                           = 0               {diagnostic}
     bool CheckJNICalls                             = false           {product}
     bool ClassUnloading                            = true            {product}
     intx ClearFPUAtPark                            = 0               {product}
     bool ClipInlining                              = true            {product}
    uintx CodeCacheExpansionSize                    = 32768           {pd product}
    uintx CodeCacheFlushingMinimumFreeSpace         = 1536000         {product}
    uintx CodeCacheMinimumFreeSpace                 = 512000          {product}
     bool CollectGen0First                          = false           {product}
     bool CompactFields                             = true            {product}
     intx CompilationPolicyChoice                   = 0               {product}
     intx CompilationRepeat                         = 0               {C1 product}
ccstrlist CompileCommand                            =                 {product}
    ccstr CompileCommandFile                        =                 {product}
ccstrlist CompileOnly                               =                 {product}
     intx CompileThreshold                          = 10000           {pd product}
     bool CompilerThreadHintNoPreempt               = true            {product}
     intx CompilerThreadPriority                    = -1              {product}
     intx CompilerThreadStackSize                   = 0               {pd product}
    uintx ConcGCThreads                             = 0               {product}
     intx ConditionalMoveLimit                      = 3               {C2 pd product}
     bool ConvertSleepToYield                       = true            {pd product}
     bool ConvertYieldToSleep                       = false           {product}
     bool DTraceAllocProbes                         = false           {product}
     bool DTraceMethodProbes                        = false           {product}
     bool DTraceMonitorProbes                       = false           {product}
     bool DebugInlinedCalls                         = true            {diagnostic}
     bool DebugNonSafepoints                        = false           {diagnostic}
    uintx DefaultMaxRAMFraction                     = 4               {product}
     intx DefaultThreadPriority                     = -1              {product}
     bool DeferInitialCardMark                      = false           {diagnostic}
     intx DeferPollingPageLoopCount                 = -1              {product}
     intx DeferThrSuspendLoopCount                  = 4000            {product}
     bool DeoptimizeRandom                          = false           {product}
     intx DesiredMethodLimit                        = 8000            {product}
     bool DisableAttachMechanism                    = false           {product}
     bool DisableExplicitGC                         = false           {product}
ccstrlist DisableIntrinsic                          =                 {diagnostic}
     bool DisplayVMOutput                           = true            {diagnostic}
     bool DisplayVMOutputToStderr                   = false           {product}
     bool DisplayVMOutputToStdout                   = false           {product}
     bool DoEscapeAnalysis                          = true            {C2 product}
     intx DominatorSearchLimit                      = 1000            {C2 diagnostic}
     bool DontCompileHugeMethods                    = true            {product}
     bool DontYieldALot                             = false           {pd product}
     bool DumpSharedSpaces                          = false           {product}
     bool EagerXrunInit                             = false           {product}
     intx EliminateAllocationArraySizeLimit         = 64              {C2 product}
     bool EliminateAllocations                      = true            {C2 product}
     bool EliminateAutoBox                          = false           {C2 diagnostic}
     bool EliminateLocks                            = true            {C2 product}
     intx EmitSync                                  = 0               {product}
    uintx ErgoHeapSizeLimit                         = 0               {product}
    ccstr ErrorFile                                 =                 {product}
     bool EstimateArgEscape                         = true            {product}
     intx EventLogLength                            = 2000            {product}
     bool ExplicitGCInvokesConcurrent               = false           {product}
     bool ExplicitGCInvokesConcurrentAndUnloadsClasses  = false           {product}
     bool ExtendedDTraceProbes                      = false           {product}
     bool FLSAlwaysCoalesceLarge                    = false           {product}
    uintx FLSCoalescePolicy                         = 2               {product}
   double FLSLargestBlockCoalesceProximity          = 0.990000        {product}
     bool FLSVerifyAllHeapReferences                = false           {diagnostic}
     bool FLSVerifyIndexTable                       = false           {diagnostic}
     bool FLSVerifyLists                            = false           {diagnostic}
     bool FailOverToOldVerifier                     = true            {product}
     bool FastTLABRefill                            = true            {product}
     intx FenceInstruction                          = 0               {product}
     intx FieldsAllocationStyle                     = 1               {product}
     bool FilterSpuriousWakeups                     = true            {product}
     bool ForceNUMA                                 = false           {product}
     bool ForceTimeHighResolution                   = false           {product}
     intx FreqInlineSize                            = 325             {pd product}
     bool FullProfileOnReInterpret                  = true            {diagnostic}
     intx G1ConcRefinementGreenZone                 = 0               {product}
     intx G1ConcRefinementRedZone                   = 0               {product}
     intx G1ConcRefinementServiceIntervalMillis     = 300             {product}
    uintx G1ConcRefinementThreads                   = 0               {product}
     intx G1ConcRefinementThresholdStep             = 0               {product}
     intx G1ConcRefinementYellowZone                = 0               {product}
     intx G1ConfidencePercent                       = 50              {product}
    uintx G1HeapRegionSize                          = 0               {product}
     intx G1MarkRegionStackSize                     = 1048576         {product}
     bool G1PrintHeapRegions                        = false           {diagnostic}
     intx G1RSetRegionEntries                       = 0               {product}
    uintx G1RSetScanBlockSize                       = 64              {product}
     intx G1RSetSparseRegionEntries                 = 0               {product}
     intx G1RSetUpdatingPauseTimePercent            = 10              {product}
     intx G1ReservePercent                          = 10              {product}
    uintx G1SATBBufferEnqueueingThresholdPercent    = 60              {product}
     intx G1SATBBufferSize                          = 1024            {product}
     bool G1SummarizeConcMark                       = false           {diagnostic}
     bool G1SummarizeRSetStats                      = false           {diagnostic}
     intx G1SummarizeRSetStatsPeriod                = 0               {diagnostic}
     bool G1TraceConcRefinement                     = false           {diagnostic}
     intx G1UpdateBufferSize                        = 256             {product}
     bool G1UseAdaptiveConcRefinement               = true            {product}
    uintx GCDrainStackTargetSize                    = 64              {product}
    uintx GCHeapFreeLimit                           = 2               {product}
    uintx GCLockerEdenExpansionPercent              = 5               {product}
     bool GCLockerInvokesConcurrent                 = false           {product}
    uintx GCLogFileSize                             = 0               {product}
     bool GCOverheadReporting                       = false           {product}
     intx GCOverheadReportingPeriodMS               = 100             {product}
     bool GCParallelVerificationEnabled             = true            {diagnostic}
    uintx GCPauseIntervalMillis                     = 0               {product}
    uintx GCTaskTimeStampEntries                    = 200             {product}
    uintx GCTimeLimit                               = 98              {product}
    uintx GCTimeRatio                               = 99              {product}
     intx GuaranteedSafepointInterval               = 1000            {diagnostic}
    ccstr HPILibPath                                =                 {product}
    uintx HeapBaseMinAddress                        = 2147483648      {pd product}
     bool HeapDumpAfterFullGC                       = false           {manageable}
     bool HeapDumpBeforeFullGC                      = false           {manageable}
     bool HeapDumpOnOutOfMemoryError                = false           {manageable}
    ccstr HeapDumpPath                              =                 {manageable}
    uintx HeapFirstMaximumCompactionCount           = 3               {product}
    uintx HeapMaximumCompactionInterval             = 20              {product}
     bool IgnoreUnrecognizedVMOptions               = false           {product}
    uintx InitialCodeCacheSize                      = 2359296         {pd product}
     bool InitialCompileFast                        = false           {diagnostic}
     bool InitialCompileReallyFast                  = false           {diagnostic}
    uintx InitialHeapSize                          := 67108864        {product}
    uintx InitialRAMFraction                        = 64              {product}
    uintx InitialSurvivorRatio                      = 8               {product}
     intx InitialTenuringThreshold                  = 7               {product}
    uintx InitiatingHeapOccupancyPercent            = 45              {product}
     bool Inline                                    = true            {product}
     intx InlineSmallCode                           = 1000            {pd product}
     bool InsertMemBarAfterArraycopy                = true            {C2 product}
     intx InteriorEntryAlignment                    = 4               {C2 pd product}
     intx InterpreterProfilePercentage              = 33              {product}
     bool JNIDetachReleasesMonitors                 = true            {product}
     bool JavaMonitorsInStackTrace                  = true            {product}
     intx JavaPriority10_To_OSPriority              = -1              {product}
     intx JavaPriority1_To_OSPriority               = -1              {product}
     intx JavaPriority2_To_OSPriority               = -1              {product}
     intx JavaPriority3_To_OSPriority               = -1              {product}
     intx JavaPriority4_To_OSPriority               = -1              {product}
     intx JavaPriority5_To_OSPriority               = -1              {product}
     intx JavaPriority6_To_OSPriority               = -1              {product}
     intx JavaPriority7_To_OSPriority               = -1              {product}
     intx JavaPriority8_To_OSPriority               = -1              {product}
     intx JavaPriority9_To_OSPriority               = -1              {product}
     bool LIRFillDelaySlots                         = false           {C1 pd product}
    uintx LargePageHeapSizeThreshold                = 134217728       {product}
    uintx LargePageSizeInBytes                      = 0               {product}
     bool LazyBootClassLoader                       = true            {product}
     bool LinkWellKnownClasses                      = false           {diagnostic}
     bool LogCompilation                            = false           {diagnostic}
    ccstr LogFile                                   =                 {diagnostic}
     bool LogVMOutput                               = false           {diagnostic}
     intx LoopOptsCount                             = 43              {C2 product}
     intx LoopUnrollLimit                           = 50              {C2 pd product}
     intx LoopUnrollMin                             = 4               {C2 product}
     bool LoopUnswitching                           = true            {C2 product}
     intx MallocVerifyInterval                      = 0               {diagnostic}
     intx MallocVerifyStart                         = 0               {diagnostic}
     bool ManagementServer                          = false           {product}
    uintx MarkStackSize                             = 32768           {product}
    uintx MarkStackSizeMax                          = 4194304         {product}
     intx MarkSweepAlwaysCompactCount               = 4               {product}
    uintx MarkSweepDeadRatio                        = 5               {product}
     intx MaxBCEAEstimateLevel                      = 5               {product}
     intx MaxBCEAEstimateSize                       = 150             {product}
     intx MaxDirectMemorySize                       = -1              {product}
     bool MaxFDLimit                                = true            {product}
    uintx MaxGCMinorPauseMillis                     = 4294967295      {product}
    uintx MaxGCPauseMillis                          = 4294967295      {product}
    uintx MaxHeapFreeRatio                          = 70              {product}
    uintx MaxHeapSize                              := 1073741824      {product}
     intx MaxInlineLevel                            = 9               {product}
     intx MaxInlineSize                             = 35              {product}
     intx MaxJavaStackTraceDepth                    = 1024            {product}
     intx MaxJumpTableSize                          = 65000           {C2 product}
     intx MaxJumpTableSparseness                    = 5               {C2 product}
     intx MaxLabelRootDepth                         = 1100            {C2 product}
     intx MaxLoopPad                                = 11              {C2 product}
    uintx MaxNewSize                                = 4294901760      {product}
     intx MaxNodeLimit                              = 65000           {C2 product}
    uintx MaxPermHeapExpansion                      = 4194304         {product}
    uintx MaxPermSize                               = 67108864        {pd product}
 uint64_t MaxRAM                                    = 0               {pd product}
    uintx MaxRAMFraction                            = 4               {product}
     intx MaxRecursiveInlineLevel                   = 1               {product}
     intx MaxTenuringThreshold                      = 15              {product}
     intx MaxTrivialSize                            = 6               {product}
     bool MethodFlushing                            = true            {product}
     intx MethodHandlePushLimit                     = 3               {diagnostic}
     intx MinCodeCacheFlushingInterval              = 30              {product}
    uintx MinHeapDeltaBytes                         = 131072          {product}
    uintx MinHeapFreeRatio                          = 40              {product}
     intx MinInliningThreshold                      = 250             {product}
     intx MinJumpTableSize                          = 18              {C2 product}
    uintx MinPermHeapExpansion                      = 262144          {product}
    uintx MinRAMFraction                            = 2               {product}
    uintx MinSurvivorRatio                          = 3               {product}
    uintx MinTLABSize                               = 2048            {product}
     intx MonitorBound                              = 0               {product}
     bool MonitorInUseLists                         = false           {product}
     intx MultiArrayExpandLimit                     = 6               {C2 product}
     bool MustCallLoadClassInternal                 = false           {product}
     intx NUMAChunkResizeWeight                     = 20              {product}
     intx NUMAPageScanRate                          = 256             {product}
     intx NUMASpaceResizeRate                       = 1073741824      {product}
     bool NUMAStats                                 = false           {product}
     intx NativeMonitorFlags                        = 0               {product}
     intx NativeMonitorSpinLimit                    = 20              {product}
     intx NativeMonitorTimeout                      = -1              {product}
     bool NeedsDeoptSuspend                         = false           {pd product}
     bool NeverActAsServerClassMachine              = false           {pd product}
     bool NeverTenure                               = false           {product}
     intx NewRatio                                  = 2               {product}
    uintx NewSize                                   = 1048576         {product}
    uintx NewSizeThreadIncrease                     = 4096            {pd product}
     intx NmethodSweepCheckInterval                 = 5               {product}
     intx NmethodSweepFraction                      = 4               {product}
     intx NodeLimitFudgeFactor                      = 1000            {C2 product}
    uintx NumberOfGCLogFiles                        = 0               {product}
     intx NumberOfLoopInstrToAlign                  = 4               {C2 product}
    uintx OldPLABSize                               = 1024            {product}
    uintx OldPLABWeight                             = 50              {product}
    uintx OldSize                                   = 4194304         {product}
     bool OmitStackTraceInFastThrow                 = true            {product}
ccstrlist OnError                                   =                 {product}
ccstrlist OnOutOfMemoryError                        =                 {product}
     intx OnStackReplacePercentage                  = 140             {pd product}
     bool OptimizeFill                              = false           {C2 product}
     bool OptimizeMethodHandles                     = true            {diagnostic}
     bool OptimizeStringConcat                      = false           {C2 product}
     bool OptoBundling                              = false           {C2 pd product}
     intx OptoLoopAlignment                         = 16              {pd product}
     bool OptoScheduling                            = false           {C2 pd product}
    uintx PLABWeight                                = 75              {product}
     bool PSChunkLargeArrays                        = true            {product}
     intx ParGCArrayScanChunk                       = 50              {product}
    uintx ParGCDesiredObjsFromOverflowList          = 20              {product}
     bool ParGCTrimOverflow                         = true            {product}
     bool ParGCUseLocalOverflow                     = false           {product}
     intx ParallelGCBufferWastePct                  = 10              {product}
     bool ParallelGCRetainPLAB                      = true            {product}
    uintx ParallelGCThreads                        := 2               {product}
     bool ParallelGCVerbose                         = false           {product}
    uintx ParallelOldDeadWoodLimiterMean            = 50              {product}
    uintx ParallelOldDeadWoodLimiterStdDev          = 80              {product}
     bool ParallelRefProcBalancingEnabled           = true            {product}
     bool ParallelRefProcEnabled                    = false           {product}
     bool PartialPeelAtUnsignedTests                = true            {C2 product}
     bool PartialPeelLoop                           = true            {C2 product}
     intx PartialPeelNewPhiDelta                    = 0               {C2 product}
     bool PauseAtStartup                            = false           {diagnostic}
    ccstr PauseAtStartupFile                        =                 {diagnostic}
    uintx PausePadding                              = 1               {product}
     intx PerBytecodeRecompilationCutoff            = 200             {product}
     intx PerBytecodeTrapLimit                      = 4               {product}
     intx PerMethodRecompilationCutoff              = 400             {product}
     intx PerMethodTrapLimit                        = 100             {product}
     bool PerfAllowAtExitRegistration               = false           {product}
     bool PerfBypassFileSystemCheck                 = false           {product}
     intx PerfDataMemorySize                        = 32768           {product}
     intx PerfDataSamplingInterval                  = 50              {product}
    ccstr PerfDataSaveFile                          =                 {product}
     bool PerfDataSaveToFile                        = false           {product}
     bool PerfDisableSharedMem                      = false           {product}
     intx PerfMaxStringConstLength                  = 1024            {product}
    uintx PermGenPadding                            = 3               {product}
    uintx PermMarkSweepDeadRatio                    = 20              {product}
    uintx PermSize                                  = 16777216        {pd product}
     bool PostSpinYield                             = true            {product}
     intx PreBlockSpin                              = 10              {product}
     intx PreInflateSpin                            = 10              {pd product}
     bool PreSpinYield                              = false           {product}
     bool PreferInterpreterNativeStubs              = false           {pd product}
     intx PrefetchCopyIntervalInBytes               = -1              {product}
     intx PrefetchFieldsAhead                       = -1              {product}
     intx PrefetchScanIntervalInBytes               = -1              {product}
     bool PreserveAllAnnotations                    = false           {product}
    uintx PreserveMarkStackSize                     = 1024            {product}
    uintx PretenureSizeThreshold                    = 0               {product}
     bool PrintAdapterHandlers                      = false           {diagnostic}
     bool PrintAdaptiveSizePolicy                   = false           {product}
     bool PrintAssembly                             = false           {diagnostic}
    ccstr PrintAssemblyOptions                      =                 {diagnostic}
     bool PrintBiasedLockingStatistics              = false           {diagnostic}
     bool PrintCMSInitiationStatistics              = false           {product}
     intx PrintCMSStatistics                        = 0               {product}
     bool PrintClassHistogram                       = false           {manageable}
     bool PrintClassHistogramAfterFullGC            = false           {manageable}
     bool PrintClassHistogramBeforeFullGC           = false           {manageable}
     bool PrintCommandLineFlags                     = false           {product}
     bool PrintCompilation                          = false           {product}
     bool PrintCompressedOopsMode                   = false           {diagnostic}
     bool PrintConcurrentLocks                      = false           {manageable}
     bool PrintDTraceDOF                            = false           {diagnostic}
     intx PrintFLSCensus                            = 0               {product}
     intx PrintFLSStatistics                        = 0               {product}
     bool PrintFlagsFinal                          := true            {product}
     bool PrintFlagsInitial                         = false           {product}
     bool PrintGC                                   = false           {manageable}
     bool PrintGCApplicationConcurrentTime          = false           {product}
     bool PrintGCApplicationStoppedTime             = false           {product}
     bool PrintGCDateStamps                         = false           {manageable}
     bool PrintGCDetails                            = false           {manageable}
     bool PrintGCTaskTimeStamps                     = false           {product}
     bool PrintGCTimeStamps                         = false           {manageable}
     bool PrintHeapAtGC                             = false           {product rw}
     bool PrintHeapAtGCExtended                     = false           {product rw}
     bool PrintHeapAtSIGBREAK                       = true            {product}
     bool PrintInlining                             = false           {diagnostic}
     bool PrintInterpreter                          = false           {diagnostic}
     bool PrintIntrinsics                           = false           {diagnostic}
     bool PrintJNIGCStalls                          = false           {product}
     bool PrintJNIResolving                         = false           {product}
     bool PrintNMethods                             = false           {diagnostic}
     bool PrintNativeNMethods                       = false           {diagnostic}
     bool PrintOldPLAB                              = false           {product}
     bool PrintOopAddress                           = false           {product}
     bool PrintPLAB                                 = false           {product}
     bool PrintParallelOldGCPhaseTimes              = false           {product}
     bool PrintPreciseBiasedLockingStatistics       = false           {C2 diagnostic}
     bool PrintPromotionFailure                     = false           {product}
     bool PrintReferenceGC                          = false           {product}
     bool PrintRevisitStats                         = false           {product}
     bool PrintSafepointStatistics                  = false           {product}
     intx PrintSafepointStatisticsCount             = 300             {product}
     intx PrintSafepointStatisticsTimeout           = -1              {product}
     bool PrintSharedSpaces                         = false           {product}
     bool PrintSignatureHandlers                    = false           {diagnostic}
     bool PrintStringTableStatistics                = false           {product}
     bool PrintStubCode                             = false           {diagnostic}
     bool PrintTLAB                                 = false           {product}
     bool PrintTenuringDistribution                 = false           {product}
     bool PrintTieredEvents                         = false           {product}
     bool PrintVMOptions                            = false           {product}
     bool PrintVMQWaitTime                          = false           {product}
     bool PrintWarnings                             = true            {product}
    uintx ProcessDistributionStride                 = 4               {product}
     bool ProfileDynamicTypes                       = true            {diagnostic}
     bool ProfileInterpreter                        = true            {pd product}
     bool ProfileIntervals                          = false           {product}
     intx ProfileIntervalsTicks                     = 100             {product}
     intx ProfileMaturityPercentage                 = 20              {product}
     bool ProfileVM                                 = false           {product}
     bool ProfilerPrintByteCodeStatistics           = false           {product}
     bool ProfilerRecordPC                          = false           {product}
    uintx PromotedPadding                           = 3               {product}
     intx QueuedAllocationWarningCount              = 0               {product}
     bool RangeCheckElimination                     = true            {product}
     intx ReadPrefetchInstr                         = 0               {product}
     intx ReadSpinIterations                        = 100             {product}
     bool ReassociateInvariants                     = true            {C2 product}
     bool ReduceBulkZeroing                         = true            {C2 product}
     bool ReduceFieldZeroing                        = true            {C2 product}
     bool ReduceInitialCardMarks                    = true            {C2 product}
     bool ReduceSignalUsage                         = false           {product}
     intx RefDiscoveryPolicy                        = 0               {product}
     bool ReflectionWrapResolutionErrors            = true            {product}
     bool RegisterFinalizersAtInit                  = true            {product}
     bool RelaxAccessControlCheck                   = false           {product}
     bool RequireSharedSpaces                       = false           {product}
    uintx ReservedCodeCacheSize                     = 50331648        {pd product}
     bool ResizeOldPLAB                             = true            {product}
     bool ResizePLAB                                = true            {product}
     bool ResizeTLAB                                = true            {pd product}
     bool RestoreMXCSROnJNICalls                    = false           {product}
     bool RewriteBytecodes                          = true            {pd product}
     bool RewriteFrequentPairs                      = true            {pd product}
     intx SafepointPollOffset                       = 256             {C1 pd product}
     intx SafepointSpinBeforeYield                  = 2000            {product}
     bool SafepointTimeout                          = false           {product}
     intx SafepointTimeoutDelay                     = 10000           {product}
     bool ScavengeBeforeFullGC                      = true            {product}
     intx ScavengeRootsInCode                       = 0               {diagnostic}
     intx SelfDestructTimer                         = 0               {product}
     bool SerializeVMOutput                         = true            {diagnostic}
    uintx SharedDummyBlockSize                      = 536870912       {product}
    uintx SharedMiscCodeSize                        = 4194304         {product}
    uintx SharedMiscDataSize                        = 4194304         {product}
     bool SharedOptimizeColdStart                   = true            {diagnostic}
    uintx SharedReadOnlySize                        = 10485760        {product}
    uintx SharedReadWriteSize                       = 12582912        {product}
     bool SharedSkipVerify                          = false           {diagnostic}
     bool ShowMessageBoxOnError                     = false           {product}
     intx SoftRefLRUPolicyMSPerMB                   = 1000            {product}
     bool SpecialStringCompareToCC                  = true            {product}
     bool SpecialStringCompress                     = true            {product}
     bool SpecialStringEqualsCC                     = true            {product}
     bool SpecialStringIndexOfCC                    = true            {product}
     bool SpecialStringInflate                      = true            {product}
     bool SplitIfBlocks                             = true            {product}
     intx StackRedPages                             = 1               {pd product}
     intx StackShadowPages                          = 3               {pd product}
     bool StackTraceInThrowable                     = true            {product}
     intx StackYellowPages                          = 2               {pd product}
     bool StartAttachListener                       = false           {product}
     intx StarvationMonitorInterval                 = 200             {product}
     bool StressLdcRewrite                          = false           {product}
     bool StressTieredRuntime                       = false           {product}
    uintx StringTableSize                           = 1009            {product}
     bool SuppressFatalErrorMessage                 = false           {product}
    uintx SurvivorPadding                           = 3               {product}
     intx SurvivorRatio                             = 8               {product}
     intx SuspendRetryCount                         = 50              {product}
     intx SuspendRetryDelay                         = 5               {product}
     intx SyncFlags                                 = 0               {product}
    ccstr SyncKnobs                                 =                 {product}
     intx SyncVerbose                               = 0               {product}
    uintx TLABAllocationWeight                      = 35              {product}
    uintx TLABRefillWasteFraction                   = 64              {product}
    uintx TLABSize                                  = 0               {product}
     bool TLABStats                                 = true            {product}
    uintx TLABWasteIncrement                        = 4               {product}
    uintx TLABWasteTargetPercent                    = 1               {product}
     intx TargetPLABWastePct                        = 10              {product}
     intx TargetSurvivorRatio                       = 50              {product}
    uintx TenuredGenerationSizeIncrement            = 20              {product}
    uintx TenuredGenerationSizeSupplement           = 80              {product}
    uintx TenuredGenerationSizeSupplementDecay      = 2               {product}
     intx ThreadPriorityPolicy                      = 0               {product}
     bool ThreadPriorityVerbose                     = false           {product}
    uintx ThreadSafetyMargin                        = 52428800        {product}
     intx ThreadStackSize                           = 320             {pd product}
    uintx ThresholdTolerance                        = 10              {product}
     intx Tier0BackedgeNotifyFreqLog                = 10              {product}
     intx Tier0InvokeNotifyFreqLog                  = 7               {product}
     intx Tier0ProfilingStartPercentage             = 200             {product}
     intx Tier1FreqInlineSize                       = 35              {C2 product}
     intx Tier1Inline                               = 0               {C2 product}
     intx Tier1LoopOptsCount                        = 0               {C2 product}
     intx Tier1MaxInlineSize                        = 8               {C2 product}
     intx Tier2BackEdgeThreshold                    = 0               {product}
     intx Tier2BackedgeNotifyFreqLog                = 14              {product}
     intx Tier2CompileThreshold                     = 0               {product}
     intx Tier2InvokeNotifyFreqLog                  = 11              {product}
     intx Tier3BackEdgeThreshold                    = 7000            {product}
     intx Tier3BackedgeNotifyFreqLog                = 13              {product}
     intx Tier3CompileThreshold                     = 2000            {product}
     intx Tier3DelayOff                             = 2               {product}
     intx Tier3DelayOn                              = 5               {product}
     intx Tier3InvocationThreshold                  = 200             {product}
     intx Tier3InvokeNotifyFreqLog                  = 10              {product}
     intx Tier3LoadFeedback                         = 5               {product}
     intx Tier3MinInvocationThreshold               = 100             {product}
     intx Tier4BackEdgeThreshold                    = 40000           {product}
     intx Tier4CompileThreshold                     = 15000           {product}
     intx Tier4InvocationThreshold                  = 5000            {product}
     intx Tier4LoadFeedback                         = 3               {product}
     intx Tier4MinInvocationThreshold               = 600             {product}
     bool TieredCompilation                         = false           {pd product}
     intx TieredCompileTaskTimeout                  = 50              {product}
     intx TieredRateUpdateMaxTime                   = 25              {product}
     intx TieredRateUpdateMinTime                   = 1               {product}
     intx TieredStopAtLevel                         = 4               {product}
     bool TimeLinearScan                            = false           {C1 product}
     bool TraceBiasedLocking                        = false           {product}
     bool TraceClassLoading                         = false           {product rw}
     bool TraceClassLoadingPreorder                 = false           {product}
     bool TraceClassResolution                      = false           {product}
     bool TraceClassUnloading                       = false           {product rw}
     bool TraceCompileTriggered                     = false           {diagnostic}
     bool TraceGen0Time                             = false           {product}
     bool TraceGen1Time                             = false           {product}
    ccstr TraceJVMTI                                =                 {product}
     bool TraceJVMTIObjectTagging                   = false           {diagnostic}
     bool TraceLoaderConstraints                    = false           {product rw}
     bool TraceMonitorInflation                     = false           {product}
     bool TraceNMethodInstalls                      = false           {diagnostic}
     bool TraceOSRBreakpoint                        = false           {diagnostic}
     bool TraceParallelOldGCTasks                   = false           {product}
     intx TraceRedefineClasses                      = 0               {product}
     bool TraceRedundantCompiles                    = false           {diagnostic}
     bool TraceSafepointCleanupTime                 = false           {product}
     bool TraceSuperWord                            = false           {C2 product}
     bool TraceSuspendWaitFailures                  = false           {product}
     bool TraceTriggers                             = false           {diagnostic}
     intx TrackedInitializationLimit                = 50              {C2 product}
     intx TypeProfileMajorReceiverPercent           = 90              {product}
     intx TypeProfileWidth                          = 2               {product}
     intx UnguardOnExecutionViolation               = 0               {product}
     bool UnlockDiagnosticVMOptions                := true            {diagnostic}
     bool UnsyncloadClass                           = false           {diagnostic}
     bool Use486InstrsOnly                          = false           {product}
     bool UseAdaptiveGCBoundary                     = false           {product}
     bool UseAdaptiveGenerationSizePolicyAtMajorCollection  = true            {product}
     bool UseAdaptiveGenerationSizePolicyAtMinorCollection  = true            {product}
     bool UseAdaptiveNUMAChunkSizing                = true            {product}
     bool UseAdaptiveSizeDecayMajorGCCost           = true            {product}
     bool UseAdaptiveSizePolicy                     = true            {product}
     bool UseAdaptiveSizePolicyFootprintGoal        = true            {product}
     bool UseAdaptiveSizePolicyWithSystemGC         = false           {product}
     bool UseAddressNop                             = true            {product}
     bool UseAltSigs                                = false           {product}
     bool UseAutoGCSelectPolicy                     = false           {product}
     bool UseBiasedLocking                          = true            {product}
     bool UseBimorphicInlining                      = true            {C2 product}
     bool UseBoundThreads                           = true            {product}
     bool UseCMSBestFit                             = true            {product}
     bool UseCMSCollectionPassing                   = true            {product}
     bool UseCMSCompactAtFullCollection             = true            {product}
     bool UseCMSInitiatingOccupancyOnly             = false           {product}
     bool UseCodeCacheFlushing                      = false           {product}
     bool UseCompiler                               = true            {product}
     bool UseCompilerSafepoints                     = true            {product}
     bool UseCompressedStrings                      = false           {product}
     bool UseConcMarkSweepGC                        = false           {product}
     bool UseCountLeadingZerosInstruction           = false           {product}
     bool UseCounterDecay                           = true            {product}
     bool UseDivMod                                 = true            {C2 product}
     bool UseFPUForSpilling                         = false           {C2 product}
     bool UseFastAccessorMethods                    = true            {product}
     bool UseFastEmptyMethods                       = true            {product}
     bool UseFastJNIAccessors                       = true            {product}
     bool UseG1GC                                   = false           {product}
     bool UseGCLogFileRotation                      = false           {product}
     bool UseGCOverheadLimit                        = true            {product}
     bool UseGCTaskAffinity                         = false           {product}
     bool UseHeavyMonitors                          = false           {product}
     bool UseIncDec                                 = true            {diagnostic}
     bool UseInlineCaches                           = true            {product}
     bool UseInterpreter                            = true            {product}
     bool UseJumpTables                             = true            {C2 product}
     bool UseLWPSynchronization                     = true            {product}
     bool UseLargePages                             = false           {pd product}
     bool UseLargePagesIndividualAllocation         = false           {pd product}
     bool UseLinuxPosixThreadCPUClocks              = false           {product}
     bool UseLoopCounter                            = true            {product}
     bool UseLoopPredicate                          = true            {C2 product}
     bool UseMaximumCompactionOnSystemGC            = true            {product}
     bool UseMembar                                 = false           {pd product}
     bool UseNUMA                                   = false           {product}
     bool UseNewCode                                = false           {diagnostic}
     bool UseNewCode2                               = false           {diagnostic}
     bool UseNewCode3                               = false           {diagnostic}
     bool UseNewLongLShift                          = false           {product}
     bool UseNiagaraInstrs                          = false           {product}
     bool UseOSErrorReporting                       = false           {pd product}
     bool UseOldInlining                            = true            {C2 product}
     bool UseOnStackReplacement                     = true            {pd product}
     bool UseOnlyInlinedBimorphic                   = true            {C2 product}
     bool UseOprofile                               = false           {product}
     bool UseOptoBiasInlining                       = true            {C2 product}
     bool UsePPCLWSYNC                              = true            {product}
     bool UsePSAdaptiveSurvivorSizePolicy           = true            {product}
     bool UseParNewGC                               = false           {product}
     bool UseParallelDensePrefixUpdate              = true            {product}
     bool UseParallelGC                            := true            {product}
     bool UseParallelOldGC                          = false           {product}
     bool UseParallelOldGCCompacting                = true            {product}
     bool UseParallelOldGCDensePrefix               = true            {product}
     bool UsePerfData                               = true            {product}
     bool UsePopCountInstruction                    = false           {product}
     bool UseRDPCForConstantTableBase               = false           {C2 product}
     intx UseSSE                                    = 3               {product}
     bool UseSSE42Intrinsics                        = false           {product}
     bool UseSerialGC                               = false           {product}
     bool UseSharedSpaces                           = false           {product}
     bool UseSignalChaining                         = true            {product}
     bool UseSpinning                               = false           {product}
     bool UseSplitVerifier                          = true            {product}
     bool UseStoreImmI16                            = false           {product}
     bool UseStringCache                            = false           {product}
     bool UseSuperWord                              = true            {C2 product}
     bool UseTLAB                                   = true            {pd product}
     bool UseThreadPriorities                       = true            {pd product}
     bool UseTypeProfile                            = true            {product}
     bool UseUnalignedLoadStores                    = false           {product}
     bool UseVMInterruptibleIO                      = true            {product}
     bool UseVectoredExceptions                     = false           {pd product}
     bool UseXMMForArrayCopy                        = true            {product}
     bool UseXmmI2D                                 = false           {product}
     bool UseXmmI2F                                 = false           {product}
     bool UseXmmLoadAndClearUpper                   = true            {product}
     bool UseXmmRegToRegMoveAll                     = true            {product}
     bool VMThreadHintNoPreempt                     = false           {product}
     intx VMThreadPriority                          = -1              {product}
     intx VMThreadStackSize                         = 512             {pd product}
     intx ValueMapInitialSize                       = 11              {C1 product}
     intx ValueMapMaxLoopSize                       = 8               {C1 product}
     intx ValueSearchLimit                          = 1000            {C2 product}
     bool VerifyAfterGC                             = false           {diagnostic}
     bool VerifyBeforeExit                          = false           {diagnostic}
     bool VerifyBeforeGC                            = false           {diagnostic}
     bool VerifyBeforeIteration                     = false           {diagnostic}
     bool VerifyDuringGC                            = false           {diagnostic}
     intx VerifyGCLevel                             = 0               {diagnostic}
    uintx VerifyGCStartAt                           = 0               {diagnostic}
     bool VerifyMergedCPBytecodes                   = true            {product}
     bool VerifyMethodHandles                       = false           {diagnostic}
     bool VerifyObjectStartArray                    = true            {diagnostic}
     bool VerifyRememberedSets                      = false           {diagnostic}
     intx WorkAroundNPTLTimedWaitHang               = 1               {product}
    uintx YoungGenerationSizeIncrement              = 20              {product}
    uintx YoungGenerationSizeSupplement             = 80              {product}
    uintx YoungGenerationSizeSupplementDecay        = 8               {product}
    uintx YoungPLABSize                             = 4096            {product}
     bool ZeroTLAB                                  = false           {product}
     intx hashCode                                  = 0               {product}