Added version 0.5-rc1

am: 7fc0b45feb

* commit '7fc0b45feb5ac6191547bb0a175a718cb41ec4f9':
  Added version 0.5-rc1
  Initial empty repository

75 files changed, 8376 insertions, 0 deletions

diff --git a/Android.mk b/Android.mk
new file mode 100644
index 0000000..c747764
--- /dev/null
+++ b/Android.mk
@@ -0,0 +1,43 @@
+# Copyright (C) 2014 The Android Open Source Project
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+LOCAL_PATH := $(call my-dir)
+
+# build caliper jar
+# ============================================================
+
+include $(CLEAR_VARS)
+
+LOCAL_MODULE := caliper-target
+LOCAL_MODULE_TAGS := optional
+LOCAL_MODULE_CLASS := JAVA_LIBRARIES
+LOCAL_SRC_FILES := $(call all-java-files-under, caliper/src/main/java/)
+LOCAL_JAVA_RESOURCE_DIRS := caliper/src/main/resources
+
+LOCAL_STATIC_JAVA_LIBRARIES := \
+  caliper-gson \
+  caliper-java-allocation-instrumenter \
+  guava
+
+include $(BUILD_STATIC_JAVA_LIBRARY)
+
+# Build dependencies.
+# ============================================================
+include $(CLEAR_VARS)
+
+LOCAL_PREBUILT_STATIC_JAVA_LIBRARIES := \
+    caliper-gson:lib/gson-1.7.1$(COMMON_JAVA_PACKAGE_SUFFIX) \
+    caliper-java-allocation-instrumenter:lib/java-allocation-instrumenter-2.0$(COMMON_JAVA_PACKAGE_SUFFIX)
+
+include $(BUILD_MULTI_PREBUILT)
diff --git a/COPYING b/COPYING
new file mode 100644
index 0000000..d645695
--- /dev/null
+++ b/COPYING
@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/README b/README
new file mode 100644
index 0000000..c54683c
--- /dev/null
+++ b/README
@@ -0,0 +1,8 @@
+To build this project with Maven:
+
+1. cd caliper
+mvn eclipse:configure-workspace eclipse:eclipse install
+
+2. To build examples
+cd examples
+mvn eclipse:configure-workspace eclipse:eclipse install
diff --git a/caliper/pom.xml b/caliper/pom.xml
new file mode 100644
index 0000000..befd583
--- /dev/null
+++ b/caliper/pom.xml
@@ -0,0 +1,134 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+  <modelVersion>4.0.0</modelVersion>
+  <groupId>com.google.caliper</groupId>
+  <artifactId>caliper</artifactId>
+  <packaging>jar</packaging>
+  <version>0.5-rc1</version>
+  <inceptionYear>2009</inceptionYear>
+  <name>caliper</name>
+  <parent>
+    <groupId>org.sonatype.oss</groupId>
+    <artifactId>oss-parent</artifactId>
+    <version>7</version>
+  </parent>
+  <url>http://code.google.com/p/caliper/</url>
+  <description>Caliper: Microbenchmarking Framework for Java</description>
+  <properties>
+    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+  </properties>
+  <licenses>
+    <license>
+      <name>The Apache Software License, Version 2.0</name>
+      <url>http://www.apache.org/licenses/LICENSE-2.0.txt</url>
+      <distribution>repo</distribution>
+    </license>
+  </licenses>
+  <scm>
+    <connection>scm:git:http://code.google.com/p/caliper/</connection>
+    <developerConnection>scm:git:http://code.google.com/p/caliper/</developerConnection>
+    <url>http://code.google.com/p/caliper/source/browse</url>
+  </scm>
+  <issueManagement>
+    <system>Google Code Issue Tracking</system>
+    <url>http://code.google.com/p/caliper/issues/list</url>
+  </issueManagement>
+  <organization>
+    <name>Google, Inc.</name>
+    <url>http://www.google.com</url>
+  </organization>
+  <dependencies>
+    <dependency>
+      <groupId>com.google.code.findbugs</groupId>
+      <artifactId>jsr305</artifactId>
+      <version>1.3.9</version>
+    </dependency>
+    <dependency>
+      <groupId>com.google.code.gson</groupId>
+      <artifactId>gson</artifactId>
+      <version>1.7.1</version>
+    </dependency>
+    <dependency>
+      <groupId>com.google.guava</groupId>
+      <artifactId>guava</artifactId>
+      <version>11.0.1</version>
+      <scope>compile</scope>
+    </dependency>
+    <dependency>
+      <groupId>com.google.code.java-allocation-instrumenter</groupId>
+      <artifactId>java-allocation-instrumenter</artifactId>
+      <version>2.0</version>
+    </dependency>
+    <dependency>
+      <groupId>junit</groupId>
+      <artifactId>junit</artifactId>
+      <version>3.8.2</version>
+      <scope>test</scope>
+    </dependency>
+  </dependencies>
+  <build>
+    <defaultGoal>package</defaultGoal>
+    <plugins>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-compiler-plugin</artifactId>
+        <version>2.3.2</version>
+        <configuration>
+          <source>1.6</source>
+          <target>1.6</target>
+        </configuration>
+      </plugin>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-eclipse-plugin</artifactId>
+        <version>2.8</version>
+        <configuration>
+          <downloadSources>true</downloadSources>
+          <downloadJavadocs>true</downloadJavadocs>
+          <workspace>../eclipse-ws/</workspace>
+        </configuration>
+      </plugin>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-source-plugin</artifactId>
+        <version>2.1.2</version>
+        <executions>
+          <execution>
+            <id>attach-sources</id>
+            <phase>verify</phase>
+            <goals>
+              <goal>jar-no-fork</goal>
+            </goals>
+          </execution>
+        </executions>
+      </plugin>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-javadoc-plugin</artifactId>
+        <version>2.7</version>
+        <executions>
+          <execution>
+            <id>generate-javadocs</id>
+            <phase>site</phase>
+            <goals>
+              <goal>javadoc</goal>
+            </goals>
+          </execution>
+        </executions>
+        <configuration>
+          <links>
+            <link>http://download.oracle.com/javase/1.5.0/docs/api/</link>
+          </links>
+          <version>true</version>
+          <show>public</show>
+        </configuration>
+      </plugin>
+    </plugins>
+  </build>
+  <developers>
+    <developer>
+      <name>Jesse Wilson</name>
+      <organization>Google Inc.</organization>
+    </developer>
+  </developers>
+</project>
diff --git a/caliper/src/main/java/com/google/caliper/AllocationMeasurer.java b/caliper/src/main/java/com/google/caliper/AllocationMeasurer.java
new file mode 100644
index 0000000..2ec3488
--- /dev/null
+++ b/caliper/src/main/java/com/google/caliper/AllocationMeasurer.java
@@ -0,0 +1,165 @@
+/*
+ * Copyright (C) 2010 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.caliper;
+
+import com.google.caliper.UserException.NonConstantMemoryUsage;
+import com.google.common.base.Supplier;
+import com.google.monitoring.runtime.instrumentation.AllocationRecorder;
+import com.google.monitoring.runtime.instrumentation.Sampler;
+
+public abstract class AllocationMeasurer extends Measurer {
+
+  protected static final int ALLOCATION_DISPLAY_THRESHOLD = 50;
+
+  private boolean log;
+  private long tempAllocationCount;
+  private long allocationsToIgnore;
+  private long numberOfAllocations;
+  private long allocationCount;
+  private long outOfThreadAllocationCount;
+  private boolean recordAllocations;
+  protected String type;
+
+  protected AllocationMeasurer() {
+    log = false;
+    allocationsToIgnore = 0;
+    numberOfAllocations = 0;
+    allocationCount = 0;
+    outOfThreadAllocationCount = 0;
+    recordAllocations = false;
+
+    final Thread allocatingThread = Thread.currentThread();
+    AllocationRecorder.addSampler(new Sampler() {
+      // allocated {@code newObj} of type {@code desc}, whose size is {@code size}.
+      // if this was not an array, {@code count} is -1. If it was array, {@code count} is the
+      // size of the array.
+      @Override public void sampleAllocation(int count, String desc, Object newObj, long size) {
+        if (recordAllocations) {
+          if (Thread.currentThread().equals(allocatingThread)) {
+            if (log) {
+              logAllocation(count, desc, size);
+            } else if (numberOfAllocations == 0) {
+              log("see first run for list of allocations");
+            }
+            allocationCount = incrementAllocationCount(allocationCount, count, size);
+            tempAllocationCount++;
+            numberOfAllocations++;
+          } else {
+            outOfThreadAllocationCount = incrementAllocationCount(outOfThreadAllocationCount, count, size);
+            numberOfAllocations++;
+          }
+        }
+      }
+    });
+  }
+
+  protected abstract long incrementAllocationCount(long orig, int count, long size);
+
+  private void logAllocation(int count, String desc, long size) {
+    if (numberOfAllocations >= allocationsToIgnore) {
+      if (numberOfAllocations < ALLOCATION_DISPLAY_THRESHOLD + allocationsToIgnore) {
+        log("allocating " + desc + (count == -1 ? "" : " array with " + count + " elements")
+            + " with size " + size + " bytes");
+      } else if (numberOfAllocations == ALLOCATION_DISPLAY_THRESHOLD + allocationsToIgnore) {
+        log("...more allocations...");
+      }
+    }
+  }
+
+  @Override public MeasurementSet run(Supplier<ConfiguredBenchmark> testSupplier) throws Exception {
+
+    // warm up, for some reason the very first time anything is measured, it will have a few more
+    // allocations.
+    measureAllocations(testSupplier.get(), 1, 0);
+
+    // The "one" case serves as a base line. There may be caching, lazy loading, etc going on here.
+    tempAllocationCount = 0; // count the number of times the sampler is called in one rep
+    long one = measureAllocationsTotal(testSupplier.get(), 1);
+    long oneAllocations = tempAllocationCount;
+
+    // we expect that the delta between any two consecutive reps will be constant
+    tempAllocationCount = 0; // count the number of times the sampler is called in two reps
+    long two = measureAllocationsTotal(testSupplier.get(), 2);
+    long twoAllocations = tempAllocationCount;
+    long expectedDiff = two - one;
+    // there is some overhead on the first call that we can ignore for the purposes of measurement
+    long unitsToIgnore = one - expectedDiff;
+    allocationsToIgnore = 2 * oneAllocations - twoAllocations;
+    log("ignoring " + allocationsToIgnore + " allocation(s) per measurement as overhead");
+
+    Measurement[] allocationMeasurements = new Measurement[4];
+    log = true;
+    allocationMeasurements[0] = measureAllocations(testSupplier.get(), 1, unitsToIgnore);
+    log = false;
+    for (int i = 1; i < allocationMeasurements.length; i++) {
+      allocationMeasurements[i] =
+          measureAllocations(testSupplier.get(), i + 1, unitsToIgnore);
+      if (Math.round(allocationMeasurements[i].getRaw()) != expectedDiff) {
+        throw new NonConstantMemoryUsage();
+      }
+    }
+
+    // The above logic guarantees that all the measurements are equal, so we only need to return a
+    // single measurement.
+    allocationsToIgnore = 0;
+    return new MeasurementSet(allocationMeasurements[0]);
+  }
+
+  private Measurement measureAllocations(ConfiguredBenchmark benchmark, int reps, long toIgnore)
+      throws Exception {
+    prepareForTest();
+    log(LogConstants.MEASURED_SECTION_STARTING);
+    resetAllocations();
+    recordAllocations = true;
+    benchmark.run(reps);
+    recordAllocations = false;
+    log(LogConstants.MEASURED_SECTION_DONE);
+    long allocations = (allocationCount - toIgnore) / reps;
+    long outOfThreadAllocations = outOfThreadAllocationCount;
+    log(allocations + " " + type + "(s) allocated per rep");
+    log(outOfThreadAllocations + " out of thread " + type + "(s) allocated in " + reps + " reps");
+    benchmark.close();
+    return getMeasurement(benchmark, allocations);
+  }
+
+  protected abstract Measurement getMeasurement(ConfiguredBenchmark benchmark, long allocations);
+
+  private long measureAllocationsTotal(ConfiguredBenchmark benchmark, int reps)
+      throws Exception {
+    prepareForTest();
+    log(LogConstants.MEASURED_SECTION_STARTING);
+    resetAllocations();
+    recordAllocations = true;
+    benchmark.run(reps);
+    recordAllocations = false;
+    log(LogConstants.MEASURED_SECTION_DONE);
+    long allocations = allocationCount;
+    long outOfThreadAllocations = outOfThreadAllocationCount;
+    log(allocations + " " + type + "(s) allocated in " + reps + " reps");
+    if (outOfThreadAllocations > 0) {
+      log(outOfThreadAllocations + " out of thread " + type + "(s) allocated in " + reps + " reps");
+    }
+    benchmark.close();
+    return allocations;
+  }
+
+  private void resetAllocations() {
+    allocationCount = 0;
+    outOfThreadAllocationCount = 0;
+    numberOfAllocations = 0;
+  }
+}
diff --git a/caliper/src/main/java/com/google/caliper/Arguments.java b/caliper/src/main/java/com/google/caliper/Arguments.java
new file mode 100644
index 0000000..cceb079
--- /dev/null
+++ b/caliper/src/main/java/com/google/caliper/Arguments.java
@@ -0,0 +1,420 @@
+/*
+ * Copyright (C) 2010 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.caliper;
+
+import com.google.caliper.UserException.DisplayUsageException;
+import com.google.caliper.UserException.IncompatibleArgumentsException;
+import com.google.caliper.UserException.InvalidParameterValueException;
+import com.google.caliper.UserException.MultipleBenchmarkClassesException;
+import com.google.caliper.UserException.NoBenchmarkClassException;
+import com.google.caliper.UserException.UnrecognizedOptionException;
+import com.google.common.base.Splitter;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Iterators;
+import com.google.common.collect.LinkedHashMultimap;
+import com.google.common.collect.Maps;
+import com.google.common.collect.Multimap;
+import com.google.common.collect.Sets;
+
+import java.io.File;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * Parse command line arguments for the runner and in-process runner.
+ */
+public final class Arguments {
+  private String suiteClassName;
+
+  /** JVMs to run in the benchmark */
+  private final Set<String> userVms = Sets.newLinkedHashSet();
+
+  /**
+   * Parameter values specified by the user on the command line. Parameters with
+   * no value in this multimap will get their values from the benchmark suite.
+   */
+  private final Multimap<String, String> userParameters = LinkedHashMultimap.create();
+
+  /**
+   * VM parameters like {memory=[-Xmx64,-Xmx128],jit=[-client,-server]}
+   */
+  private final Multimap<String, String> vmParameters = LinkedHashMultimap.create();
+
+  private int trials = 1;
+  private long warmupMillis = 3000;
+  private long runMillis = 1000;
+  private String timeUnit = null;
+  private String instanceUnit = null;
+  private String memoryUnit = null;
+  private File saveResultsFile = null;
+  private File uploadResultsFile = null;
+  private boolean captureVmLog = false;
+  private boolean printScore = false;
+  private boolean measureMemory = false;
+  private boolean debug = false;
+  private int debugReps = defaultDebugReps;
+  private MeasurementType measurementType;
+  private MeasurementType primaryMeasurementType;
+
+  /**
+   * A signal that indicates a JSON object interleaved with the process output.
+   * Should be short, but unlikely to show up in the processes natural output.
+   */
+  private String marker = "//ZxJ/";
+
+  private static final String defaultDelimiter = ",";
+  private static final int defaultDebugReps = 1000;
+
+  public String getSuiteClassName() {
+    return suiteClassName;
+  }
+
+  public Set<String> getUserVms() {
+    return userVms;
+  }
+
+  public int getTrials() {
+    return trials;
+  }
+
+  public Multimap<String, String> getVmParameters() {
+    return vmParameters;
+  }
+
+  public Multimap<String, String> getUserParameters() {
+    return userParameters;
+  }
+
+  public long getWarmupMillis() {
+    return warmupMillis;
+  }
+
+  public long getRunMillis() {
+    return runMillis;
+  }
+
+  public String getTimeUnit() {
+    return timeUnit;
+  }
+
+  public String getInstanceUnit() {
+    return instanceUnit;
+  }
+
+  public String getMemoryUnit() {
+    return memoryUnit;
+  }
+
+  public File getSaveResultsFile() {
+    return saveResultsFile;
+  }
+
+  public File getUploadResultsFile() {
+    return uploadResultsFile;
+  }
+
+  public boolean getCaptureVmLog() {
+    return captureVmLog;
+  }
+
+  public boolean printScore() {
+    return printScore;
+  }
+
+  public boolean getMeasureMemory() {
+    return measureMemory;
+  }
+
+  public MeasurementType getMeasurementType() {
+    return measurementType;
+  }
+
+  public MeasurementType getPrimaryMeasurementType() {
+    return primaryMeasurementType;
+  }
+
+  public boolean getDebug() {
+    return debug;
+  }
+
+  public int getDebugReps() {
+    return debugReps;
+  }
+
+  public String getMarker() {
+    return marker;
+  }
+
+  public static Arguments parse(String[] argsArray) {
+    Arguments result = new Arguments();
+
+    Iterator<String> args = Iterators.forArray(argsArray);
+    String delimiter = defaultDelimiter;
+    Map<String, String> userParameterStrings = Maps.newLinkedHashMap();
+    Map<String, String> vmParameterStrings = Maps.newLinkedHashMap();
+    String vmString = null;
+    boolean standardRun = false;
+    while (args.hasNext()) {
+      String arg = args.next();
+
+      if ("--help".equals(arg)) {
+        throw new DisplayUsageException();
+      }
+
+      if (arg.startsWith("-D") || arg.startsWith("-J")) {
+
+        /*
+         * Handle user parameters (-D) and VM parameters (-J) of these forms:
+         *
+         * -Dlength=100
+         * -Jmemory=-Xmx1024M
+         * -Dlength=100,200
+         * -Jmemory=-Xmx1024M,-Xmx2048M
+         * -Dlength 100
+         * -Jmemory -Xmx1024M
+         * -Dlength 100,200
+         * -Jmemory -Xmx1024M,-Xmx2048M
+         */
+
+        String name;
+        String value;
+        int equalsSign = arg.indexOf('=');
+        if (equalsSign == -1) {
+          name = arg.substring(2);
+          value = args.next();
+        } else {
+          name = arg.substring(2, equalsSign);
+          value = arg.substring(equalsSign + 1);
+        }
+
+        String previousValue;
+        if (arg.startsWith("-D")) {
+          previousValue = userParameterStrings.put(name, value);
+        } else {
+          previousValue = vmParameterStrings.put(name, value);
+        }
+        if (previousValue != null) {
+          throw new UserException.DuplicateParameterException(arg);
+        }
+        standardRun = true;
+      // TODO: move warmup/run to caliperrc
+      } else if ("--captureVmLog".equals(arg)) {
+        result.captureVmLog = true;
+        standardRun = true;
+      } else if ("--warmupMillis".equals(arg)) {
+        result.warmupMillis = Long.parseLong(args.next());
+        standardRun = true;
+      } else if ("--runMillis".equals(arg)) {
+        result.runMillis = Long.parseLong(args.next());
+        standardRun = true;
+      } else if ("--trials".equals(arg)) {
+        String value = args.next();
+        try {
+          result.trials = Integer.parseInt(value);
+          if (result.trials < 1) {
+            throw new UserException.InvalidTrialsException(value);
+          }
+        } catch (NumberFormatException e) {
+          throw new UserException.InvalidTrialsException(value);
+        }
+        standardRun = true;
+      } else if ("--vm".equals(arg)) {
+        if (vmString != null) {
+          throw new UserException.DuplicateParameterException(arg);
+        }
+        vmString = args.next();
+        standardRun = true;
+      } else if ("--delimiter".equals(arg)) {
+        delimiter = args.next();
+        standardRun = true;
+      } else if ("--timeUnit".equals(arg)) {
+        result.timeUnit = args.next();
+        standardRun = true;
+      } else if ("--instanceUnit".equals(arg)) {
+        result.instanceUnit = args.next();
+        standardRun = true;
+      } else if ("--memoryUnit".equals(arg)) {
+        result.memoryUnit = args.next();
+        standardRun = true;
+      } else if ("--saveResults".equals(arg) || "--xmlSave".equals(arg)) {
+        // TODO: unsupport legacy --xmlSave
+        result.saveResultsFile = new File(args.next());
+        standardRun = true;
+      } else if ("--uploadResults".equals(arg)) {
+        result.uploadResultsFile = new File(args.next());
+      } else if ("--printScore".equals(arg)) {
+        result.printScore = true;
+        standardRun = true;
+      } else if ("--measureMemory".equals(arg)) {
+        result.measureMemory = true;
+        standardRun = true;
+      } else if ("--debug".equals(arg)) {
+        result.debug = true;
+      } else if ("--debug-reps".equals(arg)) {
+        String value = args.next();
+        try {
+          result.debugReps = Integer.parseInt(value);
+          if (result.debugReps < 1) {
+            throw new UserException.InvalidDebugRepsException(value);
+          }
+        } catch (NumberFormatException e) {
+          throw new UserException.InvalidDebugRepsException(value);
+        }
+      } else if ("--marker".equals(arg)) {
+        result.marker = args.next();
+      } else if ("--measurementType".equals(arg)) {
+        String measurementType = args.next();
+        try {
+          result.measurementType = MeasurementType.valueOf(measurementType);
+        } catch (Exception e) {
+          throw new InvalidParameterValueException(arg, measurementType);
+        }
+        standardRun = true;
+      } else if ("--primaryMeasurementType".equals(arg)) {
+        String measurementType = args.next().toUpperCase();
+        try {
+          result.primaryMeasurementType = MeasurementType.valueOf(measurementType);
+        } catch (Exception e) {
+          throw new InvalidParameterValueException(arg, measurementType);
+        }
+        standardRun = true;
+      } else if (arg.startsWith("-")) {
+        throw new UnrecognizedOptionException(arg);
+
+      } else {
+        if (result.suiteClassName != null) {
+          throw new MultipleBenchmarkClassesException(result.suiteClassName, arg);
+        }
+        result.suiteClassName = arg;
+      }
+    }
+
+    Splitter delimiterSplitter = Splitter.on(delimiter);
+
+    if (vmString != null) {
+      Iterables.addAll(result.userVms, delimiterSplitter.split(vmString));
+    }
+
+    Set<String> duplicates = Sets.intersection(
+        userParameterStrings.keySet(), vmParameterStrings.keySet());
+    if (!duplicates.isEmpty()) {
+      throw new UserException.DuplicateParameterException(duplicates);
+    }
+
+    for (Map.Entry<String, String> entry : userParameterStrings.entrySet()) {
+      result.userParameters.putAll(entry.getKey(), delimiterSplitter.split(entry.getValue()));
+    }
+    for (Map.Entry<String, String> entry : vmParameterStrings.entrySet()) {
+      result.vmParameters.putAll(entry.getKey(), delimiterSplitter.split(entry.getValue()));
+    }
+
+    if (standardRun && result.uploadResultsFile != null) {
+      throw new IncompatibleArgumentsException("--uploadResults");
+    }
+
+    if (result.suiteClassName == null && result.uploadResultsFile == null) {
+      throw new NoBenchmarkClassException();
+    }
+
+    if (result.primaryMeasurementType != null
+        && result.primaryMeasurementType != MeasurementType.TIME && !result.measureMemory) {
+      throw new IncompatibleArgumentsException(
+          "--primaryMeasurementType " + result.primaryMeasurementType.toString().toLowerCase());
+    }
+
+    return result;
+  }
+
+  public static void printUsage() {
+    System.out.println();
+    System.out.println("Usage: Runner [OPTIONS...] <benchmark>");
+    System.out.println();
+    System.out.println("  <benchmark>: a benchmark class or suite");
+    System.out.println();
+    System.out.println("OPTIONS");
+    System.out.println();
+    System.out.println("  -D<param>=<value>: fix a benchmark parameter to a given value.");
+    System.out.println("        Multiple values can be supplied by separating them with the");
+    System.out.println("        delimiter specified in the --delimiter argument.");
+    System.out.println();
+    System.out.println("        For example: \"-Dfoo=bar,baz,bat\"");
+    System.out.println();
+    System.out.println("        \"benchmark\" is a special parameter that can be used to specify");
+    System.out.println("        which benchmark methods to run. For example, if a benchmark has");
+    System.out.println("        the method \"timeFoo\", it can be run alone by using");
+    System.out.println("        \"-Dbenchmark=Foo\". \"benchmark\" also accepts a delimiter");
+    System.out.println("        separated list of methods to run.");
+    System.out.println();
+    System.out.println("  -J<param>=<value>: set a JVM argument to the given value.");
+    System.out.println("        Multiple values can be supplied by separating them with the");
+    System.out.println("        delimiter specified in the --delimiter argument.");
+    System.out.println();
+    System.out.println("        For example: \"-JmemoryMax=-Xmx32M,-Xmx512M\"");
+    System.out.println();
+    System.out.println("  --delimiter <delimiter>: character or string to use as a delimiter");
+    System.out.println("        for parameter and vm values.");
+    System.out.println("        Default: \"" + defaultDelimiter + "\"");
+    System.out.println();
+    System.out.println("  --warmupMillis <millis>: duration to warmup each benchmark");
+    System.out.println();
+    System.out.println("  --runMillis <millis>: duration to execute each benchmark");
+    System.out.println();
+    System.out.println("  --captureVmLog: record the VM's just-in-time compiler and GC logs.");
+    System.out.println("        This may slow down or break benchmark display tools.");
+    System.out.println();
+    System.out.println("  --measureMemory: measure the number of allocations done and the amount of");
+    System.out.println("        memory used by invocations of the benchmark.");
+    System.out.println("        Default: off");
+    System.out.println();
+    System.out.println("  --vm <vm>: executable to test benchmark on. Multiple VMs may be passed");
+    System.out.println("        in as a list separated by the delimiter specified in the");
+    System.out.println("        --delimiter argument.");
+    System.out.println();
+    System.out.println("  --timeUnit <unit>: unit of time to use for result. Depends on the units");
+    System.out.println("        defined in the benchmark's getTimeUnitNames() method, if defined.");
+    System.out.println("        Default Options: ns, us, ms, s");
+    System.out.println();
+    System.out.println("  --instanceUnit <unit>: unit to use for allocation instances result.");
+    System.out.println("        Depends on the units defined in the benchmark's");
+    System.out.println("        getInstanceUnitNames() method, if defined.");
+    System.out.println("        Default Options: instances, K instances, M instances, B instances");
+    System.out.println();
+    System.out.println("  --memoryUnit <unit>: unit to use for allocation memory size result.");
+    System.out.println("        Depends on the units defined in the benchmark's");
+    System.out.println("        getMemoryUnitNames() method, if defined.");
+    System.out.println("        Default Options: B, KB, MB, GB");
+    System.out.println();
+    System.out.println("  --saveResults <file/dir>: write results to this file or directory");
+    System.out.println();
+    System.out.println("  --printScore: if present, also display an aggregate score for this run,");
+    System.out.println("        where higher is better. This number has no particular meaning,");
+    System.out.println("        but can be compared to scores from other runs that use the exact");
+    System.out.println("        same arguments.");
+    System.out.println();
+    System.out.println("  --uploadResults <file/dir>: upload this file or directory of files");
+    System.out.println("        to the web app. This argument ends Caliper early and is thus");
+    System.out.println("        incompatible with all other arguments.");
+    System.out.println();
+    System.out.println("  --debug: run without measurement for use with debugger or profiling.");
+    System.out.println();
+    System.out.println("  --debug-reps: fixed number of reps to run with --debug.");
+    System.out.println("        Default: \"" + defaultDebugReps + "\"");
+
+    // adding new options? don't forget to update executeForked()
+  }
+}
diff --git a/caliper/src/main/java/com/google/caliper/Benchmark.java b/caliper/src/main/java/com/google/caliper/Benchmark.java
new file mode 100644
index 0000000..06bda82
--- /dev/null
+++ b/caliper/src/main/java/com/google/caliper/Benchmark.java
@@ -0,0 +1,55 @@
+/*
+ * Copyright (C) 2009 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.caliper;
+
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * A collection of benchmarks that share a set of configuration parameters.
+ */
+public interface Benchmark {
+
+  Set<String> parameterNames();
+
+  Set<String> parameterValues(String parameterName);
+
+  ConfiguredBenchmark createBenchmark(Map<String, String> parameterValues);
+
+  /**
+   * A mapping of units to their values. Their values must be integers, but all values are relative,
+   * so if one unit is 1.5 times the size of another, then these units can be expressed as
+   * {"unit1"=10,"unit2"=15}. The smallest unit given by the function will be used to display
+   * immediate results when running at the command line.
+   *
+   * e.g. 0% Scenario{...} 16.08<SMALLEST-UNIT>; σ=1.72<SMALLEST-UNIT> @ 3 trials
+   */
+  Map<String, Integer> getTimeUnitNames();
+
+  Map<String, Integer> getInstanceUnitNames();
+
+  Map<String, Integer> getMemoryUnitNames();
+
+  /**
+   * Converts nanoseconds to the smallest unit defined in {@link #getTimeUnitNames()}.
+   */
+  double nanosToUnits(double nanos);
+
+  double instancesToUnits(long instances);
+
+  double bytesToUnits(long bytes);
+}
\ No newline at end of file
diff --git a/caliper/src/main/java/com/google/caliper/CaliperRc.java b/caliper/src/main/java/com/google/caliper/CaliperRc.java
new file mode 100644
index 0000000..21a283f
--- /dev/null
+++ b/caliper/src/main/java/com/google/caliper/CaliperRc.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright (C) 2010 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.caliper;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.Properties;
+
+public class CaliperRc {
+  public static final CaliperRc INSTANCE = new CaliperRc();
+
+  private final Properties properties = new Properties();
+
+  private CaliperRc() {
+    try {
+      String caliperRcEnvVar = System.getenv("CALIPERRC");
+      File caliperRcFile = (caliperRcEnvVar == null)
+          ? new File(System.getProperty("user.home"), ".caliperrc")
+          : new File(caliperRcEnvVar);
+      if (caliperRcFile.exists()) {
+        InputStream in = new FileInputStream(caliperRcFile);
+        properties.load(in);
+        in.close();
+      } else {
+        // create it with a template
+      }
+    } catch (IOException e) {
+      throw new RuntimeException(e);
+    }
+  }
+
+  public String getApiKey() {
+    return properties.getProperty("apiKey");
+  }
+
+  public String getPostUrl() {
+    return properties.getProperty("postUrl");
+  }
+
+  /**
+   * The HTTP proxy host name and port number separated by a colon, such as
+   * foo.com:8080
+   */
+  public String getProxy() {
+    return properties.getProperty("proxy");
+  }
+}
diff --git a/caliper/src/main/java/com/google/caliper/ConfigurationException.java b/caliper/src/main/java/com/google/caliper/ConfigurationException.java
new file mode 100644
index 0000000..c4a35ec
--- /dev/null
+++ b/caliper/src/main/java/com/google/caliper/ConfigurationException.java
@@ -0,0 +1,33 @@
+/*
+ * Copyright (C) 2009 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.caliper;
+
+/**
+ * Thrown upon occurrence of a configuration error.
+ */
+final class ConfigurationException extends RuntimeException {
+
+  ConfigurationException(String s) {
+    super(s);
+  }
+
+  ConfigurationException(Throwable cause) {
+    super(cause);
+  }
+
+  private static final long serialVersionUID = 0;
+}
diff --git a/caliper/src/main/java/com/google/caliper/ConfiguredBenchmark.java b/caliper/src/main/java/com/google/caliper/ConfiguredBenchmark.java
new file mode 100644
index 0000000..f150ec1
--- /dev/null
+++ b/caliper/src/main/java/com/google/caliper/ConfiguredBenchmark.java
@@ -0,0 +1,67 @@
+/**
+ * Copyright (C) 2009 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.caliper;
+
+import java.util.Map;
+
+public abstract class ConfiguredBenchmark {
+
+  private final Benchmark underlyingBenchmark;
+
+  protected ConfiguredBenchmark(Benchmark underlyingBenchmark) {
+    this.underlyingBenchmark = underlyingBenchmark;
+  }
+
+  /**
+   * Runs the benchmark through {@code reps} iterations.
+   *
+   * @return any object or null. Benchmark implementors may keep an accumulating
+   *      value to prevent the runtime from optimizing away the code under test.
+   *      Such an accumulator value can be returned here.
+   */
+  public abstract Object run(int reps) throws Exception;
+
+  public abstract void close() throws Exception;
+
+  public final Benchmark getBenchmark() {
+    return underlyingBenchmark;
+  }
+
+  public final double nanosToUnits(double nanos) {
+    return underlyingBenchmark.nanosToUnits(nanos);
+  }
+
+  public final Map<String, Integer> timeUnitNames() {
+    return underlyingBenchmark.getTimeUnitNames();
+  }
+
+  public final double instancesToUnits(long instances) {
+    return underlyingBenchmark.instancesToUnits(instances);
+  }
+
+  public final Map<String, Integer> instanceUnitNames() {
+    return underlyingBenchmark.getInstanceUnitNames();
+  }
+
+  public final double bytesToUnits(long bytes) {
+    return underlyingBenchmark.bytesToUnits(bytes);
+  }
+
+  public final Map<String, Integer> memoryUnitNames() {
+    return underlyingBenchmark.getMemoryUnitNames();
+  }
+}
diff --git a/caliper/src/main/java/com/google/caliper/ConsoleReport.java b/caliper/src/main/java/com/google/caliper/ConsoleReport.java
new file mode 100644
index 0000000..8449bda
--- /dev/null
+++ b/caliper/src/main/java/com/google/caliper/ConsoleReport.java
@@ -0,0 +1,427 @@
+/**
+ * Copyright (C) 2009 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.caliper;
+
+import com.google.caliper.util.LinearTranslation;
+import com.google.common.base.Strings;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.LinkedHashMultimap;
+import com.google.common.collect.Multimap;
+import com.google.common.collect.Ordering;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.EnumMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+
+/**
+ * Prints a report containing the tested values and the corresponding
+ * measurements. Measurements are grouped by variable using indentation.
+ * Alongside numeric values, quick-glance ascii art bar charts are printed.
+ * Sample output (this may not represent the exact form that is produced):
+ * <pre>
+ *              benchmark          d     ns linear runtime
+ * ConcatenationBenchmark 3.14159265   4397 ========================
+ * ConcatenationBenchmark       -0.0    223 ===============
+ *     FormatterBenchmark 3.14159265  33999 ==============================
+ *     FormatterBenchmark       -0.0  26399 =============================
+ * </pre>
+ */
+final class ConsoleReport {
+
+  private static final int barGraphWidth = 30;
+
+  private static final int UNITS_FOR_SCORE_100 = 1;
+  private static final int UNITS_FOR_SCORE_10 = 1000000000; // 1 s
+
+  private static final LinearTranslation scoreTranslation =
+      new LinearTranslation(Math.log(UNITS_FOR_SCORE_10), 10,
+                            Math.log(UNITS_FOR_SCORE_100), 100);
+
+  public static final Ordering<Entry<String, Integer>> UNIT_ORDERING =
+      new Ordering<Entry<String, Integer>>() {
+        @Override public int compare(Entry<String, Integer> a, Entry<String, Integer> b) {
+          return a.getValue().compareTo(b.getValue());
+        }
+      };
+
+  private final List<Variable> variables;
+  private final Run run;
+  private final List<Scenario> scenarios;
+
+  private final List<MeasurementType> orderedMeasurementTypes;
+  private final MeasurementType type;
+  private final double maxValue;
+  private final double logMinValue;
+  private final double logMaxValue;
+  private final EnumMap<MeasurementType, Integer> decimalDigitsMap =
+      new EnumMap<MeasurementType, Integer>(MeasurementType.class);
+  private final EnumMap<MeasurementType, Double> divideByMap =
+      new EnumMap<MeasurementType, Double>(MeasurementType.class);
+  private final EnumMap<MeasurementType, String> unitMap =
+      new EnumMap<MeasurementType, String>(MeasurementType.class);
+  private final EnumMap<MeasurementType, Integer> measurementColumnLengthMap =
+      new EnumMap<MeasurementType, Integer>(MeasurementType.class);
+  private boolean printScore;
+
+  ConsoleReport(Run run, Arguments arguments) {
+    this.run = run;
+    unitMap.put(MeasurementType.TIME, arguments.getTimeUnit());
+    unitMap.put(MeasurementType.INSTANCE, arguments.getInstanceUnit());
+    unitMap.put(MeasurementType.MEMORY, arguments.getMemoryUnit());
+
+    if (arguments.getMeasureMemory()) {
+      orderedMeasurementTypes = Arrays.asList(
+          MeasurementType.TIME, MeasurementType.INSTANCE, MeasurementType.MEMORY);
+    } else {
+      orderedMeasurementTypes = Arrays.asList(MeasurementType.TIME);
+    }
+
+    if (arguments.getPrimaryMeasurementType() != null) {
+      this.type = arguments.getPrimaryMeasurementType();
+    } else {
+      this.type = MeasurementType.TIME;
+    }
+
+    double min = Double.POSITIVE_INFINITY;
+    double max = 0;
+
+    Multimap<String, String> nameToValues = LinkedHashMultimap.create();
+    List<Variable> variablesBuilder = new ArrayList<Variable>();
+    for (Entry<Scenario, ScenarioResult> entry : this.run.getMeasurements().entrySet()) {
+      Scenario scenario = entry.getKey();
+      double d = entry.getValue().getMeasurementSet(type).medianUnits();
+
+      min = Math.min(min, d);
+      max = Math.max(max, d);
+
+      for (Entry<String, String> variable : scenario.getVariables().entrySet()) {
+        String name = variable.getKey();
+        nameToValues.put(name, variable.getValue());
+      }
+    }
+
+    for (Entry<String, Collection<String>> entry : nameToValues.asMap().entrySet()) {
+      Variable variable = new Variable(entry.getKey(), entry.getValue());
+      variablesBuilder.add(variable);
+    }
+
+    /*
+     * Figure out how much influence each variable has on the measured value.
+     * We sum the measurements taken with each value of each variable. For
+     * variable that have influence on the measurement, the sums will differ
+     * by value. If the variable has little influence, the sums will be similar
+     * to one another and close to the overall average. We take the standard
+     * deviation across each variable's collection of sums. Higher standard
+     * deviation implies higher influence on the measured result.
+     */
+    double sumOfAllMeasurements = 0;
+    for (ScenarioResult measurement : this.run.getMeasurements().values()) {
+      sumOfAllMeasurements += measurement.getMeasurementSet(type).medianUnits();
+    }
+    for (Variable variable : variablesBuilder) {
+      int numValues = variable.values.size();
+      double[] sumForValue = new double[numValues];
+      for (Entry<Scenario, ScenarioResult> entry
+          : this.run.getMeasurements().entrySet()) {
+        Scenario scenario = entry.getKey();
+        sumForValue[variable.index(scenario)] +=
+            entry.getValue().getMeasurementSet(type).medianUnits();
+      }
+      double mean = sumOfAllMeasurements / sumForValue.length;
+      double stdDeviationSquared = 0;
+      for (double value : sumForValue) {
+        double distance = value - mean;
+        stdDeviationSquared += distance * distance;
+      }
+      variable.stdDeviation = Math.sqrt(stdDeviationSquared / numValues);
+    }
+
+    this.variables = new StandardDeviationOrdering().reverse().sortedCopy(variablesBuilder);
+    this.scenarios = new ByVariablesOrdering().sortedCopy(this.run.getMeasurements().keySet());
+    this.maxValue = max;
+    this.logMinValue = Math.log(min);
+    this.logMaxValue = Math.log(max);
+
+    EnumMap<MeasurementType, Integer> digitsBeforeDecimalMap =
+      new EnumMap<MeasurementType, Integer>(MeasurementType.class);
+    EnumMap<MeasurementType, Integer> decimalPointMap =
+      new EnumMap<MeasurementType, Integer>(MeasurementType.class);
+    for (MeasurementType measurementType : orderedMeasurementTypes) {
+      double maxForType = 0;
+      double minForType = Double.POSITIVE_INFINITY;
+      for (Entry<Scenario, ScenarioResult> entry : this.run.getMeasurements().entrySet()) {
+        double d = entry.getValue().getMeasurementSet(measurementType).medianUnits();
+        minForType = Math.min(minForType, d);
+        maxForType = Math.max(maxForType, d);
+      }
+
+      unitMap.put(measurementType,
+          getUnit(unitMap.get(measurementType), measurementType, minForType));
+
+      divideByMap.put(measurementType,
+          (double) getUnits(measurementType).get(unitMap.get(measurementType)));
+
+      int numDigitsInMin = ceil(Math.log10(minForType));
+      decimalDigitsMap.put(measurementType,
+          ceil(Math.max(0, ceil(Math.log10(divideByMap.get(measurementType))) + 3 - numDigitsInMin)));
+
+      digitsBeforeDecimalMap.put(measurementType,
+          Math.max(1, ceil(Math.log10(maxForType / divideByMap.get(measurementType)))));
+
+      decimalPointMap.put(measurementType, decimalDigitsMap.get(measurementType) > 0 ? 1 : 0);
+
+      measurementColumnLengthMap.put(measurementType, Math.max(maxForType > 0
+          ?  digitsBeforeDecimalMap.get(measurementType) + decimalPointMap.get(measurementType)
+              + decimalDigitsMap.get(measurementType)
+          : 1, unitMap.get(measurementType).trim().length()));
+    }
+
+    this.printScore = arguments.printScore();
+  }
+
+  private String getUnit(String userSuppliedUnit, MeasurementType measurementType, double min) {
+    Map<String, Integer> units = getUnits(measurementType);
+
+    if (userSuppliedUnit == null) {
+      List<Entry<String, Integer>> entries = UNIT_ORDERING.reverse().sortedCopy(units.entrySet());
+      for (Entry<String, Integer> entry : entries) {
+        if (min / entry.getValue() >= 1) {
+          return entry.getKey();
+        }
+      }
+      // if no unit works, just use the smallest available unit.
+      return entries.get(entries.size() - 1).getKey();
+    }
+
+    if (!units.keySet().contains(userSuppliedUnit)) {
+      throw new RuntimeException("\"" + unitMap.get(measurementType) + "\" is not a valid unit.");
+    }
+    return userSuppliedUnit;
+  }
+
+  private Map<String, Integer> getUnits(MeasurementType measurementType) {
+    Map<String, Integer> units = null;
+    for (Entry<Scenario, ScenarioResult> entry : run.getMeasurements().entrySet()) {
+      if (units == null) {
+        units = entry.getValue().getMeasurementSet(measurementType).getUnitNames();
+      } else {
+        if (!units.equals(entry.getValue().getMeasurementSet(measurementType).getUnitNames())) {
+          throw new RuntimeException("measurement sets for run contain multiple, incompatible unit"
+              + " sets.");
+        }
+      }
+    }
+    if (units == null) {
+      throw new RuntimeException("run has no measurements.");
+    }
+    if (units.isEmpty()) {
+      throw new RuntimeException("no units specified.");
+    }
+    return units;
+  }
+
+  /**
+   * A variable and the set of values to which it has been assigned.
+   */
+  private static class Variable {
+    final String name;
+    final ImmutableList<String> values;
+    final int maxLength;
+    double stdDeviation;
+
+    Variable(String name, Collection<String> values) {
+      this.name = name;
+      this.values = ImmutableList.copyOf(values);
+
+      int maxLen = name.length();
+      for (String value : values) {
+        maxLen = Math.max(maxLen, value.length());
+      }
+      this.maxLength = maxLen;
+    }
+
+    String get(Scenario scenario) {
+      return scenario.getVariables().get(name);
+    }
+
+    int index(Scenario scenario) {
+      return values.indexOf(get(scenario));
+    }
+
+    boolean isInteresting() {
+      return values.size() > 1;
+    }
+  }
+
+  /**
+   * Orders the different variables by their standard deviation. This results
+   * in an appropriate grouping of output values.
+   */
+  private static class StandardDeviationOrdering extends Ordering<Variable> {
+    public int compare(Variable a, Variable b) {
+      return Double.compare(a.stdDeviation, b.stdDeviation);
+    }
+  }
+
+  /**
+   * Orders scenarios by the variables.
+   */
+  private class ByVariablesOrdering extends Ordering<Scenario> {
+    public int compare(Scenario a, Scenario b) {
+      for (Variable variable : variables) {
+        int aValue = variable.values.indexOf(variable.get(a));
+        int bValue = variable.values.indexOf(variable.get(b));
+        int diff = aValue - bValue;
+        if (diff != 0) {
+          return diff;
+        }
+      }
+      return 0;
+    }
+  }
+
+  void displayResults() {
+    printValues();
+    System.out.println();
+    printUninterestingVariables();
+    printCharCounts();
+  }
+
+  private void printCharCounts() {
+    int systemOutCharCount = 0;
+    int systemErrCharCount = 0;
+    for (ScenarioResult scenarioResult : run.getMeasurements().values()) {
+      for (MeasurementType measurementType : MeasurementType.values()) {
+        MeasurementSet measurementSet = scenarioResult.getMeasurementSet(measurementType);
+        if (measurementSet != null) {
+          systemOutCharCount += measurementSet.getSystemOutCharCount();
+          systemErrCharCount += measurementSet.getSystemErrCharCount();
+        }
+      }
+    }
+    if (systemOutCharCount > 0 || systemErrCharCount > 0) {
+      System.out.println();
+      System.out.println("Note: benchmarks printed " + systemOutCharCount
+          + " characters to System.out and " + systemErrCharCount + " characters to System.err."
+          + " Use --debug to see this output.");
+    }
+  }
+
+  /**
+   * Prints a table of values.
+   */
+  private void printValues() {
+    // header
+    for (Variable variable : variables) {
+      if (variable.isInteresting()) {
+        System.out.printf("%" + variable.maxLength + "s ", variable.name);
+      }
+    }
+    // doesn't make sense to show graphs at all for 1
+    // scenario, since it leads to vacuous graphs.
+    boolean showGraphs = scenarios.size() > 1;
+
+    EnumMap<MeasurementType, String> numbersFormatMap =
+        new EnumMap<MeasurementType, String>(MeasurementType.class);
+    for (MeasurementType measurementType : orderedMeasurementTypes) {
+      if (measurementType != type) {
+        System.out.printf("%" + measurementColumnLengthMap.get(measurementType) + "s ",
+            unitMap.get(measurementType).trim());
+      }
+
+      numbersFormatMap.put(measurementType,
+          "%" + measurementColumnLengthMap.get(measurementType)
+              + "." + decimalDigitsMap.get(measurementType) + "f"
+              + (type == measurementType ? "" : " "));
+    }
+
+    System.out.printf("%" + measurementColumnLengthMap.get(type) + "s", unitMap.get(type).trim());
+    if (showGraphs) {
+      System.out.print(" linear runtime");
+    }
+    System.out.println();
+
+    double sumOfLogs = 0.0;
+
+    for (Scenario scenario : scenarios) {
+      for (Variable variable : variables) {
+        if (variable.isInteresting()) {
+          System.out.printf("%" + variable.maxLength + "s ", variable.get(scenario));
+        }
+      }
+      ScenarioResult measurement = run.getMeasurements().get(scenario);
+      sumOfLogs += Math.log(measurement.getMeasurementSet(type).medianUnits());
+
+      for (MeasurementType measurementType : orderedMeasurementTypes) {
+        if (measurementType != type) {
+          System.out.printf(numbersFormatMap.get(measurementType),
+              measurement.getMeasurementSet(measurementType).medianUnits() / divideByMap.get(measurementType));
+        }
+      }
+
+      System.out.printf(numbersFormatMap.get(type),
+          measurement.getMeasurementSet(type).medianUnits() / divideByMap.get(type));
+      if (showGraphs) {
+        System.out.printf(" %s", barGraph(measurement.getMeasurementSet(type).medianUnits()));
+      }
+      System.out.println();
+    }
+
+    if (printScore) {
+      // arithmetic mean of logs, aka log of geometric mean
+      double meanLogUnits = sumOfLogs / scenarios.size();
+      System.out.format("%nScore: %.3f%n", scoreTranslation.translate(meanLogUnits));
+    }
+  }
+
+  /**
+   * Prints variables with only one unique value.
+   */
+  private void printUninterestingVariables() {
+    for (Variable variable : variables) {
+      if (!variable.isInteresting()) {
+        System.out.println(variable.name + ": " + Iterables.getOnlyElement(variable.values));
+      }
+    }
+  }
+
+  /**
+   * Returns a string containing a bar of proportional width to the specified
+   * value.
+   */
+  private String barGraph(double value) {
+    int graphLength = floor(value / maxValue * barGraphWidth);
+    graphLength = Math.max(1, graphLength);
+    graphLength = Math.min(barGraphWidth, graphLength);
+    return Strings.repeat("=", graphLength);
+  }
+
+  @SuppressWarnings("NumericCastThatLosesPrecision")
+  private static int floor(double d) {
+    return (int) d;
+  }
+
+  @SuppressWarnings("NumericCastThatLosesPrecision")
+  private static int ceil(double d) {
+    return (int) Math.ceil(d);
+  }
+}
diff --git a/caliper/src/main/java/com/google/caliper/CountingPrintStream.java b/caliper/src/main/java/com/google/caliper/CountingPrintStream.java
new file mode 100644
index 0000000..5c19a61
--- /dev/null
+++ b/caliper/src/main/java/com/google/caliper/CountingPrintStream.java
@@ -0,0 +1,77 @@
+/*
+ * Copyright (C) 2010 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.caliper;
+
+import java.io.PrintStream;
+
+/**
+ * Counts how many characters were written.
+ */
+final class CountingPrintStream extends PrintStream {
+
+  private final PrintStream delegate;
+  private int count;
+
+  CountingPrintStream(PrintStream delegate) {
+    super(delegate);
+    this.delegate = delegate;
+  }
+
+  public int getCount() {
+    return count;
+  }
+
+  @Override public void flush() {
+    delegate.flush();
+  }
+
+  @Override public void close() {
+    delegate.close();
+  }
+
+  @Override public boolean checkError() {
+    return delegate.checkError();
+  }
+
+  @Override protected void setError() {
+    throw new UnsupportedOperationException();
+  }
+
+  @Override protected void clearError() {
+    throw new UnsupportedOperationException();
+  }
+
+  @Override public void write(int b) {
+    count++;
+    delegate.write(b);
+  }
+
+  @Override public void write(byte[] buffer, int offset, int length) {
+    count += length;
+    delegate.write(buffer, offset, length);
+  }
+
+  @Override public void print(char[] chars) {
+    count += chars.length;
+    delegate.print(chars);
+  }
+
+  @Override public void print(String s) {
+    count += s.length();
+    delegate.print(s);
+  }
+}
diff --git a/caliper/src/main/java/com/google/caliper/DalvikVm.java b/caliper/src/main/java/com/google/caliper/DalvikVm.java
new file mode 100644
index 0000000..f89cc28
--- /dev/null
+++ b/caliper/src/main/java/com/google/caliper/DalvikVm.java
@@ -0,0 +1,62 @@
+/*
+ * Copyright (C) 2010 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.caliper;
+
+import com.google.common.collect.ImmutableList;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * The dalvikvm run on Android devices via the app_process executable.
+ */
+final class DalvikVm extends Vm {
+
+  public static boolean isDalvikVm() {
+    return "Dalvik".equals(System.getProperty("java.vm.name"));
+  }
+
+  public static String vmName() {
+    return "app_process";
+  }
+
+  @Override public List<String> getVmSpecificOptions(MeasurementType type, Arguments arguments) {
+    if (!arguments.getCaptureVmLog()) {
+      return ImmutableList.of();
+    }
+
+    List<String> result = new ArrayList<String>();
+    if (arguments.getCaptureVmLog()) {
+      // TODO: currently GC goes to logcat.
+      // result.add("-verbose:gc");
+    }
+    return result;
+  }
+
+  @Override public ProcessBuilder newProcessBuilder(File workingDirectory, String classPath,
+      ImmutableList<String> vmArgs, String className, ImmutableList<String> applicationArgs) {
+    ProcessBuilder result = new ProcessBuilder();
+    result.directory(workingDirectory);
+    result.command().addAll(vmArgs);
+    result.command().add("-Djava.class.path=" + classPath);
+    result.command().add(workingDirectory.getPath());
+    result.command().add(className);
+    result.command().addAll(applicationArgs);
+    return result;
+  }
+}
diff --git a/caliper/src/main/java/com/google/caliper/DebugMeasurer.java b/caliper/src/main/java/com/google/caliper/DebugMeasurer.java
new file mode 100644
index 0000000..64d4b7f
--- /dev/null
+++ b/caliper/src/main/java/com/google/caliper/DebugMeasurer.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright (C) 2010 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.caliper;
+
+import static com.google.common.base.Preconditions.checkArgument;
+
+import com.google.common.base.Supplier;
+
+/**
+ * Measure's the benchmark's per-trial execution time.
+ */
+class DebugMeasurer extends Measurer {
+
+  private final int reps;
+
+  DebugMeasurer(int reps) {
+    checkArgument(reps > 0);
+    this.reps = reps;
+  }
+
+  @Override public MeasurementSet run(Supplier<ConfiguredBenchmark> testSupplier)
+      throws Exception {
+    ConfiguredBenchmark benchmark = testSupplier.get();
+    benchmark.run(reps);
+    benchmark.close();
+    return null;
+  }
+}
diff --git a/caliper/src/main/java/com/google/caliper/Environment.java b/caliper/src/main/java/com/google/caliper/Environment.java
new file mode 100644
index 0000000..75c2813
--- /dev/null
+++ b/caliper/src/main/java/com/google/caliper/Environment.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright (C) 2010 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.caliper;
+
+import com.google.common.annotations.GwtCompatible;
+
+import java.io.Serializable;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * A description of an environment in which benchmarks are run.
+ *
+ * WARNING: a JSON representation of this class is stored on the app engine server. If any changes
+ * are made to this class, a deserialization adapter must be written for this class to ensure
+ * backwards compatibility.
+ *
+ * <p>Gwt-safe
+ */
+@SuppressWarnings("serial")
+@GwtCompatible
+public final class Environment
+    implements Serializable /* for GWT Serialization */ {
+  private /*final*/ Map<String, String> propertyMap;
+
+  public Environment(Map<String, String> propertyMap) {
+    this.propertyMap = new HashMap<String, String>(propertyMap);
+  }
+
+  public Map<String, String> getProperties() {
+    return propertyMap;
+  }
+
+  @Override public boolean equals(Object o) {
+    return o instanceof Environment
+        && ((Environment) o).propertyMap.equals(propertyMap);
+  }
+
+  @Override public int hashCode() {
+    return propertyMap.hashCode();
+  }
+
+  @Override public String toString() {
+    return propertyMap.toString();
+  }
+
+  @SuppressWarnings("unused")
+  private Environment() {} // for GWT Serialization
+}
diff --git a/caliper/src/main/java/com/google/caliper/EnvironmentGetter.java b/caliper/src/main/java/com/google/caliper/EnvironmentGetter.java
new file mode 100644
index 0000000..9b7150b
--- /dev/null
+++ b/caliper/src/main/java/com/google/caliper/EnvironmentGetter.java
@@ -0,0 +1,178 @@
+/*
+ * Copyright (C) 2010 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.caliper;
+
+import com.google.common.collect.ImmutableMultimap;
+import com.google.common.collect.ImmutableMultiset;
+import com.google.common.collect.Multimap;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.Reader;
+import java.net.InetAddress;
+import java.net.UnknownHostException;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+public final class EnvironmentGetter {
+
+  public Environment getEnvironmentSnapshot() {
+    Map<String, String> propertyMap = new HashMap<String, String>();
+
+    @SuppressWarnings("unchecked")
+    Map<String, String> sysProps = (Map<String, String>) (Map) System.getProperties();
+
+    // Sometimes java.runtime.version is more descriptive than java.version
+    String version = sysProps.get("java.version");
+    String alternateVersion = sysProps.get("java.runtime.version");
+    if (alternateVersion != null && alternateVersion.length() > version.length()) {
+      version = alternateVersion;
+    }
+    propertyMap.put("jre.version", version);
+
+    propertyMap.put("jre.vmname", sysProps.get("java.vm.name"));
+    propertyMap.put("jre.vmversion", sysProps.get("java.vm.version"));
+    propertyMap.put("jre.availableProcessors",
+        Integer.toString(Runtime.getRuntime().availableProcessors()));
+
+    String osName = sysProps.get("os.name");
+    propertyMap.put("os.name", osName);
+    propertyMap.put("os.version", sysProps.get("os.version"));
+    propertyMap.put("os.arch", sysProps.get("os.arch"));
+
+    try {
+      propertyMap.put("host.name", InetAddress.getLocalHost().getHostName());
+    } catch (UnknownHostException ignored) {
+    }
+
+    if (osName.equals("Linux")) {
+      getLinuxEnvironment(propertyMap);
+    }
+
+    return new Environment(propertyMap);
+  }
+
+  private void getLinuxEnvironment(Map<String, String> propertyMap) {
+    // the following probably doesn't work on ALL linux
+    Multimap<String, String> cpuInfo = propertiesFromLinuxFile("/proc/cpuinfo");
+    propertyMap.put("host.cpus", Integer.toString(cpuInfo.get("processor").size()));
+    String s = "cpu cores";
+    propertyMap.put("host.cpu.cores", describe(cpuInfo, s));
+    propertyMap.put("host.cpu.names", describe(cpuInfo, "model name"));
+    propertyMap.put("host.cpu.cachesize", describe(cpuInfo, "cache size"));
+
+    Multimap<String, String> memInfo = propertiesFromLinuxFile("/proc/meminfo");
+    // TODO redo memInfo.toString() so we don't get square brackets
+    propertyMap.put("host.memory.physical", memInfo.get("MemTotal").toString());
+    propertyMap.put("host.memory.swap", memInfo.get("SwapTotal").toString());
+
+    getAndroidEnvironment(propertyMap);
+  }
+
+  private void getAndroidEnvironment(Map<String, String> propertyMap) {
+    try {
+      Map<String, String> map = getAndroidProperties();
+      String manufacturer = map.get("ro.product.manufacturer");
+      String device = map.get("ro.product.device");
+      propertyMap.put("android.device", manufacturer + " " + device); // "Motorola sholes"
+
+      String brand = map.get("ro.product.brand");
+      String model = map.get("ro.product.model");
+      propertyMap.put("android.model", brand + " " + model); // "verizon Droid"
+
+      String release = map.get("ro.build.version.release");
+      String id = map.get("ro.build.id");
+      propertyMap.put("android.release", release + " " + id); // "Gingerbread GRH07B"
+    } catch (IOException ignored) {
+    }
+  }
+
+  private static String describe(Multimap<String, String> cpuInfo, String s) {
+    Collection<String> strings = cpuInfo.get(s);
+    // TODO redo the ImmutableMultiset.toString() call so we don't get square brackets
+    return (strings.size() == 1)
+        ? strings.iterator().next()
+        : ImmutableMultiset.copyOf(strings).toString();
+  }
+
+  /**
+   * Returns the key/value pairs from the specified properties-file like
+   * reader. Unlike standard Java properties files, {@code reader} is allowed
+   * to list the same property multiple times. Comments etc. are unsupported.
+   */
+  private static Multimap<String, String> propertiesFileToMultimap(Reader reader)
+      throws IOException {
+    ImmutableMultimap.Builder<String, String> result = ImmutableMultimap.builder();
+    BufferedReader in = new BufferedReader(reader);
+
+    String line;
+    while((line = in.readLine()) != null) {
+      String[] parts = line.split("\\s*\\:\\s*", 2);
+      if (parts.length == 2) {
+        result.put(parts[0], parts[1]);
+      }
+    }
+    in.close();
+
+    return result.build();
+  }
+
+  private static Multimap<String, String> propertiesFromLinuxFile(String file) {
+    try {
+      Process process = Runtime.getRuntime().exec(new String[]{"/bin/cat", file});
+      return propertiesFileToMultimap(
+          new InputStreamReader(process.getInputStream(), "ISO-8859-1"));
+    } catch (IOException e) {
+      return ImmutableMultimap.of();
+    }
+  }
+
+  public static void main(String[] args) {
+    Environment snapshot = new EnvironmentGetter().getEnvironmentSnapshot();
+    for (Map.Entry<String, String> entry : snapshot.getProperties().entrySet()) {
+      System.out.println(entry.getKey() + " " + entry.getValue());
+    }
+  }
+
+  /**
+   * Android properties are available from adb shell /system/bin/getprop. That
+   * program prints Android system properties in this format:
+   * [ro.product.model]: [Droid]
+   * [ro.product.brand]: [verizon]
+   */
+  private static Map<String, String> getAndroidProperties() throws IOException {
+    Map<String, String> result = new HashMap<String, String>();
+
+    Process process = Runtime.getRuntime().exec(new String[] {"/system/bin/getprop"});
+    BufferedReader reader = new BufferedReader(
+        new InputStreamReader(process.getInputStream(), "ISO-8859-1"));
+
+    Pattern pattern = Pattern.compile("\\[([^\\]]*)\\]: \\[([^\\]]*)\\]");
+    String line;
+    while ((line = reader.readLine()) != null) {
+      Matcher matcher = pattern.matcher(line);
+      if (matcher.matches()) {
+        result.put(matcher.group(1), matcher.group(2));
+      }
+    }
+    return result;
+  }
+}
diff --git a/caliper/src/main/java/com/google/caliper/InProcessRunner.java b/caliper/src/main/java/com/google/caliper/InProcessRunner.java
new file mode 100644
index 0000000..1ef4788
--- /dev/null
+++ b/caliper/src/main/java/com/google/caliper/InProcessRunner.java
@@ -0,0 +1,117 @@
+/*
+ * Copyright (C) 2010 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.caliper;
+
+import com.google.caliper.UserException.ExceptionFromUserCodeException;
+import com.google.common.base.Supplier;
+
+import java.io.OutputStream;
+import java.io.PrintStream;
+import java.util.List;
+
+/**
+ * Executes a benchmark in the current VM.
+ */
+final class InProcessRunner {
+
+  public void run(String... args) {
+    Arguments arguments = Arguments.parse(args);
+
+    ScenarioSelection scenarioSelection = new ScenarioSelection(arguments);
+
+    try {
+      Measurer measurer = getMeasurer(arguments);
+      List<Scenario> scenarios = scenarioSelection.select();
+      // We only expect one scenario right now - if we have more, something has gone wrong.
+      // This matters for things like reading the measurements. This is only done once, so if
+      // multiple scenarios are executed, they will be ignored!
+      if (scenarios.size() != 1) {
+        throw new IllegalArgumentException("Invalid arguments to subprocess. Expected exactly one "
+            + "scenario but got " + scenarios.size());
+      }
+      Scenario scenario = scenarios.get(0);
+
+      System.out.println("starting " + scenario);
+      MeasurementSet measurementSet = run(scenarioSelection, scenario, measurer);
+      System.out.println(arguments.getMarker() + Json.measurementSetToJson(measurementSet));
+    } catch (UserException e) {
+      throw e;
+    } catch (Exception e) {
+      throw new ExceptionFromUserCodeException(e);
+    }
+  }
+
+  public MeasurementSet run(final ScenarioSelection scenarioSelection, final Scenario scenario,
+      Measurer measurer) throws Exception {
+    Supplier<ConfiguredBenchmark> supplier = new Supplier<ConfiguredBenchmark>() {
+      @Override public ConfiguredBenchmark get() {
+        return scenarioSelection.createBenchmark(scenario);
+      }
+    };
+
+    PrintStream out = System.out;
+    PrintStream err = System.err;
+    measurer.setLogStream(out);
+    CountingPrintStream countedOut = new CountingPrintStream(out);
+    CountingPrintStream countedErr = new CountingPrintStream(err);
+    System.setOut(countedOut);
+    System.setErr(countedErr);
+    try {
+      MeasurementSet measurementSet = measurer.run(supplier);
+      if (measurementSet != null) {
+        measurementSet = measurementSet.plusCharCounts(
+            countedOut.getCount(), countedErr.getCount());
+      }
+      return measurementSet;
+    } finally {
+      System.setOut(out);
+      System.setErr(err);
+    }
+  }
+
+  private Measurer getMeasurer(Arguments arguments) {
+    if (arguments.getMeasurementType() == MeasurementType.TIME) {
+      return new TimeMeasurer(arguments.getWarmupMillis(), arguments.getRunMillis());
+    } else if (arguments.getMeasurementType() == MeasurementType.INSTANCE) {
+      return new InstancesAllocationMeasurer();
+    } else if (arguments.getMeasurementType() == MeasurementType.MEMORY) {
+      return new MemoryAllocationMeasurer();
+    } else if (arguments.getMeasurementType() == MeasurementType.DEBUG) {
+      return new DebugMeasurer(arguments.getDebugReps());
+    } else {
+      throw new IllegalArgumentException("unrecognized measurement type: "
+          + arguments.getMeasurementType());
+    }
+  }
+
+  public static void main(String... args) throws Exception {
+    try {
+      new InProcessRunner().run(args);
+      System.exit(0); // user code may have leave non-daemon threads behind!
+    } catch (UserException e) {
+      e.display(); // TODO: send this to the host process
+      System.out.println(LogConstants.CALIPER_LOG_PREFIX + LogConstants.SCENARIOS_FINISHED);
+      System.exit(1);
+    }
+  }
+
+  public PrintStream nullPrintStream() {
+    return new PrintStream(new OutputStream() {
+      public void write(int b) {}
+    });
+  }
+}
diff --git a/caliper/src/main/java/com/google/caliper/InstancesAllocationMeasurer.java b/caliper/src/main/java/com/google/caliper/InstancesAllocationMeasurer.java
new file mode 100644
index 0000000..3fe89c7
--- /dev/null
+++ b/caliper/src/main/java/com/google/caliper/InstancesAllocationMeasurer.java
@@ -0,0 +1,34 @@
+/*
+ * Copyright (C) 2010 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.caliper;
+
+public final class InstancesAllocationMeasurer extends AllocationMeasurer {
+
+  InstancesAllocationMeasurer() {
+    type = "instance";
+  }
+
+  @Override protected long incrementAllocationCount(long oldAllocationCount, int arrayCount,
+      long size) {
+    return oldAllocationCount + 1;
+  }
+
+  @Override protected Measurement getMeasurement(ConfiguredBenchmark benchmark, long allocations) {
+    return new Measurement(benchmark.instanceUnitNames(), allocations,
+        benchmark.instancesToUnits(allocations));
+  }
+}
diff --git a/caliper/src/main/java/com/google/caliper/Json.java b/caliper/src/main/java/com/google/caliper/Json.java
new file mode 100644
index 0000000..9e3f809
--- /dev/null
+++ b/caliper/src/main/java/com/google/caliper/Json.java
@@ -0,0 +1,226 @@
+/*
+ * Copyright (C) 2010 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.caliper;
+
+import com.google.common.collect.ImmutableMap;
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+import com.google.gson.JsonDeserializationContext;
+import com.google.gson.JsonDeserializer;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import com.google.gson.JsonParseException;
+import com.google.gson.JsonPrimitive;
+import com.google.gson.JsonSerializationContext;
+import com.google.gson.JsonSerializer;
+import com.google.gson.reflect.TypeToken;
+
+import java.lang.reflect.Type;
+import java.text.DateFormat;
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.TimeZone;
+
+/**
+ * Ordinarily serialization should be done within the class that is being serialized. However,
+ * many of these classes are used by GWT, which dies when it sees Gson.
+ */
+public final class Json {
+  /**
+   * This Gson instance must be used when serializing a class that includes a Run as a member
+   * or as a member of a member (etc.), otherwise the Map<Scenario, ScenarioResult> will not
+   * be correctly serialized.
+   */
+  private static final Gson GSON_INSTANCE =
+      new GsonBuilder()
+          .registerTypeAdapter(Date.class, new DateTypeAdapter())
+          .registerTypeAdapter(Run.class, new RunTypeAdapter())
+          .registerTypeAdapter(Measurement.class, new MeasurementDeserializer())
+          .create();
+
+  public static Gson getGsonInstance() {
+    return GSON_INSTANCE;
+  }
+
+  public static String measurementSetToJson(MeasurementSet measurementSet) {
+    return new Gson().toJson(measurementSet);
+  }
+
+  /**
+   * Attempts to extract a MeasurementSet from a string, assuming it is JSON. If this fails, it
+   * tries to extract it from the string assuming it is a space-separated list of double values.
+   */
+  public static MeasurementSet measurementSetFromJson(String measurementSetJson) {
+    try {
+      return getGsonInstance().fromJson(measurementSetJson, MeasurementSet.class);
+    } catch (JsonParseException e) {
+      // might be an old MeasurementSet, so fall back on failure to the old, space separated
+      // serialization method.
+      try {
+        String[] measurementStrings = measurementSetJson.split("\\s+");
+        List<Measurement> measurements = new ArrayList<Measurement>();
+        for (String s : measurementStrings) {
+          measurements.add(
+              new Measurement(ImmutableMap.of("ns", 1, "us", 1000, "ms", 1000000, "s", 1000000000),
+              Double.valueOf(s), Double.valueOf(s)));
+        }
+        // seconds and variations is the default unit
+        return new MeasurementSet(measurements.toArray(new Measurement[measurements.size()]));
+      } catch (NumberFormatException ignore) {
+        throw new IllegalArgumentException("Not a measurement set: " + measurementSetJson);
+      }
+    }
+  }
+
+  public static MeasurementSet measurementSetFromJson(JsonObject measurementSetJson) {
+    return getGsonInstance().fromJson(measurementSetJson, MeasurementSet.class);
+  }
+
+  /**
+   * Backwards compatibility!
+   */
+  private static class MeasurementDeserializer implements JsonDeserializer<Measurement> {
+    @Override public Measurement deserialize(JsonElement jsonElement, Type type,
+        JsonDeserializationContext context) throws JsonParseException {
+      JsonObject obj = jsonElement.getAsJsonObject();
+      if (obj.has("raw") && obj.has("processed")) {
+        return new Measurement(
+            context.<Map<String, Integer>>deserialize(obj.get("unitNames"),
+                new TypeToken<Map<String, Integer>>() {}.getType()),
+            context.<Double>deserialize(obj.get("raw"), Double.class),
+            context.<Double>deserialize(obj.get("processed"), Double.class));
+      }
+      if (obj.has("nanosPerRep") && obj.has("unitsPerRep") && obj.has("unitNames")) {
+        return new Measurement(
+            context.<Map<String, Integer>>deserialize(obj.get("unitNames"),
+                new TypeToken<Map<String, Integer>>() {}.getType()),
+            context.<Double>deserialize(obj.get("nanosPerRep"), Double.class),
+            context.<Double>deserialize(obj.get("unitsPerRep"), Double.class));
+      }
+      throw new JsonParseException(obj.toString());
+    }
+  }
+
+  /**
+   * This adapter is necessary because gson doesn't handle Maps more complex than Map<String, ...>
+   * in a useful way. For example, Map<Scenario, ScenarioResult>'s serialized version simply uses
+   * Scenario.toString() as the keys. This adapter stores this Map as lists of
+   * KeyValuePair<Scenario, ScenarioResult> instead, to preserve the Scenario objects on
+   * deserialization.
+   */
+  private static class RunTypeAdapter implements JsonSerializer<Run>, JsonDeserializer<Run> {
+
+    @Override public Run deserialize(JsonElement jsonElement, Type type,
+        JsonDeserializationContext context) throws JsonParseException {
+
+      List<KeyValuePair<Scenario, ScenarioResult>> mapList = context.deserialize(
+          jsonElement.getAsJsonObject().get("measurements"),
+          new TypeToken<List<KeyValuePair<Scenario, ScenarioResult>>>() {}.getType());
+      Map<Scenario, ScenarioResult> measurements = new LinkedHashMap<Scenario, ScenarioResult>();
+      for (KeyValuePair<Scenario, ScenarioResult> entry : mapList) {
+        measurements.put(entry.getKey(), entry.getValue());
+      }
+
+      String benchmarkName =
+          context.deserialize(jsonElement.getAsJsonObject().get("benchmarkName"), String.class);
+
+      Date executedTimestamp = context.deserialize(
+          jsonElement.getAsJsonObject().get("executedTimestamp"), Date.class);
+
+      return new Run(measurements, benchmarkName, executedTimestamp);
+    }
+
+    @Override public JsonElement serialize(Run run, Type type, JsonSerializationContext context) {
+      JsonObject result = new JsonObject();
+      result.add("benchmarkName", context.serialize(run.getBenchmarkName()));
+      result.add("executedTimestamp", context.serialize(run.getExecutedTimestamp()));
+
+      List<KeyValuePair<Scenario, ScenarioResult>> mapList =
+          new ArrayList<KeyValuePair<Scenario, ScenarioResult>>();
+      for (Map.Entry<Scenario, ScenarioResult> entry : run.getMeasurements().entrySet()) {
+        mapList.add(new KeyValuePair<Scenario, ScenarioResult>(entry.getKey(), entry.getValue()));
+      }
+      result.add("measurements", context.serialize(mapList,
+          new TypeToken<List<KeyValuePair<Scenario, ScenarioResult>>>() {}.getType()));
+
+      return result;
+    }
+  }
+
+  private static class DateTypeAdapter implements JsonSerializer<Date>, JsonDeserializer<Date> {
+    private final DateFormat dateFormat;
+
+    private DateTypeAdapter() {
+      dateFormat = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ssz", Locale.US);
+      dateFormat.setTimeZone(TimeZone.getTimeZone("UTC"));
+    }
+
+    @Override public synchronized JsonElement serialize(Date date, Type type,
+        JsonSerializationContext jsonSerializationContext) {
+      return new JsonPrimitive(dateFormat.format(date));
+    }
+
+    @Override public synchronized Date deserialize(JsonElement jsonElement, Type type,
+        JsonDeserializationContext jsonDeserializationContext) {
+      String dateString = jsonElement.getAsString();
+      // first try to parse as an ISO 8601 date
+      try {
+        return dateFormat.parse(dateString);
+      } catch (ParseException ignored) {
+      }
+      // next, try a GSON-style locale-specific dates (for Caliper r282 and earlier)
+      try {
+        return DateFormat.getDateTimeInstance().parse(dateString);
+      } catch (ParseException ignored) {
+      }
+      throw new JsonParseException(dateString);
+    }
+  }
+
+  /**
+   * This is similar to the Map.Entry class, but is necessary since Entrys are not supported
+   * by gson.
+   */
+  private static class KeyValuePair<K, V> {
+    private K k;
+    private V v;
+
+    KeyValuePair(K k, V v) {
+      this.k = k;
+      this.v = v;
+    }
+
+    public K getKey() {
+      return k;
+    }
+
+    public V getValue() {
+      return v;
+    }
+
+    @SuppressWarnings("unused")
+    private KeyValuePair() {} // for gson
+  }
+
+  private Json() {} // static class
+}
diff --git a/caliper/src/main/java/com/google/caliper/LogConstants.java b/caliper/src/main/java/com/google/caliper/LogConstants.java
new file mode 100644
index 0000000..09acebe
--- /dev/null
+++ b/caliper/src/main/java/com/google/caliper/LogConstants.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright (C) 2010 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.caliper;
+
+public final class LogConstants {
+  /**
+   * Must be prepended to line of XML that represents normalized scenario.
+   */
+  public static final String SCENARIO_JSON_PREFIX = "[scenario] ";
+  public static final String MEASUREMENT_JSON_PREFIX = "[measurement] ";
+
+  /**
+   * Must be prepended to any logs that are to be included in the run event log.
+   */
+  public static final String CALIPER_LOG_PREFIX = "[caliper] ";
+  public static final String SCENARIOS_STARTING = "[starting scenarios]";
+  public static final String STARTING_SCENARIO_PREFIX = "[starting scenario] ";
+  public static final String SCENARIO_FINISHED = "[scenario finished]";
+  public static final String SCENARIOS_FINISHED = "[scenarios finished]";
+
+  /**
+   * All events will be logged from when {@code MEASURED_SECTION_STARTING} is logged until
+   * {@code MEASURED_SECTION_DONE} is logged.
+   */
+  public static final String MEASURED_SECTION_STARTING = "[starting measured section]";
+  public static final String MEASURED_SECTION_DONE = "[done measured section]";
+
+  private LogConstants() {}
+}
diff --git a/caliper/src/main/java/com/google/caliper/Measurement.java b/caliper/src/main/java/com/google/caliper/Measurement.java
new file mode 100644
index 0000000..35865b6
--- /dev/null
+++ b/caliper/src/main/java/com/google/caliper/Measurement.java
@@ -0,0 +1,93 @@
+/*
+ * Copyright (C) 2010 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.caliper;
+
+import com.google.common.annotations.GwtCompatible;
+
+import java.io.Serializable;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Represents a measurement of a single run of a benchmark.
+ */
+@SuppressWarnings("serial")
+@GwtCompatible
+public final class Measurement
+  implements Serializable /* for GWT */ {
+
+  public static final Comparator<Measurement> SORT_BY_NANOS = new Comparator<Measurement>() {
+    @Override public int compare(Measurement a, Measurement b) {
+      double aNanos = a.getRaw();
+      double bNanos = b.getRaw();
+      return Double.compare(aNanos, bNanos);
+    }
+  };
+
+  public static final Comparator<Measurement> SORT_BY_UNITS = new Comparator<Measurement>() {
+    @Override public int compare(Measurement a, Measurement b) {
+      double aNanos = a.getProcessed();
+      double bNanos = b.getProcessed();
+      return Double.compare(aNanos, bNanos);
+    }
+  };
+
+  private /*final*/ double raw;
+  private /*final*/ double processed;
+  private /*final*/ Map<String, Integer> unitNames;
+
+  public Measurement(Map<String, Integer> unitNames, double raw, double processed) {
+    this.unitNames = new HashMap<String, Integer>(unitNames);
+    this.raw = raw;
+    this.processed = processed;
+  }
+
+  public Map<String, Integer> getUnitNames() {
+    return new HashMap<String, Integer>(unitNames);
+  }
+
+  public double getRaw() {
+    return raw;
+  }
+
+  public double getProcessed() {
+    return processed;
+  }
+
+  @Override public boolean equals(Object o) {
+    return o instanceof Measurement
+        && ((Measurement) o).raw == raw
+        && ((Measurement) o).processed == processed
+        && ((Measurement) o).unitNames.equals(unitNames);
+  }
+
+  @Override public int hashCode() {
+    return (int) raw // Double.doubleToLongBits doesn't exist on GWT
+        + (int) processed * 37
+        + unitNames.hashCode() * 1373;
+  }
+
+  @Override public String toString() {
+    return (raw != processed
+        ? raw + "/" + processed
+        : Double.toString(raw));
+  }
+
+  @SuppressWarnings("unused")
+  private Measurement() {} /* for GWT */
+}
diff --git a/caliper/src/main/java/com/google/caliper/MeasurementSet.java b/caliper/src/main/java/com/google/caliper/MeasurementSet.java
new file mode 100644
index 0000000..eb0b42a
--- /dev/null
+++ b/caliper/src/main/java/com/google/caliper/MeasurementSet.java
@@ -0,0 +1,264 @@
+/*
+ * Copyright (C) 2010 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.caliper;
+
+import com.google.common.annotations.GwtCompatible;
+
+import java.io.Serializable;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * A collection of measurements of the same scenario.
+ */
+@SuppressWarnings("serial")
+@GwtCompatible
+public final class MeasurementSet
+    implements Serializable /* for GWT Serialization */ {
+
+  private /*final*/ List<Measurement> measurements;
+  /**
+   * Mapping of user-defined units to relative sizes.
+   */
+  private /*final*/ Map<String, Integer> unitNames;
+
+  private /*final*/ int systemOutCharCount;
+  private /*final*/ int systemErrCharCount;
+
+  public MeasurementSet(Measurement... measurements) {
+    this(0, 0, getUnitNamesFromMeasurements(measurements), Arrays.asList(measurements));
+  }
+
+  private static Map<String, Integer> getUnitNamesFromMeasurements(Measurement... measurements) {
+    Map<String, Integer> unitNameToAssign = null;
+    for (Measurement measurement : measurements) {
+      if (unitNameToAssign == null) {
+        unitNameToAssign = new HashMap<String, Integer>(measurement.getUnitNames());
+      } else if (!unitNameToAssign.equals(measurement.getUnitNames())) {
+        throw new IllegalArgumentException("incompatible unit names: " + unitNameToAssign + " and "
+            + measurement.getUnitNames());
+      }
+    }
+    return unitNameToAssign;
+  }
+
+  /**
+   * Constructor to use directly from plusMeasurement. Skips some excessive checking and takes a
+   * list directly.
+   */
+  private MeasurementSet(int systemOutCharCount, int systemErrCharCount,
+      Map<String, Integer> unitNames, List<Measurement> measurements) {
+    this.systemOutCharCount = systemOutCharCount;
+    this.systemErrCharCount = systemErrCharCount;
+    this.unitNames = unitNames;
+    this.measurements = measurements;
+  }
+
+  /**
+   * This is the same as getUnitNames(), but is for backwards compatibility on the server
+   * when null pointer exceptions need to be avoided.
+   */
+  public Map<String, Integer> getUnitNames(Map<String, Integer> defaultValue) {
+    if (unitNames == null) {
+      return defaultValue;
+    }
+    return new HashMap<String, Integer>(unitNames);
+  }
+
+  public Map<String, Integer> getUnitNames() {
+    return new HashMap<String, Integer>(unitNames);
+  }
+
+  public List<Measurement> getMeasurements() {
+    return new ArrayList<Measurement>(measurements);
+  }
+
+  public int size() {
+    return measurements.size();
+  }
+
+  public int getSystemOutCharCount() {
+    return systemOutCharCount;
+  }
+
+  public int getSystemErrCharCount() {
+    return systemErrCharCount;
+  }
+
+  public List<Double> getMeasurementsRaw() {
+    List<Double> measurementRaw = new ArrayList<Double>();
+    for (Measurement measurement : measurements) {
+      measurementRaw.add(measurement.getRaw());
+    }
+    return measurementRaw;
+  }
+
+  public List<Double> getMeasurementUnits() {
+    List<Double> measurementUnits = new ArrayList<Double>();
+    for (Measurement measurement : measurements) {
+      measurementUnits.add(measurement.getProcessed());
+    }
+    return measurementUnits;
+  }
+
+  /**
+   * Returns the median measurement, with respect to raw units.
+   */
+  public double medianRaw() {
+    return median(getMeasurementsRaw());
+  }
+
+  /**
+   * Returns the median measurement, with respect to user-defined units.
+   */
+  public double medianUnits() {
+    return median(getMeasurementUnits());
+  }
+
+  private double median(List<Double> doubles) {
+    Collections.sort(doubles);
+    int n = doubles.size();
+    return (n % 2 == 0)
+        ? (doubles.get(n / 2 - 1) + doubles.get(n / 2)) / 2
+        : doubles.get(n / 2);
+  }
+
+  /**
+   * Returns the average measurement with respect to raw units.
+   */
+  public double meanRaw() {
+    return mean(getMeasurementsRaw());
+  }
+
+  /**
+   * Returns the average measurement with respect to user-defined units.
+   */
+  public double meanUnits() {
+    return mean(getMeasurementUnits());
+  }
+
+  private double mean(List<Double> doubles) {
+    double sum = 0;
+    for (double d : doubles) {
+      sum += d;
+    }
+    return sum / doubles.size();
+  }
+
+  public double standardDeviationRaw() {
+    return standardDeviation(getMeasurementsRaw());
+  }
+
+  public double standardDeviationUnits() {
+    return standardDeviation(getMeasurementUnits());
+  }
+
+  /**
+   * Returns the standard deviation of the measurements.
+   */
+  private double standardDeviation(List<Double> doubles) {
+    double mean = mean(doubles);
+    double sumOfSquares = 0;
+    for (double d : doubles) {
+      double delta = (d - mean);
+      sumOfSquares += (delta * delta);
+    }
+    return Math.sqrt(sumOfSquares / (doubles.size() - 1));
+  }
+
+  public double minRaw() {
+    return min(getMeasurementsRaw());
+  }
+
+  public double minUnits() {
+    return min(getMeasurementUnits());
+  }
+
+  /**
+   * Returns the minimum measurement.
+   */
+  private double min(List<Double> doubles) {
+    Collections.sort(doubles);
+    return doubles.get(0);
+  }
+
+  public double maxRaw() {
+    return max(getMeasurementsRaw());
+  }
+
+  public double maxUnits() {
+    return max(getMeasurementUnits());
+  }
+
+  /**
+   * Returns the maximum measurement.
+   */
+  private double max(List<Double> doubles) {
+    Collections.sort(doubles, Collections.reverseOrder());
+    return doubles.get(0);
+  }
+
+  /**
+   * Returns a new measurement set that contains the measurements in this set
+   * plus the given additional measurement.
+   */
+  public MeasurementSet plusMeasurement(Measurement measurement) {
+    // verify that this Measurement is compatible with this MeasurementSet
+    if (unitNames != null && !unitNames.equals(measurement.getUnitNames())) {
+      throw new IllegalArgumentException("new measurement incompatible with units of measurement "
+          + "set. Expected " + unitNames + " but got " + measurement.getUnitNames());
+    }
+
+    List<Measurement> resultMeasurements = new ArrayList<Measurement>(measurements);
+    resultMeasurements.add(measurement);
+    Map<String, Integer> newUnitNames = unitNames == null ? measurement.getUnitNames() : unitNames;
+    return new MeasurementSet(systemOutCharCount, systemErrCharCount,
+        newUnitNames, resultMeasurements);
+  }
+
+  public MeasurementSet plusCharCounts(int systemOutCharCount, int systemErrCharCount) {
+    return new MeasurementSet(this.systemOutCharCount + systemOutCharCount,
+        this.systemErrCharCount + systemErrCharCount, unitNames, measurements);
+  }
+
+  @Override public boolean equals(Object o) {
+    return o instanceof MeasurementSet
+        && ((MeasurementSet) o).measurements.equals(measurements)
+        && ((MeasurementSet) o).unitNames.equals(unitNames)
+        && ((MeasurementSet) o).systemOutCharCount == systemOutCharCount
+        && ((MeasurementSet) o).systemErrCharCount == systemErrCharCount;
+  }
+
+  @Override public int hashCode() {
+    return measurements.hashCode()
+        + unitNames.hashCode() * 37
+        + systemOutCharCount * 1373
+        + systemErrCharCount * 53549;
+  }
+
+  @Override public String toString() {
+    return measurements.toString() + " " + unitNames + " "
+        + systemOutCharCount + "/" + systemErrCharCount;
+  }
+
+  @SuppressWarnings("unused")
+  private MeasurementSet() {} // for GWT Serialization
+}
diff --git a/caliper/src/main/java/com/google/caliper/MeasurementType.java b/caliper/src/main/java/com/google/caliper/MeasurementType.java
new file mode 100644
index 0000000..30de69f
--- /dev/null
+++ b/caliper/src/main/java/com/google/caliper/MeasurementType.java
@@ -0,0 +1,24 @@
+/*
+ * Copyright (C) 2010 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.caliper;
+
+import com.google.common.annotations.GwtCompatible;
+
+@GwtCompatible
+public enum MeasurementType {
+  TIME, INSTANCE, MEMORY, DEBUG
+}
diff --git a/caliper/src/main/java/com/google/caliper/Measurer.java b/caliper/src/main/java/com/google/caliper/Measurer.java
new file mode 100644
index 0000000..93002e6
--- /dev/null
+++ b/caliper/src/main/java/com/google/caliper/Measurer.java
@@ -0,0 +1,44 @@
+/*
+ * Copyright (C) 2010 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.caliper;
+
+import com.google.common.base.Supplier;
+
+import java.io.PrintStream;
+
+abstract class Measurer {
+
+  private PrintStream logStream = System.out;
+
+  /**
+   * Sets the stream used to log caliper events.
+   */
+  void setLogStream(PrintStream logStream) {
+    this.logStream = logStream;
+  }
+
+  public abstract MeasurementSet run(Supplier<ConfiguredBenchmark> testSupplier) throws Exception;
+
+  protected void prepareForTest() {
+    System.gc();
+    System.gc();
+  }
+
+  protected final void log(String message) {
+    logStream.println(LogConstants.CALIPER_LOG_PREFIX + message);
+  }
+}
diff --git a/caliper/src/main/java/com/google/caliper/MemoryAllocationMeasurer.java b/caliper/src/main/java/com/google/caliper/MemoryAllocationMeasurer.java
new file mode 100644
index 0000000..a28aabf
--- /dev/null
+++ b/caliper/src/main/java/com/google/caliper/MemoryAllocationMeasurer.java
@@ -0,0 +1,34 @@
+/*
+ * Copyright (C) 2010 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.caliper;
+
+public final class MemoryAllocationMeasurer extends AllocationMeasurer {
+
+  public MemoryAllocationMeasurer() {
+    type = "byte";
+  }
+
+  @Override protected long incrementAllocationCount(long oldAllocationCount, int arrayCount,
+      long size) {
+    return oldAllocationCount + size;
+  }
+
+  @Override protected Measurement getMeasurement(ConfiguredBenchmark benchmark, long allocations) {
+    return new Measurement(benchmark.memoryUnitNames(), allocations,
+        benchmark.bytesToUnits(allocations));
+  }
+}
diff --git a/caliper/src/main/java/com/google/caliper/Param.java b/caliper/src/main/java/com/google/caliper/Param.java
new file mode 100644
index 0000000..f4cdf45
--- /dev/null
+++ b/caliper/src/main/java/com/google/caliper/Param.java
@@ -0,0 +1,61 @@
+/*
+ * Copyright (C) 2009 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.caliper;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * To make your benchmark depend on a parameterized value, create a field with the name you want
+ * this parameter to be known by, and add this annotation. Caliper will inject a value for this
+ * field to each instance it creates. These values come from
+ *
+ * <ul>
+ * <li>The command line, if specified using {@code -Dname=value1,value2,value3}
+ * <li>Otherwise, the {@link #value()} list given in the annotation
+ * <li>Otherwise, Caliper looks for a static method named {@code paramName + "Values"} (for
+ *     example, if the parameter field is {@code size}, it looks for {@code sizeValues()}). The
+ *     method can return any subtype of {@link Iterable}. The contents of that iterable are used as
+ *     the parameter values.
+ * <li>Otherwise, Caliper repeats the previous check looking for a static <em>field</em> instead
+ *     of a method.
+ * <li>Otherwise, if the parameter type is either {@code boolean} or an {@code enum} type, Caliper
+ *     assumes you want all possible values.
+ * <li>Finally, if none of the above match, Caliper will display an error and exit.
+ * </ul>
+ *
+ * <p>Caliper parameters are always strings, but can be converted to other types at the point of
+ * injection. If the type of the field this annotation is applied to is not {@link String}, then the
+ * type class must contain a static {@code fromString(String)}, {@code decode(String)} or {@code
+ * valueOf(String)} method that returns that type, or a constructor accepting only a {@code String}.
+ *
+ * <p>Caliper will test every possible combination of parameter values for your benchmark. For
+ * example, if you have two parameters, {@code -Dletter=a,b,c -Dnumber=1,2}, Caliper will construct
+ * six independent "scenarios" and perform measurement for each one. 
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.FIELD)
+public @interface Param {
+  /**
+   * One or more default values, as strings, that this parameter should be given if none are
+   * specified on the command line. If values are specified on the command line, the defaults given
+   * here are all ignored.
+   */
+  String[] value() default {};
+}
diff --git a/caliper/src/main/java/com/google/caliper/Parameter.java b/caliper/src/main/java/com/google/caliper/Parameter.java
new file mode 100644
index 0000000..c79bc86
--- /dev/null
+++ b/caliper/src/main/java/com/google/caliper/Parameter.java
@@ -0,0 +1,202 @@
+/*
+ * Copyright (C) 2009 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.caliper;
+
+import com.google.common.annotations.VisibleForTesting;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Member;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.EnumSet;
+import java.util.Map;
+import java.util.Set;
+import java.util.TreeMap;
+
+/**
+ * A parameter in a {@link SimpleBenchmark}.
+ *
+ * @param <T> the (possibly wrapped) type of the parameter field, such as {@link
+ *     String} or {@link Integer}
+ */
+abstract class Parameter<T> {
+
+  private final Field field;
+
+  private Parameter(Field field) {
+    this.field = field;
+  }
+
+  /**
+   * Returns all parameters for the given class.
+   */
+  public static Map<String, Parameter<?>> forClass(Class<? extends Benchmark> suiteClass) {
+    Map<String, Parameter<?>> parameters = new TreeMap<String, Parameter<?>>();
+    for (Field field : suiteClass.getDeclaredFields()) {
+      if (field.isAnnotationPresent(Param.class)) {
+        field.setAccessible(true);
+        Parameter<?> parameter = forField(suiteClass, field);
+        parameters.put(parameter.getName(), parameter);
+      }
+    }
+    return parameters;
+  }
+
+  @VisibleForTesting
+  static Parameter<?> forField(
+      Class<? extends Benchmark> suiteClass, final Field field) {
+    // First check for String values on the annotation itself
+    final Object[] defaults = field.getAnnotation(Param.class).value();
+    if (defaults.length > 0) {
+      return new Parameter<Object>(field) {
+        @Override public Iterable<Object> values() throws Exception {
+          return Arrays.asList(defaults);
+        }
+      };
+      // TODO: or should we continue so we can give an error/warning if params are also give in a
+      // method or field?
+    }
+
+    Parameter<?> result = null;
+    Type returnType = null;
+    Member member = null;
+
+    // Now check for a fooValues() method
+    try {
+      final Method valuesMethod = suiteClass.getDeclaredMethod(field.getName() + "Values");
+      if (!Modifier.isStatic(valuesMethod.getModifiers())) {
+        throw new ConfigurationException("Values method must be static " + member);
+      }
+      valuesMethod.setAccessible(true);
+      member = valuesMethod;
+      returnType = valuesMethod.getGenericReturnType();
+      result = new Parameter<Object>(field) {
+        @SuppressWarnings("unchecked") // guarded below
+        @Override public Iterable<Object> values() throws Exception {
+          return (Iterable<Object>) valuesMethod.invoke(null);
+        }
+      };
+    } catch (NoSuchMethodException ignored) {
+    }
+
+    // Now check for a fooValues field
+    try {
+      final Field valuesField = suiteClass.getDeclaredField(field.getName() + "Values");
+      if (!Modifier.isStatic(valuesField.getModifiers())) {
+        throw new ConfigurationException("Values field must be static " + member);
+      }
+      valuesField.setAccessible(true);
+      member = valuesField;
+      if (result != null) {
+        throw new ConfigurationException("Two values members defined for " + field);
+      }
+      returnType = valuesField.getGenericType();
+      result = new Parameter<Object>(field) {
+        @SuppressWarnings("unchecked") // guarded below
+        @Override public Iterable<Object> values() throws Exception {
+          return (Iterable<Object>) valuesField.get(null);
+        }
+      };
+    } catch (NoSuchFieldException ignored) {
+    }
+
+    // If there isn't a values member but the parameter is an enum, we default
+    // to EnumSet.allOf.
+    if (member == null && field.getType().isEnum()) {
+      returnType = Collection.class;
+      result = new Parameter<Object>(field) {
+        // TODO: figure out the simplest way to make this compile and be green in IDEA too
+        @SuppressWarnings({"unchecked", "RawUseOfParameterizedType", "RedundantCast"})
+        // guarded above
+        @Override public Iterable<Object> values() throws Exception {
+          Set<Enum> set = EnumSet.allOf((Class<Enum>) field.getType());
+          return Collections.<Object>unmodifiableSet(set);
+        }
+      };
+    }
+
+    // If it's boolean, default to (true, false)
+    if (member == null && field.getType() == boolean.class) {
+      returnType = Collection.class;
+      result = new Parameter<Object>(field) {
+        @Override public Iterable<Object> values() throws Exception {
+          return Arrays.<Object>asList(Boolean.TRUE, Boolean.FALSE);
+        }
+      };
+    }
+
+    if (result == null) {
+      return new Parameter<Object>(field) {
+        @Override public Iterable<Object> values() {
+          // TODO: need tests to make sure this fails properly when no cmdline params given and
+          // works properly when they are given. Also, can we restructure the code so that we
+          // just throw here instead of later?
+          return Collections.emptySet();
+        }
+      };
+    } else if (!isValidReturnType(returnType)) {
+      throw new ConfigurationException("Invalid return type " + returnType
+          + " for values member " + member + "; must be Collection");
+    }
+    return result;
+  }
+
+  private static boolean isValidReturnType(Type type) {
+    if (type instanceof Class) {
+      return isIterableClass(type);
+    }
+    if (type instanceof ParameterizedType) {
+      return isIterableClass(((ParameterizedType) type).getRawType());
+    }
+    return false;
+  }
+
+  private static boolean isIterableClass(Type returnClass) {
+    return Iterable.class.isAssignableFrom((Class<?>) returnClass);
+  }
+
+  /**
+   * Sets the value of this property to the specified value for the given suite.
+   */
+  public void set(Benchmark suite, Object value) throws Exception {
+    field.set(suite, value);
+  }
+
+  /**
+   * Returns the available values of the property as specified by the suite.
+   */
+  public abstract Iterable<T> values() throws Exception;
+
+  /**
+   * Returns the parameter's type, such as double.class.
+   */
+  public Type getType() {
+    return field.getGenericType();
+  }
+
+  /**
+   * Returns the field's name.
+   */
+  String getName() {
+    return field.getName();
+  }
+}
diff --git a/caliper/src/main/java/com/google/caliper/Result.java b/caliper/src/main/java/com/google/caliper/Result.java
new file mode 100644
index 0000000..c57f5a3
--- /dev/null
+++ b/caliper/src/main/java/com/google/caliper/Result.java
@@ -0,0 +1,56 @@
+/*
+ * Copyright (C) 2010 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.caliper;
+
+/**
+ * Represents an invocation of a benchmark, including the run itself, as well as the environment
+ * in which the run occurred.
+ */
+public final class Result {
+  private /*final*/ Run run;
+  private /*final*/ Environment environment;
+
+  public Result(Run run, Environment environment) {
+    this.run = run;
+    this.environment = environment;
+  }
+
+  public Run getRun() {
+    return run;
+  }
+
+  public Environment getEnvironment() {
+    return environment;
+  }
+
+  @Override public boolean equals(Object o) {
+    return o instanceof Result
+        && ((Result) o).run.equals(run)
+        && ((Result) o).environment.equals(environment);
+  }
+
+  @Override public int hashCode() {
+    return run.hashCode() * 37 + environment.hashCode();
+  }
+
+  @Override public String toString() {
+    return run + "@" + environment;
+  }
+
+  @SuppressWarnings("unused")
+  private Result() {} // for gson
+}
diff --git a/caliper/src/main/java/com/google/caliper/ResultsReader.java b/caliper/src/main/java/com/google/caliper/ResultsReader.java
new file mode 100644
index 0000000..2396dd3
--- /dev/null
+++ b/caliper/src/main/java/com/google/caliper/ResultsReader.java
@@ -0,0 +1,64 @@
+/*
+ * Copyright (C) 2010 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.caliper;
+
+import com.google.gson.JsonParseException;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+
+/**
+ * Helps with deserialization of results, given uncertainty about the format (xml or json) they
+ * are in.
+ */
+public final class ResultsReader {
+  public Result getResult(InputStream in) throws IOException {
+    // save input into a byte array since we may need to read it twice
+    byte[] postedData = readAllBytes(in);
+    Result result;
+    InputStreamReader baisJsonReader = new InputStreamReader(new ByteArrayInputStream(postedData));
+    try {
+      result = Json.getGsonInstance().fromJson(baisJsonReader, Result.class);
+    } catch (JsonParseException e) {
+      // probably an old client is trying to send data, so try to parse it as XML instead.
+      ByteArrayInputStream baisXml = new ByteArrayInputStream(postedData);
+      try {
+        result = Xml.resultFromXml(baisXml);
+      } catch (Exception e2) {
+        throw new RuntimeException(e);
+      } finally {
+        baisXml.close();
+      }
+    } finally {
+      baisJsonReader.close();
+    }
+    return result;
+  }
+
+  private byte[] readAllBytes(InputStream in) throws IOException {
+    ByteArrayOutputStream baos = new ByteArrayOutputStream();
+    byte[] buf = new byte[4096];
+    int read;
+    while ((read = in.read(buf)) != -1) {
+      baos.write(buf, 0, read);
+    }
+    return baos.toByteArray();
+  }
+}
diff --git a/caliper/src/main/java/com/google/caliper/Run.java b/caliper/src/main/java/com/google/caliper/Run.java
new file mode 100644
index 0000000..00f9350
--- /dev/null
+++ b/caliper/src/main/java/com/google/caliper/Run.java
@@ -0,0 +1,93 @@
+/**
+ * Copyright (C) 2009 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.caliper;
+
+import com.google.common.annotations.GwtCompatible;
+
+import java.io.Serializable;
+import java.util.Date;
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+/**
+ * The complete result of a benchmark suite run.
+ *
+ * WARNING: a JSON representation of this class is stored on the app engine server. If any changes
+ * are made to this class, a deserialization adapter must be written for this class to ensure
+ * backwards compatibility.
+ *
+ * <p>Gwt-safe.
+ */
+@SuppressWarnings("serial")
+@GwtCompatible
+public final class Run
+    implements Serializable /* for GWT Serialization */ {
+
+  private /*final*/ Map<Scenario, ScenarioResult> measurements;
+  private /*final*/ String benchmarkName;
+  private /*final*/ long executedTimestamp;
+
+  // TODO: add more run properties such as checksums of the executed code
+
+  public Run(Map<Scenario, ScenarioResult> measurements,
+      String benchmarkName, Date executedTimestamp) {
+    if (benchmarkName == null || executedTimestamp == null) {
+      throw new NullPointerException();
+    }
+
+    this.measurements = new LinkedHashMap<Scenario, ScenarioResult>(measurements);
+    this.benchmarkName = benchmarkName;
+    this.executedTimestamp = executedTimestamp.getTime();
+  }
+
+  public Map<Scenario, ScenarioResult> getMeasurements() {
+    return measurements;
+  }
+
+  public String getBenchmarkName() {
+    return benchmarkName;
+  }
+
+  public Date getExecutedTimestamp() {
+    return new Date(executedTimestamp);
+  }
+
+  @Override public boolean equals(Object o) {
+    if (o instanceof Run) {
+      Run that = (Run) o;
+      return measurements.equals(that.measurements)
+          && benchmarkName.equals(that.benchmarkName)
+          && executedTimestamp == that.executedTimestamp;
+    }
+
+    return false;
+  }
+
+  @Override public int hashCode() {
+    int result = measurements.hashCode();
+    result = result * 37 + benchmarkName.hashCode();
+    result = result * 37 + (int) ((executedTimestamp >> 32) ^ executedTimestamp);
+    return result;
+  }
+
+  @Override public String toString() {
+    return measurements.toString();
+  }
+
+  @SuppressWarnings("unused")
+  private Run() {} // for GWT Serialization
+}
diff --git a/caliper/src/main/java/com/google/caliper/Runner.java b/caliper/src/main/java/com/google/caliper/Runner.java
new file mode 100644
index 0000000..57715c9
--- /dev/null
+++ b/caliper/src/main/java/com/google/caliper/Runner.java
@@ -0,0 +1,438 @@
+/*
+ * Copyright (C) 2009 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.caliper;
+
+import com.google.caliper.UserException.DisplayUsageException;
+import com.google.caliper.UserException.ExceptionFromUserCodeException;
+import com.google.caliper.util.InterleavedReader;
+import com.google.common.base.Joiner;
+import com.google.common.base.Splitter;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ObjectArrays;
+import com.google.common.io.Closeables;
+import com.google.gson.JsonObject;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileFilter;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.PrintStream;
+import java.net.HttpURLConnection;
+import java.net.InetSocketAddress;
+import java.net.Proxy;
+import java.net.URL;
+import java.text.SimpleDateFormat;
+import java.util.Date;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.TimeZone;
+import java.util.regex.Pattern;
+
+/**
+ * Creates, executes and reports benchmark runs.
+ */
+public final class Runner {
+
+  private static final FileFilter UPLOAD_FILE_FILTER = new FileFilter() {
+    @Override public boolean accept(File file) {
+      return file.getName().endsWith(".xml") || file.getName().endsWith(".json");
+    }
+  };
+
+  private static final String FILE_NAME_DATE_FORMAT = "yyyy-MM-dd'T'HH-mm-ssZ";
+
+  private static final Splitter ARGUMENT_SPLITTER
+      = Splitter.on(Pattern.compile("\\s+")).omitEmptyStrings();
+
+  /** Command line arguments to the process */
+  private Arguments arguments;
+  private ScenarioSelection scenarioSelection;
+
+  private String createFileName(Result result) {
+    String timestamp = createTimestamp();
+    return String.format("%s.%s.json", result.getRun().getBenchmarkName(), timestamp);
+  }
+
+  private String createTimestamp() {
+    SimpleDateFormat dateFormat = new SimpleDateFormat(FILE_NAME_DATE_FORMAT, Locale.US);
+    dateFormat.setTimeZone(TimeZone.getTimeZone("UTC"));
+    dateFormat.setLenient(true);
+    return dateFormat.format(new Date());
+  }
+
+  public void run(String... args) {
+    this.arguments = Arguments.parse(args);
+    File resultsUploadFile = arguments.getUploadResultsFile();
+    if (resultsUploadFile != null) {
+      uploadResultsFileOrDir(resultsUploadFile);
+      return;
+    }
+    this.scenarioSelection = new ScenarioSelection(arguments);
+    if (arguments.getDebug()) {
+      debug();
+      return;
+    }
+    Result result = runOutOfProcess();
+    new ConsoleReport(result.getRun(), arguments).displayResults();
+    boolean saveResultsLocally = arguments.getSaveResultsFile() != null;
+    try {
+      postResults(result);
+    } catch (Exception e) {
+      System.out.println();
+      System.out.println(e);
+      saveResultsLocally = true;
+    }
+
+    if (saveResultsLocally) {
+      saveResults(result);
+    }
+  }
+
+  void uploadResultsFileOrDir(File resultsFileOrDir) {
+    try {
+      if (resultsFileOrDir.isDirectory()) {
+        for (File resultsFile : resultsFileOrDir.listFiles(UPLOAD_FILE_FILTER)) {
+          uploadResults(resultsFile);
+        }
+      } else {
+        uploadResults(resultsFileOrDir);
+      }
+    } catch (Exception e) {
+      throw new RuntimeException("uploading XML file failed", e);
+    }
+  }
+
+  private void uploadResults(File resultsUploadFile) throws IOException {
+    System.out.println();
+    System.out.println("Uploading " + resultsUploadFile.getCanonicalPath());
+    InputStream inputStream = new FileInputStream(resultsUploadFile);
+    try {
+      Result result = new ResultsReader().getResult(inputStream);
+      postResults(result);
+    } finally {
+      inputStream.close();
+    }
+  }
+
+  private void saveResults(Result result) {
+    File resultsFile = arguments.getSaveResultsFile();
+    File destinationFile;
+    if (resultsFile == null) {
+      File dir = new File("./caliper-results");
+      dir.mkdirs();
+      destinationFile = new File(dir, createFileName(result));
+    } else if (resultsFile.exists() && resultsFile.isDirectory()) {
+      destinationFile = new File(resultsFile, createFileName(result));
+    } else {
+      // assume this is a file
+      File parent = resultsFile.getParentFile();
+      if (parent != null) {
+        parent.mkdirs();
+      }
+      destinationFile = resultsFile;
+    }
+
+    PrintStream filePrintStream;
+    try {
+      filePrintStream = new PrintStream(new FileOutputStream(destinationFile));
+    } catch (FileNotFoundException e) {
+      throw new RuntimeException("can't open " + destinationFile, e);
+    }
+    String resultJson = Json.getGsonInstance().toJson(result);
+    try {
+      System.out.println();
+      System.out.println("Writing results to " + destinationFile.getCanonicalPath());
+      filePrintStream.print(resultJson);
+    } catch (Exception e) {
+      System.out.println(e);
+      System.out.println("Failed to write results to file, writing to standard out instead:");
+      System.out.println(resultJson);
+      System.out.flush();
+    } finally {
+      filePrintStream.close();
+    }
+  }
+
+  private void postResults(Result result) {
+    CaliperRc caliperrc = CaliperRc.INSTANCE;
+    String postUrl = caliperrc.getPostUrl();
+    String apiKey = caliperrc.getApiKey();
+    if (postUrl == null || apiKey == null) {
+      // TODO: probably nicer to show a message if only one is null
+      return;
+    }
+
+    try {
+      URL url = new URL(postUrl + apiKey + "/" + result.getRun().getBenchmarkName());
+      HttpURLConnection urlConnection = (HttpURLConnection) url.openConnection(getProxy());
+      urlConnection.setDoOutput(true);
+      String resultJson = Json.getGsonInstance().toJson(result);
+      urlConnection.getOutputStream().write(resultJson.getBytes());
+      if (urlConnection.getResponseCode() == 200) {
+        System.out.println("");
+        System.out.println("View current and previous benchmark results online:");
+        BufferedReader in = new BufferedReader(
+            new InputStreamReader(urlConnection.getInputStream()));
+        System.out.println("  " + in.readLine());
+        in.close();
+        return;
+      }
+
+      System.out.println("Posting to " + postUrl + " failed: "
+          + urlConnection.getResponseMessage());
+      BufferedReader reader = new BufferedReader(
+          new InputStreamReader(urlConnection.getInputStream()));
+      String line;
+      while ((line = reader.readLine()) != null) {
+        System.out.println(line);
+      }
+      reader.close();
+    } catch (IOException e) {
+      throw new RuntimeException("Posting to " + postUrl + " failed.", e);
+    }
+  }
+
+  private Proxy getProxy() {
+    String proxyAddress = CaliperRc.INSTANCE.getProxy();
+    if (proxyAddress == null) {
+      return Proxy.NO_PROXY;
+    }
+
+    String[] proxyHostAndPort = proxyAddress.trim().split(":");
+    return new Proxy(Proxy.Type.HTTP, new InetSocketAddress(
+        proxyHostAndPort[0], Integer.parseInt(proxyHostAndPort[1])));
+  }
+
+  private ScenarioResult runScenario(Scenario scenario) {
+    MeasurementResult timeMeasurementResult = measure(scenario, MeasurementType.TIME);
+    MeasurementSet allocationMeasurements = null;
+    String allocationEventLog = null;
+    MeasurementSet memoryMeasurements = null;
+    String memoryEventLog = null;
+    if (arguments.getMeasureMemory()) {
+      MeasurementResult allocationsMeasurementResult =
+          measure(scenario, MeasurementType.INSTANCE);
+      allocationMeasurements = allocationsMeasurementResult.getMeasurements();
+      allocationEventLog = allocationsMeasurementResult.getEventLog();
+      MeasurementResult memoryMeasurementResult =
+          measure(scenario, MeasurementType.MEMORY);
+      memoryMeasurements = memoryMeasurementResult.getMeasurements();
+      memoryEventLog = memoryMeasurementResult.getEventLog();
+    }
+
+    return new ScenarioResult(timeMeasurementResult.getMeasurements(),
+        timeMeasurementResult.getEventLog(),
+        allocationMeasurements, allocationEventLog,
+        memoryMeasurements, memoryEventLog);
+  }
+
+  private static class MeasurementResult {
+    private final MeasurementSet measurements;
+    private final String eventLog;
+
+    MeasurementResult(MeasurementSet measurements, String eventLog) {
+      this.measurements = measurements;
+      this.eventLog = eventLog;
+    }
+
+    public MeasurementSet getMeasurements() {
+      return measurements;
+    }
+
+    public String getEventLog() {
+      return eventLog;
+    }
+  }
+
+  private MeasurementResult measure(Scenario scenario, MeasurementType type) {
+    Vm vm = new VmFactory().createVm(scenario);
+    // this must be done before starting the forked process on certain VMs
+    ProcessBuilder processBuilder = createCommand(scenario, vm, type)
+        .redirectErrorStream(true);
+    Process timeProcess;
+    try {
+      timeProcess = processBuilder.start();
+    } catch (IOException e) {
+      throw new RuntimeException("failed to start subprocess", e);
+    }
+
+    MeasurementSet measurementSet = null;
+    StringBuilder eventLog = new StringBuilder();
+    InterleavedReader reader = null;
+    try {
+      reader = new InterleavedReader(arguments.getMarker(),
+          new InputStreamReader(timeProcess.getInputStream()));
+      Object o;
+      while ((o = reader.read()) != null) {
+        if (o instanceof String) {
+          eventLog.append(o);
+        } else if (measurementSet == null) {
+          JsonObject jsonObject = (JsonObject) o;
+          measurementSet = Json.measurementSetFromJson(jsonObject);
+        } else {
+          throw new RuntimeException("Unexpected value: " + o);
+        }
+      }
+    } catch (IOException e) {
+      throw new RuntimeException(e);
+    } finally {
+      Closeables.closeQuietly(reader);
+      timeProcess.destroy();
+    }
+
+    if (measurementSet == null) {
+      String message = "Failed to execute " + Joiner.on(" ").join(processBuilder.command());
+      System.err.println("  " + message);
+      System.err.println(eventLog.toString());
+      throw new ConfigurationException(message);
+    }
+
+    return new MeasurementResult(measurementSet, eventLog.toString());
+  }
+
+  private ProcessBuilder createCommand(Scenario scenario, Vm vm, MeasurementType type) {
+    File workingDirectory = new File(System.getProperty("user.dir"));
+
+    String classPath = System.getProperty("java.class.path");
+    if (classPath == null || classPath.length() == 0) {
+      throw new IllegalStateException("java.class.path is undefined in " + System.getProperties());
+    }
+
+    ImmutableList.Builder<String> vmArgs = ImmutableList.builder();
+    vmArgs.addAll(ARGUMENT_SPLITTER.split(scenario.getVariables().get(Scenario.VM_KEY)));
+    if (type == MeasurementType.INSTANCE || type == MeasurementType.MEMORY) {
+      String allocationJarFile = System.getenv("ALLOCATION_JAR");
+      vmArgs.add("-javaagent:" + allocationJarFile);
+    }
+    vmArgs.addAll(vm.getVmSpecificOptions(type, arguments));
+
+    Map<String, String> vmParameters = scenario.getVariables(
+        scenarioSelection.getVmParameterNames());
+    for (String vmParameter : vmParameters.values()) {
+      vmArgs.addAll(ARGUMENT_SPLITTER.split(vmParameter));
+    }
+
+    ImmutableList.Builder<String> caliperArgs = ImmutableList.builder();
+    caliperArgs.add("--warmupMillis").add(Long.toString(arguments.getWarmupMillis()));
+    caliperArgs.add("--runMillis").add(Long.toString(arguments.getRunMillis()));
+    caliperArgs.add("--measurementType").add(type.toString());
+    caliperArgs.add("--marker").add(arguments.getMarker());
+
+    Map<String,String> userParameters = scenario.getVariables(
+        scenarioSelection.getUserParameterNames());
+    for (Entry<String, String> entry : userParameters.entrySet()) {
+      caliperArgs.add("-D" + entry.getKey() + "=" + entry.getValue());
+    }
+    caliperArgs.add(arguments.getSuiteClassName());
+
+    return vm.newProcessBuilder(workingDirectory, classPath,
+        vmArgs.build(), InProcessRunner.class.getName(), caliperArgs.build());
+  }
+
+  private void debug() {
+    try {
+      int debugReps = arguments.getDebugReps();
+      InProcessRunner runner = new InProcessRunner();
+      DebugMeasurer measurer = new DebugMeasurer(debugReps);
+      for (Scenario scenario : scenarioSelection.select()) {
+        System.out.println("running " + debugReps + " debug reps of " + scenario);
+        runner.run(scenarioSelection, scenario, measurer);
+      }
+    } catch (Exception e) {
+      throw new ExceptionFromUserCodeException(e);
+    }
+  }
+
+  private Result runOutOfProcess() {
+    Date executedDate = new Date();
+    ImmutableMap.Builder<Scenario, ScenarioResult> resultsBuilder = ImmutableMap.builder();
+
+    try {
+      List<Scenario> scenarios = scenarioSelection.select();
+
+      int i = 0;
+      for (Scenario scenario : scenarios) {
+        beforeMeasurement(i++, scenarios.size(), scenario);
+        ScenarioResult scenarioResult = runScenario(scenario);
+        afterMeasurement(arguments.getMeasureMemory(), scenarioResult);
+        resultsBuilder.put(scenario, scenarioResult);
+      }
+      System.out.println();
+
+      Environment environment = new EnvironmentGetter().getEnvironmentSnapshot();
+      return new Result(
+          new Run(resultsBuilder.build(), arguments.getSuiteClassName(), executedDate),
+          environment);
+    } catch (Exception e) {
+      throw new ExceptionFromUserCodeException(e);
+    }
+  }
+
+  private void beforeMeasurement(int index, int total, Scenario scenario) {
+    double percentDone = (double) index / total;
+    System.out.printf("%2.0f%% %s", percentDone * 100, scenario);
+  }
+
+  private void afterMeasurement(boolean memoryMeasured, ScenarioResult scenarioResult) {
+    String memoryMeasurements = "";
+    if (memoryMeasured) {
+      MeasurementSet instanceMeasurementSet =
+          scenarioResult.getMeasurementSet(MeasurementType.INSTANCE);
+      String instanceUnit =
+        ConsoleReport.UNIT_ORDERING.min(instanceMeasurementSet.getUnitNames().entrySet()).getKey();
+      MeasurementSet memoryMeasurementSet = scenarioResult.getMeasurementSet(MeasurementType.MEMORY);
+      String memoryUnit =
+        ConsoleReport.UNIT_ORDERING.min(memoryMeasurementSet.getUnitNames().entrySet()).getKey();
+      memoryMeasurements = String.format(", allocated %s%s for a total of %s%s",
+          Math.round(instanceMeasurementSet.medianUnits()), instanceUnit,
+          Math.round(memoryMeasurementSet.medianUnits()), memoryUnit);
+    }
+
+    MeasurementSet timeMeasurementSet = scenarioResult.getMeasurementSet(MeasurementType.TIME);
+    String unit =
+        ConsoleReport.UNIT_ORDERING.min(timeMeasurementSet.getUnitNames().entrySet()).getKey();
+    System.out.printf(" %.2f %s; \u03C3=%.2f %s @ %d trials%s%n", timeMeasurementSet.medianUnits(),
+        unit, timeMeasurementSet.standardDeviationUnits(), unit,
+        timeMeasurementSet.getMeasurements().size(), memoryMeasurements);
+  }
+
+  public static void main(String[] args) {
+    try {
+      new Runner().run(args);
+      System.exit(0); // user code may have leave non-daemon threads behind!
+    } catch (DisplayUsageException e) {
+      e.display();
+      System.exit(0);
+    } catch (UserException e) {
+      e.display();
+      System.exit(1);
+    }
+  }
+
+  @SuppressWarnings("unchecked") // temporary fakery
+  public static void main(Class<? extends Benchmark> suite, String[] args) {
+    main(ObjectArrays.concat(args, suite.getName()));
+  }
+}
diff --git a/caliper/src/main/java/com/google/caliper/Scenario.java b/caliper/src/main/java/com/google/caliper/Scenario.java
new file mode 100644
index 0000000..bc026d8
--- /dev/null
+++ b/caliper/src/main/java/com/google/caliper/Scenario.java
@@ -0,0 +1,80 @@
+/*
+ * Copyright (C) 2009 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.caliper;
+
+import com.google.common.annotations.GwtCompatible;
+
+import java.io.Serializable;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * A configured benchmark.
+ *
+ * WARNING: a JSON representation of this class is stored on the app engine server. If any changes
+ * are made to this class, a deserialization adapter must be written for this class to ensure
+ * backwards compatibility.
+ *
+ * <p>Gwt-safe.
+ */
+@SuppressWarnings("serial")
+@GwtCompatible
+public final class Scenario
+    implements Serializable /* for GWT */  {
+
+  static final String VM_KEY = "vm";
+  static final String TRIAL_KEY = "trial";
+
+  private /*final*/ Map<String, String> variables;
+
+  public Scenario(Map<String, String> variables) {
+    this.variables = new LinkedHashMap<String, String>(variables);
+  }
+
+  public Map<String, String> getVariables() {
+    return variables;
+  }
+
+  /**
+   * Returns the named set of variables.
+   */
+  public Map<String, String> getVariables(Set<String> names) {
+    Map<String, String> result = new LinkedHashMap<String, String>(variables);
+    result.keySet().retainAll(names);
+    if (!result.keySet().equals(names)) {
+      throw new IllegalArgumentException("Not all of " + names + " are in " + result.keySet());
+    }
+    return result;
+  }
+
+  @Override public boolean equals(Object o) {
+    return o instanceof Scenario
+        && ((Scenario) o).getVariables().equals(variables);
+  }
+
+  @Override public int hashCode() {
+    return variables.hashCode();
+  }
+
+  @Override public String toString() {
+    return "Scenario" + variables;
+  }
+
+  @SuppressWarnings("unused")
+  private Scenario() {} // for GWT
+}
diff --git a/caliper/src/main/java/com/google/caliper/ScenarioResult.java b/caliper/src/main/java/com/google/caliper/ScenarioResult.java
new file mode 100644
index 0000000..1fa687d
--- /dev/null
+++ b/caliper/src/main/java/com/google/caliper/ScenarioResult.java
@@ -0,0 +1,88 @@
+/*
+ * Copyright (C) 2010 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.caliper;
+
+import com.google.common.annotations.GwtCompatible;
+
+import java.io.Serializable;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Holds the results for a particular scenario, including timing measurements, memory use
+ * measurements, and event logs for both, recording significant events during measurement.
+ *
+ * WARNING: a JSON representation of this class is stored on the app engine server. If any changes
+ * are made to this class, a deserialization adapter must be written for this class to ensure
+ * backwards compatibility.
+ *
+ * <p>Gwt-safe.
+ */
+@SuppressWarnings({"serial", "FieldMayBeFinal"})
+@GwtCompatible
+public final class ScenarioResult
+    implements Serializable /* for GWT Serialization */ {
+
+  // want these to be EnumMaps, but that upsets GWT
+  private /*final*/ Map<String, MeasurementSet> measurementSetMap
+      = new HashMap<String, MeasurementSet>();
+  private /*final*/ Map<String, String> eventLogMap
+      = new HashMap<String, String>();
+
+  public ScenarioResult(MeasurementSet timeMeasurementSet,
+      String timeEventLog, MeasurementSet instanceMeasurementSet,
+      String instanceEventLog, MeasurementSet memoryMeasurementSet,
+      String memoryEventLog) {
+    if (timeMeasurementSet != null) {
+      measurementSetMap.put(MeasurementType.TIME.toString(), timeMeasurementSet);
+      eventLogMap.put(MeasurementType.TIME.toString(), timeEventLog);
+    }
+    if (instanceMeasurementSet != null) {
+      measurementSetMap.put(MeasurementType.INSTANCE.toString(), instanceMeasurementSet);
+      eventLogMap.put(MeasurementType.INSTANCE.toString(), instanceEventLog);
+    }
+    if (memoryMeasurementSet != null) {
+      measurementSetMap.put(MeasurementType.MEMORY.toString(), memoryMeasurementSet);
+      eventLogMap.put(MeasurementType.MEMORY.toString(), memoryEventLog);
+    }
+  }
+
+  public MeasurementSet getMeasurementSet(MeasurementType type) {
+    return measurementSetMap.get(type.toString());
+  }
+
+  public String getEventLog(MeasurementType type) {
+    return eventLogMap.get(type.toString());
+  }
+
+  @Override public boolean equals(Object o) {
+    return o instanceof ScenarioResult
+        && ((ScenarioResult) o).measurementSetMap.equals(measurementSetMap)
+        && ((ScenarioResult) o).eventLogMap.equals(eventLogMap);
+  }
+
+  @Override public int hashCode() {
+    return measurementSetMap.hashCode() * 37 + eventLogMap.hashCode();
+  }
+
+  @Override public String toString() {
+    return "measurementSetMap: " + measurementSetMap + ", eventLogMap: " + eventLogMap;
+  }
+
+  @SuppressWarnings("unused")
+  private ScenarioResult() {} // for GWT Serialization
+}
diff --git a/caliper/src/main/java/com/google/caliper/ScenarioSelection.java b/caliper/src/main/java/com/google/caliper/ScenarioSelection.java
new file mode 100644
index 0000000..fcfead0
--- /dev/null
+++ b/caliper/src/main/java/com/google/caliper/ScenarioSelection.java
@@ -0,0 +1,253 @@
+/*
+ * Copyright (C) 2010 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.caliper;
+
+import com.google.caliper.UserException.AbstractBenchmarkException;
+import com.google.caliper.UserException.DoesntImplementBenchmarkException;
+import com.google.caliper.UserException.ExceptionFromUserCodeException;
+import com.google.caliper.UserException.NoParameterlessConstructorException;
+import com.google.caliper.UserException.NoSuchClassException;
+import com.google.common.collect.LinkedHashMultimap;
+import com.google.common.collect.Multimap;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.InvocationTargetException;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Set;
+
+/**
+ * Figures out which scenarios to benchmark given a benchmark suite, set of user
+ * parameters, and set of user VMs.
+ */
+public final class ScenarioSelection {
+
+  private final Set<String> userVms;
+  private final Multimap<String, String> vmParameters;
+  private final String suiteClassName;
+
+  /**
+   * The user parameters specified on the command line. This may be a subset of
+   * the effective user parameters because parameters not specified here may get
+   * default values from the benchmark class.
+   */
+  private final Multimap<String, String> userParameterArguments;
+
+  /**
+   * The actual user parameters we'll use to run in the benchmark. This contains
+   * the userParameterArguments plus the default user parameters.
+   */
+  private Multimap<String, String> userParameters;
+
+  private final int trials;
+  private Benchmark suite;
+
+
+  public ScenarioSelection(Arguments arguments) {
+    this(arguments.getUserVms(), arguments.getVmParameters(), arguments.getSuiteClassName(),
+        arguments.getUserParameters(), arguments.getTrials());
+  }
+
+  public ScenarioSelection(Set<String> userVms, Multimap<String, String> vmParameters,
+      String suiteClassName, Multimap<String, String> userParameterArguments, int trials) {
+    this.userVms = userVms;
+    this.vmParameters = vmParameters;
+    this.suiteClassName = suiteClassName;
+    this.userParameterArguments = userParameterArguments;
+    this.trials = trials;
+  }
+
+  /**
+   * Returns the selected scenarios for this benchmark.
+   */
+  public List<Scenario> select() {
+    prepareSuite();
+    userParameters = computeUserParameters();
+    return createScenarios();
+  }
+
+  /**
+   * Returns a normalized version of {@code scenario}, with information from {@code suite}
+   * assisting in correcting problems.
+   */
+  public Scenario normalizeScenario(Scenario scenario) {
+    // This only applies to SimpleBenchmarks since they accept the special "benchmark"
+    // parameter. This is a special case because SimpleBenchmark is the most commonly
+    // used benchmark class. Have to do this horrible stuff since Benchmark API
+    // doesn't provide scenario-normalization (and it shouldn't), which SimpleBenchmark
+    // requires.
+    if (suite instanceof SimpleBenchmark) {
+      return ((SimpleBenchmark) suite).normalizeScenario(scenario);
+    }
+
+    return scenario;
+  }
+
+  public Set<String> getUserParameterNames() {
+    if (userParameters == null) {
+      throw new IllegalStateException();
+    }
+    return userParameters.keySet();
+  }
+
+  public Set<String> getVmParameterNames() {
+    return vmParameters.keySet();
+  }
+
+  public ConfiguredBenchmark createBenchmark(Scenario scenario) {
+    return suite.createBenchmark(scenario.getVariables(getUserParameterNames()));
+  }
+
+  private void prepareSuite() {
+    Class<?> benchmarkClass;
+    try {
+      benchmarkClass = getClassByName(suiteClassName);
+    } catch (ExceptionInInitializerError e) {
+      throw new ExceptionFromUserCodeException(e.getCause());
+    } catch (ClassNotFoundException ignored) {
+      throw new NoSuchClassException(suiteClassName);
+    }
+
+    Object s;
+    try {
+      Constructor<?> constructor = benchmarkClass.getDeclaredConstructor();
+      constructor.setAccessible(true);
+      s = constructor.newInstance();
+    } catch (InstantiationException ignore) {
+      throw new AbstractBenchmarkException(benchmarkClass);
+    } catch (NoSuchMethodException ignore) {
+      throw new NoParameterlessConstructorException(benchmarkClass);
+    } catch (IllegalAccessException impossible) {
+      throw new AssertionError(impossible); // shouldn't happen since we setAccessible(true)
+    } catch (InvocationTargetException e) {
+      throw new ExceptionFromUserCodeException(e.getCause());
+    }
+
+    if (s instanceof Benchmark) {
+      this.suite = (Benchmark) s;
+    } else {
+      throw new DoesntImplementBenchmarkException(benchmarkClass);
+    }
+  }
+
+  private static Class<?> getClassByName(String className) throws ClassNotFoundException {
+    try {
+      return Class.forName(className);
+    } catch (ClassNotFoundException ignored) {
+      // try replacing the last dot with a $, in case that helps
+      // example: tutorial.Tutorial.Benchmark1 becomes tutorial.Tutorial$Benchmark1
+      // amusingly, the $ character means three different things in this one line alone
+      String newName = className.replaceFirst("\\.([^.]+)$", "\\$$1");
+      return Class.forName(newName);
+    }
+  }
+
+  private Multimap<String, String> computeUserParameters() {
+    Multimap<String, String> result = LinkedHashMultimap.create();
+    for (String key : suite.parameterNames()) {
+      // first check if the user has specified values
+      Collection<String> userValues = userParameterArguments.get(key);
+      if (!userValues.isEmpty()) {
+        result.putAll(key, userValues);
+        // TODO: type convert 'em to validate?
+
+      } else { // otherwise use the default values from the suite
+        Set<String> values = suite.parameterValues(key);
+        if (values.isEmpty()) {
+          throw new ConfigurationException(key + " has no values. "
+              + "Did you forget a -D" + key + "=<value> command line argument?");
+        }
+        result.putAll(key, values);
+      }
+    }
+    return result;
+  }
+
+  /**
+   * Returns a complete set of scenarios with every combination of variables.
+   */
+  private List<Scenario> createScenarios() {
+    List<ScenarioBuilder> builders = new ArrayList<ScenarioBuilder>();
+    builders.add(new ScenarioBuilder());
+
+    Map<String, Collection<String>> variables = new LinkedHashMap<String, Collection<String>>();
+    variables.put(Scenario.VM_KEY, userVms.isEmpty() ? VmFactory.defaultVms() : userVms);
+    variables.put(Scenario.TRIAL_KEY, newListOfSize(trials));
+    variables.putAll(userParameters.asMap());
+    variables.putAll(vmParameters.asMap());
+
+    for (Entry<String, Collection<String>> entry : variables.entrySet()) {
+      Iterator<String> values = entry.getValue().iterator();
+      if (!values.hasNext()) {
+        throw new ConfigurationException("Not enough values for " + entry);
+      }
+
+      String firstValue = values.next();
+      for (ScenarioBuilder builder : builders) {
+        builder.variables.put(entry.getKey(), firstValue);
+      }
+
+      // multiply the size of the specs by the number of alternate values
+      int size = builders.size();
+      while (values.hasNext()) {
+        String alternate = values.next();
+        for (int s = 0; s < size; s++) {
+          ScenarioBuilder copy = builders.get(s).copy();
+          copy.variables.put(entry.getKey(), alternate);
+          builders.add(copy);
+        }
+      }
+    }
+
+    List<Scenario> result = new ArrayList<Scenario>();
+    for (ScenarioBuilder builder : builders) {
+      result.add(normalizeScenario(builder.build()));
+    }
+
+    return result;
+  }
+
+  /**
+   * Returns a list containing {@code count} distinct elements.
+   */
+  private Collection<String> newListOfSize(int count) {
+    List<String> result = new ArrayList<String>();
+    for (int i = 0; i < count; i++) {
+      result.add(Integer.toString(i));
+    }
+    return result;
+  }
+
+  private static class ScenarioBuilder {
+    final Map<String, String> variables = new LinkedHashMap<String, String>();
+
+    ScenarioBuilder copy() {
+      ScenarioBuilder result = new ScenarioBuilder();
+      result.variables.putAll(variables);
+      return result;
+    }
+
+    public Scenario build() {
+      return new Scenario(variables);
+    }
+  }
+}
diff --git a/caliper/src/main/java/com/google/caliper/SimpleBenchmark.java b/caliper/src/main/java/com/google/caliper/SimpleBenchmark.java
new file mode 100644
index 0000000..01fc3a8
--- /dev/null
+++ b/caliper/src/main/java/com/google/caliper/SimpleBenchmark.java
@@ -0,0 +1,227 @@
+/*
+ * Copyright (C) 2009 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.caliper;
+
+import com.google.caliper.UserException.ExceptionFromUserCodeException;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSet;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.util.Arrays;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * A convenience class for implementing benchmarks in plain code.
+ * Implementing classes must have a no-arguments constructor.
+ *
+ * <h3>Benchmarks</h3>
+ * The benchmarks of a suite are defined by . They may be
+ * static. They are not permitted to take parameters . . ..
+ *
+ * <h3>Parameters</h3>
+ * See the {@link Param} documentation to learn about parameters.
+ */
+public abstract class SimpleBenchmark
+    implements Benchmark {
+  private static final Class<?>[] ARGUMENT_TYPES = { int.class };
+
+  private final Map<String, Parameter<?>> parameters;
+  private final Map<String, Method> methods;
+
+  protected SimpleBenchmark() {
+    parameters = Parameter.forClass(getClass());
+    methods = createTimedMethods();
+
+    if (methods.isEmpty()) {
+      throw new ConfigurationException(
+          "No benchmarks defined in " + getClass().getName());
+    }
+  }
+
+  protected void setUp() throws Exception {}
+
+  protected void tearDown() throws Exception {}
+
+  @Override public Set<String> parameterNames() {
+    return ImmutableSet.<String>builder()
+        .add("benchmark")
+        .addAll(parameters.keySet())
+        .build();
+  }
+
+  @Override public Set<String> parameterValues(String parameterName) {
+    if ("benchmark".equals(parameterName)) {
+      return methods.keySet();
+    }
+
+    Parameter<?> parameter = parameters.get(parameterName);
+    if (parameter == null) {
+      throw new IllegalArgumentException();
+    }
+    try {
+      Iterable<?> values = parameter.values();
+
+      ImmutableSet.Builder<String> result = ImmutableSet.builder();
+      for (Object value : values) {
+        result.add(String.valueOf(value));
+      }
+      return result.build();
+    } catch (Exception e) {
+      throw new ExceptionFromUserCodeException(e);
+    }
+  }
+
+  @Override public ConfiguredBenchmark createBenchmark(Map<String, String> parameterValues) {
+    if (!parameterNames().equals(parameterValues.keySet())) {
+      throw new IllegalArgumentException("Invalid parameters specified. Expected "
+          + parameterNames() + " but was " + parameterValues.keySet());
+    }
+
+    String methodName = parameterValues.get("benchmark");
+    final Method method = methods.get(methodName);
+    if (method == null) {
+      throw new IllegalArgumentException("Invalid parameters specified. \"time" + methodName + "\" "
+          + "is not a method of this benchmark.");
+    }
+
+    try {
+      @SuppressWarnings({"ClassNewInstance"}) // can throw any Exception, so we catch all Exceptions
+      final SimpleBenchmark copyOfSelf = getClass().newInstance();
+
+      for (Map.Entry<String, String> entry : parameterValues.entrySet()) {
+        String parameterName = entry.getKey();
+        if ("benchmark".equals(parameterName)) {
+          continue;
+        }
+
+        Parameter<?> parameter = parameters.get(parameterName);
+        Object value = TypeConverter.fromString(entry.getValue(), parameter.getType());
+        parameter.set(copyOfSelf, value);
+      }
+      copyOfSelf.setUp();
+
+      return new ConfiguredBenchmark(copyOfSelf) {
+        @Override public Object run(int reps) throws Exception {
+          try {
+            return method.invoke(copyOfSelf, reps);
+          } catch (InvocationTargetException e) {
+            Throwable cause = e.getCause();
+            if (cause instanceof Exception) {
+              throw (Exception) cause;
+            } else if (cause instanceof Error) {
+              throw (Error) cause;
+            } else {
+              throw e;
+            }
+          }
+        }
+
+        @Override public void close() throws Exception {
+          copyOfSelf.tearDown();
+        }
+      };
+    } catch (Exception e) {
+      throw new ExceptionFromUserCodeException(e);
+    }
+  }
+
+  public Scenario normalizeScenario(Scenario scenario) {
+    Map<String, String> variables =
+      new LinkedHashMap<String, String>(scenario.getVariables());
+    // Make sure the scenario contains method names without the prefixed "time". If
+    // it has "time" prefixed, then remove it. Also check whether the user has
+    // accidentally put a lower cased letter first, and fix it if necessary.
+    String benchmark = variables.get("benchmark");
+    Map<String, Method> timedMethods = createTimedMethods();
+    if (timedMethods.get(benchmark) == null) {
+      // try to upper case first character
+      char[] benchmarkChars = benchmark.toCharArray();
+      benchmarkChars[0] = Character.toUpperCase(benchmarkChars[0]);
+      String upperCasedBenchmark = String.valueOf(benchmarkChars);
+      if (timedMethods.get(upperCasedBenchmark) != null) {
+        variables.put("benchmark", upperCasedBenchmark);
+      } else if (benchmark.startsWith("time")) {
+        variables.put("benchmark", benchmark.substring(4));
+      }
+    }
+    return new Scenario(variables);
+  }
+
+  /**
+   * Returns a spec for each benchmark defined in the specified class. The
+   * returned specs have no parameter values; those must be added separately.
+   */
+  private Map<String, Method> createTimedMethods() {
+    ImmutableMap.Builder<String, Method> result = ImmutableMap.builder();
+    for (Method method : getClass().getDeclaredMethods()) {
+      int modifiers = method.getModifiers();
+      if (!method.getName().startsWith("time")) {
+        continue;
+      }
+
+      if (!Modifier.isPublic(modifiers)
+          || Modifier.isStatic(modifiers)
+          || Modifier.isAbstract(modifiers)
+          || !Arrays.equals(method.getParameterTypes(), ARGUMENT_TYPES)) {
+        throw new ConfigurationException("Timed methods must be public, "
+            + "non-static, non-abstract and take a single int parameter. "
+            + "But " + method + " violates these requirements.");
+      }
+
+      result.put(method.getName().substring(4), method);
+    }
+
+    return result.build();
+  }
+
+  @Override public Map<String, Integer> getTimeUnitNames() {
+    return ImmutableMap.of("ns", 1,
+        "us", 1000,
+        "ms", 1000000,
+        "s", 1000000000);
+  }
+
+  @Override public double nanosToUnits(double nanos) {
+    return nanos;
+  }
+
+  @Override public Map<String, Integer> getInstanceUnitNames() {
+    return ImmutableMap.of(" instances", 1,
+        "K instances", 1000,
+        "M instances", 1000000,
+        "B instances", 1000000000);
+  }
+
+  @Override public double instancesToUnits(long instances) {
+    return instances;
+  }
+
+  @Override public Map<String, Integer> getMemoryUnitNames() {
+    return ImmutableMap.of("B", 1,
+        "KiB", 1024,
+        "MiB", 1048576,
+        "GiB", 1073741824);
+  }
+
+  @Override public double bytesToUnits(long bytes) {
+    return bytes;
+  }
+}
diff --git a/caliper/src/main/java/com/google/caliper/StandardVm.java b/caliper/src/main/java/com/google/caliper/StandardVm.java
new file mode 100644
index 0000000..3366eb1
--- /dev/null
+++ b/caliper/src/main/java/com/google/caliper/StandardVm.java
@@ -0,0 +1,46 @@
+/*
+ * Copyright (C) 2010 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.caliper;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Lists;
+
+import java.util.ArrayList;
+import java.util.List;
+
+final class StandardVm extends Vm {
+
+  @Override public List<String> getVmSpecificOptions(MeasurementType type, Arguments arguments) {
+    if (!arguments.getCaptureVmLog()) {
+      return ImmutableList.of();
+    }
+
+    List<String> result = new ArrayList<String>();
+    result.add("-verbose:gc");
+    result.add("-Xbatch");
+    result.add("-XX:+UseSerialGC");
+    if (type == MeasurementType.TIME) {
+      return Lists.newArrayList("-XX:+PrintCompilation");
+    }
+
+    return result;
+  }
+
+  public static String defaultVmName() {
+    return "java";
+  }
+}
diff --git a/caliper/src/main/java/com/google/caliper/TimeMeasurer.java b/caliper/src/main/java/com/google/caliper/TimeMeasurer.java
new file mode 100644
index 0000000..2925d2d
--- /dev/null
+++ b/caliper/src/main/java/com/google/caliper/TimeMeasurer.java
@@ -0,0 +1,180 @@
+/**
+ * Copyright (C) 2009 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.caliper;
+
+import static com.google.common.base.Preconditions.checkArgument;
+
+import com.google.caliper.UserException.DoesNotScaleLinearlyException;
+import com.google.caliper.UserException.RuntimeOutOfRangeException;
+import com.google.common.base.Supplier;
+
+/**
+ * Measure's the benchmark's per-trial execution time.
+ */
+class TimeMeasurer extends Measurer {
+
+  private final long warmupNanos;
+  private final long runNanos;
+
+  /**
+   * If the standard deviation of our measurements is within this tolerance, we
+   * won't bother to perform additional measurements.
+   */
+  private static final double SHORT_CIRCUIT_TOLERANCE = 0.01;
+
+  private static final int MAX_TRIALS = 10;
+
+  TimeMeasurer(long warmupMillis, long runMillis) {
+    checkArgument(warmupMillis > 50);
+    checkArgument(runMillis > 50);
+
+    this.warmupNanos = warmupMillis * 1000000;
+    this.runNanos = runMillis * 1000000;
+  }
+
+  private double warmUp(Supplier<ConfiguredBenchmark> testSupplier) throws Exception {
+    long elapsedNanos = 0;
+    long netReps = 0;
+    int reps = 1;
+    boolean definitelyScalesLinearly = false;
+
+    /*
+     * Run progressively more reps at a time until we cross our warmup
+     * threshold. This way any just-in-time compiler will be comfortable running
+     * multiple iterations of our measurement method.
+     */
+    log("[starting warmup]");
+    while (elapsedNanos < warmupNanos) {
+      long nanos = measureReps(testSupplier.get(), reps);
+      elapsedNanos += nanos;
+
+      netReps += reps;
+      reps *= 2;
+
+      // if reps overflowed, that's suspicious! Check that it time scales with reps
+      if (reps <= 0) {
+        if (!definitelyScalesLinearly) {
+          checkScalesLinearly(testSupplier);
+          definitelyScalesLinearly = true;
+        }
+        reps = Integer.MAX_VALUE;
+      }
+    }
+    log("[ending warmup]");
+
+    double nanosPerExecution = (double) elapsedNanos / netReps;
+    double lowerBound = 0.1;
+    double upperBound = 10000000000.0;
+    if (!(lowerBound <= nanosPerExecution && nanosPerExecution <= upperBound)) {
+      throw new RuntimeOutOfRangeException(nanosPerExecution, lowerBound, upperBound);
+    }
+
+    return nanosPerExecution;
+  }
+
+  /**
+   * Doing half as much work shouldn't take much more than half as much time. If
+   * it does we have a broken benchmark!
+   */
+  private void checkScalesLinearly(Supplier<ConfiguredBenchmark> testSupplier) throws Exception {
+    double half = measureReps(testSupplier.get(), Integer.MAX_VALUE / 2);
+    double one = measureReps(testSupplier.get(), Integer.MAX_VALUE);
+    if (half / one > 0.75) {
+      throw new DoesNotScaleLinearlyException();
+    }
+  }
+
+  /**
+   * Measure the nanos per rep for the given test. This code uses an interesting
+   * strategy to measure the runtime to minimize execution time when execution
+   * time is consistent.
+   * <ol>
+   *   <li>1.0x {@code runMillis} trial is run.
+   *   <li>0.5x {@code runMillis} trial is run.
+   *   <li>1.5x {@code runMillis} trial is run.
+   *   <li>At this point, the standard deviation of these trials is computed. If
+   *       it is within the threshold, the result is returned.
+   *   <li>Otherwise trials continue to be executed until either the threshold
+   *       is satisfied or the maximum number of runs have been executed.
+   * </ol>
+   *
+   * @param testSupplier provides instances of the code under test. A new test
+   *      is created for each iteration because some benchmarks' performance
+   *      depends on which memory was allocated. See SetContainsBenchmark for an
+   *      example.
+   */
+  @Override public MeasurementSet run(Supplier<ConfiguredBenchmark> testSupplier)
+      throws Exception {
+    double estimatedNanosPerRep = warmUp(testSupplier);
+
+    log("[measuring nanos per rep with scale 1.00]");
+    Measurement measurement100 = measure(testSupplier, 1.00, estimatedNanosPerRep);
+    log("[measuring nanos per rep with scale 0.50]");
+    Measurement measurement050 = measure(testSupplier, 0.50, measurement100.getRaw());
+    log("[measuring nanos per rep with scale 1.50]");
+    Measurement measurement150 = measure(testSupplier, 1.50, measurement100.getRaw());
+    MeasurementSet measurementSet =
+        new MeasurementSet(measurement100, measurement050, measurement150);
+
+    for (int i = 3; i < MAX_TRIALS; i++) {
+      double threshold = SHORT_CIRCUIT_TOLERANCE * measurementSet.meanRaw();
+      if (measurementSet.standardDeviationRaw() < threshold) {
+        return measurementSet;
+      }
+
+      log("[performing additional measurement with scale 1.00]");
+      Measurement measurement = measure(testSupplier, 1.00, measurement100.getRaw());
+      measurementSet = measurementSet.plusMeasurement(measurement);
+    }
+
+    return measurementSet;
+  }
+
+  /**
+   * Runs the test method for approximately {@code runNanos * durationScale}
+   * nanos and returns a Measurement of the nanos per rep and units per rep.
+   */
+  private Measurement measure(Supplier<ConfiguredBenchmark> testSupplier,
+      double durationScale, double estimatedNanosPerRep) throws Exception {
+    int reps = (int) (durationScale * runNanos / estimatedNanosPerRep);
+    if (reps == 0) {
+      reps = 1;
+    }
+
+    log("[running trial with " + reps + " reps]");
+    ConfiguredBenchmark benchmark = testSupplier.get();
+    long elapsedTime = measureReps(benchmark, reps);
+    double nanosPerRep = elapsedTime / (double) reps;
+    log(String.format("[took %.2f nanoseconds per rep]", nanosPerRep));
+    return new Measurement(benchmark.timeUnitNames(), nanosPerRep,
+        benchmark.nanosToUnits(nanosPerRep));
+  }
+
+  /**
+   * Returns the total nanos to run {@code reps}.
+   */
+  private long measureReps(ConfiguredBenchmark benchmark, int reps) throws Exception {
+    prepareForTest();
+    log(LogConstants.MEASURED_SECTION_STARTING);
+    long startNanos = System.nanoTime();
+    benchmark.run(reps);
+    long endNanos = System.nanoTime();
+    log(LogConstants.MEASURED_SECTION_DONE);
+    benchmark.close();
+    return endNanos - startNanos;
+  }
+}
diff --git a/caliper/src/main/java/com/google/caliper/TypeConverter.java b/caliper/src/main/java/com/google/caliper/TypeConverter.java
new file mode 100644
index 0000000..c3268e0
--- /dev/null
+++ b/caliper/src/main/java/com/google/caliper/TypeConverter.java
@@ -0,0 +1,65 @@
+/**
+ * Copyright (C) 2009 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.caliper;
+
+import com.google.common.collect.ImmutableMap;
+
+import java.lang.reflect.Method;
+import java.lang.reflect.Type;
+import java.util.Map;
+
+/**
+ * Convert objects to and from Strings.
+ */
+final class TypeConverter {
+  private TypeConverter() {}
+
+  public static Object fromString(String value, Type type) {
+    if (type == String.class) {
+      return value;
+    }
+
+    Class<?> c = wrap((Class<?>) type);
+    try {
+      Method m = c.getMethod("valueOf", String.class);
+      m.setAccessible(true); // to permit inner enums, etc.
+      return m.invoke(null, value);
+    } catch (Exception e) {
+      throw new UnsupportedOperationException(
+          "Cannot convert " + value + " of type " + type, e);
+    }
+  }
+
+  // safe because both Long.class and long.class are of type Class<Long>
+  @SuppressWarnings("unchecked")
+  private static <T> Class<T> wrap(Class<T> c) {
+    return c.isPrimitive() ? (Class<T>) PRIMITIVES_TO_WRAPPERS.get(c) : c;
+  }
+
+  private static final Map<Class<?>, Class<?>> PRIMITIVES_TO_WRAPPERS
+    = new ImmutableMap.Builder<Class<?>, Class<?>>()
+      .put(boolean.class, Boolean.class)
+      .put(byte.class, Byte.class)
+      .put(char.class, Character.class)
+      .put(double.class, Double.class)
+      .put(float.class, Float.class)
+      .put(int.class, Integer.class)
+      .put(long.class, Long.class)
+      .put(short.class, Short.class)
+      .put(void.class, Void.class)
+      .build();
+}
diff --git a/caliper/src/main/java/com/google/caliper/UploadResults.java b/caliper/src/main/java/com/google/caliper/UploadResults.java
new file mode 100644
index 0000000..7dae7af
--- /dev/null
+++ b/caliper/src/main/java/com/google/caliper/UploadResults.java
@@ -0,0 +1,28 @@
+/*
+ * Copyright (C) 2010 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.caliper;
+
+import java.io.File;
+
+/**
+ * Usage: UploadResults <file_or_dir>
+ */
+public class UploadResults {
+  public static void main(String[] args) {
+    new Runner().uploadResultsFileOrDir(new File(args[0]));
+  }
+}
diff --git a/caliper/src/main/java/com/google/caliper/UserException.java b/caliper/src/main/java/com/google/caliper/UserException.java
new file mode 100644
index 0000000..a4535a7
--- /dev/null
+++ b/caliper/src/main/java/com/google/caliper/UserException.java
@@ -0,0 +1,196 @@
+/*
+ * Copyright (C) 2009 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.caliper;
+
+import java.util.Arrays;
+import java.util.Set;
+
+/**
+ * Signifies a problem that should be explained in user-friendly terms on the command line, without
+ * a confusing stack trace, and optionally followed by a usage summary.
+ */
+@SuppressWarnings("serial") // never going to serialize these... right?
+public abstract class UserException extends RuntimeException {
+  protected UserException(String error) {
+    super(error);
+  }
+
+  public abstract void display();
+
+  // - - - -
+
+  public abstract static class ErrorInUsageException extends UserException {
+    protected ErrorInUsageException(String error) {
+      super(error);
+    }
+
+    @Override public void display() {
+      String message = getMessage();
+      if (message != null) {
+        System.err.println("Error: " + message);
+      }
+      Arguments.printUsage();
+    }
+  }
+
+  public abstract static class ErrorInUserCodeException extends UserException {
+    private final String remedy;
+
+    protected ErrorInUserCodeException(String error, String remedy) {
+      super(error);
+      this.remedy = remedy;
+    }
+
+    @Override public void display() {
+      System.err.println("Error: " + getMessage());
+      System.err.println("Typical Remedy: " + remedy);
+    }
+  }
+
+  // - - - -
+
+  // Not technically an error, but works nicely this way anyway
+  public static class DisplayUsageException extends ErrorInUsageException {
+    public DisplayUsageException() {
+      super(null);
+    }
+  }
+
+  public static class IncompatibleArgumentsException extends ErrorInUsageException {
+    public IncompatibleArgumentsException(String arg) {
+      super("Some arguments passed in are incompatible with: " + arg);
+    }
+  }
+
+  public static class UnrecognizedOptionException extends ErrorInUsageException {
+    public UnrecognizedOptionException(String arg) {
+      super("Argument not recognized: " + arg);
+    }
+  }
+
+  public static class NoBenchmarkClassException extends ErrorInUsageException {
+    public NoBenchmarkClassException() {
+      super("No benchmark class specified.");
+    }
+  }
+
+  public static class MultipleBenchmarkClassesException extends ErrorInUsageException {
+    public MultipleBenchmarkClassesException(String a, String b) {
+      super("Multiple benchmark classes specified: " + Arrays.asList(a, b));
+    }
+  }
+
+  public static class MalformedParameterException extends ErrorInUsageException {
+    public MalformedParameterException(String arg) {
+      super("Malformed parameter: " + arg);
+    }
+  }
+
+  public static class DuplicateParameterException extends ErrorInUsageException {
+    public DuplicateParameterException(String arg) {
+      super("Duplicate parameter: " + arg);
+    }
+    public DuplicateParameterException(Set<String> arg) {
+      super("Duplicate parameters: " + arg);
+    }
+  }
+
+  public static class InvalidParameterValueException extends ErrorInUsageException {
+    public InvalidParameterValueException(String arg, String value) {
+      super("Invalid value \"" + value + "\" for parameter: " + arg);
+    }
+  }
+
+  public static class InvalidTrialsException extends ErrorInUsageException {
+    public InvalidTrialsException(String arg) {
+      super("Invalid trials: " + arg);
+    }
+  }
+
+  public static class CantCustomizeInProcessVmException extends ErrorInUsageException {
+    public CantCustomizeInProcessVmException() {
+      super("Can't customize VM when running in process.");
+    }
+  }
+
+  public static class NoSuchClassException extends ErrorInUsageException {
+    public NoSuchClassException(String name) {
+      super("No class named [" + name + "] was found (check CLASSPATH).");
+    }
+  }
+
+  public static class RuntimeOutOfRangeException extends ErrorInUsageException {
+    public RuntimeOutOfRangeException(
+        double nanosPerExecution, double lowerBound, double upperBound) {
+      super("Runtime " + nanosPerExecution + "ns/rep out of range "
+          + lowerBound + "-" + upperBound);
+    }
+  }
+
+  public static class DoesNotScaleLinearlyException extends ErrorInUsageException {
+    public DoesNotScaleLinearlyException() {
+      super("Doing 2x as much work didn't take 2x as much time! "
+          + "Is the JIT optimizing away the body of your benchmark?");
+    }
+  }
+
+  public static class NonConstantMemoryUsage extends ErrorInUsageException {
+    public NonConstantMemoryUsage() {
+      super("Not all reps of the inner loop allocate the same number of times! "
+          + "The reps loop should use a constant number of allocations. "
+          + "Are you using the value of reps inside the loop?");
+    }
+  }
+
+  public static class AbstractBenchmarkException extends ErrorInUserCodeException {
+    public AbstractBenchmarkException(Class<?> specifiedClass) {
+      super("Class [" + specifiedClass.getName() + "] is abstract.", "Specify a concrete class.");
+    }
+  }
+
+  public static class NoParameterlessConstructorException extends ErrorInUserCodeException {
+    public NoParameterlessConstructorException(Class<?> specifiedClass) {
+      super("Class [" + specifiedClass.getName() + "] has no parameterless constructor.",
+          "Remove all constructors or add a parameterless constructor.");
+    }
+  }
+
+  public static class DoesntImplementBenchmarkException extends ErrorInUserCodeException {
+    public DoesntImplementBenchmarkException(Class<?> specifiedClass) {
+      super("Class [" + specifiedClass + "] does not implement the " + Benchmark.class.getName()
+          + " interface.", "Add 'extends " + SimpleBenchmark.class + "' to the class declaration.");
+    }
+  }
+
+  public static class InvalidDebugRepsException extends ErrorInUsageException {
+    public InvalidDebugRepsException(String arg) {
+      super("Invalid debug reps: " + arg);
+    }
+  }
+
+  // TODO: should remove the caliper stack frames....
+  public static class ExceptionFromUserCodeException extends UserException {
+    public ExceptionFromUserCodeException(Throwable t) {
+      super("An exception was thrown from the benchmark code.");
+      initCause(t);
+    }
+    @Override public void display() {
+      System.err.println(getMessage());
+      getCause().printStackTrace(System.err);
+    }
+  }
+}
diff --git a/caliper/src/main/java/com/google/caliper/Vm.java b/caliper/src/main/java/com/google/caliper/Vm.java
new file mode 100644
index 0000000..1cc45a9
--- /dev/null
+++ b/caliper/src/main/java/com/google/caliper/Vm.java
@@ -0,0 +1,46 @@
+/*
+ * Copyright (C) 2010 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.caliper;
+
+import com.google.common.collect.ImmutableList;
+
+import java.io.File;
+import java.util.List;
+
+class Vm {
+  public List<String> getVmSpecificOptions(MeasurementType type, Arguments arguments) {
+    return ImmutableList.of();
+  }
+
+  /**
+   * Returns a process builder to run this VM.
+   *
+   * @param vmArgs the path to the VM followed by VM arguments.
+   * @param applicationArgs arguments to the target process
+   */
+  public ProcessBuilder newProcessBuilder(File workingDirectory, String classPath,
+      ImmutableList<String> vmArgs, String className, ImmutableList<String> applicationArgs) {
+    ProcessBuilder result = new ProcessBuilder();
+    result.directory(workingDirectory);
+    result.command().addAll(vmArgs);
+    result.command().add("-cp");
+    result.command().add(classPath);
+    result.command().add(className);
+    result.command().addAll(applicationArgs);
+    return result;
+  }
+}
diff --git a/caliper/src/main/java/com/google/caliper/VmFactory.java b/caliper/src/main/java/com/google/caliper/VmFactory.java
new file mode 100644
index 0000000..408e34c
--- /dev/null
+++ b/caliper/src/main/java/com/google/caliper/VmFactory.java
@@ -0,0 +1,47 @@
+/*
+ * Copyright (C) 2010 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.caliper;
+
+import com.google.common.collect.ImmutableSet;
+
+import java.util.Arrays;
+import java.util.List;
+
+public final class VmFactory {
+  public static ImmutableSet<String> defaultVms() {
+    String vmName = DalvikVm.isDalvikVm()
+        ? DalvikVm.vmName()
+        : StandardVm.defaultVmName();
+    return ImmutableSet.of(vmName);
+  }
+
+  public Vm createVm(Scenario scenario) {
+    List<String> vmList = Arrays.asList(scenario.getVariables().get(Scenario.VM_KEY).split("\\s+"));
+    Vm vm = null;
+    if (!vmList.isEmpty()) {
+      if (vmList.get(0).endsWith("app_process")) {
+        vm = new DalvikVm();
+      } else if (vmList.get(0).endsWith("java")) {
+        vm = new StandardVm();
+      }
+    }
+    if (vm == null) {
+      vm = new Vm();
+    }
+    return vm;
+  }
+}
diff --git a/caliper/src/main/java/com/google/caliper/Xml.java b/caliper/src/main/java/com/google/caliper/Xml.java
new file mode 100644
index 0000000..2aeebda
--- /dev/null
+++ b/caliper/src/main/java/com/google/caliper/Xml.java
@@ -0,0 +1,160 @@
+/*
+ * Copyright (C) 2010 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.caliper;
+
+import com.google.common.collect.ImmutableMap;
+
+import org.w3c.dom.Document;
+import org.w3c.dom.Element;
+import org.w3c.dom.Node;
+
+import java.io.InputStream;
+import java.text.SimpleDateFormat;
+import java.util.Date;
+import java.util.Locale;
+
+import javax.xml.parsers.DocumentBuilderFactory;
+
+/**
+ * This exists for backwards compatibility with old data, which is stored in XML format.
+ * All new data is stored in JSON.
+ */
+public final class Xml {
+  private static final String DATE_FORMAT_STRING = "yyyy-MM-dd'T'HH:mm:ssz";
+  private static final String ENVIRONMENT_ELEMENT_NAME = "environment";
+  private static final String RESULT_ELEMENT_NAME = "result";
+  private static final String RUN_ELEMENT_NAME = "run";
+  private static final String BENCHMARK_ATTRIBUTE = "benchmark";
+  private static final String EXECUTED_TIMESTAMP_ATTRIBUTE = "executedTimestamp";
+  private static final String OLD_SCENARIO_ELEMENT_NAME = "scenario";
+  // for backwards compatibility, use a different name
+  private static final String SCENARIO_ELEMENT_NAME = "newScenario";
+  private static final String MEASUREMENTS_ELEMENT_NAME = "measurements";
+  private static final String TIME_EVENT_LOG_ELEMENT_NAME = "eventLog";
+
+  private static Result readResultElement(Element element) throws Exception {
+    Environment environment = null;
+    Run run = null;
+    for (Node topLevelNode : XmlUtils.childrenOf(element)) {
+      if (topLevelNode.getNodeName().equals(ENVIRONMENT_ELEMENT_NAME)) {
+        Element environmentElement = (Element) topLevelNode;
+        environment = readEnvironmentElement(environmentElement);
+      } else if (topLevelNode.getNodeName().equals(RUN_ELEMENT_NAME)) {
+        run = readRunElement((Element) topLevelNode);
+      } else {
+        throw new RuntimeException("illegal node name: " + topLevelNode.getNodeName());
+      }
+    }
+
+    if (environment == null || run == null) {
+      throw new RuntimeException("missing environment or run elements");
+    }
+
+    return new Result(run, environment);
+  }
+
+  private static Environment readEnvironmentElement(Element element) {
+    return new Environment(XmlUtils.attributesOf(element));
+  }
+
+  private static Run readRunElement(Element element) throws Exception {
+    String benchmarkName = element.getAttribute(BENCHMARK_ATTRIBUTE);
+    String executedDateString = element.getAttribute(EXECUTED_TIMESTAMP_ATTRIBUTE);
+    Date executedDate = new SimpleDateFormat(DATE_FORMAT_STRING, Locale.US)
+        .parse(executedDateString);
+
+    ImmutableMap.Builder<Scenario, ScenarioResult> measurementsBuilder = ImmutableMap.builder();
+    for (Node scenarioNode : XmlUtils.childrenOf(element)) {
+      Element scenarioElement = (Element) scenarioNode;
+      Scenario scenario = new Scenario(XmlUtils.attributesOf(scenarioElement));
+      ScenarioResult scenarioResult;
+
+      // for backwards compatibility with older runs
+      if (scenarioNode.getNodeName().equals(OLD_SCENARIO_ELEMENT_NAME)) {
+        MeasurementSet measurement =
+            Json.measurementSetFromJson(scenarioElement.getTextContent());
+        scenarioResult = new ScenarioResult(measurement, "",
+            null, null, null, null);
+      } else if (scenarioNode.getNodeName().equals(SCENARIO_ELEMENT_NAME)) {
+        MeasurementSet timeMeasurementSet = null;
+        String eventLog = null;
+        for (Node node : XmlUtils.childrenOf(scenarioElement)) {
+          if (node.getNodeName().equals(MEASUREMENTS_ELEMENT_NAME)) {
+            timeMeasurementSet = Json.measurementSetFromJson(node.getTextContent());
+          } else if (node.getNodeName().equals(TIME_EVENT_LOG_ELEMENT_NAME)) {
+            eventLog = node.getTextContent();
+          } else {
+            throw new RuntimeException("illegal node name: " + node.getNodeName());
+          }
+        }
+        if (timeMeasurementSet == null || eventLog == null) {
+          throw new RuntimeException("missing node \"" + MEASUREMENTS_ELEMENT_NAME + "\" or \""
+              + TIME_EVENT_LOG_ELEMENT_NAME + "\"");
+        }
+        // "new Measurement[0]" used instead of empty varargs argument since MeasurementSet has
+        // an empty private constructor.
+        scenarioResult = new ScenarioResult(timeMeasurementSet, eventLog,
+            null, null, null, null);
+      } else {
+        throw new RuntimeException("illegal node name: " + scenarioNode.getNodeName());
+      }
+
+      measurementsBuilder.put(scenario, scenarioResult);
+    }
+
+    return new Run(measurementsBuilder.build(), benchmarkName, executedDate);
+  }
+
+  /**
+   * Creates a result by decoding XML from the specified stream. The XML should
+   * be consistent with the format emitted by the now deleted runToXml(Run, OutputStream).
+   */
+  public static Run runFromXml(InputStream in) {
+    try {
+      Document document = DocumentBuilderFactory.newInstance().newDocumentBuilder().parse(in);
+      return readRunElement(document.getDocumentElement());
+    } catch (Exception e) {
+      throw new IllegalStateException("Malformed XML document", e);
+    }
+  }
+
+  /**
+   * Creates an environment by decoding XML from the specified stream. The XML should
+   * be consistent with the format emitted by the now deleted
+   * environmentToXml(Environment, OutputStream).
+   */
+  public static Environment environmentFromXml(InputStream in) {
+    try {
+      Document document = DocumentBuilderFactory.newInstance().newDocumentBuilder().parse(in);
+      Element environmentElement = document.getDocumentElement();
+      return readEnvironmentElement(environmentElement);
+    } catch (Exception e) {
+      throw new IllegalStateException("Malformed XML document", e);
+    }
+  }
+
+  public static Result resultFromXml(InputStream in) {
+    try {
+      Document document = DocumentBuilderFactory.newInstance().newDocumentBuilder().parse(in);
+      return readResultElement(document.getDocumentElement());
+    } catch (Exception e) {
+      throw new IllegalStateException("Malformed XML document", e);
+    }
+  }
+
+  private Xml() {}
+}
diff --git a/caliper/src/main/java/com/google/caliper/XmlUtils.java b/caliper/src/main/java/com/google/caliper/XmlUtils.java
new file mode 100644
index 0000000..458e6fa
--- /dev/null
+++ b/caliper/src/main/java/com/google/caliper/XmlUtils.java
@@ -0,0 +1,49 @@
+/*
+ * Copyright (C) 2010 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.caliper;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+
+import org.w3c.dom.Attr;
+import org.w3c.dom.Element;
+import org.w3c.dom.NamedNodeMap;
+import org.w3c.dom.Node;
+import org.w3c.dom.NodeList;
+
+public final class XmlUtils {
+  public static ImmutableList<Node> childrenOf(Node node) {
+    NodeList children = node.getChildNodes();
+    ImmutableList.Builder<Node> result = ImmutableList.builder();
+    for (int i = 0, size = children.getLength(); i < size; i++) {
+      result.add(children.item(i));
+    }
+    return result.build();
+  }
+
+  public static ImmutableMap<String, String> attributesOf(Element element) {
+    NamedNodeMap map = element.getAttributes();
+    ImmutableMap.Builder<String, String> result = ImmutableMap.builder();
+    for (int i = 0, size = map.getLength(); i < size; i++) {
+      Attr attr = (Attr) map.item(i);
+      result.put(attr.getName(), attr.getValue());
+    }
+    return result.build();
+  }
+
+  private XmlUtils() {}
+}
diff --git a/caliper/src/main/java/com/google/caliper/util/InterleavedReader.java b/caliper/src/main/java/com/google/caliper/util/InterleavedReader.java
new file mode 100644
index 0000000..40293bf
--- /dev/null
+++ b/caliper/src/main/java/com/google/caliper/util/InterleavedReader.java
@@ -0,0 +1,128 @@
+/*
+ * Copyright (C) 2010 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.caliper.util;
+
+import com.google.gson.JsonParser;
+
+import java.io.BufferedReader;
+import java.io.Closeable;
+import java.io.IOException;
+import java.io.Reader;
+
+/**
+ * Reads a stream containing inline JSON objects. Each JSON object is prefixed
+ * by a marker string and suffixed by a newline character.
+ */
+public final class InterleavedReader implements Closeable {
+
+  /**
+   * The length of the scratch buffer to search for markers in. Also acts as an
+   * upper bound on the length of returned strings. Not used as an I/O buffer.
+   */
+  private static final int BUFFER_LENGTH = 80;
+
+  private final String marker;
+  private final BufferedReader reader;
+  private final JsonParser jsonParser = new JsonParser();
+
+  public static final String DEFAULT_MARKER = "//ZxJ/";
+
+  public InterleavedReader(Reader reader) {
+    this(DEFAULT_MARKER, reader);
+  }
+
+  public InterleavedReader(String marker, Reader reader) {
+    if (marker.length() > BUFFER_LENGTH) {
+      throw new IllegalArgumentException("marker.length() > BUFFER_LENGTH");
+    }
+    this.marker = marker;
+    this.reader = reader instanceof BufferedReader
+        ? (BufferedReader) reader
+        : new BufferedReader(reader);
+  }
+
+  /**
+   * Returns the next value in the stream: either a String, a JsonElement, or
+   * null to indicate the end of the stream. Callers should use instanceof to
+   * inspect the return type.
+   */
+  public Object read() throws IOException {
+    char[] buffer = new char[BUFFER_LENGTH];
+    reader.mark(BUFFER_LENGTH);
+    int count = 0;
+    int textEnd;
+
+    while (true) {
+      int r = reader.read(buffer, count, buffer.length - count);
+
+      if (r == -1) {
+        // the input is exhausted; return the remaining characters
+        textEnd = count;
+        break;
+      }
+
+      count += r;
+      int possibleMarker = findPossibleMarker(buffer, count);
+
+      if (possibleMarker != 0) {
+        // return the characters that precede the marker
+        textEnd = possibleMarker;
+        break;
+      }
+
+      if (count < marker.length()) {
+        // the buffer contains only the prefix of a marker so we must read more
+        continue;
+      }
+
+      // we've read a marker so return the value that follows
+      reader.reset();
+      String json = reader.readLine().substring(marker.length());
+      return jsonParser.parse(json);
+    }
+
+    if (count == 0) {
+      return null;
+    }
+
+    // return characters
+    reader.reset();
+    count = reader.read(buffer, 0, textEnd);
+    return new String(buffer, 0, count);
+  }
+
+  @Override public void close() throws IOException {
+    reader.close();
+  }
+
+  /**
+   * Returns the index of marker in {@code chars}, stopping at {@code limit}.
+   * Should the chars end with a prefix of marker, the offset of that prefix
+   * is returned.
+   */
+  int findPossibleMarker(char[] chars, int limit) {
+    search:
+    for (int i = 0; true; i++) {
+      for (int m = 0; m < marker.length() && i + m < limit; m++) {
+        if (chars[i + m] != marker.charAt(m)) {
+          continue search;
+        }
+      }
+      return i;
+    }
+  }
+}
diff --git a/caliper/src/main/java/com/google/caliper/util/LinearTranslation.java b/caliper/src/main/java/com/google/caliper/util/LinearTranslation.java
new file mode 100644
index 0000000..2e52b06
--- /dev/null
+++ b/caliper/src/main/java/com/google/caliper/util/LinearTranslation.java
@@ -0,0 +1,48 @@
+/*
+ * Copyright (C) 2010 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.caliper.util;
+
+import com.google.common.annotations.GwtCompatible;
+
+@GwtCompatible
+public class LinearTranslation {
+  //  y = mx + b
+  private final double m;
+  private final double b;
+
+  // TODO(kevinb): why so high? why even check this at all?
+  private static final double EQUALITY_TOLERANCE = 1.0E-6;
+
+  /**
+   * Constructs a linear translation for which {@code translate(in1) == out1}
+   * and {@code translate(in2) == out2}.
+   *
+   * @throws IllegalArgumentException if {@code in1 == in2}
+   */
+  public LinearTranslation(double in1, double out1, double in2, double out2) {
+    if (Math.abs(in1 - in2) < EQUALITY_TOLERANCE) {
+      throw new IllegalArgumentException("in1 and in2 are approximately equal");
+    }
+    double divisor = in1 - in2;
+    this.m = (out1 - out2) / divisor;
+    this.b = (in1 * out2 - in2 * out1) / divisor;
+  }
+
+  public double translate(double in) {
+    return m * in + b;
+  }
+}
diff --git a/caliper/src/main/resources/CaliperCore.gwt.xml b/caliper/src/main/resources/CaliperCore.gwt.xml
new file mode 100644
index 0000000..fcfe2fe
--- /dev/null
+++ b/caliper/src/main/resources/CaliperCore.gwt.xml
@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module>
+  <inherits name='com.google.gwt.user.User'/>
+  <source path="com/google/caliper">
+    <!-- Adding a file? Don't forget to update build.xml! -->
+    <include name="**/LinearTranslation.java"/>
+    <include name="**/Environment.java"/>
+    <include name="**/Run.java"/>
+    <include name="**/Measurement.java"/>
+    <include name="**/MeasurementSet.java"/>
+    <include name="**/ScenarioResult.java"/>
+    <include name="**/MeasurementType.java"/>
+    <include name="**/Scenario.java"/>
+  </source>
+</module>
\ No newline at end of file
diff --git a/caliper/src/test/java/com/google/caliper/AllTests.java b/caliper/src/test/java/com/google/caliper/AllTests.java
new file mode 100644
index 0000000..0e3d1cc
--- /dev/null
+++ b/caliper/src/test/java/com/google/caliper/AllTests.java
@@ -0,0 +1,33 @@
+/*
+ * Copyright (C) 2010 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.caliper;
+
+import junit.framework.Test;
+import junit.framework.TestSuite;
+
+public class AllTests {
+  public static Test suite() {
+    TestSuite suite = new TestSuite();
+    suite.addTestSuite(CaliperTest.class);
+    suite.addTestSuite(JsonTest.class);
+    suite.addTestSuite(MeasurementSetTest.class);
+    suite.addTestSuite(ParameterTest.class);
+    suite.addTestSuite(WarmupOverflowTest.class);
+
+    return suite;
+  }
+}
diff --git a/caliper/src/test/java/com/google/caliper/CaliperTest.java b/caliper/src/test/java/com/google/caliper/CaliperTest.java
new file mode 100644
index 0000000..18857ba
--- /dev/null
+++ b/caliper/src/test/java/com/google/caliper/CaliperTest.java
@@ -0,0 +1,93 @@
+/*
+ * Copyright (C) 2010 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.caliper;
+
+import com.google.common.base.Supplier;
+import java.util.Map;
+import java.util.Set;
+import junit.framework.TestCase;
+
+public final class CaliperTest extends TestCase {
+
+  /**
+   * Test we detect and fail when benchmarks don't scale properly.
+   * @throws Exception
+   */
+  public void testBenchmarkScalesNonLinearly() throws Exception {
+    TimeMeasurer timeMeasurer = new TimeMeasurer(1000, 1000);
+    try {
+      timeMeasurer.run(new NonLinearTimedRunnable());
+      fail();
+    } catch (UserException.DoesNotScaleLinearlyException e) {
+    }
+  }
+
+  private static class NonLinearTimedRunnable extends ConfiguredBenchmark
+      implements Supplier<ConfiguredBenchmark> {
+    private NonLinearTimedRunnable() {
+      super(new NoOpBenchmark());
+    }
+
+    @Override public ConfiguredBenchmark get() {
+      return this;
+    }
+
+    @Override public Object run(int reps) throws Exception {
+      return null; // broken! doesn't loop reps times.
+    }
+
+    @Override public void close() throws Exception {}
+  }
+
+  private static class NoOpBenchmark implements Benchmark {
+    @Override public Set<String> parameterNames() {
+      return null;
+    }
+
+    @Override public Set<String> parameterValues(String parameterName) {
+      return null;
+    }
+
+    @Override public ConfiguredBenchmark createBenchmark(Map<String, String> parameterValues) {
+      return null;
+    }
+
+    @Override public Map<String, Integer> getTimeUnitNames() {
+      return null;
+    }
+
+    @Override public Map<String, Integer> getInstanceUnitNames() {
+      return null;
+    }
+
+    @Override public Map<String, Integer> getMemoryUnitNames() {
+      return null;
+    }
+
+    @Override public double nanosToUnits(double nanos) {
+      return 0;
+    }
+
+    @Override public double instancesToUnits(long instances) {
+      return 0;
+    }
+
+    @Override public double bytesToUnits(long bytes) {
+      return 0;
+    }
+  }
+}
diff --git a/caliper/src/test/java/com/google/caliper/JsonTest.java b/caliper/src/test/java/com/google/caliper/JsonTest.java
new file mode 100644
index 0000000..cee02b0
--- /dev/null
+++ b/caliper/src/test/java/com/google/caliper/JsonTest.java
@@ -0,0 +1,67 @@
+/*
+ * Copyright (C) 2011 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.caliper;
+
+import com.google.common.collect.ImmutableMap;
+import java.util.Date;
+import java.util.Locale;
+import java.util.Map;
+import junit.framework.TestCase;
+
+public final class JsonTest extends TestCase {
+
+  public void testJsonSerialization() {
+    Result original = newSampleResult();
+    String json = Json.getGsonInstance().toJson(original, Result.class);
+    Result reserialized = Json.getGsonInstance().fromJson(json, Result.class);
+    assertEquals(original, reserialized);
+  }
+
+  /**
+   * Caliper's JSON files used to include dates specific to the host machine's
+   * locale. http://code.google.com/p/caliper/issues/detail?id=113
+   */
+  public void testJsonSerializationWithFancyLocale() {
+    Result original = newSampleResult();
+
+    // serialize in one locale...
+    Locale defaultLocale = Locale.getDefault();
+    Locale.setDefault(Locale.ITALY);
+    String json;
+    try {
+      json = Json.getGsonInstance().toJson(original, Result.class);
+    } finally {
+      Locale.setDefault(defaultLocale);
+    }
+
+    // deserialize in another
+    Result reserialized = Json.getGsonInstance().fromJson(json, Result.class);
+    assertEquals(original, reserialized);
+  }
+
+  private Result newSampleResult() {
+    Map<String,Integer> units = ImmutableMap.of("ns", 1);
+    MeasurementSet timeMeasurements = new MeasurementSet(new Measurement(units, 2.0, 2.0));
+    Date executedDate = new Date(0);
+    Scenario scenario = new Scenario(ImmutableMap.of("benchmark", "Foo"));
+    ScenarioResult scenarioResult = new ScenarioResult(
+        timeMeasurements, "log", null, null, null, null);
+    Run run = new Run(ImmutableMap.of(scenario, scenarioResult), "foo.FooBenchmark", executedDate);
+    Environment environment = new Environment(ImmutableMap.of("os.name", "Linux"));
+    return new Result(run, environment);
+  }
+}
diff --git a/caliper/src/test/java/com/google/caliper/MeasurementSetTest.java b/caliper/src/test/java/com/google/caliper/MeasurementSetTest.java
new file mode 100644
index 0000000..f6f7cbb
--- /dev/null
+++ b/caliper/src/test/java/com/google/caliper/MeasurementSetTest.java
@@ -0,0 +1,216 @@
+/*
+ * Copyright (C) 2010 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.caliper;
+
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.Ordering;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import junit.framework.TestCase;
+
+public class MeasurementSetTest extends TestCase {
+
+  Ordering<Measurement> MEASUREMENT_BY_NANOS = new Ordering<Measurement>() {
+    @Override public int compare(Measurement a, Measurement b) {
+      return Double.compare(a.getRaw(), b.getRaw());
+    }
+  };
+  
+  public void testIncompatibleMeasurements() {
+    Measurement[] measurements = new Measurement[2];
+    measurements[0] = new Measurement(ImmutableMap.of("doublens", 1), 1.1, 2.2);
+    measurements[1] = new Measurement(ImmutableMap.of("triplens", 1), 3.8, 7.6);
+    try {
+      new MeasurementSet(measurements);
+      fail("illegal argument exception not thrown");
+    } catch (IllegalArgumentException e) {
+      // success
+    }
+  }
+
+  public void testIncompatibleAddedMeasurements() {
+    Measurement[] measurements = new Measurement[1];
+    measurements[0] = new Measurement(ImmutableMap.of("doublens", 1), 1.1, 2.2);
+    MeasurementSet measurementSet = new MeasurementSet(measurements);
+    try {
+      measurementSet.plusMeasurement(new Measurement(ImmutableMap.of("triplens", 1), 3.8, 7.6));
+      fail("illegal argument exception not thrown");
+    } catch (IllegalArgumentException e) {
+      // success
+    }
+  }
+
+  public void testSize() {
+    Measurement[] measurements = new Measurement[3];
+    measurements[0] = new Measurement(ImmutableMap.of("doublens", 1), 1.1, 2.2);
+    measurements[1] = new Measurement(ImmutableMap.of("doublens", 1), 3.8, 7.6);
+    measurements[2] = new Measurement(ImmutableMap.of("doublens", 1), 2.3, 4.6);
+    MeasurementSet measurementSet = new MeasurementSet(measurements);
+    assertEquals(3, measurementSet.size());
+
+    Measurement[] measurements2 = new Measurement[4];
+    measurements2[0] = new Measurement(ImmutableMap.of("doublens", 1), 1.1, 2.2);
+    measurements2[1] = new Measurement(ImmutableMap.of("doublens", 1), 3.8, 7.6);
+    measurements2[2] = new Measurement(ImmutableMap.of("doublens", 1), 2.3, 4.6);
+    measurements2[3] = new Measurement(ImmutableMap.of("doublens", 1), 7.2, 14.4);
+    MeasurementSet measurementSet2 =
+        new MeasurementSet(measurements2);
+    assertEquals(4, measurementSet2.size());
+  }
+
+  public void testPlusMeasurement() {
+    Measurement[] measurements = new Measurement[3];
+    measurements[0] = new Measurement(ImmutableMap.of("doublens", 1), 1.1, 2.2);
+    measurements[1] = new Measurement(ImmutableMap.of("doublens", 1), 3.8, 7.6);
+    measurements[2] = new Measurement(ImmutableMap.of("doublens", 1), 2.3, 4.6);
+    MeasurementSet measurementSet = new MeasurementSet(measurements);
+
+    Measurement[] measurements2 = new Measurement[4];
+    measurements2[0] = new Measurement(ImmutableMap.of("doublens", 1), 1.1, 2.2);
+    measurements2[1] = new Measurement(ImmutableMap.of("doublens", 1), 3.8, 7.6);
+    measurements2[2] = new Measurement(ImmutableMap.of("doublens", 1), 2.3, 4.6);
+    measurements2[3] = new Measurement(ImmutableMap.of("doublens", 1), 7.2, 14.4);
+    MeasurementSet measurementSet2 =
+        new MeasurementSet(measurements2);
+
+    MeasurementSet measurementSet3 = measurementSet.plusMeasurement(measurements2[3]);
+
+    assertDoubleListsEquals(measurementSet2.getMeasurementsRaw(),
+        measurementSet3.getMeasurementsRaw(), 0.0000001);
+    assertDoubleListsEquals(measurementSet2.getMeasurementUnits(),
+        measurementSet3.getMeasurementUnits(), 0.0000001);
+    assertEquals(measurementSet2.getUnitNames(), measurementSet3.getUnitNames());
+
+    List<Measurement> measurementList1 =
+        MEASUREMENT_BY_NANOS.sortedCopy(measurementSet2.getMeasurements());
+    List<Measurement> measurementList2 =
+        MEASUREMENT_BY_NANOS.sortedCopy(measurementSet3.getMeasurements());
+    assertEquals(measurementList1.size(), measurementList2.size());
+    for (int i = 0; i < measurementList1.size(); i++) {
+      assertEquals(measurementList1.get(i).getRaw(),
+          measurementList2.get(i).getRaw());
+      assertEquals(measurementList1.get(i).getProcessed(),
+          measurementList2.get(i).getProcessed());
+    }
+  }
+
+  public void testMedian() {
+    Measurement[] measurements = new Measurement[3];
+    measurements[0] = new Measurement(ImmutableMap.of("doublens", 1), 1.1, 2.2);
+    measurements[1] = new Measurement(ImmutableMap.of("doublens", 1), 3.8, 7.6);
+    measurements[2] = new Measurement(ImmutableMap.of("doublens", 1), 2.3, 4.6);
+    MeasurementSet measurementSet = new MeasurementSet(measurements);
+    assertEquals(2.3, measurementSet.medianRaw(), 0.00000001);
+    assertEquals(4.6, measurementSet.medianUnits(), 0.00000001);
+
+    Measurement[] measurements2 = new Measurement[4];
+    measurements2[0] = new Measurement(ImmutableMap.of("doublens", 1), 1.1, 2.2);
+    measurements2[1] = new Measurement(ImmutableMap.of("doublens", 1), 3.8, 7.6);
+    measurements2[2] = new Measurement(ImmutableMap.of("doublens", 1), 2.3, 4.6);
+    measurements2[3] = new Measurement(ImmutableMap.of("doublens", 1), 7.2, 14.4);
+    MeasurementSet measurementSet2 =
+        new MeasurementSet(measurements2);
+    assertEquals((2.3 + 3.8) / 2, measurementSet2.medianRaw(), 0.00000001);
+    assertEquals((4.6 + 7.6) / 2, measurementSet2.medianUnits(), 0.00000001);
+  }
+
+  public void testMean() {
+    Measurement[] measurements = new Measurement[3];
+    measurements[0] = new Measurement(ImmutableMap.of("doublens", 1), 1.1, 2.2);
+    measurements[1] = new Measurement(ImmutableMap.of("doublens", 1), 3.8, 7.6);
+    measurements[2] = new Measurement(ImmutableMap.of("doublens", 1), 2.3, 4.6);
+    MeasurementSet measurementSet = new MeasurementSet(measurements);
+    assertEquals((1.1 + 3.8 + 2.3) / 3, measurementSet.meanRaw(), 0.00000001);
+    assertEquals((2.2 + 7.6 + 4.6) / 3, measurementSet.meanUnits(), 0.00000001);
+
+    Measurement[] measurements2 = new Measurement[4];
+    measurements2[0] = new Measurement(ImmutableMap.of("doublens", 1), 1.1, 2.2);
+    measurements2[1] = new Measurement(ImmutableMap.of("doublens", 1), 3.8, 7.6);
+    measurements2[2] = new Measurement(ImmutableMap.of("doublens", 1), 2.3, 4.6);
+    measurements2[3] = new Measurement(ImmutableMap.of("doublens", 1), 7.2, 14.4);
+    MeasurementSet measurementSet2 =
+        new MeasurementSet(measurements2);
+    assertEquals((1.1 + 2.3 + 3.8 + 7.2) / 4, measurementSet2.meanRaw(), 0.00000001);
+    assertEquals((2.2 + 4.6 + 7.6 + 14.4) / 4, measurementSet2.meanUnits(), 0.00000001);
+  }
+
+  public void testStandardDeviation() {
+    Measurement[] measurements = new Measurement[3];
+    measurements[0] = new Measurement(ImmutableMap.of("doublens", 1), 1.1, 2.2);
+    measurements[1] = new Measurement(ImmutableMap.of("doublens", 1), 3.8, 7.6);
+    measurements[2] = new Measurement(ImmutableMap.of("doublens", 1), 2.3, 4.6);
+    MeasurementSet measurementSet = new MeasurementSet(measurements);
+    assertEquals(1.35277, measurementSet.standardDeviationRaw(), 0.00001);
+    assertEquals(2.70555, measurementSet.standardDeviationUnits(), 0.00001);
+  }
+
+  public void testMax() {
+    Measurement[] measurements = new Measurement[3];
+    measurements[0] = new Measurement(ImmutableMap.of("doublens", 1), 1.1, 2.2);
+    measurements[1] = new Measurement(ImmutableMap.of("doublens", 1), 3.8, 7.6);
+    measurements[2] = new Measurement(ImmutableMap.of("doublens", 1), 2.3, 4.6);
+    MeasurementSet measurementSet = new MeasurementSet(measurements);
+    assertEquals(3.8, measurementSet.maxRaw(), 0.00000001);
+    assertEquals(7.6, measurementSet.maxUnits(), 0.00000001);
+  }
+
+  public void testMin() {
+    Measurement[] measurements = new Measurement[3];
+    measurements[0] = new Measurement(ImmutableMap.of("doublens", 1), 1.1, 2.2);
+    measurements[1] = new Measurement(ImmutableMap.of("doublens", 1), 3.8, 7.6);
+    measurements[2] = new Measurement(ImmutableMap.of("doublens", 1), 2.3, 4.6);
+    MeasurementSet measurementSet = new MeasurementSet(measurements);
+    assertEquals(1.1, measurementSet.minRaw(), 0.00000001);
+    assertEquals(2.2, measurementSet.minUnits(), 0.00000001);
+  }
+
+  public void testJsonRoundtrip() {
+    Measurement[] measurements = new Measurement[3];
+    measurements[0] = new Measurement(ImmutableMap.of("doublens", 1), 1.1, 2.2);
+    measurements[1] = new Measurement(ImmutableMap.of("doublens", 1), 3.8, 7.6);
+    measurements[2] = new Measurement(ImmutableMap.of("doublens", 1), 2.3, 4.6);
+    MeasurementSet measurementSet = new MeasurementSet(measurements);
+    MeasurementSet roundTripped =
+        Json.measurementSetFromJson(Json.measurementSetToJson(measurementSet));
+    assertDoubleListsEquals(measurementSet.getMeasurementsRaw(),
+        roundTripped.getMeasurementsRaw(), 0.00000001);
+    assertDoubleListsEquals(measurementSet.getMeasurementUnits(),
+        roundTripped.getMeasurementUnits(), 0.00000001);
+    assertEquals(measurementSet.getUnitNames(), roundTripped.getUnitNames());
+  }
+
+  @SuppressWarnings({"AssertEqualsBetweenInconvertibleTypes"})
+  public void testFromLegacyString() {
+    MeasurementSet measurementSet = Json.measurementSetFromJson("122.0 133.0 144.0");
+    assertDoubleListsEquals(Arrays.asList(122.0, 133.0, 144.0),
+        measurementSet.getMeasurementsRaw(), 0.00000001);
+    assertDoubleListsEquals(Arrays.asList(122.0, 133.0, 144.0),
+        measurementSet.getMeasurementUnits(), 0.00000001);
+    assertEquals(ImmutableMap.of("ns", 1, "us", 1000, "ms", 1000000, "s", 1000000000),
+        measurementSet.getUnitNames());
+  }
+
+  private void assertDoubleListsEquals(List<Double> expected, List<Double> actual, double epsilon) {
+    assertEquals(expected.size(), actual.size());
+    Collections.sort(expected);
+    Collections.sort(actual);
+    for (int i = 0; i < expected.size(); i++) {
+      assertEquals(expected.get(i), actual.get(i), epsilon);
+    }
+  }
+}
diff --git a/caliper/src/test/java/com/google/caliper/ParameterTest.java b/caliper/src/test/java/com/google/caliper/ParameterTest.java
new file mode 100644
index 0000000..9063261
--- /dev/null
+++ b/caliper/src/test/java/com/google/caliper/ParameterTest.java
@@ -0,0 +1,71 @@
+/*
+ * Copyright (C) 2010 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.caliper;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Sets;
+
+import junit.framework.TestCase;
+
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Map;
+
+public class ParameterTest extends TestCase {
+
+  public static class A extends SimpleBenchmark {
+    @Param({"value1", "value2"}) String param;
+  }
+
+  public void testFromAnnotation() throws Exception {
+    Map<String,Parameter<?>> map = Parameter.forClass(A.class);
+    Parameter<?> p = map.get("param");
+    assertEquals("param", p.getName());
+    assertEquals(String.class, p.getType());
+
+    checkParameterValues(A.class, "value1", "value2");
+  }
+
+  public enum Foo { VALUE1, VALUE2 }
+
+  public static class H extends SimpleBenchmark {
+    @Param Foo param;
+  }
+
+  public void testAllEnums() throws Exception {
+    checkParameterValues(H.class, Foo.VALUE1, Foo.VALUE2);
+  }
+
+  public static class I extends SimpleBenchmark {
+    @Param boolean param;
+  }
+
+  public void testBoolean() throws Exception {
+    checkParameterValues(I.class, true, false);
+  }
+
+  private static void checkParameterValues(Class<? extends SimpleBenchmark> bClass,
+      Object... expected) throws Exception {
+    Map<String,Parameter<?>> map = Parameter.forClass(bClass);
+    assertEquals(1, map.size());
+    Parameter<?> p = map.get("param");
+    List<Object> values = ImmutableList.copyOf(p.values());
+    assertEquals(Arrays.asList(expected), values);
+  }
+}
diff --git a/caliper/src/test/java/com/google/caliper/WarmupOverflowTest.java b/caliper/src/test/java/com/google/caliper/WarmupOverflowTest.java
new file mode 100644
index 0000000..85e59af
--- /dev/null
+++ b/caliper/src/test/java/com/google/caliper/WarmupOverflowTest.java
@@ -0,0 +1,81 @@
+/*
+ * Copyright (C) 2010 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.caliper;
+
+import com.google.caliper.UserException.DoesNotScaleLinearlyException;
+import com.google.common.util.concurrent.SimpleTimeLimiter;
+import com.google.common.util.concurrent.TimeLimiter;
+import java.util.concurrent.Callable;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+import junit.framework.TestCase;
+
+/**
+ * Test exposing an issue where any warmup that completes enough executions to reach
+ * Integer.MAX_VALUE reps (either because the benchmark code is optimized away or because the
+ * warmupMillis are long enough compared to the benchmark execution time).
+ */
+public class WarmupOverflowTest extends TestCase {
+  private TimeLimiter timeLimiter;
+
+  @Override public void setUp() {
+    timeLimiter = new SimpleTimeLimiter(Executors.newSingleThreadExecutor());
+  }
+
+  public void testOptimizedAwayBenchmarkDoesNotTakeTooLongToRun() throws Exception {
+    try {
+      timeLimiter.callWithTimeout(new Callable<Void>() {
+        @Override public Void call() throws Exception {
+          InProcessRunner runner = new InProcessRunner();
+          runner.run(OptimizedAwayBenchmark.class.getName(), "--warmupMillis", "3000",
+              "--measurementType", "TIME");
+          return null;
+        }
+      }, 90, TimeUnit.SECONDS, false);
+    } catch (DoesNotScaleLinearlyException expected) {
+    }
+  }
+
+  public void testLongWarmupMillisDoesNotTakeTooLongToRun() throws Exception {
+    timeLimiter.callWithTimeout(new Callable<Void>() {
+      @Override public Void call() throws Exception {
+        InProcessRunner runner = new InProcessRunner();
+        runner.run(RelativelyFastBenchmark.class.getName(), "--warmupMillis", "8000",
+            "--runMillis", "51", "--measurementType", "TIME");
+        return null;
+      }
+    }, 90, TimeUnit.SECONDS, false);
+  }
+
+  public static class OptimizedAwayBenchmark extends SimpleBenchmark {
+    public void timeIsNullOrEmpty(int reps) {
+      for (int i = 0; i < reps; i++) {
+        // do nothing!
+      }
+    }
+  }
+
+  public static class RelativelyFastBenchmark extends SimpleBenchmark {
+    public long timeSqrt(int reps) {
+      long result = 0;
+      for(int i = 0; i < reps; i++) {
+        result += Math.sqrt(81);
+      }
+      return result;
+    }
+  }
+}
diff --git a/examples/pom.xml b/examples/pom.xml
new file mode 100644
index 0000000..7352d7b
--- /dev/null
+++ b/examples/pom.xml
@@ -0,0 +1,88 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+  <modelVersion>4.0.0</modelVersion>
+  <groupId>com.google.caliper</groupId>
+  <artifactId>caliper-examples</artifactId>
+  <packaging>jar</packaging>
+  <version>0.5-rc1</version>
+  <inceptionYear>2009</inceptionYear>
+  <name>Caliper Examples</name>
+  <parent>
+    <groupId>org.sonatype.oss</groupId>
+    <artifactId>oss-parent</artifactId>
+    <version>5</version>
+  </parent>
+  <url>http://code.google.com/p/caliper/</url>
+  <description>Caliper Examples</description>
+  <licenses>
+    <license>
+      <name>The Apache Software License, Version 2.0</name>
+      <url>http://www.apache.org/licenses/LICENSE-2.0.txt</url>
+      <distribution>repo</distribution>
+    </license>
+  </licenses>
+  <scm>
+    <connection>scm:git:http://code.google.com/p/caliper/examples</connection>
+    <developerConnection>scm:git:git:http://code.google.com/p/caliper/examples</developerConnection>
+    <url>http://caliper.codegoogle.com/svn/trunk/examples</url>
+  </scm>
+  <issueManagement>
+    <system>Google Code Issue Tracking</system>
+    <url>http://code.google.com/p/caliper/issues/list</url>
+  </issueManagement>
+  <organization>
+    <name>Google, Inc.</name>
+    <url>http://www.google.com</url>
+  </organization>
+  <dependencies>
+    <dependency>
+      <groupId>com.google.caliper</groupId>
+      <artifactId>caliper</artifactId>
+      <version>0.5-rc1</version>
+    </dependency>
+    <dependency>
+      <groupId>junit</groupId>
+      <artifactId>junit</artifactId>
+      <version>3.8.2</version>
+      <scope>test</scope>
+    </dependency>
+  </dependencies>
+  <build>
+    <defaultGoal>package</defaultGoal>
+    <plugins>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-compiler-plugin</artifactId>
+        <version>2.3.2</version>
+        <configuration>
+          <source>1.6</source>
+          <target>1.6</target>
+        </configuration>
+      </plugin>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-eclipse-plugin</artifactId>
+        <version>2.8</version>
+        <configuration>
+          <downloadSources>true</downloadSources>
+          <downloadJavadocs>true</downloadJavadocs>
+          <workspace>../eclipse-ws/</workspace>
+        </configuration>
+      </plugin>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-release-plugin</artifactId>
+        <version>2.1</version>
+        <configuration>
+          <arguments>-DenableCiProfile=true</arguments>
+        </configuration>
+      </plugin>
+    </plugins>
+  </build>
+  <developers>
+    <developer>
+      <name>Jesse Wilson</name>
+      <organization>Google Inc.</organization>
+    </developer>
+  </developers>
+</project>
diff --git a/examples/src/main/java/examples/ArraySortBenchmark.java b/examples/src/main/java/examples/ArraySortBenchmark.java
new file mode 100644
index 0000000..f42390f
--- /dev/null
+++ b/examples/src/main/java/examples/ArraySortBenchmark.java
@@ -0,0 +1,102 @@
+/*
+ * Copyright (C) 2009 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package examples;
+
+import com.google.caliper.Param;
+import com.google.caliper.Runner;
+import com.google.caliper.SimpleBenchmark;
+import java.util.Arrays;
+import java.util.Random;
+
+/**
+ * Measures sorting on different distributions of integers.
+ */
+public class ArraySortBenchmark extends SimpleBenchmark {
+
+  @Param({"10", "100", "1000", "10000"}) private int length;
+
+  @Param private Distribution distribution;
+
+  private int[] values;
+  private int[] copy;
+
+  @Override protected void setUp() throws Exception {
+    values = distribution.create(length);
+    copy = new int[length];
+  }
+
+  public void timeSort(int reps) {
+    for (int i = 0; i < reps; i++) {
+      System.arraycopy(values, 0, copy, 0, values.length);
+      Arrays.sort(copy);
+    }
+  }
+
+  public enum Distribution {
+    SAWTOOTH {
+      @Override
+      int[] create(int length) {
+        int[] result = new int[length];
+        for (int i = 0; i < length; i += 5) {
+          result[i] = 0;
+          result[i + 1] = 1;
+          result[i + 2] = 2;
+          result[i + 3] = 3;
+          result[i + 4] = 4;
+        }
+        return result;
+      }
+    },
+    INCREASING {
+      @Override
+      int[] create(int length) {
+        int[] result = new int[length];
+        for (int i = 0; i < length; i++) {
+          result[i] = i;
+        }
+        return result;
+      }
+    },
+    DECREASING {
+      @Override
+      int[] create(int length) {
+        int[] result = new int[length];
+        for (int i = 0; i < length; i++) {
+          result[i] = length - i;
+        }
+        return result;
+      }
+    },
+    RANDOM {
+      @Override
+      int[] create(int length) {
+        Random random = new Random();
+        int[] result = new int[length];
+        for (int i = 0; i < length; i++) {
+          result[i] = random.nextInt();
+        }
+        return result;
+      }
+    };
+
+    abstract int[] create(int length);
+  }
+
+  public static void main(String[] args) throws Exception {
+    Runner.main(ArraySortBenchmark.class, args);
+  }
+}
diff --git a/examples/src/main/java/examples/BitSetBenchmark.java b/examples/src/main/java/examples/BitSetBenchmark.java
new file mode 100644
index 0000000..3154b01
--- /dev/null
+++ b/examples/src/main/java/examples/BitSetBenchmark.java
@@ -0,0 +1,186 @@
+/*
+ * Copyright (C) 2010 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package examples;
+
+import com.google.caliper.Runner;
+import com.google.caliper.SimpleBenchmark;
+import java.util.BitSet;
+import java.util.Random;
+
+/**
+ * A simple example of a benchmark for BitSet showing some of the issues with
+ * micro-benchmarking.
+ *
+ * <p>The following is a discussion of how the benchmarks evolved and what they
+ * may (or may not) tell us. This discussion is based on the following set of
+ * results:
+ *
+ * <p><pre>
+ *  0% Scenario{vm=java, benchmark=SetBitSetX64} 233.45ns; σ=0.31ns @ 3 trials
+ * 20% Scenario{vm=java, benchmark=SetMaskX64} 116.62ns; σ=0.09ns @ 3 trials
+ * 40% Scenario{vm=java, benchmark=CharsToBitSet} 748.40ns; σ=23.52ns @ 10 trials
+ * 60% Scenario{vm=java, benchmark=CharsToMask} 198.55ns; σ=9.46ns @ 10 trials
+ * 80% Scenario{vm=java, benchmark=BaselineIteration} 67.85ns; σ=0.44ns @ 3 trials
+ *
+ *         benchmark   ns logarithmic runtime
+ *      SetBitSetX64  233 XXXXXXXXX|||||||||||||||
+ *        SetMaskX64  117 XXXX|||||||||||||||||
+ *     CharsToBitSet  748 XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
+ *       CharsToMask  199 XXXXXXX||||||||||||||||
+ * BaselineIteration   68 XX|||||||||||||||||
+ * </pre>
+ *
+ * <p>Initially things look simple. The {@link #timeSetBitSetX64(int)} benchmark
+ * takes approximately twice as long as {@link #timeSetMaskX64(int)}. However
+ * the inner loops in these benchmarks have almost no content, so a more
+ * 'real world' benchmark was devised in an attempt to back up these results.
+ *
+ * <p>The {@link #timeCharsToMask(int)} and {@link #timeCharsToBitSet(int)}
+ * benchmarks convert a simple char[] of '1's and '0's to a corresponding BitSet
+ * or bit mask. These also processes 64 bits per iteration and so appears to be
+ * doing the same amount of work as the first benchmarks.
+ *
+ * <p>Additionally the {@link BitSetBenchmark#timeBaselineIteration(int)}
+ * benchmark attempts to measure the raw cost of looping through and reading the
+ * source data.
+ *
+ * <p>When comparing the benchmarks that use bit masking, we see that the
+ * measured time of the SetMaskX64 benchmark (117ns) is roughly the same
+ * as the CharsToMask benchmark (199ns) with the BaselineIteration time (68ms)
+ * subtracted from it. This gives us some confidence that both benchmarks are
+ * resulting in the same underlying work on the CPU.
+ *
+ * <p>However the CharsToBitSet and the SetBitSetX64 benchmarks differ very
+ * significantly (approximately 3x) even when accounting for the
+ * BaselineIteration result. This suggests that the performance of
+ * {@link BitSet#set} is quite dependent on the surrounding code and how
+ * it is optimized by the JVM.
+ *
+ * <p>The conclusions we can draw from this are:
+ *
+ * <p><b>1:</b> Using BitSet is slower than using bit masks directly. At best it
+ * seems about 2x slower than a bit mask, but could easily be 5x slower in real
+ * applications.
+ *
+ * <p>While these are only estimates, we can conclude that when performance is
+ * important and where bit set operations occur in tight loops, bit masks
+ * should be used in favor of BitSets.
+ *
+ * <p><b>2:</b>Overly simplistic benchmarks can give a very false impression of
+ * performance.
+ */
+public class BitSetBenchmark extends SimpleBenchmark {
+  private BitSet bitSet;
+  private char[] bitString;
+
+  @Override protected void setUp() throws Exception {
+    bitSet = new BitSet(64);
+    bitString = new char[64];
+    Random r = new Random();
+    for (int n = 0; n < 64; n++) {
+      bitString[n] = r.nextBoolean() ? '1' : '0';
+    }
+  }
+
+  /**
+   * This benchmark attempts to measure performance of {@link BitSet#set}.
+   */
+  public int timeSetBitSetX64(int reps) {
+    long count = 64L * reps;
+    for (int i = 0; i < count; i++) {
+      bitSet.set(i & 0x3F, true);
+    }
+    return bitSet.hashCode();
+  }
+
+  /**
+   * This benchmark attempts to measure performance of direct bit-manipulation.
+   */
+  public long timeSetMaskX64(int reps) {
+    long count = 64L * reps;
+    long bitMask = 0L;
+    for (int i = 0; i < count; i++) {
+      bitMask |= 1 << (i & 0x3F);
+    }
+    return bitMask;
+  }
+
+  /**
+   * This benchmark parses a char[] of 1's and 0's into a BitSet. Results from
+   * this benchmark should be comparable with those from
+   * {@link #timeCharsToMask(int)}.
+   */
+  public String timeCharsToBitSet(int reps) {
+    /*
+     * This benchmark now measures the complete parsing of a char[] rather than
+     * a single invocation of {@link BitSet#set}. However this fine because
+     * it is intended to be a comparative benchmark.
+     */
+    for (int i = 0; i < reps; i++) {
+      for (int n = 0; n < bitString.length; n++) {
+        bitSet.set(n, bitString[n] == '1');
+      }
+    }
+    return bitSet.toString();
+  }
+
+  /**
+   * This benchmark parses a char[] of 1's and 0's into a bit mask. Results from
+   * this benchmark should be comparable with those from
+   * {@link #timeCharsToBitSet(int)}.
+   */
+  public long timeCharsToMask(int reps) {
+    /*
+     * Comparing results we see a far more realistic sounding result whereby
+     * using a bit mask is a little over 4x faster than using BitSet.
+     */
+    long bitMask = 0;
+    for (int i = 0; i < reps; i++) {
+      for (int n = 0; n < bitString.length; n++) {
+        long m = 1 << n;
+        if (bitString[n] == '1') {
+          bitMask |= m;
+        } else {
+          bitMask &= ~m;
+        }
+      }
+    }
+    return bitMask;
+  }
+
+  /**
+   * This benchmark attempts to measure the baseline cost of both
+   * {@link #timeCharsToBitSet(int)} and {@link #timeCharsToMask(int)}.
+   * It does this by unconditionally summing the character values of the char[].
+   * This is as close to a no-op case as we can expect to get without unwanted
+   * over-optimization.
+   */
+  public long timeBaselineIteration(int reps) {
+    int badHash = 0;
+    for (int i = 0; i < reps; i++) {
+      for (int n = 0; n < bitString.length; n++) {
+        badHash += bitString[n];
+      }
+    }
+    return badHash;
+  }
+
+  // TODO: remove this from all examples when IDE plugins are ready
+  public static void main(String[] args) throws Exception {
+      Runner.main(BitSetBenchmark.class, args);
+  }
+}
diff --git a/examples/src/main/java/examples/CharacterBenchmark.java b/examples/src/main/java/examples/CharacterBenchmark.java
new file mode 100644
index 0000000..1e013af
--- /dev/null
+++ b/examples/src/main/java/examples/CharacterBenchmark.java
@@ -0,0 +1,300 @@
+/*
+ * Copyright (C) 2009 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package examples;
+
+import com.google.caliper.Param;
+import com.google.caliper.Runner;
+import com.google.caliper.SimpleBenchmark;
+
+/**
+ * Tests various Character methods, intended for testing multiple
+ * implementations against each other.
+ */
+public class CharacterBenchmark extends SimpleBenchmark {
+
+    @Param private CharacterSet characterSet;
+
+    @Param private Overload overload;
+
+    private char[] chars;
+
+    @Override protected void setUp() throws Exception {
+        this.chars = characterSet.chars;
+    }
+
+    public enum Overload { CHAR, INT }
+
+    public enum CharacterSet {
+        ASCII(128),
+        UNICODE(65536);
+        final char[] chars;
+        CharacterSet(int size) {
+            this.chars = new char[65536];
+            for (int i = 0; i < 65536; ++i) {
+                chars[i] = (char) (i % size);
+            }
+        }
+    }
+
+    // A fake benchmark to give us a baseline.
+    public boolean timeIsSpace(int reps) {
+        boolean dummy = false;
+        if (overload == Overload.CHAR) {
+            for (int i = 0; i < reps; ++i) {
+                for (int ch = 0; ch < 65536; ++ch) {
+                    dummy ^= ((char) ch == ' ');
+                }
+            }
+        } else {
+            for (int i = 0; i < reps; ++i) {
+                for (int ch = 0; ch < 65536; ++ch) {
+                    dummy ^= (ch == ' ');
+                }
+            }
+        }
+        return dummy;
+    }
+
+    public void timeDigit(int reps) {
+        if (overload == Overload.CHAR) {
+            for (int i = 0; i < reps; ++i) {
+                for (int ch = 0; ch < 65536; ++ch) {
+                    Character.digit(chars[ch], 10);
+                }
+            }
+        } else {
+            for (int i = 0; i < reps; ++i) {
+                for (int ch = 0; ch < 65536; ++ch) {
+                    Character.digit((int) chars[ch], 10);
+                }
+            }
+        }
+    }
+
+    public void timeGetNumericValue(int reps) {
+        if (overload == Overload.CHAR) {
+            for (int i = 0; i < reps; ++i) {
+                for (int ch = 0; ch < 65536; ++ch) {
+                    Character.getNumericValue(chars[ch]);
+                }
+            }
+        } else {
+            for (int i = 0; i < reps; ++i) {
+                for (int ch = 0; ch < 65536; ++ch) {
+                    Character.getNumericValue((int) chars[ch]);
+                }
+            }
+        }
+    }
+
+    public void timeIsDigit(int reps) {
+        if (overload == Overload.CHAR) {
+            for (int i = 0; i < reps; ++i) {
+                for (int ch = 0; ch < 65536; ++ch) {
+                    Character.isDigit(chars[ch]);
+                }
+            }
+        } else {
+            for (int i = 0; i < reps; ++i) {
+                for (int ch = 0; ch < 65536; ++ch) {
+                    Character.isDigit((int) chars[ch]);
+                }
+            }
+        }
+    }
+
+    public void timeIsIdentifierIgnorable(int reps) {
+        if (overload == Overload.CHAR) {
+            for (int i = 0; i < reps; ++i) {
+                for (int ch = 0; ch < 65536; ++ch) {
+                    Character.isIdentifierIgnorable(chars[ch]);
+                }
+            }
+        } else {
+            for (int i = 0; i < reps; ++i) {
+                for (int ch = 0; ch < 65536; ++ch) {
+                    Character.isIdentifierIgnorable((int) chars[ch]);
+                }
+            }
+        }
+    }
+
+    public void timeIsJavaIdentifierPart(int reps) {
+        if (overload == Overload.CHAR) {
+            for (int i = 0; i < reps; ++i) {
+                for (int ch = 0; ch < 65536; ++ch) {
+                    Character.isJavaIdentifierPart(chars[ch]);
+                }
+            }
+        } else {
+            for (int i = 0; i < reps; ++i) {
+                for (int ch = 0; ch < 65536; ++ch) {
+                    Character.isJavaIdentifierPart((int) chars[ch]);
+                }
+            }
+        }
+    }
+
+    public void timeIsJavaIdentifierStart(int reps) {
+        if (overload == Overload.CHAR) {
+            for (int i = 0; i < reps; ++i) {
+                for (int ch = 0; ch < 65536; ++ch) {
+                    Character.isJavaIdentifierStart(chars[ch]);
+                }
+            }
+        } else {
+            for (int i = 0; i < reps; ++i) {
+                for (int ch = 0; ch < 65536; ++ch) {
+                    Character.isJavaIdentifierStart((int) chars[ch]);
+                }
+            }
+        }
+    }
+
+    public void timeIsLetter(int reps) {
+        if (overload == Overload.CHAR) {
+            for (int i = 0; i < reps; ++i) {
+                for (int ch = 0; ch < 65536; ++ch) {
+                    Character.isLetter(chars[ch]);
+                }
+            }
+        } else {
+            for (int i = 0; i < reps; ++i) {
+                for (int ch = 0; ch < 65536; ++ch) {
+                    Character.isLetter((int) chars[ch]);
+                }
+            }
+        }
+    }
+
+    public void timeIsLetterOrDigit(int reps) {
+        if (overload == Overload.CHAR) {
+            for (int i = 0; i < reps; ++i) {
+                for (int ch = 0; ch < 65536; ++ch) {
+                    Character.isLetterOrDigit(chars[ch]);
+                }
+            }
+        } else {
+            for (int i = 0; i < reps; ++i) {
+                for (int ch = 0; ch < 65536; ++ch) {
+                    Character.isLetterOrDigit((int) chars[ch]);
+                }
+            }
+        }
+    }
+
+    public void timeIsLowerCase(int reps) {
+        if (overload == Overload.CHAR) {
+            for (int i = 0; i < reps; ++i) {
+                for (int ch = 0; ch < 65536; ++ch) {
+                    Character.isLowerCase(chars[ch]);
+                }
+            }
+        } else {
+            for (int i = 0; i < reps; ++i) {
+                for (int ch = 0; ch < 65536; ++ch) {
+                    Character.isLowerCase((int) chars[ch]);
+                }
+            }
+        }
+    }
+
+    public void timeIsSpaceChar(int reps) {
+        if (overload == Overload.CHAR) {
+            for (int i = 0; i < reps; ++i) {
+                for (int ch = 0; ch < 65536; ++ch) {
+                    Character.isSpaceChar(chars[ch]);
+                }
+            }
+        } else {
+            for (int i = 0; i < reps; ++i) {
+                for (int ch = 0; ch < 65536; ++ch) {
+                    Character.isSpaceChar((int) chars[ch]);
+                }
+            }
+        }
+    }
+
+    public void timeIsUpperCase(int reps) {
+        if (overload == Overload.CHAR) {
+            for (int i = 0; i < reps; ++i) {
+                for (int ch = 0; ch < 65536; ++ch) {
+                    Character.isUpperCase(chars[ch]);
+                }
+            }
+        } else {
+            for (int i = 0; i < reps; ++i) {
+                for (int ch = 0; ch < 65536; ++ch) {
+                    Character.isUpperCase((int) chars[ch]);
+                }
+            }
+        }
+    }
+
+    public void timeIsWhitespace(int reps) {
+        if (overload == Overload.CHAR) {
+            for (int i = 0; i < reps; ++i) {
+                for (int ch = 0; ch < 65536; ++ch) {
+                    Character.isWhitespace(chars[ch]);
+                }
+            }
+        } else {
+            for (int i = 0; i < reps; ++i) {
+                for (int ch = 0; ch < 65536; ++ch) {
+                    Character.isWhitespace((int) chars[ch]);
+                }
+            }
+        }
+    }
+
+    public void timeToLowerCase(int reps) {
+        if (overload == Overload.CHAR) {
+            for (int i = 0; i < reps; ++i) {
+                for (int ch = 0; ch < 65536; ++ch) {
+                    Character.toLowerCase(chars[ch]);
+                }
+            }
+        } else {
+            for (int i = 0; i < reps; ++i) {
+                for (int ch = 0; ch < 65536; ++ch) {
+                    Character.toLowerCase((int) chars[ch]);
+                }
+            }
+        }
+    }
+
+    public void timeToUpperCase(int reps) {
+        if (overload == Overload.CHAR) {
+            for (int i = 0; i < reps; ++i) {
+                for (int ch = 0; ch < 65536; ++ch) {
+                    Character.toUpperCase(chars[ch]);
+                }
+            }
+        } else {
+            for (int i = 0; i < reps; ++i) {
+                for (int ch = 0; ch < 65536; ++ch) {
+                    Character.toUpperCase((int) chars[ch]);
+                }
+            }
+        }
+    }
+
+    // TODO: remove this from all examples when IDE plugins are ready
+    public static void main(String[] args) throws Exception {
+        Runner.main(CharacterBenchmark.class, args);
+    }
+}
diff --git a/examples/src/main/java/examples/CompressionSizeBenchmark.java b/examples/src/main/java/examples/CompressionSizeBenchmark.java
new file mode 100644
index 0000000..90ddd39
--- /dev/null
+++ b/examples/src/main/java/examples/CompressionSizeBenchmark.java
@@ -0,0 +1,90 @@
+/*
+ * Copyright (C) 2010 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package examples;
+
+import com.google.caliper.Param;
+import com.google.caliper.api.Benchmark;
+import com.google.caliper.model.ArbitraryMeasurement;
+import com.google.caliper.runner.CaliperMain;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.zip.Deflater;
+
+/**
+ * Example "arbitrary measurement" benchmark.
+ */
+public class CompressionSizeBenchmark extends Benchmark {
+
+  @Param({
+      "this string will compress badly",
+      "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+      "asdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdf"})
+  private String toCompress;
+  @Param({"bestCompression", "bestSpeed", "noCompression", "huffmanOnly"})
+  private String compressionLevel;
+
+  private double compressionRatio;
+
+  public static final Map<String, Integer> compressionLevelMap = new HashMap<String, Integer>();
+  static {
+      compressionLevelMap.put("bestCompression", Deflater.BEST_COMPRESSION);
+      compressionLevelMap.put("bestSpeed", Deflater.BEST_SPEED);
+      compressionLevelMap.put("noCompression", Deflater.NO_COMPRESSION);
+      compressionLevelMap.put("huffmanOnly", Deflater.HUFFMAN_ONLY);
+  }
+
+  public long timeSimpleCompression(int reps) {
+    long dummy = 0;
+    for (int i = 0; i < reps; i++) {
+      dummy += compress(toCompress.getBytes()).length;
+    }
+    return dummy;
+  }
+
+  @ArbitraryMeasurement(units = ":1", description = "ratio of uncompressed to compressed")
+  public double compressionSize() {
+    byte[] initialBytes = toCompress.getBytes();
+    byte[] finalBytes = compress(initialBytes);
+    compressionRatio = (double) initialBytes.length / (double) finalBytes.length;
+    return compressionRatio;
+  }
+
+  private byte[] compress(byte[] bytes) {
+    Deflater compressor = new Deflater();
+    compressor.setLevel(compressionLevelMap.get(compressionLevel));
+    compressor.setInput(bytes);
+    compressor.finish();
+    ByteArrayOutputStream bos = new ByteArrayOutputStream();
+    byte[] buf = new byte[1024];
+    while (!compressor.finished()) {
+      int count = compressor.deflate(buf);
+      bos.write(buf, 0, count);
+    }
+    try {
+      bos.close();
+    } catch (IOException e) {
+    }
+    return bos.toByteArray();
+  }
+
+  public static void main(String[] args) {
+    CaliperMain.main(CompressionSizeBenchmark.class, args);
+  }
+}
diff --git a/examples/src/main/java/examples/ContainsBenchmark.java b/examples/src/main/java/examples/ContainsBenchmark.java
new file mode 100644
index 0000000..01bb8c6
--- /dev/null
+++ b/examples/src/main/java/examples/ContainsBenchmark.java
@@ -0,0 +1,78 @@
+/*
+ * Copyright (C) 2010 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package examples;
+
+import com.google.caliper.Param;
+import com.google.caliper.Runner;
+import com.google.caliper.SimpleBenchmark;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Random;
+import java.util.Set;
+
+public class ContainsBenchmark extends SimpleBenchmark {
+  @Param({"0", "25", "50", "75", "100"}) private int percentNulls;
+  @Param({"100", "1000", "10000"}) private int containsPerRep;
+
+  /** the set under test */
+  private final Set<String> set = new HashSet<String>();
+
+  /** twenty-five percent nulls */
+  private final List<Object> queries = new ArrayList<Object>();
+
+  @Override protected void setUp() {
+    set.addAll(Arrays.asList("str1", "str2", "str3", "str4"));
+    int nullThreshold = percentNulls * containsPerRep / 100;
+    for (int i = 0; i < nullThreshold; i++) {
+      queries.add(null);
+    }
+    for (int i = nullThreshold; i < containsPerRep; i++) {
+      queries.add(new Object());
+    }
+    Collections.shuffle(queries, new Random(0));
+  }
+
+  @Override public Map<String, Integer> getTimeUnitNames() {
+    Map<String, Integer> unitNames = new HashMap<String, Integer>();
+    unitNames.put("ns/contains", 1);
+    unitNames.put("us/contains", 1000);
+    unitNames.put("ms/contains", 1000000);
+    unitNames.put("s/contains", 1000000000);
+    return unitNames;
+  }
+
+  @Override public double nanosToUnits(double nanos) {
+    return nanos / containsPerRep;
+  }
+
+  public void timeContains(int reps) {
+    for (int i = 0; i < reps; i++) {
+      for (Object query : queries) {
+        set.contains(query);
+      }
+    }
+  }
+
+  public static void main(String[] args) {
+    Runner.main(ContainsBenchmark.class, args);
+  }
+}
diff --git a/examples/src/main/java/examples/CopyArrayBenchmark.java b/examples/src/main/java/examples/CopyArrayBenchmark.java
new file mode 100644
index 0000000..fed0950
--- /dev/null
+++ b/examples/src/main/java/examples/CopyArrayBenchmark.java
@@ -0,0 +1,356 @@
+/*
+ * Copyright (C) 2010 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package examples;
+
+import com.google.caliper.Param;
+import com.google.caliper.Runner;
+import com.google.caliper.SimpleBenchmark;
+
+import java.util.Arrays;
+import java.util.Random;
+
+/**
+ * Tests each of four ways to copy an array, for all nine array types.
+ *
+ * <p>Once upon a time, {@code clone} was much slower than the other array copy techniques, but
+ * that was fixed in Sun bug:
+ *
+ * <a href="http://bugs.sun.com/view_bug.do?bug_id=6428387">
+ * array clone() much slower than Arrays.copyOf</a>
+ *
+ * at which time all copy methods were equally efficient.
+ *
+ * <p>Recent (2011) measurements with OpenJDK 7 on Linux are less clear.  Results suggests that:
+ *
+ * <ul>
+ * <li>The different methods of copying have indistinguishable performance with hotspot server for
+ *     all nine types, except that the naive LOOP is slower.
+ *     With the "client" compiler, LOOP beats CLONE, which is the slowest.
+ * <li>As array sizes get large, the runtime is indeed proportional to the size of the array in
+ *     memory (boolean arrays count as byte arrays!).
+ * </ul>
+ */
+public class CopyArrayBenchmark extends SimpleBenchmark {
+  public enum Strategy {
+    CLONE {
+      @Override Object[] copy(Object[] array) {
+        return array.clone();
+      }
+      @Override boolean[] copy(boolean[] array) {
+        return array.clone();
+      }
+      @Override byte[] copy(byte[] array) {
+        return array.clone();
+      }
+      @Override char[] copy(char[] array) {
+        return array.clone();
+      }
+      @Override double[] copy(double[] array) {
+        return array.clone();
+      }
+      @Override float[] copy(float[] array) {
+        return array.clone();
+      }
+      @Override int[] copy(int[] array) {
+        return array.clone();
+      }
+      @Override long[] copy(long[] array) {
+        return array.clone();
+      }
+      @Override short[] copy(short[] array) {
+        return array.clone();
+      }
+    },
+    ARRAYS_COPYOF {
+      @Override Object[] copy(Object[] array) {
+        return Arrays.copyOf(array, array.length);
+      }
+      @Override boolean[] copy(boolean[] array) {
+        return Arrays.copyOf(array, array.length);
+      }
+      @Override byte[] copy(byte[] array) {
+        return Arrays.copyOf(array, array.length);
+      }
+      @Override char[] copy(char[] array) {
+        return Arrays.copyOf(array, array.length);
+      }
+      @Override double[] copy(double[] array) {
+        return Arrays.copyOf(array, array.length);
+      }
+      @Override float[] copy(float[] array) {
+        return Arrays.copyOf(array, array.length);
+      }
+      @Override int[] copy(int[] array) {
+        return Arrays.copyOf(array, array.length);
+      }
+      @Override long[] copy(long[] array) {
+        return Arrays.copyOf(array, array.length);
+      }
+      @Override short[] copy(short[] array) {
+        return Arrays.copyOf(array, array.length);
+      }
+    },
+    SYSTEM_ARRAYCOPY {
+      @Override Object[] copy(Object[] array) {
+        Object[] copy = new Object[array.length];
+        System.arraycopy(array, 0, copy, 0, array.length);
+        return copy;
+      }
+      @Override boolean[] copy(boolean[] array) {
+        boolean[] copy = new boolean[array.length];
+        System.arraycopy(array, 0, copy, 0, array.length);
+        return copy;
+      }
+      @Override byte[] copy(byte[] array) {
+        byte[] copy = new byte[array.length];
+        System.arraycopy(array, 0, copy, 0, array.length);
+        return copy;
+      }
+      @Override char[] copy(char[] array) {
+        char[] copy = new char[array.length];
+        System.arraycopy(array, 0, copy, 0, array.length);
+        return copy;
+      }
+      @Override double[] copy(double[] array) {
+        double[] copy = new double[array.length];
+        System.arraycopy(array, 0, copy, 0, array.length);
+        return copy;
+      }
+      @Override float[] copy(float[] array) {
+        float[] copy = new float[array.length];
+        System.arraycopy(array, 0, copy, 0, array.length);
+        return copy;
+      }
+      @Override int[] copy(int[] array) {
+        int[] copy = new int[array.length];
+        System.arraycopy(array, 0, copy, 0, array.length);
+        return copy;
+      }
+      @Override long[] copy(long[] array) {
+        long[] copy = new long[array.length];
+        System.arraycopy(array, 0, copy, 0, array.length);
+        return copy;
+      }
+      @Override short[] copy(short[] array) {
+        short[] copy = new short[array.length];
+        System.arraycopy(array, 0, copy, 0, array.length);
+        return copy;
+      }
+    },
+    LOOP {
+      @Override Object[] copy(Object[] array) {
+        int len = array.length;
+        Object[] copy = new Object[len];
+        for (int i = 0; i < len; i++) {
+          copy[i] = array[i];
+        }
+        return copy;
+      }
+      @Override boolean[] copy(boolean[] array) {
+        int len = array.length;
+        boolean[] copy = new boolean[array.length];
+        for (int i = 0; i < len; i++) {
+          copy[i] = array[i];
+        }
+        return copy;
+      }
+      @Override byte[] copy(byte[] array) {
+        int len = array.length;
+        byte[] copy = new byte[array.length];
+        for (int i = 0; i < len; i++) {
+          copy[i] = array[i];
+        }
+        return copy;
+      }
+      @Override char[] copy(char[] array) {
+        int len = array.length;
+        char[] copy = new char[array.length];
+        for (int i = 0; i < len; i++) {
+          copy[i] = array[i];
+        }
+        return copy;
+      }
+      @Override double[] copy(double[] array) {
+        int len = array.length;
+        double[] copy = new double[array.length];
+        for (int i = 0; i < len; i++) {
+          copy[i] = array[i];
+        }
+        return copy;
+      }
+      @Override float[] copy(float[] array) {
+        int len = array.length;
+        float[] copy = new float[array.length];
+        for (int i = 0; i < len; i++) {
+          copy[i] = array[i];
+        }
+        return copy;
+      }
+      @Override int[] copy(int[] array) {
+        int len = array.length;
+        int[] copy = new int[array.length];
+        for (int i = 0; i < len; i++) {
+          copy[i] = array[i];
+        }
+        return copy;
+      }
+      @Override long[] copy(long[] array) {
+        int len = array.length;
+        long[] copy = new long[array.length];
+        for (int i = 0; i < len; i++) {
+          copy[i] = array[i];
+        }
+        return copy;
+      }
+      @Override short[] copy(short[] array) {
+        int len = array.length;
+        short[] copy = new short[array.length];
+        for (int i = 0; i < len; i++) {
+          copy[i] = array[i];
+        }
+        return copy;
+      }
+    },
+    ;
+
+    abstract Object[] copy(Object[] array);
+    abstract boolean[] copy(boolean[] array);
+    abstract byte[] copy(byte[] array);
+    abstract char[] copy(char[] array);
+    abstract double[] copy(double[] array);
+    abstract float[] copy(float[] array);
+    abstract int[] copy(int[] array);
+    abstract long[] copy(long[] array);
+    abstract short[] copy(short[] array);
+  }
+
+  @Param Strategy strategy;
+
+  @Param({"5", "500", "50000"}) int size;
+
+  Object[] objectArray;
+  boolean[] booleanArray;
+  byte[] byteArray;
+  char[] charArray;
+  double[] doubleArray;
+  float[] floatArray;
+  int[] intArray;
+  long[] longArray;
+  short[] shortArray;
+
+  @Override protected void setUp() {
+    objectArray = new Object[size];
+    booleanArray = new boolean[size];
+    byteArray = new byte[size];
+    charArray = new char[size];
+    doubleArray = new double[size];
+    floatArray = new float[size];
+    intArray = new int[size];
+    longArray = new long[size];
+    shortArray = new short[size];
+
+    Random random = new Random();
+    for (int i = 0; i < size; i++) {
+      int num = random.nextInt();
+      objectArray[i] = new Object();
+      booleanArray[i] = num % 2 == 0;
+      byteArray[i] = (byte) num;
+      charArray[i] = (char) num;
+      doubleArray[i] = num;
+      floatArray[i] = (float) num;
+      intArray[i] = num;
+      longArray[i] = num;
+      shortArray[i] = (short) num;
+    }
+  }
+
+  public int timeObjects(int reps) {
+    int dummy = 0;
+    for (int i = 0; i < reps; i++) {
+      dummy += strategy.copy(objectArray).hashCode();
+    }
+    return dummy;
+  }
+
+  public int timeBooleans(int reps) {
+    int dummy = 0;
+    for (int i = 0; i < reps; i++) {
+      dummy += strategy.copy(booleanArray).hashCode();
+    }
+    return dummy;
+  }
+
+  public int timeBytes(int reps) {
+    int dummy = 0;
+    for (int i = 0; i < reps; i++) {
+      dummy += strategy.copy(byteArray).hashCode();
+    }
+    return dummy;
+  }
+
+  public int timeChars(int reps) {
+    int dummy = 0;
+    for (int i = 0; i < reps; i++) {
+      dummy += strategy.copy(charArray).hashCode();
+    }
+    return dummy;
+  }
+
+  public int timeDoubles(int reps) {
+    int dummy = 0;
+    for (int i = 0; i < reps; i++) {
+      dummy += strategy.copy(doubleArray).hashCode();
+    }
+    return dummy;
+  }
+
+  public int timeFloats(int reps) {
+    int dummy = 0;
+    for (int i = 0; i < reps; i++) {
+      dummy += strategy.copy(floatArray).hashCode();
+    }
+    return dummy;
+  }
+
+  public int timeInts(int reps) {
+    int dummy = 0;
+    for (int i = 0; i < reps; i++) {
+      dummy += strategy.copy(intArray).hashCode();
+    }
+    return dummy;
+  }
+
+  public int timeLongs(int reps) {
+    int dummy = 0;
+    for (int i = 0; i < reps; i++) {
+      dummy += strategy.copy(longArray).hashCode();
+    }
+    return dummy;
+  }
+
+  public int timeShorts(int reps) {
+    int dummy = 0;
+    for (int i = 0; i < reps; i++) {
+      dummy += strategy.copy(shortArray).hashCode();
+    }
+    return dummy;
+  }
+
+  public static void main(String[] args) {
+    Runner.main(CopyArrayBenchmark.class, args);
+  }
+}
diff --git a/examples/src/main/java/examples/DemoBenchmark.java b/examples/src/main/java/examples/DemoBenchmark.java
new file mode 100644
index 0000000..3b7e2dd
--- /dev/null
+++ b/examples/src/main/java/examples/DemoBenchmark.java
@@ -0,0 +1,74 @@
+/*
+ * Copyright (C) 2011 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package examples;
+
+import com.google.caliper.Param;
+import com.google.caliper.api.Benchmark;
+import com.google.caliper.api.SkipThisScenarioException;
+import com.google.caliper.api.VmParam;
+import com.google.caliper.runner.CaliperMain;
+import com.google.caliper.util.ShortDuration;
+
+import java.math.BigDecimal;
+
+public class DemoBenchmark extends Benchmark {
+  @Param({"abc", "def", "xyz"}) String string;
+  @Param({"1", "2"}) int number;
+  @Param Foo foo;
+
+  @Param({"0.00", "123.45"}) BigDecimal money;
+  @Param({"1ns", "2 minutes"}) ShortDuration duration;
+  @VmParam({"-Xmx32m", "-Xmx1g"}) String memoryMax;
+
+  enum Foo {
+    FOO, BAR, BAZ, QUX;
+  }
+
+  DemoBenchmark() {
+//    System.out.println("I should not do this.");
+  }
+
+  @Override protected void setUp() throws Exception {
+    if (string.equals("abc") && number == 1) {
+      throw new SkipThisScenarioException();
+    }
+  }
+
+  public int timeSomething(int reps) {
+    int dummy = 0;
+    for (int i = 0; i < reps; i++) {
+      dummy += i;
+    }
+    return dummy;
+  }
+
+  public int timeSomethingElse(int reps) {
+    int dummy = 0;
+    for (int i = 0; i < reps; i++) {
+      dummy -= i;
+    }
+    return dummy;
+  }
+
+  @Override protected void tearDown() throws Exception {
+//    System.out.println("Hey, I'm tearing up the joint.");
+  }
+
+  public static void main(String[] args) {
+    CaliperMain.main(DemoBenchmark.class, args);
+  }
+}
diff --git a/examples/src/main/java/examples/DoubleToStringBenchmark.java b/examples/src/main/java/examples/DoubleToStringBenchmark.java
new file mode 100644
index 0000000..291ec84
--- /dev/null
+++ b/examples/src/main/java/examples/DoubleToStringBenchmark.java
@@ -0,0 +1,107 @@
+/*
+ * Copyright (C) 2009 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package examples;
+
+import com.google.caliper.Param;
+import com.google.caliper.Runner;
+import com.google.caliper.SimpleBenchmark;
+
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * Measures the various ways the JDK converts doubles to strings.
+ */
+public class DoubleToStringBenchmark extends SimpleBenchmark {
+  @Param Method method;
+
+  public enum Method {
+    TO_STRING {
+      @Override String convert(double d) {
+        return ((Double) d).toString();
+      }
+      @Override String convert(Double d) {
+        return d.toString();
+      }
+    },
+    STRING_VALUE_OF {
+      @Override String convert(double d) {
+        return String.valueOf(d);
+      }
+      @Override String convert(Double d) {
+        return String.valueOf(d);
+      }
+    },
+    STRING_FORMAT {
+      @Override String convert(double d) {
+        return String.format("%f", d);
+      }
+      @Override String convert(Double d) {
+        return String.format("%f", d);
+      }
+    },
+    QUOTE_TRICK {
+      @Override String convert(double d) {
+        return "" + d;
+      }
+      @Override String convert(Double d) {
+        return "" + d;
+      }
+    },
+    ;
+
+    abstract String convert(double d);
+    abstract String convert(Double d);
+  }
+
+  enum Value {
+    Pi(Math.PI),
+    NegativeZero(-0.0),
+    NegativeInfinity(Double.NEGATIVE_INFINITY),
+    NaN(Double.NaN);
+
+    final double value;
+
+    Value(double value) {
+      this.value = value;
+    }
+  }
+
+  @Param Value value;
+
+  public int timePrimitive(int reps) {
+    double d = value.value;
+    int dummy = 0;
+    for (int i = 0; i < reps; i++) {
+      dummy += method.convert(d).length();
+    }
+    return dummy;
+  }
+
+  public int timeWrapper(int reps) {
+    Double d = value.value;
+    int dummy = 0;
+    for (int i = 0; i < reps; i++) {
+      dummy += method.convert(d).length();
+    }
+    return dummy;
+  }
+
+  public static void main(String[] args) throws Exception {
+    Runner.main(DoubleToStringBenchmark.class, args);
+  }
+}
diff --git a/examples/src/main/java/examples/DoubleToStringBenchmark2.java b/examples/src/main/java/examples/DoubleToStringBenchmark2.java
new file mode 100644
index 0000000..8e6c69a
--- /dev/null
+++ b/examples/src/main/java/examples/DoubleToStringBenchmark2.java
@@ -0,0 +1,111 @@
+/*
+ * Copyright (C) 2009 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package examples;
+
+import com.google.caliper.Param;
+import com.google.caliper.Runner;
+import com.google.caliper.SimpleBenchmark;
+
+/**
+ * Measures the various ways the JDK converts doubles to strings.
+ */
+public class DoubleToStringBenchmark2 extends SimpleBenchmark {
+  @Param boolean useWrapper;
+
+  enum Value {
+    Pi(Math.PI),
+    NegativeZero(-0.0),
+    NegativeInfinity(Double.NEGATIVE_INFINITY),
+    NaN(Double.NaN);
+
+    final double d;
+
+    Value(double d) {
+      this.d = d;
+    }
+  }
+
+  @Param Value value;
+
+  public int timeToString(int reps) {
+    int dummy = 0;
+    if (useWrapper) {
+      Double d = value.d;
+      for (int i = 0; i < reps; i++) {
+        dummy += d.toString().length();
+      }
+    } else {
+      double d = value.d;
+      for (int i = 0; i < reps; i++) {
+        dummy += ((Double) d).toString().length();
+      }
+    }
+    return dummy;
+  }
+
+  public int timeStringValueOf(int reps) {
+    int dummy = 0;
+    if (useWrapper) {
+      Double d = value.d;
+      for (int i = 0; i < reps; i++) {
+        dummy += String.valueOf(d).length();
+      }
+    } else {
+      double d = value.d;
+      for (int i = 0; i < reps; i++) {
+        dummy += String.valueOf(d).length();
+      }
+    }
+    return dummy;
+  }
+
+  public int timeStringFormat(int reps) {
+    int dummy = 0;
+    if (useWrapper) {
+      Double d = value.d;
+      for (int i = 0; i < reps; i++) {
+        dummy += String.format("%f", d).length();
+      }
+    } else {
+      double d = value.d;
+      for (int i = 0; i < reps; i++) {
+        dummy += String.format("%f", d).length();
+      }
+    }
+    return dummy;
+  }
+
+  public int timeQuoteTrick(int reps) {
+    int dummy = 0;
+    if (useWrapper) {
+      Double d = value.d;
+      for (int i = 0; i < reps; i++) {
+        dummy += ("" + d).length();
+      }
+    } else {
+      double d = value.d;
+      for (int i = 0; i < reps; i++) {
+        dummy += ("" + d).length();
+      }
+    }
+    return dummy;
+  }
+
+  public static void main(String[] args) throws Exception {
+    Runner.main(DoubleToStringBenchmark2.class, args);
+  }
+}
diff --git a/examples/src/main/java/examples/EnumSetContainsBenchmark.java b/examples/src/main/java/examples/EnumSetContainsBenchmark.java
new file mode 100644
index 0000000..b232514
--- /dev/null
+++ b/examples/src/main/java/examples/EnumSetContainsBenchmark.java
@@ -0,0 +1,92 @@
+/*
+ * Copyright (C) 2009 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package examples;
+
+import com.google.caliper.Param;
+import com.google.caliper.Runner;
+import com.google.caliper.SimpleBenchmark;
+import java.util.EnumSet;
+import java.util.Set;
+
+/**
+ * Measures EnumSet#contains().
+ */
+public class EnumSetContainsBenchmark extends SimpleBenchmark {
+
+  @Param private SetMaker setMaker;
+
+  public enum SetMaker {
+    ENUM_SET {
+      @Override Set<?> newSet() {
+        return EnumSet.allOf(RegularSize.class);
+      }
+      @Override Object[] testValues() {
+        return new Object[] { RegularSize.E1, RegularSize.E2, RegularSize.E20,
+            RegularSize.E39, RegularSize.E40, "A", LargeSize.E40, null };
+      }
+    },
+    LARGE_ENUM_SET {
+      @Override Set<?> newSet() {
+        return EnumSet.allOf(LargeSize.class);
+      }
+      @Override Object[] testValues() {
+        return new Object[] { LargeSize.E1, LargeSize.E63, LargeSize.E64,
+            LargeSize.E65, LargeSize.E140, "A", RegularSize.E40, null };
+      }
+    };
+
+    abstract Set<?> newSet();
+    abstract Object[] testValues();
+  }
+
+  private enum RegularSize {
+    E1, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11, E12, E13, E14, E15, E16, E17,
+    E18, E19, E20, E21, E22, E23, E24, E25, E26, E27, E28, E29, E30, E31, E32,
+    E33, E34, E35, E36, E37, E38, E39, E40,
+  }
+
+  private enum LargeSize {
+    E1, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11, E12, E13, E14, E15, E16, E17,
+    E18, E19, E20, E21, E22, E23, E24, E25, E26, E27, E28, E29, E30, E31, E32,
+    E33, E34, E35, E36, E37, E38, E39, E40, E41, E42, E43, E44, E45, E46, E47,
+    E48, E49, E50, E51, E52, E53, E54, E55, E56, E57, E58, E59, E60, E61, E62,
+    E63, E64, E65, E66, E67, E68, E69, E70, E71, E72, E73, E74, E75, E76, E77,
+    E78, E79, E80, E81, E82, E83, E84, E85, E86, E87, E88, E89, E90, E91, E92,
+    E93, E94, E95, E96, E97, E98, E99, E100, E101, E102, E103, E104, E105, E106,
+    E107, E108, E109, E110, E111, E112, E113, E114, E115, E116, E117, E118,
+    E119, E120, E121, E122, E123, E124, E125, E126, E127, E128, E129, E130,
+    E131, E132, E133, E134, E135, E136, E137, E138, E139, E140,
+  }
+
+  private Set<?> set;
+  private Object[] testValues;
+
+  @Override protected void setUp() {
+    this.set = setMaker.newSet();
+    this.testValues = setMaker.testValues();
+  }
+
+  public void timeContains(int reps) {
+    for (int i = 0; i < reps; i++) {
+      set.contains(testValues[i % testValues.length]);
+    }
+  }
+
+  public static void main(String[] args) throws Exception {
+    Runner.main(EnumSetContainsBenchmark.class, args);
+  }
+}
diff --git a/examples/src/main/java/examples/ExpensiveObjectsBenchmark.java b/examples/src/main/java/examples/ExpensiveObjectsBenchmark.java
new file mode 100644
index 0000000..a11b1bd
--- /dev/null
+++ b/examples/src/main/java/examples/ExpensiveObjectsBenchmark.java
@@ -0,0 +1,76 @@
+/*
+ * Copyright (C) 2009 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package examples;
+
+import com.google.caliper.SimpleBenchmark;
+import com.google.caliper.runner.CaliperMain;
+
+import java.text.DecimalFormatSymbols;
+import java.text.NumberFormat;
+import java.text.SimpleDateFormat;
+import java.util.Locale;
+
+/**
+ * Benchmarks creation and cloning various expensive objects.
+ */
+@SuppressWarnings({"ResultOfObjectAllocationIgnored"}) // TODO: should fix!
+public class ExpensiveObjectsBenchmark extends SimpleBenchmark {
+  public void timeNewDecimalFormatSymbols(int reps) {
+    for (int i = 0; i < reps; ++i) {
+      new DecimalFormatSymbols(Locale.US);
+    }
+  }
+
+  public void timeClonedDecimalFormatSymbols(int reps) {
+    DecimalFormatSymbols dfs = new DecimalFormatSymbols(Locale.US);
+    for (int i = 0; i < reps; ++i) {
+      dfs.clone();
+    }
+  }
+
+  public void timeNewNumberFormat(int reps) {
+    for (int i = 0; i < reps; ++i) {
+      NumberFormat.getInstance(Locale.US);
+    }
+  }
+
+  public void timeClonedNumberFormat(int reps) {
+    NumberFormat nf = NumberFormat.getInstance(Locale.US);
+    for (int i = 0; i < reps; ++i) {
+      nf.clone();
+    }
+  }
+
+  public void timeNewSimpleDateFormat(int reps) {
+    for (int i = 0; i < reps; ++i) {
+      new SimpleDateFormat();
+    }
+  }
+
+  public void timeClonedSimpleDateFormat(int reps) {
+    SimpleDateFormat sdf = new SimpleDateFormat();
+    for (int i = 0; i < reps; ++i) {
+      sdf.clone();
+    }
+  }
+
+  // TODO: remove this from all examples when IDE plugins are ready
+  public static void main(String[] args) throws Exception {
+    CaliperMain.main(ExpensiveObjectsBenchmark.class, args);
+//    Runner.main(ExpensiveObjectsBenchmark.class, args);
+  }
+}
diff --git a/examples/src/main/java/examples/FormatterBenchmark.java b/examples/src/main/java/examples/FormatterBenchmark.java
new file mode 100644
index 0000000..b4a0541
--- /dev/null
+++ b/examples/src/main/java/examples/FormatterBenchmark.java
@@ -0,0 +1,76 @@
+/*
+ * Copyright (C) 2009 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package examples;
+
+import com.google.caliper.Runner;
+import com.google.caliper.SimpleBenchmark;
+import java.util.Formatter;
+
+/**
+ * Compares Formatter against hand-written StringBuilder code.
+ */
+public class FormatterBenchmark extends SimpleBenchmark {
+  public void timeFormatter_NoFormatting(int reps) {
+    for (int i = 0; i < reps; i++) {
+      Formatter f = new Formatter();
+      f.format("this is a reasonably short string that doesn't actually need any formatting");
+    }
+  }
+
+  public void timeStringBuilder_NoFormatting(int reps) {
+    for (int i = 0; i < reps; i++) {
+      StringBuilder sb = new StringBuilder();
+      sb.append("this is a reasonably short string that doesn't actually need any formatting");
+    }
+  }
+
+  public void timeFormatter_OneInt(int reps) {
+    for (int i = 0; i < reps; i++) {
+      Formatter f = new Formatter();
+      f.format("this is a reasonably short string that has an int %d in it", i);
+    }
+  }
+
+  public void timeStringBuilder_OneInt(int reps) {
+    for (int i = 0; i < reps; i++) {
+      StringBuilder sb = new StringBuilder();
+      sb.append("this is a reasonably short string that has an int ");
+      sb.append(i);
+      sb.append(" in it");
+    }
+  }
+
+  public void timeFormatter_OneString(int reps) {
+    for (int i = 0; i < reps; i++) {
+      Formatter f = new Formatter();
+      f.format("this is a reasonably short string that has a string %s in it", "hello");
+    }
+  }
+
+  public void timeStringBuilder_OneString(int reps) {
+    for (int i = 0; i < reps; i++) {
+      StringBuilder sb = new StringBuilder();
+      sb.append("this is a reasonably short string that has a string ");
+      sb.append("hello");
+      sb.append(" in it");
+    }
+  }
+
+  public static void main(String[] args) throws Exception {
+    Runner.main(FormatterBenchmark.class, args);
+  }
+}
diff --git a/examples/src/main/java/examples/IntModBenchmark.java b/examples/src/main/java/examples/IntModBenchmark.java
new file mode 100644
index 0000000..55a119c
--- /dev/null
+++ b/examples/src/main/java/examples/IntModBenchmark.java
@@ -0,0 +1,94 @@
+/*
+ * Copyright (C) 2009 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package examples;
+
+import com.google.caliper.Runner;
+import com.google.caliper.SimpleBenchmark;
+
+/**
+ * Measures several candidate implementations for mod().
+ */
+@SuppressWarnings("SameParameterValue")
+public class IntModBenchmark extends SimpleBenchmark {
+  private static final int M = (1 << 16) - 1;
+
+  public int timeConditional(int reps) {
+    int dummy = 5;
+    for (int i = 0; i < reps; i++) {
+      dummy += Integer.MAX_VALUE + conditionalMod(dummy, M);
+    }
+    return dummy;
+  }
+
+  private static int conditionalMod(int a, int m) {
+    int r = a % m;
+    return r < 0 ? r + m : r;
+  }
+
+  public int timeDoubleRemainder(int reps) {
+    int dummy = 5;
+    for (int i = 0; i < reps; i++) {
+      dummy += Integer.MAX_VALUE + doubleRemainderMod(dummy, M);
+    }
+    return dummy;
+  }
+
+  @SuppressWarnings("NumericCastThatLosesPrecision") // result of % by an int must be in int range
+  private static int doubleRemainderMod(int a, int m) {
+    return (int) ((a % m + (long) m) % m);
+  }
+
+  public int timeRightShiftingMod(int reps) {
+    int dummy = 5;
+    for (int i = 0; i < reps; i++) {
+      dummy += Integer.MAX_VALUE + rightShiftingMod(dummy, M);
+    }
+    return dummy;
+  }
+
+  @SuppressWarnings("NumericCastThatLosesPrecision") // must be in int range
+  private static int rightShiftingMod(int a, int m) {
+     long r = a % m;
+     return (int) (r + (r >> 63 & m));
+  }
+
+  public int timeLeftShiftingMod(int reps) {
+    int dummy = 5;
+    for (int i = 0; i < reps; i++) {
+      dummy += Integer.MAX_VALUE + leftShiftingMod(dummy, M);
+    }
+    return dummy;
+  }
+
+  @SuppressWarnings("NumericCastThatLosesPrecision") // result of % by an int must be in int range
+  private static int leftShiftingMod(int a, int m) {
+    return (int) ((a + ((long) m << 32)) % m);
+  }
+
+  public int timeWrongMod(int reps) {
+    int dummy = 5;
+    for (int i = 0; i < reps; i++) {
+      dummy += Integer.MAX_VALUE + dummy % M;
+    }
+    return dummy;
+  }
+
+  // TODO: remove this from all examples when IDE plugins are ready
+  public static void main(String[] args) throws Exception {
+    Runner.main(IntModBenchmark.class, args);
+  }
+}
\ No newline at end of file
diff --git a/examples/src/main/java/examples/ListIterationBenchmark.java b/examples/src/main/java/examples/ListIterationBenchmark.java
new file mode 100644
index 0000000..a8cfb05
--- /dev/null
+++ b/examples/src/main/java/examples/ListIterationBenchmark.java
@@ -0,0 +1,73 @@
+/*
+ * Copyright (C) 2009 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package examples;
+
+import com.google.caliper.Param;
+import com.google.caliper.Runner;
+import com.google.caliper.SimpleBenchmark;
+import java.util.AbstractList;
+import java.util.List;
+
+/**
+ * Measures iterating through list elements.
+ */
+public class ListIterationBenchmark extends SimpleBenchmark {
+
+  @Param({"0", "10", "100", "1000"})
+  private int length;
+
+  private List<Object> list;
+  private Object[] array;
+
+  @Override protected void setUp() {
+    array = new Object[length];
+    for (int i = 0; i < length; i++) {
+      array[i] = new Object();
+    }
+
+    list = new AbstractList<Object>() {
+      @Override public int size() {
+        return length;
+      }
+
+      @Override public Object get(int i) {
+        return array[i];
+      }
+    };
+  }
+
+  @SuppressWarnings({"UnusedDeclaration"}) // TODO: fix
+  public void timeListIteration(int reps) {
+    for (int i = 0; i < reps; i++) {
+      for (Object value : list) {
+      }
+    }
+  }
+
+  @SuppressWarnings({"UnusedDeclaration"}) // TODO: fix
+  public void timeArrayIteration(int reps) {
+    for (int i = 0; i < reps; i++) {
+      for (Object value : array) {
+      }
+    }
+  }
+
+  // TODO: remove this from all examples when IDE plugins are ready
+  public static void main(String[] args) throws Exception {
+    Runner.main(ListIterationBenchmark.class, args);
+  }
+}
\ No newline at end of file
diff --git a/examples/src/main/java/examples/LoopingBackwardsBenchmark.java b/examples/src/main/java/examples/LoopingBackwardsBenchmark.java
new file mode 100644
index 0000000..1e3d1ad
--- /dev/null
+++ b/examples/src/main/java/examples/LoopingBackwardsBenchmark.java
@@ -0,0 +1,52 @@
+/*
+ * Copyright (C) 2010 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package examples;
+
+import com.google.caliper.Param;
+import com.google.caliper.Runner;
+import com.google.caliper.SimpleBenchmark;
+
+/**
+ * Testing the old canard that looping backwards is faster.
+ */
+public class LoopingBackwardsBenchmark extends SimpleBenchmark {
+  @Param({"2", "20", "2000", "20000000"}) int max;
+
+  public int timeForwards(int reps) {
+    int dummy = 0;
+    for (int i = 0; i < reps; i++) {
+      for (int j = 0; j < max; j++) {
+        dummy += j;
+      }
+    }
+    return dummy;
+  }
+
+  public int timeBackwards(int reps) {
+    int dummy = 0;
+    for (int i = 0; i < reps; i++) {
+      for (int j = max - 1; j >= 0; j--) {
+        dummy += j;
+      }
+    }
+    return dummy;
+  }
+
+  public static void main(String[] args) throws Exception {
+    Runner.main(LoopingBackwardsBenchmark.class, args);
+  }
+}
diff --git a/examples/src/main/java/examples/MessageDigestCreationBenchmark.java b/examples/src/main/java/examples/MessageDigestCreationBenchmark.java
new file mode 100644
index 0000000..c9437bd
--- /dev/null
+++ b/examples/src/main/java/examples/MessageDigestCreationBenchmark.java
@@ -0,0 +1,44 @@
+/*
+ * Copyright (C) 2010 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package examples;
+
+import com.google.caliper.Param;
+import com.google.caliper.Runner;
+import com.google.caliper.SimpleBenchmark;
+
+import java.security.MessageDigest;
+
+/**
+ * Times creating new MessageDigest instances.
+ */
+public class MessageDigestCreationBenchmark extends SimpleBenchmark {
+  // By default, just the "interesting ones". Also consider Adler32 and CRC32,
+  // but these are not guaranteed to be supported in all runtime environments.
+  @Param({"MD5", "SHA-1", "SHA-256", "SHA-512"})
+  String algorithm;
+
+  public void time(int reps) throws Exception {
+    // Change this to use a dummy if the results look suspicious.
+    for (int i = 0; i < reps; i++) {
+      MessageDigest.getInstance(algorithm);
+    }
+  }
+
+  public static void main(String[] args) throws Exception {
+    Runner.main(MessageDigestCreationBenchmark.class, args);
+  }
+}
diff --git a/examples/src/main/java/examples/StringBuilderBenchmark.java b/examples/src/main/java/examples/StringBuilderBenchmark.java
new file mode 100644
index 0000000..3c839d3
--- /dev/null
+++ b/examples/src/main/java/examples/StringBuilderBenchmark.java
@@ -0,0 +1,132 @@
+/*
+ * Copyright (C) 2009 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package examples;
+
+import com.google.caliper.Param;
+import com.google.caliper.Runner;
+import com.google.caliper.SimpleBenchmark;
+
+/**
+ * Tests the performance of various StringBuilder methods.
+ */
+public class StringBuilderBenchmark extends SimpleBenchmark {
+
+    @Param({"1", "10", "100"}) private int length;
+
+    public void timeAppendBoolean(int reps) {
+        for (int i = 0; i < reps; ++i) {
+            StringBuilder sb = new StringBuilder();
+            for (int j = 0; j < length; ++j) {
+                sb.append(true);
+            }
+        }
+    }
+
+    public void timeAppendChar(int reps) {
+        for (int i = 0; i < reps; ++i) {
+            StringBuilder sb = new StringBuilder();
+            for (int j = 0; j < length; ++j) {
+                sb.append('c');
+            }
+        }
+    }
+
+    public void timeAppendCharArray(int reps) {
+        char[] chars = "chars".toCharArray();
+        for (int i = 0; i < reps; ++i) {
+            StringBuilder sb = new StringBuilder();
+            for (int j = 0; j < length; ++j) {
+                sb.append(chars);
+            }
+        }
+    }
+
+    public void timeAppendCharSequence(int reps) {
+        CharSequence cs = "chars";
+        for (int i = 0; i < reps; ++i) {
+            StringBuilder sb = new StringBuilder();
+            for (int j = 0; j < length; ++j) {
+                sb.append(cs);
+            }
+        }
+    }
+
+    public void timeAppendDouble(int reps) {
+        double d = 1.2;
+        for (int i = 0; i < reps; ++i) {
+            StringBuilder sb = new StringBuilder();
+            for (int j = 0; j < length; ++j) {
+                sb.append(d);
+            }
+        }
+    }
+
+    public void timeAppendFloat(int reps) {
+        float f = 1.2f;
+        for (int i = 0; i < reps; ++i) {
+            StringBuilder sb = new StringBuilder();
+            for (int j = 0; j < length; ++j) {
+                sb.append(f);
+            }
+        }
+    }
+
+    public void timeAppendInt(int reps) {
+        int n = 123;
+        for (int i = 0; i < reps; ++i) {
+            StringBuilder sb = new StringBuilder();
+            for (int j = 0; j < length; ++j) {
+                sb.append(n);
+            }
+        }
+    }
+
+    public void timeAppendLong(int reps) {
+        long l = 123;
+        for (int i = 0; i < reps; ++i) {
+            StringBuilder sb = new StringBuilder();
+            for (int j = 0; j < length; ++j) {
+                sb.append(l);
+            }
+        }
+    }
+
+    public void timeAppendObject(int reps) {
+        Object o = new Object();
+        for (int i = 0; i < reps; ++i) {
+            StringBuilder sb = new StringBuilder();
+            for (int j = 0; j < length; ++j) {
+                sb.append(o);
+            }
+        }
+    }
+
+    public void timeAppendString(int reps) {
+        String s = "chars";
+        for (int i = 0; i < reps; ++i) {
+            StringBuilder sb = new StringBuilder();
+            for (int j = 0; j < length; ++j) {
+                sb.append(s);
+            }
+        }
+    }
+
+    // TODO: remove this from all examples when IDE plugins are ready
+    public static void main(String[] args) throws Exception {
+        Runner.main(StringBuilderBenchmark.class, args);
+    }
+}
diff --git a/lib/gson-1.7.1.jar b/lib/gson-1.7.1.jar
new file mode 100644
index 0000000..eb54274
--- /dev/null
+++ b/lib/gson-1.7.1.jar
diff --git a/lib/java-allocation-instrumenter-2.0.jar b/lib/java-allocation-instrumenter-2.0.jar
new file mode 100644
index 0000000..8ea4193
--- /dev/null
+++ b/lib/java-allocation-instrumenter-2.0.jar
diff --git a/scripts/caliper b/scripts/caliper
new file mode 100644
index 0000000..a25caf1
--- /dev/null
+++ b/scripts/caliper
@@ -0,0 +1,9 @@
+#!/bin/sh
+
+# rough
+
+export PATH=$PATH:$JAVA_HOME/bin
+base=`dirname $0`
+export ALLOCATION_JAR=$base/lib/allocation.jar
+exec java -cp $base/lib/caliper-@VERSION@.jar:$ALLOCATION_JAR:$CLASSPATH com.google.caliper.Runner $*
+
diff --git a/tutorial/Tutorial.java b/tutorial/Tutorial.java
new file mode 100644
index 0000000..625d387
--- /dev/null
+++ b/tutorial/Tutorial.java
@@ -0,0 +1,187 @@
+/*
+ * Copyright (C) 2009 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package tutorial;
+
+import com.google.caliper.Param;
+import com.google.caliper.SimpleBenchmark;
+
+/**
+ * Caliper tutorial. To run the example benchmarks in this file:
+ * {@code CLASSPATH=... [caliper_home]/caliper tutorial.Tutorial.Benchmark1}
+ */
+public class Tutorial {
+
+  /*
+   * We begin the Caliper tutorial with the simplest benchmark you can write.
+   * We'd like to know how efficient the method System.nanoTime() is.
+   *
+   * Notice:
+   *
+   *  - We write a class that extends com.google.caliper.SimpleBenchmark.
+   *  - It contains a public instance method whose name begins with 'time' and
+   *    which accepts a single 'int reps' parameter.
+   *  - The body of the method simply executes the code we wish to measure,
+   *    'reps' times.
+   *
+   * Example run:
+   *
+   *    $ CLASSPATH=build/classes/test caliper tutorial.Tutorial.Benchmark1
+   *    [real-time results appear on this line]
+   *
+   *    Summary report for tutorial.Tutorial$Benchmark1:
+   *
+   *    Benchmark   ns
+   *    ---------  ---
+   *    NanoTime   233
+   */
+  public static class Benchmark1 extends SimpleBenchmark {
+    public void timeNanoTime(int reps) {
+      for (int i = 0; i < reps; i++) {
+        System.nanoTime();
+      }
+    }
+  }
+
+  /*
+   * Now let's compare two things: nanoTime() versus currentTimeMillis().
+   * Notice:
+   *
+   *  - We simply add another method, following the same rules as the first.
+   *
+   * Example run output:
+   *
+   *   Benchmark           ns
+   *   -----------------  ---
+   *   NanoTime           248
+   *   CurrentTimeMillis  118
+   */
+  public static class Benchmark2 extends SimpleBenchmark {
+    public void timeNanoTime(int reps) {
+      for (int i = 0; i < reps; i++) {
+        System.nanoTime();
+      }
+    }
+    public void timeCurrentTimeMillis(int reps) {
+      for (int i = 0; i < reps; i++) {
+        System.currentTimeMillis();
+      }
+    }
+  }
+
+  /*
+   * Let's try iterating over a large array. This seems simple enough, but
+   * there is a problem!
+   */
+  public static class Benchmark3 extends SimpleBenchmark {
+    private final int[] array = new int[1000000];
+
+    @SuppressWarnings("UnusedDeclaration") // IDEA tries to warn us!
+    public void timeArrayIteration_BAD(int reps) {
+      for (int i = 0; i < reps; i++) {
+        for (int ignoreMe : array) {}
+      }
+    }
+  }
+
+  /*
+   * Caliper reported that the benchmark above ran in 4 nanoseconds.
+   *
+   * Wait, what?
+   *
+   * How can it possibly iterate over a million zeroes in 4 ns!?
+   *
+   * It is very important to sanity-check benchmark results with common sense!
+   * In this case, we're indeed getting a bogus result. The problem is that the
+   * Java Virtual Machine is too smart: it detected the fact that the loop was
+   * producing no actual result, so it simply compiled it right out. The method
+   * never looped at all. To fix this, we need to use a dummy result value.
+   *
+   * Notice:
+   *
+   *  - We simply change the 'time' method from 'void' to any return type we
+   *    wish. Then we return a value that can't be known without actually
+   *    performing the work, and thus we defeat the runtime optimizations.
+   *  - We're no longer timing *just* the code we want to be testing - our
+   *    result will now be inflated by the (small) cost of addition. This is an
+   *    unfortunate fact of life with microbenchmarking. In fact, we were
+   *    already inflated by the cost of an int comparison, "i < reps" as it was.
+   *
+   * With this change, Caliper should report a much more realistic value, more
+   * on the order of an entire millisecond.
+   */
+  public static class Benchmark4 extends SimpleBenchmark {
+    private final int[] array = new int[1000000];
+
+    public int timeArrayIteration_fixed(int reps) {
+      int dummy = 0;
+      for (int i = 0; i < reps; i++) {
+        for (int doNotIgnoreMe : array) {
+          dummy += doNotIgnoreMe;
+        }
+      }
+      return dummy; // framework ignores this, but it has served its purpose!
+    }
+  }
+
+  /*
+   * Now we'd like to know how various other *sizes* of arrays perform. We
+   * don't want to have to cut and paste the whole benchmark just to provide a
+   * different size. What we need is a parameter!
+   *
+   * When you run this benchmark the same way you ran the previous ones, you'll
+   * now get an error: "No values provided for benchmark parameter 'size'".
+   * You can provide the value requested at the command line like this:
+   *
+   *   [caliper_home]/caliper tutorial.Tutorial.Benchmark5 -Dsize=100}
+   *
+   * You'll see output like this:
+   *
+   *   Benchmark       size   ns
+   *   --------------  ----  ---
+   *   ArrayIteration   100   51
+   *
+   * Now that we've parameterized our benchmark, things are starting to get fun.
+   * Try passing '-Dsize=10,100,1000' and see what happens!
+   *
+   *   Benchmark       size   ns
+   *   --------------  ----  -----------------------------------
+   *   ArrayIteration    10    7 |
+   *   ArrayIteration   100   49 ||||
+   *   ArrayIteration  1000  477 ||||||||||||||||||||||||||||||
+   *
+   */
+  public static class Benchmark5 extends SimpleBenchmark {
+    @Param int size; // set automatically by framework
+
+    private int[] array; // set by us, in setUp()
+
+    @Override protected void setUp() {
+      // @Param values are guaranteed to have been injected by now
+      array = new int[size];
+    }
+
+    public int timeArrayIteration(int reps) {
+      int dummy = 0;
+      for (int i = 0; i < reps; i++) {
+        for (int doNotIgnoreMe : array) {
+          dummy += doNotIgnoreMe;
+        }
+      }
+      return dummy;
+    }
+  }
+}