Remove BUILD_TV

[tlwilmar]

Summary

Cleanup code to remove BUILD_TV and unused code bracketed by it.

[AndreyChurbanov]

LGTM

openmp/trunk/runtime/src/kmp.h

typedef struct kmp_cpuinfo {
   int apic_id;
   int physical_id;
   int logical_id;
   kmp_uint64 frequency; // Nominal CPU frequency in Hz.
   char name[3 * sizeof(kmp_cpuid_t)]; // CPUID(0x80000002,0x80000003,0x80000004)
 } kmp_cpuinfo_t;
 #endif
 
-#ifdef BUILD_TV
-
-struct tv_threadprivate {
-  /* Record type #1 */
-  void *global_addr;
-  void *thread_addr;
-};
-
-struct tv_data {
-  struct tv_data *next;
-  void *type;
-  union tv_union {
-    struct tv_threadprivate tp;
-  } u;
-};
-
-extern kmp_key_t __kmp_tv_key;
-
-#endif /* BUILD_TV */
-
-/* ------------------------------------------------------------------------ */
-
 #if USE_ITT_BUILD
 // We cannot include "kmp_itt.h" due to circular dependency. Declare the only
 // required type here. Later we will check the type meets requirements.
 typedef int kmp_itt_mark_t;
 #define KMP_ITT_DEBUG 0
 #endif /* USE_ITT_BUILD */
 
 /* Taskq data structures */

 #else
   kmp_bootstrap_lock_t bget_lock; // Lock for accessing bget free list. Must be
 // bootstrap lock so we can use it at library
 // shutdown.
 #endif /* USE_LOCK_FOR_BGET */
 #endif /* ! USE_CMP_XCHG_FOR_BGET */
 #endif /* KMP_USE_BGET */
 
-#ifdef BUILD_TV
-  struct tv_data *tv_data;
-#endif
-
   PACKED_REDUCTION_METHOD_T
   packed_reduction_method; /* stored by __kmpc_reduce*(), used by
                               __kmpc_end_reduce*() */
 
 } kmp_local_t;
 
 #define KMP_CHECK_UPDATE(a, b)                                                 \
   if ((a) != (b))                                                              \

 
 extern void __kmp_parallel_deo(int *gtid_ref, int *cid_ref, ident_t *loc_ref);
 extern void __kmp_parallel_dxo(int *gtid_ref, int *cid_ref, ident_t *loc_ref);
 
 #ifdef USE_LOAD_BALANCE
 extern int __kmp_get_load_balance(int);
 #endif
 
-#ifdef BUILD_TV
-extern void __kmp_tv_threadprivate_store(kmp_info_t *th, void *global_addr,
-                                         void *thread_addr);
-#endif
-
 extern int __kmp_get_global_thread_id(void);
 extern int __kmp_get_global_thread_id_reg(void);
 extern void __kmp_exit_thread(int exit_status);
 extern void __kmp_abort(char const *format, ...);
 extern void __kmp_abort_thread(void);
 extern void __kmp_abort_process(void);
 extern void __kmp_warn(char const *format, ...);
 

openmp/trunk/runtime/src/kmp_global.cpp

/* Signal handling is disabled by default, because it confuses users: In case of
    stack backtrace when program is aborting, but the code is not signal-safe.
    When multiple signals raised at the same time (which occurs in dynamic
    negative tests because all the worker threads detects the same error),
    Fortran RTL may hang. The bug finally fixed in Fortran RTL library provided
    by Steve R., and will be available soon. */
 int __kmp_handle_signals = FALSE;
 #endif
 
-/* ----------------------------------------------- */
-#ifdef BUILD_TV
-kmp_key_t __kmp_tv_key = 0;
-#endif
-
-/* ------------------------------------------------------------------------ */
-
 #ifdef DEBUG_SUSPEND
 int get_suspend_count_(void) {
   int count = __kmp_suspend_count;
   __kmp_suspend_count = 0;
   return count;
 }
 void set_suspend_count_(int *value) { __kmp_suspend_count = *value; }
 #endif

openmp/trunk/runtime/src/kmp_runtime.cpp

#endif
   // TODO: Initialize ICVs from parent; GEH - isn't that already done in
   // __kmp_initialize_team()?
 
   /* TODO no worksharing in speculative threads */
   this_thr->th.th_dispatch = &team->t.t_dispatch[tid];
 
   this_thr->th.th_local.this_construct = 0;
 
-#ifdef BUILD_TV
-  this_thr->th.th_local.tv_data = 0;
-#endif
-
   if (!this_thr->th.th_pri_common) {
     this_thr->th.th_pri_common =
         (struct common_table *)__kmp_allocate(sizeof(struct common_table));
     if (__kmp_storage_map) {
       __kmp_print_storage_map_gtid(
           gtid, this_thr->th.th_pri_common, this_thr->th.th_pri_common + 1,
           sizeof(struct common_table), "th_%d.th_pri_common\n", gtid);
     }; // if

openmp/trunk/runtime/src/kmp_threadprivate.cpp

#ifdef KMP_TASK_COMMON_DEBUG
   dump_list();
 #endif
 
   /* Link the node into a simple list */
 
   tn->link = __kmp_threads[gtid]->th.th_pri_head;
   __kmp_threads[gtid]->th.th_pri_head = tn;
 
-#ifdef BUILD_TV
-  __kmp_tv_threadprivate_store(__kmp_threads[gtid], tn->gbl_addr, tn->par_addr);
-#endif
-
   if ((__kmp_foreign_tp) ? (KMP_INITIAL_GTID(gtid)) : (KMP_UBER_GTID(gtid)))
     return tn;
 
   /* if C++ object with copy constructor, use it;
    * else if C++ object with constructor, use it for the non-master copies only;
    * else use pod_init and memcpy
    *
    * C++ constructors need to be called once for each non-master thread on

openmp/trunk/runtime/src/z_Linux_util.cpp

 void __kmp_clear_system_time(void) {
   struct timeval tval;
   int status;
   status = gettimeofday(&tval, NULL);
   KMP_CHECK_SYSFAIL_ERRNO("gettimeofday", status);
   TIMEVAL_TO_TIMESPEC(&tval, &__kmp_sys_timer_data.start);
 }
 
-#ifdef BUILD_TV
-
-void __kmp_tv_threadprivate_store(kmp_info_t *th, void *global_addr,
-                                  void *thread_addr) {
-  struct tv_data *p;
-
-  p = (struct tv_data *)__kmp_allocate(sizeof(*p));
-
-  p->u.tp.global_addr = global_addr;
-  p->u.tp.thread_addr = thread_addr;
-
-  p->type = (void *)1;
-
-  p->next = th->th.th_local.tv_data;
-  th->th.th_local.tv_data = p;
-
-  if (p->next == 0) {
-    int rc = pthread_setspecific(__kmp_tv_key, p);
-    KMP_CHECK_SYSFAIL("pthread_setspecific", rc);
-  }
-}
-
-#endif /* BUILD_TV */
-
 static int __kmp_get_xproc(void) {
 
   int r = 0;
 
 #if KMP_OS_LINUX || KMP_OS_FREEBSD || KMP_OS_NETBSD
 
   r = sysconf(_SC_NPROCESSORS_ONLN);
 
if (sysconf(_SC_THREADS)) {
     if (__kmp_sys_min_stksize <= 1) {
       __kmp_sys_min_stksize = KMP_MIN_STKSIZE;
     }
   }
 
   /* Set up minimum number of threads to switch to TLS gtid */
   __kmp_tls_gtid_min = KMP_TLS_GTID_MIN;
 
-#ifdef BUILD_TV
-  {
-    int rc = pthread_key_create(&__kmp_tv_key, 0);
-    KMP_CHECK_SYSFAIL("pthread_key_create", rc);
-  }
-#endif
-
   status = pthread_key_create(&__kmp_gtid_threadprivate_key,
                               __kmp_internal_end_dest);
   KMP_CHECK_SYSFAIL("pthread_key_create", status);
   status = pthread_mutexattr_init(&mutex_attr);
   KMP_CHECK_SYSFAIL("pthread_mutexattr_init", status);
   status = pthread_mutex_init(&__kmp_wait_mx.m_mutex, &mutex_attr);
   KMP_CHECK_SYSFAIL("pthread_mutex_init", status);
   status = pthread_condattr_init(&cond_attr);
void __kmp_runtime_destroy(void) {
   };
 
 #if USE_ITT_BUILD
   __kmp_itt_destroy();
 #endif /* USE_ITT_BUILD */
 
   status = pthread_key_delete(__kmp_gtid_threadprivate_key);
   KMP_CHECK_SYSFAIL("pthread_key_delete", status);
-#ifdef BUILD_TV
-  status = pthread_key_delete(__kmp_tv_key);
-  KMP_CHECK_SYSFAIL("pthread_key_delete", status);
-#endif
 
   status = pthread_mutex_destroy(&__kmp_wait_mx.m_mutex);
   if (status != 0 && status != EBUSY) {
     KMP_SYSFAIL("pthread_mutex_destroy", status);
   }
   status = pthread_cond_destroy(&__kmp_wait_cv.c_cond);
   if (status != 0 && status != EBUSY) {
     KMP_SYSFAIL("pthread_cond_destroy", status);