Added a signal handler for the kernels. All routines now exit cleanly from a Ctrl-C. Fixes issue #12 and #58

Author: manodeep

xi_mocks/DDrppi/countpairs_rp_pi_mocks_impl.c.src

@@ -28,6 +28,14 @@
 #include <omp.h>
 #endif
 
+int interrupt_status_DDrppi_mocks_DOUBLE=EXIT_SUCCESS;
+
+void interrupt_handler_countpairs_rp_pi_mocks_DOUBLE(int signo)
+{
+    fprintf(stderr,"Received signal = `%s' (signo = %d). Aborting \n",strsignal(signo), signo);
+    interrupt_status_DDrppi_mocks_DOUBLE = EXIT_FAILURE;
+}    
+
 
 int check_ra_dec_cz_DOUBLE(const int64_t N, DOUBLE *phi, DOUBLE *theta, DOUBLE *cz)
 {
@@ -207,6 +215,16 @@ int countpairs_mocks_DOUBLE(const int64_t ND1, DOUBLE *ra1, DOUBLE *dec1, DOUBLE
     int zbin_refine_factor=2;
     const int npibin = (int) pimax;
 
+    /* setup interrupt handler -> mostly useful during the python execution. 
+       Let's Ctrl-C abort the extension  */
+    int interrupt_signals[] = {SIGTERM, SIGINT, SIGHUP};
+    for(size_t i=0;i<sizeof(interrupt_signals)/sizeof(interrupt_signals[0]);i++) {
+        int signo = interrupt_signals[i];
+        if (signal(signo, interrupt_handler_countpairs_rp_pi_mocks_DOUBLE) == SIG_ERR) {
+            fprintf(stderr,"Can not handle signal = %d\n", signo);
+        }
+    }
+    
     //Try to initialize cosmology - code will exit if comoslogy is not implemented.
     //Putting in a different scope so I can call the variable status
     {
@@ -424,7 +442,7 @@ int countpairs_mocks_DOUBLE(const int64_t ND1, DOUBLE *ra1, DOUBLE *dec1, DOUBLE
 
 
 #if defined(_OPENMP)
-#pragma omp parallel shared(numdone, abort_status)
+#pragma omp parallel shared(numdone, abort_status, interrupt_status_DDrppi_mocks_DOUBLE)
     {
         const int tid = omp_get_thread_num();
         uint64_t npairs[totnbins];
@@ -441,10 +459,10 @@ int countpairs_mocks_DOUBLE(const int64_t ND1, DOUBLE *ra1, DOUBLE *dec1, DOUBLE
         for(int64_t index1=0;index1<totncells;index1++) {
 
 #if defined(_OPENMP)
-#pragma omp flush (abort_status)
+#pragma omp flush (abort_status, interrupt_status_DDrppi_mocks_DOUBLE)
 #endif
-            if(abort_status == EXIT_SUCCESS) { //omp cancel was introduced in omp 4.0 - so this is my way of checking if loop needs to be cancelled
-                
+            if(abort_status == EXIT_SUCCESS && interrupt_status_DDrppi_mocks_DOUBLE == EXIT_SUCCESS) {
+                //omp cancel was introduced in omp 4.0 - so this is my way of checking if loop needs to be cancelled
                 /* If the verbose option is not enabled, avoid outputting anything unnecessary*/
                 if(options.verbose) {
 #if defined(_OPENMP)
@@ -524,13 +542,8 @@ int countpairs_mocks_DOUBLE(const int64_t ND1, DOUBLE *ra1, DOUBLE *dec1, DOUBLE
     if(autocorr == 0) {
         free_cellarray_mocks_index_particles_DOUBLE(lattice2,totncells);
     }
-    
-    if(options.verbose) {
-        finish_myprogressbar(&interrupted);
-    }
-        
 
-    if(abort_status != EXIT_SUCCESS) {
+    if(abort_status != EXIT_SUCCESS || interrupt_status_DDrppi_mocks_DOUBLE != EXIT_SUCCESS) {
         /* Cleanup memory here if aborting */
         free(rupp);
 #if defined(_OPENMP)

xi_mocks/DDrppi/countpairs_rp_pi_mocks_impl.h.src

@@ -14,6 +14,8 @@ extern "C" {
 
 #include "countpairs_rp_pi_mocks.h" //for definition of results_countpairs_mocks
 
+    extern void interrupt_handler_countpairs_rp_pi_mocks_DOUBLE(int signo);
+    
     typedef int (*countpairs_mocks_func_ptr_DOUBLE)(const int64_t N0, DOUBLE *x0, DOUBLE *y0, DOUBLE *z0, DOUBLE *d0, 
                                                     const int64_t N1, DOUBLE *x1, DOUBLE *y1, DOUBLE *z1, DOUBLE *d1,
                                                     const int same_cell, 

xi_mocks/vpf/countspheres_mocks_impl.c.src

@@ -24,6 +24,15 @@
 
 #include "vpf_mocks_kernels_DOUBLE.c"
 
+int interrupt_status_vpf_mocks_DOUBLE=EXIT_SUCCESS;
+
+void interrupt_handler_vpf_mocks_DOUBLE(int signo)
+{
+    fprintf(stderr,"Received signal = `%s' (signo = %d). Aborting \n",strsignal(signo), signo);
+    interrupt_status_vpf_mocks_DOUBLE = EXIT_FAILURE;
+}    
+
+
 int count_neighbors_DOUBLE(const DOUBLE xcen,const DOUBLE ycen,const DOUBLE zcen,const DOUBLE smin,const DOUBLE inv_rcube,const DOUBLE rmax,
                            const int ngrid,const cellarray_DOUBLE *lattice, const int nthreshold, const int bin_refine_factor);
 
@@ -178,11 +187,27 @@ int countspheres_mocks_DOUBLE(const int64_t Ngal, DOUBLE *xgal, DOUBLE *ygal, DO
     XRETURN(num_pN >= 1, EXIT_FAILURE,"Number of pN's=%d requested must be at least 1", num_pN);
 
     /* Start cosmology */
-    init_cosmology(cosmology);
+    {
+        // Declared in separate scope so I can call the variable status;
+        int status = init_cosmology(cosmology);
+        if(status != EXIT_SUCCESS) {
+            return status;
+        }
+    }
 
     struct config_options options = *input_options;
     options.periodic=0;
 
+    /* setup interrupt handler -> mostly useful during the python execution. 
+       Let's Ctrl-C abort the extension  */
+    int interrupt_signals[] = {SIGTERM, SIGINT, SIGHUP};
+    for(size_t i=0;i<sizeof(interrupt_signals)/sizeof(interrupt_signals[0]);i++) {
+        int signo = interrupt_signals[i];
+        if (signal(signo, interrupt_handler_vpf_mocks_DOUBLE) == SIG_ERR) {
+            fprintf(stderr,"Can not handle signal = %d\n", signo);
+        }
+    }
+    
     int need_randoms=0;
     int64_t num_centers_in_file=0;
     FILE *fpcen = fopen(centers_file,"r");
@@ -337,13 +362,12 @@ int countspheres_mocks_DOUBLE(const int64_t Ngal, DOUBLE *xgal, DOUBLE *ygal, DO
     itry=0 ;
     isucceed=0 ;
     int ncenters_written=0;
-
     int interrupted=0;
     if(options.verbose) {
         init_my_progressbar(nc, &interrupted);
     }
 
-    while(isucceed < nc && itry < Nran) {
+    while(isucceed < nc && itry < Nran && interrupt_status_vpf_mocks_DOUBLE == EXIT_SUCCESS) {
 
         if(options.verbose){
             my_progressbar(isucceed,&interrupted);
@@ -453,7 +477,11 @@ int countspheres_mocks_DOUBLE(const int64_t Ngal, DOUBLE *xgal, DOUBLE *ygal, DO
     if(need_randoms == 1) {
         free_cellarray_DOUBLE(randoms_lattice, totncells);
     }
-
+    if(interrupt_status_vpf_mocks_DOUBLE != EXIT_SUCCESS) {
+        matrix_free((void **) pN, nbin);
+        return EXIT_FAILURE;
+    }
+    
     if(options.verbose) {
         finish_myprogressbar(&interrupted);
         fprintf(stderr,"%s> Placed %d centers out of %d trials.\n",__FUNCTION__,isucceed,itry);

xi_mocks/vpf/countspheres_mocks_impl.h.src

@@ -15,7 +15,8 @@ extern "C" {
 #include "defs.h" //for definition of struct config_options
 #include "countspheres_mocks.h"//for definition of struct results_countspheres_mocks 
 
-
+    extern void interrupt_handler_vpf_mocks_DOUBLE(int signo);
+    
     typedef int (*vpf_mocks_func_ptr_DOUBLE)(const int64_t np, DOUBLE * restrict X, DOUBLE * restrict Y, DOUBLE * restrict Z,
                                              const DOUBLE xc, const DOUBLE yc, const DOUBLE zc,
                                              const DOUBLE rmax, const int nbin, 

xi_mocks/wtheta/countpairs_theta_mocks_impl.c.src

@@ -23,6 +23,16 @@
 #include <omp.h>
 #endif
 
+int interrupt_status_wtheta_mocks_DOUBLE=EXIT_SUCCESS;
+
+void interrupt_handler_wtheta_mocks_DOUBLE(int signo)
+{
+    fprintf(stderr,"Received signal = `%s' (signo = %d). Aborting \n",strsignal(signo), signo);
+    interrupt_status_wtheta_mocks_DOUBLE = EXIT_FAILURE;
+}    
+
+
+
 int check_ra_dec_DOUBLE(const int64_t N, DOUBLE *ra, DOUBLE *theta)
 {
     if(N==0) {
@@ -291,6 +301,15 @@ int countpairs_theta_mocks_DOUBLE(const int64_t ND1, DOUBLE *ra1, DOUBLE *dec1,
     int ra_refine_factor = 2;
     int dec_refine_factor = 2;
 
+    /* setup interrupt handler -> mostly useful during the python execution. 
+       Let's Ctrl-C abort the extension  */
+    int interrupt_signals[] = {SIGTERM, SIGINT, SIGHUP};
+    for(size_t i=0;i<sizeof(interrupt_signals)/sizeof(interrupt_signals[0]);i++) {
+        int signo = interrupt_signals[i];
+        if (signal(signo, interrupt_handler_wtheta_mocks_DOUBLE) == SIG_ERR) {
+            fprintf(stderr,"Can not handle signal = %d\n", signo);
+        }
+    }
 
 #if defined(_OPENMP)
     if((options.link_in_ra == 0) && (dec_refine_factor < numthreads)) {
@@ -577,7 +596,7 @@ int countpairs_theta_mocks_DOUBLE(const int64_t ND1, DOUBLE *ra1, DOUBLE *dec1,
 
 
 #if defined(_OPENMP)
-#pragma omp parallel shared(numdone, abort_status)
+#pragma omp parallel shared(numdone, abort_status, interrupt_status_wtheta_mocks_DOUBLE)
     {
         int tid = omp_get_thread_num();
         uint64_t npairs[nthetabin];
@@ -598,7 +617,8 @@ int countpairs_theta_mocks_DOUBLE(const int64_t ND1, DOUBLE *ra1, DOUBLE *dec1,
 #if defined(_OPENMP)
 #pragma omp flush (abort_status)
 #endif
-            if(abort_status == EXIT_SUCCESS) { //omp cancel was introduced in omp 4.0 - so this is my way of checking if loop needs to be cancelled
+            if(abort_status == EXIT_SUCCESS && interrupt_status_wtheta_mocks_DOUBLE == EXIT_SUCCESS) {
+                //omp cancel was introduced in omp 4.0 - so this is my way of checking if loop needs to be cancelled
 
                 /* If the verbose option is not enabled, avoid outputting anything unnecessary*/
                 if(options.verbose) {
@@ -687,7 +707,7 @@ int countpairs_theta_mocks_DOUBLE(const int64_t ND1, DOUBLE *ra1, DOUBLE *dec1,
         free_cellarray_mocks_index_wtheta_DOUBLE(lattice2,totncells);
     }
 
-    if(abort_status != EXIT_SUCCESS) {
+    if(abort_status != EXIT_SUCCESS || interrupt_status_wtheta_mocks_DOUBLE != EXIT_SUCCESS) {
         /* Cleanup memory here if aborting */
         free(theta_upp);
 #if defined(_OPENMP)

xi_mocks/wtheta/countpairs_theta_mocks_impl.h.src

@@ -14,6 +14,7 @@ extern "C" {
 
 #include "countpairs_theta_mocks.h"
 
+    extern void interrupt_handler_wtheta_mocks_DOUBLE(int signo);
 
     typedef int (*countpairs_theta_mocks_func_ptr_DOUBLE)(const int64_t N0, DOUBLE *x0, DOUBLE *y0, DOUBLE *z0, 
                                                           const int64_t N1, DOUBLE *x1, DOUBLE *y1, DOUBLE *z1,

xi_theory/vpf/countspheres_impl.c.src

@@ -22,6 +22,13 @@
 
 #include "vpf_kernels_DOUBLE.c"
 
+int interrupt_status_vpf_DOUBLE=EXIT_SUCCESS;
+
+void interrupt_handler_vpf_DOUBLE(int signo)
+{
+    fprintf(stderr,"Received signal = `%s' (signo = %d). Aborting \n",strsignal(signo), signo);
+    interrupt_status_vpf_DOUBLE = EXIT_FAILURE;
+}    
 
 vpf_func_ptr_DOUBLE vpf_driver_DOUBLE(const struct config_options *options) 
 {
@@ -119,6 +126,17 @@ int countspheres_DOUBLE(const int64_t np, DOUBLE * restrict X, DOUBLE * restrict
     gsl_rng * rng;
     int bin_refine_factor=1;
 
+    /* setup interrupt handler -> mostly useful during the python execution. 
+       Let's Ctrl-C abort the extension  */
+    int interrupt_signals[] = {SIGTERM, SIGINT, SIGHUP};
+    for(size_t i=0;i<sizeof(interrupt_signals)/sizeof(interrupt_signals[0]);i++) {
+        int signo = interrupt_signals[i];
+        if (signal(signo, interrupt_handler_vpf_DOUBLE) == SIG_ERR) {
+            fprintf(stderr,"Can not handle signal = %d\n", signo);
+        }
+    }
+
+    
     rng = gsl_rng_alloc (T);
     gsl_rng_set(rng, seed);
 
@@ -165,7 +183,7 @@ int countspheres_DOUBLE(const int64_t np, DOUBLE * restrict X, DOUBLE * restrict
 
     /* loop through centers, placing each randomly */
     int ic=0;
-    while(ic < nc) {
+    while(ic < nc && interrupt_status_vpf_DOUBLE == EXIT_SUCCESS) {
         if(options->verbose) {
             my_progressbar(ic,&interrupted);
         }
@@ -307,6 +325,10 @@ int countspheres_DOUBLE(const int64_t np, DOUBLE * restrict X, DOUBLE * restrict
 
     gsl_rng_free (rng);
     free_cellarray_DOUBLE(lattice, totncells);
+    if(interrupt_status_vpf_DOUBLE != EXIT_SUCCESS) {
+        matrix_free((void **) pN, nbin);
+        return interrupt_status_vpf_DOUBLE;
+    }
 
     if(options->verbose) {
         finish_myprogressbar(&interrupted);

xi_theory/vpf/countspheres_impl.h.src

@@ -13,6 +13,8 @@ extern "C" {
 #endif
 
 #include "countspheres.h" //for definition of DOUBLE
+
+    extern void interrupt_handler_vpf_DOUBLE(int signo);
 
     typedef int (*vpf_func_ptr_DOUBLE)(const int64_t np, DOUBLE * restrict X, DOUBLE * restrict Y, DOUBLE * restrict Z,
                                        const DOUBLE xc, const DOUBLE yc, const DOUBLE zc,

xi_theory/wp/countpairs_wp_impl.c.src

@@ -9,9 +9,10 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <math.h>
-#include <assert.h>
 #include <stdint.h>
 #include <inttypes.h>
+#include <signal.h>
+#include <unistd.h>
 
 #include "countpairs_wp_impl_DOUBLE.h" //function proto-type
 #include "wp_kernels_DOUBLE.c"
@@ -27,6 +28,15 @@
 #include <omp.h>
 #endif
 
+int interrupt_status_wp_DOUBLE=EXIT_SUCCESS;
+
+void interrupt_handler_countpairs_wp_DOUBLE(int signo)
+{
+    fprintf(stderr,"Received signal = `%s' (signo = %d). Aborting \n",strsignal(signo), signo);
+    interrupt_status_wp_DOUBLE = EXIT_FAILURE;
+}    
+
+
 wp_func_ptr_DOUBLE wp_driver_DOUBLE(const struct config_options *options)
 {
   static int initialized = 0;
@@ -121,6 +131,16 @@ int countpairs_wp_DOUBLE(const int64_t ND, DOUBLE * restrict X, DOUBLE * restric
 
     int bin_refine_factor=2,zbin_refine_factor=1;
     int nmesh_x, nmesh_y, nmesh_z;
+
+    /* setup interrupt handler -> mostly useful during the python execution. 
+       Let's Ctrl-C abort the extension  */
+    int interrupt_signals[] = {SIGTERM, SIGINT, SIGHUP};
+    for(size_t i=0;i<sizeof(interrupt_signals)/sizeof(interrupt_signals[0]);i++) {
+        int signo = interrupt_signals[i];
+        if (signal(signo, interrupt_handler_countpairs_wp_DOUBLE) == SIG_ERR) {
+            fprintf(stderr,"Can not handle signal = %d\n", signo);
+        }
+    }
 
     /***********************
      *initializing the  bins
@@ -219,7 +239,7 @@ int countpairs_wp_DOUBLE(const int64_t ND, DOUBLE * restrict X, DOUBLE * restric
 
 
 #if defined(_OPENMP)
-#pragma omp parallel shared(numdone, abort_status)
+#pragma omp parallel shared(numdone, abort_status, interrupt_status_wp_DOUBLE)
     {
         const int tid = omp_get_thread_num();
         uint64_t npair[nrpbins];
@@ -239,9 +259,9 @@ int countpairs_wp_DOUBLE(const int64_t ND, DOUBLE * restrict X, DOUBLE * restric
         for(int index1=0;index1<totncells;index1++) {
 
 #if defined(_OPENMP)            
-#pragma omp flush (abort_status)
+#pragma omp flush (abort_status, interrupt_status_wp_DOUBLE)
 #endif
-            if(abort_status == EXIT_SUCCESS) {
+            if(abort_status == EXIT_SUCCESS && interrupt_status_wp_DOUBLE == EXIT_SUCCESS) {
 
                 if(options.verbose) {
 #if defined(_OPENMP)
@@ -331,14 +351,8 @@ int countpairs_wp_DOUBLE(const int64_t ND, DOUBLE * restrict X, DOUBLE * restric
         }
     }//omp parallel
 #endif
-
-    if(options.verbose) {
-      finish_myprogressbar(&interrupted);
-      fprintf(stderr, "Freeing memory associated with 3-D lattices\n");
-    }
     free_cellarray_index_particles_DOUBLE(lattice, totncells);
-    
-    if(abort_status != EXIT_SUCCESS) {
+    if(abort_status != EXIT_SUCCESS || interrupt_status_wp_DOUBLE != EXIT_SUCCESS) {
       /* Cleanup memory here if aborting */
       free(rupp);
 #if defined(_OPENMP)