Merge lp:~pbeaman/akiban-persistit/better_4hour_tpcc_2 into lp:akiban-persistit

[Peter Beaman]

This branch solves several problems relating to Journal I/O, pruning and performance.

Specifically, when running the 4-hour TPCC test on a particular server, perf02, the "terminal" threads outrun the ability of the JOURNAL_COPIER thread to remove obsolete journal files. The result is an ever-growing collection of journal files that eventually overflow the disk. The distinguishing feature of perf02 is that it has 12 fast cores (x2 with hyper-threading) but just a single disk drive.

This branch keeps the number of journal files under control during the test (never exceeding 16) and allows the test to complete. The test arrives at a stable configuration after a couple of hours and there's no reason to believe it would fail if run for much longer periods of time. However, a longer test run has not yet been completed.

Major changes:

1) The Transaction#commit() method now includes a call to new method JournalManager#throttle() which imposes a voluntary delay if the JournalCopier#urgency() value becomes large. The delay adjusts upward when urgency becomes extreme.

2) The order in which commit() completes its actions has changed to:

   flush()
   notifyComplete();
   throttle();
   waitForDurability();

Further, durability is measured from a timestamp taken immediately after the call to flush().

It is safe to call notifyComplete() and allow other concurrent transactions to continue (thereby hopefully allowing more transactions to join a GROUP commit). It is safe because no other transaction released by notifyComplete() can commit and become durable unless this one is also durable.

3) Pruning is accelerated, preventing old aborted transactions from holding up the JOURNAL_COPIER cleanup process. There are two main changes to support faster pruning:

3a) Scheduling: the CLEANUP_MANAGER normally polls once per second, but when the queue becomes more than half full it now runs continuously until the queue is no longer half full.

3b) Prune on write: when a dirty page thats needs pruning is being written to disk, a new optional code path prunes it before writing it. This reduces the likelihood that a page that is read back in from disk will need to be pruned.

Other changes made while analyzing test runs include updates in the IOMeter log function, and small fixes in the CLI.

One source a many lines of diff output is that to enable a new test the PersistitUnitTestCase class was moved from com.persistit.unit to com.persistit. In a future proposal I intend to move all of the unit tests to the correct package (same package as the class they are testing) and get rid of TestShim.

Due to the large size of this proposal, it not be approved until after Akiban Server 1.4.0 - and for that reason perhaps deserves a new version number, which is not in the current proposal.

This branch depends on the eclipse-canonical-format branch to reduce the number of format-only diffs.

[lp:~pbeaman/akiban-persistit/better_4hour_tpcc_2]

370. By Peter Beaman on 2012-08-24

Merge from release-notes-3.16

371. By Peter Beaman on 2012-08-28

Merge from trunk, modify according to review comments.

372. By Peter Beaman on 2012-08-28

One more review comment.

373. By Peter Beaman on 2012-08-28

Remove extraneous eclipse-format file

Unmerged revisions

=== modified file 'doc/Configuration.rst'
--- doc/Configuration.rst	2012-06-11 21:25:37 +0000
+++ doc/Configuration.rst	2012-08-24 18:21:22 +0000
@@ -221,7 +221,7 @@
   ``serialOverride``, ``constructorOverride``: (``com.persistit.Configuration#setSerialOverride`` ``com.persistit.Configuration#setConstructorOverride``) 
       Control aspects of object serialization. See :ref:`Serialization`.
 
-  ``showgui``: (``com.persistit.Configuration#setShowGUI``), True of False.  
+  ``showgui``: (``com.persistit.Configuration#setShowGUI``), True or False (default).  
       If true, Persistit attempts to create and display an instance of the AdminUI utility panel within the current JVM. 
       Alternatively, AdminUI uses RMI and can be launched and run remotely if ``rmiport`` or ``rmihost`` has been 
       specified.
@@ -231,6 +231,18 @@
       install a logging adapter to reroute messages through Log4J, SLF4J or other logger. The ``logfile`` property is used 
       only when no adapter has been installed.
 
+  ``bufferinventory``: (``com.persistit.Configuration#setBufferInventoryEnabled``), True or False (default).
+      If true, Persistit periodically records an inventory of all the buffes in the buffers pools to the System Volume. The inventory
+      enables Persistit to preload the buffer pools then next time it starts up with approximately the same pages that were present
+      before shutdown. To enable buffer preloading, the bufferpreload property must also be true.
+      
+  ``bufferpreload``: (``com.persistit.Configuration#setBufferPreloadEnabled``), True or False (default).
+      If true, and if a buffer pool inventory was previously recorded, Persistit attempts to "warm up" the buffer pool
+      by preloading pages that were present in the buffer pool when Persistit last shut down. This may allow a freshly started
+      Persistit instance to begin service a workload similar to what it had previously been processing without incurring the
+      cost of many random disk reads to load pages.
+        
+
 For all integer-valued properties, the suffix “K” may be used to represent kilo, “M” for mega, “G” for giga and “T” for tera. For example, “2M” represents the value 2,097,152.
 
 A Configuration Example

=== modified file 'doc/ReleaseNotes.rst'
--- doc/ReleaseNotes.rst	2012-08-06 14:43:42 +0000
+++ doc/ReleaseNotes.rst	2012-08-24 18:21:22 +0000
@@ -44,6 +44,26 @@
 |
 |
 
+
+************************************
+3.1.6
+************************************
+
+Release Date
+============
+August 24, 2012
+
+Overview
+========
+This version of Persistit fixes one bug.
+
+Fixed Issues
+============
+
+https://bugs.launchpad.net/akiban-persistit/+bug/1036422
+
+With CommitPolicy HARD we observed a CPU-soaking loop in the commit logic.
+
 ************************************
 3.1.5
 ************************************

=== added file 'eclipse-format.xml'
--- eclipse-format.xml	1970-01-01 00:00:00 +0000
+++ eclipse-format.xml	2012-08-24 18:21:22 +0000
@@ -0,0 +1,72 @@
+<!--
+
+    Copyright © 2011-2012 Akiban Technologies, Inc.  All rights reserved.
+    
+    This program and the accompanying materials are made available
+    under the terms of the Eclipse Public License v1.0 which
+    accompanies this distribution, and is available at
+    http://www.eclipse.org/legal/epl-v10.html
+    
+    This program may also be available under different license terms.
+    For more information, see www.akiban.com or contact [e-mail].
+    
+    Contributors:
+    Akiban Technologies, Inc.
+
+-->
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<profiles version="2">
+<profile kind="CleanUpProfile" name="Akiban-Persistit" version="2">
+<setting id="cleanup.format_source_code" value="true"/>
+<setting id="cleanup.add_missing_annotations" value="true"/>
+<setting id="cleanup.use_this_for_non_static_method_access_only_if_necessary" value="true"/>
+<setting id="cleanup.remove_unused_private_types" value="true"/>
+<setting id="cleanup.qualify_static_member_accesses_through_instances_with_declaring_class" value="true"/>
+<setting id="cleanup.qualify_static_method_accesses_with_declaring_class" value="false"/>
+<setting id="cleanup.add_generated_serial_version_id" value="false"/>
+<setting id="cleanup.make_variable_declarations_final" value="true"/>
+<setting id="cleanup.add_missing_methods" value="false"/>
+<setting id="cleanup.always_use_this_for_non_static_field_access" value="false"/>
+<setting id="cleanup.remove_trailing_whitespaces_ignore_empty" value="false"/>
+<setting id="cleanup.correct_indentation" value="true"/>
+<setting id="cleanup.never_use_parentheses_in_expressions" value="true"/>
+<setting id="cleanup.add_serial_version_id" value="false"/>
+<setting id="cleanup.remove_unused_private_methods" value="true"/>
+<setting id="cleanup.use_this_for_non_static_field_access" value="false"/>
+<setting id="cleanup.use_blocks_only_for_return_and_throw" value="false"/>
+<setting id="cleanup.remove_unused_private_members" value="false"/>
+<setting id="cleanup.add_missing_override_annotations_interface_methods" value="true"/>
+<setting id="cleanup.remove_trailing_whitespaces_all" value="true"/>
+<setting id="cleanup.make_type_abstract_if_missing_method" value="false"/>
+<setting id="cleanup.always_use_this_for_non_static_method_access" value="false"/>
+<setting id="cleanup.remove_unnecessary_nls_tags" value="true"/>
+<setting id="cleanup.format_source_code_changes_only" value="false"/>
+<setting id="cleanup.qualify_static_field_accesses_with_declaring_class" value="false"/>
+<setting id="cleanup.add_missing_nls_tags" value="false"/>
+<setting id="cleanup.use_this_for_non_static_field_access_only_if_necessary" value="true"/>
+<setting id="cleanup.qualify_static_member_accesses_through_subtypes_with_declaring_class" value="false"/>
+<setting id="cleanup.remove_unnecessary_casts" value="true"/>
+<setting id="cleanup.qualify_static_member_accesses_with_declaring_class" value="true"/>
+<setting id="cleanup.use_parentheses_in_expressions" value="false"/>
+<setting id="cleanup.remove_unused_private_fields" value="true"/>
+<setting id="cleanup.make_parameters_final" value="true"/>
+<setting id="cleanup.remove_trailing_whitespaces" value="true"/>
+<setting id="cleanup.remove_unused_imports" value="true"/>
+<setting id="cleanup.organize_imports" value="true"/>
+<setting id="cleanup.sort_members" value="false"/>
+<setting id="cleanup.remove_private_constructors" value="true"/>
+<setting id="cleanup.convert_to_enhanced_for_loop" value="false"/>
+<setting id="cleanup.always_use_blocks" value="true"/>
+<setting id="cleanup.never_use_blocks" value="false"/>
+<setting id="cleanup.always_use_parentheses_in_expressions" value="false"/>
+<setting id="cleanup.use_this_for_non_static_method_access" value="false"/>
+<setting id="cleanup.remove_unused_local_variables" value="false"/>
+<setting id="cleanup.make_private_fields_final" value="true"/>
+<setting id="cleanup.add_missing_deprecated_annotations" value="true"/>
+<setting id="cleanup.add_default_serial_version_id" value="true"/>
+<setting id="cleanup.sort_members_all" value="false"/>
+<setting id="cleanup.use_blocks" value="false"/>
+<setting id="cleanup.add_missing_override_annotations" value="true"/>
+<setting id="cleanup.make_local_variable_final" value="true"/>
+</profile>
+</profiles>

=== modified file 'pom.xml'
--- pom.xml	2012-08-07 21:11:28 +0000
+++ pom.xml	2012-08-24 18:21:22 +0000
@@ -82,6 +82,14 @@
         </dependency>
     </dependencies>
 
+    <pluginRepositories>
+        <pluginRepository>
+            <id>maven-java-formatter-plugin</id>
+            <name>Maven2 Java Formatter Plugin repository</name>
+            <url>https://raw.github.com/benalexau/maven-java-formatter-plugin/master/releases/</url>
+        </pluginRepository>
+    </pluginRepositories>
+
     <build>
         <finalName>${project.artifactId}-${project.version}${BZR_REVISION}</finalName>
         <resources>
@@ -256,6 +264,7 @@
                         <exclude>.project</exclude>
                         <exclude>.classpath</exclude>
                         <exclude>.bzrignore</exclude>
+                        <exclude>src/etc/eclipse*.xml</exclude>
                         <!-- Other -->
                         <exclude>LICENSE.txt</exclude>
                     </excludes>
@@ -273,6 +282,21 @@
                 <artifactId>maven-eclipse-plugin</artifactId>
                 <version>2.6</version>
             </plugin>
+            <plugin>
+                <groupId>com.googlecode.maven-java-formatter-plugin</groupId>
+                <artifactId>maven-java-formatter-plugin</artifactId>
+                <version>0.4.0.e371sr1</version>
+                <configuration>
+                    <configFile>${project.basedir}/src/etc/eclipse-format-config.xml</configFile>
+                </configuration>
+                <executions>
+                    <execution>
+                        <goals>
+                            <goal>format</goal>
+                        </goals>
+                    </execution>
+                </executions>
+            </plugin>
         </plugins>
         <pluginManagement>
             <plugins>
@@ -324,6 +348,19 @@
                                         <ignore />
                                     </action>
                                 </pluginExecution>
+                                <pluginExecution>
+                                    <pluginExecutionFilter>
+                                        <groupId>com.googlecode.maven-java-formatter-plugin</groupId>
+                                        <artifactId>maven-java-formatter-plugin</artifactId>
+                                        <versionRange>[0.4.0.e371sr1,)</versionRange>
+                                        <goals>
+                                            <goal>format</goal>
+                                        </goals>
+                                    </pluginExecutionFilter>
+                                    <action>
+                                        <ignore></ignore>
+                                    </action>
+                                </pluginExecution>
                             </pluginExecutions>
                         </lifecycleMappingMetadata>
                     </configuration>
@@ -331,7 +368,6 @@
             </plugins>
         </pluginManagement>
     </build>
-
     <reporting>
         <plugins>
             <plugin>

=== added file 'src/etc/eclipse-cleanup-config.xml'
--- src/etc/eclipse-cleanup-config.xml	1970-01-01 00:00:00 +0000
+++ src/etc/eclipse-cleanup-config.xml	2012-08-24 18:21:22 +0000
@@ -0,0 +1,56 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<profiles version="2">
+<profile kind="CleanUpProfile" name="Akiban-Persistit" version="2">
+<setting id="cleanup.format_source_code" value="true"/>
+<setting id="cleanup.add_missing_annotations" value="true"/>
+<setting id="cleanup.use_this_for_non_static_method_access_only_if_necessary" value="true"/>
+<setting id="cleanup.remove_unused_private_types" value="true"/>
+<setting id="cleanup.qualify_static_member_accesses_through_instances_with_declaring_class" value="true"/>
+<setting id="cleanup.qualify_static_method_accesses_with_declaring_class" value="false"/>
+<setting id="cleanup.add_generated_serial_version_id" value="false"/>
+<setting id="cleanup.make_variable_declarations_final" value="true"/>
+<setting id="cleanup.add_missing_methods" value="false"/>
+<setting id="cleanup.always_use_this_for_non_static_field_access" value="false"/>
+<setting id="cleanup.remove_trailing_whitespaces_ignore_empty" value="false"/>
+<setting id="cleanup.correct_indentation" value="true"/>
+<setting id="cleanup.never_use_parentheses_in_expressions" value="true"/>
+<setting id="cleanup.add_serial_version_id" value="false"/>
+<setting id="cleanup.remove_unused_private_methods" value="true"/>
+<setting id="cleanup.use_this_for_non_static_field_access" value="false"/>
+<setting id="cleanup.use_blocks_only_for_return_and_throw" value="false"/>
+<setting id="cleanup.remove_unused_private_members" value="false"/>
+<setting id="cleanup.add_missing_override_annotations_interface_methods" value="true"/>
+<setting id="cleanup.remove_trailing_whitespaces_all" value="true"/>
+<setting id="cleanup.make_type_abstract_if_missing_method" value="false"/>
+<setting id="cleanup.always_use_this_for_non_static_method_access" value="false"/>
+<setting id="cleanup.remove_unnecessary_nls_tags" value="true"/>
+<setting id="cleanup.format_source_code_changes_only" value="false"/>
+<setting id="cleanup.qualify_static_field_accesses_with_declaring_class" value="false"/>
+<setting id="cleanup.add_missing_nls_tags" value="false"/>
+<setting id="cleanup.use_this_for_non_static_field_access_only_if_necessary" value="true"/>
+<setting id="cleanup.qualify_static_member_accesses_through_subtypes_with_declaring_class" value="false"/>
+<setting id="cleanup.remove_unnecessary_casts" value="true"/>
+<setting id="cleanup.qualify_static_member_accesses_with_declaring_class" value="true"/>
+<setting id="cleanup.use_parentheses_in_expressions" value="false"/>
+<setting id="cleanup.remove_unused_private_fields" value="true"/>
+<setting id="cleanup.make_parameters_final" value="true"/>
+<setting id="cleanup.remove_trailing_whitespaces" value="true"/>
+<setting id="cleanup.remove_unused_imports" value="true"/>
+<setting id="cleanup.organize_imports" value="true"/>
+<setting id="cleanup.sort_members" value="false"/>
+<setting id="cleanup.remove_private_constructors" value="true"/>
+<setting id="cleanup.convert_to_enhanced_for_loop" value="false"/>
+<setting id="cleanup.always_use_blocks" value="true"/>
+<setting id="cleanup.never_use_blocks" value="false"/>
+<setting id="cleanup.always_use_parentheses_in_expressions" value="false"/>
+<setting id="cleanup.use_this_for_non_static_method_access" value="false"/>
+<setting id="cleanup.remove_unused_local_variables" value="false"/>
+<setting id="cleanup.make_private_fields_final" value="true"/>
+<setting id="cleanup.add_missing_deprecated_annotations" value="true"/>
+<setting id="cleanup.add_default_serial_version_id" value="true"/>
+<setting id="cleanup.sort_members_all" value="false"/>
+<setting id="cleanup.use_blocks" value="false"/>
+<setting id="cleanup.add_missing_override_annotations" value="true"/>
+<setting id="cleanup.make_local_variable_final" value="true"/>
+</profile>
+</profiles>

=== added file 'src/etc/eclipse-format-config.xml'
--- src/etc/eclipse-format-config.xml	1970-01-01 00:00:00 +0000
+++ src/etc/eclipse-format-config.xml	2012-08-24 18:21:22 +0000
@@ -0,0 +1,291 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<profiles version="12">
+<profile kind="CodeFormatterProfile" name="Akiban-code-format" version="12">
+<setting id="org.eclipse.jdt.core.formatter.comment.insert_new_line_before_root_tags" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.disabling_tag" value="@formatter:off"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_annotation" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_type_parameters" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_type_declaration" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_type_arguments" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.brace_position_for_anonymous_type_declaration" value="end_of_line"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_colon_in_case" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_brace_in_array_initializer" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.comment.new_lines_at_block_boundaries" value="true"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_new_line_in_empty_annotation_declaration" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_new_line_before_closing_brace_in_array_initializer" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_annotation" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.blank_lines_before_field" value="0"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_while" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.use_on_off_tags" value="false"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_annotation_type_member_declaration" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_new_line_before_else_in_if_statement" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_prefix_operator" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.keep_else_statement_on_same_line" value="false"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_ellipsis" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.comment.insert_new_line_for_parameter" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_annotation_type_declaration" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.indent_breaks_compare_to_cases" value="true"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_at_in_annotation" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.alignment_for_multiple_fields" value="16"/>
+<setting id="org.eclipse.jdt.core.formatter.alignment_for_expressions_in_array_initializer" value="16"/>
+<setting id="org.eclipse.jdt.core.formatter.alignment_for_conditional_expression" value="80"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_for" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_binary_operator" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_question_in_wildcard" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.brace_position_for_array_initializer" value="end_of_line"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_enum_constant" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_new_line_before_finally_in_try_statement" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_local_variable" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_new_line_before_catch_in_try_statement" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_while" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.blank_lines_after_package" value="1"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_type_parameters" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.continuation_indentation" value="2"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_postfix_operator" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.alignment_for_arguments_in_method_invocation" value="16"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_type_arguments" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_superinterfaces" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.blank_lines_before_new_chunk" value="1"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_binary_operator" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.blank_lines_before_package" value="0"/>
+<setting id="org.eclipse.jdt.core.compiler.source" value="1.7"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_enum_constant_arguments" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_constructor_declaration" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.comment.format_line_comments" value="true"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_closing_angle_bracket_in_type_arguments" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_enum_declarations" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.join_wrapped_lines" value="true"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_block" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.alignment_for_arguments_in_explicit_constructor_call" value="16"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_method_invocation_arguments" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.blank_lines_before_member_type" value="1"/>
+<setting id="org.eclipse.jdt.core.formatter.align_type_members_on_columns" value="false"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_enum_constant" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_for" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_method_declaration" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.alignment_for_selector_in_method_invocation" value="16"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_switch" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_unary_operator" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_colon_in_case" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.comment.indent_parameter_description" value="true"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_method_declaration" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_switch" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_enum_declaration" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_angle_bracket_in_type_parameters" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.comment.clear_blank_lines_in_block_comment" value="false"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_new_line_in_empty_type_declaration" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.lineSplit" value="120"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_if" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_between_brackets_in_array_type_reference" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_parenthesized_expression" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_explicitconstructorcall_arguments" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_constructor_declaration" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.blank_lines_before_first_class_body_declaration" value="0"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_method" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.indentation.size" value="4"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_method_declaration" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.enabling_tag" value="@formatter:on"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_enum_constant" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.alignment_for_superclass_in_type_declaration" value="16"/>
+<setting id="org.eclipse.jdt.core.formatter.alignment_for_assignment" value="0"/>
+<setting id="org.eclipse.jdt.core.compiler.problem.assertIdentifier" value="error"/>
+<setting id="org.eclipse.jdt.core.formatter.tabulation.char" value="space"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_constructor_declaration_parameters" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_semicolon_in_try_resources" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_prefix_operator" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.indent_statements_compare_to_body" value="true"/>
+<setting id="org.eclipse.jdt.core.formatter.blank_lines_before_method" value="1"/>
+<setting id="org.eclipse.jdt.core.formatter.wrap_outer_expressions_when_nested" value="true"/>
+<setting id="org.eclipse.jdt.core.formatter.format_guardian_clause_on_one_line" value="false"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_colon_in_for" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_cast" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.alignment_for_parameters_in_constructor_declaration" value="16"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_colon_in_labeled_statement" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.brace_position_for_annotation_type_declaration" value="end_of_line"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_new_line_in_empty_method_body" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.alignment_for_method_declaration" value="0"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_method_invocation" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_try" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_bracket_in_array_allocation_expression" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_enum_constant" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_annotation" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_at_in_annotation_type_declaration" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_method_declaration_throws" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_if" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.brace_position_for_switch" value="end_of_line"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_method_declaration_throws" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_parenthesized_expression_in_return" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_annotation" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_question_in_conditional" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_question_in_wildcard" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_try" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_bracket_in_array_allocation_expression" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.comment.preserve_white_space_between_code_and_line_comments" value="false"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_parenthesized_expression_in_throw" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_type_arguments" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.compiler.problem.enumIdentifier" value="error"/>
+<setting id="org.eclipse.jdt.core.formatter.indent_switchstatements_compare_to_switch" value="false"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_ellipsis" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.brace_position_for_block" value="end_of_line"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_for_inits" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.brace_position_for_method_declaration" value="end_of_line"/>
+<setting id="org.eclipse.jdt.core.formatter.compact_else_if" value="true"/>
+<setting id="org.eclipse.jdt.core.formatter.wrap_before_or_operator_multicatch" value="true"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_array_initializer" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_for_increments" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.format_line_comment_starting_on_first_column" value="true"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_bracket_in_array_reference" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_field" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.brace_position_for_enum_constant" value="end_of_line"/>
+<setting id="org.eclipse.jdt.core.formatter.comment.indent_root_tags" value="true"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_enum_declarations" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.alignment_for_union_type_in_multicatch" value="16"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_explicitconstructorcall_arguments" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_switch" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_method_declaration_parameters" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_superinterfaces" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_allocation_expression" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.tabulation.size" value="4"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_bracket_in_array_type_reference" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_new_line_after_opening_brace_in_array_initializer" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_closing_brace_in_block" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_bracket_in_array_reference" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_new_line_in_empty_enum_constant" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_type_arguments" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_constructor_declaration" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_constructor_declaration_throws" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_if" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.comment.clear_blank_lines_in_javadoc_comment" value="false"/>
+<setting id="org.eclipse.jdt.core.formatter.alignment_for_throws_clause_in_constructor_declaration" value="16"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_assignment_operator" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_assignment_operator" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.indent_empty_lines" value="false"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_synchronized" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_closing_paren_in_cast" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_method_declaration_parameters" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.brace_position_for_block_in_case" value="end_of_line"/>
+<setting id="org.eclipse.jdt.core.formatter.number_of_empty_lines_to_preserve" value="1"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_method_declaration" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_catch" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_constructor_declaration" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_method_invocation" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_bracket_in_array_reference" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.alignment_for_arguments_in_qualified_allocation_expression" value="16"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_and_in_type_parameter" value="insert"/>
+<setting id="org.eclipse.jdt.core.compiler.compliance" value="1.7"/>
+<setting id="org.eclipse.jdt.core.formatter.continuation_indentation_for_array_initializer" value="2"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_between_empty_brackets_in_array_allocation_expression" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_at_in_annotation_type_declaration" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.alignment_for_arguments_in_allocation_expression" value="16"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_cast" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_unary_operator" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_parameterized_type_reference" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_anonymous_type_declaration" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.keep_empty_array_initializer_on_one_line" value="false"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_new_line_in_empty_enum_declaration" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.keep_imple_if_on_one_line" value="false"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_constructor_declaration_parameters" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_closing_angle_bracket_in_type_parameters" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_new_line_at_end_of_file_if_missing" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_colon_in_for" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_colon_in_labeled_statement" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_parameterized_type_reference" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.alignment_for_superinterfaces_in_type_declaration" value="16"/>
+<setting id="org.eclipse.jdt.core.formatter.alignment_for_binary_expression" value="16"/>
+<setting id="org.eclipse.jdt.core.formatter.brace_position_for_enum_declaration" value="end_of_line"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_type" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_while" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode" value="enabled"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_try" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.put_empty_statement_on_new_line" value="true"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_new_line_after_label" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_parameter" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_type_parameters" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_method_invocation" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_new_line_before_while_in_do_statement" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.alignment_for_arguments_in_enum_constant" value="16"/>
+<setting id="org.eclipse.jdt.core.formatter.comment.format_javadoc_comments" value="true"/>
+<setting id="org.eclipse.jdt.core.formatter.comment.line_length" value="80"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_package" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.blank_lines_between_import_groups" value="1"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_enum_constant_arguments" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_semicolon" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.brace_position_for_constructor_declaration" value="end_of_line"/>
+<setting id="org.eclipse.jdt.core.formatter.number_of_blank_lines_at_beginning_of_method_body" value="0"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_colon_in_conditional" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_type_header" value="true"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_annotation_type_member_declaration" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.wrap_before_binary_operator" value="true"/>
+<setting id="org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_enum_declaration_header" value="true"/>
+<setting id="org.eclipse.jdt.core.formatter.blank_lines_between_type_declarations" value="1"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_synchronized" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.indent_statements_compare_to_block" value="true"/>
+<setting id="org.eclipse.jdt.core.formatter.alignment_for_superinterfaces_in_enum_declaration" value="16"/>
+<setting id="org.eclipse.jdt.core.formatter.join_lines_in_comments" value="true"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_question_in_conditional" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_multiple_field_declarations" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.alignment_for_compact_if" value="16"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_for_inits" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.indent_switchstatements_compare_to_cases" value="true"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_array_initializer" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_colon_in_default" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_and_in_type_parameter" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_constructor_declaration" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.blank_lines_before_imports" value="1"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_colon_in_assert" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.comment.format_html" value="true"/>
+<setting id="org.eclipse.jdt.core.formatter.alignment_for_throws_clause_in_method_declaration" value="16"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_type_parameters" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_bracket_in_array_allocation_expression" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_new_line_in_empty_anonymous_type_declaration" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_colon_in_conditional" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_parameterized_type_reference" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_for" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_postfix_operator" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.comment.format_source_code" value="true"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_synchronized" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_allocation_expression" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_constructor_declaration_throws" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.alignment_for_parameters_in_method_declaration" value="16"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_brace_in_array_initializer" value="insert"/>
+<setting id="org.eclipse.jdt.core.compiler.codegen.targetPlatform" value="1.7"/>
+<setting id="org.eclipse.jdt.core.formatter.alignment_for_resources_in_try" value="80"/>
+<setting id="org.eclipse.jdt.core.formatter.use_tabs_only_for_leading_indentations" value="false"/>
+<setting id="org.eclipse.jdt.core.formatter.alignment_for_arguments_in_annotation" value="0"/>
+<setting id="org.eclipse.jdt.core.formatter.comment.format_header" value="false"/>
+<setting id="org.eclipse.jdt.core.formatter.comment.format_block_comments" value="true"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_enum_constant" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.alignment_for_enum_constants" value="0"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_new_line_in_empty_block" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_annotation_declaration_header" value="true"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_parenthesized_expression" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_parenthesized_expression" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_catch" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_multiple_local_declarations" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_switch" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_for_increments" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_method_invocation" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_colon_in_assert" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.brace_position_for_type_declaration" value="end_of_line"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_array_initializer" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_between_empty_braces_in_array_initializer" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_method_declaration" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_semicolon_in_for" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_catch" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_angle_bracket_in_parameterized_type_reference" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_multiple_field_declarations" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_annotation" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_parameterized_type_reference" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_method_invocation_arguments" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.comment.new_lines_at_javadoc_boundaries" value="true"/>
+<setting id="org.eclipse.jdt.core.formatter.blank_lines_after_imports" value="1"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_multiple_local_declarations" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_enum_constant_header" value="true"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_semicolon_in_for" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.never_indent_line_comments_on_first_column" value="false"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_semicolon_in_try_resources" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_angle_bracket_in_type_arguments" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.never_indent_block_comments_on_first_column" value="false"/>
+<setting id="org.eclipse.jdt.core.formatter.keep_then_statement_on_same_line" value="false"/>
+</profile>
+</profiles>

=== modified file 'src/main/java/com/persistit/Accumulator.java'
--- src/main/java/com/persistit/Accumulator.java	2012-08-02 04:45:28 +0000
+++ src/main/java/com/persistit/Accumulator.java	2012-08-24 18:21:22 +0000
@@ -97,10 +97,10 @@
     final static Comparator<Accumulator> SORT_COMPARATOR = new Comparator<Accumulator>() {
 
         @Override
-        public int compare(Accumulator a, Accumulator b) {
+        public int compare(final Accumulator a, final Accumulator b) {
             final String treeNameA = a.getTree() == null ? "" : a.getTree().getName();
             final String treeNameB = b.getTree() == null ? "" : b.getTree().getName();
-            int compare = treeNameA.compareTo(treeNameB);
+            final int compare = treeNameA.compareTo(treeNameB);
             if (compare != 0) {
                 return compare;
             } else {
@@ -144,7 +144,7 @@
      * longer present in live TransactionStatus objects. This array has one
      * element per TransactionIndexBucket.
      */
-    private long[] _bucketValues;
+    private final long[] _bucketValues;
 
     /*
      * Object held on the accumulators list in {@link Persistit}. An
@@ -374,7 +374,7 @@
         }
 
         Accumulator takeCheckpointRef() {
-            Accumulator result = _checkpointRef;
+            final Accumulator result = _checkpointRef;
             _checkpointRef = null;
             return result;
         }
@@ -551,7 +551,7 @@
     long getSnapshotValue(final long timestamp, final int step) throws PersistitInterruptedException {
         try {
             return _transactionIndex.getAccumulatorSnapshot(this, timestamp, step, _baseValue);
-        } catch (InterruptedException ie) {
+        } catch (final InterruptedException ie) {
             throw new PersistitInterruptedException(ie);
         }
     }
@@ -588,6 +588,7 @@
     /**
      * Update the Accumulator by contributing a value. The contribution is
      * immediately accumulated into the live value, and it is also posted with a
+     * 
      * @{link {@link Delta} instance to the supplied {@link Transaction}.
      * 
      * @param value
@@ -636,8 +637,8 @@
      *         values for this <code>Accumulator</code>.
      */
     public String toString() {
-        return String.format("Accumulator(tree=%s index=%d type=%s base=%,d live=%,d)", _tree == null ? "null" : _tree
-                .getName(), _index, getType(), _baseValue, _liveValue.get());
+        return String.format("Accumulator(tree=%s index=%d type=%s base=%,d live=%,d)",
+                _tree == null ? "null" : _tree.getName(), _index, getType(), _baseValue, _liveValue.get());
     }
 
     void store(final Value value) {
@@ -649,8 +650,8 @@
 
     static AccumulatorState getAccumulatorState(final Tree tree, final int index) throws PersistitException {
         final Exchange exchange = tree.getVolume().getStructure().directoryExchange();
-        exchange.clear().append(VolumeStructure.DIRECTORY_TREE_NAME).append(VolumeStructure.TREE_ACCUMULATOR).append(
-                tree.getName()).append(index).fetch();
+        exchange.clear().append(VolumeStructure.DIRECTORY_TREE_NAME).append(VolumeStructure.TREE_ACCUMULATOR)
+                .append(tree.getName()).append(index).fetch();
         if (exchange.getValue().isDefined()) {
             return (AccumulatorState) exchange.getValue().get();
         } else {

=== modified file 'src/main/java/com/persistit/AccumulatorState.java'
--- src/main/java/com/persistit/AccumulatorState.java	2012-08-02 04:45:28 +0000
+++ src/main/java/com/persistit/AccumulatorState.java	2012-08-24 18:21:22 +0000
@@ -15,7 +15,6 @@
 
 package com.persistit;
 
-
 /**
  * State of an accumulator recovered from a checkpoint.
  * 
@@ -48,19 +47,19 @@
     public String toString() {
         return String.format("Accumulator(tree=%s index=%d type=%s value=%,d)", _treeName, _index, _type, _value);
     }
-    
+
     public String getTreeName() {
         return _treeName;
     }
-    
+
     public int getIndex() {
         return _index;
     }
-    
+
     public Accumulator.Type getType() {
         return _type;
     }
-    
+
     public long getValue() {
         return _value;
     }

=== modified file 'src/main/java/com/persistit/AlertMonitor.java'
--- src/main/java/com/persistit/AlertMonitor.java	2012-08-02 04:45:28 +0000
+++ src/main/java/com/persistit/AlertMonitor.java	2012-08-24 18:21:22 +0000
@@ -113,7 +113,7 @@
      */
     public class History {
         private AlertLevel _level = AlertLevel.NORMAL;
-        private List<Event> _eventList = new ArrayList<Event>();
+        private final List<Event> _eventList = new ArrayList<Event>();
         private volatile long _firstEventTime = Long.MAX_VALUE;
         private volatile long _lastWarnLogTime = Long.MIN_VALUE;
         private volatile long _lastErrorLogTime = Long.MIN_VALUE;
@@ -142,7 +142,7 @@
         public String getDetailedHistory() {
             final StringBuilder sb = new StringBuilder();
             synchronized (AlertMonitor.this) {
-                int size = _eventList.size();
+                final int size = _eventList.size();
                 if (_count > 0) {
                     sb.append(String.format(EVENT_FORMAT, 1, format(_firstEvent)));
                     for (int index = _count > size ? 0 : 1; index < size; index++) {
@@ -250,7 +250,7 @@
          *            does nothing unless the interval has elapsed.
          */
         public void poll(final long now, final boolean force) {
-            int count = getCount();
+            final int count = getCount();
             if (count > _reportedCount) {
                 switch (_level) {
                 case ERROR:
@@ -316,7 +316,7 @@
      * event was posted.
      */
     public static class Event {
-        private AlertLevel _level;
+        private final AlertLevel _level;
         private final LogItem _logItem;
         private final Object[] _args;
         private final long _time;
@@ -332,7 +332,7 @@
          * @param args
          *            arguments specific to the <code>LogItem</code>
          */
-        public Event(AlertLevel level, LogItem logItem, Object... args) {
+        public Event(final AlertLevel level, final LogItem logItem, final Object... args) {
             this(level, System.currentTimeMillis(), logItem, args);
         }
 
@@ -349,7 +349,7 @@
          * @param args
          *            arguments specific to the <code>LogItem</code>
          */
-        public Event(AlertLevel level, long time, LogItem logItem, Object... args) {
+        public Event(final AlertLevel level, final long time, final LogItem logItem, final Object... args) {
             _level = level;
             _logItem = logItem;
             _args = args;
@@ -492,7 +492,7 @@
     private volatile long _errorLogTimeInterval = DEFAULT_ERROR_INTERVAL;
     private volatile int _historyLength = DEFAULT_HISTORY_LENGTH;
 
-    private AtomicLong _notificationSequence = new AtomicLong();
+    private final AtomicLong _notificationSequence = new AtomicLong();
     private volatile ObjectName _objectName;
 
     /**
@@ -533,7 +533,7 @@
      *            A String describing the nature of the event. A separate
      *            event-history is maintained for each unique category.
      */
-    public synchronized final void post(Event event, final String category) {
+    public synchronized final void post(final Event event, final String category) {
         History history = _historyMap.get(category);
         if (history == null) {
             history = new History();
@@ -570,7 +570,7 @@
      *            the interval in milliseconds
      */
     @Override
-    public void setWarnLogTimeInterval(long warnLogTimeInterval) {
+    public void setWarnLogTimeInterval(final long warnLogTimeInterval) {
         Util.rangeCheck(warnLogTimeInterval, MINIMUM_WARN_INTERVAL, MAXIMUM_WARN_INTERVAL);
         _warnLogTimeInterval = warnLogTimeInterval;
     }
@@ -592,7 +592,7 @@
      *            the interval in milliseconds
      */
     @Override
-    public void setErrorLogTimeInterval(long errorLogTimeInterval) {
+    public void setErrorLogTimeInterval(final long errorLogTimeInterval) {
         Util.rangeCheck(errorLogTimeInterval, MINIMUM_ERROR_INTERVAL, MAXIMUM_ERROR_INTERVAL);
         _errorLogTimeInterval = errorLogTimeInterval;
     }
@@ -613,7 +613,7 @@
      * @return the <code>History</code> for that category or <code>null</code>
      *         if the specified category has no <code>History</code>.
      */
-    public synchronized History getHistory(String name) {
+    public synchronized History getHistory(final String name) {
         return _historyMap.get(name);
     }
 
@@ -637,7 +637,7 @@
      *            the historyLength to set
      */
     @Override
-    public synchronized void setHistoryLength(int historyLength) {
+    public synchronized void setHistoryLength(final int historyLength) {
         Util.rangeCheck(historyLength, MINIMUM_HISTORY_LENGTH, MAXIMUM_HISTORY_LENGTH);
         _historyLength = historyLength;
         for (final History history : _historyMap.values()) {
@@ -652,7 +652,7 @@
      * @return List of AlertRecord elements.
      */
     public synchronized AlertRecord[] getAlertRecordArray() {
-        List<AlertRecord> list = new ArrayList<AlertRecord>();
+        final List<AlertRecord> list = new ArrayList<AlertRecord>();
         for (final Map.Entry<String, History> entry : _historyMap.entrySet()) {
             for (final Event event : entry.getValue().getEventList()) {
                 list.add(new AlertRecord(entry.getKey(), event));
@@ -681,7 +681,7 @@
      */
     @Override
     public synchronized String toString() {
-        StringBuilder sb = new StringBuilder();
+        final StringBuilder sb = new StringBuilder();
         for (final Map.Entry<String, History> entry : _historyMap.entrySet()) {
             sb.append(String.format("%12s: %s\n", entry.getKey(), entry.getValue()));
         }
@@ -705,8 +705,8 @@
      */
     @Override
     public synchronized String getDetailedHistory(final String select) {
-        Pattern pattern = Util.pattern(select, true);
-        StringBuilder sb = new StringBuilder();
+        final Pattern pattern = Util.pattern(select, true);
+        final StringBuilder sb = new StringBuilder();
         for (final Map.Entry<String, History> entry : _historyMap.entrySet()) {
             if (pattern.matcher(entry.getKey()).matches()) {
                 sb.append(String.format("%s:\n", entry.getKey()));
@@ -737,10 +737,10 @@
      */
     @Override
     public MBeanNotificationInfo[] getNotificationInfo() {
-        String[] types = new String[] { NOTIFICATION_TYPE };
-        String name = Notification.class.getName();
-        String description = "Alert raised by Akiban PersistIT";
-        MBeanNotificationInfo info = new MBeanNotificationInfo(types, name, description);
+        final String[] types = new String[] { NOTIFICATION_TYPE };
+        final String name = Notification.class.getName();
+        final String description = "Alert raised by Akiban PersistIT";
+        final MBeanNotificationInfo info = new MBeanNotificationInfo(types, name, description);
         return new MBeanNotificationInfo[] { info };
     }
 
@@ -751,7 +751,7 @@
      * 
      * @param history
      */
-    private void log(History history) {
+    private void log(final History history) {
         final Event event = history.getLastEvent();
         if (event != null && event.getLogItem().isEnabled()) {
             if (history.getCount() == 1) {
@@ -767,13 +767,13 @@
      * 
      * @param history
      */
-    private void sendNotification(History history) {
+    private void sendNotification(final History history) {
         final Event event = history.getLastEvent();
         if (event != null && event.getLogItem().isEnabled()) {
-            final String description = LogBase.recurring(event.getLogItem().logMessage(event.getArgs()), history
-                    .getCount(), history.getDuration());
-            Notification notification = new Notification(NOTIFICATION_TYPE, getClass().getName(), _notificationSequence
-                    .incrementAndGet(), description);
+            final String description = LogBase.recurring(event.getLogItem().logMessage(event.getArgs()),
+                    history.getCount(), history.getDuration());
+            final Notification notification = new Notification(NOTIFICATION_TYPE, getClass().getName(),
+                    _notificationSequence.incrementAndGet(), description);
             sendNotification(notification);
         }
     }
@@ -796,7 +796,7 @@
      * @param event
      * @return
      */
-    private String format(Event event) {
+    private String format(final Event event) {
         return event == null ? "null" : event.toString();
     }
 

=== modified file 'src/main/java/com/persistit/AntiValue.java'
--- src/main/java/com/persistit/AntiValue.java	2012-08-02 04:45:28 +0000
+++ src/main/java/com/persistit/AntiValue.java	2012-08-24 18:21:22 +0000
@@ -15,10 +15,10 @@
 
 package com.persistit;
 
+import java.util.Arrays;
+
 import com.persistit.exception.InvalidKeyException;
 
-import java.util.Arrays;
-
 /**
  * Represents the end of a key range to be removed. Used in Transactions.
  * 
@@ -26,29 +26,29 @@
  * @version 1.1
  */
 class AntiValue {
-    private int _elisionCount;
-    private byte[] _bytes;
+    private final int _elisionCount;
+    private final byte[] _bytes;
 
-    AntiValue(int ec, byte[] bytes) {
+    AntiValue(final int ec, final byte[] bytes) {
         _elisionCount = ec;
         _bytes = bytes;
     }
 
-    static void putAntiValue(Value value, Key key1, Key key2) {
-        int elisionCount = key1.firstUniqueByteIndex(key2);
-        int size = key2.getEncodedSize() - elisionCount;
-        byte[] bytes = new byte[size];
+    static void putAntiValue(final Value value, final Key key1, final Key key2) {
+        final int elisionCount = key1.firstUniqueByteIndex(key2);
+        final int size = key2.getEncodedSize() - elisionCount;
+        final byte[] bytes = new byte[size];
         System.arraycopy(key2.getEncodedBytes(), elisionCount, bytes, 0, size);
         value.putAntiValue((short) elisionCount, bytes);
     }
 
-    static void fixUpKeys(Exchange exchange, int elisionCount, byte[] bytes, int offset, int length)
-            throws InvalidKeyException {
-        Key spareKey1 = exchange.getAuxiliaryKey1();
-        Key spareKey2 = exchange.getAuxiliaryKey2();
+    static void fixUpKeys(final Exchange exchange, final int elisionCount, final byte[] bytes, final int offset,
+            final int length) throws InvalidKeyException {
+        final Key spareKey1 = exchange.getAuxiliaryKey1();
+        final Key spareKey2 = exchange.getAuxiliaryKey2();
         spareKey1.copyTo(spareKey2);
-        byte[] baseBytes = spareKey2.getEncodedBytes();
-        int baseSize = spareKey2.getEncodedSize();
+        final byte[] baseBytes = spareKey2.getEncodedBytes();
+        final int baseSize = spareKey2.getEncodedSize();
         if (baseSize < elisionCount || elisionCount + length > Key.MAX_KEY_LENGTH) {
             throw new InvalidKeyException("Key encoding in transaction is invalid");
         }

=== modified file 'src/main/java/com/persistit/BackupTask.java'
--- src/main/java/com/persistit/BackupTask.java	2012-08-02 04:45:28 +0000
+++ src/main/java/com/persistit/BackupTask.java	2012-08-24 18:21:22 +0000
@@ -76,12 +76,13 @@
     private volatile String _backupStatus;
 
     @Cmd("backup")
-    static Task setupTask(@Arg("file|string|Archive file path") String file,
-            @Arg("_flag|a|Start appendOnly mode") boolean start, @Arg("_flag|e|End appendOnly mode") boolean end,
-            @Arg("_flag|c|Request checkpoint before backup") boolean checkpoint,
-            @Arg("_flag|z|Compress output to ZIP format") boolean compressed,
-            @Arg("_flag|f|Emit a list of files that need to be copied") boolean showFiles,
-            @Arg("_flag|y|Copyback pages before starting") boolean copyback) throws Exception {
+    static Task setupTask(@Arg("file|string|Archive file path") final String file,
+            @Arg("_flag|a|Start appendOnly mode") final boolean start,
+            @Arg("_flag|e|End appendOnly mode") final boolean end,
+            @Arg("_flag|c|Request checkpoint before backup") final boolean checkpoint,
+            @Arg("_flag|z|Compress output to ZIP format") final boolean compressed,
+            @Arg("_flag|f|Emit a list of files that need to be copied") final boolean showFiles,
+            @Arg("_flag|y|Copyback pages before starting") final boolean copyback) throws Exception {
         final BackupTask task = new BackupTask();
         task._toFile = file;
         task._start = start;
@@ -103,7 +104,7 @@
     protected void runTask() throws Exception {
         validate();
         final Management management = _persistit.getManagement();
-        boolean wasAppendOnly = management.getJournalInfo().isAppendOnly();
+        final boolean wasAppendOnly = management.getJournalInfo().isAppendOnly();
         if (_checkpoint) {
             postMessage("Waiting for checkpoint", 0);
             final Checkpoint cp = _persistit.checkpoint();
@@ -115,9 +116,9 @@
         }
         if (_copyback && !wasAppendOnly) {
             postMessage("Copying back pages from journal", 0);
-            long start = _persistit.getJournalManager().getCopiedPageCount();
+            final long start = _persistit.getJournalManager().getCopiedPageCount();
             _persistit.copyBackPages();
-            long end = _persistit.getJournalManager().getCopiedPageCount();
+            final long end = _persistit.getJournalManager().getCopiedPageCount();
             postMessage((end - start) + " pages copied", 0);
         }
         try {
@@ -128,7 +129,7 @@
                     doBackup();
                 }
             }
-        } catch (Exception e) {
+        } catch (final Exception e) {
             _backupStatus = "Failed: " + e;
         } finally {
             management.setAppendOnly(_start ? true : _end ? false : wasAppendOnly);
@@ -136,7 +137,7 @@
     }
 
     @Override
-    protected void postMessage(final String message, int level) {
+    protected void postMessage(final String message, final int level) {
         super.postMessage(message, level);
         _backupStatus = message;
     }
@@ -152,9 +153,9 @@
         final long baseAddress = info.getBaseAddress();
         final long currentAddress = info.getCurrentJournalAddress();
         final long blockSize = info.getBlockSize();
-        String path = JournalManager.fileToPath(new File(info.getCurrentJournalFile()));
+        final String path = JournalManager.fileToPath(new File(info.getCurrentJournalFile()));
         for (long generation = baseAddress / blockSize; generation <= currentAddress / blockSize; generation++) {
-            File file = JournalManager.generationToFile(path, generation);
+            final File file = JournalManager.generationToFile(path, generation);
             _files.add(file.getAbsolutePath());
         }
         final StringBuilder sb = new StringBuilder();

=== modified file 'src/main/java/com/persistit/Buffer.java'
--- src/main/java/com/persistit/Buffer.java	2012-08-02 04:45:28 +0000
+++ src/main/java/com/persistit/Buffer.java	2012-08-24 18:21:22 +0000
@@ -264,19 +264,23 @@
 
     private final static int BINARY_SEARCH_THRESHOLD = 6;
 
+    private final static int PRUNE_MVV_HELPER_CHANGED = 1;
+    private final static int PRUNE_MVV_HELPER_HAS_LONG = 2;
+
     abstract static class VerifyVisitor {
 
-        protected void visitPage(long timestamp, Volume volume, long page, int type, int bufferSize, int keyBlockStart,
-                int keyBlockEnd, int alloc, int available, long rightSibling) throws PersistitException {
-        }
-
-        protected void visitIndexRecord(Key key, int foundAt, int tail, int kLength, long pointer)
-                throws PersistitException {
-
-        }
-
-        protected void visitDataRecord(Key key, int foundAt, int tail, int klength, int offset, int length, byte[] bytes)
-                throws PersistitException {
+        protected void visitPage(final long timestamp, final Volume volume, final long page, final int type,
+                final int bufferSize, final int keyBlockStart, final int keyBlockEnd, final int alloc,
+                final int available, final long rightSibling) throws PersistitException {
+        }
+
+        protected void visitIndexRecord(final Key key, final int foundAt, final int tail, final int kLength,
+                final long pointer) throws PersistitException {
+
+        }
+
+        protected void visitDataRecord(final Key key, final int foundAt, final int tail, final int klength,
+                final int offset, final int length, final byte[] bytes) throws PersistitException {
         }
     }
 
@@ -323,7 +327,7 @@
      * The bytes in this buffer. Note these bytes are also the backing store of
      * _byteBuffer.
      */
-    private byte[] _bytes;
+    private final byte[] _bytes;
 
     /**
      * FastIndex structure used for rapid page searching
@@ -382,7 +386,7 @@
      * @param size
      *            The buffer size, in bytes.
      */
-    Buffer(int size, int index, BufferPool pool, Persistit persistit) {
+    Buffer(int size, final int index, final BufferPool pool, final Persistit persistit) {
         super(persistit);
         boolean ok = false;
         for (int s = MIN_BUFFER_SIZE; !ok && s <= MAX_BUFFER_SIZE; s *= 2) {
@@ -402,7 +406,7 @@
         _fastIndex = new FastIndex(this, 1 + (size - HEADER_SIZE) / MAX_KEY_RATIO);
     }
 
-    Buffer(Buffer original) {
+    Buffer(final Buffer original) {
         this(original._bufferSize, original._poolIndex, original._pool, original._persistit);
         setStatus(original);
         _type = original._type;
@@ -421,7 +425,7 @@
     /**
      * Initializes the buffer so that it contains no keys or data.
      */
-    void init(int type) {
+    void init(final int type) {
         _type = type;
         setKeyBlockEnd(KEY_BLOCK_START);
         _tailHeaderSize = isIndexPage() ? TAILBLOCK_HDR_SIZE_INDEX : TAILBLOCK_HDR_SIZE_DATA;
@@ -449,7 +453,7 @@
      * @throws InUseException
      * @throws PersistitInterruptedException
      */
-    void load(Volume vol, long page) throws PersistitIOException, InvalidPageAddressException,
+    void load(final Volume vol, final long page) throws PersistitIOException, InvalidPageAddressException,
             InvalidPageStructureException, VolumeClosedException, InUseException, PersistitInterruptedException {
         _vol = vol;
         _page = page;
@@ -463,7 +467,7 @@
         _timestamp = getLong(TIMESTAMP_OFFSET);
 
         if (_page != 0) {
-            int type = getByte(TYPE_OFFSET);
+            final int type = getByte(TYPE_OFFSET);
             if (type > PAGE_TYPE_MAX) {
                 throw new InvalidPageStructureException("Invalid type " + type);
             }
@@ -501,15 +505,23 @@
         Debug.$assert0.t(isMine());
         final long checkpointTimestamp = _persistit.getTimestampAllocator().getProposedCheckpointTimestamp();
         if (isDirty() && !isTemporary() && getTimestamp() < checkpointTimestamp && timestamp > checkpointTimestamp) {
-            writePage();
+            writePage(false);
             _pool.bumpForcedCheckpointWrites();
         }
     }
 
     void writePage() throws PersistitException {
+        writePage(_persistit.getJournalManager().isWritePagePruningEnabled());
+    }
+
+    private void writePage(final boolean prune) throws PersistitException {
+        assert isMine();
         _persistit.checkFatal();
         final Volume volume = getVolume();
         if (volume != null) {
+            if (prune) {
+                pruneMvvValues(null, false);
+            }
             clearSlack();
             save();
             _vol.getStorage().writePage(this);
@@ -519,6 +531,7 @@
         }
     }
 
+    @Override
     boolean clearDirty() {
         if (super.clearDirty()) {
             _pool.decrementDirtyPageCount();
@@ -527,6 +540,7 @@
         return false;
     }
 
+    @Override
     boolean setDirty() {
         throw new UnsupportedOperationException();
     }
@@ -543,12 +557,12 @@
     }
 
     @Override
-    boolean claim(boolean writer) throws PersistitInterruptedException {
+    boolean claim(final boolean writer) throws PersistitInterruptedException {
         return claim(writer, DEFAULT_MAX_WAIT_TIME);
     }
 
     @Override
-    boolean claim(boolean writer, long timeout) throws PersistitInterruptedException {
+    boolean claim(final boolean writer, final long timeout) throws PersistitInterruptedException {
         if (super.claim(writer, timeout)) {
             if (!isDirty()) {
                 _timestamp = _persistit.getCurrentTimestamp();
@@ -579,7 +593,7 @@
         Util.clearBytes(_bytes, 0, _bufferSize);
     }
 
-    void clearBytes(int from, int to) {
+    void clearBytes(final int from, final int to) {
         Util.clearBytes(_bytes, from, to);
     }
 
@@ -733,7 +747,7 @@
      * @param pageAddress
      *            the sibling's address
      */
-    void setRightSibling(long pageAddress) {
+    void setRightSibling(final long pageAddress) {
         Debug.$assert0.t(isMine());
         _rightSibling = pageAddress;
     }
@@ -803,15 +817,15 @@
      *         it follows the last key in the page.
      * @throws PersistitInterruptedException
      */
-    int findKey(Key key) throws PersistitInterruptedException {
+    int findKey(final Key key) throws PersistitInterruptedException {
         final FastIndex fastIndex = getFastIndex();
-        byte[] kbytes = key.getEncodedBytes();
-        int klength = key.getEncodedSize();
+        final byte[] kbytes = key.getEncodedBytes();
+        final int klength = key.getEncodedSize();
         int depth = 0;
         int left = KEY_BLOCK_START;
         int right = _keyBlockEnd;
-        int start = left;
-        int tailHeaderSize = _tailHeaderSize;
+        final int start = left;
+        final int tailHeaderSize = _tailHeaderSize;
 
         for (int p = start; p < right;) {
             //
@@ -820,7 +834,7 @@
             int kbData = getInt(p);
             int index = (p - start) >> 2;
             int runCount = fastIndex.getRunCount(index);
-            int ebc = decodeKeyBlockEbc(kbData);
+            final int ebc = decodeKeyBlockEbc(kbData);
 
             if (depth < ebc) {
                 // We know that depth < ebc for a bunch of KeyBlocks - we
@@ -836,7 +850,7 @@
             }
 
             else if (depth > ebc) {
-                int result = p | (depth << DEPTH_SHIFT);
+                final int result = p | (depth << DEPTH_SHIFT);
                 return result;
             }
 
@@ -847,7 +861,7 @@
                 int kb = kbytes[depth] & 0xFF;
 
                 if (kb < db) {
-                    int result = p | (depth << DEPTH_SHIFT);
+                    final int result = p | (depth << DEPTH_SHIFT);
                     return result;
                 }
                 if (kb > db) {
@@ -858,13 +872,13 @@
                         // either do a linear search or perform a binary search
                         // within the run.
                         //
-                        int p2 = p + (runCount * KEYBLOCK_LENGTH);
+                        final int p2 = p + (runCount * KEYBLOCK_LENGTH);
                         //
                         // p2 now points to the last key block with the same
                         // ebc in this run.
                         //
-                        int kbData2 = getInt(p2);
-                        int db2 = decodeKeyBlockDb(kbData2);
+                        final int kbData2 = getInt(p2);
+                        final int db2 = decodeKeyBlockDb(kbData2);
                         //
                         // For the common case that runCount == 1, we avoid
                         // setting up the binary search loop. Instead, the
@@ -877,7 +891,7 @@
                                 // This is right because we already know
                                 // that kb > db.
                                 //
-                                int result = p2 | (depth << DEPTH_SHIFT);
+                                final int result = p2 | (depth << DEPTH_SHIFT);
                                 return result;
                             } else if (db2 < kb) {
                                 //
@@ -888,7 +902,7 @@
                                 // -
                                 // in that case we use the cross count to skip
                                 // all of them.
-                                int runCount2 = fastIndex.getRunCount(index + runCount);
+                                final int runCount2 = fastIndex.getRunCount(index + runCount);
                                 assert runCount2 <= 0;
                                 p = p2 + KEYBLOCK_LENGTH * (-runCount + 1);
                                 continue;
@@ -921,8 +935,8 @@
                             // we are seeking.
                             //
                             if (runCount > BINARY_SEARCH_THRESHOLD) {
-                                int distance = (right - left) >> 2;
-                                int oldRight = right;
+                                final int distance = (right - left) >> 2;
+                                final int oldRight = right;
                                 if (distance > kb - db + 1) {
                                     right = left + ((kb - db + 1) << 2);
                                 }
@@ -942,7 +956,7 @@
                                     // that kb > db and less than db2, so the
                                     // final answer is know to be in right.
                                     //
-                                    int result = right | (depth << DEPTH_SHIFT);
+                                    final int result = right | (depth << DEPTH_SHIFT);
                                     return result;
                                 }
                                 //
@@ -950,7 +964,7 @@
                                 // mid-point and
                                 // adjust the ends depending on the comparison.
                                 //
-                                int db1 = getDb(p);
+                                final int db1 = getDb(p);
 
                                 if (db1 == kb) {
                                     db = db1;
@@ -998,10 +1012,10 @@
                 // for each byte in the key.
                 //
                 kbData = getInt(p);
-                int tail = decodeKeyBlockTail(kbData);
-                int tbData = getInt(tail);
-                int tlength = decodeTailBlockKLength(tbData) + depth + 1;
-                int qlength = tlength < klength ? tlength : klength;
+                final int tail = decodeKeyBlockTail(kbData);
+                final int tbData = getInt(tail);
+                final int tlength = decodeTailBlockKLength(tbData) + depth + 1;
+                final int qlength = tlength < klength ? tlength : klength;
                 //
                 // Walk down the key, increasing depth
                 //
@@ -1025,7 +1039,7 @@
                             // Key is less than tail, so we return
                             // this keyblock
                             //
-                            int result = p | (depth << DEPTH_SHIFT) | FIXUP_MASK;
+                            final int result = p | (depth << DEPTH_SHIFT) | FIXUP_MASK;
                             return result;
                         }
                         matched = false;
@@ -1045,7 +1059,7 @@
                             // And the key lengths are equal so this is an
                             // exact match.
                             //
-                            int result = p | (depth << DEPTH_SHIFT) | EXACT_MASK;
+                            final int result = p | (depth << DEPTH_SHIFT) | EXACT_MASK;
                             return result;
                         }
                     } else if (tlength > qlength) {
@@ -1054,7 +1068,7 @@
                         // key is less than tail, so we return the
                         // this keyblock since it is greater than the key
                         //
-                        int result = p | (depth << DEPTH_SHIFT) | FIXUP_MASK;
+                        final int result = p | (depth << DEPTH_SHIFT) | FIXUP_MASK;
                         return result;
                     }
                     // Otherwise, the key is longer, so we move to the next
@@ -1066,7 +1080,7 @@
 
         }
 
-        int result = right | (depth << DEPTH_SHIFT);
+        final int result = right | (depth << DEPTH_SHIFT);
         return result;
     }
 
@@ -1074,13 +1088,13 @@
         if (isDataPage()) {
             final int p = foundAt & P_MASK;
             if (p >= KEY_BLOCK_START && p < _keyBlockEnd) {
-                int kbData = getInt(p);
-                int tail = decodeKeyBlockTail(kbData);
-                int tbData = getInt(tail);
-                int klength = decodeTailBlockKLength(tbData);
-                int size = decodeTailBlockSize(tbData);
-                int offset = tail + _tailHeaderSize + klength;
-                int valueSize = size - klength - _tailHeaderSize;
+                final int kbData = getInt(p);
+                final int tail = decodeKeyBlockTail(kbData);
+                final int tbData = getInt(tail);
+                final int klength = decodeTailBlockKLength(tbData);
+                final int size = decodeTailBlockSize(tbData);
+                final int offset = tail + _tailHeaderSize + klength;
+                final int valueSize = size - klength - _tailHeaderSize;
                 return valueSize == 1 && _bytes[offset] == MVV.TYPE_ANTIVALUE;
             }
         }
@@ -1099,13 +1113,13 @@
         if (isDataPage() || isIndexPage()) {
             final int p = foundAt & P_MASK;
             if (p >= KEY_BLOCK_START && p < _keyBlockEnd) {
-                int kbData = getInt(p);
-                int tail = decodeKeyBlockTail(kbData);
-                int tbData = getInt(tail);
-                int klength = decodeTailBlockKLength(tbData);
-                int size = decodeTailBlockSize(tbData);
-                int offset = tail + _tailHeaderSize + klength;
-                int valueSize = size - klength - _tailHeaderSize;
+                final int kbData = getInt(p);
+                final int tail = decodeKeyBlockTail(kbData);
+                final int tbData = getInt(tail);
+                final int klength = decodeTailBlockKLength(tbData);
+                final int size = decodeTailBlockSize(tbData);
+                final int offset = tail + _tailHeaderSize + klength;
+                final int valueSize = size - klength - _tailHeaderSize;
                 return ((long) offset) << 32 | valueSize;
             }
         }
@@ -1116,13 +1130,13 @@
         Debug.$assert0.t(foundAt > 0 && foundAt < _keyBlockEnd);
         if (isDataPage() || isIndexPage()) {
             for (int p = KEY_BLOCK_START; p <= foundAt; p += KEYBLOCK_LENGTH) {
-                int kbData = getInt(p);
-                int tail = decodeKeyBlockTail(kbData);
-                int ebc = decodeKeyBlockEbc(kbData);
-                int db = decodeKeyBlockDb(kbData);
-                int tbData = getInt(tail);
-                int klength = decodeTailBlockKLength(tbData);
-                byte[] keyBytes = key.getEncodedBytes();
+                final int kbData = getInt(p);
+                final int tail = decodeKeyBlockTail(kbData);
+                final int ebc = decodeKeyBlockEbc(kbData);
+                final int db = decodeKeyBlockDb(kbData);
+                final int tbData = getInt(tail);
+                final int klength = decodeTailBlockKLength(tbData);
+                final byte[] keyBytes = key.getEncodedBytes();
                 keyBytes[ebc] = (byte) db;
                 System.arraycopy(_bytes, tail + _tailHeaderSize, keyBytes, ebc + 1, klength);
                 key.setEncodedSize(ebc + klength + 1);
@@ -1130,32 +1144,32 @@
         }
     }
 
-    Value fetch(int foundAt, Value value) {
+    Value fetch(final int foundAt, final Value value) {
         if ((foundAt & EXACT_MASK) == 0) {
             value.clear();
         } else {
             Debug.$assert0.t(foundAt > 0 && (foundAt & P_MASK) < _keyBlockEnd);
-            int kbData = getInt(foundAt & P_MASK);
-            int tail = decodeKeyBlockTail(kbData);
-            int tbData = getInt(tail);
-            int klength = decodeTailBlockKLength(tbData);
-            int size = decodeTailBlockSize(tbData);
-            int valueSize = size - klength - _tailHeaderSize;
+            final int kbData = getInt(foundAt & P_MASK);
+            final int tail = decodeKeyBlockTail(kbData);
+            final int tbData = getInt(tail);
+            final int klength = decodeTailBlockKLength(tbData);
+            final int size = decodeTailBlockSize(tbData);
+            final int valueSize = size - klength - _tailHeaderSize;
             value.putEncodedBytes(_bytes, tail + _tailHeaderSize + klength, valueSize);
         }
         return value;
     }
 
-    long fetchLongRecordPointer(int foundAt) {
+    long fetchLongRecordPointer(final int foundAt) {
         if (!isDataPage()) {
             return 0;
         }
-        int kbData = getInt(foundAt & P_MASK);
-        int tail = decodeKeyBlockTail(kbData);
-        int tbData = getInt(tail);
-        int klength = decodeTailBlockKLength(tbData);
-        int size = decodeTailBlockSize(tbData);
-        int valueSize = size - klength - _tailHeaderSize;
+        final int kbData = getInt(foundAt & P_MASK);
+        final int tail = decodeKeyBlockTail(kbData);
+        final int tbData = getInt(tail);
+        final int klength = decodeTailBlockKLength(tbData);
+        final int size = decodeTailBlockSize(tbData);
+        final int valueSize = size - klength - _tailHeaderSize;
         if (valueSize != LONGREC_SIZE) {
             return 0;
         }
@@ -1163,16 +1177,16 @@
             return 0;
         }
 
-        long pointer = getLong(tail + _tailHeaderSize + klength + LONGREC_PAGE_OFFSET);
+        final long pointer = getLong(tail + _tailHeaderSize + klength + LONGREC_PAGE_OFFSET);
         return pointer;
     }
 
-    long getPointer(int foundAt) throws PersistitException {
+    long getPointer(final int foundAt) throws PersistitException {
         if (!isIndexPage()) {
             throw new InvalidPageTypeException("type=" + _type);
         }
-        int kbData = getInt(foundAt & P_MASK);
-        int tail = decodeKeyBlockTail(kbData);
+        final int kbData = getInt(foundAt & P_MASK);
+        final int tail = decodeKeyBlockTail(kbData);
         return getInt(tail + 4);
     }
 
@@ -1185,8 +1199,8 @@
      * @param foundAt
      * @return
      */
-    int traverse(Key key, Key.Direction mode, int foundAt) {
-        boolean exactMatch = (foundAt & EXACT_MASK) > 0;
+    int traverse(final Key key, final Key.Direction mode, final int foundAt) {
+        final boolean exactMatch = (foundAt & EXACT_MASK) > 0;
         if (mode == Key.EQ || exactMatch && (mode == Key.LTEQ || mode == Key.GTEQ)) {
             return foundAt;
         }
@@ -1205,21 +1219,21 @@
      * @param foundAt
      * @return
      */
-    int previousKey(Key key, int foundAt) {
+    int previousKey(final Key key, final int foundAt) {
         int p = (foundAt & P_MASK) - KEYBLOCK_LENGTH;
-        int depth = (foundAt & DEPTH_MASK) >>> DEPTH_SHIFT;
+        final int depth = (foundAt & DEPTH_MASK) >>> DEPTH_SHIFT;
 
         if (p < KEY_BLOCK_START)
             return foundAt;
 
-        byte[] kbytes = key.getEncodedBytes();
+        final byte[] kbytes = key.getEncodedBytes();
 
         // Compute the count of prefix bytes in the supplied key that
         // are known to match. The leftmost knownGood bytes do not need
         // to be recovered by traversing keys in the page.
         //
-        int kbData2 = getInt(p + KEYBLOCK_LENGTH);
-        int ebc2 = decodeKeyBlockEbc(kbData2);
+        final int kbData2 = getInt(p + KEYBLOCK_LENGTH);
+        final int ebc2 = decodeKeyBlockEbc(kbData2);
         int kbData = getInt(p);
         int ebc = decodeKeyBlockEbc(kbData);
         int knownGood = ebc;
@@ -1244,7 +1258,7 @@
         int unknown = decodeTailBlockKLength(getInt(tail)) + ebc + 1;
         key.setEncodedSize(unknown);
 
-        int result = p | (unknown << DEPTH_SHIFT) | EXACT_MASK;
+        final int result = p | (unknown << DEPTH_SHIFT) | EXACT_MASK;
         //
         // Reconstruct the previous key.
         //
@@ -1252,7 +1266,7 @@
             if (ebc < unknown) {
                 // move bytes from this keyblock into the result key.
                 kbytes[ebc] = (byte) decodeKeyBlockDb(kbData);
-                int more = unknown - ebc - 1;
+                final int more = unknown - ebc - 1;
                 if (more > 0) {
                     System.arraycopy(_bytes, tail + _tailHeaderSize, kbytes, ebc + 1, more);
                 }
@@ -1278,7 +1292,7 @@
      * @param foundAt
      * @return
      */
-    int nextKey(Key key, int foundAt) {
+    int nextKey(final Key key, final int foundAt) {
         int p = foundAt & P_MASK;
         if ((foundAt & EXACT_MASK) != 0)
             p += KEYBLOCK_LENGTH;
@@ -1286,16 +1300,16 @@
         if (p >= _keyBlockEnd)
             return foundAt;
 
-        byte[] kbytes = key.getEncodedBytes();
-        int kbData = getInt(p);
-        int ebc = decodeKeyBlockEbc(kbData);
-        int tail = decodeKeyBlockTail(kbData);
-        int tbData = getInt(tail);
-        int klength = decodeTailBlockKLength(tbData);
-        int keyLength = klength + ebc + 1;
+        final byte[] kbytes = key.getEncodedBytes();
+        final int kbData = getInt(p);
+        final int ebc = decodeKeyBlockEbc(kbData);
+        final int tail = decodeKeyBlockTail(kbData);
+        final int tbData = getInt(tail);
+        final int klength = decodeTailBlockKLength(tbData);
+        final int keyLength = klength + ebc + 1;
         key.setEncodedSize(keyLength);
 
-        int result = p | (keyLength << DEPTH_SHIFT) | EXACT_MASK;
+        final int result = p | (keyLength << DEPTH_SHIFT) | EXACT_MASK;
         //
         // Note: the findKey method is guaranteed to return the offset of a
         // keyblock whose first ebc bytes match the supplied key.
@@ -1313,15 +1327,15 @@
      * @param foundAt
      * @return
      */
-    int nextLongRecord(Value value, int foundAt) {
+    int nextLongRecord(final Value value, final int foundAt) {
         Debug.$assert0.t(isDataPage());
         for (int p = foundAt & P_MASK; p < _keyBlockEnd; p += KEYBLOCK_LENGTH) {
-            int kbData = getInt(p);
-            int tail = decodeKeyBlockTail(kbData);
-            int tbData = getInt(tail);
-            int klength = decodeTailBlockKLength(tbData);
-            int size = decodeTailBlockSize(tbData);
-            int valueSize = size - klength - _tailHeaderSize;
+            final int kbData = getInt(p);
+            final int tail = decodeKeyBlockTail(kbData);
+            final int tbData = getInt(tail);
+            final int klength = decodeTailBlockKLength(tbData);
+            final int size = decodeTailBlockSize(tbData);
+            final int valueSize = size - klength - _tailHeaderSize;
             if ((valueSize > 0) && ((_bytes[tail + _tailHeaderSize + klength] & 0xFF) == LONGREC_TYPE)) {
                 value.putEncodedBytes(_bytes, tail + _tailHeaderSize + klength, valueSize);
                 return p;
@@ -1330,15 +1344,15 @@
         return -1;
     }
 
-    int previousKeyBlock(int foundAt) {
-        int p = (foundAt & P_MASK) - KEYBLOCK_LENGTH;
+    int previousKeyBlock(final int foundAt) {
+        final int p = (foundAt & P_MASK) - KEYBLOCK_LENGTH;
         if (p < KEY_BLOCK_START || p > _keyBlockEnd)
             return -1;
         return p;
     }
 
-    int nextKeyBlock(int foundAt) {
-        int p = (foundAt & P_MASK) + KEYBLOCK_LENGTH;
+    int nextKeyBlock(final int foundAt) {
+        final int p = (foundAt & P_MASK) + KEYBLOCK_LENGTH;
         if (p >= _keyBlockEnd || p < KEY_BLOCK_START)
             return -1;
         return p;
@@ -1366,8 +1380,8 @@
      *            The value, converted to a byte array
      * @throws PersistitInterruptedException
      */
-    int putValue(Key key, ValueHelper valueHelper) throws PersistitInterruptedException {
-        int p = findKey(key);
+    int putValue(final Key key, final ValueHelper valueHelper) throws PersistitInterruptedException {
+        final int p = findKey(key);
         return putValue(key, valueHelper, p, false);
     }
 
@@ -1383,13 +1397,13 @@
      * @param foundAt
      *            The keyblock before which this record will be inserted
      */
-    int putValue(Key key, ValueHelper valueHelper, int foundAt, boolean postSplit) {
+    int putValue(final Key key, final ValueHelper valueHelper, final int foundAt, final boolean postSplit) {
         if (Debug.ENABLED) {
             assertVerify();
         }
 
-        boolean exactMatch = (foundAt & EXACT_MASK) > 0;
-        int p = foundAt & P_MASK;
+        final boolean exactMatch = (foundAt & EXACT_MASK) > 0;
+        final int p = foundAt & P_MASK;
 
         if (exactMatch) {
             return replaceValue(key, valueHelper, p);
@@ -1401,9 +1415,9 @@
                 length = valueHelper.requiredLength(_bytes, 0, -1);
             }
 
-            int depth = (foundAt & DEPTH_MASK) >>> DEPTH_SHIFT;
-            boolean fixupSuccessor = (foundAt & FIXUP_MASK) > 0;
-            byte[] kbytes = key.getEncodedBytes();
+            final int depth = (foundAt & DEPTH_MASK) >>> DEPTH_SHIFT;
+            final boolean fixupSuccessor = (foundAt & FIXUP_MASK) > 0;
+            final byte[] kbytes = key.getEncodedBytes();
 
             int ebcNew;
             int ebcSuccessor;
@@ -1429,8 +1443,8 @@
                 ebcSuccessor = 0;
                 ebcNew = depth;
             }
-            int klength = key.getEncodedSize() - ebcNew - 1;
-            int newTailSize = klength + length + _tailHeaderSize;
+            final int klength = key.getEncodedSize() - ebcNew - 1;
+            final int newTailSize = klength + length + _tailHeaderSize;
 
             if (getKeyCount() >= _pool.getMaxKeys() || !willFit(newTailSize + KEYBLOCK_LENGTH - (free1 - free2))) {
                 Debug.$assert0.t(!postSplit);
@@ -1443,8 +1457,8 @@
             // is correct.
             //
             if (fixupSuccessor && ebcNew != ebcSuccessor) {
-                int successorKeyLength = decodeTailBlockKLength(successorTailBlock);
-                int successorDb = getByte(successorTail + _tailHeaderSize + delta - 1);
+                final int successorKeyLength = decodeTailBlockKLength(successorTailBlock);
+                final int successorDb = getByte(successorTail + _tailHeaderSize + delta - 1);
 
                 // Write updated successor tail block
                 putInt(successorTail, encodeTailBlock(successorTailSize - delta, successorKeyLength - delta));
@@ -1460,7 +1474,7 @@
 
                 putInt(p, kbSuccessor);
             }
-            int dbNew = kbytes[ebcNew] & 0xFF;
+            final int dbNew = kbytes[ebcNew] & 0xFF;
             //
             // Allocate space for the new tail block
             //
@@ -1481,7 +1495,7 @@
             System.arraycopy(_bytes, p, _bytes, p + KEYBLOCK_LENGTH, _keyBlockEnd - p - KEYBLOCK_LENGTH);
 
             // Write new key block
-            int newKeyBlock = encodeKeyBlock(ebcNew, dbNew, newTail);
+            final int newKeyBlock = encodeKeyBlock(ebcNew, dbNew, newTail);
             putInt(p, newKeyBlock);
 
             // Write new tail block
@@ -1493,14 +1507,18 @@
             System.arraycopy(kbytes, ebcNew + 1, _bytes, newTail + _tailHeaderSize, klength);
 
             if (isIndexPage()) {
-                int pointer = (int) valueHelper.getPointerValue();
+                final int pointer = (int) valueHelper.getPointerValue();
 
                 Debug.$assert0.t(p + KEYBLOCK_LENGTH < _keyBlockEnd ? pointer > 0 : true);
                 putInt(newTail + TAILBLOCK_POINTER, pointer);
             } else {
-                int storedLength = valueHelper.storeVersion(_bytes, newTail + _tailHeaderSize + klength, -1,
-                        _bytes.length); // TODO limit
-                incCountIfMvv(_bytes, newTail + _tailHeaderSize + klength, storedLength & MVV.STORE_LENGTH_MASK);
+                final int offset = newTail + _tailHeaderSize + klength;
+                final int storedLength = valueHelper.storeVersion(_bytes, offset, -1, _bytes.length); // TODO
+                // limit
+                incCountIfMvv(_bytes, offset, storedLength & MVV.STORE_LENGTH_MASK);
+
+                // TODO - remove after debugging
+                MVV.verify(_persistit.getTransactionIndex(), _bytes, offset, storedLength & MVV.STORE_LENGTH_MASK);
             }
             //
             // Correct not to call getFastIndex()
@@ -1532,12 +1550,12 @@
      */
     private boolean adjacentKeyCheck(int p) {
         p &= P_MASK;
-        int kbData1 = getInt(p);
-        int kbData2 = getInt(p + KEYBLOCK_LENGTH);
-        int db1 = decodeKeyBlockDb(kbData1);
-        int ebc1 = decodeKeyBlockEbc(kbData1);
-        int db2 = decodeKeyBlockDb(kbData2);
-        int ebc2 = decodeKeyBlockEbc(kbData2);
+        final int kbData1 = getInt(p);
+        final int kbData2 = getInt(p + KEYBLOCK_LENGTH);
+        final int db1 = decodeKeyBlockDb(kbData1);
+        final int ebc1 = decodeKeyBlockEbc(kbData1);
+        final int db2 = decodeKeyBlockDb(kbData2);
+        final int ebc2 = decodeKeyBlockEbc(kbData2);
 
         if (db1 == 0 && p > KEY_BLOCK_START) {
             return false; // Can set breakpoint here
@@ -1551,9 +1569,9 @@
         if (ebc2 < ebc1)
             return true;
         if (ebc2 > ebc1) {
-            int tail1 = decodeKeyBlockTail(kbData1);
-            int tbData1 = getInt(tail1);
-            int klength1 = decodeTailBlockKLength(tbData1);
+            final int tail1 = decodeKeyBlockTail(kbData1);
+            final int tbData1 = getInt(tail1);
+            final int klength1 = decodeTailBlockKLength(tbData1);
             int db = -1;
             if (klength1 >= ebc2 - ebc1) {
                 db = _bytes[tail1 + _tailHeaderSize + ebc2 - ebc1 - 1] & DB_MASK;
@@ -1569,12 +1587,12 @@
         return false; // Can set breakpoint here
     }
 
-    private int replaceValue(Key key, ValueHelper valueHelper, int p) {
-        int kbData = getInt(p);
-        int tail = decodeKeyBlockTail(kbData);
-        int tbData = getInt(tail);
-        int klength = decodeTailBlockKLength(tbData);
-        int oldTailSize = decodeTailBlockSize(tbData);
+    private int replaceValue(final Key key, final ValueHelper valueHelper, final int p) {
+        final int kbData = getInt(p);
+        final int tail = decodeKeyBlockTail(kbData);
+        final int tbData = getInt(tail);
+        final int klength = decodeTailBlockKLength(tbData);
+        final int oldTailSize = decodeTailBlockSize(tbData);
         boolean wasMVV = false;
         boolean isMVV = false;
 
@@ -1587,9 +1605,9 @@
             wasMVV = isValueMVV(_bytes, tail + _tailHeaderSize + klength, oldTailSize - _tailHeaderSize - klength);
         }
 
-        int newTailSize = klength + length + _tailHeaderSize;
-        int oldNext = (tail + oldTailSize + ~TAILBLOCK_MASK) & TAILBLOCK_MASK;
-        int newNext = (tail + newTailSize + ~TAILBLOCK_MASK) & TAILBLOCK_MASK;
+        final int newTailSize = klength + length + _tailHeaderSize;
+        final int oldNext = (tail + oldTailSize + ~TAILBLOCK_MASK) & TAILBLOCK_MASK;
+        final int newNext = (tail + newTailSize + ~TAILBLOCK_MASK) & TAILBLOCK_MASK;
         int newTail = tail;
         if (newNext < oldNext) {
             // Free the remainder of the old tail block
@@ -1622,13 +1640,18 @@
         }
 
         if (isIndexPage()) {
-            long pointer = valueHelper.getPointerValue();
+            final long pointer = valueHelper.getPointerValue();
             Debug.$assert0.t(p + KEYBLOCK_LENGTH < _keyBlockEnd ? pointer > 0 : pointer == -1);
             putInt(newTail + TAILBLOCK_POINTER, (int) pointer);
         } else {
-            final int storedLength = valueHelper.storeVersion(_bytes, newTail + _tailHeaderSize + klength, oldTailSize
-                    - _tailHeaderSize - klength, _bytes.length); // TODO - limit
-            isMVV = isValueMVV(_bytes, newTail + _tailHeaderSize + klength, storedLength & MVV.STORE_LENGTH_MASK);
+            final int offset = newTail + _tailHeaderSize + klength;
+            final int storedLength = valueHelper.storeVersion(_bytes, offset, oldTailSize - _tailHeaderSize - klength,
+                    _bytes.length); // TODO - limit
+            isMVV = isValueMVV(_bytes, offset, storedLength & MVV.STORE_LENGTH_MASK);
+
+            // TODO - remove after debugging
+            MVV.verify(_persistit.getTransactionIndex(), _bytes, offset, storedLength & MVV.STORE_LENGTH_MASK);
+
         }
         if (!wasMVV && isMVV) {
             _mvvCount++;
@@ -1658,11 +1681,11 @@
      * @return <i>true</i> if the key was found and the value removed, else
      *         <i>false</i>
      */
-    boolean removeKeys(int foundAt1, int foundAt2, Key spareKey) {
+    boolean removeKeys(final int foundAt1, final int foundAt2, final Key spareKey) {
         if (Debug.ENABLED) {
             assertVerify();
         }
-        int p1 = foundAt1 & P_MASK;
+        final int p1 = foundAt1 & P_MASK;
         int p2 = foundAt2 & P_MASK;
         if ((foundAt2 & EXACT_MASK) != 0)
             p2 += KEYBLOCK_LENGTH;
@@ -1675,24 +1698,24 @@
 
         int ebc = Integer.MAX_VALUE;
 
-        byte[] spareBytes = spareKey.getEncodedBytes();
+        final byte[] spareBytes = spareKey.getEncodedBytes();
         int keySize = 0;
         for (int p = p1; p < p2; p += KEYBLOCK_LENGTH) {
-            int kbData = getInt(p);
-            int ebcCandidate = decodeKeyBlockEbc(kbData);
+            final int kbData = getInt(p);
+            final int ebcCandidate = decodeKeyBlockEbc(kbData);
             if (ebcCandidate < ebc) {
                 ebc = ebcCandidate;
             }
-            int db = decodeKeyBlockDb(kbData);
-            int tail = decodeKeyBlockTail(kbData);
-            int tbData = getInt(tail);
-            int klength = decodeTailBlockKLength(tbData);
+            final int db = decodeKeyBlockDb(kbData);
+            final int tail = decodeKeyBlockTail(kbData);
+            final int tbData = getInt(tail);
+            final int klength = decodeTailBlockKLength(tbData);
             spareBytes[ebcCandidate] = (byte) db;
             if (klength > 0) {
                 System.arraycopy(_bytes, tail + _tailHeaderSize, spareBytes, ebcCandidate + 1, klength);
             }
             keySize = klength + ebcCandidate + 1;
-            int size = (decodeTailBlockSize(tbData) + ~TAILBLOCK_MASK) & TAILBLOCK_MASK;
+            final int size = (decodeTailBlockSize(tbData) + ~TAILBLOCK_MASK) & TAILBLOCK_MASK;
             deallocTail(tail, size);
         }
         spareKey.setEncodedSize(keySize);
@@ -1711,22 +1734,22 @@
         //
         if (p1 < _keyBlockEnd) {
             int kbNext = getInt(p1);
-            int ebcNext = decodeKeyBlockEbc(kbNext);
+            final int ebcNext = decodeKeyBlockEbc(kbNext);
 
             //
             // If ebcNext > ebc then the successor key will need to expand.
             //
             if (ebcNext > ebc) {
                 int tailNext = decodeKeyBlockTail(kbNext);
-                int dbNext = decodeKeyBlockDb(kbNext);
-                int tbNext = getInt(tailNext);
-                int nextTailSize = decodeTailBlockSize(tbNext);
-
-                int nextTailBlockSize = (nextTailSize + ~TAILBLOCK_MASK) & TAILBLOCK_MASK;
-
-                int newNextTailBlockSize = (nextTailSize + ebcNext - ebc + ~TAILBLOCK_MASK) & TAILBLOCK_MASK;
-
-                int delta = newNextTailBlockSize - nextTailBlockSize;
+                final int dbNext = decodeKeyBlockDb(kbNext);
+                final int tbNext = getInt(tailNext);
+                final int nextTailSize = decodeTailBlockSize(tbNext);
+
+                final int nextTailBlockSize = (nextTailSize + ~TAILBLOCK_MASK) & TAILBLOCK_MASK;
+
+                final int newNextTailBlockSize = (nextTailSize + ebcNext - ebc + ~TAILBLOCK_MASK) & TAILBLOCK_MASK;
+
+                final int delta = newNextTailBlockSize - nextTailBlockSize;
                 boolean freeNextTailBlock = false;
                 int newNextTail = tailNext;
                 if (delta > 0) {
@@ -1786,17 +1809,17 @@
                 //
                 // Now construct the new tail block
                 //
-                int newNextKLength = decodeTailBlockKLength(tbNext) + ebcNext - ebc;
-                int newNextTailSize = nextTailSize + ebcNext - ebc;
+                final int newNextKLength = decodeTailBlockKLength(tbNext) + ebcNext - ebc;
+                final int newNextTailSize = nextTailSize + ebcNext - ebc;
                 putInt(newNextTail, encodeTailBlock(newNextTailSize, newNextKLength));
                 if (freeNextTailBlock) {
-                    int toFree = (nextTailSize + ~TAILBLOCK_MASK) & TAILBLOCK_MASK;
+                    final int toFree = (nextTailSize + ~TAILBLOCK_MASK) & TAILBLOCK_MASK;
                     deallocTail(tailNext, toFree);
                 }
                 //
                 // Fix up the successor key block
                 //
-                int kbNewNext = encodeKeyBlock(ebc, spareBytes[ebc], newNextTail);
+                final int kbNewNext = encodeKeyBlock(ebc, spareBytes[ebc], newNextTail);
                 putInt(p1, kbNewNext);
             }
         }
@@ -1820,7 +1843,7 @@
      *            The amount by which that block is to be expanded.
      * @return int Offset of the expanded tail block, or -1 if it does not fit.
      */
-    private int wedgeTail(int tail, int delta) {
+    private int wedgeTail(final int tail, int delta) {
         delta = (delta + ~TAILBLOCK_MASK) & TAILBLOCK_MASK;
         if (delta == 0) {
             return tail;
@@ -1836,8 +1859,8 @@
         _alloc -= delta;
 
         for (int p = KEY_BLOCK_START; p < _keyBlockEnd; p += KEYBLOCK_LENGTH) {
-            int kbData = getInt(p);
-            int oldTail = decodeKeyBlockTail(kbData);
+            final int kbData = getInt(p);
+            final int oldTail = decodeKeyBlockTail(kbData);
             if (oldTail < tail) {
                 putInt(p, encodeKeyBlockTail(kbData, oldTail - delta));
             }
@@ -1869,8 +1892,8 @@
      *         the right sibling Buffer.
      * @throws PersistitException
      */
-    final int split(Buffer rightSibling, Key key, ValueHelper valueHelper, int foundAt, Key indexKey,
-            Sequence sequence, SplitPolicy policy) throws PersistitException {
+    final int split(final Buffer rightSibling, final Key key, final ValueHelper valueHelper, int foundAt,
+            final Key indexKey, final Sequence sequence, final SplitPolicy policy) throws PersistitException {
         // Make sure the right sibling page is empty.
 
         Debug.$assert0.t(rightSibling._keyBlockEnd == KEY_BLOCK_START);
@@ -1888,10 +1911,10 @@
         //
         int currentSize = _bufferSize - _alloc - _slack + _keyBlockEnd - KEY_BLOCK_START;
 
-        int foundAtPosition = foundAt & P_MASK;
-        boolean exact = (foundAt & EXACT_MASK) != 0;
+        final int foundAtPosition = foundAt & P_MASK;
+        final boolean exact = (foundAt & EXACT_MASK) != 0;
         int depth = (foundAt & DEPTH_MASK) >>> DEPTH_SHIFT;
-        boolean fixupSuccessor = (foundAt & FIXUP_MASK) > 0;
+        final boolean fixupSuccessor = (foundAt & FIXUP_MASK) > 0;
 
         int ebcNew;
         int ebcSuccessor;
@@ -1899,18 +1922,18 @@
         int deltaSuccessorEbc = 0;
 
         if (fixupSuccessor) {
-            int kbSuccessor = getInt(foundAtPosition);
-            int tbSuccessor = getInt(decodeKeyBlockTail(kbSuccessor));
+            final int kbSuccessor = getInt(foundAtPosition);
+            final int tbSuccessor = getInt(decodeKeyBlockTail(kbSuccessor));
             ebcNew = decodeKeyBlockEbc(kbSuccessor);
             ebcSuccessor = depth;
-            int tbSize = decodeTailBlockSize(tbSuccessor);
+            final int tbSize = decodeTailBlockSize(tbSuccessor);
 
             // This is the number of bytes by which the successor key
             // can have its elided byte count increased.
             deltaSuccessorEbc = ebcSuccessor - ebcNew;
 
-            int oldSize = (tbSize + ~TAILBLOCK_MASK) & TAILBLOCK_MASK;
-            int newSize = (tbSize - deltaSuccessorEbc + ~TAILBLOCK_MASK) & TAILBLOCK_MASK;
+            final int oldSize = (tbSize + ~TAILBLOCK_MASK) & TAILBLOCK_MASK;
+            final int newSize = (tbSize - deltaSuccessorEbc + ~TAILBLOCK_MASK) & TAILBLOCK_MASK;
 
             // This is the number of bytes by which the successor tail block
             // can be reduced (because its elision count has increased.)
@@ -1924,11 +1947,11 @@
         int newTailBlockSize;
         int newValueSize;
         if (exact) {
-            int kbData = getInt(foundAtPosition);
-            int tail = decodeKeyBlockTail(kbData);
-            int tbData = getInt(tail);
-            int tbSize = decodeTailBlockSize(tbData);
-            int klength = decodeTailBlockKLength(tbData);
+            final int kbData = getInt(foundAtPosition);
+            final int tail = decodeKeyBlockTail(kbData);
+            final int tbData = getInt(tail);
+            final int tbSize = decodeTailBlockSize(tbData);
+            final int klength = decodeTailBlockKLength(tbData);
             oldTailBlockSize = (tbSize + ~TAILBLOCK_MASK) & TAILBLOCK_MASK;
             keyBlockSizeDelta = 0;
             ebcNew = decodeKeyBlockEbc(kbData);
@@ -1940,7 +1963,7 @@
         newTailBlockSize = ((isIndexPage() ? 0 : newValueSize) + _tailHeaderSize + key.getEncodedSize() - ebcNew - 1 + ~TAILBLOCK_MASK)
                 & TAILBLOCK_MASK;
 
-        int virtualSize = currentSize + newTailBlockSize - oldTailBlockSize + keyBlockSizeDelta
+        final int virtualSize = currentSize + newTailBlockSize - oldTailBlockSize + keyBlockSizeDelta
                 - deltaSuccessorTailSize;
 
         int splitBest = 0; // Maximal fitness measure
@@ -1951,7 +1974,7 @@
         boolean armed = true;
         int whereInserted = -1;
 
-        int rightKeyBlock = _keyBlockEnd - KEYBLOCK_LENGTH;
+        final int rightKeyBlock = _keyBlockEnd - KEYBLOCK_LENGTH;
         for (int p = KEY_BLOCK_START; p < rightKeyBlock;) {
             int splitCandidate = 0;
             if (p == foundAtPosition && armed) {
@@ -1968,18 +1991,18 @@
                 // Compute the number of bytes by which the successor tailblock
                 // will grow due to its elision count becoming zero.
                 //
-                int kbData = getInt(p);
-                int tbData = getInt(decodeKeyBlockTail(kbData));
-                int ebc = decodeKeyBlockEbc(kbData);
-                int tbSize = decodeTailBlockSize(tbData);
-                int tbSizeDelta = ((tbSize + ebc + ~TAILBLOCK_MASK) & TAILBLOCK_MASK)
+                final int kbData = getInt(p);
+                final int tbData = getInt(decodeKeyBlockTail(kbData));
+                final int ebc = decodeKeyBlockEbc(kbData);
+                final int tbSize = decodeTailBlockSize(tbData);
+                final int tbSizeDelta = ((tbSize + ebc + ~TAILBLOCK_MASK) & TAILBLOCK_MASK)
                         - ((tbSize + ~TAILBLOCK_MASK) & TAILBLOCK_MASK);
 
-                int edgeTailBlockSize = (decodeTailBlockKLength(tbData) - deltaSuccessorEbc + _tailHeaderSize + ~TAILBLOCK_MASK)
+                final int edgeTailBlockSize = (decodeTailBlockKLength(tbData) - deltaSuccessorEbc + _tailHeaderSize + ~TAILBLOCK_MASK)
                         & TAILBLOCK_MASK;
 
                 if (p < rightKeyBlock) {
-                    int rightSize = virtualSize - leftSize + tbSizeDelta;
+                    final int rightSize = virtualSize - leftSize + tbSizeDelta;
 
                     splitCandidate = policy.splitFit(this, p, foundAtPosition, exact, leftSize + KEYBLOCK_LENGTH
                             + edgeTailBlockSize, rightSize, currentSize, virtualSize, _bufferSize - KEY_BLOCK_START,
@@ -1996,7 +2019,7 @@
                 int kbData = getInt(p);
                 int tbData = getInt(decodeKeyBlockTail(kbData));
                 int tbSizeDelta;
-                int tailBlockSize = (decodeTailBlockSize(tbData) + ~TAILBLOCK_MASK) & TAILBLOCK_MASK;
+                final int tailBlockSize = (decodeTailBlockSize(tbData) + ~TAILBLOCK_MASK) & TAILBLOCK_MASK;
                 leftSize += tailBlockSize + KEYBLOCK_LENGTH;
 
                 p += KEYBLOCK_LENGTH;
@@ -2011,8 +2034,8 @@
                 } else {
                     kbData = getInt(p);
                     tbData = getInt(decodeKeyBlockTail(kbData));
-                    int ebc = decodeKeyBlockEbc(kbData);
-                    int tbSize = decodeTailBlockSize(tbData);
+                    final int ebc = decodeKeyBlockEbc(kbData);
+                    final int tbSize = decodeTailBlockSize(tbData);
 
                     tbSizeDelta = ((tbSize + ebc + ~TAILBLOCK_MASK) & TAILBLOCK_MASK)
                             - ((tbSize + ~TAILBLOCK_MASK) & TAILBLOCK_MASK);
@@ -2022,7 +2045,7 @@
                 }
 
                 if (p < rightKeyBlock) {
-                    int rightSize = virtualSize - leftSize + tbSizeDelta;
+                    final int rightSize = virtualSize - leftSize + tbSizeDelta;
 
                     splitCandidate = policy.splitFit(this, p, foundAtPosition, exact, leftSize + KEYBLOCK_LENGTH
                             + edgeTailBlockSize, rightSize, currentSize, virtualSize, _bufferSize - KEY_BLOCK_START,
@@ -2048,11 +2071,11 @@
         //
         // Now move the keys and records.
         //
-        byte[] indexKeyBytes = indexKey.getEncodedBytes();
-        int splitAtPosition = splitAt & P_MASK;
+        final byte[] indexKeyBytes = indexKey.getEncodedBytes();
+        final int splitAtPosition = splitAt & P_MASK;
 
-        boolean lastLeft = (splitAt & EXACT_MASK) != 0;
-        boolean firstRight = !lastLeft && splitAtPosition == foundAtPosition;
+        final boolean lastLeft = (splitAt & EXACT_MASK) != 0;
+        final boolean firstRight = !lastLeft && splitAtPosition == foundAtPosition;
         int indexKeyDepth = 0;
         //
         // First we need to compute the full key in the right sibling page.
@@ -2074,18 +2097,18 @@
         //
         if (!firstRight) {
             for (int p = scanStart; p <= splitAtPosition; p += KEYBLOCK_LENGTH) {
-                int kbData = getInt(p);
-                int ebc = decodeKeyBlockEbc(kbData);
-                int db = decodeKeyBlockDb(kbData);
-                int tail = decodeKeyBlockTail(kbData);
+                final int kbData = getInt(p);
+                final int ebc = decodeKeyBlockEbc(kbData);
+                final int db = decodeKeyBlockDb(kbData);
+                final int tail = decodeKeyBlockTail(kbData);
                 if (ebc > indexKeyDepth) {
                     throw new InvalidPageStructureException("ebc at " + p + " ebc=" + ebc + " > indexKeyDepth="
                             + indexKeyDepth);
                 }
                 indexKeyDepth = ebc;
                 indexKeyBytes[indexKeyDepth++] = (byte) db;
-                int tbData = getInt(tail);
-                int klength = decodeTailBlockKLength(tbData);
+                final int tbData = getInt(tail);
+                final int klength = decodeTailBlockKLength(tbData);
 
                 System.arraycopy(_bytes, tail + _tailHeaderSize, indexKeyBytes, indexKeyDepth, klength);
                 indexKeyDepth += klength;
@@ -2202,7 +2225,7 @@
                 if (isDataPage()) {
                     currentSize = (tailBlockSize + ~TAILBLOCK_MASK) & TAILBLOCK_MASK;
 
-                    int newSize = (tailBlockSize - dataSize + ~TAILBLOCK_MASK) & TAILBLOCK_MASK;
+                    final int newSize = (tailBlockSize - dataSize + ~TAILBLOCK_MASK) & TAILBLOCK_MASK;
                     if (newSize != currentSize) {
                         deallocTail(tail + newSize, currentSize - newSize);
                     }
@@ -2217,9 +2240,9 @@
         //
         // Fix up the right edge key in the left page.
         //
-        int kbData = getInt(splitAtPosition);
+        final int kbData = getInt(splitAtPosition);
         int edgeTail = decodeKeyBlockTail(kbData);
-        int ebc = decodeKeyBlockEbc(kbData);
+        final int ebc = decodeKeyBlockEbc(kbData);
         depth = (foundAt & DEPTH_MASK) >>> DEPTH_SHIFT;
 
         if (firstRight && !exact) {
@@ -2230,10 +2253,10 @@
             if (fixupSuccessor) {
                 depth = ebc;
             }
-            int db = indexKeyBytes[depth];
+            final int db = indexKeyBytes[depth];
 
-            int edgeKeyLength = indexKey.getEncodedSize() - depth - 1;
-            int edgeTailBlockSize = edgeKeyLength + _tailHeaderSize;
+            final int edgeKeyLength = indexKey.getEncodedSize() - depth - 1;
+            final int edgeTailBlockSize = edgeKeyLength + _tailHeaderSize;
             edgeTail = allocTail(edgeTailBlockSize);
             if (edgeTail == -1) {
                 setKeyBlockEnd(splitAtPosition);
@@ -2367,8 +2390,8 @@
      *             in the rare case where no rearrangement of the records is
      *             possible.
      */
-    final boolean join(Buffer buffer, int foundAt1, int foundAt2, Key indexKey, Key spareKey, JoinPolicy policy)
-            throws RebalanceException {
+    final boolean join(final Buffer buffer, int foundAt1, int foundAt2, final Key indexKey, final Key spareKey,
+            final JoinPolicy policy) throws RebalanceException {
         foundAt1 &= P_MASK;
         foundAt2 &= P_MASK;
 
@@ -2401,17 +2424,17 @@
         //
         buffer.keyAt(foundAt2, spareKey);
 
-        long measureLeft = joinMeasure(foundAt1, _keyBlockEnd);
-        long measureRight = buffer.joinMeasure(KEY_BLOCK_START, foundAt2);
+        final long measureLeft = joinMeasure(foundAt1, _keyBlockEnd);
+        final long measureRight = buffer.joinMeasure(KEY_BLOCK_START, foundAt2);
         kbData = buffer.getInt(foundAt2);
-        int oldEbc = decodeKeyBlockEbc(kbData);
-        int newEbc = Math.min(oldEbc, Math.min((int) (measureLeft >>> 32), (int) (measureRight >>> 32)));
+        final int oldEbc = decodeKeyBlockEbc(kbData);
+        final int newEbc = Math.min(oldEbc, Math.min((int) (measureLeft >>> 32), (int) (measureRight >>> 32)));
         tail = decodeKeyBlockTail(kbData);
         tbData = buffer.getInt(tail);
 
-        int oldSize = decodeTailBlockSize(tbData);
-        int newSize = oldSize + (oldEbc - newEbc);
-        int adjustmentForNewEbc = ((newSize + ~TAILBLOCK_MASK) & TAILBLOCK_MASK)
+        final int oldSize = decodeTailBlockSize(tbData);
+        final int newSize = oldSize + (oldEbc - newEbc);
+        final int adjustmentForNewEbc = ((newSize + ~TAILBLOCK_MASK) & TAILBLOCK_MASK)
                 - ((oldSize + ~TAILBLOCK_MASK) & TAILBLOCK_MASK);
 
         /*
@@ -2424,7 +2447,7 @@
         final int virtualKeyCount = ((foundAt1 - KEY_BLOCK_START) + (buffer.getKeyBlockEnd() - foundAt2))
                 / KEYBLOCK_LENGTH;
 
-        boolean okayToRejoin = virtualKeyCount < _pool.getMaxKeys() && policy.acceptJoin(this, virtualSize);
+        final boolean okayToRejoin = virtualKeyCount < _pool.getMaxKeys() && policy.acceptJoin(this, virtualSize);
 
         boolean result;
 
@@ -2473,7 +2496,7 @@
             /*
              * unsplice the right buffer from the right sibling chain.
              */
-            long rightSibling = buffer.getRightSibling();
+            final long rightSibling = buffer.getRightSibling();
             setRightSibling(rightSibling);
             if (hasMVV) {
                 _mvvCount = Integer.MAX_VALUE;
@@ -2520,7 +2543,7 @@
                 buffer.joinDeallocateTails(KEY_BLOCK_START, foundAt2);
                 buffer.clearBytes(KEY_BLOCK_START, foundAt2);
                 buffer.reduceEbc(foundAt2, newEbc, spareKeyBytes);
-                int rightSize = buffer._keyBlockEnd - joinOffset;
+                final int rightSize = buffer._keyBlockEnd - joinOffset;
 
                 moveRecords(buffer, foundAt2, joinOffset, _keyBlockEnd, true);
 
@@ -2540,7 +2563,7 @@
 
                 buffer.joinDeallocateTails(KEY_BLOCK_START, foundAt2);
 
-                int rightSize = buffer._keyBlockEnd - foundAt2;
+                final int rightSize = buffer._keyBlockEnd - foundAt2;
                 System.arraycopy(buffer._bytes, foundAt2, buffer._bytes, KEY_BLOCK_START, rightSize);
                 buffer.clearBytes(KEY_BLOCK_START + rightSize, buffer._keyBlockEnd);
                 buffer.setKeyBlockEnd(KEY_BLOCK_START + rightSize);
@@ -2629,18 +2652,18 @@
      * @return long encoding the size being deleted and the minimum ebc
      * 
      */
-    long joinMeasure(int from, int to) {
+    long joinMeasure(final int from, final int to) {
         int minimumEbc = Integer.MAX_VALUE;
         int totalDeallocatedSize = 0;
         for (int index = from; index < to; index += KEYBLOCK_LENGTH) {
-            int kbData = getInt(index);
-            int ebc = decodeKeyBlockEbc(kbData);
+            final int kbData = getInt(index);
+            final int ebc = decodeKeyBlockEbc(kbData);
             if (index != KEY_BLOCK_START && ebc < minimumEbc) {
                 minimumEbc = ebc;
             }
-            int tail = decodeKeyBlockTail(kbData);
-            int tbData = getInt(tail);
-            int size = decodeTailBlockSize(tbData);
+            final int tail = decodeKeyBlockTail(kbData);
+            final int tbData = getInt(tail);
+            final int size = decodeTailBlockSize(tbData);
             totalDeallocatedSize += ((size + ~TAILBLOCK_MASK) & TAILBLOCK_MASK) + KEYBLOCK_LENGTH;
         }
         return (((long) minimumEbc) << 32) | totalDeallocatedSize;
@@ -2660,12 +2683,12 @@
      * @param to
      *            offset of the next key block not being deleted
      */
-    void joinDeallocateTails(int from, int to) {
+    void joinDeallocateTails(final int from, final int to) {
         for (int index = from; index < to; index += KEYBLOCK_LENGTH) {
-            int kbData = getInt(index);
-            int tail = decodeKeyBlockTail(kbData);
-            int tbData = getInt(tail);
-            int size = (decodeTailBlockSize(tbData) + ~TAILBLOCK_MASK) & TAILBLOCK_MASK;
+            final int kbData = getInt(index);
+            final int tail = decodeKeyBlockTail(kbData);
+            final int tbData = getInt(tail);
+            final int size = (decodeTailBlockSize(tbData) + ~TAILBLOCK_MASK) & TAILBLOCK_MASK;
             deallocTail(tail, size);
         }
     }
@@ -2739,23 +2762,24 @@
         //
         for (int p = KEY_BLOCK_START; p < foundAt1; p += KEYBLOCK_LENGTH) {
             kbData = getInt(p);
-            int ebc = decodeKeyBlockEbc(kbData);
+            final int ebc = decodeKeyBlockEbc(kbData);
             tail = decodeKeyBlockTail(kbData);
             tbData = getInt(tail);
-            int size = decodeTailBlockSize(tbData);
+            final int size = decodeTailBlockSize(tbData);
             klength = decodeTailBlockKLength(tbData);
 
-            int delta = ((size + ebc + ~TAILBLOCK_MASK) & TAILBLOCK_MASK) - ((size + ~TAILBLOCK_MASK) & TAILBLOCK_MASK);
-
-            int candidateRightSize = virtualSize - leftSize + delta;
-
-            int candidateLeftSize = leftSize + KEYBLOCK_LENGTH + ((klength + ~TAILBLOCK_MASK) & TAILBLOCK_MASK)
+            final int delta = ((size + ebc + ~TAILBLOCK_MASK) & TAILBLOCK_MASK)
+                    - ((size + ~TAILBLOCK_MASK) & TAILBLOCK_MASK);
+
+            final int candidateRightSize = virtualSize - leftSize + delta;
+
+            final int candidateLeftSize = leftSize + KEYBLOCK_LENGTH + ((klength + ~TAILBLOCK_MASK) & TAILBLOCK_MASK)
                     + _tailHeaderSize;
 
-            int rightKeyCount = ((buffer.getKeyBlockEnd() - foundAt2) + (foundAt1 - p)) / KEYBLOCK_LENGTH;
+            final int rightKeyCount = ((buffer.getKeyBlockEnd() - foundAt2) + (foundAt1 - p)) / KEYBLOCK_LENGTH;
 
-            int joinFit = policy.rebalanceFit(this, buffer, p, foundAt1, foundAt2, virtualSize, candidateLeftSize,
-                    candidateRightSize, _bufferSize - KEY_BLOCK_START);
+            final int joinFit = policy.rebalanceFit(this, buffer, p, foundAt1, foundAt2, virtualSize,
+                    candidateLeftSize, candidateRightSize, _bufferSize - KEY_BLOCK_START);
 
             if (joinFit > joinBest && rightKeyCount < _pool.getMaxKeys()) {
                 joinBest = joinFit;
@@ -2770,10 +2794,10 @@
          */
         for (int p = foundAt2; p < buffer._keyBlockEnd; p += KEYBLOCK_LENGTH) {
             kbData = buffer.getInt(p);
-            int ebc = decodeKeyBlockEbc(kbData);
+            final int ebc = decodeKeyBlockEbc(kbData);
             tail = decodeKeyBlockTail(kbData);
             tbData = buffer.getInt(tail);
-            int size = decodeTailBlockSize(tbData);
+            final int size = decodeTailBlockSize(tbData);
             klength = decodeTailBlockKLength(tbData);
 
             /*
@@ -2781,23 +2805,24 @@
              * rebalance key would have to grow if it became the first key on
              * the right page and its ebc became zero.
              */
-            int delta = ((size + ebc + ~TAILBLOCK_MASK) & TAILBLOCK_MASK) - ((size + ~TAILBLOCK_MASK) & TAILBLOCK_MASK);
+            final int delta = ((size + ebc + ~TAILBLOCK_MASK) & TAILBLOCK_MASK)
+                    - ((size + ~TAILBLOCK_MASK) & TAILBLOCK_MASK);
 
             /*
              * Amount by which the current tail block needs to grow to
              * accommodate reduced ebc.
              */
-            int adjustment = (p == foundAt2) ? adjustmentForNewEbc : 0;
-
-            int candidateRightSize = virtualSize - leftSize + delta;
-
-            int candidateLeftSize = leftSize + ((klength + ~TAILBLOCK_MASK) & TAILBLOCK_MASK) + adjustment
+            final int adjustment = (p == foundAt2) ? adjustmentForNewEbc : 0;
+
+            final int candidateRightSize = virtualSize - leftSize + delta;
+
+            final int candidateLeftSize = leftSize + ((klength + ~TAILBLOCK_MASK) & TAILBLOCK_MASK) + adjustment
                     + _tailHeaderSize + KEYBLOCK_LENGTH;
 
-            int leftKeyCount = ((foundAt1 - KEY_BLOCK_START) + (p - foundAt2)) / KEYBLOCK_LENGTH;
+            final int leftKeyCount = ((foundAt1 - KEY_BLOCK_START) + (p - foundAt2)) / KEYBLOCK_LENGTH;
 
-            int joinFit = policy.rebalanceFit(this, buffer, p, foundAt1, foundAt2, virtualSize, candidateLeftSize,
-                    candidateRightSize, _bufferSize - KEY_BLOCK_START);
+            final int joinFit = policy.rebalanceFit(this, buffer, p, foundAt1, foundAt2, virtualSize,
+                    candidateLeftSize, candidateRightSize, _bufferSize - KEY_BLOCK_START);
 
             if (joinFit > joinBest && leftKeyCount < _pool.getMaxKeys()) {
                 joinBest = joinFit;
@@ -2821,12 +2846,12 @@
         return _fastIndex;
     }
 
-    private void reduceEbc(int p, int newEbc, byte[] indexKeyBytes) {
+    private void reduceEbc(final int p, final int newEbc, final byte[] indexKeyBytes) {
         int kbData = getInt(p);
-        int oldDb = decodeKeyBlockDb(kbData);
-        int oldEbc = decodeKeyBlockEbc(kbData);
+        final int oldDb = decodeKeyBlockDb(kbData);
+        final int oldEbc = decodeKeyBlockEbc(kbData);
         int tail = decodeKeyBlockTail(kbData);
-        int tbData = getInt(tail);
+        final int tbData = getInt(tail);
         int size = decodeTailBlockSize(tbData);
         int klength = decodeTailBlockKLength(tbData);
 
@@ -2836,7 +2861,7 @@
             throw new IllegalArgumentException("newEbc=" + newEbc + " must be less than oldEbc=" + oldEbc);
         }
 
-        int delta = ((size + oldEbc - newEbc + ~TAILBLOCK_MASK) & TAILBLOCK_MASK)
+        final int delta = ((size + oldEbc - newEbc + ~TAILBLOCK_MASK) & TAILBLOCK_MASK)
                 - ((size + ~TAILBLOCK_MASK) & TAILBLOCK_MASK);
         int newTail;
         boolean wedged = false;
@@ -2881,7 +2906,7 @@
 
         size += oldEbc - newEbc;
         klength += oldEbc - newEbc;
-        int newDb = indexKeyBytes[newEbc] & 0xFF;
+        final int newDb = indexKeyBytes[newEbc] & 0xFF;
 
         putInt(newTail, encodeTailBlock(size, klength));
 
@@ -2897,7 +2922,7 @@
      * @param insertAt
      * @param includesRightEdge
      */
-    void moveRecords(Buffer buffer, int p1, int p2, int insertAt, boolean includesRightEdge) {
+    void moveRecords(final Buffer buffer, final int p1, final int p2, int insertAt, final boolean includesRightEdge) {
         if (p2 - p1 + _keyBlockEnd > _alloc) {
             repack();
         }
@@ -2912,15 +2937,15 @@
             setKeyBlockEnd(getKeyBlockEnd() + KEYBLOCK_LENGTH);
 
         for (int p = p1; p < p2 || includesRightEdge && p == p2; p += KEYBLOCK_LENGTH) {
-            int kbData = buffer.getInt(p);
-            int ebc = decodeKeyBlockEbc(kbData);
-            int db = decodeKeyBlockDb(kbData);
-            int tail = decodeKeyBlockTail(kbData);
-            int tbData = buffer.getInt(tail);
-            int size = decodeTailBlockSize(tbData);
-            int klength = decodeTailBlockKLength(tbData);
+            final int kbData = buffer.getInt(p);
+            final int ebc = decodeKeyBlockEbc(kbData);
+            final int db = decodeKeyBlockDb(kbData);
+            final int tail = decodeKeyBlockTail(kbData);
+            final int tbData = buffer.getInt(tail);
+            final int size = decodeTailBlockSize(tbData);
+            final int klength = decodeTailBlockKLength(tbData);
             int newSize = size;
-            boolean edgeCase = includesRightEdge && p == p2;
+            final boolean edgeCase = includesRightEdge && p == p2;
             if (edgeCase) {
                 // this is just for the right edge key of the left page
                 newSize = _tailHeaderSize + klength;
@@ -2972,7 +2997,7 @@
      */
     private int allocTail(int size) {
         size = (size + ~TAILBLOCK_MASK) & TAILBLOCK_MASK;
-        int alloc = _alloc - size;
+        final int alloc = _alloc - size;
         if (alloc >= _keyBlockEnd) {
             _alloc = alloc;
             return alloc;
@@ -2981,7 +3006,7 @@
         }
     }
 
-    private void deallocTail(int tail, int size) {
+    private void deallocTail(final int tail, int size) {
         size = (size + ~TAILBLOCK_MASK) & TAILBLOCK_MASK;
 
         Debug.$assert0.t((size > 0 && size <= _bufferSize - _alloc) && (tail >= _alloc && tail < _bufferSize)
@@ -2993,9 +3018,9 @@
             // any free space above this block.
             //
             while (tail + size < _bufferSize) {
-                int kbNext = getInt(tail + size);
+                final int kbNext = getInt(tail + size);
                 if ((kbNext & TAILBLOCK_INUSE_MASK) == 0) {
-                    int sizeNext = decodeTailBlockSize(kbNext);
+                    final int sizeNext = decodeTailBlockSize(kbNext);
                     Debug.$assert0.t((sizeNext & ~TAILBLOCK_MASK) == 0 && sizeNext != 0);
                     _slack -= sizeNext;
                     putInt(tail + size, 0);
@@ -3018,7 +3043,7 @@
     private void repack() {
         Debug.$assert0.t(isMine());
 
-        int[] plan = getRepackPlanBuffer();
+        final int[] plan = getRepackPlanBuffer();
         //
         // Phase 1:
         // For each allocated tail block, post the offset of its
@@ -3028,9 +3053,9 @@
         int free = 0;
         int back = 0;
         for (int tail = _alloc; tail < _bufferSize;) {
-            int tbData = getInt(tail);
+            final int tbData = getInt(tail);
 
-            int size = (decodeTailBlockSize(tbData) + ~TAILBLOCK_MASK) & TAILBLOCK_MASK;
+            final int size = (decodeTailBlockSize(tbData) + ~TAILBLOCK_MASK) & TAILBLOCK_MASK;
             if (size <= 0) {
                 _persistit.fatal("Buffer has invalid tailblock length " + size + " at " + tail + " in " + this, null);
             }
@@ -3058,9 +3083,9 @@
             if (free > 0)
                 moveSize += alloc - tail - free;
             alloc = tail + free;
-            int planData = plan[tail / TAILBLOCK_FACTOR];
+            final int planData = plan[tail / TAILBLOCK_FACTOR];
             plan[tail / TAILBLOCK_FACTOR] = free + tail;
-            int deltaFree = planData & 0xFFFF;
+            final int deltaFree = planData & 0xFFFF;
             if (deltaFree > 0 && moveSize > 0 && free > 0) {
                 System.arraycopy(_bytes, moveFrom, _bytes, moveFrom + free, moveSize);
                 moveSize = 0;
@@ -3080,14 +3105,14 @@
         //
         if (free > 0) {
             for (int p = KEY_BLOCK_START; p < _keyBlockEnd; p += KEYBLOCK_LENGTH) {
-                int kbData = getInt(p);
+                final int kbData = getInt(p);
                 //
                 // For certain remove operations, we may have invalid keyblocks
                 // in range. We can safely ignore them here.
                 //
                 if (kbData != 0) {
-                    int tail = decodeKeyBlockTail(kbData);
-                    int newTail = plan[tail / KEYBLOCK_LENGTH];
+                    final int tail = decodeKeyBlockTail(kbData);
+                    final int newTail = plan[tail / KEYBLOCK_LENGTH];
 
                     if (newTail != tail) {
                         putInt(p, encodeKeyBlockTail(kbData, newTail));
@@ -3105,7 +3130,7 @@
      *            The size required by the proposed new tailblock.
      * @return boolean <i>true</i> if it will fit, else <i>false</i>.
      */
-    private boolean willFit(int needed) {
+    private boolean willFit(final int needed) {
         return needed <= (_alloc - _keyBlockEnd + _slack);
     }
 
@@ -3116,8 +3141,8 @@
      * @param foundAt
      *            The keyblock index
      */
-    boolean isAfterRightEdge(int foundAt) {
-        int p = foundAt & P_MASK;
+    boolean isAfterRightEdge(final int foundAt) {
+        final int p = foundAt & P_MASK;
         return (p >= _keyBlockEnd) || ((p == _keyBlockEnd - KEYBLOCK_LENGTH && (foundAt & EXACT_MASK) != 0));
     }
 
@@ -3127,7 +3152,7 @@
      * 
      * @param foundAt
      */
-    boolean isBeforeLeftEdge(int foundAt) {
+    boolean isBeforeLeftEdge(final int foundAt) {
         return (((foundAt & EXACT_MASK) == 0 && (foundAt & P_MASK) <= KEY_BLOCK_START) || (foundAt & P_MASK) < KEY_BLOCK_START);
     }
 
@@ -3136,11 +3161,11 @@
         return _bytes;
     }
 
-    int getByte(int index) {
+    int getByte(final int index) {
         return (_bytes[index] & 0xFF);
     }
 
-    int getChar(int index) {
+    int getChar(final int index) {
         if (Persistit.BIG_ENDIAN) {
             return (_bytes[index + 1] & 0xFF) | (_bytes[index] & 0xFF) << 8;
         } else {
@@ -3148,7 +3173,7 @@
         }
     }
 
-    int getInt(int index) {
+    int getInt(final int index) {
         if (Persistit.BIG_ENDIAN) {
             return (_bytes[index + 3] & 0xFF) | (_bytes[index + 2] & 0xFF) << 8 | (_bytes[index + 1] & 0xFF) << 16
                     | (_bytes[index] & 0xFF) << 24;
@@ -3158,21 +3183,21 @@
         }
     }
 
-    long getLong(int index) {
+    long getLong(final int index) {
         if (Persistit.BIG_ENDIAN) {
-            return (long) (_bytes[index + 7] & 0xFF) | (long) (_bytes[index + 6] & 0xFF) << 8
+            return _bytes[index + 7] & 0xFF | (long) (_bytes[index + 6] & 0xFF) << 8
                     | (long) (_bytes[index + 5] & 0xFF) << 16 | (long) (_bytes[index + 4] & 0xFF) << 24
                     | (long) (_bytes[index + 3] & 0xFF) << 32 | (long) (_bytes[index + 2] & 0xFF) << 40
                     | (long) (_bytes[index + 1] & 0xFF) << 48 | (long) (_bytes[index] & 0xFF) << 56;
         } else {
-            return (long) (_bytes[index] & 0xFF) | (long) (_bytes[index + 1] & 0xFF) << 8
+            return _bytes[index] & 0xFF | (long) (_bytes[index + 1] & 0xFF) << 8
                     | (long) (_bytes[index + 2] & 0xFF) << 16 | (long) (_bytes[index + 3] & 0xFF) << 24
                     | (long) (_bytes[index + 4] & 0xFF) << 32 | (long) (_bytes[index + 5] & 0xFF) << 40
                     | (long) (_bytes[index + 6] & 0xFF) << 48 | (long) (_bytes[index + 7] & 0xFF) << 56;
         }
     }
 
-    int getDb(int index) {
+    int getDb(final int index) {
         if (Persistit.BIG_ENDIAN) {
             return _bytes[index + 3] & 0xFF;
         } else {
@@ -3180,12 +3205,12 @@
         }
     }
 
-    void putByte(int index, int value) {
+    void putByte(final int index, final int value) {
         Debug.$assert0.t(index >= 0 && index + 1 <= _bytes.length);
         _bytes[index] = (byte) (value);
     }
 
-    void putChar(int index, int value) {
+    void putChar(final int index, final int value) {
         Debug.$assert0.t(index >= 0 && index + 2 <= _bytes.length);
         if (Persistit.BIG_ENDIAN) {
             _bytes[index + 1] = (byte) (value);
@@ -3196,7 +3221,7 @@
         }
     }
 
-    void putInt(int index, int value) {
+    void putInt(final int index, final int value) {
         Debug.$assert0.t(index >= 0 && index + 4 <= _bytes.length);
         if (Persistit.BIG_ENDIAN) {
             _bytes[index + 3] = (byte) (value);
@@ -3211,7 +3236,7 @@
         }
     }
 
-    void putLong(int index, long value) {
+    void putLong(final int index, final long value) {
         Debug.$assert0.t(index >= 0 && index + 8 <= _bytes.length);
 
         if (Persistit.BIG_ENDIAN) {
@@ -3235,7 +3260,7 @@
         }
     }
 
-    static void writeLongRecordDescriptor(byte[] bytes, int size, long pageAddr) {
+    static void writeLongRecordDescriptor(final byte[] bytes, final int size, final long pageAddr) {
         if (bytes.length != LONGREC_SIZE) {
             throw new IllegalArgumentException("Bad LONG_RECORD descriptor size: " + size);
         }
@@ -3246,7 +3271,7 @@
         Util.putLong(bytes, LONGREC_PAGE_OFFSET, pageAddr);
     }
 
-    static int decodeLongRecordDescriptorSize(byte[] bytes, int offset) {
+    static int decodeLongRecordDescriptorSize(final byte[] bytes, final int offset) {
         int type;
         if ((type = (bytes[offset] & 0xFF)) != LONGREC_TYPE) {
             throw new IllegalArgumentException("Bad LONG_RECORD descriptor type: " + type);
@@ -3254,7 +3279,7 @@
         return (int) Util.getLong(bytes, offset + LONGREC_SIZE_OFFSET);
     }
 
-    static long decodeLongRecordDescriptorPointer(byte[] bytes, int offset) {
+    static long decodeLongRecordDescriptorPointer(final byte[] bytes, final int offset) {
         int type;
         if ((type = (bytes[offset] & 0xFF)) != LONGREC_TYPE) {
             throw new IllegalArgumentException("Bad LONG_RECORD descriptor type: " + type);
@@ -3263,7 +3288,7 @@
     }
 
     static int bufferSizeWithOverhead(final int bufferSize) {
-        int fastIndexSize = ((bufferSize - HEADER_SIZE) / MAX_KEY_RATIO) * FastIndex.BYTES_PER_ENTRY;
+        final int fastIndexSize = ((bufferSize - HEADER_SIZE) / MAX_KEY_RATIO) * FastIndex.BYTES_PER_ENTRY;
         return bufferSize + fastIndexSize + ESTIMATED_FIXED_BUFFER_OVERHEAD;
     }
 
@@ -3314,16 +3339,16 @@
         return (size + ~TAILBLOCK_MASK) & TAILBLOCK_MASK;
     }
 
-    static int encodeKeyBlock(int ebc, int db, int tail) {
+    static int encodeKeyBlock(final int ebc, final int db, final int tail) {
         return ((ebc << EBC_SHIFT) & EBC_MASK) | ((db /* << DB_SHIFT */) & DB_MASK)
                 | ((tail << TAIL_SHIFT) & TAIL_MASK);
     }
 
-    static int encodeKeyBlockTail(int kbData, int tail) {
+    static int encodeKeyBlockTail(final int kbData, final int tail) {
         return (kbData & ~TAIL_MASK) | ((tail << TAIL_SHIFT) & TAIL_MASK);
     }
 
-    static int encodeTailBlock(int size, int klength) {
+    static int encodeTailBlock(final int size, final int klength) {
         return ((klength << TAILBLOCK_KLENGTH_SHIFT) & TAILBLOCK_KLENGTH_MASK) | ((size /*
                                                                                          * <<
                                                                                          * TAILBLOCK_SIZE_SHIFT
@@ -3331,35 +3356,35 @@
                 | TAILBLOCK_INUSE_MASK;
     }
 
-    static int encodeFreeBlock(int size) {
+    static int encodeFreeBlock(final int size) {
         return ((size /* << TAILBLOCK_SIZE_SHIFT */) & TAILBLOCK_SIZE_MASK);
     }
 
-    static int decodeKeyBlockEbc(int kbData) {
+    static int decodeKeyBlockEbc(final int kbData) {
         return (kbData & EBC_MASK) >>> EBC_SHIFT;
     }
 
-    static int decodeKeyBlockDb(int kbData) {
+    static int decodeKeyBlockDb(final int kbData) {
         return (kbData & DB_MASK) /* >>> DB_SHIFT */;
     }
 
-    static int decodeKeyBlockTail(int kbData) {
+    static int decodeKeyBlockTail(final int kbData) {
         return (kbData & TAIL_MASK) >>> TAIL_SHIFT;
     }
 
-    static int decodeTailBlockSize(int tbData) {
+    static int decodeTailBlockSize(final int tbData) {
         return (tbData & TAILBLOCK_SIZE_MASK) /* >>> TAILBLOCK_SIZE_SHIFT */;
     }
 
-    static int decodeTailBlockKLength(int tbData) {
+    static int decodeTailBlockKLength(final int tbData) {
         return (tbData & TAILBLOCK_KLENGTH_MASK) >>> TAILBLOCK_KLENGTH_SHIFT;
     }
 
-    static boolean decodeTailBlockInUse(int tbData) {
+    static boolean decodeTailBlockInUse(final int tbData) {
         return (tbData & TAILBLOCK_INUSE_MASK) != 0;
     }
 
-    static int decodeDepth(int foundAt) {
+    static int decodeDepth(final int foundAt) {
         return (foundAt & DEPTH_MASK) >>> DEPTH_SHIFT;
     }
 
@@ -3367,7 +3392,7 @@
         return _persistit.getThreadLocalIntArray(MAX_BUFFER_SIZE / TAILBLOCK_FACTOR);
     }
 
-    PersistitException verify(Key key, VerifyVisitor visitor) {
+    PersistitException verify(Key key, final VerifyVisitor visitor) {
         try {
             if (_page == 0) {
                 return new InvalidPageStructureException("head page is neither a data page nor an index page");
@@ -3380,8 +3405,8 @@
                 key = new Key(_persistit);
             }
 
-            byte[] kb = key.getEncodedBytes();
-            int[] plan = getRepackPlanBuffer();
+            final byte[] kb = key.getEncodedBytes();
+            final int[] plan = getRepackPlanBuffer();
             for (int index = 0; index < plan.length; index++) {
                 plan[index] = 0;
             }
@@ -3392,10 +3417,10 @@
             }
 
             for (int p = KEY_BLOCK_START; p < _keyBlockEnd; p += KEYBLOCK_LENGTH) {
-                int kbData = getInt(p);
-                int db = decodeKeyBlockDb(kbData);
-                int ebc = decodeKeyBlockEbc(kbData);
-                int tail = decodeKeyBlockTail(kbData);
+                final int kbData = getInt(p);
+                final int db = decodeKeyBlockDb(kbData);
+                final int ebc = decodeKeyBlockEbc(kbData);
+                final int tail = decodeKeyBlockTail(kbData);
 
                 if (p == KEY_BLOCK_START && ebc != 0) {
                     return new InvalidPageStructureException("invalid initial ebc " + ebc + " for keyblock at " + p
@@ -3407,8 +3432,8 @@
                     return new InvalidPageStructureException("invalid tail block offset " + tail + " for keyblock at "
                             + p + " --[" + summarize() + "]");
                 }
-                int tbData = getInt(tail);
-                int klength = decodeTailBlockKLength(tbData);
+                final int tbData = getInt(tail);
+                final int klength = decodeTailBlockKLength(tbData);
                 if ((tbData & TAILBLOCK_INUSE_MASK) == 0) {
                     return new InvalidPageStructureException("not in-use tail block offset " + tail
                             + " for keyblock at " + p + " --[" + summarize() + "]");
@@ -3426,14 +3451,14 @@
                         compare = (kb[index] & 0xFF) - (_bytes[tail + _tailHeaderSize + index - 1] & 0xFF);
                     }
                     if (compare != 0) {
-                        String s = compare < 0 ? "too big" : "too small";
+                        final String s = compare < 0 ? "too big" : "too small";
                         return new InvalidPageStructureException("initial key " + s + " at offset " + index
                                 + " for keyblock at " + p + " --[" + summarize() + "]");
                     }
                 }
                 // Verify that successor keys follow in sequence.
                 if (p > KEY_BLOCK_START && ebc < key.getEncodedSize()) {
-                    int dbPrev = kb[ebc] & 0xFF;
+                    final int dbPrev = kb[ebc] & 0xFF;
                     if (db < dbPrev) {
                         return new InvalidPageStructureException("db not greater: db=" + db + " dbPrev=" + dbPrev
                                 + " for keyblock at " + p + " --[" + summarize() + "]");
@@ -3444,7 +3469,7 @@
                 // redundant
                 //
                 if (isIndexPage()) {
-                    int pointer = getInt(tail + 4);
+                    final int pointer = getInt(tail + 4);
                     if (visitor != null) {
                         visitor.visitIndexRecord(key, p, tail, klength, pointer);
                     }
@@ -3455,13 +3480,18 @@
                         }
                     }
                 } else if (isDataPage()) {
-                    int size = decodeTailBlockSize(tbData);
-                    int offset = tail + _tailHeaderSize + klength;
-                    int length = size - klength - _tailHeaderSize;
+                    final int size = decodeTailBlockSize(tbData);
+                    final int offset = tail + _tailHeaderSize + klength;
+                    final int length = size - klength - _tailHeaderSize;
                     if (visitor != null) {
                         visitor.visitDataRecord(key, p, tail, klength, offset, length, getBytes());
                     }
-                    Debug.$assert1.t(MVV.verify(_bytes, offset, length));
+
+                    if (!MVV.verify(_bytes, offset, length)) {
+                        throw new InvalidPageStructureException("invalid MVV record at offset/length=" + offset + "/"
+                                + length);
+                    }
+
                 }
 
                 if (_pool != null && getKeyCount() > _pool.getMaxKeys()) {
@@ -3477,13 +3507,13 @@
 
             // Now check the free blocks
 
-            int formerBlock = _alloc;
+            final int formerBlock = _alloc;
             for (int tail = _alloc; tail < _bufferSize;) {
                 if ((tail & ~TAILBLOCK_MASK) != 0 || tail < 0 || tail > _bufferSize) {
                     return new InvalidPageStructureException("Tail block at " + formerBlock + " is invalid");
                 }
-                int tbData = getInt(tail);
-                int size = decodeTailBlockSize(tbData);
+                final int tbData = getInt(tail);
+                final int size = decodeTailBlockSize(tbData);
                 if (size <= ~TAILBLOCK_MASK || size >= _bufferSize - _keyBlockEnd) {
                     return new InvalidPageStructureException("Tailblock at " + tail + " has invalid size=" + size);
                 }
@@ -3492,7 +3522,7 @@
                         return new InvalidPageStructureException("Tailblock at " + tail + " is in use, but no key "
                                 + " block points to it.");
                     }
-                    int klength = decodeTailBlockKLength(tbData);
+                    final int klength = decodeTailBlockKLength(tbData);
                     {
                         if (klength + _tailHeaderSize > size) {
                             return new InvalidPageStructureException("Tailblock at " + tail + " has klength=" + klength
@@ -3508,7 +3538,7 @@
                 tail += ((size + ~TAILBLOCK_MASK) & TAILBLOCK_MASK);
             }
             return null;
-        } catch (PersistitException pe) {
+        } catch (final PersistitException pe) {
             return pe;
         }
 
@@ -3528,7 +3558,7 @@
      * @return
      * @throws PersistitException
      */
-    boolean pruneMvvValues(final Tree tree, boolean pruneLongMVVs) throws PersistitException {
+    boolean pruneMvvValues(final Tree tree, final boolean pruneLongMVVs) throws PersistitException {
 
         boolean changed = false;
         try {
@@ -3541,70 +3571,22 @@
                 final long timestamp = _persistit.getTimestampAllocator().updateTimestamp();
                 _mvvCount = 0;
                 writePageOnCheckpoint(timestamp);
-                List<PrunedVersion> prunedVersions = new ArrayList<PrunedVersion>();
-                for (int p = KEY_BLOCK_START; p < _keyBlockEnd; p += KEYBLOCK_LENGTH) {
-                    final int kbData = getInt(p);
-                    final int tail = decodeKeyBlockTail(kbData);
-                    final int tbData = getInt(tail);
-                    final int klength = decodeTailBlockKLength(tbData);
-                    final int oldTailSize = decodeTailBlockSize(tbData);
-                    final int offset = tail + _tailHeaderSize + klength;
-                    final int oldSize = oldTailSize - klength - _tailHeaderSize;
-
-                    if (oldSize > 0) {
-                        int valueByte = _bytes[offset] & 0xFF;
-                        if (isLongMVV(_bytes, offset, oldSize)) {
-                            /*
-                             * Can't prune in this pass because of long record
-                             * timestamp management. Simply remember that there
-                             * are long records to prune, then prune them in a
-                             * copy of the buffer.
-                             */
-                            hasLongMvvRecords = true;
-                        }
-                        if (valueByte == MVV.TYPE_MVV) {
-                            final int newSize = MVV.prune(_bytes, offset, oldSize, _persistit.getTransactionIndex(),
-                                    true, prunedVersions);
-                            if (newSize != oldSize) {
-                                changed = true;
-                                int newTailSize = klength + newSize + _tailHeaderSize;
-                                int oldNext = (tail + oldTailSize + ~TAILBLOCK_MASK) & TAILBLOCK_MASK;
-                                int newNext = (tail + newTailSize + ~TAILBLOCK_MASK) & TAILBLOCK_MASK;
-                                if (newNext < oldNext) {
-                                    // Free the remainder of the old tail block
-                                    deallocTail(newNext, oldNext - newNext);
-                                } else {
-                                    Debug.$assert0.t(newNext == oldNext);
-                                }
-                                // Rewrite the tail block header
-                                putInt(tail, encodeTailBlock(newTailSize, klength));
-                                if (Debug.ENABLED) {
-                                    MVV.verify(_bytes, offset, newSize);
-                                }
-                            }
-                            valueByte = newSize > 0 ? _bytes[offset] & 0xFF : -1;
-                            incCountIfMvv(_bytes, offset, newSize);
-                        }
-
-                        if (pruneAntiValue(valueByte, p, tree)) {
-                            changed = true;
-                            p -= KEYBLOCK_LENGTH;
-                        }
-                    }
-                }
+                final int flags = pruneMvvValuesHelper(tree);
+                changed = (flags & PRUNE_MVV_HELPER_CHANGED) != 0;
+                hasLongMvvRecords = (flags & PRUNE_MVV_HELPER_HAS_LONG) != 0;
+
                 if (changed) {
                     setDirtyAtTimestamp(timestamp);
                 }
 
-                deallocatePrunedVersions(_persistit, _vol, prunedVersions);
-                prunedVersions.clear();
+                final List<PrunedVersion> prunedVersions = new ArrayList<PrunedVersion>();
 
                 if (pruneLongMVVs && hasLongMvvRecords) {
-                    List<PersistitException> deferredExceptions = new ArrayList<PersistitException>();
-                    List<Long> oldChainsToDeallocate = new ArrayList<Long>();
+                    final List<PersistitException> deferredExceptions = new ArrayList<PersistitException>();
+                    final List<Long> oldChainsToDeallocate = new ArrayList<Long>();
 
-                    Buffer copy = new Buffer(this);
-                    boolean copyChanged = copy.pruneLongMvvValues(tree, prunedVersions, deferredExceptions,
+                    final Buffer copy = new Buffer(this);
+                    final boolean copyChanged = copy.pruneLongMvvValues(tree, prunedVersions, deferredExceptions,
                             oldChainsToDeallocate);
                     if (copyChanged) {
                         changed = true;
@@ -3640,6 +3622,63 @@
         return changed;
     }
 
+    private int pruneMvvValuesHelper(final Tree tree) throws PersistitException {
+        boolean changed = false;
+        boolean hasLongMvvRecords = false;
+        final List<PrunedVersion> prunedVersions = new ArrayList<PrunedVersion>();
+
+        for (int p = KEY_BLOCK_START; p < _keyBlockEnd; p += KEYBLOCK_LENGTH) {
+            final int kbData = getInt(p);
+            final int tail = decodeKeyBlockTail(kbData);
+            final int tbData = getInt(tail);
+            final int klength = decodeTailBlockKLength(tbData);
+            final int oldTailSize = decodeTailBlockSize(tbData);
+            final int offset = tail + _tailHeaderSize + klength;
+            final int oldSize = oldTailSize - klength - _tailHeaderSize;
+
+            if (oldSize > 0) {
+                int valueByte = _bytes[offset] & 0xFF;
+                if (isLongMVV(_bytes, offset, oldSize)) {
+                    /*
+                     * Can't prune in this pass because of long record timestamp
+                     * management. Simply remember that there are long records
+                     * to prune, then prune them in a copy of the buffer.
+                     */
+                    hasLongMvvRecords = true;
+                }
+                if (valueByte == MVV.TYPE_MVV) {
+                    final int newSize = MVV.prune(_bytes, offset, oldSize, _persistit.getTransactionIndex(), true,
+                            prunedVersions);
+                    if (newSize != oldSize) {
+                        changed = true;
+                        final int newTailSize = klength + newSize + _tailHeaderSize;
+                        final int oldNext = (tail + oldTailSize + ~TAILBLOCK_MASK) & TAILBLOCK_MASK;
+                        final int newNext = (tail + newTailSize + ~TAILBLOCK_MASK) & TAILBLOCK_MASK;
+                        if (newNext < oldNext) {
+                            // Free the remainder of the old tail block
+                            deallocTail(newNext, oldNext - newNext);
+                        } else {
+                            Debug.$assert0.t(newNext == oldNext);
+                        }
+                        // Rewrite the tail block header
+                        putInt(tail, encodeTailBlock(newTailSize, klength));
+                        Debug.$assert0.t(MVV.verify(_bytes, offset, newSize));
+                    }
+                    valueByte = newSize > 0 ? _bytes[offset] & 0xFF : -1;
+                    incCountIfMvv(_bytes, offset, newSize);
+                }
+
+                if (pruneAntiValue(valueByte, p, tree)) {
+                    changed = true;
+                    p -= KEYBLOCK_LENGTH;
+                }
+            }
+        }
+        deallocatePrunedVersions(_persistit, _vol, prunedVersions);
+        prunedVersions.clear();
+        return (changed ? PRUNE_MVV_HELPER_CHANGED : 0) | (hasLongMvvRecords ? PRUNE_MVV_HELPER_HAS_LONG : 0);
+    }
+
     /**
      * This method attempts to prune each LongRecord MVVs found in the page.
      * This method is performed on a _copy_ of the original Buffer being pruned;
@@ -3666,17 +3705,17 @@
                     boolean pruned = false;
                     try {
                         pruned = pruneLongMvv(_bytes, offset, oldSize, value, prunedVersions, toDeallocate);
-                    } catch (PersistitException pe) {
+                    } catch (final PersistitException pe) {
                         deferredExceptions.add(pe);
                     }
                     if (pruned) {
                         changed = true;
-                        int newSize = value.getEncodedSize();
+                        final int newSize = value.getEncodedSize();
                         assert newSize <= oldSize : "Pruned long value overflow";
                         System.arraycopy(value.getEncodedBytes(), 0, _bytes, offset, newSize);
-                        int newTailSize = klength + newSize + _tailHeaderSize;
-                        int oldNext = (tail + oldTailSize + ~TAILBLOCK_MASK) & TAILBLOCK_MASK;
-                        int newNext = (tail + newTailSize + ~TAILBLOCK_MASK) & TAILBLOCK_MASK;
+                        final int newTailSize = klength + newSize + _tailHeaderSize;
+                        final int oldNext = (tail + oldTailSize + ~TAILBLOCK_MASK) & TAILBLOCK_MASK;
+                        final int newNext = (tail + newTailSize + ~TAILBLOCK_MASK) & TAILBLOCK_MASK;
                         if (newNext < oldNext) {
                             // Free the remainder of the old tail block
                             deallocTail(newNext, oldNext - newNext);
@@ -3709,8 +3748,7 @@
                     if (!_enqueuedForAntiValuePruning) {
                         final int treeHandle = tree.getHandle();
                         assert treeHandle != 0 : "MVV found in a temporary tree " + tree;
-                        if (_persistit.getCleanupManager().offer(
-                                new CleanupAntiValue(treeHandle, getPageAddress()))) {
+                        if (_persistit.getCleanupManager().offer(new CleanupAntiValue(treeHandle, getPageAddress()))) {
                             _enqueuedForAntiValuePruning = true;
                         }
                     }
@@ -3731,19 +3769,19 @@
     private boolean pruneLongMvv(final byte[] bytes, final int offset, final int oldSize, final Value value,
             final List<PrunedVersion> prunedVersions, final List<Long> toDeallocate) throws PersistitException {
         assert isLongMVV(bytes, offset, oldSize) : "Not a long MVV";
-        long oldLongRecordChain = decodeLongRecordDescriptorPointer(bytes, offset);
+        final long oldLongRecordChain = decodeLongRecordDescriptorPointer(bytes, offset);
         value.changeLongRecordMode(false);
         value.ensureFit(oldSize);
         System.arraycopy(bytes, offset, value.getEncodedBytes(), 0, oldSize);
         value.setEncodedSize(oldSize);
         final LongRecordHelper helper = new LongRecordHelper(_persistit, _vol);
         helper.fetchLongRecord(value, Integer.MAX_VALUE);
-        byte[] rawBytes = value.getEncodedBytes();
-        int oldLongSize = value.getEncodedSize();
+        final byte[] rawBytes = value.getEncodedBytes();
+        final int oldLongSize = value.getEncodedSize();
         // TODO - perhaps remove. Done as a precaution for now.
-        MVV.verify(rawBytes, 0, oldLongSize);
-        List<PrunedVersion> provisionalPrunedVersions = new ArrayList<PrunedVersion>();
-        int newLongSize = MVV.prune(rawBytes, 0, oldLongSize, _persistit.getTransactionIndex(), true,
+        Debug.$assert0.t(MVV.verify(rawBytes, 0, oldLongSize));
+        final List<PrunedVersion> provisionalPrunedVersions = new ArrayList<PrunedVersion>();
+        final int newLongSize = MVV.prune(rawBytes, 0, oldLongSize, _persistit.getTransactionIndex(), true,
                 provisionalPrunedVersions);
         if (newLongSize == oldLongSize) {
             // No pruning done.
@@ -3771,6 +3809,7 @@
                 getTimestamp(), getGeneration());
     }
 
+    @Override
     public String toString() {
         if (_toStringDebug) {
             return toStringDetail();
@@ -3818,7 +3857,7 @@
                 }
                 boolean elision = false;
                 for (int index = 0; index < records.length; index++) {
-                    RecordInfo r = records[index];
+                    final RecordInfo r = records[index];
                     r.getKeyState().copyTo(key);
                     String mark = " ";
                     boolean selected = all | index < contextLines || index >= records.length - contextLines;
@@ -3843,16 +3882,16 @@
                                     r.getValueState().getEncodedBytes().length, Util.abridge(value.toString(),
                                             maxValueDisplayLength)));
                         } else {
-                            sb.append(String.format("\n%s  %5d: db=%3d ebc=%3d tb=%,5d [%,d]%s->%,d", mark, r
-                                    .getKbOffset(), r.getDb(), r.getEbc(), r.getTbOffset(), r.getKLength(), Util
-                                    .abridge(key.toString(), maxKeyDisplayLength), r.getPointerValue()));
+                            sb.append(String.format("\n%s  %5d: db=%3d ebc=%3d tb=%,5d [%,d]%s->%,d", mark,
+                                    r.getKbOffset(), r.getDb(), r.getEbc(), r.getTbOffset(), r.getKLength(),
+                                    Util.abridge(key.toString(), maxKeyDisplayLength), r.getPointerValue()));
                         }
                     } else {
                         elision = true;
                     }
 
                 }
-            } catch (Exception e) {
+            } catch (final Exception e) {
                 sb.append(" - " + e);
             }
         } else if (isHeadPage()) {
@@ -3876,7 +3915,7 @@
     }
 
     String foundAtString(int p) {
-        StringBuilder sb = new StringBuilder("<");
+        final StringBuilder sb = new StringBuilder("<");
         sb.append(p & P_MASK);
         if ((p & EXACT_MASK) != 0)
             sb.append(":exact");
@@ -3892,7 +3931,7 @@
         else if (p + KEYBLOCK_LENGTH == _keyBlockEnd)
             sb.append(":end");
         else {
-            int kbData = getInt(p);
+            final int kbData = getInt(p);
             sb.append(":ebc=" + decodeKeyBlockEbc(kbData));
             sb.append(":db=" + decodeKeyBlockDb(kbData));
             sb.append(":tail=" + decodeKeyBlockTail(kbData));
@@ -3908,23 +3947,23 @@
         ManagementImpl.RecordInfo[] result = null;
 
         if (isIndexPage() || isDataPage()) {
-            Key key = new Key(_persistit);
-            Value value = new Value(_persistit);
+            final Key key = new Key(_persistit);
+            final Value value = new Value(_persistit);
 
-            int count = (_keyBlockEnd - KEY_BLOCK_START) / KEYBLOCK_LENGTH;
+            final int count = (_keyBlockEnd - KEY_BLOCK_START) / KEYBLOCK_LENGTH;
             result = new ManagementImpl.RecordInfo[count];
             int n = 0;
             for (int p = KEY_BLOCK_START; p < _keyBlockEnd; p += KEYBLOCK_LENGTH) {
-                int kbData = getInt(p);
-                int db = decodeKeyBlockDb(kbData);
-                int ebc = decodeKeyBlockEbc(kbData);
-                int tail = decodeKeyBlockTail(kbData);
-                int tbData = tail != 0 ? getInt(tail) : 0;
-                int size = decodeTailBlockSize(tbData);
-                int klength = decodeTailBlockKLength(tbData);
-                boolean inUse = decodeTailBlockInUse(tbData);
+                final int kbData = getInt(p);
+                final int db = decodeKeyBlockDb(kbData);
+                final int ebc = decodeKeyBlockEbc(kbData);
+                final int tail = decodeKeyBlockTail(kbData);
+                final int tbData = tail != 0 ? getInt(tail) : 0;
+                final int size = decodeTailBlockSize(tbData);
+                final int klength = decodeTailBlockKLength(tbData);
+                final boolean inUse = decodeTailBlockInUse(tbData);
 
-                ManagementImpl.RecordInfo rec = new ManagementImpl.RecordInfo();
+                final ManagementImpl.RecordInfo rec = new ManagementImpl.RecordInfo();
                 rec._kbOffset = p;
                 rec._tbOffset = tail;
                 rec._ebc = ebc;
@@ -3933,7 +3972,7 @@
                 rec._size = size;
                 rec._inUse = inUse;
 
-                byte[] kbytes = key.getEncodedBytes();
+                final byte[] kbytes = key.getEncodedBytes();
                 kbytes[ebc] = (byte) db;
                 System.arraycopy(_bytes, tail + _tailHeaderSize, kbytes, ebc + 1, klength);
                 key.setEncodedSize(ebc + 1 + klength);
@@ -3956,11 +3995,11 @@
                 result[n++] = rec;
             }
         } else if (isGarbagePage()) {
-            int count = (_bufferSize - _alloc) / GARBAGE_BLOCK_SIZE;
+            final int count = (_bufferSize - _alloc) / GARBAGE_BLOCK_SIZE;
             result = new ManagementImpl.RecordInfo[count];
             int n = 0;
             for (int p = _alloc; p < _bufferSize; p += GARBAGE_BLOCK_SIZE) {
-                ManagementImpl.RecordInfo rec = new ManagementImpl.RecordInfo();
+                final ManagementImpl.RecordInfo rec = new ManagementImpl.RecordInfo();
                 rec._tbOffset = p;
                 rec._garbageStatus = getInt(p + GARBAGE_BLOCK_STATUS);
                 rec._garbageLeftPage = getLong(p + GARBAGE_BLOCK_LEFT_PAGE);
@@ -3973,12 +4012,12 @@
 
     void assertVerify() {
         if (Debug.VERIFY_PAGES) {
-            Exception verifyException = verify(null, null);
+            final Exception verifyException = verify(null, null);
             Debug.$assert1.t(verifyException == null);
         }
     }
 
-    boolean addGarbageChain(long left, long right, long expectedCount) {
+    boolean addGarbageChain(final long left, final long right, final long expectedCount) {
         Debug.$assert0.t(left > 0 && left <= MAX_VALID_PAGE_ADDR && left != _page && right != _page && isGarbagePage());
 
         if (_alloc - GARBAGE_BLOCK_SIZE < _keyBlockEnd) {
@@ -4006,7 +4045,7 @@
         Debug.$assert0.t(isGarbagePage());
         if (_alloc + GARBAGE_BLOCK_SIZE > _bufferSize)
             return -1;
-        long page = getLong(_alloc + GARBAGE_BLOCK_LEFT_PAGE);
+        final long page = getLong(_alloc + GARBAGE_BLOCK_LEFT_PAGE);
         Debug.$assert0.t(page > 0 && page <= MAX_VALID_PAGE_ADDR && page != _page);
         return page;
     }
@@ -4019,13 +4058,13 @@
             return getLong(_alloc + GARBAGE_BLOCK_RIGHT_PAGE);
     }
 
-    long getGarbageChainLeftPage(int p) {
-        long page = getLong(p + GARBAGE_BLOCK_LEFT_PAGE);
+    long getGarbageChainLeftPage(final int p) {
+        final long page = getLong(p + GARBAGE_BLOCK_LEFT_PAGE);
         Debug.$assert1.t(page > 0 && page <= MAX_VALID_PAGE_ADDR && page != _page);
         return page;
     }
 
-    long getGarbageChainRightPage(int p) {
+    long getGarbageChainRightPage(final int p) {
         return getLong(p + GARBAGE_BLOCK_RIGHT_PAGE);
     }
 
@@ -4036,18 +4075,18 @@
         bumpGeneration();
     }
 
-    void setGarbageLeftPage(long left) {
+    void setGarbageLeftPage(final long left) {
         Debug.$assert1.t(isMine() && isGarbagePage() && left > 0 && left <= MAX_VALID_PAGE_ADDR && left != _page
                 && _alloc + GARBAGE_BLOCK_SIZE <= _bufferSize && _alloc >= _keyBlockEnd);
         putLong(_alloc + GARBAGE_BLOCK_LEFT_PAGE, left);
         bumpGeneration();
     }
 
-    void populateInfo(ManagementImpl.BufferInfo info) {
+    void populateInfo(final ManagementImpl.BufferInfo info) {
         info.poolIndex = _poolIndex;
         info.pageAddress = _page;
         info.rightSiblingAddress = _rightSibling;
-        Volume vol = _vol;
+        final Volume vol = _vol;
         if (vol != null) {
             info.volumeName = vol.getPath();
         } else {
@@ -4064,7 +4103,7 @@
         info.timestamp = _timestamp;
         info.status = getStatus();
         info.statusName = getStatusCode();
-        Thread writerThread = getWriterThread();
+        final Thread writerThread = getWriterThread();
         if (writerThread != null) {
             info.writerThreadName = writerThread.getName();
         } else {
@@ -4075,10 +4114,10 @@
 
     void enqueuePruningAction(final int treeHandle) {
         if (_mvvCount > 0) {
-            long delay = _persistit.getCleanupManager().getMinimumPruningDelay();
+            final long delay = _persistit.getCleanupManager().getMinimumPruningDelay();
             if (delay > 0) {
-                long last = _lastPrunedTime;
-                long now = System.currentTimeMillis();
+                final long last = _lastPrunedTime;
+                final long now = System.currentTimeMillis();
                 if (now - last > delay) {
                     _lastPrunedTime = now;
                     _persistit.getCleanupManager().offer(
@@ -4105,9 +4144,9 @@
      *            writes an IV record.
      * @throws Exception
      */
-    void dump(final ByteBuffer bb, final boolean secure, boolean verbose, final Set<Volume> identifiedVolumes)
+    void dump(final ByteBuffer bb, final boolean secure, final boolean verbose, final Set<Volume> identifiedVolumes)
             throws Exception {
-        byte[] bytes = new byte[_bufferSize];
+        final byte[] bytes = new byte[_bufferSize];
         int type;
         int keyBlockEnd;
         int alloc;
@@ -4120,7 +4159,7 @@
         /*
          * Copy all the information needed quickly and then release the buffer.
          */
-        boolean claimed = claim(false, Persistit.SHORT_DELAY);
+        final boolean claimed = claim(false, Persistit.SHORT_DELAY);
         try {
             bufferSize = _bufferSize;
             type = _type;
@@ -4138,12 +4177,12 @@
             }
         }
 
-        String toString = toString();
+        final String toString = toString();
         if (verbose) {
             System.out.println(toString);
         }
 
-        int volumeHandle = volume == null ? 0 : volume.getHandle();
+        final int volumeHandle = volume == null ? 0 : volume.getHandle();
         if (volume != null && !identifiedVolumes.contains(volume)) {
             IV.putType(bb);
             IV.putHandle(bb, volumeHandle);
@@ -4154,9 +4193,9 @@
             identifiedVolumes.add(volume);
         }
 
-        boolean isDataPage = type == PAGE_TYPE_DATA;
-        boolean isIndexPage = type >= PAGE_TYPE_INDEX_MIN && type <= PAGE_TYPE_INDEX_MAX;
-        boolean isLongRecordPage = type == PAGE_TYPE_LONG_RECORD;
+        final boolean isDataPage = type == PAGE_TYPE_DATA;
+        final boolean isIndexPage = type >= PAGE_TYPE_INDEX_MIN && type <= PAGE_TYPE_INDEX_MAX;
+        final boolean isLongRecordPage = type == PAGE_TYPE_LONG_RECORD;
 
         /*
          * Following is equivalent to the save method, except written to the
@@ -4187,7 +4226,7 @@
         } else if (secure && isLongRecordPage) {
             left = KEY_BLOCK_START;
         }
-        int recordSize = PA.OVERHEAD + left + right;
+        final int recordSize = PA.OVERHEAD + left + right;
         PA.putLength(bb, recordSize);
         PA.putType(bb);
         PA.putVolumeHandle(bb, volumeHandle);
@@ -4207,7 +4246,7 @@
      * @param bytes
      *            buffer image
      */
-    private void dumpSecureOverwriteValues(byte[] bytes) {
+    private void dumpSecureOverwriteValues(final byte[] bytes) {
         if (bytes[0] != PAGE_TYPE_DATA) {
             return;
         }
@@ -4216,12 +4255,12 @@
          * overwrite values.
          */
         for (int p = KEY_BLOCK_START; p < Util.getInt(bytes, KEY_BLOCK_END_OFFSET); p += KEYBLOCK_LENGTH) {
-            int kbData = Util.getInt(bytes, p);
-            int db = decodeKeyBlockDb(kbData);
+            final int kbData = Util.getInt(bytes, p);
+            final int db = decodeKeyBlockDb(kbData);
             if (db == 0 && p == KEY_BLOCK_START) {
                 continue;
             } else if (db == Key.TYPE_STRING) {
-                int tail = decodeKeyBlockTail(kbData);
+                final int tail = decodeKeyBlockTail(kbData);
                 if (bytes[tail + TAILBLOCK_HDR_SIZE_DATA] == '_') {
                     // Probably a system key - don't overwrite values
                     return;
@@ -4235,9 +4274,9 @@
 
         int tail = Util.getChar(bytes, FREE_OFFSET);
         for (; tail < bytes.length;) {
-            int tbData = Util.getInt(bytes, tail);
-            int tbSize = (decodeTailBlockSize(tbData) + ~TAILBLOCK_MASK) & TAILBLOCK_MASK;
-            int tbKLength = decodeTailBlockKLength(tbData);
+            final int tbData = Util.getInt(bytes, tail);
+            final int tbSize = (decodeTailBlockSize(tbData) + ~TAILBLOCK_MASK) & TAILBLOCK_MASK;
+            final int tbKLength = decodeTailBlockKLength(tbData);
             //
             // If the tbSize field is corrupt then just dump the
             // remainder of the buffer
@@ -4250,7 +4289,7 @@
             // Otherwise, dump just the portion of the tailblock we
             // need for analysis and fill the rest with 'x's.
             //
-            boolean tbInUse = decodeTailBlockInUse(tbData);
+            final boolean tbInUse = decodeTailBlockInUse(tbData);
             // Number of bytes we need to dump
             int keep;
             if (tbInUse) {
@@ -4272,7 +4311,8 @@
         }
     }
 
-    static void deallocatePrunedVersions(Persistit persistit, Volume volume, List<PrunedVersion> prunedVersions) {
+    static void deallocatePrunedVersions(final Persistit persistit, final Volume volume,
+            final List<PrunedVersion> prunedVersions) {
         for (final PrunedVersion pv : prunedVersions) {
             final TransactionStatus ts = persistit.getTransactionIndex().getStatus(pv.getTs());
             if (ts != null && ts.getTc() == TransactionStatus.ABORTED) {
@@ -4281,7 +4321,7 @@
             if (pv.getLongRecordPage() != 0) {
                 try {
                     volume.getStructure().deallocateGarbageChain(pv.getLongRecordPage(), 0);
-                } catch (PersistitException e) {
+                } catch (final PersistitException e) {
                     persistit.getLogBase().pruneException.log(e, ts);
                 }
             }
@@ -4289,20 +4329,20 @@
         prunedVersions.clear();
     }
 
-    static boolean isLongRecord(byte[] bytes, int offset, int length) {
+    static boolean isLongRecord(final byte[] bytes, final int offset, final int length) {
         return (length > 0) && ((bytes[offset] & 0xFF) == LONGREC_TYPE);
     }
 
-    static boolean isLongMVV(byte[] bytes, int offset, int length) {
+    static boolean isLongMVV(final byte[] bytes, final int offset, final int length) {
         return isLongRecord(bytes, offset, length) && (length > LONGREC_PREFIX_OFFSET)
                 && MVV.isArrayMVV(bytes, offset + LONGREC_PREFIX_OFFSET, length - LONGREC_PREFIX_OFFSET);
     }
 
-    static boolean isValueMVV(byte[] bytes, int offset, int length) {
+    static boolean isValueMVV(final byte[] bytes, final int offset, final int length) {
         return MVV.isArrayMVV(bytes, offset, length) || isLongMVV(bytes, offset, length);
     }
 
-    private void incCountIfMvv(byte[] bytes, int offset, int length) {
+    private void incCountIfMvv(final byte[] bytes, final int offset, final int length) {
         if (isValueMVV(bytes, offset, length)) {
             ++_mvvCount;
         }

=== modified file 'src/main/java/com/persistit/BufferPool.java'
--- src/main/java/com/persistit/BufferPool.java	2012-08-07 21:11:28 +0000
+++ src/main/java/com/persistit/BufferPool.java	2012-08-24 18:21:22 +0000
@@ -16,9 +16,13 @@
 package com.persistit;
 
 import java.io.DataOutputStream;
+import java.io.IOException;
 import java.nio.ByteBuffer;
+import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Collections;
 import java.util.HashSet;
+import java.util.List;
 import java.util.Set;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicInteger;
@@ -26,6 +30,7 @@
 import java.util.concurrent.atomic.AtomicLongArray;
 import java.util.concurrent.locks.ReentrantLock;
 
+import com.persistit.JournalManager.PageNode;
 import com.persistit.exception.InUseException;
 import com.persistit.exception.InvalidPageAddressException;
 import com.persistit.exception.InvalidPageStructureException;
@@ -36,7 +41,6 @@
 import com.persistit.exception.VolumeClosedException;
 import com.persistit.util.Debug;
 import com.persistit.util.Util;
-import java.io.*;
 
 /**
  * A pool of {@link Buffer} objects, maintained on various lists that permit
@@ -52,7 +56,7 @@
     private final static long DEFAULT_WRITER_POLL_INTERVAL = 5000;
 
     private final static int PAGE_WRITER_TRANCHE_SIZE = 5000;
-    
+
     /**
      * Sleep time when buffers are exhausted
      */
@@ -87,6 +91,17 @@
      */
     private final static int WRITE_AGE_THRESHOLD_RATIO = 4;
 
+    private final static String INVENTORY_TREE_NAME = "_buffers";
+    /**
+     * Maximum number of buffer inventory versions to retain
+     */
+    private final static int INVENTORY_VERSIONS = 3;
+
+    /**
+     * Preload log multiple
+     */
+    private final static int INVENTORY_PRELOAD_LOG_MESSAGE_MULTIPLE = 10000;
+
     /**
      * The Persistit instance that references this BufferPool.
      */
@@ -148,7 +163,7 @@
     /**
      * Count of newly created pages
      */
-    private AtomicLong _newCounter = new AtomicLong();
+    private final AtomicLong _newCounter = new AtomicLong();
 
     /**
      * Count of valid buffers evicted to make room for another page.
@@ -188,7 +203,7 @@
      * Timestamp to which all dirty pages should be written. PAGE_WRITER writes
      * any page with a lower update timestamp regardless of urgency.
      */
-    private AtomicLong _flushTimestamp = new AtomicLong();
+    private final AtomicLong _flushTimestamp = new AtomicLong();
 
     /**
      * Polling interval for PageWriter
@@ -196,24 +211,12 @@
     private volatile long _writerPollInterval = DEFAULT_WRITER_POLL_INTERVAL;
 
     private volatile int _pageWriterTrancheSize = PAGE_WRITER_TRANCHE_SIZE;
-    
-    /**
-     * Polling interval for PageCacher
-     */
-    private volatile long _cacherPollInterval;
-    
+
     /**
      * The PAGE_WRITER IOTaskRunnable
      */
     private PageWriter _writer;
-    
-    /**
-     * The PAGE_CACHER IOTaskRunnable
-     */
-    private PageCacher _cacher;
-        
-    private String _defaultLogPath;
-    
+
     /**
      * Construct a BufferPool with the specified count of <code>Buffer</code>s
      * of the specified size.
@@ -223,7 +226,7 @@
      * @param size
      *            The size (in bytes) of each buffer
      */
-    BufferPool(int count, int size, Persistit persistit) {
+    BufferPool(final int count, final int size, final Persistit persistit) {
         _persistit = persistit;
         if (count < MINIMUM_POOL_COUNT) {
             throw new IllegalArgumentException("Buffer pool count too small: " + count);
@@ -250,7 +253,7 @@
         _hashTable = new Buffer[_bufferCount * HASH_MULTIPLE];
         _hashLocks = new ReentrantLock[HASH_LOCKS];
         _maxKeys = (_bufferSize - Buffer.HEADER_SIZE) / Buffer.MAX_KEY_RATIO;
-        
+
         for (int index = 0; index < HASH_LOCKS; index++) {
             _hashLocks[index] = new ReentrantLock();
         }
@@ -263,11 +266,11 @@
         byte[] reserve = new byte[1024 * 1024];
         try {
             for (int index = 0; index < _bufferCount; index++) {
-                Buffer buffer = new Buffer(size, index, this, _persistit);
+                final Buffer buffer = new Buffer(size, index, this, _persistit);
                 _buffers[index] = buffer;
                 buffers++;
             }
-        } catch (OutOfMemoryError e) {
+        } catch (final OutOfMemoryError e) {
             //
             // Note: written this way to try to avoid another OOME.
             // Do not use String.format here.
@@ -284,38 +287,6 @@
             throw e;
         }
         _writer = new PageWriter();
-        _cacher = new PageCacher();
-    }
-    
-    void warmupBufferPool(String pathName, String fname) throws PersistitException {
-        File file = new File(pathName, fname + ".log");
-        _defaultLogPath = file.getAbsolutePath();
-        
-        try {
-            if (!file.exists()) {
-               file.createNewFile();
-            }
-            
-            BufferedReader reader = new BufferedReader(new FileReader(file));
-            String currLine;
-            while ((currLine = reader.readLine()) != null) {
-                String[] info = currLine.split(" ");
-                if (info.length == 2) {
-                    Volume vol = _persistit.getVolume(info[1]);
-                    if (vol != null) {
-                        long page = Long.parseLong(info[0]);
-                    	Buffer buff = get(vol, page, false, true);
-                    	buff.release();
-                    }
-                }
-            }
-            reader.close();
-            _cacherPollInterval = _persistit.getConfiguration().getBufferInventoryPollingInterval();
-            _cacher.start();
-        }
-        catch (IOException e) {
-            throw new PersistitException(e);
-        }
     }
 
     void startThreads() throws PersistitException {
@@ -325,18 +296,15 @@
     void close() {
         _closed.set(true);
         _persistit.waitForIOTaskStop(_writer);
-        _persistit.waitForIOTaskStop(_cacher);
         _writer = null;
-        _cacher = null;
     }
 
     /**
-     * Abruptly stop (using {@link Thread#stop()}) the writer, cacher, and collector
-     * threads. This method should be used only by tests.
+     * Abruptly stop (using {@link Thread#stop()}) the writer, cacher, and
+     * collector threads. This method should be used only by tests.
      */
     void crash() {
         IOTaskRunnable.crash(_writer);
-        IOTaskRunnable.crash(_cacher);
     }
 
     void flush(final long timestamp) throws PersistitInterruptedException {
@@ -351,14 +319,14 @@
         return _flushTimestamp.get() != 0;
     }
 
-    int hashIndex(Volume vol, long page) {
+    int hashIndex(final Volume vol, final long page) {
         return (int) (((page ^ vol.hashCode()) & Integer.MAX_VALUE) % _hashTable.length);
     }
 
-    int countInUse(Volume vol, boolean writer) {
+    int countInUse(final Volume vol, final boolean writer) {
         int count = 0;
         for (int i = 0; i < _bufferCount; i++) {
-            Buffer buffer = _buffers[i];
+            final Buffer buffer = _buffers[i];
             if ((vol == null || buffer.getVolume() == vol)
                     && ((buffer.getStatus() & SharedResource.CLAIMED_MASK) != 0 && (!writer || (buffer.getStatus() & SharedResource.WRITER_MASK) != 0))) {
                 count++;
@@ -367,7 +335,7 @@
         return count;
     }
 
-    void populateBufferPoolInfo(ManagementImpl.BufferPoolInfo info) {
+    void populateBufferPoolInfo(final ManagementImpl.BufferPoolInfo info) {
         info.bufferCount = _bufferCount;
         info.bufferSize = _bufferSize;
         info.missCount = _missCounter.get();
@@ -383,8 +351,8 @@
         int writerClaimedPages = 0;
 
         for (int index = 0; index < _bufferCount; index++) {
-            Buffer buffer = _buffers[index];
-            int status = buffer.getStatus();
+            final Buffer buffer = _buffers[index];
+            final int status = buffer.getStatus();
             if ((status & SharedResource.VALID_MASK) != 0)
                 validPages++;
             if ((status & SharedResource.WRITER_MASK) != 0)
@@ -400,12 +368,13 @@
         info.updateAcquisitonTime();
     }
 
-    int populateInfo(ManagementImpl.BufferInfo[] array, int traveralType, int includeMask, int excludeMask) {
+    int populateInfo(final ManagementImpl.BufferInfo[] array, final int traveralType, final int includeMask,
+            final int excludeMask) {
         int index = 0;
         switch (traveralType) {
         case 0:
             for (int i = 0; i < _bufferCount; i++) {
-                Buffer buffer = _buffers[i];
+                final Buffer buffer = _buffers[i];
                 if (selected(buffer, includeMask, excludeMask)) {
                     populateInfo1(array, index, buffer);
                     index++;
@@ -420,44 +389,15 @@
         return index;
     }
 
-    private static void populateInfo1(ManagementImpl.BufferInfo[] array, int index, Buffer buffer) {
+    private static void populateInfo1(final ManagementImpl.BufferInfo[] array, final int index, final Buffer buffer) {
         if (index < array.length) {
             if (array[index] == null)
                 array[index] = new ManagementImpl.BufferInfo();
             buffer.populateInfo(array[index]);
         }
     }
-    
-    private void populateWarmupFile() throws PersistitException {
-        File file = new File(_defaultLogPath);
-        
-        try {
-            BufferedWriter writer = new BufferedWriter(new FileWriter(file));
-            for (int i = 0; i < _buffers.length; ++i) {
-                Buffer b = _buffers[i];
-                if (b != null && b.isValid() && !b.isDirty()) {
-                    long page = b.getPageAddress();
-                    Volume volume = b.getVolume();
-                    long page2 = b.getPageAddress();
-                    Volume volume2 = b.getVolume();
-                    
-                    // Check if buffer has changed while reading
-                    if (page == page2 && volume == volume2 && volume != null) {
-                        String addr = Long.toString(page);
-                        String vol = volume.getName(); 
-                        writer.append(addr + " " + vol);
-                        writer.newLine();
-                        writer.flush();
-                    }
-                }
-            }
-            writer.close();
-        } catch (IOException e) {
-            throw new PersistitException(e);
-        }
-    }
 
-    private boolean selected(Buffer buffer, int includeMask, int excludeMask) {
+    private boolean selected(final Buffer buffer, final int includeMask, final int excludeMask) {
         return ((includeMask == 0) || (buffer.getStatus() & includeMask) != 0)
                 && (buffer.getStatus() & excludeMask) == 0;
     }
@@ -599,7 +539,7 @@
      *            The volume
      * @throws PersistitInterruptedException
      */
-    boolean invalidate(Volume volume) throws PersistitInterruptedException {
+    boolean invalidate(final Volume volume) throws PersistitInterruptedException {
         final float ratio = (float) volume.getStorage().getNextAvailablePage() / (float) _bufferCount;
         if (ratio < SMALL_VOLUME_RATIO) {
             return invalidateSmallVolume(volume);
@@ -612,7 +552,7 @@
         boolean result = true;
         int markedAvailable = 0;
         for (long page = 1; page < volume.getStorage().getNextAvailablePage(); page++) {
-            int hashIndex = hashIndex(volume, page);
+            final int hashIndex = hashIndex(volume, page);
             _hashLocks[hashIndex % HASH_LOCKS].lock();
             try {
                 for (Buffer buffer = _hashTable[hashIndex]; buffer != null; buffer = buffer.getNext()) {
@@ -630,9 +570,9 @@
                                 buffer.release();
                             }
                             if (invalidated) {
-                                int q = buffer.getIndex() / 64;
-                                int p = buffer.getIndex() % 64;
-                                long bits = _availablePagesBits.get(q);
+                                final int q = buffer.getIndex() / 64;
+                                final int p = buffer.getIndex() % 64;
+                                final long bits = _availablePagesBits.get(q);
                                 if (_availablePagesBits.compareAndSet(q, bits, bits | (1L << p))) {
                                     markedAvailable++;
                                 }
@@ -657,7 +597,7 @@
         boolean result = true;
         int markedAvailable = 0;
         for (int index = 0; index < _bufferCount; index++) {
-            Buffer buffer = _buffers[index];
+            final Buffer buffer = _buffers[index];
             if ((buffer.getVolume() == volume || volume == null) && !buffer.isFixed() && buffer.isValid()) {
                 if (buffer.claim(true, 0)) {
                     // re-check after claim
@@ -671,9 +611,9 @@
                         buffer.release();
                     }
                     if (invalidated) {
-                        int q = buffer.getIndex() / 64;
-                        int p = buffer.getIndex() % 64;
-                        long bits = _availablePagesBits.get(q);
+                        final int q = buffer.getIndex() / 64;
+                        final int p = buffer.getIndex() % 64;
+                        final long bits = _availablePagesBits.get(q);
                         if (_availablePagesBits.compareAndSet(q, bits, bits | (1L << p))) {
                             markedAvailable++;
                         }
@@ -689,29 +629,33 @@
         return result;
     }
 
-    private void invalidate(Buffer buffer) {
+    private void invalidate(final Buffer buffer) {
         Debug.$assert0.t(buffer.isValid() && buffer.isMine());
 
         while (!detach(buffer)) {
             //
-            // Spin until detach succeeds. Note: this method must not throw an Exception
-            // because it is called in at at critical time when cleanup must be done.
-            // It is not possible to lock the hash bucket here due to possible deadlock.
-            // However, the likelihood of a lengthy live-lock is infinitesimal so polling
+            // Spin until detach succeeds. Note: this method must not throw an
+            // Exception
+            // because it is called in at at critical time when cleanup must be
+            // done.
+            // It is not possible to lock the hash bucket here due to possible
+            // deadlock.
+            // However, the likelihood of a lengthy live-lock is infinitesimal
+            // so polling
             // is acceptable.
             //
-        	try {
-        		Thread.sleep(1);
-        	} catch (InterruptedException ie) {
-        		// ignore
-        	}
+            try {
+                Thread.sleep(1);
+            } catch (final InterruptedException ie) {
+                // ignore
+            }
         }
         buffer.clearValid();
         buffer.clearDirty();
         buffer.setPageAddressAndVolume(0, null);
     }
 
-    private boolean detach(Buffer buffer) {
+    private boolean detach(final Buffer buffer) {
         final int hash = hashIndex(buffer.getVolume(), buffer.getPageAddress());
         if (!_hashLocks[hash % HASH_LOCKS].tryLock()) {
             return false;
@@ -756,8 +700,9 @@
      * @return Buffer The Buffer describing the buffer containing the page.
      * @throws InUseException
      */
-    Buffer get(Volume vol, long page, boolean writer, boolean wantRead) throws PersistitException {
-        int hash = hashIndex(vol, page);
+    Buffer get(final Volume vol, final long page, final boolean writer, final boolean wantRead)
+            throws PersistitException {
+        final int hash = hashIndex(vol, page);
         Buffer buffer = null;
 
         for (;;) {
@@ -904,10 +849,10 @@
      * @throws RetryException
      * @throws IOException
      */
-    public Buffer getBufferCopy(Volume vol, long page) throws InvalidPageAddressException,
+    public Buffer getBufferCopy(final Volume vol, final long page) throws InvalidPageAddressException,
             InvalidPageStructureException, VolumeClosedException, InUseException, PersistitIOException,
             PersistitInterruptedException {
-        int hash = hashIndex(vol, page);
+        final int hash = hashIndex(vol, page);
         Buffer buffer = null;
         _hashLocks[hash % HASH_LOCKS].lock();
         try {
@@ -934,7 +879,7 @@
         // Didn't find it in the pool, so we'll read a copy.
         //
         buffer = new Buffer(_bufferSize, -1, this, _persistit);
-        boolean acquired = buffer.claim(true);
+        final boolean acquired = buffer.claim(true);
         assert acquired : "buffer not unavailable";
         buffer.load(vol, page);
         buffer.setValid();
@@ -968,7 +913,7 @@
         // since no valid page will need to be evicted.
         //
         if (_availablePages.get()) {
-            int start = (_clock.get() / 64) * 64;
+            final int start = (_clock.get() / 64) * 64;
             for (int q = start;;) {
                 q += 64;
                 if (q >= _bufferCount) {
@@ -1007,12 +952,12 @@
         // Look for a page to evict.
         //
         for (int retry = 0; retry < _bufferCount * 2;) {
-            int clock = _clock.get();
+            final int clock = _clock.get();
             assert clock < _bufferCount;
             if (!_clock.compareAndSet(clock, (clock + 1) % _bufferCount)) {
                 continue;
             }
-            Buffer buffer = _buffers[clock];
+            final Buffer buffer = _buffers[clock];
             if (buffer.isTouched()) {
                 buffer.clearTouched();
             } else {
@@ -1081,7 +1026,7 @@
 
     void setFlushTimestamp(final long timestamp) {
         while (true) {
-            long current = _flushTimestamp.get();
+            final long current = _flushTimestamp.get();
             if (timestamp > current) {
                 if (_flushTimestamp.compareAndSet(current, timestamp)) {
                     break;
@@ -1099,7 +1044,7 @@
      *         polling cycle
      */
     boolean shouldWritePages() {
-        int cleanCount = _bufferCount - _dirtyPageCount.get();
+        final int cleanCount = _bufferCount - _dirtyPageCount.get();
         if (getEarliestDirtyTimestamp() < _flushTimestamp.get()) {
             return true;
         }
@@ -1116,7 +1061,7 @@
     }
 
     void writeDirtyBuffers(final int[] priorities, final BufferHolder[] selectedBuffers) throws PersistitException {
-        int count = selectDirtyBuffers(priorities, selectedBuffers);
+        final int count = selectDirtyBuffers(priorities, selectedBuffers);
         if (count > 0) {
             Arrays.sort(selectedBuffers, 0, count);
             for (int index = 0; index < count; index++) {
@@ -1144,7 +1089,7 @@
         final long currentTimestamp = _persistit.getCurrentTimestamp();
 
         long earliestDirtyTimestamp = currentTimestamp;
-        long flushTimestamp = _flushTimestamp.get();
+        final long flushTimestamp = _flushTimestamp.get();
 
         boolean flushed = true;
         for (int index = clock; index < clock + _bufferCount; index++) {
@@ -1202,8 +1147,9 @@
         }
         return count;
     }
-    
-    int addSelectedBufferByPriority(final Buffer buffer, final int priority, final int[] priorities, final BufferHolder[] holders, final int initialCount) {
+
+    int addSelectedBufferByPriority(final Buffer buffer, final int priority, final int[] priorities,
+            final BufferHolder[] holders, final int initialCount) {
         int count = initialCount;
         if (priority > 0) {
             if (count == 0 || priorities[count - 1] > priority) {
@@ -1214,13 +1160,13 @@
                 }
             } else {
                 count = Math.min(count, priorities.length - 1);
-                int where = count; 
+                int where = count;
                 while (where > 0 && priorities[where - 1] < priority) {
                     where--;
                 }
-                int move = count - where ;
+                final int move = count - where;
                 if (move > 0) {
-                    BufferHolder lastHolder = holders[count];
+                    final BufferHolder lastHolder = holders[count];
                     System.arraycopy(priorities, where, priorities, where + 1, move);
                     System.arraycopy(holders, where, holders, where + 1, move);
                     holders[where] = lastHolder;
@@ -1240,8 +1186,8 @@
      * 
      * @return priority
      */
-     int writePriority(final Buffer buffer, int clock, long checkpointTimestamp, final long currentTimestamp) {
-        int status = buffer.getStatus();
+    int writePriority(final Buffer buffer, final int clock, final long checkpointTimestamp, final long currentTimestamp) {
+        final int status = buffer.getStatus();
         if ((status & Buffer.VALID_MASK) == 0 || (status & Buffer.DIRTY_MASK) == 0) {
             // ineligible
             return 0;
@@ -1336,7 +1282,7 @@
          *         address order.
          */
         @Override
-        public int compareTo(BufferHolder buffer) {
+        public int compareTo(final BufferHolder buffer) {
             return _volumeId > buffer._volumeId ? 1 : _volumeId < buffer._volumeId ? -1 : _page > buffer._page ? 1
                     : _page < buffer._page ? -1 : 0;
 
@@ -1367,7 +1313,7 @@
 
         @Override
         public void runTask() throws PersistitException {
-            int size = _pageWriterTrancheSize;
+            final int size = _pageWriterTrancheSize;
             if (size != _priorities.length) {
                 _priorities = new int[size];
                 _selectedBuffers = new BufferHolder[size];
@@ -1391,35 +1337,6 @@
             return isFlushing() ? 0 : _writerPollInterval;
         }
     }
-    
-    /**
-     * Implementation of PAGE_CACHER thread
-     */
-    class PageCacher extends IOTaskRunnable {
-        
-        PageCacher() {
-            super(BufferPool.this._persistit);
-        }
-        
-        void start() {
-            start("PAGE_CACHER:" + _bufferSize, _cacherPollInterval);
-        }
-
-        @Override
-        public void runTask() throws Exception {
-            populateWarmupFile();
-        }
-        
-        @Override
-        protected boolean shouldStop() {
-            return _closed.get() && !isFlushing();
-        }
-        
-        @Override
-        protected long pollInterval() {
-            return isFlushing() ? 0 : _cacherPollInterval;
-        }
-    }
 
     @Override
     public String toString() {
@@ -1431,7 +1348,7 @@
      * @param detail
      * @return toString value for buffer at index <code>i</code>.
      */
-    String toString(int i, boolean detail) {
+    String toString(final int i, final boolean detail) {
         if (detail) {
             return _buffers[i].toStringDetail();
         } else {
@@ -1475,4 +1392,133 @@
         }
         stream.flush();
     }
+
+    void recordBufferInventory(final long timestamp) throws PersistitException {
+        final Exchange exchange = getBufferInventoryExchange();
+        /*
+         * Advisory only - transaction integrity not needed
+         */
+        exchange.ignoreTransactions();
+        try {
+            int total = 0;
+            exchange.clear().append(_bufferSize).append(timestamp).append(Key.BEFORE);
+            final Value value = exchange.getValue();
+            final int clockValueBefore = _clock.get();
+            for (int index = 0; index < _buffers.length; index++) {
+                final Buffer buffer = _buffers[index];
+                long page1 = -1, page2 = -1;
+                Volume volume1 = null, volume2 = null;
+                if (buffer != null && buffer.isValid()) {
+                    while (true) {
+                        page1 = buffer.getPageAddress();
+                        volume1 = buffer.getVolume();
+                        page2 = buffer.getPageAddress();
+                        volume2 = buffer.getVolume();
+                        if (page1 == page2 && volume1 == volume2) {
+                            break;
+                        }
+                        Util.spinSleep();
+                    }
+                    if (volume1 != null && !volume1.isTemporary()) {
+                        value.clear().setStreamMode(true);
+                        value.put(volume1.getHandle());
+                        value.put(page1);
+                        exchange.to(index).store();
+                        total++;
+                    }
+                }
+            }
+            final int clockValueAfter = _clock.get();
+            exchange.cut();
+            value.clear().setStreamMode(true);
+            value.put(_bufferCount);
+            value.put(total);
+            value.put(clockValueBefore);
+            value.put(clockValueAfter);
+            value.put(System.currentTimeMillis());
+            exchange.store();
+            int count = 0;
+            while (exchange.previous()) {
+                if (++count > INVENTORY_VERSIONS) {
+                    exchange.remove(Key.GTEQ);
+                }
+            }
+        } catch (final PersistitException e) {
+            _persistit.getLogBase().bufferInventoryException.log(e);
+        }
+    }
+
+    void preloadBufferInventory() {
+        int count = 0;
+        int total = 0;
+        try {
+            final JournalManager jman = _persistit.getJournalManager();
+            final Exchange exchange = getBufferInventoryExchange();
+            final Value value = exchange.getValue();
+            final List<PageNode> pageNodes = new ArrayList<PageNode>();
+            boolean foundInventory = false;
+            exchange.clear().append(_bufferSize).append(Key.AFTER);
+            while (exchange.previous()) {
+                if (exchange.getValue().isDefined()) {
+                    foundInventory = true;
+                    break;
+                }
+            }
+            if (!foundInventory) {
+                return;
+            }
+            value.setStreamMode(true);
+            /* int bufferCount = */value.getInt();
+            total = value.getInt();
+            /* int clockValueBefore = */value.getInt();
+            /* int clockValueAfter = */value.getInt();
+            final long systemTime = value.getLong();
+
+            _persistit.getLogBase().bufferInventoryLoad.log(systemTime);
+
+            exchange.append(Key.BEFORE);
+
+            while (exchange.next()) {
+                value.setStreamMode(true);
+                final int volumeHandle = value.getInt();
+                final long pageAddress = value.getLong();
+                final PageNode pn = new PageNode(volumeHandle, pageAddress);
+                pageNodes.add(pn);
+            }
+
+            Collections.sort(pageNodes, PageNode.READ_COMPARATOR);
+            for (final PageNode pn : pageNodes) {
+                final Volume vol = jman.volumeForHandle(pn.getVolumeHandle());
+                if (vol == null) {
+                    continue;
+                }
+                try {
+                    final Buffer buff = get(vol, pn.getPageAddress(), false, true);
+                    buff.release();
+                    count++;
+                    if ((count % INVENTORY_PRELOAD_LOG_MESSAGE_MULTIPLE) == 0) {
+                        _persistit.getLogBase().bufferInventoryProgress.log(count, total);
+                    }
+                    if (count >= _bufferCount) {
+                        //
+                        // If the buffer pool is now smaller, no need to load
+                        // more pages
+                        //
+                        break;
+                    }
+                } catch (final PersistitException e) {
+                    // ignore it
+                }
+            }
+        } catch (final PersistitException e) {
+            _persistit.getLogBase().bufferInventoryException.log(e);
+        } finally {
+            _persistit.getLogBase().bufferInventoryProgress.log(count, total);
+        }
+    }
+
+    private Exchange getBufferInventoryExchange() throws PersistitException {
+        final Volume sysvol = _persistit.getSystemVolume();
+        return _persistit.getExchange(sysvol, INVENTORY_TREE_NAME, true);
+    }
 }

=== modified file 'src/main/java/com/persistit/BufferPoolMXBeanImpl.java'
--- src/main/java/com/persistit/BufferPoolMXBeanImpl.java	2012-08-02 04:45:28 +0000
+++ src/main/java/com/persistit/BufferPoolMXBeanImpl.java	2012-08-24 18:21:22 +0000
@@ -23,8 +23,9 @@
 
 /**
  * MXBean that exposes information about a {@link BufferPool}.
+ * 
  * @author peter
- *
+ * 
  */
 class BufferPoolMXBeanImpl implements BufferPoolMXBean {
 
@@ -47,16 +48,16 @@
     }
 
     private BufferPoolInfo recent() {
-        long now = System.currentTimeMillis();
+        final long now = System.currentTimeMillis();
         if (_recent.getAcquisitionTime() < now - MAX_STALE) {
             try {
-                BufferPoolInfo[] array = _persistit.getManagement().getBufferPoolInfoArray();
-                for (BufferPoolInfo info : array) {
+                final BufferPoolInfo[] array = _persistit.getManagement().getBufferPoolInfoArray();
+                for (final BufferPoolInfo info : array) {
                     if (info.getBufferSize() == _bufferSize) {
                         _recent = info;
                     }
                 }
-            } catch (RemoteException e) {
+            } catch (final RemoteException e) {
                 // TODO Auto-generated catch block
                 e.printStackTrace();
             }

=== modified file 'src/main/java/com/persistit/CLI.java'
--- src/main/java/com/persistit/CLI.java	2012-08-02 04:45:28 +0000
+++ src/main/java/com/persistit/CLI.java	2012-08-24 18:21:22 +0000
@@ -168,12 +168,12 @@
     public static void registerCommands(final Class<?> clazz) {
         for (final Method method : clazz.getDeclaredMethods()) {
             if (method.isAnnotationPresent(Cmd.class)) {
-                String name = method.getAnnotation(Cmd.class).value();
-                Annotation[][] parameters = method.getParameterAnnotations();
-                String[] argTemplate = new String[parameters.length];
+                final String name = method.getAnnotation(Cmd.class).value();
+                final Annotation[][] parameters = method.getParameterAnnotations();
+                final String[] argTemplate = new String[parameters.length];
                 int index = 0;
-                for (Annotation[] annotations : parameters) {
-                    Arg argAnnotation = (Arg) annotations[0];
+                for (final Annotation[] annotations : parameters) {
+                    final Arg argAnnotation = (Arg) annotations[0];
                     argTemplate[index++] = argAnnotation.value();
                 }
                 COMMANDS.put(name, new Command(name, argTemplate, method));
@@ -228,7 +228,7 @@
         int port = -1;
         String host = null;
 
-        String[] hostPieces = args[0].split(":");
+        final String[] hostPieces = args[0].split(":");
         switch (hostPieces.length) {
         case 1:
             port = Integer.parseInt(hostPieces[0]);
@@ -275,7 +275,7 @@
      */
     public static void runScript(final Persistit persistit, final BufferedReader reader, final PrintWriter writer)
             throws Exception {
-        CLI cli = new CLI(persistit, reader, writer);
+        final CLI cli = new CLI(persistit, reader, writer);
         cli.commandLoop();
         cli.close(false);
         writer.println();
@@ -307,7 +307,7 @@
 
         boolean quoted = false;
         for (int index = 0; index < commandLine.length(); index++) {
-            char c = commandLine.charAt(index);
+            final char c = commandLine.charAt(index);
             if (index == 0 && !Character.isLetter(c)) {
                 commandDelimiter = c;
                 continue;
@@ -342,17 +342,17 @@
     }
 
     static Task parseTask(final Persistit persistit, final String line) throws Exception {
-        List<String> pieces = pieces(line);
+        final List<String> pieces = pieces(line);
         if (pieces.isEmpty()) {
             return null;
         }
         final String commandName = pieces.remove(0);
-        Command command = COMMANDS.get(commandName);
+        final Command command = COMMANDS.get(commandName);
         if (command == null) {
             return null;
         }
-        Task task = command.createTask(persistit, new ArgParser(commandName, pieces.toArray(new String[pieces.size()]),
-                command.argTemplate).strict());
+        final Task task = command.createTask(persistit,
+                new ArgParser(commandName, pieces.toArray(new String[pieces.size()]), command.argTemplate).strict());
         if (task != null) {
             task.setPersistit(persistit);
         }
@@ -433,14 +433,14 @@
         private final BufferedReader _reader;
         private final PrintWriter _writer;
 
-        private ScriptReader(final BufferedReader reader, PrintWriter writer) {
+        private ScriptReader(final BufferedReader reader, final PrintWriter writer) {
             _reader = reader;
             _writer = writer;
         }
 
         @Override
         public String readLine() throws IOException {
-            String line = _reader.readLine();
+            final String line = _reader.readLine();
             if (line != null) {
                 _writer.println();
                 _writer.println(">> " + line);
@@ -476,10 +476,10 @@
         private String execute(final CLI cli, final ArgParser ap) throws Exception {
             final Object[] args = invocationArgs(ap);
             if (method.getReturnType() == String.class) {
-                String result = (String) method.invoke(cli, args);
+                final String result = (String) method.invoke(cli, args);
                 return result;
             } else if (Task.class.isAssignableFrom(method.getReturnType())) {
-                Task task = (Task) method.invoke(cli, args);
+                final Task task = (Task) method.invoke(cli, args);
                 task.setPersistit(cli._persistit);
                 task.setMaximumTime(-1);
                 task.setMessageWriter(cli._writer);
@@ -493,9 +493,9 @@
 
         private Task createTask(final Persistit persistit, final ArgParser ap) throws Exception {
             if (Task.class.isAssignableFrom(method.getReturnType())) {
-                CLI cli = persistit.getSessionCLI();
+                final CLI cli = persistit.getSessionCLI();
                 final Object[] args = invocationArgs(ap);
-                Task task = (Task) method.invoke(cli, args);
+                final Task task = (Task) method.invoke(cli, args);
                 return task;
             } else {
                 return null;
@@ -503,10 +503,10 @@
         }
 
         private Object[] invocationArgs(final ArgParser ap) {
-            Class<?>[] types = method.getParameterTypes();
+            final Class<?>[] types = method.getParameterTypes();
             final Object[] args = new Object[types.length];
             for (int index = 0; index < types.length; index++) {
-                Class<?> type = types[index];
+                final Class<?> type = types[index];
                 if (String.class.equals(type)) {
                     args[index] = ap.stringValue(index);
                 } else if (int.class.equals(type)) {
@@ -525,7 +525,7 @@
 
         @Override
         public String toString() {
-            StringBuilder sb = new StringBuilder(name);
+            final StringBuilder sb = new StringBuilder(name);
             sb.append(Util.NEW_LINE);
             sb.append(new ArgParser(name, new String[0], argTemplate).strict());
             return sb.toString();
@@ -540,7 +540,7 @@
 
     private LineReader _lineReader;
     PrintWriter _writer = new PrintWriter(System.out);
-    private Stack<BufferedReader> _sourceStack = new Stack<BufferedReader>();
+    private final Stack<BufferedReader> _sourceStack = new Stack<BufferedReader>();
     private Persistit _persistit;
     private boolean _stop = false;
     private Volume _currentVolume;
@@ -635,19 +635,19 @@
                         final String[] args = list.toArray(new String[list.size()]);
                         final ArgParser ap = new ArgParser(commandName, args, command.argTemplate).strict();
                         if (!ap.isUsageOnly()) {
-                            String result = command.execute(this, ap);
+                            final String result = command.execute(this, ap);
                             if (result != null) {
                                 _writer.println(result);
                             }
                             _lastStatus += " - done";
                         }
-                    } catch (InvocationTargetException e) {
+                    } catch (final InvocationTargetException e) {
                         _lastStatus += e.getTargetException();
                         _writer.println(e.getTargetException());
-                    } catch (RuntimeException e) {
+                    } catch (final RuntimeException e) {
                         _lastStatus += e;
                         e.printStackTrace(_writer);
-                    } catch (Exception e) {
+                    } catch (final Exception e) {
                         _lastStatus += e;
                         _writer.println(e);
                     }
@@ -680,28 +680,28 @@
      * @throws Exception
      */
     @Cmd("open")
-    String open(@Arg("datapath|string|Data path") String datapath,
-            @Arg("journalpath|string|Journal path") String journalpath,
-            @Arg("volumepath|string|Volume file") String volumepath,
-            @Arg("rmiport|int:1099:0:99999|RMI Management port") int rmiport,
-            @Arg("_flag|y|Recover committed transactions") boolean y) throws Exception {
+    String open(@Arg("datapath|string|Data path") final String datapath,
+            @Arg("journalpath|string|Journal path") final String journalpath,
+            @Arg("volumepath|string|Volume file") final String volumepath,
+            @Arg("rmiport|int:1099:0:99999|RMI Management port") final int rmiport,
+            @Arg("_flag|y|Recover committed transactions") final boolean y) throws Exception {
 
         if (_live) {
             return "Cannot open another Persistit instance within a live system";
         }
         close(false);
 
-        String jpath = journalPath(filesOnPath(journalpath.isEmpty() ? datapath : journalpath));
-        List<VolumeSpecification> volumeSpecifications = volumeSpecifications(
+        final String jpath = journalPath(filesOnPath(journalpath.isEmpty() ? datapath : journalpath));
+        final List<VolumeSpecification> volumeSpecifications = volumeSpecifications(
                 filesOnPath(volumepath.isEmpty() ? datapath : volumepath), Long.MAX_VALUE);
-        Set<Integer> bufferSizes = new HashSet<Integer>();
+        final Set<Integer> bufferSizes = new HashSet<Integer>();
         for (final VolumeSpecification vs : volumeSpecifications) {
             bufferSizes.add(vs.getPageSize());
         }
         final Properties properties = new Properties();
-        long bpoolMemory = availableMemory() / 2;
+        final long bpoolMemory = availableMemory() / 2;
         for (final Integer size : bufferSizes) {
-            int alloc = (int) (size * 1.25);
+            final int alloc = (int) (size * 1.25);
             final int count = (int) ((bpoolMemory / bufferSizes.size()) / alloc);
             properties.put(Persistit.BUFFERS_PROPERTY_NAME + size, Integer.toString(count));
         }
@@ -747,7 +747,7 @@
             }
         }
         if (sysvol != null) {
-            properties.put(Persistit.SYSTEM_VOLUME_PROPERTY, sysvol.getName());
+            persistit.getConfiguration().setSysVolume(sysvol.getName());
         }
 
         _persistit = persistit;
@@ -755,7 +755,7 @@
     }
 
     @Cmd("close")
-    String close(@Arg("_flag|f|Flush modifications to disk") boolean flush) throws Exception {
+    String close(@Arg("_flag|f|Flush modifications to disk") final boolean flush) throws Exception {
         if (_persistit != null) {
             try {
                 if (_live) {
@@ -764,7 +764,7 @@
                     _persistit.shutdownGUI();
                     _persistit.close(flush);
                 }
-            } catch (Exception e) {
+            } catch (final Exception e) {
                 return e.toString();
             } finally {
                 _persistit = null;
@@ -832,6 +832,7 @@
             public void runTask() throws Exception {
                 final JournalTool jt = new JournalTool(_persistit);
                 jt.setAction(jt.new SimpleDumpAction() {
+                    @Override
                     protected void write(final String msg) {
                         postMessage(msg, LOG_NORMAL);
                     }
@@ -923,7 +924,7 @@
                     return;
                 }
 
-                List<Object> selected = new ArrayList<Object>();
+                final List<Object> selected = new ArrayList<Object>();
                 final TreeSelector selector = TreeSelector.parseSelector(tstring, r, '\\');
 
                 for (final Volume volume : _persistit.getVolumes()) {
@@ -988,10 +989,10 @@
                 if (!keyString.isEmpty()) {
                     new KeyParser(keyString).parseKey(exchange.getKey());
                 }
-                StringBuilder sb = new StringBuilder();
-                int depth = _currentTree.getDepth();
+                final StringBuilder sb = new StringBuilder();
+                final int depth = _currentTree.getDepth();
                 for (int level = depth; --level >= 0;) {
-                    Buffer copy = exchange.fetchBufferCopy(level);
+                    final Buffer copy = exchange.fetchBufferCopy(level);
                     if (sb.length() > 0) {
                         sb.append(Util.NEW_LINE);
                     }
@@ -1051,7 +1052,7 @@
                     return;
                 }
                 if (index >= 0) {
-                    BufferPool pool = _persistit.getBufferPool(pageSize);
+                    final BufferPool pool = _persistit.getBufferPool(pageSize);
                     buffer = pool.getBufferCopy(index);
                 } else if (journalAddress >= 0) {
                     buffer = _persistit.getJournalManager().readPageBuffer(journalAddress);
@@ -1088,12 +1089,13 @@
                 }
             }
 
+            @Override
             public String getStatus() {
                 return "";
             }
         };
     }
-    
+
     @Cmd("pviewchain")
     Task pviewchain(final @Arg("page|long:0:0:99999999999999999|Starting page address") long pageAddress,
             final @Arg("find|long:-1:0:99999999999999999|Optional page pointer to find") long findPointer,
@@ -1102,7 +1104,7 @@
             final @Arg("maxvalue|int:42:4:100000|Maximum displayed value length") int maxvalue,
             final @Arg("context|int:3:0:100000|Context lines") int context,
             final @Arg("_flag|a|All lines") boolean allLines, final @Arg("_flag|s|Summary only") boolean summary) {
-        
+
         return new Task() {
 
             @Override
@@ -1121,15 +1123,15 @@
                         postMessage(buffer.toStringDetail(findPointer, maxkey, maxvalue, context, allLines), LOG_NORMAL);
                     }
                     currentPage = buffer.getRightSibling();
-                }    
+                }
             }
 
             @Override
             public String getStatus() {
                 return "";
             }
-            
-        };   
+
+        };
     }
 
     @Cmd("jquery")
@@ -1140,6 +1142,7 @@
             final @Arg("_flag|V|Show volume handle map") boolean showTreeMap,
             final @Arg("_flag|T|Show tree handle map") boolean showVolumeMap) {
         return new Task() {
+            @Override
             public void runTask() throws Exception {
                 if (!showVolumeMap && !showTreeMap && pageAddress == -1 && ts == -1) {
                     postMessage("No items requested", LOG_NORMAL);
@@ -1147,20 +1150,20 @@
                 }
                 if (showVolumeMap) {
                     postMessage("Volume Handle Map", LOG_NORMAL);
-                    Map<Integer, Volume> map = _persistit.getJournalManager().queryVolumeMap();
+                    final Map<Integer, Volume> map = _persistit.getJournalManager().queryVolumeMap();
                     for (final Map.Entry<Integer, Volume> entry : map.entrySet()) {
                         postMessage(String.format("%,5d -> %s", entry.getKey(), entry.getValue()), LOG_NORMAL);
                     }
                 }
                 if (showVolumeMap) {
                     postMessage("Tree Handle Map", LOG_NORMAL);
-                    Map<Integer, TreeDescriptor> map = _persistit.getJournalManager().queryTreeMap();
+                    final Map<Integer, TreeDescriptor> map = _persistit.getJournalManager().queryTreeMap();
                     for (final Map.Entry<Integer, TreeDescriptor> entry : map.entrySet()) {
                         postMessage(String.format("%,5d -> %s", entry.getKey(), entry.getValue()), LOG_NORMAL);
                     }
                 }
                 if (ts != -1) {
-                    TransactionMapItem item = _persistit.getJournalManager().queryTransactionMap(ts);
+                    final TransactionMapItem item = _persistit.getJournalManager().queryTransactionMap(ts);
                     postMessage(String.format("TransactionMapItem for ts=%,d -> %s", ts, item), LOG_NORMAL);
                 }
                 if (pageAddress != -1) {
@@ -1168,7 +1171,7 @@
                     if (volumeHandle != -1) {
                         queryPageNode(volumeHandle, pageAddress, verbose);
                     } else {
-                        Map<Integer, Volume> volumeMap = _persistit.getJournalManager().queryVolumeMap();
+                        final Map<Integer, Volume> volumeMap = _persistit.getJournalManager().queryVolumeMap();
                         for (final int handle : volumeMap.keySet()) {
                             queryPageNode(handle, pageAddress, verbose);
                         }
@@ -1202,6 +1205,7 @@
             final @Arg("_flag|v|Verbose") boolean verbose) throws Exception {
 
         return new Task() {
+            @Override
             public void runTask() throws Exception {
                 final File target = new File(file);
                 if (target.exists() && !ovewrite) {
@@ -1255,12 +1259,12 @@
                 zos.closeEntry();
                 bb.clear();
 
-                PrintWriter writer = new PrintWriter(zos);
+                final PrintWriter writer = new PrintWriter(zos);
                 ze = new ZipEntry(basePath + ".txt");
                 ze.setSize(Integer.MAX_VALUE);
                 ze.setTime(baseTime);
                 zos.putNextEntry(ze);
-                List<Volume> volumes = _persistit.getVolumes();
+                final List<Volume> volumes = _persistit.getVolumes();
 
                 writer.printf("@volumes=%d\n", volumes.size());
                 for (final Volume volume : volumes) {
@@ -1314,7 +1318,7 @@
 
     @Cmd("cliserver")
     static Task cliserver(final @Arg("port|int:9999:1024:99999999") int port) throws Exception {
-        Task task = new Task() {
+        final Task task = new Task() {
             CLI _cli;
 
             @Override
@@ -1325,9 +1329,9 @@
 
             @Override
             public String getStatus() {
-                CLI cli = _cli;
+                final CLI cli = _cli;
                 if (cli != null) {
-                    String status = cli._lastStatus;
+                    final String status = cli._lastStatus;
                     if (status != null) {
                         return status;
                     }
@@ -1339,12 +1343,12 @@
         return task;
     }
 
-    private static String journalPath(List<String> files) {
+    private static String journalPath(final List<String> files) {
         String journalPath = null;
         for (final String file : files) {
-            Matcher matcher = JournalManager.PATH_PATTERN.matcher(file);
+            final Matcher matcher = JournalManager.PATH_PATTERN.matcher(file);
             if (matcher.matches()) {
-                String path = matcher.group(1);
+                final String path = matcher.group(1);
                 if (journalPath == null) {
                     journalPath = path;
                 } else if (!journalPath.equals(path)) {
@@ -1355,7 +1359,7 @@
         return journalPath;
     }
 
-    private static List<VolumeSpecification> volumeSpecifications(List<String> files, long systemTimestamp) {
+    private static List<VolumeSpecification> volumeSpecifications(final List<String> files, final long systemTimestamp) {
         final List<VolumeSpecification> list = new ArrayList<VolumeSpecification>();
         for (final String path : files) {
             if (JournalManager.PATH_PATTERN.matcher(path).matches()) {
@@ -1366,7 +1370,7 @@
                 if (VolumeHeader.verifyVolumeHeader(specification, systemTimestamp)) {
                     list.add(specification);
                 }
-            } catch (PersistitException e) {
+            } catch (final PersistitException e) {
                 // ignore this file
             }
         }

=== modified file 'src/main/java/com/persistit/CheckpointManager.java'
--- src/main/java/com/persistit/CheckpointManager.java	2012-08-02 04:45:28 +0000
+++ src/main/java/com/persistit/CheckpointManager.java	2012-08-24 18:21:22 +0000
@@ -43,7 +43,7 @@
         private final long _systemTime;
 
         private volatile boolean _completed = false;
-        
+
         Checkpoint(final long timestamp, final long systemTime) {
             _timestamp = timestamp;
             _systemTime = systemTime;
@@ -72,8 +72,8 @@
 
         @Override
         public String toString() {
-            return String.format("Checkpoint %,d%s @ %s", _timestamp, isCompleted() ? "c" : "u", SDF.format(new Date(
-                    _systemTime)));
+            return String.format("Checkpoint %,d%s @ %s", _timestamp, isCompleted() ? "c" : "u",
+                    SDF.format(new Date(_systemTime)));
         }
 
         @Override
@@ -81,7 +81,7 @@
             if (!(object instanceof Checkpoint)) {
                 return false;
             }
-            Checkpoint cp = (Checkpoint) object;
+            final Checkpoint cp = (Checkpoint) object;
             return cp._systemTime == _systemTime && cp._timestamp == _timestamp;
         }
     }
@@ -92,9 +92,9 @@
      * Default interval in nanoseconds between checkpoints - two minutes.
      */
     private final static long DEFAULT_CHECKPOINT_INTERVAL = 120;
-    
+
     private final static long MINIMUM_CHECKPOINT_INTERVAL = 10;
-    
+
     private final static long MAXIMUM_CHECKPOINT_INTERVAL = 1800;
 
     private final static Checkpoint UNAVALABLE_CHECKPOINT = new Checkpoint(0, 0);
@@ -110,13 +110,12 @@
     private final static long FLUSH_CHECKPOINT_INTERVAL = 5000;
 
     private volatile Checkpoint _currentCheckpoint = new Checkpoint(0, 0, true);
-    
-    private List<Checkpoint> _outstandingCheckpoints = new ArrayList<Checkpoint>();
-
-
-    private AtomicBoolean _closed = new AtomicBoolean();
-
-    private AtomicBoolean _fastClose = new AtomicBoolean();
+
+    private final List<Checkpoint> _outstandingCheckpoints = new ArrayList<Checkpoint>();
+
+    private final AtomicBoolean _closed = new AtomicBoolean();
+
+    private final AtomicBoolean _fastClose = new AtomicBoolean();
 
     CheckpointManager(final Persistit persistit) {
         super(persistit);
@@ -139,12 +138,12 @@
     Checkpoint getCurrentCheckpoint() {
         return _currentCheckpoint;
     }
-    
+
     long getCheckpointIntervalNanos() {
         return _checkpointIntervalNanos;
     }
 
-    void setCheckpointIntervalNanos(long interval) {
+    void setCheckpointIntervalNanos(final long interval) {
         _checkpointIntervalNanos = interval;
     }
 
@@ -159,19 +158,19 @@
     }
 
     @Override
-    public void setCheckpointInterval(long interval) {
+    public void setCheckpointInterval(final long interval) {
         Util.rangeCheck(interval, MINIMUM_CHECKPOINT_INTERVAL, MAXIMUM_CHECKPOINT_INTERVAL);
         _checkpointIntervalNanos = interval * NS_PER_S;
     }
-    
+
     @Override
-    public synchronized  int getOutstandingCheckpointCount() {
+    public synchronized int getOutstandingCheckpointCount() {
         return _outstandingCheckpoints.size();
     }
-    
+
     @Override
     public synchronized String outstandingCheckpointReport() {
-        StringBuilder sb = new StringBuilder();
+        final StringBuilder sb = new StringBuilder();
         for (final Checkpoint cp : _outstandingCheckpoints) {
             sb.append(cp);
             sb.append(Util.NEW_LINE);
@@ -180,7 +179,7 @@
     }
 
     Checkpoint checkpoint() throws PersistitException {
-        Checkpoint checkpoint = createCheckpoint();
+        final Checkpoint checkpoint = createCheckpoint();
         _persistit.flushBuffers(checkpoint.getTimestamp());
 
         while (true) {
@@ -202,6 +201,7 @@
     void pollCreateCheckpoint() throws PersistitException {
         final long now = System.nanoTime();
         if (_lastCheckpointNanos + _checkpointIntervalNanos < now) {
+            _persistit.recordBufferPoolInventory();
             createCheckpoint();
         }
     }
@@ -239,26 +239,26 @@
         final SessionId saveSessionId = _persistit.getSessionId();
         try {
             _persistit.setSessionId(_checkpointTxnSessionId);
-            Transaction txn = _persistit.getTransaction();
+            final Transaction txn = _persistit.getTransaction();
 
             _lastCheckpointNanos = System.nanoTime();
 
             txn.beginCheckpoint();
             try {
                 _persistit.flushTransactions(txn.getStartTimestamp());
-                List<Accumulator> accumulators = _persistit.getCheckpointAccumulators();
+                final List<Accumulator> accumulators = _persistit.getCheckpointAccumulators();
                 _persistit.getTransactionIndex().checkpointAccumulatorSnapshots(txn.getStartTimestamp(), accumulators);
                 Accumulator.saveAccumulatorCheckpointValues(accumulators);
                 txn.commit(CommitPolicy.HARD);
                 _currentCheckpoint = new Checkpoint(txn.getStartTimestamp(), System.currentTimeMillis());
                 _outstandingCheckpoints.add(_currentCheckpoint);
                 _persistit.getLogBase().checkpointProposed.log(_currentCheckpoint);
-                return _currentCheckpoint;
-            } catch (InterruptedException ie) {
+            } catch (final InterruptedException ie) {
                 throw new PersistitInterruptedException(ie);
             } finally {
                 txn.end();
             }
+            return _currentCheckpoint;
         } finally {
             _persistit.setSessionId(saveSessionId);
         }
@@ -272,9 +272,9 @@
     void pollFlushCheckpoint() {
         final long earliestDirtyTimestamp = _persistit.earliestDirtyTimestamp();
         Checkpoint checkpoint = null;
-        synchronized(this) {
+        synchronized (this) {
             while (!_outstandingCheckpoints.isEmpty()) {
-                Checkpoint cp = _outstandingCheckpoints.get(0);
+                final Checkpoint cp = _outstandingCheckpoints.get(0);
                 if (cp.getTimestamp() <= earliestDirtyTimestamp) {
                     checkpoint = cp;
                     _outstandingCheckpoints.remove(0);
@@ -286,7 +286,7 @@
         if (checkpoint != null) {
             try {
                 _persistit.getJournalManager().writeCheckpointToJournal(checkpoint);
-            } catch (PersistitException e) {
+            } catch (final PersistitException e) {
                 _persistit.getLogBase().exception.log(e);
             }
         }

=== modified file 'src/main/java/com/persistit/ClassIndex.java'
--- src/main/java/com/persistit/ClassIndex.java	2012-08-02 04:45:28 +0000
+++ src/main/java/com/persistit/ClassIndex.java	2012-08-24 18:21:22 +0000
@@ -71,8 +71,8 @@
             INITIAL_CAPACITY);
 
     private int _testIdFloor = Integer.MIN_VALUE;
-    private AtomicInteger _cacheMisses = new AtomicInteger();
-    private AtomicInteger _discardedDuplicates = new AtomicInteger();
+    private final AtomicInteger _cacheMisses = new AtomicInteger();
+    private final AtomicInteger _discardedDuplicates = new AtomicInteger();
 
     /**
      * A structure holding a ClassInfo, plus links to other related
@@ -82,7 +82,7 @@
         final ClassInfoEntry _next;
         final ClassInfo _classInfo;
 
-        ClassInfoEntry(ClassInfo ci, ClassInfoEntry next) {
+        ClassInfoEntry(final ClassInfo ci, final ClassInfoEntry next) {
             _classInfo = ci;
             _next = next;
         }
@@ -95,7 +95,7 @@
      * @param persistit
      *            Owning Persistit instance.
      */
-    ClassIndex(Persistit persistit) {
+    ClassIndex(final Persistit persistit) {
         _persistit = persistit;
     }
 
@@ -117,8 +117,8 @@
      *            The handle
      * @return The associated ClassInfo, or <i>null</i> if there is none.
      */
-    public ClassInfo lookupByHandle(int handle) {
-        AtomicReferenceArray<ClassInfoEntry> hashTable = _hashTable;
+    public ClassInfo lookupByHandle(final int handle) {
+        final AtomicReferenceArray<ClassInfoEntry> hashTable = _hashTable;
         ClassInfoEntry cie = hashTable.get(handle % hashTable.length());
         while (cie != null) {
             if (cie._classInfo.getHandle() == handle)
@@ -138,43 +138,44 @@
                 try {
                     ex.clear().append(BY_HANDLE).append(handle).fetch();
                     txn.commit();
-                } catch (Exception e) {
+                } catch (final Exception e) {
                     _persistit.getLogBase().exception.log(e);
                     throw new ConversionException(e);
                 } finally {
                     txn.end();
                 }
-                Value value = ex.getValue();
+                final Value value = ex.getValue();
                 if (value.isDefined()) {
                     value.setStreamMode(true);
-                    int storedId = value.getInt();
-                    String storedName = value.getString();
-                    long storedSuid = value.getLong();
+                    final int storedId = value.getInt();
+                    final String storedName = value.getString();
+                    final long storedSuid = value.getLong();
                     if (storedId != handle) {
                         throw new IllegalStateException("ClassInfo stored for handle=" + handle
                                 + " has invalid stored handle=" + storedId);
                     }
-                    Class<?> cl = Class.forName(storedName, false, Thread.currentThread().getContextClassLoader());
+                    final Class<?> cl = Class
+                            .forName(storedName, false, Thread.currentThread().getContextClassLoader());
 
                     long suid = 0;
-                    ObjectStreamClass osc = ObjectStreamClass.lookupAny(cl);
+                    final ObjectStreamClass osc = ObjectStreamClass.lookupAny(cl);
                     if (osc != null)
                         suid = osc.getSerialVersionUID();
                     if (storedSuid != suid) {
                         throw new ConversionException("Class " + cl.getName() + " persistent SUID=" + storedSuid
                                 + " does not match current class SUID=" + suid);
                     }
-                    ClassInfo ci = new ClassInfo(cl, suid, handle, osc);
+                    final ClassInfo ci = new ClassInfo(cl, suid, handle, osc);
                     hashClassInfo(ci);
                     return ci;
                 } else {
-                    ClassInfo ci = new ClassInfo(null, 0, handle, null);
+                    final ClassInfo ci = new ClassInfo(null, 0, handle, null);
                     hashClassInfo(ci);
                     return ci;
                 }
-            } catch (ClassNotFoundException cnfe) {
+            } catch (final ClassNotFoundException cnfe) {
                 throw new ConversionException(cnfe);
-            } catch (PersistitException pe) {
+            } catch (final PersistitException pe) {
                 throw new ConversionException(pe);
             } finally {
                 if (ex != null)
@@ -191,13 +192,13 @@
      *            The <code>Class</code>
      * @return The ClassInfo for the specified Class.
      */
-    public ClassInfo lookupByClass(Class<?> clazz) {
-        AtomicReferenceArray<ClassInfoEntry> hashTable = _hashTable;
+    public ClassInfo lookupByClass(final Class<?> clazz) {
+        final AtomicReferenceArray<ClassInfoEntry> hashTable = _hashTable;
 
         ObjectStreamClass osc = null;
         long suid = 0;
 
-        int nh = clazz.getName().hashCode() & 0x7FFFFFFF;
+        final int nh = clazz.getName().hashCode() & 0x7FFFFFFF;
         ClassInfoEntry cie = hashTable.get(nh % hashTable.length());
 
         while (cie != null) {
@@ -260,14 +261,14 @@
                 final int handle;
                 txn.begin();
                 ex.clear().append(BY_NAME).append(clazz.getName()).append(suid).fetch();
-                Value value = ex.getValue();
+                final Value value = ex.getValue();
                 try {
                     if (value.isDefined()) {
                         value.setStreamMode(true);
 
                         handle = value.getInt();
-                        String storedName = value.getString();
-                        long storedSuid = value.getLong();
+                        final String storedName = value.getString();
+                        final long storedSuid = value.getLong();
 
                         if (storedSuid != suid || !clazz.getName().equals(storedName)) {
                             throw new ConversionException("Class " + clazz.getName() + " persistent SUID=" + storedSuid
@@ -301,7 +302,7 @@
                 } finally {
                     txn.end();
                 }
-            } catch (PersistitException pe) {
+            } catch (final PersistitException pe) {
                 throw new ConversionException(pe);
             } finally {
                 if (ex != null) {
@@ -322,16 +323,16 @@
      * @param clazz
      *            Class instance to register.
      */
-    public void registerClass(Class<?> clazz) {
+    public void registerClass(final Class<?> clazz) {
         lookupByClass(clazz);
     }
 
-    private void hashClassInfo(ClassInfo ci) {
-        int size = _size.get();
+    private void hashClassInfo(final ClassInfo ci) {
+        final int size = _size.get();
         if (size * EXTRA_FACTOR > _hashTable.length()) {
-            int discarded = _discardedDuplicates.get();
-            AtomicReferenceArray<ClassInfoEntry> newHashTable = new AtomicReferenceArray<ClassInfoEntry>(EXTRA_FACTOR
-                    * 2 * size);
+            final int discarded = _discardedDuplicates.get();
+            final AtomicReferenceArray<ClassInfoEntry> newHashTable = new AtomicReferenceArray<ClassInfoEntry>(
+                    EXTRA_FACTOR * 2 * size);
             for (int i = 0; i < _hashTable.length(); i++) {
                 ClassInfoEntry cie = _hashTable.get(i);
                 while (cie != null) {
@@ -345,7 +346,7 @@
         addHashEntry(_hashTable, ci);
     }
 
-    private void addHashEntry(final AtomicReferenceArray<ClassInfoEntry> hashTable, ClassInfo ci) {
+    private void addHashEntry(final AtomicReferenceArray<ClassInfoEntry> hashTable, final ClassInfo ci) {
         final int hh = ci.getHandle() % hashTable.length();
         final int nh = ci.getDescribedClass() == null ? -1
                 : ((ci.getDescribedClass().getName().hashCode() & 0x7FFFFFFF) % hashTable.length());
@@ -358,7 +359,8 @@
         }
     }
 
-    private boolean addHashEntry(final AtomicReferenceArray<ClassInfoEntry> hashTable, ClassInfo ci, final int hash) {
+    private boolean addHashEntry(final AtomicReferenceArray<ClassInfoEntry> hashTable, final ClassInfo ci,
+            final int hash) {
         ClassInfoEntry cie = hashTable.get(hash);
         while (cie != null) {
             if (ci.equals(cie._classInfo)) {
@@ -367,7 +369,7 @@
             cie = cie._next;
         }
         cie = hashTable.get(hash);
-        ClassInfoEntry newCie = new ClassInfoEntry(ci, cie);
+        final ClassInfoEntry newCie = new ClassInfoEntry(ci, cie);
         hashTable.set(hash, newCie);
         _size.incrementAndGet();
         return true;
@@ -375,14 +377,14 @@
 
     private Exchange getExchange() throws PersistitException {
         try {
-            Volume volume = _persistit.getSystemVolume();
+            final Volume volume = _persistit.getSystemVolume();
             return _persistit.getExchange(volume, CLASS_INDEX_TREE_NAME, true);
-        } catch (PersistitException pe) {
+        } catch (final PersistitException pe) {
             throw new ConversionException(pe);
         }
     }
 
-    private void releaseExchange(Exchange ex) {
+    private void releaseExchange(final Exchange ex) {
         _persistit.releaseExchange(ex);
     }
 

=== modified file 'src/main/java/com/persistit/ClassInfo.java'
--- src/main/java/com/persistit/ClassInfo.java	2012-08-02 04:45:28 +0000
+++ src/main/java/com/persistit/ClassInfo.java	2012-08-24 18:21:22 +0000
@@ -24,21 +24,22 @@
  */
 
 class ClassInfo {
-    private Class<?> _class;
-    private long _suid;
-    private int _handle;
-    private ObjectStreamClass _osc;
+    private final Class<?> _class;
+    private final long _suid;
+    private final int _handle;
+    private final ObjectStreamClass _osc;
 
-    ClassInfo(Class<?> cl, long suid, int handle, ObjectStreamClass osc) {
+    ClassInfo(final Class<?> cl, final long suid, final int handle, final ObjectStreamClass osc) {
         _class = cl;
         _suid = suid;
         _handle = handle;
         _osc = osc;
     }
 
+    @Override
     public boolean equals(final Object object) {
         if (object instanceof ClassInfo) {
-            ClassInfo ci = (ClassInfo) object;
+            final ClassInfo ci = (ClassInfo) object;
             if (equals(_class, ci._class) && _handle == ci._handle && _suid == ci._suid) {