Replaced hashCode() with UniquelyIdentifiable.getId()

java.lang.Object.hashCode() returns non unique numbers.

src/foundation/pEp/jniadapter/AbstractEngine.java

@@ -8,7 +8,7 @@ import foundation.pEp.jniadapter.Sync.DefaultCallback;
 import java.io.UnsupportedEncodingException;
 import java.text.Normalizer;
 
-abstract class AbstractEngine implements AutoCloseable {
+abstract class AbstractEngine extends UniquelyIdentifiable implements AutoCloseable {
     static {
         System.loadLibrary("pEpJNI");
     }

src/foundation/pEp/jniadapter/UniquelyIdentifiable.java

@@ -0,0 +1,11 @@
+package foundation.pEp.jniadapter;
+import java.util.concurrent.atomic.AtomicLong;
+
+abstract class UniquelyIdentifiable {
+    static final AtomicLong NEXT_ID = new AtomicLong(1);
+    final long id = NEXT_ID.getAndIncrement();
+
+    public long getId() {
+        return id;
+    }
+}

src/jniutils.cc

@@ -12,17 +12,17 @@
 namespace pEp {
     namespace JNIAdapter {
         std::mutex global_mutex;
-        std::unordered_map<int, std::mutex*> engine_objhash_mutex;
+        std::unordered_map<long, std::mutex*> engine_objid_mutex;
 
         std::mutex* get_engine_java_object_mutex(
                 JNIEnv *env,
                 jobject obj
             )
         {
-            int engine_obj_hash = (int)callIntMethod(env, obj, "hashCode");
-            assert(engine_obj_hash);
-            std::mutex *engine_obj_mutex = engine_objhash_mutex.at(engine_obj_hash);
-            pEpLog(engine_obj_mutex << " with native_handle: " << engine_obj_mutex->native_handle() << " for java object hash: " << engine_obj_hash);
+            long engine_obj_id = (long)callLongMethod(env, obj, "getId");
+            assert(engine_obj_id);
+            std::mutex *engine_obj_mutex = engine_objid_mutex.at(engine_obj_id);
+            pEpLog(engine_obj_mutex << " with native_handle: " << engine_obj_mutex->native_handle() << " for java object id: " << engine_obj_id);
             assert(engine_obj_mutex);
             return engine_obj_mutex;
         }
@@ -32,16 +32,16 @@ namespace pEp {
                 jobject obj
             )
         {
-            int engine_obj_hash = (int)callIntMethod(env, obj, "hashCode");
-            assert(engine_obj_hash);
+            long engine_obj_id = (long)callLongMethod(env, obj, "getId");
+            assert(engine_obj_id);
             std::mutex *engine_obj_mutex = new std::mutex();
-            pEpLog(engine_obj_mutex << " with native_handle: " << engine_obj_mutex->native_handle() << " for java object hash: " << engine_obj_hash);
+            pEpLog(engine_obj_mutex << " with native_handle: " << engine_obj_mutex->native_handle() << " for java object id: " << engine_obj_id);
             assert(engine_obj_mutex);
-            if(get_engine_java_object_mutex(env, obj) != nullptr ) {
-                pEpLog("Fatal: mutex already existing for this object");
+            if(engine_objid_mutex.count(engine_obj_id) > 0) {
+                pEpLog("Fatal: mutex already existing for object id: " << engine_obj_id);
                 assert(0);
             }
-            engine_objhash_mutex.insert(std::make_pair(engine_obj_hash, engine_obj_mutex ));
+            engine_objid_mutex.insert(std::make_pair(engine_obj_id, engine_obj_mutex ));
         }
 
         void release_engine_java_object_mutex(
@@ -49,12 +49,12 @@ namespace pEp {
                 jobject obj
             )
         {
-            int engine_obj_hash = (int)callIntMethod(env, obj, "hashCode");
-            assert(engine_obj_hash);
-            std::mutex *engine_obj_mutex = engine_objhash_mutex.at(engine_obj_hash);
-            pEpLog(engine_obj_mutex << " with native_handle: " << engine_obj_mutex->native_handle() << " for java object hash: " << engine_obj_hash);
+            long engine_obj_id = (long)callLongMethod(env, obj, "getId");
+            assert(engine_obj_id);
+            std::mutex *engine_obj_mutex = engine_objid_mutex.at(engine_obj_id);
+            pEpLog(engine_obj_mutex << " with native_handle: " << engine_obj_mutex->native_handle() << " for java object id: " << engine_obj_id);
             assert(engine_obj_mutex);
-            engine_objhash_mutex.erase(engine_obj_hash);
+            engine_objid_mutex.erase(engine_obj_id);
             delete engine_obj_mutex;
         }
 

src/jniutils.hh

@@ -24,7 +24,7 @@ namespace pEp {
         extern std::mutex global_mutex;
 
         // Stores mutex per java object
-        extern std::unordered_map<int, std::mutex*> engine_objhash_mutex;
+        extern std::unordered_map<long, std::mutex*> engine_objid_mutex;
 
         // needs to be called after create_engine_java_object_mutex()
         // and before release_engine_java_object_mutex()

test/java/foundation/pEp/jniadapter/test/jni92/TestMain.java

@@ -34,7 +34,7 @@ class TestMain {
         Engine e;
         TestUtils.logH2("Creating new Engine");
         e = new Engine();
-        TestUtils.log("Engine created with java object hash: " + e.hashCode());
+        TestUtils.log("Engine created with java object ID: " + e.getId());
         return e;
     }
 
@@ -48,7 +48,7 @@ class TestMain {
 
     public static void engineConsumer(Vector<Engine> ev, Consumer<Engine> ec) {
         ev.forEach(e -> {
-            TestUtils.logH2("engineConsumer: on engine object hash: " + e.hashCode());
+            TestUtils.logH2("engineConsumer: on engine java object ID: " + e.getId());
             ec.accept(e);
         });
     }
@@ -75,13 +75,16 @@ class TestMain {
 
         int nrTestruns = 1000;
         boolean multiThreaded = true;
-        int nrThreads = 200;
+        int nrThreads = 20;
         int nrEnginesPerThread = 1000;
 
         for (int run = 0; run < nrTestruns; run++ ) {
-             TestUtils.logH1("Testrun Nr: " + run);
+            TestUtils.logH1("Testrun Nr: " + run);
             if (!multiThreaded) {
                 // Single Threaded
+//                for (int i = 0; i < nrEnginesPerThread; i++) {
+//                    Engine eni = new Engine();
+//                }
                 TestMainRun(nrEnginesPerThread);
             } else {
                 // Mutli Threaded
@@ -104,6 +107,9 @@ class TestMain {
                     }
                 });
             }
+            TestUtils.logH1("Testrun DONE" );
+            System.gc();
+//            TestUtils.sleep(2000);
         }
     }
 }