introduce TST_THREAD_MASTER thread Id for master, num_threads counts only workers

Author: cniethammer

one-sided/tst_one_sided_simple_ring_get.c

@@ -96,7 +96,6 @@ int tst_one_sided_simple_ring_get_cleanup (struct tst_env * env)
   comm = tst_comm_getcomm (env->comm);
   MPI_CHECK (MPI_Comm_rank (comm, &comm_rank));
 
-  //if (tst_global_rank == 0 && tst_thread_get_num() == 0)
   	MPI_Win_free (&send_win);
 
   tst_type_freevalues (env->type, env->send_buffer, env->values_num);

p2p/tst_p2p_simple_ring_bsend.c

@@ -19,7 +19,7 @@
 int tst_p2p_simple_ring_bsend_init (struct tst_env * env)
 {
   int comm_rank;
-  int num_threads = 1;
+  int num = 1;
   MPI_Comm comm;
 
   tst_output_printf (DEBUG_LOG, TST_REPORT_MAX, "(Rank:%d) env->comm:%d env->type:%d env->values_num:%d\n",
@@ -37,14 +37,12 @@ int tst_p2p_simple_ring_bsend_init (struct tst_env * env)
   tst_type_setstandardarray (env->type, env->values_num, env->send_buffer, comm_rank);
 
 #ifdef HAVE_MPI2_THREADS
-  num_threads = tst_thread_num_threads ();
-#endif
-  env->mpi_buffer_size = num_threads * (tst_type_gettypesize (env->type) * env->values_num + MPI_BSEND_OVERHEAD);
-  if ( NULL == (env->mpi_buffer = malloc (env->mpi_buffer_size)) )
-    ERROR (errno, "malloc");
-#ifdef HAVE_MPI2_THREADS
-  if ( tst_thread_get_num() == 0 ) {
+  if (tst_thread_get_num() == TST_THREAD_MASTER) {
 #endif
+    num = 1 + tst_thread_num_threads ();
+    env->mpi_buffer_size = num * (tst_type_gettypesize (env->type) * env->values_num + MPI_BSEND_OVERHEAD);
+    if ( NULL == (env->mpi_buffer = malloc (env->mpi_buffer_size)) )
+      ERROR (errno, "malloc");
     MPI_CHECK (MPI_Buffer_attach (env->mpi_buffer, env->mpi_buffer_size));
 #ifdef HAVE_MPI2_THREADS
   }
@@ -129,7 +127,7 @@ int tst_p2p_simple_ring_bsend_run (struct tst_env * env)
 int tst_p2p_simple_ring_bsend_cleanup (struct tst_env * env)
 {
 #ifdef HAVE_MPI2_THREADS
-  if ( tst_thread_get_num() == 0 ) {
+  if (tst_thread_get_num() == TST_THREAD_MASTER) {
 #endif
   MPI_CHECK (MPI_Buffer_detach (&env->mpi_buffer, &env->mpi_buffer_size));
 #ifdef HAVE_MPI2_THREADS

p2p/tst_p2p_simple_ring_ibsend.c

@@ -31,7 +31,7 @@ static int mpi_buffer_size = 0;
 int tst_p2p_simple_ring_ibsend_init (struct tst_env * env)
 {
   int comm_rank;
-  int num_threads = 1;
+  int num = 1;
   MPI_Comm comm;
 
   tst_output_printf (DEBUG_LOG, TST_REPORT_MAX, "(Rank:%d) env->comm:%d env->type:%d env->values_num:%d\n",
@@ -52,10 +52,10 @@ int tst_p2p_simple_ring_ibsend_init (struct tst_env * env)
    * Actually, the standard doesn't even say so.
    */
 #ifdef HAVE_MPI2_THREADS
-  if ( tst_thread_get_num() == 0 ) {
+  if ( tst_thread_get_num() == TST_THREAD_MASTER ) {
 #endif
-    num_threads = tst_thread_num_threads ();
-    env->mpi_buffer_size = num_threads * (tst_type_gettypesize (env->type) * env->values_num + MPI_BSEND_OVERHEAD);
+    num = 1 + tst_thread_num_threads();
+    env->mpi_buffer_size = num * (tst_type_gettypesize (env->type) * env->values_num + MPI_BSEND_OVERHEAD);
     if ((env->mpi_buffer = malloc (env->mpi_buffer_size)) == NULL)
       ERROR (errno, "malloc");
     MPI_CHECK (MPI_Buffer_attach (env->mpi_buffer, env->mpi_buffer_size));
@@ -134,7 +134,7 @@ int tst_p2p_simple_ring_ibsend_run (struct tst_env * env)
 int tst_p2p_simple_ring_ibsend_cleanup (struct tst_env * env)
 {
 #ifdef HAVE_MPI2_THREADS
-  if ( tst_thread_get_num () == 0 ) {
+  if ( tst_thread_get_num () == TST_THREAD_MASTER ) {
 #endif
     void *buf;
     int size = -1;

tst_comm.c

@@ -632,15 +632,13 @@ int tst_comm_cleanup () {
 
 
 MPI_Comm tst_comm_getcomm (int i) {
-
   CHECK_ARG (i, MPI_COMM_NULL);
-
-  if (tst_thread_running() && tst_thread_get_num() > 0) {
-    int threadId = tst_thread_get_num();
-    return comms[i].mpi_thread_comms[threadId - 1];
+  int threadId = tst_thread_get_num();
+  if (threadId == TST_THREAD_MASTER) {
+    return comms[i].mpi_comm;
   }
   else {
-    return comms[i].mpi_comm;
+    return comms[i].mpi_thread_comms[threadId];
   }
 }
 

tst_threads.c

@@ -8,6 +8,7 @@
 #include "mpi_test_suite.h"
 
 
+
 static int num_threads; /**< Number of available threads - 1 */
 static int working;
 static pthread_mutex_t working_mutex = PTHREAD_MUTEX_INITIALIZER;
@@ -136,7 +137,7 @@ int tst_thread_init(int max_threads, struct tst_thread_env_t ***thread_env) {
   int i;
   struct tst_thread_env_t ** env;
 
-  assert(max_threads > 0);
+  assert(max_threads >= 0);
   assert(thread_env != NULL);
   assert(num_threads == 0);
 
@@ -146,17 +147,12 @@ int tst_thread_init(int max_threads, struct tst_thread_env_t ***thread_env) {
   tst_output_printf(DEBUG_LOG, TST_REPORT_MAX, "(Rank:%d) tst_thread_init: Initializing %d threads\n",
                  tst_global_rank, max_threads);
 
-  tst_thread_tid_array = malloc ( max_threads * sizeof (pthread_t));
-  memset (tst_thread_tid_array, 0, max_threads * sizeof (pthread_t));
-  env = malloc ( max_threads * sizeof (struct tst_thread_env_t *));
-  memset (env, 0, max_threads * sizeof (struct tst_thread_env_t*));
+  tst_thread_tid_array = malloc(max_threads * sizeof (pthread_t));
+  memset(tst_thread_tid_array, 0, max_threads * sizeof (pthread_t));
+  env = malloc( max_threads * sizeof (struct tst_thread_env_t *));
+  memset(env, 0, max_threads * sizeof (struct tst_thread_env_t*));
 
-  /*
-   * Master thread also doing some work
-   */
-  tst_thread_tid_array[0] = pthread_self();
-
-  for (i = 0; i < max_threads - 1; i++) {
+  for (i = 0; i < max_threads; i++) {
     int ret;
     env[i] = malloc (sizeof (struct tst_thread_env_t));
     memset (env[i], 0, sizeof (struct tst_thread_env_t));
@@ -165,11 +161,11 @@ int tst_thread_init(int max_threads, struct tst_thread_env_t ***thread_env) {
     ret = pthread_create (&(env[i]->tid), NULL, tst_thread_dispatcher, env[i]);
     if (ret != 0)
       ERROR (errno, "tst_thread_init: pthread_create");
-    tst_thread_tid_array[i + 1] = env[i]->tid;
+    tst_thread_tid_array[i] = env[i]->tid;
     num_threads++;
   }
 
-  assert(num_threads == max_threads - 1);
+  assert(num_threads == max_threads);
   *thread_env = env;
   return 0;
 }
@@ -202,19 +198,18 @@ int tst_thread_cleanup (struct tst_thread_env_t ** thread_env)
 
 /** \brief Return thread ID of the current thread
  *
- * \return Success: thread ID, Fail: -1
+ * \return thread ID
  */
 inline int tst_thread_get_num() {
-  assert(num_threads >= 0);
-  assert(NULL != tst_thread_tid_array);
+  assert(num_threads == 0 || ((num_threads > 0) && (NULL != tst_thread_tid_array)));
   int i = 0;
   pthread_t self = pthread_self();
-  for (i = 0; i <= num_threads; i++) {
+  for (i = 0; i < num_threads; i++) {
     if (pthread_equal(tst_thread_tid_array[i], self)) {
       return i;
     }
   }
-  return -1;
+  return TST_THREAD_MASTER;
 }
 
 /** \brief Reset test environment of all running threads
@@ -337,7 +332,7 @@ int tst_thread_execute_cleanup (struct tst_env * env)
 
 
 inline int tst_thread_num_threads () {
-  return num_threads + 1; /* +1 because the main thread also is doing some work */
+  return num_threads;
 }
 
 

tst_threads.h

@@ -7,6 +7,9 @@
 #include "mpi_test_suite.h"
 
 
+#define TST_THREAD_MASTER -1
+
+
 typedef enum {
   TST_THREAD_CMD_NULL = 0,
   TST_THREAD_CMD_INIT,