Add comments

Author: srini009

src/mercury.c

@@ -1019,6 +1019,9 @@ HG_Finalize(hg_class_t *hg_class)
     hg_thread_spin_destroy(&private_class->register_lock);
     free(private_class);
 
+    /* Finalize PVAR data structures */
+    hg_prof_pvar_finalize();
+
 done:
     return ret;
 }
@@ -1929,7 +1932,6 @@ HG_Forward(hg_handle_t handle, hg_cb_t callback, void *arg, void *in_struct)
         HG_Error_to_string(ret));
 
     /* PVAR profiling support: Increment the value of the PVAR with the name "hg_pvar_hg_forward_count" */
-    fprintf(stderr, "[MERCURY_PROF_INTERFACE] Incrementing the value of PVAR with name hg_pvar_hg_forward_count\n");
     HG_PROF_PVAR_COUNTER_INC(hg_pvar_hg_forward_count, 1);
 
 done:

src/mercury_prof_interface.c

@@ -92,6 +92,7 @@ HG_Prof_init(hg_class_t *hg_class) {
 
   hg_prof_set_is_initialized(hg_private_class);
   hg_private_class->num_pvars = NUM_PVARS;
+  hg_private_class->session = NULL;
 
   return HG_SUCCESS;
 }
@@ -104,9 +105,9 @@ HG_Prof_finalize(hg_class_t *hg_class) {
 
   if(hg_prof_get_is_initialized(hg_private_class)) {
     hg_prof_set_is_initialized(hg_private_class);
+    hg_private_class->session = NULL;
   }
 
-  fprintf(stderr, "[MERCURY_PROF_INTERFACE] Successfully shutting down profiling interface\n");
   return HG_SUCCESS;
 }
 
@@ -168,6 +169,21 @@ HG_Prof_pvar_session_create(hg_class_t *hg_class, hg_prof_pvar_session_t *sessio
   return HG_SUCCESS;
 }
 
+/*---------------------------------------------------------------------------*/
+hg_return_t 
+HG_Prof_pvar_session_destroy(hg_class_t *hg_class, hg_prof_pvar_session_t *session) {
+
+  struct hg_private_class *hg_private_class = (struct hg_private_class *)(hg_class);
+
+  if(!hg_prof_get_is_initialized(hg_private_class))
+    return HG_NA_ERROR;
+
+  free((*session)->pvar_handle_array);
+  free((*session));
+  hg_private_class->session = NULL;
+
+  return HG_SUCCESS;
+}
 /*---------------------------------------------------------------------------*/
 hg_return_t 
 HG_Prof_pvar_handle_alloc(hg_prof_pvar_session_t session, int pvar_index, void *obj_handle, hg_prof_pvar_handle_t *handle, int *count) {
@@ -201,7 +217,22 @@ HG_Prof_pvar_handle_alloc(hg_prof_pvar_session_t session, int pvar_index, void *
   /* Return handle */
   *handle = s.pvar_handle_array[pvar_index];
 
-  fprintf(stderr, "[MERCURY_PROF_INTERFACE] Successfully allocated handle for PVAR: %s\n", (*s.pvar_handle_array[pvar_index]).name);
+  return HG_SUCCESS;
+}
+
+/*---------------------------------------------------------------------------*/
+hg_return_t 
+HG_Prof_pvar_handle_free(hg_prof_pvar_session_t session, int pvar_index, hg_prof_pvar_handle_t *handle) {
+
+  if(!hg_prof_get_session_is_initialized(session))
+    return HG_NA_ERROR;
+
+  
+  struct hg_prof_pvar_session s = *session;
+  assert(s.pvar_handle_array[pvar_index] == *handle);
+  free(s.pvar_handle_array[pvar_index]);
+  s.pvar_handle_array[pvar_index] = NULL;
+  *handle = NULL;
 
   return HG_SUCCESS;
 }
@@ -217,6 +248,17 @@ HG_Prof_pvar_start(hg_prof_pvar_session_t session, hg_prof_pvar_handle_t handle)
   return HG_SUCCESS;
 }
 
+/*---------------------------------------------------------------------------*/
+hg_return_t 
+HG_Prof_pvar_stop(hg_prof_pvar_session_t session, hg_prof_pvar_handle_t handle) {
+  if(!hg_prof_get_session_is_initialized(session))
+    return HG_NA_ERROR;
+
+  if (!(*handle).continuous && ((*handle).is_started))
+     (*handle).is_started = 0;
+  return HG_SUCCESS;
+}
+
 /*---------------------------------------------------------------------------*/
 hg_return_t 
 HG_Prof_pvar_read(hg_prof_pvar_session_t session, hg_prof_pvar_handle_t handle, void *buf) {

src/mercury_prof_interface.h

@@ -41,15 +41,27 @@ HG_PUBLIC hg_return_t
 HG_Prof_finalize(hg_class_t *hg_class);
 
 /**
- * Create a session. In this case, return a reference to the default session that is currently supported.
+ * Create a session.
  *
+ * \param hg_class [IN/OUT]       pointer to HG_CLASS 
  * \param session [IN/OUT]        pointer to PVAR session object 
  *
  * \return HG_SUCCESS or corresponding HG error code
  */
 HG_PUBLIC hg_return_t 
 HG_Prof_pvar_session_create(hg_class_t *hg_class, hg_prof_pvar_session_t *session);
 
+/**
+ * Destroy a session.
+ *
+ * \param hg_class [IN/OUT]       pointer to HG_CLASS 
+ * \param session [IN/OUT]        pointer to PVAR session object 
+ *
+ * \return HG_SUCCESS or corresponding HG error code
+ */
+HG_PUBLIC hg_return_t 
+HG_Prof_pvar_session_destroy(hg_class_t *hg_class, hg_prof_pvar_session_t *session);
+
 /**
  * Client-side API to retrieve the number of PVARs currently exported.
  *
@@ -96,6 +108,19 @@ HG_PUBLIC hg_return_t
 HG_Prof_pvar_handle_alloc(hg_prof_pvar_session_t session, 
 			int pvar_index, void *obj_handle, hg_prof_pvar_handle_t *handle, int *count);
 
+/**
+ * Free handle for a PVAR at a given index.
+ *
+ * \param session [IN]            opaque PVAR session object
+ * \param pvar_index [IN]	  PVAR index
+ * \param handle [IN/OUT]	  pointer to the opaque PVAR handle object that is returned to the calling client
+ *
+ * \return HG_SUCCESS or corresponding HG error code
+ */
+HG_PUBLIC hg_return_t 
+HG_Prof_pvar_handle_free(hg_prof_pvar_session_t session, 
+			int pvar_index, hg_prof_pvar_handle_t *handle);
+
 /**
  * Start the PVAR is it is not continuous and has not been started yet.
  *
@@ -107,6 +132,17 @@ HG_Prof_pvar_handle_alloc(hg_prof_pvar_session_t session,
 HG_PUBLIC hg_return_t 
 HG_Prof_pvar_start(hg_prof_pvar_session_t session, hg_prof_pvar_handle_t handle);
 
+/**
+ * Stop the PVAR is it is not continuous and has been started.
+ *
+ * \param session [IN]        opaque PVAR session object 
+ * \param handle [IN]         opaque PVAR handle object 
+ *
+ * \return HG_SUCCESS or corresponding HG error code
+ */
+HG_PUBLIC hg_return_t 
+HG_Prof_pvar_stop(hg_prof_pvar_session_t session, hg_prof_pvar_handle_t handle);
+
 /**
  * Read the value of the PVAR when the client supplies the handle.
  * Note that the handle is necessary as the input (instead of the pvar_index) because there may be multiple PVAR sessions in flight.

src/mercury_prof_pvar_impl.c

@@ -105,3 +105,12 @@ return HG_SUCCESS;
 }
 
 /*---------------------------------------------------------------------------*/
+hg_return_t 
+hg_prof_pvar_finalize() {
+
+    /*Finalize internal PVAR data structures*/
+    hg_hash_table_free(pvar_table);
+    pvar_table = NULL;
+
+return HG_SUCCESS;
+}

src/mercury_prof_pvar_impl.h

@@ -67,6 +67,21 @@ typedef struct hg_prof_pvar_data_t hg_prof_pvar_data_t;
 hg_return_t 
 hg_prof_pvar_init();
 
+/**
+ * Internal routine that gets invoked during Mercury's own finalization routine.
+ * General routine for finalizing and freeing the internal PVAR data structures.
+ *
+ * \return HG_SUCCESS or corresponding HG error code
+ */
+hg_return_t 
+hg_prof_pvar_finalize();
+
+/**
+ * Internal routine that returns the PVAR address associated with the name.
+ *
+ * \param name [IN]	  PVAR name
+ * \return hg_atomic_int32_t* that represents the PVAR addr
+ */
 hg_atomic_int32_t *
 hg_prof_get_pvar_addr_from_name(const char* name);