From bed970cdde06918fe600340a98337a0f9707f3bf Mon Sep 17 00:00:00 2001 From: Marek Gradzki Date: Mon, 28 May 2018 17:56:18 +0200 Subject: jvpp-benchmark: measure classifyAddDelTable Synchronously creates classify tables. 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: sudo java -jar ./target/jvpp-benchmark-exec.jar \ ClassifyTableCreateBenchmark To specify aclSetSize (default=100), use: sudo java -jar ./target/jvpp-benchmark-exec.jar \ ClassifyTableCreateBenchmark -p tableSetSize=1000 To see more options, use java -jar ./target/jvpp-benchmark-exec.jar -h Change-Id: I387d879bc99dce45f93d66e8a99f7206f067b443 Signed-off-by: Marek Gradzki --- it/jvpp-benchmark/asciidoc/Readme.adoc | 53 +++-- .../fd/hc2vpp/it/jvpp/benchmark/AclProvider.java | 27 --- .../hc2vpp/it/jvpp/benchmark/AclProviderImpl.java | 105 ---------- .../it/jvpp/benchmark/AclUpdateBenchmark.java | 215 --------------------- .../hc2vpp/it/jvpp/benchmark/acl/AclProvider.java | 27 +++ .../it/jvpp/benchmark/acl/AclProviderImpl.java | 105 ++++++++++ .../it/jvpp/benchmark/acl/AclUpdateBenchmark.java | 215 +++++++++++++++++++++ .../classify/ClassifyTableCreateBenchmark.java | 129 +++++++++++++ .../benchmark/classify/ClassifyTableProvider.java | 23 +++ .../classify/ClassifyTableProviderImpl.java | 72 +++++++ .../it/jvpp/benchmark/AclProviderImplTest.java | 60 ------ .../it/jvpp/benchmark/acl/AclProviderImplTest.java | 60 ++++++ .../classify/ClassifyTableProviderImplTest.java | 39 ++++ 13 files changed, 708 insertions(+), 422 deletions(-) delete mode 100644 it/jvpp-benchmark/src/main/java/io/fd/hc2vpp/it/jvpp/benchmark/AclProvider.java delete mode 100644 it/jvpp-benchmark/src/main/java/io/fd/hc2vpp/it/jvpp/benchmark/AclProviderImpl.java delete mode 100644 it/jvpp-benchmark/src/main/java/io/fd/hc2vpp/it/jvpp/benchmark/AclUpdateBenchmark.java create mode 100644 it/jvpp-benchmark/src/main/java/io/fd/hc2vpp/it/jvpp/benchmark/acl/AclProvider.java create mode 100644 it/jvpp-benchmark/src/main/java/io/fd/hc2vpp/it/jvpp/benchmark/acl/AclProviderImpl.java create mode 100644 it/jvpp-benchmark/src/main/java/io/fd/hc2vpp/it/jvpp/benchmark/acl/AclUpdateBenchmark.java create mode 100644 it/jvpp-benchmark/src/main/java/io/fd/hc2vpp/it/jvpp/benchmark/classify/ClassifyTableCreateBenchmark.java create mode 100644 it/jvpp-benchmark/src/main/java/io/fd/hc2vpp/it/jvpp/benchmark/classify/ClassifyTableProvider.java create mode 100644 it/jvpp-benchmark/src/main/java/io/fd/hc2vpp/it/jvpp/benchmark/classify/ClassifyTableProviderImpl.java delete mode 100644 it/jvpp-benchmark/src/test/java/io/fd/hc2vpp/it/jvpp/benchmark/AclProviderImplTest.java create mode 100644 it/jvpp-benchmark/src/test/java/io/fd/hc2vpp/it/jvpp/benchmark/acl/AclProviderImplTest.java create mode 100644 it/jvpp-benchmark/src/test/java/io/fd/hc2vpp/it/jvpp/benchmark/classify/ClassifyTableProviderImplTest.java (limited to 'it') 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/AclProvider.java deleted file mode 100644 index b00f5b90a..000000000 --- a/it/jvpp-benchmark/src/main/java/io/fd/hc2vpp/it/jvpp/benchmark/AclProvider.java +++ /dev/null @@ -1,27 +0,0 @@ -/* - * 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; - -import io.fd.vpp.jvpp.acl.dto.AclAddReplace; - -/** - * Provides ACLs for JVpp Benchmark. - */ -interface AclProvider { - AclAddReplace next(); - void setAclIndex(final int index); -} 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/AclProviderImpl.java deleted file mode 100644 index 98894fe1d..000000000 --- a/it/jvpp-benchmark/src/main/java/io/fd/hc2vpp/it/jvpp/benchmark/AclProviderImpl.java +++ /dev/null @@ -1,105 +0,0 @@ -/* - * 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; - -import io.fd.vpp.jvpp.acl.dto.AclAddReplace; -import io.fd.vpp.jvpp.acl.types.AclRule; -import javax.annotation.concurrent.NotThreadSafe; - -@NotThreadSafe -class AclProviderImpl implements AclProvider { - private static final int CREATE_NEW_ACL = -1; - private static final short MAX_PORT_NUMBER = (short) 65535; - - private final int aclSetSize; - private final AclAddReplace[] acls; - private final IpProvider ipProvider = new IpProvider(); - - /** - * Pointer to ACL to be returned by invocation of {@link #next()} method. - */ - private int currentAcl = 0; - - AclProviderImpl(final int aclSetSize, final int aclSize) { - this.aclSetSize = aclSetSize; - acls = new AclAddReplace[aclSetSize]; - initAcls(aclSetSize, aclSize); - } - - @Override - public AclAddReplace next() { - final AclAddReplace result = acls[currentAcl]; - currentAcl = (currentAcl + 1) % aclSetSize; - return result; - } - - @Override - public void setAclIndex(final int index) { - for (int i = 0; i < aclSetSize; ++i) { - acls[i].aclIndex = index; - } - } - - private void initAcls(final int aclSetSize, final int aclSize) { - for (int i = 0; i < aclSetSize; ++i) { - acls[i] = createAddReplaceRequest(aclSize, CREATE_NEW_ACL); - } - } - - private AclAddReplace createAddReplaceRequest(final int size, final int index) { - AclAddReplace request = new AclAddReplace(); - request.aclIndex = index; - request.count = size; - request.r = createRules(size); - return request; - } - - private AclRule[] createRules(final int size) { - final AclRule[] rules = new AclRule[size]; - for (int i = 0; i < size; ++i) { - rules[i] = new AclRule(); - rules[i].isIpv6 = 0; - rules[i].isPermit = 1; - rules[i].srcIpAddr = ipProvider.next(); - rules[i].srcIpPrefixLen = 32; - rules[i].dstIpAddr = ipProvider.next(); - rules[i].dstIpPrefixLen = 32; - rules[i].dstportOrIcmpcodeFirst = 0; - rules[i].dstportOrIcmpcodeLast = MAX_PORT_NUMBER; - rules[i].srcportOrIcmptypeFirst = 0; - rules[i].srcportOrIcmptypeLast = MAX_PORT_NUMBER; - rules[i].proto = 17; // UDP - } - return rules; - } - - private static final class IpProvider { - private long ip = 0x01000001; // 1.0.0.1 - - private static byte[] getIp(final int i) { - int b1 = (i >> 24) & 0xff; - int b2 = (i >> 16) & 0xff; - int b3 = (i >> 8) & 0xff; - int b4 = i & 0xff; - return new byte[] {(byte) b1, (byte) b2, (byte) b3, (byte) b4}; - } - - private byte[] next() { - return getIp((int) (ip++)); - } - } -} \ No newline at end of file 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/AclUpdateBenchmark.java deleted file mode 100644 index 3ec7be953..000000000 --- a/it/jvpp-benchmark/src/main/java/io/fd/hc2vpp/it/jvpp/benchmark/AclUpdateBenchmark.java +++ /dev/null @@ -1,215 +0,0 @@ -/* - * 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; - -import static io.fd.hc2vpp.it.jvpp.benchmark.AclUpdateBenchmark.InterfaceMode.L2; -import static io.fd.hc2vpp.it.jvpp.benchmark.AclUpdateBenchmark.InterfaceMode.L3; - -import com.google.common.io.CharStreams; -import io.fd.vpp.jvpp.JVppRegistryImpl; -import io.fd.vpp.jvpp.acl.JVppAclImpl; -import io.fd.vpp.jvpp.acl.dto.AclInterfaceSetAclList; -import io.fd.vpp.jvpp.acl.future.FutureJVppAclFacade; -import io.fd.vpp.jvpp.core.JVppCoreImpl; -import io.fd.vpp.jvpp.core.dto.BridgeDomainAddDel; -import io.fd.vpp.jvpp.core.dto.CreateLoopback; -import io.fd.vpp.jvpp.core.dto.CreateLoopbackReply; -import io.fd.vpp.jvpp.core.dto.SwInterfaceAddDelAddress; -import io.fd.vpp.jvpp.core.dto.SwInterfaceSetFlags; -import io.fd.vpp.jvpp.core.dto.SwInterfaceSetL2Bridge; -import io.fd.vpp.jvpp.core.future.FutureJVppCoreFacade; -import io.fd.vpp.jvpp.dto.JVppReply; -import java.io.IOException; -import java.io.InputStreamReader; -import java.nio.charset.StandardCharsets; -import java.util.Arrays; -import java.util.concurrent.CompletionStage; -import java.util.concurrent.ExecutionException; -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 AclUpdateBenchmark { - private static final Logger LOG = LoggerFactory.getLogger(AclUpdateBenchmark.class); - - @Param( {"100"}) - private int aclSize; - - @Param( {"100"}) - private int aclSetSize; - - @Param( {"L3"}) - private InterfaceMode mode; - - private AclProvider aclProvider; - private JVppRegistryImpl registry; - private FutureJVppAclFacade jvppAcl; - private FutureJVppCoreFacade jvppCore; - - @Benchmark - public void testMethod() throws Exception { - jvppAcl.aclAddReplace(aclProvider.next()).toCompletableFuture().get(); - } - - @Setup(Level.Iteration) - public void setup() throws Exception { - initAclProvider(); - startVpp(); - connect(); - initAcl(); - } - - @TearDown(Level.Iteration) - public void tearDown() throws Exception { - disconnect(); - stopVpp(); - } - - private void initAclProvider() { - aclProvider = new AclProviderImpl(aclSetSize, aclSize); - } - - 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()); - jvppAcl = new FutureJVppAclFacade(registry, new JVppAclImpl()); - LOG.info("Successfully connected to JVPP"); - } - - private void disconnect() throws Exception { - LOG.info("Disconnecting ..."); - jvppAcl.close(); - jvppCore.close(); - registry.close(); - LOG.info("Successfully disconnected ..."); - } - - /** - * Initializes loopback interface, creates ACL and assigns it to loop0. - */ - private void initAcl() - throws ExecutionException, InterruptedException { - // Create loopback interface - final CreateLoopbackReply loop0 = invoke(jvppCore.createLoopback(new CreateLoopback())); - - // Enable loop0 - final SwInterfaceSetFlags flags = new SwInterfaceSetFlags(); - flags.adminUpDown = 1; - flags.swIfIndex = loop0.swIfIndex; - invoke(jvppCore.swInterfaceSetFlags(flags)); - - if (L3.equals(mode)) { - // Assign IP to loop0 - final SwInterfaceAddDelAddress address = new SwInterfaceAddDelAddress(); - address.address = new byte[]{1,0,0,0}; - address.addressLength = 8; - address.isAdd = 1; - address.swIfIndex = loop0.swIfIndex; - invoke(jvppCore.swInterfaceAddDelAddress(address)); - } else if (L2.equals(mode)) { - // Create bridge domain 1 - final BridgeDomainAddDel bd = new BridgeDomainAddDel(); - bd.bdId = 1; - bd.isAdd = 1; - invoke(jvppCore.bridgeDomainAddDel(bd)); - - // Assign loop0 to BD1: - final SwInterfaceSetL2Bridge loop0Bridge = new SwInterfaceSetL2Bridge(); - loop0Bridge.bdId = bd.bdId; - loop0Bridge.rxSwIfIndex = loop0.swIfIndex; - loop0Bridge.enable = 1; // set L2 mode - invoke(jvppCore.swInterfaceSetL2Bridge(loop0Bridge)); - } - - // Create ACL - final int aclId = invoke(jvppAcl.aclAddReplace(aclProvider.next())).aclIndex; - - // Assign the ACL to loop0 interface - final AclInterfaceSetAclList aclList = new AclInterfaceSetAclList(); - aclList.swIfIndex = loop0.swIfIndex; - aclList.count = 1; - aclList.nInput = 1; - aclList.acls = new int[] {aclId}; - invoke(jvppAcl.aclInterfaceSetAclList(aclList)); - - // Use ACL index in subsequent executions of aclProvider.next() method - aclProvider.setAclIndex(aclId); - } - - public enum InterfaceMode { - L2, L3 - } - - private static > R invoke(final CompletionStage completionStage) - throws ExecutionException, InterruptedException { - return completionStage.toCompletableFuture().get(); - } -} diff --git a/it/jvpp-benchmark/src/main/java/io/fd/hc2vpp/it/jvpp/benchmark/acl/AclProvider.java b/it/jvpp-benchmark/src/main/java/io/fd/hc2vpp/it/jvpp/benchmark/acl/AclProvider.java new file mode 100644 index 000000000..f3459916e --- /dev/null +++ b/it/jvpp-benchmark/src/main/java/io/fd/hc2vpp/it/jvpp/benchmark/acl/AclProvider.java @@ -0,0 +1,27 @@ +/* + * 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.acl; + +import io.fd.vpp.jvpp.acl.dto.AclAddReplace; + +/** + * Provides ACLs for JVpp Benchmark. + */ +interface AclProvider { + AclAddReplace next(); + void setAclIndex(final int index); +} diff --git a/it/jvpp-benchmark/src/main/java/io/fd/hc2vpp/it/jvpp/benchmark/acl/AclProviderImpl.java b/it/jvpp-benchmark/src/main/java/io/fd/hc2vpp/it/jvpp/benchmark/acl/AclProviderImpl.java new file mode 100644 index 000000000..ca0ddbb8f --- /dev/null +++ b/it/jvpp-benchmark/src/main/java/io/fd/hc2vpp/it/jvpp/benchmark/acl/AclProviderImpl.java @@ -0,0 +1,105 @@ +/* + * 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.acl; + +import io.fd.vpp.jvpp.acl.dto.AclAddReplace; +import io.fd.vpp.jvpp.acl.types.AclRule; +import javax.annotation.concurrent.NotThreadSafe; + +@NotThreadSafe +class AclProviderImpl implements AclProvider { + private static final int CREATE_NEW_ACL = -1; + private static final short MAX_PORT_NUMBER = (short) 65535; + + private final int aclSetSize; + private final AclAddReplace[] acls; + private final IpProvider ipProvider = new IpProvider(); + + /** + * Pointer to ACL to be returned by invocation of {@link #next()} method. + */ + private int currentAcl = 0; + + AclProviderImpl(final int aclSetSize, final int aclSize) { + this.aclSetSize = aclSetSize; + acls = new AclAddReplace[aclSetSize]; + initAcls(aclSetSize, aclSize); + } + + @Override + public AclAddReplace next() { + final AclAddReplace result = acls[currentAcl]; + currentAcl = (currentAcl + 1) % aclSetSize; + return result; + } + + @Override + public void setAclIndex(final int index) { + for (int i = 0; i < aclSetSize; ++i) { + acls[i].aclIndex = index; + } + } + + private void initAcls(final int aclSetSize, final int aclSize) { + for (int i = 0; i < aclSetSize; ++i) { + acls[i] = createAddReplaceRequest(aclSize, CREATE_NEW_ACL); + } + } + + private AclAddReplace createAddReplaceRequest(final int size, final int index) { + AclAddReplace request = new AclAddReplace(); + request.aclIndex = index; + request.count = size; + request.r = createRules(size); + return request; + } + + private AclRule[] createRules(final int size) { + final AclRule[] rules = new AclRule[size]; + for (int i = 0; i < size; ++i) { + rules[i] = new AclRule(); + rules[i].isIpv6 = 0; + rules[i].isPermit = 1; + rules[i].srcIpAddr = ipProvider.next(); + rules[i].srcIpPrefixLen = 32; + rules[i].dstIpAddr = ipProvider.next(); + rules[i].dstIpPrefixLen = 32; + rules[i].dstportOrIcmpcodeFirst = 0; + rules[i].dstportOrIcmpcodeLast = MAX_PORT_NUMBER; + rules[i].srcportOrIcmptypeFirst = 0; + rules[i].srcportOrIcmptypeLast = MAX_PORT_NUMBER; + rules[i].proto = 17; // UDP + } + return rules; + } + + private static final class IpProvider { + private long ip = 0x01000001; // 1.0.0.1 + + private static byte[] getIp(final int i) { + int b1 = (i >> 24) & 0xff; + int b2 = (i >> 16) & 0xff; + int b3 = (i >> 8) & 0xff; + int b4 = i & 0xff; + return new byte[] {(byte) b1, (byte) b2, (byte) b3, (byte) b4}; + } + + private byte[] next() { + return getIp((int) (ip++)); + } + } +} \ No newline at end of file diff --git a/it/jvpp-benchmark/src/main/java/io/fd/hc2vpp/it/jvpp/benchmark/acl/AclUpdateBenchmark.java b/it/jvpp-benchmark/src/main/java/io/fd/hc2vpp/it/jvpp/benchmark/acl/AclUpdateBenchmark.java new file mode 100644 index 000000000..e8bf2a833 --- /dev/null +++ b/it/jvpp-benchmark/src/main/java/io/fd/hc2vpp/it/jvpp/benchmark/acl/AclUpdateBenchmark.java @@ -0,0 +1,215 @@ +/* + * 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.acl; + +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; +import io.fd.vpp.jvpp.acl.JVppAclImpl; +import io.fd.vpp.jvpp.acl.dto.AclInterfaceSetAclList; +import io.fd.vpp.jvpp.acl.future.FutureJVppAclFacade; +import io.fd.vpp.jvpp.core.JVppCoreImpl; +import io.fd.vpp.jvpp.core.dto.BridgeDomainAddDel; +import io.fd.vpp.jvpp.core.dto.CreateLoopback; +import io.fd.vpp.jvpp.core.dto.CreateLoopbackReply; +import io.fd.vpp.jvpp.core.dto.SwInterfaceAddDelAddress; +import io.fd.vpp.jvpp.core.dto.SwInterfaceSetFlags; +import io.fd.vpp.jvpp.core.dto.SwInterfaceSetL2Bridge; +import io.fd.vpp.jvpp.core.future.FutureJVppCoreFacade; +import io.fd.vpp.jvpp.dto.JVppReply; +import java.io.IOException; +import java.io.InputStreamReader; +import java.nio.charset.StandardCharsets; +import java.util.Arrays; +import java.util.concurrent.CompletionStage; +import java.util.concurrent.ExecutionException; +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 AclUpdateBenchmark { + private static final Logger LOG = LoggerFactory.getLogger(AclUpdateBenchmark.class); + + @Param( {"100"}) + private int aclSize; + + @Param( {"100"}) + private int aclSetSize; + + @Param( {"L3"}) + private InterfaceMode mode; + + private AclProvider aclProvider; + private JVppRegistryImpl registry; + private FutureJVppAclFacade jvppAcl; + private FutureJVppCoreFacade jvppCore; + + @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(); + } + + @Setup(Level.Iteration) + public void setup() throws Exception { + initAclProvider(); + startVpp(); + connect(); + initAcl(); + } + + @TearDown(Level.Iteration) + public void tearDown() throws Exception { + disconnect(); + stopVpp(); + } + + private void initAclProvider() { + aclProvider = new AclProviderImpl(aclSetSize, aclSize); + } + + 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()); + jvppAcl = new FutureJVppAclFacade(registry, new JVppAclImpl()); + LOG.info("Successfully connected to JVPP"); + } + + private void disconnect() throws Exception { + LOG.info("Disconnecting ..."); + jvppAcl.close(); + jvppCore.close(); + registry.close(); + LOG.info("Successfully disconnected ..."); + } + + /** + * Initializes loopback interface, creates ACL and assigns it to loop0. + */ + private void initAcl() + throws ExecutionException, InterruptedException { + // Create loopback interface + final CreateLoopbackReply loop0 = invoke(jvppCore.createLoopback(new CreateLoopback())); + + // Enable loop0 + final SwInterfaceSetFlags flags = new SwInterfaceSetFlags(); + flags.adminUpDown = 1; + flags.swIfIndex = loop0.swIfIndex; + invoke(jvppCore.swInterfaceSetFlags(flags)); + + if (L3.equals(mode)) { + // Assign IP to loop0 + final SwInterfaceAddDelAddress address = new SwInterfaceAddDelAddress(); + address.address = new byte[]{1,0,0,0}; + address.addressLength = 8; + address.isAdd = 1; + address.swIfIndex = loop0.swIfIndex; + invoke(jvppCore.swInterfaceAddDelAddress(address)); + } else if (L2.equals(mode)) { + // Create bridge domain 1 + final BridgeDomainAddDel bd = new BridgeDomainAddDel(); + bd.bdId = 1; + bd.isAdd = 1; + invoke(jvppCore.bridgeDomainAddDel(bd)); + + // Assign loop0 to BD1: + final SwInterfaceSetL2Bridge loop0Bridge = new SwInterfaceSetL2Bridge(); + loop0Bridge.bdId = bd.bdId; + loop0Bridge.rxSwIfIndex = loop0.swIfIndex; + loop0Bridge.enable = 1; // set L2 mode + invoke(jvppCore.swInterfaceSetL2Bridge(loop0Bridge)); + } + + // Create ACL + final int aclId = invoke(jvppAcl.aclAddReplace(aclProvider.next())).aclIndex; + + // Assign the ACL to loop0 interface + final AclInterfaceSetAclList aclList = new AclInterfaceSetAclList(); + aclList.swIfIndex = loop0.swIfIndex; + aclList.count = 1; + aclList.nInput = 1; + aclList.acls = new int[] {aclId}; + invoke(jvppAcl.aclInterfaceSetAclList(aclList)); + + // Use ACL index in subsequent executions of aclProvider.next() method + aclProvider.setAclIndex(aclId); + } + + public enum InterfaceMode { + L2, L3 + } + + private static > R invoke(final CompletionStage completionStage) + throws ExecutionException, InterruptedException { + return completionStage.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/AclProviderImplTest.java deleted file mode 100644 index fd4b0d7ff..000000000 --- a/it/jvpp-benchmark/src/test/java/io/fd/hc2vpp/it/jvpp/benchmark/AclProviderImplTest.java +++ /dev/null @@ -1,60 +0,0 @@ -/* - * 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; - -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertNotEquals; - -import io.fd.vpp.jvpp.acl.dto.AclAddReplace; -import java.util.Arrays; -import org.junit.Test; - -public class AclProviderImplTest { - @Test - public void testAclsDiffer() throws Exception { - final AclProviderImpl aclProvider = new AclProviderImpl(2, 2); - final AclAddReplace acl0 = aclProvider.next(); - final AclAddReplace acl1 = aclProvider.next(); - final AclAddReplace acl2 = aclProvider.next(); - final AclAddReplace acl3 = aclProvider.next(); - - // Test if ACLs are provided in round-robin fashion - assertEquals("ACLs 0 and 2 should be equal", acl0, acl2); - assertEquals("ACLs 1 and 3 should be equal", acl1, acl3); - assertNotEquals("ACLs 0 and 1 should be different", acl0, acl1); - } - - @Test - public void testRulesDiffer() throws Exception { - final int aclSize = 3; - final AclProviderImpl aclProvider = new AclProviderImpl(1, aclSize); - final AclAddReplace acl = aclProvider.next(); - assertEquals("Unexpected value of AclAddReplace.count", aclSize, acl.count); - assertEquals("Unexpected size of ACL", aclSize, acl.r.length); - assertNotEquals("ACL rules 0 and 1 should be different", acl.r[0], acl.r[1]); - assertNotEquals("ACL rules 1 and 2 should be different", acl.r[1], acl.r[2]); - assertNotEquals("ACL rules 0 and 2 should be different", acl.r[0], acl.r[2]); - } - - @Test - public void testIPsWithinRuleDiffer() throws Exception { - final AclProviderImpl aclProvider = new AclProviderImpl(1, 1); - final AclAddReplace acl = aclProvider.next(); - assertFalse(Arrays.equals(acl.r[0].srcIpAddr, acl.r[0].dstIpAddr)); - } -} \ No newline at end of file diff --git a/it/jvpp-benchmark/src/test/java/io/fd/hc2vpp/it/jvpp/benchmark/acl/AclProviderImplTest.java b/it/jvpp-benchmark/src/test/java/io/fd/hc2vpp/it/jvpp/benchmark/acl/AclProviderImplTest.java new file mode 100644 index 000000000..d54d178e1 --- /dev/null +++ b/it/jvpp-benchmark/src/test/java/io/fd/hc2vpp/it/jvpp/benchmark/acl/AclProviderImplTest.java @@ -0,0 +1,60 @@ +/* + * 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.acl; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertNotEquals; + +import io.fd.vpp.jvpp.acl.dto.AclAddReplace; +import java.util.Arrays; +import org.junit.Test; + +public class AclProviderImplTest { + @Test + public void testAclsDiffer() throws Exception { + final AclProviderImpl aclProvider = new AclProviderImpl(2, 2); + final AclAddReplace acl0 = aclProvider.next(); + final AclAddReplace acl1 = aclProvider.next(); + final AclAddReplace acl2 = aclProvider.next(); + final AclAddReplace acl3 = aclProvider.next(); + + // Test if ACLs are provided in round-robin fashion + assertEquals("ACLs 0 and 2 should be equal", acl0, acl2); + assertEquals("ACLs 1 and 3 should be equal", acl1, acl3); + assertNotEquals("ACLs 0 and 1 should be different", acl0, acl1); + } + + @Test + public void testRulesDiffer() throws Exception { + final int aclSize = 3; + final AclProviderImpl aclProvider = new AclProviderImpl(1, aclSize); + final AclAddReplace acl = aclProvider.next(); + assertEquals("Unexpected value of AclAddReplace.count", aclSize, acl.count); + assertEquals("Unexpected size of ACL", aclSize, acl.r.length); + assertNotEquals("ACL rules 0 and 1 should be different", acl.r[0], acl.r[1]); + assertNotEquals("ACL rules 1 and 2 should be different", acl.r[1], acl.r[2]); + assertNotEquals("ACL rules 0 and 2 should be different", acl.r[0], acl.r[2]); + } + + @Test + public void testIPsWithinRuleDiffer() throws Exception { + final AclProviderImpl aclProvider = new AclProviderImpl(1, 1); + final AclAddReplace acl = aclProvider.next(); + assertFalse(Arrays.equals(acl.r[0].srcIpAddr, acl.r[0].dstIpAddr)); + } +} \ No newline at end of file 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 -- cgit 1.2.3-korg