Add atomics and remove all global variables

Author: srini009

src/mercury.c

@@ -24,7 +24,6 @@
 
 /* PVAR profiling support */
 #include "mercury_prof_pvar_impl.h"
-HG_PROF_PVAR_UINT_COUNTER_DECL_EXTERN(hg_pvar_hg_forward_count);
 
 /****************/
 /* Local Macros */
@@ -963,7 +962,6 @@ HG_Init_opt(const char *na_info_string, hg_bool_t na_listen,
     const struct hg_init_info *hg_init_info)
 {
     struct hg_private_class *hg_class = NULL;
-    int ret;
 #ifdef HG_HAS_VERBOSE_ERROR
     const char *log_level = NULL;
 
@@ -994,7 +992,7 @@ HG_Init_opt(const char *na_info_string, hg_bool_t na_listen,
 
 
     /* Initialize PVAR profiling data structures */
-    ret = hg_prof_pvar_init();
+    int ret = hg_prof_pvar_init();
     assert(ret == HG_SUCCESS);
 
     return (hg_class_t *) hg_class;
@@ -1893,6 +1891,8 @@ HG_Forward(hg_handle_t handle, hg_cb_t callback, void *arg, void *in_struct)
     hg_uint8_t flags = 0;
     hg_return_t ret = HG_SUCCESS;
 
+    HG_PROF_PVAR_UINT_COUNTER(hg_pvar_hg_forward_count);
+
     HG_CHECK_ERROR(handle == HG_HANDLE_NULL, done, ret, HG_INVALID_ARG,
         "NULL HG handle");
 

src/mercury_prof_interface.c

@@ -230,6 +230,9 @@ HG_Prof_pvar_read(hg_prof_pvar_session_t session, hg_prof_pvar_handle_t handle,
       /*for(int i = 0; i < h.count; h++)*/ /* Need to support PVAR arrays, just a placeholder that assumes PVAR count is 1 */
       *((unsigned int *)buf) = *((unsigned int *)h.addr);
       break;
+    case HG_DOUBLE:
+      *((double *)buf) = *((double *)h.addr);
+      break;
   }
   return HG_SUCCESS;
 }

src/mercury_prof_pvar_impl.c

@@ -25,11 +25,9 @@
 /* Local Variables */
 /*******************/
 
-static hg_hash_table_t *pvar_table; /* Internal hash table containing PVAR info */
+static hg_hash_table_t *pvar_table; /* Internal hash table containing all PVAR info */
 
-HG_PROF_PVAR_UINT_COUNTER_DECL(hg_pvar_hg_forward_count); /* Declaring a PVAR */
-
-/* Internal routines for the pvar_hash_table data structure */
+/* Internal routines for the hash tables */
 static HG_INLINE int
 hg_prof_uint_equal(void *vlocation1, void *vlocation2)
 {
@@ -44,14 +42,34 @@ hg_prof_uint_hash(void *vlocation)
 }
 
 /*---------------------------------------------------------------------------*/
-
 hg_prof_pvar_data_t *
 hg_prof_pvar_table_lookup(unsigned int key)
 {
     return hg_hash_table_lookup(pvar_table, (hg_hash_table_key_t)(&key));
 }
+
 /*---------------------------------------------------------------------------*/
+hg_atomic_int32_t * 
+hg_prof_get_pvar_addr_from_name(const char* name)
+{
+   hg_prof_pvar_data_t * value = NULL;
+
+   for(unsigned int i = 0; i < hg_hash_table_num_entries(pvar_table); i++) {
+     value = hg_hash_table_lookup(pvar_table, (hg_hash_table_key_t)(&i));
+     if(strcmp(value->name, name)==0) {
+       break;
+     }
+     value = NULL;
+   }
+
+   if(value != NULL) {
+     return (hg_atomic_int32_t *)value->addr;
+   } else {
+      return NULL;
+   }
+}
 
+/*---------------------------------------------------------------------------*/
 void 
 HG_PROF_PVAR_REGISTER_impl(hg_prof_class_t varclass, hg_prof_datatype_t dtype, const char* name, void *addr, int count,
     hg_prof_bind_t bind, int continuous, const char * desc) {
@@ -61,6 +79,7 @@ HG_PROF_PVAR_REGISTER_impl(hg_prof_class_t varclass, hg_prof_datatype_t dtype, c
     *key = hg_hash_table_num_entries(pvar_table);
     hg_prof_pvar_data_t * pvar_info = NULL;
     pvar_info = (hg_prof_pvar_data_t *)malloc(sizeof(hg_prof_pvar_data_t));
+
     (*pvar_info).pvar_class = varclass;
     (*pvar_info).pvar_datatype = dtype;
     (*pvar_info).pvar_bind = bind;
@@ -69,6 +88,7 @@ HG_PROF_PVAR_REGISTER_impl(hg_prof_class_t varclass, hg_prof_datatype_t dtype, c
     strcpy((*pvar_info).name, name);
     strcpy((*pvar_info).description, desc);
     (*pvar_info).continuous = continuous;
+
     hg_hash_table_insert(pvar_table, (hg_hash_table_key_t)key, (hg_hash_table_value_t)(pvar_info));
 }
 
@@ -80,7 +100,6 @@ hg_prof_pvar_init() {
     pvar_table = hg_hash_table_new(hg_prof_uint_hash, hg_prof_uint_equal);
     /* Register available PVARs */
     HG_PROF_PVAR_UINT_COUNTER_REGISTER(HG_UINT, HG_PROF_BIND_NO_OBJECT, hg_pvar_hg_forward_count, "Number of times HG_Forward has been invoked");
-    HG_PROF_PVAR_UINT_COUNTER_REGISTER(HG_UINT, HG_PROF_BIND_NO_OBJECT, hg_pvar_dummy, "Dummy");
 
 return HG_SUCCESS;
 }

src/mercury_prof_pvar_impl.h

@@ -40,26 +40,23 @@ typedef struct hg_prof_pvar_data_t hg_prof_pvar_data_t;
 
 #define NUM_PVARS 1 /* Number of PVARs currently exported. PVAR indices go from 0......(NUM_PVARS - 1). */
 
-/* PVAR declaration and registration macros */
-#define HG_PROF_PVAR_UINT_COUNTER_DECL(name) \
-    hg_atomic_int32_t PVAR_COUNTER_##name;
-
-#define HG_PROF_PVAR_UINT_COUNTER_DECL_EXTERN(name) \
-    extern hg_atomic_int32_t PVAR_COUNTER_##name;
+/* PVAR handle declaration and registration macros */
+#define HG_PROF_PVAR_UINT_COUNTER(name) \
+    static hg_atomic_int32_t * addr_##name = NULL;
 
 #define HG_PROF_PVAR_UINT_COUNTER_REGISTER(dtype, bind,\
             name, desc) \
-        void *addr_##name; \
+        hg_atomic_int32_t *addr_##name = (hg_atomic_int32_t *)malloc(sizeof(hg_atomic_int32_t)); \
         /* Set initial value */ \
-        hg_atomic_init32((&PVAR_COUNTER_##name), 0); \
-        addr = &PVAR_COUNTER_##name; \
+        hg_atomic_init32(addr_##name, 0); \
         HG_PROF_PVAR_REGISTER_impl(HG_PVAR_CLASS_COUNTER, dtype, #name, \
-            addr, 1, bind, 1, desc); 
+            (void *)addr_##name, 1, bind, 1, desc); 
 
 /* Increment the value of a PVAR */
 #define HG_PROF_PVAR_COUNTER_INC(name, val) \
+    addr_##name = (addr_##name == NULL ? hg_prof_get_pvar_addr_from_name(#name): addr_##name); \
     for(int i=0; i < val; i++) \
-        hg_atomic_incr32(&PVAR_COUNTER_##name);
+        hg_atomic_incr32(addr_##name);
 
 /**
  * Internal routine that gets invoked during Mercury's own initialization routine.
@@ -70,6 +67,8 @@ typedef struct hg_prof_pvar_data_t hg_prof_pvar_data_t;
 hg_return_t 
 hg_prof_pvar_init();
 
+hg_atomic_int32_t *
+hg_prof_get_pvar_addr_from_name(const char* name);
 
 /**
  * Internal routine that returns the PVAR data associated with a key representing index.
@@ -80,6 +79,7 @@ hg_prof_pvar_init();
 hg_prof_pvar_data_t * 
 hg_prof_pvar_table_lookup(unsigned int key);
 
+
 /**
  * PVAR registration function. Used by internal Mercury modules to register any PVARs that they export.
  * \param varclass [IN]	  PVAR class