[OpenMP] Fix build errors when building with KMP_DEBUG_ADAPTIVE_LOCKS=1

[jlpeyton]

Summary

This change fixes build errors when building a runtime with adaptive lock stats
enabled. Most of the errors were due to the recent changes in the runtime, but
it seems that we have not tried to build this debug runtime on Windows for a
long time.

Patch by Hansang Bae

[tlwilmar]

LGTM

openmp/trunk/runtime/src/kmp.h

struct kmp_adaptive_backoff_params_t {
   // Badness is a bit mask : 0,1,3,7,15,... on each hard failure we move one to
   // the right
   kmp_uint32 max_badness;
 };
 
 extern kmp_adaptive_backoff_params_t __kmp_adaptive_backoff_params;
 
 #if KMP_DEBUG_ADAPTIVE_LOCKS
-extern char *__kmp_speculative_statsfile;
+extern const char *__kmp_speculative_statsfile;
 #endif
 
 #endif // KMP_USE_ADAPTIVE_LOCKS
 
 #if OMP_40_ENABLED
 extern int __kmp_display_env; /* TRUE or FALSE */
 extern int __kmp_display_env_verbose; /* TRUE if OMP_DISPLAY_ENV=VERBOSE */
 extern int __kmp_omp_cancellation; /* TRUE or FALSE */

openmp/trunk/runtime/src/kmp_global.cpp

 kmp_nested_nthreads_t __kmp_nested_nth = {NULL, 0, 0};
 
 #if KMP_USE_ADAPTIVE_LOCKS
 
 kmp_adaptive_backoff_params_t __kmp_adaptive_backoff_params = {
     1, 1024}; // TODO: tune it!
 
 #if KMP_DEBUG_ADAPTIVE_LOCKS
-char *__kmp_speculative_statsfile = "-";
+const char *__kmp_speculative_statsfile = "-";
 #endif
 
 #endif // KMP_USE_ADAPTIVE_LOCKS
 
 #if OMP_40_ENABLED
 int __kmp_display_env = FALSE;
 int __kmp_display_env_verbose = FALSE;
 int __kmp_omp_cancellation = FALSE;

openmp/trunk/runtime/src/kmp_lock.cpp

 #include <atomic>
 
 #include "kmp.h"
 #include "kmp_i18n.h"
 #include "kmp_io.h"
 #include "kmp_itt.h"
 #include "kmp_lock.h"
 #include "kmp_wait_release.h"
+#include "kmp_wrapper_getpid.h"
 
 #include "tsan_annotations.h"
 
 #if KMP_USE_FUTEX
 #include <sys/syscall.h>
 #include <unistd.h>
 // We should really include <futex.h>, but that causes compatibility problems on
 // different Linux* OS distributions that either require that you include (or

 // keep locks that haven't been destroyed in the liveLocks list so that we can
 // grab their statistics too.
 static kmp_adaptive_lock_statistics_t destroyedStats;
 
 // To hold the list of live locks.
 static kmp_adaptive_lock_info_t liveLocks;
 
 // A lock so we can safely update the list of locks.
-static kmp_bootstrap_lock_t chain_lock;
+static kmp_bootstrap_lock_t chain_lock =
+    KMP_BOOTSTRAP_LOCK_INITIALIZER(chain_lock);
 
 // Initialize the list of stats.
 void __kmp_init_speculative_stats() {
   kmp_adaptive_lock_info_t *lck = &liveLocks;
 
-  memset((void *)&(lck->stats), 0, sizeof(lck->stats));
+  memset(CCAST(kmp_adaptive_lock_statistics_t *, &(lck->stats)), 0,
+         sizeof(lck->stats));
   lck->stats.next = lck;
   lck->stats.prev = lck;
 
   KMP_ASSERT(lck->stats.next->stats.prev == lck);
   KMP_ASSERT(lck->stats.prev->stats.next == lck);
 
   __kmp_init_bootstrap_lock(&chain_lock);
 }
static void __kmp_forget_lock(kmp_adaptive_lock_info_t *lck) {
   kmp_adaptive_lock_info_t *n = lck->stats.next;
   kmp_adaptive_lock_info_t *p = lck->stats.prev;
 
   n->stats.prev = p;
   p->stats.next = n;
 }
 
 static void __kmp_zero_speculative_stats(kmp_adaptive_lock_info_t *lck) {
-  memset((void *)&lck->stats, 0, sizeof(lck->stats));
+  memset(CCAST(kmp_adaptive_lock_statistics_t *, &lck->stats), 0,
+         sizeof(lck->stats));
   __kmp_remember_lock(lck);
 }
 
 static void __kmp_add_stats(kmp_adaptive_lock_statistics_t *t,
                             kmp_adaptive_lock_info_t *lck) {
   kmp_adaptive_lock_statistics_t volatile *s = &lck->stats;
 
   t->nonSpeculativeAcquireAttempts += lck->acquire_attempts;
   t->successfulSpeculations += s->successfulSpeculations;
   t->hardFailedSpeculations += s->hardFailedSpeculations;
   t->softFailedSpeculations += s->softFailedSpeculations;
   t->nonSpeculativeAcquires += s->nonSpeculativeAcquires;
   t->lemmingYields += s->lemmingYields;
 }
 
 static void __kmp_accumulate_speculative_stats(kmp_adaptive_lock_info_t *lck) {
-  kmp_adaptive_lock_statistics_t *t = &destroyedStats;
-
   __kmp_acquire_bootstrap_lock(&chain_lock);
 
   __kmp_add_stats(&destroyedStats, lck);
   __kmp_forget_lock(lck);
 
   __kmp_release_bootstrap_lock(&chain_lock);
 }
 
KMP_SNPRINTF(&buffer[0], buffLen, __kmp_speculative_statsfile,
                (kmp_int32)getpid());
   FILE *result = fopen(&buffer[0], "w");
 
   // Maybe we should issue a warning here...
   return result ? result : stdout;
 }
 
 void __kmp_print_speculative_stats() {
-  if (__kmp_user_lock_kind != lk_adaptive)
-    return;
-
-  FILE *statsFile = __kmp_open_stats_file();
-
   kmp_adaptive_lock_statistics_t total = destroyedStats;
   kmp_adaptive_lock_info_t *lck;
 
   for (lck = liveLocks.stats.next; lck != &liveLocks; lck = lck->stats.next) {
     __kmp_add_stats(&total, lck);
   }
   kmp_adaptive_lock_statistics_t *t = &total;
   kmp_uint32 totalSections =
       t->nonSpeculativeAcquires + t->successfulSpeculations;
   kmp_uint32 totalSpeculations = t->successfulSpeculations +
                                  t->hardFailedSpeculations +
                                  t->softFailedSpeculations;
+  if (totalSections <= 0)
+    return;
+
+  FILE *statsFile = __kmp_open_stats_file();
 
   fprintf(statsFile, "Speculative lock statistics (all approximate!)\n");
   fprintf(statsFile, " Lock parameters: \n"
                      "   max_soft_retries               : %10d\n"
                      "   max_badness                    : %10d\n",
           __kmp_adaptive_backoff_params.max_soft_retries,
           __kmp_adaptive_backoff_params.max_badness);
   fprintf(statsFile, " Non-speculative acquire attempts : %10d\n",

openmp/trunk/runtime/src/kmp_settings.cpp

if (msg != NULL) {
     KMP_INFORM(Using_uint64_Value, name, buf.str);
     __kmp_str_buf_free(&buf);
   }
   *out = uint;
 } // __kmp_stg_parse_int
 
 #if KMP_DEBUG_ADAPTIVE_LOCKS
 static void __kmp_stg_parse_file(char const *name, char const *value,
-                                 char *suffix, char **out) {
+                                 const char *suffix, char **out) {
   char buffer[256];
   char *t;
   int hasSuffix;
   __kmp_str_free(out);
   t = (char *)strrchr(value, '.');
   hasSuffix = t && __kmp_str_eqf(t, suffix);
   t = __kmp_str_format("%s%s", value, hasSuffix ? "" : suffix);
   __kmp_expand_file_name(buffer, sizeof(buffer), t);
__kmp_str_buf_print(buffer, "%d,%d'\n",
                       __kmp_adaptive_backoff_params.max_badness);
 } // __kmp_stg_print_adaptive_lock_props
 
 #if KMP_DEBUG_ADAPTIVE_LOCKS
 
 static void __kmp_stg_parse_speculative_statsfile(char const *name,
                                                   char const *value,
                                                   void *data) {
-  __kmp_stg_parse_file(name, value, "", &__kmp_speculative_statsfile);
+  __kmp_stg_parse_file(name, value, "", CCAST(char**, &__kmp_speculative_statsfile));
 } // __kmp_stg_parse_speculative_statsfile
 
 static void __kmp_stg_print_speculative_statsfile(kmp_str_buf_t *buffer,
                                                   char const *name,
                                                   void *data) {
   if (__kmp_str_match("-", 0, __kmp_speculative_statsfile)) {
     __kmp_stg_print_str(buffer, name, "stdout");
   } else {