benchmarks/src/main/java/org/opendaylight/yangtools/yang/data/impl/tree/InMemoryDataTreeBenchmark.java

   1 /**
   2  * Copyright (c) 2013 Cisco Systems, Inc. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8 package org.opendaylight.yangtools.yang.data.impl.tree;
   9
  10 import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
  11 import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
  12
  13 import java.io.IOException;
  14 import java.util.concurrent.TimeUnit;
  15 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
  16 import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
  17 import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
  18 import org.opendaylight.yangtools.yang.data.api.schema.MapNode;
  19 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
  20 import org.opendaylight.yangtools.yang.data.api.schema.tree.*;
  21 import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
  22 import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.CollectionNodeBuilder;
  23 import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableContainerNodeBuilder;
  24 import org.opendaylight.yangtools.yang.data.impl.schema.tree.InMemoryDataTreeFactory;
  25 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
  26 import org.openjdk.jmh.annotations.*;
  27 import org.openjdk.jmh.runner.Runner;
  28 import org.openjdk.jmh.runner.RunnerException;
  29 import org.openjdk.jmh.runner.options.Options;
  30 import org.openjdk.jmh.runner.options.OptionsBuilder;
  31
  32 /**
  33  * Benchmarking of InMemoryDataTree performance.
  34  *
  35  * JMH is used for microbenchmarking.
  36  *
  37  * @author Lukas Sedlak &lt;lsedlak@cisco.com&gt;
  38  *
  39  * @see <a href="http://openjdk.java.net/projects/code-tools/jmh/">JMH</a>
  40  */
  41 @State(Scope.Thread)
  42 @BenchmarkMode(Mode.AverageTime)
  43 @OutputTimeUnit(TimeUnit.MILLISECONDS)
  44 @Fork(1)
  45 public class InMemoryDataTreeBenchmark {
  46
  47     private static final int WARMUP_ITERATIONS = 20;
  48     private static final int MEASUREMENT_ITERATIONS = 20;
  49
  50     private static final int OUTER_LIST_100K = 100000;
  51     private static final int OUTER_LIST_50K = 50000;
  52     private static final int OUTER_LIST_10K = 10000;
  53
  54     private static final YangInstanceIdentifier[] OUTER_LIST_100K_PATHS = initOuterListPaths(OUTER_LIST_100K);
  55     private static final YangInstanceIdentifier[] OUTER_LIST_50K_PATHS = initOuterListPaths(OUTER_LIST_50K);
  56     private static final YangInstanceIdentifier[] OUTER_LIST_10K_PATHS = initOuterListPaths(OUTER_LIST_10K);
  57
  58     private static YangInstanceIdentifier[] initOuterListPaths(final int outerListPathsCount) {
  59         final YangInstanceIdentifier[] paths = new YangInstanceIdentifier[outerListPathsCount];
  60
  61         for (int outerListKey = 0; outerListKey < outerListPathsCount; ++outerListKey) {
  62             paths[outerListKey] = YangInstanceIdentifier.builder(BenchmarkModel.OUTER_LIST_PATH)
  63                 .nodeWithKey(BenchmarkModel.OUTER_LIST_QNAME, BenchmarkModel.ID_QNAME, outerListKey)
  64                 .build();
  65         }
  66         return paths;
  67     }
  68
  69     private static final MapNode ONE_ITEM_INNER_LIST = initInnerListItems(1);
  70     private static final MapNode TWO_ITEM_INNER_LIST = initInnerListItems(2);
  71     private static final MapNode TEN_ITEM_INNER_LIST = initInnerListItems(10);
  72
  73     private static MapNode initInnerListItems(final int count) {
  74         final CollectionNodeBuilder<MapEntryNode, MapNode> mapEntryBuilder = ImmutableNodes
  75             .mapNodeBuilder(BenchmarkModel.INNER_LIST_QNAME);
  76
  77         for (int i = 1; i <= count; ++i) {
  78             mapEntryBuilder
  79                 .withChild(ImmutableNodes.mapEntry(BenchmarkModel.INNER_LIST_QNAME, BenchmarkModel.NAME_QNAME, i));
  80         }
  81
  82         return mapEntryBuilder.build();
  83     }
  84
  85     private static final NormalizedNode<?, ?>[] OUTER_LIST_ONE_ITEM_INNER_LIST = initOuterListItems(OUTER_LIST_100K, ONE_ITEM_INNER_LIST);
  86     private static final NormalizedNode<?, ?>[] OUTER_LIST_TWO_ITEM_INNER_LIST = initOuterListItems(OUTER_LIST_50K, TWO_ITEM_INNER_LIST);
  87     private static final NormalizedNode<?, ?>[] OUTER_LIST_TEN_ITEM_INNER_LIST = initOuterListItems(OUTER_LIST_10K, TEN_ITEM_INNER_LIST);
  88
  89     private static NormalizedNode<?,?>[] initOuterListItems(int outerListItemsCount, MapNode innerList) {
  90         final NormalizedNode<?,?>[] outerListItems = new NormalizedNode[outerListItemsCount];
  91
  92         for (int i = 0; i < outerListItemsCount; ++i) {
  93             int outerListKey = i;
  94             outerListItems[i] = ImmutableNodes.mapEntryBuilder(BenchmarkModel.OUTER_LIST_QNAME, BenchmarkModel.ID_QNAME, outerListKey)
  95                 .withChild(innerList).build();
  96         }
  97         return outerListItems;
  98     }
  99
 100     private SchemaContext schemaContext;
 101     private DataTree datastore;
 102
 103     public static void main(String... args) throws IOException, RunnerException {
 104         Options opt = new OptionsBuilder()
 105             .include(".*" + InMemoryDataTreeBenchmark.class.getSimpleName() + ".*")
 106             .forks(1)
 107             .build();
 108
 109         new Runner(opt).run();
 110     }
 111
 112     @Setup(Level.Trial)
 113     public void setup() throws DataValidationFailedException, SourceException, ReactorException {
 114         schemaContext = BenchmarkModel.createTestContext();
 115         final InMemoryDataTreeFactory factory = InMemoryDataTreeFactory.getInstance();
 116         datastore = factory.create();
 117         datastore.setSchemaContext(schemaContext);
 118         final DataTreeSnapshot snapshot = datastore.takeSnapshot();
 119         initTestNode(snapshot);
 120     }
 121
 122     @TearDown
 123     public void tearDown() {
 124         schemaContext = null;
 125         datastore = null;
 126     }
 127
 128     private void initTestNode(final DataTreeSnapshot snapshot) throws DataValidationFailedException {
 129         final DataTreeModification modification = snapshot.newModification();
 130         final YangInstanceIdentifier testPath = YangInstanceIdentifier.builder(BenchmarkModel.TEST_PATH)
 131             .build();
 132
 133         modification.write(testPath, provideOuterListNode());
 134         datastore.validate(modification);
 135         final DataTreeCandidate candidate = datastore.prepare(modification);
 136         datastore.commit(candidate);
 137     }
 138
 139     private DataContainerChild<?, ?> provideOuterListNode() {
 140         return ImmutableContainerNodeBuilder
 141             .create()
 142             .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(BenchmarkModel.TEST_QNAME))
 143             .withChild(
 144                 ImmutableNodes.mapNodeBuilder(BenchmarkModel.OUTER_LIST_QNAME)
 145                     .build()).build();
 146     }
 147
 148     @Benchmark
 149     @Warmup(iterations = WARMUP_ITERATIONS, timeUnit = TimeUnit.MILLISECONDS)
 150     @Measurement(iterations = MEASUREMENT_ITERATIONS, timeUnit = TimeUnit.MILLISECONDS)
 151     public void write100KSingleNodeWithOneInnerItemInOneCommitBenchmark() throws Exception {
 152         final DataTreeSnapshot snapshot = datastore.takeSnapshot();
 153         final DataTreeModification modification = snapshot.newModification();
 154         for (int outerListKey = 0; outerListKey < OUTER_LIST_100K; ++outerListKey) {
 155             modification.write(OUTER_LIST_100K_PATHS[outerListKey], OUTER_LIST_ONE_ITEM_INNER_LIST[outerListKey]);
 156         }
 157         datastore.validate(modification);
 158         final DataTreeCandidate candidate = datastore.prepare(modification);
 159         datastore.commit(candidate);
 160     }
 161
 162     @Benchmark
 163     @Warmup(iterations = WARMUP_ITERATIONS, timeUnit = TimeUnit.MILLISECONDS)
 164     @Measurement(iterations = MEASUREMENT_ITERATIONS, timeUnit = TimeUnit.MILLISECONDS)
 165     public void write100KSingleNodeWithOneInnerItemInCommitPerWriteBenchmark() throws Exception {
 166         final DataTreeSnapshot snapshot = datastore.takeSnapshot();
 167         for (int outerListKey = 0; outerListKey < OUTER_LIST_100K; ++outerListKey) {
 168             final DataTreeModification modification = snapshot.newModification();
 169             modification.write(OUTER_LIST_100K_PATHS[outerListKey], OUTER_LIST_ONE_ITEM_INNER_LIST[outerListKey]);
 170             datastore.validate(modification);
 171             final DataTreeCandidate candidate = datastore.prepare(modification);
 172             datastore.commit(candidate);
 173         }
 174     }
 175
 176     @Benchmark
 177     @Warmup(iterations = WARMUP_ITERATIONS, timeUnit = TimeUnit.MILLISECONDS)
 178     @Measurement(iterations = MEASUREMENT_ITERATIONS, timeUnit = TimeUnit.MILLISECONDS)
 179     public void write50KSingleNodeWithTwoInnerItemsInOneCommitBenchmark() throws Exception {
 180         final DataTreeSnapshot snapshot = datastore.takeSnapshot();
 181         final DataTreeModification modification = snapshot.newModification();
 182         for (int outerListKey = 0; outerListKey < OUTER_LIST_50K; ++outerListKey) {
 183             modification.write(OUTER_LIST_50K_PATHS[outerListKey], OUTER_LIST_TWO_ITEM_INNER_LIST[outerListKey]);
 184         }
 185         datastore.validate(modification);
 186         final DataTreeCandidate candidate = datastore.prepare(modification);
 187         datastore.commit(candidate);
 188     }
 189
 190     @Benchmark
 191     @Warmup(iterations = WARMUP_ITERATIONS, timeUnit = TimeUnit.MILLISECONDS)
 192     @Measurement(iterations = MEASUREMENT_ITERATIONS, timeUnit = TimeUnit.MILLISECONDS)
 193     public void write50KSingleNodeWithTwoInnerItemsInCommitPerWriteBenchmark() throws Exception {
 194         final DataTreeSnapshot snapshot = datastore.takeSnapshot();
 195         for (int outerListKey = 0; outerListKey < OUTER_LIST_50K; ++outerListKey) {
 196             final DataTreeModification modification = snapshot.newModification();
 197             modification.write(OUTER_LIST_50K_PATHS[outerListKey], OUTER_LIST_TWO_ITEM_INNER_LIST[outerListKey]);
 198             datastore.validate(modification);
 199             final DataTreeCandidate candidate = datastore.prepare(modification);
 200             datastore.commit(candidate);
 201         }
 202     }
 203
 204     @Benchmark
 205     @Warmup(iterations = WARMUP_ITERATIONS, timeUnit = TimeUnit.MILLISECONDS)
 206     @Measurement(iterations = MEASUREMENT_ITERATIONS, timeUnit = TimeUnit.MILLISECONDS)
 207     public void write10KSingleNodeWithTenInnerItemsInOneCommitBenchmark() throws Exception {
 208         final DataTreeSnapshot snapshot = datastore.takeSnapshot();
 209         final DataTreeModification modification = snapshot.newModification();
 210         for (int outerListKey = 0; outerListKey < OUTER_LIST_10K; ++outerListKey) {
 211             modification.write(OUTER_LIST_10K_PATHS[outerListKey], OUTER_LIST_TEN_ITEM_INNER_LIST[outerListKey]);
 212         }
 213         datastore.validate(modification);
 214         final DataTreeCandidate candidate = datastore.prepare(modification);
 215         datastore.commit(candidate);
 216     }
 217
 218     @Benchmark
 219     @Warmup(iterations = WARMUP_ITERATIONS, timeUnit = TimeUnit.MILLISECONDS)
 220     @Measurement(iterations = MEASUREMENT_ITERATIONS, timeUnit = TimeUnit.MILLISECONDS)
 221     public void write10KSingleNodeWithTenInnerItemsInCommitPerWriteBenchmark() throws Exception {
 222         final DataTreeSnapshot snapshot = datastore.takeSnapshot();
 223         for (int outerListKey = 0; outerListKey < OUTER_LIST_10K; ++outerListKey) {
 224             final DataTreeModification modification = snapshot.newModification();
 225             modification.write(OUTER_LIST_10K_PATHS[outerListKey], OUTER_LIST_TEN_ITEM_INNER_LIST[outerListKey]);
 226             datastore.validate(modification);
 227             final DataTreeCandidate candidate = datastore.prepare(modification);
 228             datastore.commit(candidate);
 229         }
 230     }
 231 }