import com.samsung.android.beyond.inference.InferenceModuleFactory;
import com.samsung.android.beyond.inference.TensorOutputCallback;
import com.samsung.android.beyond.inference.Peer;
+import com.samsung.android.beyond.inference.PeerInfo;
import com.samsung.android.beyond.inference.tensor.Tensor;
import com.samsung.android.beyond.inference.tensor.TensorHandler;
import com.samsung.android.beyond.inference.tensor.TensorInfo;
import com.samsung.android.beyond.inference.tensor.TensorSet;
import com.samsung.android.beyond.module.peer.NN.NNModule;
+import org.junit.After;
import org.junit.BeforeClass;
import org.junit.Test;
private static String modelAbsolutePath = null;
+ private Peer serverPeer = null;
+
+ private Peer inferencePeer = null;
+
private InferenceHandler inferenceHandler = null;
private TensorHandler tensorHandler = null;
- private Peer inferencePeer = null;
-
@BeforeClass
public static void initialize() {
context = getInstrumentation().getContext();
@Test
public void testAsyncSetOutputCallback() {
- inferenceHandler = InferenceModuleFactory.createHandler(InferenceMode.REMOTE);
- assertNotNull(inferenceHandler);
-
- Peer serverPeer = InferenceModuleFactory.createPeerServer(context, NNModule.NAME);
+ serverPeer = InferenceModuleFactory.createPeerServer(context, NNModule.NAME);
assertNotNull(serverPeer);
assertTrue(serverPeer.setInfo());
assertTrue(serverPeer.activateControlChannel());
assert(false);
}
- Peer.Info info = new Peer.Info();
- info.host = TEST_SERVER_IP;
- info.port = TEST_SERVER_PORT;
- assertTrue(inferencePeer.setInfo(info));
+ assertTrue(inferencePeer.setInfo(new PeerInfo(TEST_SERVER_IP, TEST_SERVER_PORT)));
+
+ inferenceHandler = InferenceModuleFactory.createHandler(InferenceMode.REMOTE);
+ assertNotNull(inferenceHandler);
assertTrue(inferenceHandler.addInferencePeer(inferencePeer)); // Cover activateControlChannel()
assertTrue(inferenceHandler.loadModel(modelAbsolutePath));
assertTrue(inferenceHandler.prepare());
assertTrue(inferenceHandler.run(inputTensorSet));
Looper.loop();
+ }
+ @After
+ public void destroyInferenceModules() {
assertTrue(inferencePeer.deactivateControlChannel());
+ assertTrue(serverPeer.deactivateControlChannel());
+
+ assertTrue(inferenceHandler.removeInferencePeer(inferencePeer));
+
+ serverPeer.close();
+ inferencePeer.close();
+ inferenceHandler.close();
}
}
import com.samsung.android.beyond.inference.InferenceMode;
import com.samsung.android.beyond.inference.InferenceModuleFactory;
import com.samsung.android.beyond.inference.Peer;
+import com.samsung.android.beyond.inference.PeerInfo;
import com.samsung.android.beyond.inference.tensor.Tensor;
import com.samsung.android.beyond.inference.tensor.TensorHandler;
import com.samsung.android.beyond.inference.tensor.TensorInfo;
import com.samsung.android.beyond.inference.tensor.TensorSet;
import com.samsung.android.beyond.module.peer.NN.NNModule;
+import org.junit.After;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
private static String modelAbsolutePath = null;
+ private Peer serverPeer = null;
+
+ private Peer inferencePeer = null;
+
private InferenceHandler inferenceHandler = null;
private TensorHandler tensorHandler = null;
- private Peer inferencePeer = null;
-
@BeforeClass
public static void initialize() {
context = getInstrumentation().getContext();
@Before
public void prepareInferenceModules() {
- inferenceHandler = InferenceModuleFactory.createHandler(InferenceMode.REMOTE);
- assertNotNull(inferenceHandler);
-
- Peer serverPeer = InferenceModuleFactory.createPeerServer(context, NNModule.NAME);
+ serverPeer = InferenceModuleFactory.createPeerServer(context, NNModule.NAME);
assertNotNull(serverPeer);
assertTrue(serverPeer.setInfo());
assertTrue(serverPeer.activateControlChannel());
inferencePeer = InferenceModuleFactory.createPeerClient(context, NNModule.NAME);
assertNotNull(inferencePeer);
- Peer.Info info = new Peer.Info();
- info.host = TEST_SERVER_IP;
- info.port = TEST_SERVER_PORT;
- assertTrue(inferencePeer.setInfo(info));
+ assertTrue(inferencePeer.setInfo(new PeerInfo(TEST_SERVER_IP, TEST_SERVER_PORT)));
+
+ inferenceHandler = InferenceModuleFactory.createHandler(InferenceMode.REMOTE);
+ assertNotNull(inferenceHandler);
}
@Test
public void testAddInferencePeer() {
assertTrue(inferenceHandler.addInferencePeer(inferencePeer)); // Cover activateControlChannel()
-
- assertTrue(inferencePeer.deactivateControlChannel());
}
@Test
assertTrue(inferenceHandler.addInferencePeer(inferencePeer)); // Cover activateControlChannel()
assertTrue(inferenceHandler.loadModel(modelAbsolutePath));
-
- assertTrue(inferencePeer.deactivateControlChannel());
}
@Test
assertTrue(inferenceHandler.loadModel(modelAbsolutePath));
assertTrue(inferenceHandler.prepare());
-
- assertTrue(inferencePeer.deactivateControlChannel());
}
@Test
}
assertTrue(inferenceHandler.run(inputTensorSet));
+ }
+ @After
+ public void destroyInferenceModules() {
assertTrue(inferencePeer.deactivateControlChannel());
+ assertTrue(serverPeer.deactivateControlChannel());
+
+ assertTrue(inferenceHandler.removeInferencePeer(inferencePeer));
+
+ serverPeer.close();
+ inferencePeer.close();
+ inferenceHandler.close();
}
}
import com.samsung.android.beyond.authenticator.Authenticator;
import com.samsung.android.beyond.inference.InferenceModuleFactory;
import com.samsung.android.beyond.inference.Peer;
+import com.samsung.android.beyond.inference.PeerInfo;
import com.samsung.android.beyond.module.authenticator.SSL.SSLModule;
import com.samsung.android.beyond.module.peer.NN.NNModule;
private static Context context;
+ private Peer serverPeer = null;
+
private Peer inferencePeer = null;
@BeforeClass
@Test
public void testCreatePeerServer() {
- inferencePeer = InferenceModuleFactory.createPeerServer(context, NNModule.NAME);
- assertNotNull(inferencePeer);
+ serverPeer = InferenceModuleFactory.createPeerServer(context, NNModule.NAME);
+ assertNotNull(serverPeer);
+
+ serverPeer.close();
}
@Test
public void testPeerServerSetInfo() {
- inferencePeer = InferenceModuleFactory.createPeerServer(context, NNModule.NAME);
+ serverPeer = InferenceModuleFactory.createPeerServer(context, NNModule.NAME);
- assertEquals(true, inferencePeer.setInfo());
+ assertEquals(true, serverPeer.setInfo());
+
+ serverPeer.close();
}
@Test
public void testPeerServerGetInfo() {
- inferencePeer = InferenceModuleFactory.createPeerServer(context, NNModule.NAME);
- inferencePeer.setInfo();
+ serverPeer = InferenceModuleFactory.createPeerServer(context, NNModule.NAME);
+ serverPeer.setInfo();
- Peer.Info info = inferencePeer.getInfo();
+ PeerInfo info = serverPeer.getInfo();
assertNotNull(info);
- assertEquals(info.port, 3000);
- assertEquals(info.host, "0.0.0.0");
+ assertEquals(info.getHost(), "0.0.0.0");
+ assertEquals(info.getPort(), 3000);
+
+ serverPeer.close();
}
@Test
- public void testPeerServerActivateControlChannel() {
- inferencePeer = InferenceModuleFactory.createPeerServer(context, NNModule.NAME);
- inferencePeer.setInfo();
+ public void testPeerServerActivateAndDeactivateControlChannel() {
+ serverPeer = InferenceModuleFactory.createPeerServer(context, NNModule.NAME);
+ serverPeer.setInfo();
- assertEquals(true, inferencePeer.activateControlChannel());
+ assertEquals(true, serverPeer.activateControlChannel());
+
+ assertEquals(true, serverPeer.deactivateControlChannel());
+
+ serverPeer.close();
}
@Test
assertTrue(auth.activate());
assertTrue(auth.prepare());
- inferencePeer = InferenceModuleFactory.createPeerServer(context, NNModule.NAME);
- assertNotNull(inferencePeer);
+ serverPeer = InferenceModuleFactory.createPeerServer(context, NNModule.NAME);
+ assertNotNull(serverPeer);
- boolean status = inferencePeer.configure(ConfigType.AUTHENTICATOR, auth);
+ boolean status = serverPeer.configure(ConfigType.AUTHENTICATOR, auth);
assertTrue(status);
// TODO:
// GC the inferencePeer and destroy its native instance
- inferencePeer = null;
auth.close();
auth = null;
- }
- @Test
- public void testPeerServerDeactivateControlChannel() {
- inferencePeer = InferenceModuleFactory.createPeerServer(context, NNModule.NAME);
- inferencePeer.setInfo();
- inferencePeer.activateControlChannel();
-
- assertEquals(true, inferencePeer.deactivateControlChannel());
+ serverPeer.close();
}
@Test
inferencePeer = InferenceModuleFactory.createPeerClient(context, NNModule.NAME);
assertNotNull(inferencePeer);
+
+ inferencePeer.close();
}
@Test
public void testPeerClientSetInfo() {
inferencePeer = InferenceModuleFactory.createPeerClient(context, NNModule.NAME);
- Peer.Info info = new Peer.Info();
- info.host = TEST_SERVER_IP;
- info.port = TEST_SERVER_PORT;
+ PeerInfo info = new PeerInfo(TEST_SERVER_IP, TEST_SERVER_PORT);
assertEquals(true, inferencePeer.setInfo(info));
- }
- @Test
- public void testPeerClientActivateControlChannel() {
- inferencePeer = InferenceModuleFactory.createPeerClient(context, NNModule.NAME);
- Peer.Info info = new Peer.Info();
- info.host = TEST_SERVER_IP;
- info.port = TEST_SERVER_PORT;
- inferencePeer.setInfo(info);
-
- assertEquals(true, inferencePeer.activateControlChannel());
+ inferencePeer.close();
}
@Test
- public void testPeerClientDeactivateControlChannel() {
- Peer serverPeer = InferenceModuleFactory.createPeerServer(context, NNModule.NAME);
+ public void testPeerClientActivateAndDeactivateControlChannel() {
+ serverPeer = InferenceModuleFactory.createPeerServer(context, NNModule.NAME);
serverPeer.setInfo();
serverPeer.activateControlChannel();
inferencePeer = InferenceModuleFactory.createPeerClient(context, NNModule.NAME);
- inferencePeer.setInfo();
- inferencePeer.activateControlChannel();
+ inferencePeer.setInfo(new PeerInfo(TEST_SERVER_IP, TEST_SERVER_PORT));
+
+ assertEquals(true, inferencePeer.activateControlChannel());
+
+ assertTrue(inferencePeer.deactivateControlChannel());
+ assertTrue(serverPeer.deactivateControlChannel());
- assertEquals(true, inferencePeer.deactivateControlChannel());
+ inferencePeer.close();
+ serverPeer.close();
}
}
import com.samsung.android.beyond.inference.InferenceMode;
import com.samsung.android.beyond.inference.InferenceModuleFactory;
import com.samsung.android.beyond.inference.Peer;
+import com.samsung.android.beyond.inference.PeerInfo;
import com.samsung.android.beyond.inference.tensor.Tensor;
import com.samsung.android.beyond.inference.tensor.TensorHandler;
import com.samsung.android.beyond.inference.tensor.TensorInfo;
import com.samsung.android.beyond.inference.tensor.TensorSet;
import com.samsung.android.beyond.module.peer.NN.NNModule;
+import org.junit.After;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
private TensorHandler tensorHandler = null;
+ private Peer serverPeer = null;
+
private Peer inferencePeer = null;
+ private TensorSet inputTensorSet = null;
+
private static String uint8ModelAbsolutePath = null;
private static String float32ModelAbsolutePath = null;
inferenceHandler = InferenceModuleFactory.createHandler(InferenceMode.REMOTE);
assertNotNull(inferenceHandler);
- Peer serverPeer = InferenceModuleFactory.createPeerServer(context, NNModule.NAME);
+ serverPeer = InferenceModuleFactory.createPeerServer(context, NNModule.NAME);
assertNotNull(serverPeer);
assertTrue(serverPeer.setInfo());
assertTrue(serverPeer.activateControlChannel());
inferencePeer = InferenceModuleFactory.createPeerClient(context, NNModule.NAME);
assertNotNull(inferencePeer);
- Peer.Info info = new Peer.Info();
- info.host = TEST_SERVER_IP;
- info.port = TEST_SERVER_PORT;
- assertTrue(inferencePeer.setInfo(info));
+ assertTrue(inferencePeer.setInfo(new PeerInfo(TEST_SERVER_IP, TEST_SERVER_PORT)));
+
assertTrue(inferenceHandler.addInferencePeer(inferencePeer)); // Cover activateControlChannel()
tensorHandler = new TensorHandler(inferenceHandler);
for (TensorInfo tensorInfo : outputTensorsInfo) {
assertArrayEquals(tensorInfo.getDimensions(), MOBILENET_OUTPUT_TENSOR_DIMENSIONS);
}
-
- destroyModules();
- }
-
- private void destroyModules() {
- assertTrue(inferencePeer.deactivateControlChannel());
}
@Test
for (Tensor tensor : outputTensors) {
assertArrayEquals(MOBILENET_OUTPUT_TENSOR_DIMENSIONS, tensor.getTensorInfo().getDimensions());
}
-
- destroyModules();
}
@Test
for (TensorInfo tensorInfo : inputTensorsInfo) {
assertArrayEquals(MOBILENET_INPUT_TENSOR_DIMENSIONS, tensorInfo.getDimensions());
}
- TensorSet inputTensorSet = tensorHandler.allocateTensorSet(inputTensorsInfo);
+ inputTensorSet = tensorHandler.allocateTensorSet(inputTensorsInfo);
assertNotNull(inputTensorSet);
Tensor[] inputTensors = inputTensorSet.getTensors();
assertEquals(MOBILENET_INPUT_TENSOR_NUMBER, inputTensors.length);
assertNotNull(byteBuffer);
assertArrayEquals(TEST_DATA_UINT8.array(), byteBuffer.array());
}
-
- destroyModules();
}
@Test
assertNotNull(floatBuffer);
assertArrayEquals(TEST_DATA_FLOAT32.array(), floatBuffer.array(), 0);
}
-
- destroyModules();
}
@Test
TensorSet outputTensors = tensorHandler.getOutput(outputTensorsProperties);
assertNotNull(outputTensors);
assertTrue(isOrange(outputTensors.getTensors()));
-
- destroyModules();
}
public static boolean isOrange(Tensor[] tensors) {
}
return true;
}
+
+ @After
+ public void destroyInferenceModules() {
+ assertTrue(inferencePeer.deactivateControlChannel());
+ assertTrue(serverPeer.deactivateControlChannel());
+
+ assertTrue(inferenceHandler.removeInferencePeer(inferencePeer));
+
+ serverPeer.close();
+ inferencePeer.close();
+ inferenceHandler.close();
+ Log.i(TAG, "Inference modules are destroyed!!");
+ }
}
return run(instance, inputTensors.getTensorsInstance(), inputTensors.getTensors().length);
}
+ public boolean removeInferencePeer(@NonNull Peer inferencePeer) {
+ if (instance == 0L) {
+ Log.e(TAG, "Instance is invalid.");
+ return false;
+ }
+
+ return removePeer(instance, inferencePeer.getNativeInstance());
+ }
+
public boolean setOutputCallback(@NonNull TensorOutputCallback tensorOutputCallback) {
if (instance == 0L) {
Log.e(TAG, "Instance is invalid.");
private native boolean run(long inferenceHandle, long tensorsInstance, int numberOfTensors);
+ private native boolean removePeer(long inferenceHandle, long peerHandle);
+
private static native void destroy(long inferenceHandle);
private native int setCallback(long instance, TensorOutputCallback tensorOutputCallback);
initialize();
}
- public static class Info {
- public String host;
- public int port;
- public String uuid;
-
- // TODO:
- // List of runtimes
-
- public Info() {}
-
- public Info(@NonNull String host, int port) {
- this.host = host;
- this.port = port;
- }
- }
-
private EventListener eventListener;
Peer(@NonNull Context context, @NonNull String peerType, @NonNull NodeType nodeType) {
return false;
}
- return setInfo(instance, new Info(IP, port));
+ return setInfo(instance, new PeerInfo(IP, port));
}
private boolean validateIPv4(@NonNull String IP) {
return false;
}
- Info info = new Info();
- info.host = "0.0.0.0";
- info.port = 3000;
- info.uuid = "N/A";
- return setInfo(instance, info);
+ return setInfo(instance, new PeerInfo("0.0.0.0", 3000));
}
- public boolean setInfo(@NonNull Info info) {
+ public boolean setInfo(@NonNull PeerInfo info) {
if (instance == 0L) {
Log.e(TAG, "Instance is invalid.");
return false;
return setInfo(instance, info);
}
- public Info getInfo() {
+ public PeerInfo getInfo() {
if (instance == 0L) {
Log.e(TAG, "Instance is invalid.");
return null;
private native long create(String[] args);
- private native boolean setInfo(long handle, Info info);
+ private native boolean setInfo(long handle, PeerInfo info);
- private native Info getInfo(long handle);
+ private native PeerInfo getInfo(long handle);
private native boolean activate(long handle);
--- /dev/null
+package com.samsung.android.beyond.inference;
+
+public class PeerInfo {
+
+ private final String host;
+ private final int port;
+ private String uuid;
+
+ // TODO:
+ // List of runtimes
+
+ public PeerInfo(String host, int port) {
+ this.host = host;
+ this.port = port;
+ }
+
+ public PeerInfo(String host, int port, String uuid) {
+ this.host = host;
+ this.port = port;
+ }
+
+ public String getHost() {
+ return host;
+ }
+
+ public int getPort() {
+ return port;
+ }
+
+ public String getUuid() {
+ return uuid;
+ }
+}
return true;
}
+jboolean InferenceNativeInterface::Java_com_samsung_android_beyond_InferenceHandler_removePeer(JNIEnv *env, jobject thiz, jlong inference_handle, jlong peer_handle) // TODO: Device a better idea to transfer peer_handle.
+{
+ InferenceNativeInterface *inference_handle_ = reinterpret_cast<InferenceNativeInterface *>(inference_handle);
+ PeerNativeInterface *peer_handle_ = reinterpret_cast<PeerNativeInterface *>(peer_handle);
+ int ret = inference_handle_->inference->RemovePeer(static_cast<beyond::InferenceInterface::PeerInterface *>(peer_handle_->GetBeyonDInstance()));
+ if (ret < 0) {
+ ErrPrint("Fail to remove the given peer to the inference handler, ret = %d\n", ret);
+ return false;
+ }
+
+ return true;
+}
+
void InferenceNativeInterface::Java_com_samsung_android_beyond_InferenceHandler_destroy(JNIEnv *env, jclass klass, jlong inference_handle)
{
- return;
+ InferenceNativeInterface *inference_handle_ = reinterpret_cast<InferenceNativeInterface *>(inference_handle);
+ if (inference_handle_ == nullptr) {
+ ErrPrint("inference_handle_ == nullptr");
+ return;
+ }
+
+ inference_handle_->inference->Destroy();
+ inference_handle_ = nullptr;
}
jint InferenceNativeInterface::Java_com_samsung_android_beyond_InferenceHandler_setOutputCallback(JNIEnv *env, jobject thiz, jlong inference_handle, jobject callback_object)
{ "loadModel", "(JLjava/lang/String;)Z", (void *)Java_com_samsung_android_beyond_InferenceHandler_loadModel },
{ "prepare", "(J)Z", reinterpret_cast<void *>(Java_com_samsung_android_beyond_InferenceHandler_prepare) },
{ "run", "(JJI)Z", reinterpret_cast<void *>(Java_com_samsung_android_beyond_InferenceHandler_run) },
+ { "removePeer", "(JJ)Z", reinterpret_cast<void *>(Java_com_samsung_android_beyond_InferenceHandler_removePeer) },
{ "destroy", "(J)V", reinterpret_cast<void *>(Java_com_samsung_android_beyond_InferenceHandler_destroy) },
{ "setCallback", "(JLcom/samsung/android/beyond/inference/TensorOutputCallback;)I", reinterpret_cast<void *>(Java_com_samsung_android_beyond_InferenceHandler_setOutputCallback) },
};
static jboolean Java_com_samsung_android_beyond_InferenceHandler_loadModel(JNIEnv *env, jobject thiz, jlong inference_handle, jstring model_path);
static jboolean Java_com_samsung_android_beyond_InferenceHandler_prepare(JNIEnv *env, jobject thiz, jlong inference_handle);
static jboolean Java_com_samsung_android_beyond_InferenceHandler_run(JNIEnv *env, jobject thiz, jlong inference_handle, jlong tensors_instance, jint num_tensors);
+ static jboolean Java_com_samsung_android_beyond_InferenceHandler_removePeer(JNIEnv *env, jobject thiz, jlong inference_handle, jlong peer_handle);
static jint Java_com_samsung_android_beyond_InferenceHandler_setOutputCallback(JNIEnv *env, jobject thiz, jlong inference_handle, jobject callback_object);
int AttachEventLoop(JNIEnv *env);
}
peer_handle->peer->Destroy();
+ peer_handle = nullptr;
}
jboolean PeerNativeInterface::Java_com_samsung_android_beyond_InferencePeer_configure(JNIEnv *env, jobject thiz, jlong handle, jchar type, jobject obj)
void PeerNativeInterface::Java_com_samsung_android_beyond_InferencePeer_initialize(JNIEnv *env, jclass klass)
{
- jclass infoKlass = env->FindClass("com/samsung/android/beyond/inference/Peer$Info");
+ jclass infoKlass = env->FindClass("com/samsung/android/beyond/inference/PeerInfo");
if (infoKlass == nullptr) {
ErrPrint("Unable to get the class");
return;
static JNINativeMethod peer_jni_methods[] = {
{ "initialize", "()V", reinterpret_cast<void *>(Java_com_samsung_android_beyond_InferencePeer_initialize) },
{ "create", "([Ljava/lang/String;)J", reinterpret_cast<void *>(Java_com_samsung_android_beyond_InferencePeer_create) },
- { "setInfo", "(JLcom/samsung/android/beyond/inference/Peer$Info;)Z", reinterpret_cast<void *>(Java_com_samsung_android_beyond_InferencePeer_set_info) },
- { "getInfo", "(J)Lcom/samsung/android/beyond/inference/Peer$Info;", reinterpret_cast<void *>(Java_com_samsung_android_beyond_InferencePeer_get_info) },
+ { "setInfo", "(JLcom/samsung/android/beyond/inference/PeerInfo;)Z", reinterpret_cast<void *>(Java_com_samsung_android_beyond_InferencePeer_set_info) },
+ { "getInfo", "(J)Lcom/samsung/android/beyond/inference/PeerInfo;", reinterpret_cast<void *>(Java_com_samsung_android_beyond_InferencePeer_get_info) },
{ "activate", "(J)Z", reinterpret_cast<void *>(Java_com_samsung_android_beyond_InferencePeer_activate) },
{ "configure", "(JCLjava/lang/Object;)Z", reinterpret_cast<void *>(Java_com_samsung_android_beyond_InferencePeer_configure) },
{ "deactivate", "(J)Z", reinterpret_cast<void *>(Java_com_samsung_android_beyond_InferencePeer_deactivate) },