feat: Use other hardwares if remote interface fails to initialize

If the remote interface is not initialized succesfully, the other
hardwares would be used to calculate PoW.
The checking mechanism is based on the record in the initiailzation
phase.

Close #186.

src/dcurl.c

@@ -33,8 +33,17 @@
 
 /* check whether dcurl is initialized */
 static bool isInitialized = false;
+static uint8_t initStatus = 0;
 static uv_sem_t notify;
 
+/* for checking whether the corresponding implementation is initialized */
+#define C_BIT 1
+#define SSE_BIT 2
+#define AVX_BIT 4
+#define GPU_BIT 8
+#define FPGA_BIT 16
+#define REMOTE_BIT 32
+
 LIST_HEAD(IMPL_LIST);
 LIST_HEAD(REMOTE_IMPL_LIST);
 
@@ -61,26 +70,44 @@ static uv_sem_t notify_remote;
 
 bool dcurl_init()
 {
-    bool ret = true;
+    bool ret = false;
 
 #if defined(ENABLE_AVX)
-    ret &= registerImplContext(&PoWAVX_Context);
+    if (registerImplContext(&PoWAVX_Context)) {
+        initStatus = initStatus | AVX_BIT;
+        ret |= true;
+    }
 #elif defined(ENABLE_SSE)
-    ret &= registerImplContext(&PoWSSE_Context);
+    if (registerImplContext(&PoWSSE_Context)) {
+        initStatus = initStatus | SSE_BIT;
+        ret |= true;
+    }
 #elif defined(ENABLE_GENERIC)
-    ret &= registerImplContext(&PoWC_Context);
+    if (registerImplContext(&PoWC_Context)) {
+        initStatus = initStatus | C_BIT;
+        ret |= true;
+    }
 #endif
 
 #if defined(ENABLE_OPENCL)
-    ret &= registerImplContext(&PoWCL_Context);
+    if (registerImplContext(&PoWCL_Context)) {
+        initStatus = initStatus | GPU_BIT;
+        ret |= true;
+    }
 #endif
 
 #if defined(ENABLE_FPGA_ACCEL)
-    ret &= registerImplContext(&PoWFPGAAccel_Context);
+    if (registerImplContext(&PoWFPGAAccel_Context)) {
+        initStatus = initStatus | FPGA_BIT;
+        ret |= true;
+    }
 #endif
 
 #if defined(ENABLE_REMOTE)
-    ret &= registerRemoteContext(&Remote_Context);
+    if (registerRemoteContext(&Remote_Context)) {
+        initStatus = initStatus | REMOTE_BIT;
+        ret |= true;
+    }
     uv_sem_init(&notify_remote, 0);
 #endif
 
@@ -109,6 +136,8 @@ void dcurl_destroy()
         destroyImplContext(impl);
         list_del(p);
     }
+
+    initStatus = 0;
 }
 
 
@@ -124,38 +153,40 @@ int8_t *dcurl_entry(int8_t *trytes, int mwm, int threads)
         return NULL;
 
 #if defined(ENABLE_REMOTE)
-    RemoteImplContext *remoteImpl = NULL;
-    struct list_head *pRemote;
-
-    do {
-        list_for_each (pRemote, &REMOTE_IMPL_LIST) {
-            remoteImpl = list_entry(pRemote, RemoteImplContext, list);
-            if (enterRemoteContext(remoteImpl)) {
-                pow_ctx = getRemoteContext(remoteImpl, trytes, mwm);
-                goto remote_pow;
+    if (initStatus & REMOTE_BIT) {
+        RemoteImplContext *remoteImpl = NULL;
+        struct list_head *pRemote;
+
+        do {
+            list_for_each (pRemote, &REMOTE_IMPL_LIST) {
+                remoteImpl = list_entry(pRemote, RemoteImplContext, list);
+                if (enterRemoteContext(remoteImpl)) {
+                    pow_ctx = getRemoteContext(remoteImpl, trytes, mwm);
+                    goto remote_pow;
+                }
             }
+            uv_sem_wait(&notify_remote);
+        } while (1);
+
+    remote_pow:
+        if (!doRemoteContext(remoteImpl, pow_ctx)) {
+            /* The remote interface can not work without activated RabbitMQ
+             * broker and remote worker. If it is not working, the PoW would be
+             * calculated by the local machine. And the remote interface
+             * resource should be released.
+             */
+            freeRemoteContext(remoteImpl, pow_ctx);
+            exitRemoteContext(remoteImpl);
+            uv_sem_post(&notify_remote);
+            goto local_pow;
+        } else {
+            res = getRemoteResult(remoteImpl, pow_ctx);
         }
-        uv_sem_wait(&notify_remote);
-    } while (1);
-
-remote_pow:
-    if (!doRemoteContext(remoteImpl, pow_ctx)) {
-        /* The remote interface can not work without activated RabbitMQ broker
-         * and remote worker. If it is not working, the PoW would be calculated
-         * by the local machine. And the remote interface resource should be
-         * released.
-         */
         freeRemoteContext(remoteImpl, pow_ctx);
         exitRemoteContext(remoteImpl);
         uv_sem_post(&notify_remote);
-        goto local_pow;
-    } else {
-        res = getRemoteResult(remoteImpl, pow_ctx);
+        return res;
     }
-    freeRemoteContext(remoteImpl, pow_ctx);
-    exitRemoteContext(remoteImpl);
-    uv_sem_post(&notify_remote);
-    return res;
 
 local_pow:
 #endif