aboutsummaryrefslogtreecommitdiffstats
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/vpp-api/java/jvpp-core/io/fd/vpp/jvpp/core/examples/CallbackApiReadPerfTest.java146
-rw-r--r--src/vpp-api/java/jvpp-core/io/fd/vpp/jvpp/core/examples/CallbackApiWritePerfTest.java162
-rw-r--r--src/vpp-api/java/jvpp-core/io/fd/vpp/jvpp/core/examples/FutureApiReadPerfTest.java137
-rw-r--r--src/vpp-api/java/jvpp-core/io/fd/vpp/jvpp/core/examples/Readme.txt11
4 files changed, 454 insertions, 2 deletions
diff --git a/src/vpp-api/java/jvpp-core/io/fd/vpp/jvpp/core/examples/CallbackApiReadPerfTest.java b/src/vpp-api/java/jvpp-core/io/fd/vpp/jvpp/core/examples/CallbackApiReadPerfTest.java
new file mode 100644
index 00000000000..6ff440dccc0
--- /dev/null
+++ b/src/vpp-api/java/jvpp-core/io/fd/vpp/jvpp/core/examples/CallbackApiReadPerfTest.java
@@ -0,0 +1,146 @@
+/*
+ * Copyright (c) 2017 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.vpp.jvpp.core.examples;
+
+import io.fd.vpp.jvpp.JVpp;
+import io.fd.vpp.jvpp.JVppRegistry;
+import io.fd.vpp.jvpp.JVppRegistryImpl;
+import io.fd.vpp.jvpp.VppCallbackException;
+import io.fd.vpp.jvpp.core.JVppCoreImpl;
+import io.fd.vpp.jvpp.core.callback.ShowVersionReplyCallback;
+import io.fd.vpp.jvpp.core.dto.*;
+
+import java.util.logging.Logger;
+
+public class CallbackApiReadPerfTest {
+
+ private static final Logger LOG = Logger.getLogger(CallbackApiReadPerfTest.class.getName());
+ private static final ShowVersion REQUEST = new ShowVersion();
+
+ /**
+ *
+ * @param args - for running for one sec requires no parameter
+ * - for running for set amount of requests requires one parameters, desired REQUEST amount
+ * @throws Exception if arguments aren't String representations of numbers
+ */
+ public static void main(String[] args) throws Exception {
+ if (args.length != 0) {
+ testInvokeCounter(true, Integer.parseUnsignedInt(args[0]));
+ } else {
+ testInvokeCounter(false, 0);
+ }
+ }
+
+ /**
+ *
+ * @param setCount true = run with set amount of requests, false = run for 1 sec
+ * @param count number of request with which test should be run
+ * @throws Exception
+ */
+ private static void testInvokeCounter(boolean setCount, int count) throws Exception {
+ LOG.info("Testing callback API Invocation Counter");
+ try (final JVppRegistry registry = new JVppRegistryImpl("CallbackApiReadPerfTest");
+ final JVpp jvpp = new JVppCoreImpl()) {
+ TestCallback callback = new TestCallback(count);
+ registry.register(jvpp, callback);
+ if (!setCount) {
+ for(int i = 0; i < 5; i++) {
+ callback.reset();
+ LOG.info("Starting invocation for 1sec");
+ long time = System.nanoTime();
+ do {
+ jvpp.send(REQUEST);
+ } while (System.nanoTime() - time < 1000000000 || callback.stop());
+ int replyCount = callback.getReplyCounter();
+ LOG.info(String.format("Invocation count within 1 second: %d", replyCount));
+ }
+ } else {
+ for (int i = 0; i < 5; i++) {
+ LOG.info("Starting invocations");
+ callback.reset();
+ long time = System.nanoTime();
+ for (int x = 0; x < count; x++) {
+ jvpp.send(REQUEST);
+ }
+ long timeAfter = callback.getTime();
+ LOG.info(String.format("Invocations took %d ns (%f invocations/s)", timeAfter - time,
+ count * (1000000000.0/(timeAfter - time))));
+ }
+ }
+
+
+ Thread.sleep(1000);
+ LOG.info("Disconnecting...");
+ }
+ Thread.sleep(1000);
+ }
+
+ static class TestCallback implements ShowVersionReplyCallback {
+
+ private int replyCounter = 0;
+ private int count;
+ private long time = 0;
+ private boolean stop = false;
+
+ public TestCallback(int count) throws Exception {
+ this.count = count;
+ }
+
+ public int getReplyCounter() {
+ return replyCounter;
+ }
+
+ public void reset() {
+ replyCounter = 0;
+ time = 0;
+ stop = false;
+ }
+
+ public boolean stop() {
+ this.stop = true;
+ return false;
+ }
+
+ /* actual method called from VPP
+ not thread safe but since there's only one VPP thread listening for requests and calling
+ this method it's OK
+ */
+ @Override
+ public void onShowVersionReply(final ShowVersionReply msg) {
+ if (stop) {
+ return;
+ }
+ replyCounter++;
+ if (replyCounter == count ) {
+ time = System.nanoTime();
+ }
+ }
+
+ @Override
+ public void onError(VppCallbackException ex) {
+ System.out.printf("Received onError exception: call=%s, context=%d, retval=%d%n", ex.getMethodName(),
+ ex.getCtxId(), ex.getErrorCode());
+ }
+
+ public long getTime() throws Exception {
+ while(time == 0) {
+ Thread.sleep(1000);
+ }
+ return time;
+ }
+ }
+}
diff --git a/src/vpp-api/java/jvpp-core/io/fd/vpp/jvpp/core/examples/CallbackApiWritePerfTest.java b/src/vpp-api/java/jvpp-core/io/fd/vpp/jvpp/core/examples/CallbackApiWritePerfTest.java
new file mode 100644
index 00000000000..1940ddcf378
--- /dev/null
+++ b/src/vpp-api/java/jvpp-core/io/fd/vpp/jvpp/core/examples/CallbackApiWritePerfTest.java
@@ -0,0 +1,162 @@
+/*
+ * Copyright (c) 2017 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.vpp.jvpp.core.examples;
+
+import io.fd.vpp.jvpp.JVpp;
+import io.fd.vpp.jvpp.JVppRegistry;
+import io.fd.vpp.jvpp.JVppRegistryImpl;
+import io.fd.vpp.jvpp.VppCallbackException;
+import io.fd.vpp.jvpp.core.JVppCoreImpl;
+import io.fd.vpp.jvpp.core.dto.*;
+import io.fd.vpp.jvpp.core.callback.ClassifyAddDelTableReplyCallback;
+
+import java.util.logging.Logger;
+
+public class CallbackApiWritePerfTest {
+
+ private static final Logger LOG = Logger.getLogger(CallbackApiWritePerfTest.class.getName());
+ private static final ClassifyAddDelTable REQUEST = createAddDelTable();
+
+ private static ClassifyAddDelTable createAddDelTable () {
+ ClassifyAddDelTable addDelTable = new ClassifyAddDelTable();
+ addDelTable.isAdd = 1;
+ addDelTable.tableIndex = -1;
+ addDelTable.nbuckets = 2;
+ addDelTable.memorySize = 2 << 20;
+ addDelTable.nextTableIndex = ~0; // default
+ addDelTable.missNextIndex = ~0; // default
+ addDelTable.skipNVectors = 0;
+ addDelTable.matchNVectors = 1;
+ addDelTable.mask =
+ new byte[] {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
+ (byte) 0xff, (byte) 0xff, 0x00, 0x00, 0x00, 0x00};
+ return addDelTable;
+ };
+
+ /**
+ *
+ * @param args - for running for one sec requires no parameter
+ * - for running for set amount of requests requires one parameters, desired REQUEST amount
+ * @throws Exception if arguments aren't String representations of numbers
+ */
+ public static void main(String[] args) throws Exception {
+ if (args.length != 0) {
+ testInvokeCounter(true, Integer.parseUnsignedInt(args[0]));
+ } else {
+ testInvokeCounter(false, 0);
+ }
+ }
+
+ /**
+ *
+ * @param setCount true = run with set amount of requests, false = run for 1 sec
+ * @param count number of requests with which test should be run
+ * @throws Exception
+ */
+ private static void testInvokeCounter(boolean setCount, int count) throws Exception {
+ LOG.info("Testing callback API Invocation Counter");
+ try (final JVppRegistry registry = new JVppRegistryImpl("CallbackApiWritePerfTest");
+ final JVpp jvpp = new JVppCoreImpl()) {
+ TestCallback callback = new TestCallback(count);
+ registry.register(jvpp, callback);
+ if (!setCount) {
+ for(int i = 0; i < 5; i++) {
+ callback.reset();
+ LOG.info("Starting invocation for 1sec");
+ long time = System.nanoTime();
+ do {
+ jvpp.send(REQUEST);
+ } while (System.nanoTime() - time < 1000000000 || callback.stop());
+ int replyCount = callback.getReplyCounter();
+ LOG.info(String.format("Invocation count within 1 second: %d", replyCount));
+ }
+ } else {
+ for(int i = 0; i < 5; i++) {
+ LOG.info("Starting invocations");
+ callback.reset();
+ long time = System.nanoTime();
+ for (int x = 1; x <= count; x++) {
+ jvpp.send(REQUEST);
+ }
+ long timeAfter = callback.getTime();
+ LOG.info(String.format("Invocations took %d ns (%f invocations/s)", timeAfter - time,
+ count * (1000000000.0 / (timeAfter - time))));
+ }
+ }
+
+
+ Thread.sleep(1000);
+ LOG.info("Disconnecting...");
+ }
+ Thread.sleep(1000);
+ }
+
+ static class TestCallback implements ClassifyAddDelTableReplyCallback {
+
+ private int replyCounter = 0;
+ private int count;
+ private long time = 0;
+ private boolean stop = false;
+
+ public TestCallback(int count) throws Exception {
+ this.count = count;
+ }
+
+ public int getReplyCounter() {
+ return replyCounter;
+ }
+
+ public void reset() {
+ replyCounter = 0;
+ time = 0;
+ stop = false;
+ }
+
+ public boolean stop() {
+ this.stop = true;
+ return false;
+ }
+
+ /* actual method called from VPP
+ not thread safe but since there's only one VPP thread listening for requests and calling
+ this method it's OK
+ */
+ @Override
+ public void onClassifyAddDelTableReply(final ClassifyAddDelTableReply msg) {
+ if (stop) {
+ return;
+ }
+ replyCounter++;
+ if (replyCounter == count ) {
+ time = System.nanoTime();
+ }
+ }
+
+ @Override
+ public void onError(VppCallbackException ex) {
+ System.out.printf("Received onError exception: call=%s, context=%d, retval=%d%n", ex.getMethodName(),
+ ex.getCtxId(), ex.getErrorCode());
+ }
+
+ public long getTime() throws Exception {
+ while(time == 0) {
+ Thread.sleep(1000);
+ }
+ return time;
+ }
+ }
+}
diff --git a/src/vpp-api/java/jvpp-core/io/fd/vpp/jvpp/core/examples/FutureApiReadPerfTest.java b/src/vpp-api/java/jvpp-core/io/fd/vpp/jvpp/core/examples/FutureApiReadPerfTest.java
new file mode 100644
index 00000000000..f335b28dfa3
--- /dev/null
+++ b/src/vpp-api/java/jvpp-core/io/fd/vpp/jvpp/core/examples/FutureApiReadPerfTest.java
@@ -0,0 +1,137 @@
+/*
+ * Copyright (c) 2017 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.vpp.jvpp.core.examples;
+
+import io.fd.vpp.jvpp.JVppRegistry;
+import io.fd.vpp.jvpp.JVppRegistryImpl;
+import io.fd.vpp.jvpp.core.JVppCoreImpl;
+import io.fd.vpp.jvpp.core.callback.ShowVersionReplyCallback;
+import io.fd.vpp.jvpp.core.dto.*;
+import io.fd.vpp.jvpp.core.future.FutureJVppCoreFacade;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.logging.Logger;
+
+public class FutureApiReadPerfTest {
+
+ private static final Logger LOG = Logger.getLogger(FutureApiReadPerfTest.class.getName());
+ private static final ShowVersion REQUEST = new ShowVersion();
+ private static volatile int currentCount = 0;
+ private static int desiredCount = 0;
+ private static long timeAfter = 0;
+ private static volatile boolean stop = false;
+ /**
+ * Run after reply message is received
+ * in case of running for 1 sec check if time passed (stop variable) and if it does skip processing
+ * in case of running for set amount of REQUEST, record time in which was last reply received
+ * not thread save but since reading part process only one message at a time it's ok
+ */
+ private static Runnable replyFc = () -> {
+ if (stop) {
+ return;
+ }
+ currentCount++;
+ if(currentCount == desiredCount) {
+ timeAfter = System.nanoTime();
+ }
+ };
+
+ /**
+ * Used to reset counters and flags between runs
+ */
+ private static void reset() {
+ currentCount = 0;
+ timeAfter = 0;
+ stop = false;
+ }
+
+ public static boolean stop() {
+ stop = true;
+ return false;
+ }
+
+ /**
+ *
+ * @return time of last reply received
+ * @throws Exception during thread sleep
+ */
+ private static long getTime() throws Exception {
+ while(timeAfter == 0) {
+ LOG.info(String.format("Received %d replies", currentCount));
+ Thread.sleep(1000);
+ }
+ return timeAfter;
+ }
+
+ /**
+ *
+ * @param args - for running for one sec requires no parameter
+ * - for running for set amount of requests requires one parameters, desired REQUEST amount
+ * @throws Exception if arguments aren't String representations of numbers
+ */
+ public static void main(String[] args) throws Exception {
+ if (args.length == 1) {
+ desiredCount = Integer.parseUnsignedInt(args[0]);
+ testInvokeCounter(true);
+ } else {
+ testInvokeCounter(false);
+ }
+ }
+
+ /**
+ *
+ * @param setCount true = run with set amount of requests, false = run for 1 sec
+ * @throws Exception
+ */
+ private static void testInvokeCounter(boolean setCount) throws Exception {
+ LOG.info("Testing callback API Invocation Counter");
+ try (final JVppRegistry registry = new JVppRegistryImpl("FutureApiReadPerfTest");
+ final FutureJVppCoreFacade jvpp = new FutureJVppCoreFacade(registry, new JVppCoreImpl())) {
+ if (!setCount) {
+ for(int i = 0; i < 5; i++) {
+ reset();
+ LOG.info("Starting invocation for 1sec");
+ long time = System.nanoTime();
+ do {
+ CompletableFuture<ShowVersionReply> replyFuture = jvpp.showVersion(REQUEST).toCompletableFuture();
+ replyFuture.thenRun(replyFc);
+ } while (System.nanoTime() - time < 1000000000 || stop());
+ LOG.info(String.format("Invocation count within 1 second: %d", currentCount));
+ }
+ } else {
+ for (int i = 0; i < 5; i++) {
+ LOG.info("Starting invocations");
+ reset();
+ long time = System.nanoTime();
+ for (int x = 0; x < desiredCount; x++) {
+ CompletableFuture<ShowVersionReply> replyFuture = jvpp.showVersion(REQUEST).toCompletableFuture();
+ replyFuture.thenRun(replyFc);
+ }
+ LOG.info("Invocations send");
+ long timeAfter = getTime();
+ LOG.info(String.format("Invocations took %d ns (%f invocations/s)", timeAfter - time,
+ desiredCount * (1000000000.0/(timeAfter - time))));
+ }
+ }
+
+
+ Thread.sleep(1000);
+ LOG.info("Disconnecting...");
+ }
+ Thread.sleep(1000);
+ }
+}
diff --git a/src/vpp-api/java/jvpp-core/io/fd/vpp/jvpp/core/examples/Readme.txt b/src/vpp-api/java/jvpp-core/io/fd/vpp/jvpp/core/examples/Readme.txt
index 10c603f5b3a..9fe3c7ac702 100644
--- a/src/vpp-api/java/jvpp-core/io/fd/vpp/jvpp/core/examples/Readme.txt
+++ b/src/vpp-api/java/jvpp-core/io/fd/vpp/jvpp/core/examples/Readme.txt
@@ -2,8 +2,8 @@ This package contains basic examples for jvpp. To run the examples:
- Make sure VPP is running
- From VPP's build-root/ folder execute:
- - release version: sudo java -cp build-vpp-native/vpp/vpp-api/java/jvpp-registry-17.10.jar:build-vpp-native/vpp/vpp-api/java/jvpp-core-17.10.jar io.fd.vpp.jvpp.core.examples.[test name]
- - debug version: sudo java -cp build-vpp_debug-native/vpp/vpp-api/java/jvpp-registry-17.10.jar:build-vpp_debug-native/vpp/vpp-api/java/jvpp-core-17.10.jar io.fd.vpp.jvpp.core.examples.[test name]
+ - release version: sudo java -cp build-vpp-native/vpp/vpp-api/java/jvpp-registry-18.01.jar:build-vpp-native/vpp/vpp-api/java/jvpp-core-18.01.jar io.fd.vpp.jvpp.core.examples.[test name]
+ - debug version: sudo java -cp build-vpp_debug-native/vpp/vpp-api/java/jvpp-registry-18.01.jar:build-vpp_debug-native/vpp/vpp-api/java/jvpp-core-18.01.jar io.fd.vpp.jvpp.core.examples.[test name]
Available examples:
CallbackApiExample - Similar to ControlPingTest, invokes more complex calls (e.g. interface dump) using low level JVpp APIs
@@ -15,3 +15,10 @@ FutureApiNotificationExample - Example of interface notifications using Future b
FutureApiExample - Execution of more complex calls using Future based JVpp facade
L2AclExample - Example of L2 ACL creation
LispAdjacencyExample - Example of lisp adjacency creation and read (custom vpe.api type support showcase)
+
+CallbackApiReadPerfTest, FutureApiReadPerfTest, CallbackApiWritePerfTest - test provide two ways to count invocations:
+1) maximum number of invocations and received replyies within 1 sec
+sudo java -cp build-vpp-native/vpp/vpp-api/java/jvpp-registry-18.01.jar:build-vpp-native/vpp/vpp-api/java/jvpp-core-18.01.jar io.fd.vpp.jvpp.core.examples.[test name]
+2) measure time in ns from first request to receiving last reply over set amount of requests
+sudo java -cp build-vpp-native/vpp/vpp-api/java/jvpp-registry-18.01.jar:build-vpp-native/vpp/vpp-api/java/jvpp-core-18.01.jar io.fd.vpp.jvpp.core.examples.[test name] [number of request to send]
+