Free the allocated memory and handle the exception

DLTcollab · Aug 14, 2018 · da79d4a · da79d4a
1 parent 43eb6c6
commit da79d4a
Show file tree

Hide file tree

Showing 8 changed files with 85 additions and 9 deletions.
diff --git a/src/clcontext.c b/src/clcontext.c
@@ -161,26 +161,32 @@ int init_clcontext(CLContext *ctx)
     cl_uint num_platform = 0;
     cl_platform_id *platform = NULL;
 
+    /* Get the platform */
     clGetPlatformIDs(0, NULL, &num_platform);
     platform = (cl_platform_id *) malloc(sizeof(cl_platform_id) * num_platform);
+    if (!platform) return 0;
     clGetPlatformIDs(num_platform, platform, NULL);
 
     cl_uint num_devices = 0;
     cl_device_id *devices = NULL;
 
+    /* Iterate the platform list and get its devices */
     for (int i = 0; i < num_platform; i++) {
         clGetDeviceIDs(platform[i], CL_DEVICE_TYPE_GPU, 0, NULL, &num_devices);
         devices = (cl_device_id *) malloc(sizeof(cl_device_id) * num_devices);
+        if (!devices) goto exit;
         clGetDeviceIDs(platform[i], CL_DEVICE_TYPE_GPU, num_devices, devices, NULL);
         for (int j = 0; j < num_devices; j++) {
             int ret = 1;
             ret &= set_clcontext(&ctx[ctx_idx], devices[j]);
             ret &= init_cl_kernel(&ctx[ctx_idx]);
             ret &= init_BufferInfo(&ctx[ctx_idx]);
-            if (!ret) return 0;
+            if (!ret) goto exit;
             ctx_idx++;
         }
+        free(devices);
     }
-
+    free(platform);
+exit:
     return ctx_idx;
 }
diff --git a/src/dcurl.c b/src/dcurl.c
@@ -70,6 +70,13 @@ int dcurl_init()
 
 void dcurl_destroy()
 {
+    ImplContext *impl = NULL;
+    struct list_head *p;
+
+    list_for_each(p, &IMPL_LIST) {
+        impl = list_entry(p, ImplContext, list);
+        destroyImplContext(impl);
+    }
 }
 
 

diff --git a/src/implcontext.c b/src/implcontext.c
@@ -14,6 +14,11 @@ int initializeImplContext(ImplContext *impl_ctx)
     return impl_ctx->initialize(impl_ctx);
 }
 
+void destroyImplContext(ImplContext *impl_ctx)
+{
+    return impl_ctx->destroy(impl_ctx);
+}
+
 int enterImplContext(ImplContext *impl_ctx)
 {
     pthread_mutex_lock(&impl_ctx->lock);

diff --git a/src/implcontext.h b/src/implcontext.h
@@ -18,7 +18,7 @@ struct _impl_context {
 
     /* Functions of Implementation Context */
     int (*initialize)(ImplContext *impl_ctx);
-
+    void (*destroy)(ImplContext *impl_ctx);
     /* Private PoW Context for each thread */
     void *(*getPoWContext)(ImplContext *impl_ctx, int8_t *trytes, int mwm);
     int (*doThePoW)(void *pow_ctx);
@@ -31,6 +31,7 @@ struct _impl_context {
 
 int registerImplContext(ImplContext *impl_ctx);
 int initializeImplContext(ImplContext *impl_ctx);
+void destroyImplContext(ImplContext *impl_ctx);
 int enterImplContext(ImplContext *impl_ctx);
 void exitImplContext(ImplContext *impl_ctx);
 void *getPoWContext(ImplContext *impl_ctx, int8_t *trytes, int mwm);

diff --git a/src/pow_avx.c b/src/pow_avx.c
@@ -592,13 +592,15 @@ static int PoWAVX_Context_Initialize(ImplContext *impl_ctx)
 {
     int nproc = get_avail_nprocs();
     PoW_AVX_Context *ctx = (PoW_AVX_Context *) malloc(sizeof(PoW_AVX_Context) * impl_ctx->num_max_thread);
-
+    if (!ctx) return 0;
     for (int i = 0; i < impl_ctx->num_max_thread; i++) {
         ctx[i].threads = (pthread_t *) malloc(sizeof(pthread_t) * nproc);
         ctx[i].pitem = (Pwork_struct *) malloc(sizeof(Pwork_struct) * nproc);
         ctx[i].nonce_array = (int8_t **) malloc(sizeof(int *) * nproc);
+        void *chunk = malloc(NonceTrinarySize * nproc);
+        if (!ctx[i].threads || !ctx[i].pitem || !ctx[i].nonce_array || !chunk) return 0;
         for (int j = 0; j < nproc; j++)
-            ctx[i].nonce_array[j] = (int8_t *) malloc(NonceTrinarySize);
+            ctx[i].nonce_array[j] = (int8_t *) (chunk + j * NonceTrinarySize);
         ctx[i].num_threads = nproc;
         impl_ctx->bitmap = impl_ctx->bitmap << 1 | 0x1;
     }
@@ -607,6 +609,18 @@ static int PoWAVX_Context_Initialize(ImplContext *impl_ctx)
     return 1;
 }
 
+static void PoWAVX_Context_Destroy(ImplContext *impl_ctx)
+{
+    PoW_AVX_Context *ctx = (PoW_AVX_Context *) impl_ctx->context;
+    for (int i = 0; i < impl_ctx->num_max_thread; i++) {
+        free(ctx[i].threads);
+        free(ctx[i].pitem);
+        free(ctx[i].nonce_array[0]);
+        free(ctx[i].nonce_array);
+    }
+    free(ctx);
+}
+
 static void *PoWAVX_getPoWContext(ImplContext *impl_ctx, int8_t *trytes, int mwm)
 {
     pthread_mutex_lock(&impl_ctx->lock);
@@ -636,6 +650,7 @@ static int PoWAVX_freePoWContext(ImplContext *impl_ctx, void *pow_ctx)
 static int8_t *PoWAVX_getPoWResult(void *pow_ctx)
 {
     int8_t *ret = (int8_t *) malloc(sizeof(int8_t) * 2673);
+    if (!ret) return NULL;
     memcpy(ret, ((PoW_AVX_Context *) pow_ctx)->output_trytes, 2673);
     return ret;
 }
@@ -646,6 +661,7 @@ ImplContext PoWAVX_Context = {
     .num_max_thread = 2,
     .num_working_thread = 0,
     .initialize = PoWAVX_Context_Initialize,
+    .destroy = PoWAVX_Context_Destroy,
     .getPoWContext = PoWAVX_getPoWContext,
     .freePoWContext = PoWAVX_freePoWContext,
     .doThePoW = PowAVX,

diff --git a/src/pow_c.c b/src/pow_c.c
@@ -353,13 +353,15 @@ static int PoWC_Context_Initialize(ImplContext *impl_ctx)
 {
     int nproc = get_avail_nprocs();
     PoW_C_Context *ctx = (PoW_C_Context *) malloc(sizeof(PoW_C_Context) * impl_ctx->num_max_thread);
-
+    if (!ctx) return 0;
     for (int i = 0; i < impl_ctx->num_max_thread; i++) {
         ctx[i].threads = (pthread_t *) malloc(sizeof(pthread_t) * nproc);
         ctx[i].pitem = (Pwork_struct *) malloc(sizeof(Pwork_struct) * nproc);
         ctx[i].nonce_array = (int8_t **) malloc(sizeof(int *) * nproc);
+        void *chunk = malloc(NonceTrinarySize * nproc);
+        if (!ctx[i].threads || !ctx[i].pitem || !ctx[i].nonce_array || !chunk) return 0;
         for (int j = 0; j < nproc; j++)
-            ctx[i].nonce_array[j] = (int8_t *) malloc(NonceTrinarySize);
+            ctx[i].nonce_array[j] = (int8_t *) (chunk + j * NonceTrinarySize);
         ctx[i].num_threads = nproc;
         impl_ctx->bitmap = impl_ctx->bitmap << 1 | 0x1;
     }
@@ -368,6 +370,18 @@ static int PoWC_Context_Initialize(ImplContext *impl_ctx)
     return 1;
 }
 
+static void PoWC_Context_Destroy(ImplContext *impl_ctx)
+{
+    PoW_C_Context *ctx = (PoW_C_Context *) impl_ctx->context;
+    for (int i = 0; i < impl_ctx->num_max_thread; i++) {
+        free(ctx[i].threads);
+        free(ctx[i].pitem);
+        free(ctx[i].nonce_array[0]);
+        free(ctx[i].nonce_array);
+    }
+    free(ctx);
+}
+
 static void *PoWC_getPoWContext(ImplContext *impl_ctx, int8_t *trytes, int mwm)
 {
     pthread_mutex_lock(&impl_ctx->lock);
@@ -397,6 +411,7 @@ static int PoWC_freePoWContext(ImplContext *impl_ctx, void *pow_ctx)
 static int8_t *PoWC_getPoWResult(void *pow_ctx)
 {
     int8_t *ret = (int8_t *) malloc(sizeof(int8_t) * 2673);
+    if (!ret) return NULL;
     memcpy(ret, ((PoW_C_Context *) pow_ctx)->output_trytes, 2673);
     return ret;
 }
@@ -407,6 +422,7 @@ ImplContext PoWC_Context = {
     .num_max_thread = 2,
     .num_working_thread = 0,
     .initialize = PoWC_Context_Initialize,
+    .destroy = PoWC_Context_Destroy,
     .getPoWContext = PoWC_getPoWContext,
     .freePoWContext = PoWC_freePoWContext,
     .doThePoW = PowC,

diff --git a/src/pow_cl.c b/src/pow_cl.c
@@ -148,6 +148,7 @@ static int8_t *pwork(int8_t *state, int mwm, CLContext *ctx)
     }
 
     int8_t *buf = malloc(HASH_LENGTH);
+    if (!buf) return NULL;
 
     if (found > 0) {
         if (CL_SUCCESS != clEnqueueReadBuffer(titan->cmdq, titan->buffer[0],
@@ -236,6 +237,7 @@ static int PoWCL_Context_Initialize(ImplContext *impl_ctx)
 {
     impl_ctx->num_max_thread = init_clcontext(_opencl_ctx);
     PoW_CL_Context *ctx = (PoW_CL_Context *) malloc(sizeof(PoW_CL_Context) * impl_ctx->num_max_thread);
+    if (!ctx) return 0;
     for (int i = 0; i < impl_ctx->num_max_thread; i++) {
         ctx[i].clctx = &_opencl_ctx[i];
         impl_ctx->bitmap = impl_ctx->bitmap << 1 | 0x1;
@@ -245,6 +247,11 @@ static int PoWCL_Context_Initialize(ImplContext *impl_ctx)
     return 1;
 }
 
+static void PoWCL_Context_Destroy(ImplContext *impl_ctx)
+{
+    free(impl_ctx->context);
+}
+
 static void *PoWCL_getPoWContext(ImplContext *impl_ctx, int8_t *trytes, int mwm)
 {
     pthread_mutex_lock(&impl_ctx->lock);
@@ -274,6 +281,7 @@ static int PoWCL_freePoWContext(ImplContext *impl_ctx, void *pow_ctx)
 static int8_t *PoWCL_getPoWResult(void *pow_ctx)
 {
     int8_t *ret = (int8_t *) malloc(sizeof(int8_t) * 2673);
+    if (!ret) return NULL;
     memcpy(ret, ((PoW_CL_Context *) pow_ctx)->output_trytes, 2673);
     return ret;
 }
@@ -284,6 +292,7 @@ ImplContext PoWCL_Context = {
     .num_max_thread = 0,
     .num_working_thread = 0,
     .initialize = PoWCL_Context_Initialize,
+    .destroy = PoWCL_Context_Destroy,
     .getPoWContext = PoWCL_getPoWContext,
     .freePoWContext = PoWCL_freePoWContext,
     .doThePoW = PowCL,

diff --git a/src/pow_sse.c b/src/pow_sse.c
@@ -369,13 +369,15 @@ static int PoWSSE_Context_Initialize(ImplContext *impl_ctx)
 {
     int nproc = get_avail_nprocs();
     PoW_SSE_Context *ctx = (PoW_SSE_Context *) malloc(sizeof(PoW_SSE_Context) * impl_ctx->num_max_thread);
-
+    if(!ctx) return 0;
     for (int i = 0; i < impl_ctx->num_max_thread; i++) {
         ctx[i].threads = (pthread_t *) malloc(sizeof(pthread_t) * nproc);
         ctx[i].pitem = (Pwork_struct *) malloc(sizeof(Pwork_struct) * nproc);
         ctx[i].nonce_array = (int8_t **) malloc(sizeof(int *) * nproc);
+        void *chunk = malloc(NonceTrinarySize * nproc);
+        if (!ctx[i].threads || !ctx[i].pitem || !ctx[i].nonce_array || !chunk) return 0;
         for (int j = 0; j < nproc; j++)
-            ctx[i].nonce_array[j] = (int8_t *) malloc(NonceTrinarySize);
+            ctx[i].nonce_array[j] = (int8_t *) (chunk + j * NonceTrinarySize);
         ctx[i].num_threads = nproc;
         impl_ctx->bitmap = impl_ctx->bitmap << 1 | 0x1;
     }
@@ -384,6 +386,18 @@ static int PoWSSE_Context_Initialize(ImplContext *impl_ctx)
     return 1;
 }
 
+static void PoWSSE_Context_Destroy(ImplContext *impl_ctx)
+{
+    PoW_SSE_Context *ctx = (PoW_SSE_Context *) impl_ctx->context;
+    for (int i = 0; i < impl_ctx->num_max_thread; i++) {
+        free(ctx[i].threads);
+        free(ctx[i].pitem);
+        free(ctx[i].nonce_array[0]);
+        free(ctx[i].nonce_array);
+    }
+    free(ctx);
+}
+
 static void *PoWSSE_getPoWContext(ImplContext *impl_ctx, int8_t *trytes, int mwm)
 {
     pthread_mutex_lock(&impl_ctx->lock);
@@ -413,6 +427,7 @@ static int PoWSSE_freePoWContext(ImplContext *impl_ctx, void *pow_ctx)
 static int8_t *PoWSSE_getPoWResult(void *pow_ctx)
 {
     int8_t *ret = (int8_t *) malloc(sizeof(int8_t) * 2673);
+    if (!ret) return NULL;
     memcpy(ret, ((PoW_SSE_Context *) pow_ctx)->output_trytes, 2673);
     return ret;
 }
@@ -423,6 +438,7 @@ ImplContext PoWSSE_Context = {
     .num_max_thread = 2,
     .num_working_thread = 0,
     .initialize = PoWSSE_Context_Initialize,
+    .destroy = PoWSSE_Context_Destroy,
     .getPoWContext = PoWSSE_getPoWContext,
     .freePoWContext = PoWSSE_freePoWContext,
     .doThePoW = PowSSE,