Fix benchmarks

Benchmarks have been in a state of disarray, fix them up:
- use yang-test-utils
- properly ready modifications
- upgrade JMH to 1.21

Change-Id: I8fa90cdde3b56664935685ad62452bb7c272cf3d
Signed-off-by: Robert Varga <robert.varga@pantheon.tech>

diff --git a/benchmarks/pom.xml b/benchmarks/pom.xml
index b9878d85b8b808cf08b3815d441749618fa0a115..898c0833cb04016449223ab292f499d17357462f 100644 (file)
--- a/benchmarks/pom.xml
+++ b/benchmarks/pom.xml
@@ -28,47 +28,56 @@
         </dependency>
         <dependency>
             <groupId>${project.groupId}</groupId>
-            <artifactId>yang-parser-impl</artifactId>
+            <artifactId>yang-test-util</artifactId>
             <version>2.0.5-SNAPSHOT</version>
+            <scope>compile</scope>
         </dependency>
         <dependency>
             <groupId>org.openjdk.jmh</groupId>
             <artifactId>jmh-core</artifactId>
-            <version>1.19</version>
+            <version>1.21</version>
         </dependency>
         <dependency>
             <groupId>org.openjdk.jmh</groupId>
             <artifactId>jmh-generator-annprocess</artifactId>
-            <version>1.19</version>
+            <version>1.21</version>
         </dependency>
     </dependencies>
 
-    <build>
-        <plugins>
-            <plugin>
-                <groupId>org.codehaus.mojo</groupId>
-                <artifactId>exec-maven-plugin</artifactId>
-                <configuration>
-                    <classpathScope>test</classpathScope>
-                    <executable>java</executable>
-                    <arguments>
-                        <argument>-classpath</argument>
-                        <classpath/>
-                        <argument>org.openjdk.jmh.Main</argument>
-                        <argument>.*</argument>
-                    </arguments>
-                </configuration>
-                <executions>
-                    <execution>
-                        <id>run-benchmarks</id>
-                        <phase>integration-test</phase>
-                        <goals>
-                            <goal>exec</goal>
-                        </goals>
-                    </execution>
-                </executions>
-            </plugin>
-        </plugins>
-    </build>
-
+    <profiles>
+        <profile>
+            <activation>
+                <property>
+                    <name>benchmarks</name>
+                </property>
+            </activation>
+            <build>
+                <plugins>
+                    <plugin>
+                        <groupId>org.codehaus.mojo</groupId>
+                        <artifactId>exec-maven-plugin</artifactId>
+                        <configuration>
+                            <classpathScope>test</classpathScope>
+                            <executable>java</executable>
+                            <arguments>
+                                <argument>-classpath</argument>
+                                <classpath/>
+                                <argument>org.openjdk.jmh.Main</argument>
+                                <argument>.*</argument>
+                            </arguments>
+                        </configuration>
+                        <executions>
+                            <execution>
+                                <id>run-benchmarks</id>
+                                <phase>integration-test</phase>
+                                <goals>
+                                    <goal>exec</goal>
+                                </goals>
+                            </execution>
+                        </executions>
+                    </plugin>
+                </plugins>
+            </build>
+        </profile>
+    </profiles>
 </project>

diff --git a/benchmarks/src/main/java/org/opendaylight/yangtools/yang/data/impl/tree/BenchmarkModel.java b/benchmarks/src/main/java/org/opendaylight/yangtools/yang/data/impl/tree/BenchmarkModel.java
index 9f6305a54677d57b0a0dbb45fbf7e7a639fc908a..af9bf73349e1469f73ee3c1b591fb61a8731bb06 100644 (file)
--- a/benchmarks/src/main/java/org/opendaylight/yangtools/yang/data/impl/tree/BenchmarkModel.java
+++ b/benchmarks/src/main/java/org/opendaylight/yangtools/yang/data/impl/tree/BenchmarkModel.java
@@ -7,43 +7,38 @@
  */
 package org.opendaylight.yangtools.yang.data.impl.tree;
 
-import java.io.IOException;
 import org.opendaylight.yangtools.yang.common.QName;
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
-import org.opendaylight.yangtools.yang.model.parser.api.YangSyntaxErrorException;
-import org.opendaylight.yangtools.yang.model.repo.api.YangTextSchemaSource;
-import org.opendaylight.yangtools.yang.parser.rfc6020.repo.YangStatementStreamSource;
-import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
-import org.opendaylight.yangtools.yang.parser.stmt.reactor.CrossSourceStatementReactor;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.YangInferencePipeline;
+import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
 
 /**
  * @author Lukas Sedlak <lsedlak@cisco.com>
  */
-public class BenchmarkModel {
-
-    public static final QName TEST_QNAME =
-            QName.create("urn:opendaylight:params:xml:ns:yang:controller:md:sal:dom:store:test", "2014-03-13", "test");
-    public static final QName OUTER_LIST_QNAME = QName.create(TEST_QNAME, "outer-list");
-    public static final QName INNER_LIST_QNAME = QName.create(TEST_QNAME, "inner-list");
-    public static final QName OUTER_CHOICE_QNAME = QName.create(TEST_QNAME, "outer-choice");
-    public static final QName ID_QNAME = QName.create(TEST_QNAME, "id");
-    public static final QName NAME_QNAME = QName.create(TEST_QNAME, "name");
-    public static final QName VALUE_QNAME = QName.create(TEST_QNAME, "value");
-
-    public static final YangInstanceIdentifier TEST_PATH = YangInstanceIdentifier.of(TEST_QNAME);
-    public static final YangInstanceIdentifier OUTER_LIST_PATH = YangInstanceIdentifier.builder(TEST_PATH)
-            .node(OUTER_LIST_QNAME).build();
-
-    public static SchemaContext createTestContext() {
-        CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
-        try {
-            reactor.addSource(YangStatementStreamSource.create(
-                YangTextSchemaSource.forResource("/odl-datastore-test.yang")));
-            return reactor.buildEffective();
-        } catch (IOException | YangSyntaxErrorException | ReactorException e) {
-            throw new IllegalStateException(e);
-        }
+final class BenchmarkModel {
+    private static final QName TEST_QNAME = QName.create(
+        "urn:opendaylight:params:xml:ns:yang:controller:md:sal:dom:store:test", "2014-03-13", "test").intern();
+    static final NodeIdentifier TEST = NodeIdentifier.create(TEST_QNAME);
+    static final YangInstanceIdentifier TEST_PATH = YangInstanceIdentifier.create(TEST);
+
+    static final QName OUTER_LIST_QNAME = QName.create(TEST_QNAME, "outer-list").intern();
+    static final NodeIdentifier OUTER_LIST = NodeIdentifier.create(OUTER_LIST_QNAME);
+    static final YangInstanceIdentifier OUTER_LIST_PATH = YangInstanceIdentifier.create(TEST, OUTER_LIST);
+
+    static final QName INNER_LIST_QNAME = QName.create(TEST_QNAME, "inner-list").intern();
+    static final NodeIdentifier INNER_LIST = NodeIdentifier.create(INNER_LIST_QNAME);
+
+    static final QName OUTER_CHOICE_QNAME = QName.create(TEST_QNAME, "outer-choice").intern();
+    static final QName ID_QNAME = QName.create(TEST_QNAME, "id").intern();
+    static final QName NAME_QNAME = QName.create(TEST_QNAME, "name").intern();
+    static final QName VALUE_QNAME = QName.create(TEST_QNAME, "value".intern());
+
+    private BenchmarkModel() {
+
+    }
+
+    static SchemaContext createTestContext() {
+        return YangParserTestUtils.parseYangResource("/odl-datastore-test.yang");
     }
 }

diff --git a/benchmarks/src/main/java/org/opendaylight/yangtools/yang/data/impl/tree/InMemoryDataTreeBenchmark.java b/benchmarks/src/main/java/org/opendaylight/yangtools/yang/data/impl/tree/InMemoryDataTreeBenchmark.java
index 226fa357ae4c2a082b54266c61f8f43eedec7f94..2978a58a2eb60ea31e9bc9e0cd60e2a591282cba 100644 (file)
--- a/benchmarks/src/main/java/org/opendaylight/yangtools/yang/data/impl/tree/InMemoryDataTreeBenchmark.java
+++ b/benchmarks/src/main/java/org/opendaylight/yangtools/yang/data/impl/tree/InMemoryDataTreeBenchmark.java
@@ -7,26 +7,26 @@
  */
 package org.opendaylight.yangtools.yang.data.impl.tree;
 
+import com.google.common.collect.Streams;
 import java.io.IOException;
+import java.util.Arrays;
 import java.util.concurrent.TimeUnit;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
 import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
 import org.opendaylight.yangtools.yang.data.api.schema.MapNode;
 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
+import org.opendaylight.yangtools.yang.data.api.schema.tree.CursorAwareDataTreeModification;
 import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTree;
-import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidate;
 import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeConfiguration;
 import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeModification;
-import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeSnapshot;
 import org.opendaylight.yangtools.yang.data.api.schema.tree.DataValidationFailedException;
 import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
 import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.CollectionNodeBuilder;
 import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableContainerNodeBuilder;
 import org.opendaylight.yangtools.yang.data.impl.schema.tree.InMemoryDataTreeFactory;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
-import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
-import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
 import org.openjdk.jmh.annotations.Benchmark;
 import org.openjdk.jmh.annotations.BenchmarkMode;
 import org.openjdk.jmh.annotations.Fork;
@@ -59,37 +59,32 @@ import org.openjdk.jmh.runner.options.OptionsBuilder;
 @Fork(1)
 public class InMemoryDataTreeBenchmark {
 
-    private static final int WARMUP_ITERATIONS = 20;
-    private static final int MEASUREMENT_ITERATIONS = 20;
+    private static final int WARMUP_ITERATIONS = 10;
+    private static final int MEASUREMENT_ITERATIONS = 10;
 
     private static final int OUTER_LIST_100K = 100000;
     private static final int OUTER_LIST_50K = 50000;
     private static final int OUTER_LIST_10K = 10000;
 
-    private static final YangInstanceIdentifier[] OUTER_LIST_100K_PATHS = initOuterListPaths(OUTER_LIST_100K);
-    private static final YangInstanceIdentifier[] OUTER_LIST_50K_PATHS = initOuterListPaths(OUTER_LIST_50K);
-    private static final YangInstanceIdentifier[] OUTER_LIST_10K_PATHS = initOuterListPaths(OUTER_LIST_10K);
+    private static final NodeIdentifierWithPredicates[] OUTER_LIST_IDS = Streams.mapWithIndex(
+        IntStream.range(0, OUTER_LIST_100K),
+        (i, index) -> new NodeIdentifierWithPredicates(BenchmarkModel.OUTER_LIST_QNAME, BenchmarkModel.ID_QNAME, i))
+            .collect(Collectors.toList()).toArray(new NodeIdentifierWithPredicates[0]);
 
-    private static YangInstanceIdentifier[] initOuterListPaths(final int outerListPathsCount) {
-        final YangInstanceIdentifier[] paths = new YangInstanceIdentifier[outerListPathsCount];
-
-        for (int outerListKey = 0; outerListKey < outerListPathsCount; ++outerListKey) {
-            paths[outerListKey] = YangInstanceIdentifier.builder(BenchmarkModel.OUTER_LIST_PATH)
-                .nodeWithKey(BenchmarkModel.OUTER_LIST_QNAME, BenchmarkModel.ID_QNAME, outerListKey)
-                .build();
-        }
-        return paths;
-    }
+    private static final YangInstanceIdentifier[] OUTER_LIST_PATHS = Arrays.stream(OUTER_LIST_IDS)
+            .map(id -> BenchmarkModel.OUTER_LIST_PATH.node(id).toOptimized())
+            .collect(Collectors.toList()).toArray(new YangInstanceIdentifier[0]);
 
+    private static final MapNode EMPTY_OUTER_LIST = ImmutableNodes.mapNodeBuilder(BenchmarkModel.OUTER_LIST).build();
     private static final MapNode ONE_ITEM_INNER_LIST = initInnerListItems(1);
     private static final MapNode TWO_ITEM_INNER_LIST = initInnerListItems(2);
     private static final MapNode TEN_ITEM_INNER_LIST = initInnerListItems(10);
 
     private static MapNode initInnerListItems(final int count) {
         final CollectionNodeBuilder<MapEntryNode, MapNode> mapEntryBuilder = ImmutableNodes
-            .mapNodeBuilder(BenchmarkModel.INNER_LIST_QNAME);
+            .mapNodeBuilder(BenchmarkModel.INNER_LIST);
 
-        for (int i = 1; i <= count; ++i) {
+        for (int i = 0; i < count; ++i) {
             mapEntryBuilder
                 .withChild(ImmutableNodes.mapEntry(BenchmarkModel.INNER_LIST_QNAME, BenchmarkModel.NAME_QNAME, i));
         }
@@ -97,22 +92,19 @@ public class InMemoryDataTreeBenchmark {
         return mapEntryBuilder.build();
     }
 
-    private static final NormalizedNode<?, ?>[] OUTER_LIST_ONE_ITEM_INNER_LIST = initOuterListItems(OUTER_LIST_100K, ONE_ITEM_INNER_LIST);
-    private static final NormalizedNode<?, ?>[] OUTER_LIST_TWO_ITEM_INNER_LIST = initOuterListItems(OUTER_LIST_50K, TWO_ITEM_INNER_LIST);
-    private static final NormalizedNode<?, ?>[] OUTER_LIST_TEN_ITEM_INNER_LIST = initOuterListItems(OUTER_LIST_10K, TEN_ITEM_INNER_LIST);
+    private static final NormalizedNode<?, ?>[] OUTER_LIST_ONE_ITEM_INNER_LIST = initOuterListItems(OUTER_LIST_100K,
+        ONE_ITEM_INNER_LIST);
+    private static final NormalizedNode<?, ?>[] OUTER_LIST_TWO_ITEM_INNER_LIST = initOuterListItems(OUTER_LIST_50K,
+        TWO_ITEM_INNER_LIST);
+    private static final NormalizedNode<?, ?>[] OUTER_LIST_TEN_ITEM_INNER_LIST = initOuterListItems(OUTER_LIST_10K,
+        TEN_ITEM_INNER_LIST);
 
     private static NormalizedNode<?,?>[] initOuterListItems(final int outerListItemsCount, final MapNode innerList) {
-        final NormalizedNode<?,?>[] outerListItems = new NormalizedNode[outerListItemsCount];
-
-        for (int i = 0; i < outerListItemsCount; ++i) {
-            int outerListKey = i;
-            outerListItems[i] = ImmutableNodes.mapEntryBuilder(BenchmarkModel.OUTER_LIST_QNAME, BenchmarkModel.ID_QNAME, outerListKey)
-                .withChild(innerList).build();
-        }
-        return outerListItems;
+        return Arrays.stream(OUTER_LIST_IDS).limit(outerListItemsCount)
+                .map(id -> ImmutableNodes.mapEntryBuilder().withNodeIdentifier(id).withChild(innerList).build())
+                .collect(Collectors.toList()).toArray(new NormalizedNode[0]);
     }
 
-    private SchemaContext schemaContext;
     private DataTree datastore;
 
     public static void main(final String... args) throws IOException, RunnerException {
@@ -125,129 +117,94 @@ public class InMemoryDataTreeBenchmark {
     }
 
     @Setup(Level.Trial)
-    public void setup() throws DataValidationFailedException, SourceException, ReactorException {
-        schemaContext = BenchmarkModel.createTestContext();
-        final InMemoryDataTreeFactory factory = InMemoryDataTreeFactory.getInstance();
-        datastore = factory.create(DataTreeConfiguration.DEFAULT_CONFIGURATION);
-        datastore.setSchemaContext(schemaContext);
-        final DataTreeSnapshot snapshot = datastore.takeSnapshot();
-        initTestNode(snapshot);
+    public void setup() throws DataValidationFailedException {
+        datastore = new InMemoryDataTreeFactory().create(DataTreeConfiguration.DEFAULT_CONFIGURATION,
+            BenchmarkModel.createTestContext());
+
+        final DataTreeModification modification = begin();
+        modification.write(BenchmarkModel.TEST_PATH, ImmutableContainerNodeBuilder.create()
+            .withNodeIdentifier(BenchmarkModel.TEST).withChild(EMPTY_OUTER_LIST).build());
+        commit(modification);
     }
 
     @TearDown
     public void tearDown() {
-        schemaContext = null;
         datastore = null;
     }
 
-    private void initTestNode(final DataTreeSnapshot snapshot) throws DataValidationFailedException {
-        final DataTreeModification modification = snapshot.newModification();
-        final YangInstanceIdentifier testPath = YangInstanceIdentifier.builder(BenchmarkModel.TEST_PATH)
-            .build();
-
-        modification.write(testPath, provideOuterListNode());
-        modification.ready();
-        datastore.validate(modification);
-        final DataTreeCandidate candidate = datastore.prepare(modification);
-        datastore.commit(candidate);
-    }
-
-    private static DataContainerChild<?, ?> provideOuterListNode() {
-        return ImmutableContainerNodeBuilder
-            .create()
-            .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(BenchmarkModel.TEST_QNAME))
-            .withChild(
-                ImmutableNodes.mapNodeBuilder(BenchmarkModel.OUTER_LIST_QNAME)
-                    .build()).build();
-    }
-
     @Benchmark
     @Warmup(iterations = WARMUP_ITERATIONS, timeUnit = TimeUnit.MILLISECONDS)
     @Measurement(iterations = MEASUREMENT_ITERATIONS, timeUnit = TimeUnit.MILLISECONDS)
-    public void write100KSingleNodeWithOneInnerItemInOneCommitBenchmark() throws Exception {
-        final DataTreeSnapshot snapshot = datastore.takeSnapshot();
-        final DataTreeModification modification = snapshot.newModification();
+    public void write100KSingleNodeWithOneInnerItemInOneCommitBenchmark() throws DataValidationFailedException {
+        final DataTreeModification modification = begin();
         for (int outerListKey = 0; outerListKey < OUTER_LIST_100K; ++outerListKey) {
-            modification.write(OUTER_LIST_100K_PATHS[outerListKey], OUTER_LIST_ONE_ITEM_INNER_LIST[outerListKey]);
+            modification.write(OUTER_LIST_PATHS[outerListKey], OUTER_LIST_ONE_ITEM_INNER_LIST[outerListKey]);
         }
-        modification.ready();
-        datastore.validate(modification);
-        final DataTreeCandidate candidate = datastore.prepare(modification);
-        datastore.commit(candidate);
+        commit(modification);
     }
 
     @Benchmark
     @Warmup(iterations = WARMUP_ITERATIONS, timeUnit = TimeUnit.MILLISECONDS)
     @Measurement(iterations = MEASUREMENT_ITERATIONS, timeUnit = TimeUnit.MILLISECONDS)
-    public void write100KSingleNodeWithOneInnerItemInCommitPerWriteBenchmark() throws Exception {
-        final DataTreeSnapshot snapshot = datastore.takeSnapshot();
+    public void write100KSingleNodeWithOneInnerItemInCommitPerWriteBenchmark() throws DataValidationFailedException {
         for (int outerListKey = 0; outerListKey < OUTER_LIST_100K; ++outerListKey) {
-            final DataTreeModification modification = snapshot.newModification();
-            modification.write(OUTER_LIST_100K_PATHS[outerListKey], OUTER_LIST_ONE_ITEM_INNER_LIST[outerListKey]);
-            modification.ready();
-            datastore.validate(modification);
-            final DataTreeCandidate candidate = datastore.prepare(modification);
-            datastore.commit(candidate);
+            final DataTreeModification modification = begin();
+            modification.write(OUTER_LIST_PATHS[outerListKey], OUTER_LIST_ONE_ITEM_INNER_LIST[outerListKey]);
+            commit(modification);
         }
     }
 
     @Benchmark
     @Warmup(iterations = WARMUP_ITERATIONS, timeUnit = TimeUnit.MILLISECONDS)
     @Measurement(iterations = MEASUREMENT_ITERATIONS, timeUnit = TimeUnit.MILLISECONDS)
-    public void write50KSingleNodeWithTwoInnerItemsInOneCommitBenchmark() throws Exception {
-        final DataTreeSnapshot snapshot = datastore.takeSnapshot();
-        final DataTreeModification modification = snapshot.newModification();
+    public void write50KSingleNodeWithTwoInnerItemsInOneCommitBenchmark() throws DataValidationFailedException {
+        final DataTreeModification modification = begin();
         for (int outerListKey = 0; outerListKey < OUTER_LIST_50K; ++outerListKey) {
-            modification.write(OUTER_LIST_50K_PATHS[outerListKey], OUTER_LIST_TWO_ITEM_INNER_LIST[outerListKey]);
+            modification.write(OUTER_LIST_PATHS[outerListKey], OUTER_LIST_TWO_ITEM_INNER_LIST[outerListKey]);
         }
-        datastore.validate(modification);
-        modification.ready();
-        final DataTreeCandidate candidate = datastore.prepare(modification);
-        datastore.commit(candidate);
+        commit(modification);
     }
 
     @Benchmark
     @Warmup(iterations = WARMUP_ITERATIONS, timeUnit = TimeUnit.MILLISECONDS)
     @Measurement(iterations = MEASUREMENT_ITERATIONS, timeUnit = TimeUnit.MILLISECONDS)
-    public void write50KSingleNodeWithTwoInnerItemsInCommitPerWriteBenchmark() throws Exception {
-        final DataTreeSnapshot snapshot = datastore.takeSnapshot();
+    public void write50KSingleNodeWithTwoInnerItemsInCommitPerWriteBenchmark() throws DataValidationFailedException {
         for (int outerListKey = 0; outerListKey < OUTER_LIST_50K; ++outerListKey) {
-            final DataTreeModification modification = snapshot.newModification();
-            modification.write(OUTER_LIST_50K_PATHS[outerListKey], OUTER_LIST_TWO_ITEM_INNER_LIST[outerListKey]);
-            datastore.validate(modification);
-            modification.ready();
-            final DataTreeCandidate candidate = datastore.prepare(modification);
-            datastore.commit(candidate);
+            final DataTreeModification modification = begin();
+            modification.write(OUTER_LIST_PATHS[outerListKey], OUTER_LIST_TWO_ITEM_INNER_LIST[outerListKey]);
+            commit(modification);
         }
     }
 
     @Benchmark
     @Warmup(iterations = WARMUP_ITERATIONS, timeUnit = TimeUnit.MILLISECONDS)
     @Measurement(iterations = MEASUREMENT_ITERATIONS, timeUnit = TimeUnit.MILLISECONDS)
-    public void write10KSingleNodeWithTenInnerItemsInOneCommitBenchmark() throws Exception {
-        final DataTreeSnapshot snapshot = datastore.takeSnapshot();
-        final DataTreeModification modification = snapshot.newModification();
+    public void write10KSingleNodeWithTenInnerItemsInOneCommitBenchmark() throws DataValidationFailedException {
+        final DataTreeModification modification = begin();
         for (int outerListKey = 0; outerListKey < OUTER_LIST_10K; ++outerListKey) {
-            modification.write(OUTER_LIST_10K_PATHS[outerListKey], OUTER_LIST_TEN_ITEM_INNER_LIST[outerListKey]);
+            modification.write(OUTER_LIST_PATHS[outerListKey], OUTER_LIST_TEN_ITEM_INNER_LIST[outerListKey]);
         }
-        datastore.validate(modification);
-        modification.ready();
-        final DataTreeCandidate candidate = datastore.prepare(modification);
-        datastore.commit(candidate);
+        commit(modification);
     }
 
     @Benchmark
     @Warmup(iterations = WARMUP_ITERATIONS, timeUnit = TimeUnit.MILLISECONDS)
     @Measurement(iterations = MEASUREMENT_ITERATIONS, timeUnit = TimeUnit.MILLISECONDS)
-    public void write10KSingleNodeWithTenInnerItemsInCommitPerWriteBenchmark() throws Exception {
-        final DataTreeSnapshot snapshot = datastore.takeSnapshot();
+    public void write10KSingleNodeWithTenInnerItemsInCommitPerWriteBenchmark() throws DataValidationFailedException {
         for (int outerListKey = 0; outerListKey < OUTER_LIST_10K; ++outerListKey) {
-            final DataTreeModification modification = snapshot.newModification();
-            modification.write(OUTER_LIST_10K_PATHS[outerListKey], OUTER_LIST_TEN_ITEM_INNER_LIST[outerListKey]);
-            datastore.validate(modification);
-            modification.ready();
-            final DataTreeCandidate candidate = datastore.prepare(modification);
-            datastore.commit(candidate);
+            final DataTreeModification modification = begin();
+            modification.write(OUTER_LIST_PATHS[outerListKey], OUTER_LIST_TEN_ITEM_INNER_LIST[outerListKey]);
+            commit(modification);
         }
     }
+
+    private CursorAwareDataTreeModification begin() {
+        return (CursorAwareDataTreeModification) datastore.takeSnapshot().newModification();
+    }
+
+    private void commit(final DataTreeModification modification) throws DataValidationFailedException {
+        modification.ready();
+        datastore.validate(modification);
+        datastore.commit(datastore.prepare(modification));
+    }
 }

diff --git a/pom.xml b/pom.xml
index 3f5929020c00ac57ade1226bff36ffddd496d946..76a900ee120a69d4b10f794dfcf752f7e0306544 100644 (file)
--- a/pom.xml
+++ b/pom.xml
@@ -31,6 +31,7 @@
     </scm>
 
     <modules>
+        <module>benchmarks</module>
         <module>common</module>
         <module>features</module>
         <module>yang</module>
@@ -39,16 +40,6 @@
     </modules>
 
     <profiles>
-      <profile>
-        <id>benchmarks</id>
-        <activation>
-          <activeByDefault>false</activeByDefault>
-        </activation>
-        <modules>
-          <module>benchmarks</module>
-        </modules>
-      </profile>
-
       <profile>
         <!--
             This profile is to ensure we only build javadocs reports