diff options
Diffstat (limited to 'it/jvpp-benchmark')
9 files changed, 308 insertions, 22 deletions
diff --git a/it/jvpp-benchmark/asciidoc/Readme.adoc b/it/jvpp-benchmark/asciidoc/Readme.adoc index 8c787d4ac..a8e5d2c48 100644 --- a/it/jvpp-benchmark/asciidoc/Readme.adoc +++ b/it/jvpp-benchmark/asciidoc/Readme.adoc @@ -2,14 +2,26 @@ Provides JMH based benchmarks JVpp (Java API for VPP). +Compile: +[source,shell] +--- +cd $HC2VPP_ROOT/it/jvpp-benchmark +mvn clean install +--- + +To display JMH options, use +[source,shell] +--- +java -jar ./target/jvpp-benchmark-exec.jar -h +--- + == AclUpdateBenchmark Creates ACL of size aclSize using acl_add_replace, then assigns it to loopback interface using acl_interface_set_acl_list. Then ACL is updated synchronously using acl_add_replace. -By default 20x2s warmup and 100x2s measurment iterations -are performed. +By default 20x2s warmup and 100x2s measurement iterations are performed. VPP is restarted after each iteration. @@ -17,39 +29,50 @@ Each invocation of acl_add_replace uses ACL from precomputed set of ACLs of size aclSetSize. ACLs from the set are used in round-robin fashion. -Compile: -[source,shell] ---- -cd $HC2VPP_ROOT/it/jvpp-benchmark -mvn clean install ---- - Run with: [source,shell] --- -sudo java -jar ./target/jvpp-benchmark-exec.jar +sudo java -jar ./target/jvpp-benchmark-exec.jar AclUpdateBenchmark --- To specify aclSize (default=100), use: [source,shell] --- -sudo java -jar ./target/jvpp-benchmark-exec.jar -p aclSize=1000 +sudo java -jar ./target/jvpp-benchmark-exec.jar -p aclSize=1000 AclUpdateBenchmark --- To specify aclSetSize (default=100), use: [source,shell] --- -sudo java -jar ./target/jvpp-benchmark-exec.jar -p aclSetSize=1000 +sudo java -jar ./target/jvpp-benchmark-exec.jar -p aclSetSize=1000 AclUpdateBenchmark --- To test interface in bridged (L2) / routed (L3) mode (default=L3), use: [source,shell] --- -sudo java -jar ./target/jvpp-benchmark-exec.jar -p mode=L2 +sudo java -jar ./target/jvpp-benchmark-exec.jar -p mode=L2 AclUpdateBenchmark --- -To see more options, use + +== ClassifyTableCreateBenchmark + +Synchronously creates classify tables using classifyAddDelTable operation. +By default 20x2s warmup and 100x2s measurement iterations are performed. + +VPP is restarted after each iteration. + +Each invocation of classifyAddDelTable uses tables +from precomputed set of size tableSetSize. +Tables from the set are used in round-robin fashion. + +Run with: [source,shell] --- -java -jar ./target/jvpp-benchmark-exec.jar -h +sudo java -jar ./target/jvpp-benchmark-exec.jar ClassifyTableCreateBenchmark +--- + +To specify tableSetSize (default=100), use: +[source,shell] +--- +sudo java -jar ./target/jvpp-benchmark-exec.jar ClassifyTableCreateBenchmark -p aclSetSize=1000 --- diff --git a/it/jvpp-benchmark/src/main/java/io/fd/hc2vpp/it/jvpp/benchmark/AclProvider.java b/it/jvpp-benchmark/src/main/java/io/fd/hc2vpp/it/jvpp/benchmark/acl/AclProvider.java index b00f5b90a..f3459916e 100644 --- a/it/jvpp-benchmark/src/main/java/io/fd/hc2vpp/it/jvpp/benchmark/AclProvider.java +++ b/it/jvpp-benchmark/src/main/java/io/fd/hc2vpp/it/jvpp/benchmark/acl/AclProvider.java @@ -14,7 +14,7 @@ * limitations under the License. */ -package io.fd.hc2vpp.it.jvpp.benchmark; +package io.fd.hc2vpp.it.jvpp.benchmark.acl; import io.fd.vpp.jvpp.acl.dto.AclAddReplace; diff --git a/it/jvpp-benchmark/src/main/java/io/fd/hc2vpp/it/jvpp/benchmark/AclProviderImpl.java b/it/jvpp-benchmark/src/main/java/io/fd/hc2vpp/it/jvpp/benchmark/acl/AclProviderImpl.java index 98894fe1d..ca0ddbb8f 100644 --- a/it/jvpp-benchmark/src/main/java/io/fd/hc2vpp/it/jvpp/benchmark/AclProviderImpl.java +++ b/it/jvpp-benchmark/src/main/java/io/fd/hc2vpp/it/jvpp/benchmark/acl/AclProviderImpl.java @@ -14,7 +14,7 @@ * limitations under the License. */ -package io.fd.hc2vpp.it.jvpp.benchmark; +package io.fd.hc2vpp.it.jvpp.benchmark.acl; import io.fd.vpp.jvpp.acl.dto.AclAddReplace; import io.fd.vpp.jvpp.acl.types.AclRule; diff --git a/it/jvpp-benchmark/src/main/java/io/fd/hc2vpp/it/jvpp/benchmark/AclUpdateBenchmark.java b/it/jvpp-benchmark/src/main/java/io/fd/hc2vpp/it/jvpp/benchmark/acl/AclUpdateBenchmark.java index 3ec7be953..e8bf2a833 100644 --- a/it/jvpp-benchmark/src/main/java/io/fd/hc2vpp/it/jvpp/benchmark/AclUpdateBenchmark.java +++ b/it/jvpp-benchmark/src/main/java/io/fd/hc2vpp/it/jvpp/benchmark/acl/AclUpdateBenchmark.java @@ -14,10 +14,10 @@ * limitations under the License. */ -package io.fd.hc2vpp.it.jvpp.benchmark; +package io.fd.hc2vpp.it.jvpp.benchmark.acl; -import static io.fd.hc2vpp.it.jvpp.benchmark.AclUpdateBenchmark.InterfaceMode.L2; -import static io.fd.hc2vpp.it.jvpp.benchmark.AclUpdateBenchmark.InterfaceMode.L3; +import static io.fd.hc2vpp.it.jvpp.benchmark.acl.AclUpdateBenchmark.InterfaceMode.L2; +import static io.fd.hc2vpp.it.jvpp.benchmark.acl.AclUpdateBenchmark.InterfaceMode.L3; import com.google.common.io.CharStreams; import io.fd.vpp.jvpp.JVppRegistryImpl; @@ -58,7 +58,6 @@ import org.openjdk.jmh.annotations.Warmup; import org.slf4j.Logger; import org.slf4j.LoggerFactory; - @BenchmarkMode(Mode.AverageTime) @State(Scope.Thread) @Fork(1) @@ -86,6 +85,7 @@ public class AclUpdateBenchmark { @Benchmark public void testMethod() throws Exception { + // In real application, reply may be ignored by the caller, so we ignore as well. jvppAcl.aclAddReplace(aclProvider.next()).toCompletableFuture().get(); } diff --git a/it/jvpp-benchmark/src/main/java/io/fd/hc2vpp/it/jvpp/benchmark/classify/ClassifyTableCreateBenchmark.java b/it/jvpp-benchmark/src/main/java/io/fd/hc2vpp/it/jvpp/benchmark/classify/ClassifyTableCreateBenchmark.java new file mode 100644 index 000000000..32700933e --- /dev/null +++ b/it/jvpp-benchmark/src/main/java/io/fd/hc2vpp/it/jvpp/benchmark/classify/ClassifyTableCreateBenchmark.java @@ -0,0 +1,129 @@ +/* + * Copyright (c) 2018 Cisco and/or its affiliates. + * + * 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 io.fd.hc2vpp.it.jvpp.benchmark.classify; + +import com.google.common.io.CharStreams; +import io.fd.vpp.jvpp.JVppRegistryImpl; +import io.fd.vpp.jvpp.core.JVppCoreImpl; +import io.fd.vpp.jvpp.core.dto.ClassifyAddDelTableReply; +import io.fd.vpp.jvpp.core.future.FutureJVppCoreFacade; +import java.io.IOException; +import java.io.InputStreamReader; +import java.nio.charset.StandardCharsets; +import java.util.Arrays; +import java.util.concurrent.TimeUnit; +import org.openjdk.jmh.annotations.Benchmark; +import org.openjdk.jmh.annotations.BenchmarkMode; +import org.openjdk.jmh.annotations.Fork; +import org.openjdk.jmh.annotations.Level; +import org.openjdk.jmh.annotations.Measurement; +import org.openjdk.jmh.annotations.Mode; +import org.openjdk.jmh.annotations.OutputTimeUnit; +import org.openjdk.jmh.annotations.Param; +import org.openjdk.jmh.annotations.Scope; +import org.openjdk.jmh.annotations.Setup; +import org.openjdk.jmh.annotations.State; +import org.openjdk.jmh.annotations.TearDown; +import org.openjdk.jmh.annotations.Threads; +import org.openjdk.jmh.annotations.Timeout; +import org.openjdk.jmh.annotations.Warmup; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +@BenchmarkMode(Mode.AverageTime) +@State(Scope.Thread) +@Fork(1) +@Threads(1) +@Timeout(time = 5) +@Warmup(iterations = 20, time = 2) +@Measurement(iterations = 100, time = 2) +@OutputTimeUnit(TimeUnit.MILLISECONDS) +public class ClassifyTableCreateBenchmark { + private static final Logger LOG = LoggerFactory.getLogger(ClassifyTableCreateBenchmark.class); + + @Param( {"100"}) + private int tableSetSize; + + private JVppRegistryImpl registry; + private FutureJVppCoreFacade jvppCore; + private ClassifyTableProvider classifyTableProvider; + + @Benchmark + public ClassifyAddDelTableReply testMethod() throws Exception { + // Caller may want to process reply, so return it to prevent JVM from dead code elimination + return jvppCore.classifyAddDelTable(classifyTableProvider.next()).toCompletableFuture().get(); + } + + @Setup(Level.Iteration) + public void setup() throws Exception { + initProvider(); + startVpp(); + connect(); + } + + @TearDown(Level.Iteration) + public void tearDown() throws Exception { + disconnect(); + stopVpp(); + } + + private void initProvider() { + classifyTableProvider = new ClassifyTableProviderImpl(tableSetSize); + } + + private void startVpp() throws Exception { + LOG.info("Starting VPP ..."); + final String[] cmd = {"/bin/sh", "-c", "sudo service vpp start"}; + exec(cmd); + LOG.info("VPP started successfully"); + } + + private void stopVpp() throws Exception { + LOG.info("Stopping VPP ..."); + final String[] cmd = {"/bin/sh", "-c", "sudo service vpp stop"}; + exec(cmd); + + // Wait to be sure VPP was stopped. + // Prevents VPP start failure: "vpp.service: Start request repeated too quickly". + Thread.sleep(1500); + LOG.info("VPP stopped successfully"); + } + + private static void exec(String[] command) throws IOException, InterruptedException { + Process process = Runtime.getRuntime().exec(command); + process.waitFor(); + if (process.exitValue() != 0) { + String error_msg = "Failed to execute " + Arrays.toString(command) + ": " + + CharStreams.toString(new InputStreamReader(process.getErrorStream(), StandardCharsets.UTF_8)); + throw new IllegalStateException(error_msg); + } + } + + private void connect() throws IOException { + LOG.info("Connecting to JVPP ..."); + registry = new JVppRegistryImpl("ACLUpdateBenchmark"); + jvppCore = new FutureJVppCoreFacade(registry, new JVppCoreImpl()); + LOG.info("Successfully connected to JVPP"); + } + + private void disconnect() throws Exception { + LOG.info("Disconnecting ..."); + jvppCore.close(); + registry.close(); + LOG.info("Successfully disconnected ..."); + } +} diff --git a/it/jvpp-benchmark/src/main/java/io/fd/hc2vpp/it/jvpp/benchmark/classify/ClassifyTableProvider.java b/it/jvpp-benchmark/src/main/java/io/fd/hc2vpp/it/jvpp/benchmark/classify/ClassifyTableProvider.java new file mode 100644 index 000000000..e23ecc6a1 --- /dev/null +++ b/it/jvpp-benchmark/src/main/java/io/fd/hc2vpp/it/jvpp/benchmark/classify/ClassifyTableProvider.java @@ -0,0 +1,23 @@ +/* + * Copyright (c) 2018 Cisco and/or its affiliates. + * + * 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 io.fd.hc2vpp.it.jvpp.benchmark.classify; + +import io.fd.vpp.jvpp.core.dto.ClassifyAddDelTable; + +interface ClassifyTableProvider { + ClassifyAddDelTable next(); +} diff --git a/it/jvpp-benchmark/src/main/java/io/fd/hc2vpp/it/jvpp/benchmark/classify/ClassifyTableProviderImpl.java b/it/jvpp-benchmark/src/main/java/io/fd/hc2vpp/it/jvpp/benchmark/classify/ClassifyTableProviderImpl.java new file mode 100644 index 000000000..80ebdccd2 --- /dev/null +++ b/it/jvpp-benchmark/src/main/java/io/fd/hc2vpp/it/jvpp/benchmark/classify/ClassifyTableProviderImpl.java @@ -0,0 +1,72 @@ +/* + * Copyright (c) 2018 Cisco and/or its affiliates. + * + * 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 io.fd.hc2vpp.it.jvpp.benchmark.classify; + +import io.fd.vpp.jvpp.core.dto.ClassifyAddDelTable; +import java.io.Serializable; +import java.util.Random; +import javax.annotation.concurrent.NotThreadSafe; + +@NotThreadSafe +class ClassifyTableProviderImpl implements ClassifyTableProvider { + /** + * Static seed to make rnd.nextBytes() output the same for all test run. + */ + private static final long SEED = -2084670072119134328L; + private final int tableSetSize; + private final ClassifyAddDelTable[] tables; + private final Random rnd = new Random(SEED); + + /** + * Pointer to Classify table to be returned by invocation of {@link #next()} method. + */ + private int currentTable = 0; + + ClassifyTableProviderImpl(final int tableSetSize) { + this.tableSetSize = tableSetSize; + tables = new ClassifyAddDelTable[tableSetSize]; + initTables(tableSetSize); + } + + @Override + public ClassifyAddDelTable next() { + final ClassifyAddDelTable result = tables[currentTable]; + currentTable = (currentTable + 1) % tableSetSize; + return result; + } + + private void initTables(final int tableSetSize) { + for (int i = 0; i < tableSetSize; ++i) { + tables[i] = createTable(); + } + } + + private ClassifyAddDelTable createTable() { + final ClassifyAddDelTable addDelTable = new ClassifyAddDelTable(); + addDelTable.isAdd = 1; + addDelTable.tableIndex = -1; + addDelTable.nbuckets = 2; + addDelTable.memorySize = 2 << 20; + addDelTable.nextTableIndex = ~0; + addDelTable.missNextIndex = ~0; + addDelTable.skipNVectors = 0; + addDelTable.matchNVectors = 1; + addDelTable.mask = new byte[16]; + rnd.nextBytes(addDelTable.mask); + return addDelTable; + } +} diff --git a/it/jvpp-benchmark/src/test/java/io/fd/hc2vpp/it/jvpp/benchmark/AclProviderImplTest.java b/it/jvpp-benchmark/src/test/java/io/fd/hc2vpp/it/jvpp/benchmark/acl/AclProviderImplTest.java index fd4b0d7ff..d54d178e1 100644 --- a/it/jvpp-benchmark/src/test/java/io/fd/hc2vpp/it/jvpp/benchmark/AclProviderImplTest.java +++ b/it/jvpp-benchmark/src/test/java/io/fd/hc2vpp/it/jvpp/benchmark/acl/AclProviderImplTest.java @@ -14,7 +14,7 @@ * limitations under the License. */ -package io.fd.hc2vpp.it.jvpp.benchmark; +package io.fd.hc2vpp.it.jvpp.benchmark.acl; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertFalse; diff --git a/it/jvpp-benchmark/src/test/java/io/fd/hc2vpp/it/jvpp/benchmark/classify/ClassifyTableProviderImplTest.java b/it/jvpp-benchmark/src/test/java/io/fd/hc2vpp/it/jvpp/benchmark/classify/ClassifyTableProviderImplTest.java new file mode 100644 index 000000000..8f11077e0 --- /dev/null +++ b/it/jvpp-benchmark/src/test/java/io/fd/hc2vpp/it/jvpp/benchmark/classify/ClassifyTableProviderImplTest.java @@ -0,0 +1,39 @@ +/* + * Copyright (c) 2018 Cisco and/or its affiliates. + * + * 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 io.fd.hc2vpp.it.jvpp.benchmark.classify; + +import static org.junit.Assert.*; + +import io.fd.vpp.jvpp.acl.dto.AclAddReplace; +import io.fd.vpp.jvpp.core.dto.ClassifyAddDelTable; +import org.junit.Test; + +public class ClassifyTableProviderImplTest { + @Test + public void testTablesDiffer() throws Exception { + final ClassifyTableProviderImpl provider = new ClassifyTableProviderImpl(2); + final ClassifyAddDelTable table0 = provider.next(); + final ClassifyAddDelTable table1 = provider.next(); + final ClassifyAddDelTable table2 = provider.next(); + final ClassifyAddDelTable table3 = provider.next(); + + // Test if ACLs are provided in round-robin fashion + assertEquals("Tables 0 and 2 should be equal", table0, table2); + assertEquals("Tables 1 and 3 should be equal", table1, table3); + assertNotEquals("Tables 0 and 1 should be different", table0, table1); + } +}
\ No newline at end of file |