diff options
Diffstat (limited to 'openmp/runtime/src/kmp_threadprivate.cpp')
| -rw-r--r-- | openmp/runtime/src/kmp_threadprivate.cpp | 1056 |
1 files changed, 518 insertions, 538 deletions
diff --git a/openmp/runtime/src/kmp_threadprivate.cpp b/openmp/runtime/src/kmp_threadprivate.cpp index 31d3e07508d..b1faf1c9a66 100644 --- a/openmp/runtime/src/kmp_threadprivate.cpp +++ b/openmp/runtime/src/kmp_threadprivate.cpp @@ -14,502 +14,476 @@ #include "kmp.h" -#include "kmp_itt.h" #include "kmp_i18n.h" - -/* ------------------------------------------------------------------------ */ -/* ------------------------------------------------------------------------ */ +#include "kmp_itt.h" #define USE_CHECKS_COMMON -#define KMP_INLINE_SUBR 1 - - -/* ------------------------------------------------------------------------ */ -/* ------------------------------------------------------------------------ */ +#define KMP_INLINE_SUBR 1 -void -kmp_threadprivate_insert_private_data( int gtid, void *pc_addr, void *data_addr, size_t pc_size ); -struct private_common * -kmp_threadprivate_insert( int gtid, void *pc_addr, void *data_addr, size_t pc_size ); +void kmp_threadprivate_insert_private_data(int gtid, void *pc_addr, + void *data_addr, size_t pc_size); +struct private_common *kmp_threadprivate_insert(int gtid, void *pc_addr, + void *data_addr, + size_t pc_size); -struct shared_table __kmp_threadprivate_d_table; - -/* ------------------------------------------------------------------------ */ -/* ------------------------------------------------------------------------ */ +struct shared_table __kmp_threadprivate_d_table; static #ifdef KMP_INLINE_SUBR -__forceinline + __forceinline #endif -struct private_common * -__kmp_threadprivate_find_task_common( struct common_table *tbl, int gtid, void *pc_addr ) + struct private_common * + __kmp_threadprivate_find_task_common(struct common_table *tbl, int gtid, + void *pc_addr) { - struct private_common *tn; + struct private_common *tn; #ifdef KMP_TASK_COMMON_DEBUG - KC_TRACE( 10, ( "__kmp_threadprivate_find_task_common: thread#%d, called with address %p\n", - gtid, pc_addr ) ); - dump_list(); + KC_TRACE(10, ("__kmp_threadprivate_find_task_common: thread#%d, called with " + "address %p\n", + gtid, pc_addr)); + dump_list(); #endif - for (tn = tbl->data[ KMP_HASH(pc_addr) ]; tn; tn = tn->next) { - if (tn->gbl_addr == pc_addr) { + for (tn = tbl->data[KMP_HASH(pc_addr)]; tn; tn = tn->next) { + if (tn->gbl_addr == pc_addr) { #ifdef KMP_TASK_COMMON_DEBUG - KC_TRACE( 10, ( "__kmp_threadprivate_find_task_common: thread#%d, found node %p on list\n", - gtid, pc_addr ) ); + KC_TRACE(10, ("__kmp_threadprivate_find_task_common: thread#%d, found " + "node %p on list\n", + gtid, pc_addr)); #endif - return tn; - } + return tn; } - return 0; + } + return 0; } static #ifdef KMP_INLINE_SUBR -__forceinline + __forceinline #endif -struct shared_common * -__kmp_find_shared_task_common( struct shared_table *tbl, int gtid, void *pc_addr ) -{ - struct shared_common *tn; + struct shared_common * + __kmp_find_shared_task_common(struct shared_table *tbl, int gtid, + void *pc_addr) { + struct shared_common *tn; - for (tn = tbl->data[ KMP_HASH(pc_addr) ]; tn; tn = tn->next) { - if (tn->gbl_addr == pc_addr) { + for (tn = tbl->data[KMP_HASH(pc_addr)]; tn; tn = tn->next) { + if (tn->gbl_addr == pc_addr) { #ifdef KMP_TASK_COMMON_DEBUG - KC_TRACE( 10, ( "__kmp_find_shared_task_common: thread#%d, found node %p on list\n", - gtid, pc_addr ) ); + KC_TRACE( + 10, + ("__kmp_find_shared_task_common: thread#%d, found node %p on list\n", + gtid, pc_addr)); #endif - return tn; - } + return tn; } - return 0; + } + return 0; } - -/* - * Create a template for the data initialized storage. - * Either the template is NULL indicating zero fill, - * or the template is a copy of the original data. - */ - -static struct private_data * -__kmp_init_common_data( void *pc_addr, size_t pc_size ) -{ - struct private_data *d; - size_t i; - char *p; - - d = (struct private_data *) __kmp_allocate( sizeof( struct private_data ) ); -/* - d->data = 0; // AC: commented out because __kmp_allocate zeroes the memory - d->next = 0; -*/ - d->size = pc_size; - d->more = 1; - - p = (char*)pc_addr; - - for (i = pc_size; i > 0; --i) { - if (*p++ != '\0') { - d->data = __kmp_allocate( pc_size ); - KMP_MEMCPY( d->data, pc_addr, pc_size ); - break; - } +// Create a template for the data initialized storage. Either the template is +// NULL indicating zero fill, or the template is a copy of the original data. +static struct private_data *__kmp_init_common_data(void *pc_addr, + size_t pc_size) { + struct private_data *d; + size_t i; + char *p; + + d = (struct private_data *)__kmp_allocate(sizeof(struct private_data)); + /* + d->data = 0; // AC: commented out because __kmp_allocate zeroes the + memory + d->next = 0; + */ + d->size = pc_size; + d->more = 1; + + p = (char *)pc_addr; + + for (i = pc_size; i > 0; --i) { + if (*p++ != '\0') { + d->data = __kmp_allocate(pc_size); + KMP_MEMCPY(d->data, pc_addr, pc_size); + break; } + } - return d; + return d; } -/* - * Initialize the data area from the template. - */ - -static void -__kmp_copy_common_data( void *pc_addr, struct private_data *d ) -{ - char *addr = (char *) pc_addr; - int i, offset; - - for (offset = 0; d != 0; d = d->next) { - for (i = d->more; i > 0; --i) { - if (d->data == 0) - memset( & addr[ offset ], '\0', d->size ); - else - KMP_MEMCPY( & addr[ offset ], d->data, d->size ); - offset += d->size; - } +// Initialize the data area from the template. +static void __kmp_copy_common_data(void *pc_addr, struct private_data *d) { + char *addr = (char *)pc_addr; + int i, offset; + + for (offset = 0; d != 0; d = d->next) { + for (i = d->more; i > 0; --i) { + if (d->data == 0) + memset(&addr[offset], '\0', d->size); + else + KMP_MEMCPY(&addr[offset], d->data, d->size); + offset += d->size; } + } } -/* ------------------------------------------------------------------------ */ -/* ------------------------------------------------------------------------ */ - /* we are called from __kmp_serial_initialize() with __kmp_initz_lock held. */ -void -__kmp_common_initialize( void ) -{ - if( ! TCR_4(__kmp_init_common) ) { - int q; +void __kmp_common_initialize(void) { + if (!TCR_4(__kmp_init_common)) { + int q; #ifdef KMP_DEBUG - int gtid; + int gtid; #endif - __kmp_threadpriv_cache_list = NULL; + __kmp_threadpriv_cache_list = NULL; #ifdef KMP_DEBUG - /* verify the uber masters were initialized */ - for(gtid = 0 ; gtid < __kmp_threads_capacity; gtid++ ) - if( __kmp_root[gtid] ) { - KMP_DEBUG_ASSERT( __kmp_root[gtid]->r.r_uber_thread ); - for ( q = 0; q< KMP_HASH_TABLE_SIZE; ++q) - KMP_DEBUG_ASSERT( !__kmp_root[gtid]->r.r_uber_thread->th.th_pri_common->data[q] ); -/* __kmp_root[ gitd ]-> r.r_uber_thread -> th.th_pri_common -> data[ q ] = 0;*/ - } + /* verify the uber masters were initialized */ + for (gtid = 0; gtid < __kmp_threads_capacity; gtid++) + if (__kmp_root[gtid]) { + KMP_DEBUG_ASSERT(__kmp_root[gtid]->r.r_uber_thread); + for (q = 0; q < KMP_HASH_TABLE_SIZE; ++q) + KMP_DEBUG_ASSERT( + !__kmp_root[gtid]->r.r_uber_thread->th.th_pri_common->data[q]); + /* __kmp_root[ gitd ]-> r.r_uber_thread -> + * th.th_pri_common -> data[ q ] = 0;*/ + } #endif /* KMP_DEBUG */ - for (q = 0; q < KMP_HASH_TABLE_SIZE; ++q) - __kmp_threadprivate_d_table.data[ q ] = 0; + for (q = 0; q < KMP_HASH_TABLE_SIZE; ++q) + __kmp_threadprivate_d_table.data[q] = 0; - TCW_4(__kmp_init_common, TRUE); - } + TCW_4(__kmp_init_common, TRUE); + } } /* Call all destructors for threadprivate data belonging to all threads. Currently unused! */ -void -__kmp_common_destroy( void ) -{ - if( TCR_4(__kmp_init_common) ) { - int q; - - TCW_4(__kmp_init_common, FALSE); - - for (q = 0; q < KMP_HASH_TABLE_SIZE; ++q) { - int gtid; - struct private_common *tn; - struct shared_common *d_tn; - - /* C++ destructors need to be called once per thread before exiting */ - /* don't call destructors for master thread though unless we used copy constructor */ - - for (d_tn = __kmp_threadprivate_d_table.data[ q ]; d_tn; d_tn = d_tn->next) { - if (d_tn->is_vec) { - if (d_tn->dt.dtorv != 0) { - for (gtid = 0; gtid < __kmp_all_nth; ++gtid) { - if( __kmp_threads[gtid] ) { - if( (__kmp_foreign_tp) ? (! KMP_INITIAL_GTID (gtid)) : - (! KMP_UBER_GTID (gtid)) ) { - tn = __kmp_threadprivate_find_task_common( __kmp_threads[ gtid ]->th.th_pri_common, - gtid, d_tn->gbl_addr ); - if (tn) { - (*d_tn->dt.dtorv) (tn->par_addr, d_tn->vec_len); - } - } - } - } - if (d_tn->obj_init != 0) { - (*d_tn->dt.dtorv) (d_tn->obj_init, d_tn->vec_len); - } - } - } else { - if (d_tn->dt.dtor != 0) { - for (gtid = 0; gtid < __kmp_all_nth; ++gtid) { - if( __kmp_threads[gtid] ) { - if( (__kmp_foreign_tp) ? (! KMP_INITIAL_GTID (gtid)) : - (! KMP_UBER_GTID (gtid)) ) { - tn = __kmp_threadprivate_find_task_common( __kmp_threads[ gtid ]->th.th_pri_common, - gtid, d_tn->gbl_addr ); - if (tn) { - (*d_tn->dt.dtor) (tn->par_addr); - } - } - } - } - if (d_tn->obj_init != 0) { - (*d_tn->dt.dtor) (d_tn->obj_init); - } - } +void __kmp_common_destroy(void) { + if (TCR_4(__kmp_init_common)) { + int q; + + TCW_4(__kmp_init_common, FALSE); + + for (q = 0; q < KMP_HASH_TABLE_SIZE; ++q) { + int gtid; + struct private_common *tn; + struct shared_common *d_tn; + + /* C++ destructors need to be called once per thread before exiting. + Don't call destructors for master thread though unless we used copy + constructor */ + + for (d_tn = __kmp_threadprivate_d_table.data[q]; d_tn; + d_tn = d_tn->next) { + if (d_tn->is_vec) { + if (d_tn->dt.dtorv != 0) { + for (gtid = 0; gtid < __kmp_all_nth; ++gtid) { + if (__kmp_threads[gtid]) { + if ((__kmp_foreign_tp) ? (!KMP_INITIAL_GTID(gtid)) + : (!KMP_UBER_GTID(gtid))) { + tn = __kmp_threadprivate_find_task_common( + __kmp_threads[gtid]->th.th_pri_common, gtid, + d_tn->gbl_addr); + if (tn) { + (*d_tn->dt.dtorv)(tn->par_addr, d_tn->vec_len); + } + } + } + } + if (d_tn->obj_init != 0) { + (*d_tn->dt.dtorv)(d_tn->obj_init, d_tn->vec_len); + } + } + } else { + if (d_tn->dt.dtor != 0) { + for (gtid = 0; gtid < __kmp_all_nth; ++gtid) { + if (__kmp_threads[gtid]) { + if ((__kmp_foreign_tp) ? (!KMP_INITIAL_GTID(gtid)) + : (!KMP_UBER_GTID(gtid))) { + tn = __kmp_threadprivate_find_task_common( + __kmp_threads[gtid]->th.th_pri_common, gtid, + d_tn->gbl_addr); + if (tn) { + (*d_tn->dt.dtor)(tn->par_addr); + } } + } } - __kmp_threadprivate_d_table.data[ q ] = 0; + if (d_tn->obj_init != 0) { + (*d_tn->dt.dtor)(d_tn->obj_init); + } + } } + } + __kmp_threadprivate_d_table.data[q] = 0; } + } } /* Call all destructors for threadprivate data belonging to this thread */ -void -__kmp_common_destroy_gtid( int gtid ) -{ - struct private_common *tn; - struct shared_common *d_tn; - - KC_TRACE( 10, ("__kmp_common_destroy_gtid: T#%d called\n", gtid ) ); - if( (__kmp_foreign_tp) ? (! KMP_INITIAL_GTID (gtid)) : - (! KMP_UBER_GTID (gtid)) ) { - - if( TCR_4(__kmp_init_common) ) { - - /* Cannot do this here since not all threads have destroyed their data */ - /* TCW_4(__kmp_init_common, FALSE); */ - - for (tn = __kmp_threads[ gtid ]->th.th_pri_head; tn; tn = tn->link) { - - d_tn = __kmp_find_shared_task_common( &__kmp_threadprivate_d_table, - gtid, tn->gbl_addr ); - - KMP_DEBUG_ASSERT( d_tn ); - - if (d_tn->is_vec) { - if (d_tn->dt.dtorv != 0) { - (void) (*d_tn->dt.dtorv) (tn->par_addr, d_tn->vec_len); - } - if (d_tn->obj_init != 0) { - (void) (*d_tn->dt.dtorv) (d_tn->obj_init, d_tn->vec_len); - } - } else { - if (d_tn->dt.dtor != 0) { - (void) (*d_tn->dt.dtor) (tn->par_addr); - } - if (d_tn->obj_init != 0) { - (void) (*d_tn->dt.dtor) (d_tn->obj_init); - } - } - } - KC_TRACE( 30, ("__kmp_common_destroy_gtid: T#%d threadprivate destructors complete\n", - gtid ) ); +void __kmp_common_destroy_gtid(int gtid) { + struct private_common *tn; + struct shared_common *d_tn; + + KC_TRACE(10, ("__kmp_common_destroy_gtid: T#%d called\n", gtid)); + if ((__kmp_foreign_tp) ? (!KMP_INITIAL_GTID(gtid)) : (!KMP_UBER_GTID(gtid))) { + + if (TCR_4(__kmp_init_common)) { + + /* Cannot do this here since not all threads have destroyed their data */ + /* TCW_4(__kmp_init_common, FALSE); */ + + for (tn = __kmp_threads[gtid]->th.th_pri_head; tn; tn = tn->link) { + + d_tn = __kmp_find_shared_task_common(&__kmp_threadprivate_d_table, gtid, + tn->gbl_addr); + + KMP_DEBUG_ASSERT(d_tn); + + if (d_tn->is_vec) { + if (d_tn->dt.dtorv != 0) { + (void)(*d_tn->dt.dtorv)(tn->par_addr, d_tn->vec_len); + } + if (d_tn->obj_init != 0) { + (void)(*d_tn->dt.dtorv)(d_tn->obj_init, d_tn->vec_len); + } + } else { + if (d_tn->dt.dtor != 0) { + (void)(*d_tn->dt.dtor)(tn->par_addr); + } + if (d_tn->obj_init != 0) { + (void)(*d_tn->dt.dtor)(d_tn->obj_init); + } } + } + KC_TRACE(30, ("__kmp_common_destroy_gtid: T#%d threadprivate destructors " + "complete\n", + gtid)); } + } } -/* ------------------------------------------------------------------------ */ -/* ------------------------------------------------------------------------ */ - #ifdef KMP_TASK_COMMON_DEBUG -static void -dump_list( void ) -{ - int p, q; - - for (p = 0; p < __kmp_all_nth; ++p) { - if( !__kmp_threads[p] ) continue; - for (q = 0; q < KMP_HASH_TABLE_SIZE; ++q) { - if (__kmp_threads[ p ]->th.th_pri_common->data[ q ]) { - struct private_common *tn; - - KC_TRACE( 10, ( "\tdump_list: gtid:%d addresses\n", p ) ); - - for (tn = __kmp_threads[ p ]->th.th_pri_common->data[ q ]; tn; tn = tn->next) { - KC_TRACE( 10, ( "\tdump_list: THREADPRIVATE: Serial %p -> Parallel %p\n", - tn->gbl_addr, tn->par_addr ) ); - } - } +static void dump_list(void) { + int p, q; + + for (p = 0; p < __kmp_all_nth; ++p) { + if (!__kmp_threads[p]) + continue; + for (q = 0; q < KMP_HASH_TABLE_SIZE; ++q) { + if (__kmp_threads[p]->th.th_pri_common->data[q]) { + struct private_common *tn; + + KC_TRACE(10, ("\tdump_list: gtid:%d addresses\n", p)); + + for (tn = __kmp_threads[p]->th.th_pri_common->data[q]; tn; + tn = tn->next) { + KC_TRACE(10, + ("\tdump_list: THREADPRIVATE: Serial %p -> Parallel %p\n", + tn->gbl_addr, tn->par_addr)); } + } } + } } #endif /* KMP_TASK_COMMON_DEBUG */ +// NOTE: this routine is to be called only from the serial part of the program. +void kmp_threadprivate_insert_private_data(int gtid, void *pc_addr, + void *data_addr, size_t pc_size) { + struct shared_common **lnk_tn, *d_tn; + KMP_DEBUG_ASSERT(__kmp_threads[gtid] && + __kmp_threads[gtid]->th.th_root->r.r_active == 0); -/* - * NOTE: this routine is to be called only from the serial part of the program. - */ - -void -kmp_threadprivate_insert_private_data( int gtid, void *pc_addr, void *data_addr, size_t pc_size ) -{ - struct shared_common **lnk_tn, *d_tn; - KMP_DEBUG_ASSERT( __kmp_threads[ gtid ] && - __kmp_threads[ gtid ] -> th.th_root -> r.r_active == 0 ); - - d_tn = __kmp_find_shared_task_common( &__kmp_threadprivate_d_table, - gtid, pc_addr ); + d_tn = __kmp_find_shared_task_common(&__kmp_threadprivate_d_table, gtid, + pc_addr); - if (d_tn == 0) { - d_tn = (struct shared_common *) __kmp_allocate( sizeof( struct shared_common ) ); + if (d_tn == 0) { + d_tn = (struct shared_common *)__kmp_allocate(sizeof(struct shared_common)); - d_tn->gbl_addr = pc_addr; - d_tn->pod_init = __kmp_init_common_data( data_addr, pc_size ); -/* - d_tn->obj_init = 0; // AC: commented out because __kmp_allocate zeroes the memory - d_tn->ct.ctor = 0; - d_tn->cct.cctor = 0;; - d_tn->dt.dtor = 0; - d_tn->is_vec = FALSE; - d_tn->vec_len = 0L; -*/ - d_tn->cmn_size = pc_size; + d_tn->gbl_addr = pc_addr; + d_tn->pod_init = __kmp_init_common_data(data_addr, pc_size); + /* + d_tn->obj_init = 0; // AC: commented out because __kmp_allocate + zeroes the memory + d_tn->ct.ctor = 0; + d_tn->cct.cctor = 0;; + d_tn->dt.dtor = 0; + d_tn->is_vec = FALSE; + d_tn->vec_len = 0L; + */ + d_tn->cmn_size = pc_size; - __kmp_acquire_lock( &__kmp_global_lock, gtid ); + __kmp_acquire_lock(&__kmp_global_lock, gtid); - lnk_tn = &(__kmp_threadprivate_d_table.data[ KMP_HASH(pc_addr) ]); + lnk_tn = &(__kmp_threadprivate_d_table.data[KMP_HASH(pc_addr)]); - d_tn->next = *lnk_tn; - *lnk_tn = d_tn; + d_tn->next = *lnk_tn; + *lnk_tn = d_tn; - __kmp_release_lock( &__kmp_global_lock, gtid ); - } + __kmp_release_lock(&__kmp_global_lock, gtid); + } } -struct private_common * -kmp_threadprivate_insert( int gtid, void *pc_addr, void *data_addr, size_t pc_size ) -{ - struct private_common *tn, **tt; - struct shared_common *d_tn; - - /* +++++++++ START OF CRITICAL SECTION +++++++++ */ +struct private_common *kmp_threadprivate_insert(int gtid, void *pc_addr, + void *data_addr, + size_t pc_size) { + struct private_common *tn, **tt; + struct shared_common *d_tn; - __kmp_acquire_lock( & __kmp_global_lock, gtid ); + /* +++++++++ START OF CRITICAL SECTION +++++++++ */ + __kmp_acquire_lock(&__kmp_global_lock, gtid); - tn = (struct private_common *) __kmp_allocate( sizeof (struct private_common) ); + tn = (struct private_common *)__kmp_allocate(sizeof(struct private_common)); - tn->gbl_addr = pc_addr; + tn->gbl_addr = pc_addr; - d_tn = __kmp_find_shared_task_common( &__kmp_threadprivate_d_table, - gtid, pc_addr ); /* Only the MASTER data table exists. */ + d_tn = __kmp_find_shared_task_common( + &__kmp_threadprivate_d_table, gtid, + pc_addr); /* Only the MASTER data table exists. */ - if (d_tn != 0) { - /* This threadprivate variable has already been seen. */ + if (d_tn != 0) { + /* This threadprivate variable has already been seen. */ - if ( d_tn->pod_init == 0 && d_tn->obj_init == 0 ) { - d_tn->cmn_size = pc_size; + if (d_tn->pod_init == 0 && d_tn->obj_init == 0) { + d_tn->cmn_size = pc_size; - if (d_tn->is_vec) { - if (d_tn->ct.ctorv != 0) { - /* Construct from scratch so no prototype exists */ - d_tn->obj_init = 0; - } - else if (d_tn->cct.cctorv != 0) { - /* Now data initialize the prototype since it was previously registered */ - d_tn->obj_init = (void *) __kmp_allocate( d_tn->cmn_size ); - (void) (*d_tn->cct.cctorv) (d_tn->obj_init, pc_addr, d_tn->vec_len); - } - else { - d_tn->pod_init = __kmp_init_common_data( data_addr, d_tn->cmn_size ); - } - } else { - if (d_tn->ct.ctor != 0) { - /* Construct from scratch so no prototype exists */ - d_tn->obj_init = 0; - } - else if (d_tn->cct.cctor != 0) { - /* Now data initialize the prototype since it was previously registered */ - d_tn->obj_init = (void *) __kmp_allocate( d_tn->cmn_size ); - (void) (*d_tn->cct.cctor) (d_tn->obj_init, pc_addr); - } - else { - d_tn->pod_init = __kmp_init_common_data( data_addr, d_tn->cmn_size ); - } - } + if (d_tn->is_vec) { + if (d_tn->ct.ctorv != 0) { + /* Construct from scratch so no prototype exists */ + d_tn->obj_init = 0; + } else if (d_tn->cct.cctorv != 0) { + /* Now data initialize the prototype since it was previously + * registered */ + d_tn->obj_init = (void *)__kmp_allocate(d_tn->cmn_size); + (void)(*d_tn->cct.cctorv)(d_tn->obj_init, pc_addr, d_tn->vec_len); + } else { + d_tn->pod_init = __kmp_init_common_data(data_addr, d_tn->cmn_size); } + } else { + if (d_tn->ct.ctor != 0) { + /* Construct from scratch so no prototype exists */ + d_tn->obj_init = 0; + } else if (d_tn->cct.cctor != 0) { + /* Now data initialize the prototype since it was previously + registered */ + d_tn->obj_init = (void *)__kmp_allocate(d_tn->cmn_size); + (void)(*d_tn->cct.cctor)(d_tn->obj_init, pc_addr); + } else { + d_tn->pod_init = __kmp_init_common_data(data_addr, d_tn->cmn_size); + } + } } - else { - struct shared_common **lnk_tn; - - d_tn = (struct shared_common *) __kmp_allocate( sizeof( struct shared_common ) ); - d_tn->gbl_addr = pc_addr; - d_tn->cmn_size = pc_size; - d_tn->pod_init = __kmp_init_common_data( data_addr, pc_size ); -/* - d_tn->obj_init = 0; // AC: commented out because __kmp_allocate zeroes the memory - d_tn->ct.ctor = 0; - d_tn->cct.cctor = 0; - d_tn->dt.dtor = 0; - d_tn->is_vec = FALSE; - d_tn->vec_len = 0L; -*/ - lnk_tn = &(__kmp_threadprivate_d_table.data[ KMP_HASH(pc_addr) ]); - - d_tn->next = *lnk_tn; - *lnk_tn = d_tn; - } - - tn->cmn_size = d_tn->cmn_size; - - if ( (__kmp_foreign_tp) ? (KMP_INITIAL_GTID (gtid)) : (KMP_UBER_GTID (gtid)) ) { - tn->par_addr = (void *) pc_addr; - } - else { - tn->par_addr = (void *) __kmp_allocate( tn->cmn_size ); - } - - __kmp_release_lock( & __kmp_global_lock, gtid ); + } else { + struct shared_common **lnk_tn; - /* +++++++++ END OF CRITICAL SECTION +++++++++ */ + d_tn = (struct shared_common *)__kmp_allocate(sizeof(struct shared_common)); + d_tn->gbl_addr = pc_addr; + d_tn->cmn_size = pc_size; + d_tn->pod_init = __kmp_init_common_data(data_addr, pc_size); + /* + d_tn->obj_init = 0; // AC: commented out because __kmp_allocate + zeroes the memory + d_tn->ct.ctor = 0; + d_tn->cct.cctor = 0; + d_tn->dt.dtor = 0; + d_tn->is_vec = FALSE; + d_tn->vec_len = 0L; + */ + lnk_tn = &(__kmp_threadprivate_d_table.data[KMP_HASH(pc_addr)]); + + d_tn->next = *lnk_tn; + *lnk_tn = d_tn; + } + + tn->cmn_size = d_tn->cmn_size; + + if ((__kmp_foreign_tp) ? (KMP_INITIAL_GTID(gtid)) : (KMP_UBER_GTID(gtid))) { + tn->par_addr = (void *)pc_addr; + } else { + tn->par_addr = (void *)__kmp_allocate(tn->cmn_size); + } + + __kmp_release_lock(&__kmp_global_lock, gtid); +/* +++++++++ END OF CRITICAL SECTION +++++++++ */ #ifdef USE_CHECKS_COMMON - if (pc_size > d_tn->cmn_size) { - KC_TRACE( 10, ( "__kmp_threadprivate_insert: THREADPRIVATE: %p (%" - KMP_UINTPTR_SPEC " ,%" KMP_UINTPTR_SPEC ")\n", - pc_addr, pc_size, d_tn->cmn_size ) ); - KMP_FATAL( TPCommonBlocksInconsist ); - } + if (pc_size > d_tn->cmn_size) { + KC_TRACE( + 10, ("__kmp_threadprivate_insert: THREADPRIVATE: %p (%" KMP_UINTPTR_SPEC + " ,%" KMP_UINTPTR_SPEC ")\n", + pc_addr, pc_size, d_tn->cmn_size)); + KMP_FATAL(TPCommonBlocksInconsist); + } #endif /* USE_CHECKS_COMMON */ - tt = &(__kmp_threads[ gtid ]->th.th_pri_common->data[ KMP_HASH(pc_addr) ]); + tt = &(__kmp_threads[gtid]->th.th_pri_common->data[KMP_HASH(pc_addr)]); #ifdef KMP_TASK_COMMON_DEBUG - if (*tt != 0) { - KC_TRACE( 10, ( "__kmp_threadprivate_insert: WARNING! thread#%d: collision on %p\n", - gtid, pc_addr ) ); - } + if (*tt != 0) { + KC_TRACE( + 10, + ("__kmp_threadprivate_insert: WARNING! thread#%d: collision on %p\n", + gtid, pc_addr)); + } #endif - tn->next = *tt; - *tt = tn; + tn->next = *tt; + *tt = tn; #ifdef KMP_TASK_COMMON_DEBUG - KC_TRACE( 10, ( "__kmp_threadprivate_insert: thread#%d, inserted node %p on list\n", - gtid, pc_addr ) ); - dump_list( ); + KC_TRACE(10, + ("__kmp_threadprivate_insert: thread#%d, inserted node %p on list\n", + gtid, pc_addr)); + dump_list(); #endif - /* Link the node into a simple list */ + /* Link the node into a simple list */ - tn->link = __kmp_threads[ gtid ]->th.th_pri_head; - __kmp_threads[ gtid ]->th.th_pri_head = tn; + 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 ); + __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 allocate - * C++ copy constructors need to be called once for each thread on allocate - */ + if ((__kmp_foreign_tp) ? (KMP_INITIAL_GTID(gtid)) : (KMP_UBER_GTID(gtid))) + return tn; - /* - * C++ object with constructors/destructors; - * don't call constructors for master thread though - */ - if (d_tn->is_vec) { - if ( d_tn->ct.ctorv != 0) { - (void) (*d_tn->ct.ctorv) (tn->par_addr, d_tn->vec_len); - } else if (d_tn->cct.cctorv != 0) { - (void) (*d_tn->cct.cctorv) (tn->par_addr, d_tn->obj_init, d_tn->vec_len); - } else if (tn->par_addr != tn->gbl_addr) { - __kmp_copy_common_data( tn->par_addr, d_tn->pod_init ); - } - } else { - if ( d_tn->ct.ctor != 0 ) { - (void) (*d_tn->ct.ctor) (tn->par_addr); - } else if (d_tn->cct.cctor != 0) { - (void) (*d_tn->cct.cctor) (tn->par_addr, d_tn->obj_init); - } else if (tn->par_addr != tn->gbl_addr) { - __kmp_copy_common_data( tn->par_addr, d_tn->pod_init ); - } + /* 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 + * allocate + * C++ copy constructors need to be called once for each thread on allocate */ + + /* C++ object with constructors/destructors; don't call constructors for + master thread though */ + if (d_tn->is_vec) { + if (d_tn->ct.ctorv != 0) { + (void)(*d_tn->ct.ctorv)(tn->par_addr, d_tn->vec_len); + } else if (d_tn->cct.cctorv != 0) { + (void)(*d_tn->cct.cctorv)(tn->par_addr, d_tn->obj_init, d_tn->vec_len); + } else if (tn->par_addr != tn->gbl_addr) { + __kmp_copy_common_data(tn->par_addr, d_tn->pod_init); } -/* !BUILD_OPENMP_C - if (tn->par_addr != tn->gbl_addr) - __kmp_copy_common_data( tn->par_addr, d_tn->pod_init ); */ + } else { + if (d_tn->ct.ctor != 0) { + (void)(*d_tn->ct.ctor)(tn->par_addr); + } else if (d_tn->cct.cctor != 0) { + (void)(*d_tn->cct.cctor)(tn->par_addr, d_tn->obj_init); + } else if (tn->par_addr != tn->gbl_addr) { + __kmp_copy_common_data(tn->par_addr, d_tn->pod_init); + } + } + /* !BUILD_OPENMP_C + if (tn->par_addr != tn->gbl_addr) + __kmp_copy_common_data( tn->par_addr, d_tn->pod_init ); */ - return tn; + return tn; } /* ------------------------------------------------------------------------ */ @@ -528,91 +502,95 @@ kmp_threadprivate_insert( int gtid, void *pc_addr, void *data_addr, size_t pc_si Register constructors and destructors for thread private data. This function is called when executing in parallel, when we know the thread id. */ -void -__kmpc_threadprivate_register(ident_t *loc, void *data, kmpc_ctor ctor, kmpc_cctor cctor, kmpc_dtor dtor) -{ - struct shared_common *d_tn, **lnk_tn; +void __kmpc_threadprivate_register(ident_t *loc, void *data, kmpc_ctor ctor, + kmpc_cctor cctor, kmpc_dtor dtor) { + struct shared_common *d_tn, **lnk_tn; - KC_TRACE( 10, ("__kmpc_threadprivate_register: called\n" ) ); + KC_TRACE(10, ("__kmpc_threadprivate_register: called\n")); #ifdef USE_CHECKS_COMMON - /* copy constructor must be zero for current code gen (Nov 2002 - jph) */ - KMP_ASSERT( cctor == 0); + /* copy constructor must be zero for current code gen (Nov 2002 - jph) */ + KMP_ASSERT(cctor == 0); #endif /* USE_CHECKS_COMMON */ - /* Only the global data table exists. */ - d_tn = __kmp_find_shared_task_common( &__kmp_threadprivate_d_table, -1, data ); - - if (d_tn == 0) { - d_tn = (struct shared_common *) __kmp_allocate( sizeof( struct shared_common ) ); - d_tn->gbl_addr = data; + /* Only the global data table exists. */ + d_tn = __kmp_find_shared_task_common(&__kmp_threadprivate_d_table, -1, data); - d_tn->ct.ctor = ctor; - d_tn->cct.cctor = cctor; - d_tn->dt.dtor = dtor; -/* - d_tn->is_vec = FALSE; // AC: commented out because __kmp_allocate zeroes the memory - d_tn->vec_len = 0L; - d_tn->obj_init = 0; - d_tn->pod_init = 0; -*/ - lnk_tn = &(__kmp_threadprivate_d_table.data[ KMP_HASH(data) ]); + if (d_tn == 0) { + d_tn = (struct shared_common *)__kmp_allocate(sizeof(struct shared_common)); + d_tn->gbl_addr = data; - d_tn->next = *lnk_tn; - *lnk_tn = d_tn; - } + d_tn->ct.ctor = ctor; + d_tn->cct.cctor = cctor; + d_tn->dt.dtor = dtor; + /* + d_tn->is_vec = FALSE; // AC: commented out because __kmp_allocate + zeroes the memory + d_tn->vec_len = 0L; + d_tn->obj_init = 0; + d_tn->pod_init = 0; + */ + lnk_tn = &(__kmp_threadprivate_d_table.data[KMP_HASH(data)]); + + d_tn->next = *lnk_tn; + *lnk_tn = d_tn; + } } -void * -__kmpc_threadprivate(ident_t *loc, kmp_int32 global_tid, void *data, size_t size) -{ - void *ret; - struct private_common *tn; +void *__kmpc_threadprivate(ident_t *loc, kmp_int32 global_tid, void *data, + size_t size) { + void *ret; + struct private_common *tn; - KC_TRACE( 10, ("__kmpc_threadprivate: T#%d called\n", global_tid ) ); + KC_TRACE(10, ("__kmpc_threadprivate: T#%d called\n", global_tid)); #ifdef USE_CHECKS_COMMON - if (! __kmp_init_serial) - KMP_FATAL( RTLNotInitialized ); + if (!__kmp_init_serial) + KMP_FATAL(RTLNotInitialized); #endif /* USE_CHECKS_COMMON */ - if ( ! __kmp_threads[global_tid] -> th.th_root -> r.r_active && ! __kmp_foreign_tp ) { - /* The parallel address will NEVER overlap with the data_address */ - /* dkp: 3rd arg to kmp_threadprivate_insert_private_data() is the data_address; use data_address = data */ - - KC_TRACE( 20, ("__kmpc_threadprivate: T#%d inserting private data\n", global_tid ) ); - kmp_threadprivate_insert_private_data( global_tid, data, data, size ); - - ret = data; - } - else { - KC_TRACE( 50, ("__kmpc_threadprivate: T#%d try to find private data at address %p\n", - global_tid, data ) ); - tn = __kmp_threadprivate_find_task_common( __kmp_threads[ global_tid ]->th.th_pri_common, global_tid, data ); - - if ( tn ) { - KC_TRACE( 20, ("__kmpc_threadprivate: T#%d found data\n", global_tid ) ); + if (!__kmp_threads[global_tid]->th.th_root->r.r_active && !__kmp_foreign_tp) { + /* The parallel address will NEVER overlap with the data_address */ + /* dkp: 3rd arg to kmp_threadprivate_insert_private_data() is the + * data_address; use data_address = data */ + + KC_TRACE(20, ("__kmpc_threadprivate: T#%d inserting private data\n", + global_tid)); + kmp_threadprivate_insert_private_data(global_tid, data, data, size); + + ret = data; + } else { + KC_TRACE( + 50, + ("__kmpc_threadprivate: T#%d try to find private data at address %p\n", + global_tid, data)); + tn = __kmp_threadprivate_find_task_common( + __kmp_threads[global_tid]->th.th_pri_common, global_tid, data); + + if (tn) { + KC_TRACE(20, ("__kmpc_threadprivate: T#%d found data\n", global_tid)); #ifdef USE_CHECKS_COMMON - if ((size_t) size > tn->cmn_size) { - KC_TRACE( 10, ( "THREADPRIVATE: %p (%" KMP_UINTPTR_SPEC " ,%" KMP_UINTPTR_SPEC ")\n", - data, size, tn->cmn_size ) ); - KMP_FATAL( TPCommonBlocksInconsist ); - } + if ((size_t)size > tn->cmn_size) { + KC_TRACE(10, ("THREADPRIVATE: %p (%" KMP_UINTPTR_SPEC + " ,%" KMP_UINTPTR_SPEC ")\n", + data, size, tn->cmn_size)); + KMP_FATAL(TPCommonBlocksInconsist); + } #endif /* USE_CHECKS_COMMON */ - } - else { - /* The parallel address will NEVER overlap with the data_address */ - /* dkp: 3rd arg to kmp_threadprivate_insert() is the data_address; use data_address = data */ - KC_TRACE( 20, ("__kmpc_threadprivate: T#%d inserting data\n", global_tid ) ); - tn = kmp_threadprivate_insert( global_tid, data, data, size ); - } - - ret = tn->par_addr; + } else { + /* The parallel address will NEVER overlap with the data_address */ + /* dkp: 3rd arg to kmp_threadprivate_insert() is the data_address; use + * data_address = data */ + KC_TRACE(20, ("__kmpc_threadprivate: T#%d inserting data\n", global_tid)); + tn = kmp_threadprivate_insert(global_tid, data, data, size); } - KC_TRACE( 10, ("__kmpc_threadprivate: T#%d exiting; return value = %p\n", - global_tid, ret ) ); - return ret; + ret = tn->par_addr; + } + KC_TRACE(10, ("__kmpc_threadprivate: T#%d exiting; return value = %p\n", + global_tid, ret)); + + return ret; } /*! @@ -627,62 +605,63 @@ __kmpc_threadprivate(ident_t *loc, kmp_int32 global_tid, void *data, size_t size Allocate private storage for threadprivate data. */ void * -__kmpc_threadprivate_cached( - ident_t * loc, - kmp_int32 global_tid, // gtid. - void * data, // Pointer to original global variable. - size_t size, // Size of original global variable. - void *** cache -) { - KC_TRACE( 10, ("__kmpc_threadprivate_cached: T#%d called with cache: %p, address: %p, size: %" - KMP_SIZE_T_SPEC "\n", - global_tid, *cache, data, size ) ); - - if ( TCR_PTR(*cache) == 0) { - __kmp_acquire_lock( & __kmp_global_lock, global_tid ); - - if ( TCR_PTR(*cache) == 0) { - __kmp_acquire_bootstrap_lock(&__kmp_tp_cached_lock); - __kmp_tp_cached = 1; - __kmp_release_bootstrap_lock(&__kmp_tp_cached_lock); - void ** my_cache; - KMP_ITT_IGNORE( - my_cache = (void**) - __kmp_allocate(sizeof( void * ) * __kmp_tp_capacity + sizeof ( kmp_cached_addr_t )); - ); - // No need to zero the allocated memory; __kmp_allocate does that. - KC_TRACE( 50, ("__kmpc_threadprivate_cached: T#%d allocated cache at address %p\n", - global_tid, my_cache ) ); - - /* TODO: free all this memory in __kmp_common_destroy using __kmp_threadpriv_cache_list */ - /* Add address of mycache to linked list for cleanup later */ - kmp_cached_addr_t *tp_cache_addr; - - tp_cache_addr = (kmp_cached_addr_t *) & my_cache[__kmp_tp_capacity]; - tp_cache_addr -> addr = my_cache; - tp_cache_addr -> next = __kmp_threadpriv_cache_list; - __kmp_threadpriv_cache_list = tp_cache_addr; - - KMP_MB(); - - TCW_PTR( *cache, my_cache); - - KMP_MB(); - } - - __kmp_release_lock( & __kmp_global_lock, global_tid ); +__kmpc_threadprivate_cached(ident_t *loc, + kmp_int32 global_tid, // gtid. + void *data, // Pointer to original global variable. + size_t size, // Size of original global variable. + void ***cache) { + KC_TRACE(10, ("__kmpc_threadprivate_cached: T#%d called with cache: %p, " + "address: %p, size: %" KMP_SIZE_T_SPEC "\n", + global_tid, *cache, data, size)); + + if (TCR_PTR(*cache) == 0) { + __kmp_acquire_lock(&__kmp_global_lock, global_tid); + + if (TCR_PTR(*cache) == 0) { + __kmp_acquire_bootstrap_lock(&__kmp_tp_cached_lock); + __kmp_tp_cached = 1; + __kmp_release_bootstrap_lock(&__kmp_tp_cached_lock); + void **my_cache; + KMP_ITT_IGNORE( + my_cache = (void **)__kmp_allocate( + sizeof(void *) * __kmp_tp_capacity + sizeof(kmp_cached_addr_t));); + // No need to zero the allocated memory; __kmp_allocate does that. + KC_TRACE( + 50, + ("__kmpc_threadprivate_cached: T#%d allocated cache at address %p\n", + global_tid, my_cache)); + + /* TODO: free all this memory in __kmp_common_destroy using + * __kmp_threadpriv_cache_list */ + /* Add address of mycache to linked list for cleanup later */ + kmp_cached_addr_t *tp_cache_addr; + + tp_cache_addr = (kmp_cached_addr_t *)&my_cache[__kmp_tp_capacity]; + tp_cache_addr->addr = my_cache; + tp_cache_addr->next = __kmp_threadpriv_cache_list; + __kmp_threadpriv_cache_list = tp_cache_addr; + + KMP_MB(); + + TCW_PTR(*cache, my_cache); + + KMP_MB(); } - void *ret; - if ((ret = TCR_PTR((*cache)[ global_tid ])) == 0) { - ret = __kmpc_threadprivate( loc, global_tid, data, (size_t) size); + __kmp_release_lock(&__kmp_global_lock, global_tid); + } - TCW_PTR( (*cache)[ global_tid ], ret); - } - KC_TRACE( 10, ("__kmpc_threadprivate_cached: T#%d exiting; return value = %p\n", - global_tid, ret ) ); + void *ret; + if ((ret = TCR_PTR((*cache)[global_tid])) == 0) { + ret = __kmpc_threadprivate(loc, global_tid, data, (size_t)size); + + TCW_PTR((*cache)[global_tid], ret); + } + KC_TRACE(10, + ("__kmpc_threadprivate_cached: T#%d exiting; return value = %p\n", + global_tid, ret)); - return ret; + return ret; } /*! @@ -695,39 +674,40 @@ __kmpc_threadprivate_cached( @param vector_length length of the vector (bytes or elements?) Register vector constructors and destructors for thread private data. */ -void -__kmpc_threadprivate_register_vec( ident_t *loc, void *data, kmpc_ctor_vec ctor, - kmpc_cctor_vec cctor, kmpc_dtor_vec dtor, - size_t vector_length ) -{ - struct shared_common *d_tn, **lnk_tn; +void __kmpc_threadprivate_register_vec(ident_t *loc, void *data, + kmpc_ctor_vec ctor, kmpc_cctor_vec cctor, + kmpc_dtor_vec dtor, + size_t vector_length) { + struct shared_common *d_tn, **lnk_tn; - KC_TRACE( 10, ("__kmpc_threadprivate_register_vec: called\n" ) ); + KC_TRACE(10, ("__kmpc_threadprivate_register_vec: called\n")); #ifdef USE_CHECKS_COMMON - /* copy constructor must be zero for current code gen (Nov 2002 - jph) */ - KMP_ASSERT( cctor == 0); + /* copy constructor must be zero for current code gen (Nov 2002 - jph) */ + KMP_ASSERT(cctor == 0); #endif /* USE_CHECKS_COMMON */ - d_tn = __kmp_find_shared_task_common( &__kmp_threadprivate_d_table, - -1, data ); /* Only the global data table exists. */ - - if (d_tn == 0) { - d_tn = (struct shared_common *) __kmp_allocate( sizeof( struct shared_common ) ); - d_tn->gbl_addr = data; + d_tn = __kmp_find_shared_task_common( + &__kmp_threadprivate_d_table, -1, + data); /* Only the global data table exists. */ - d_tn->ct.ctorv = ctor; - d_tn->cct.cctorv = cctor; - d_tn->dt.dtorv = dtor; - d_tn->is_vec = TRUE; - d_tn->vec_len = (size_t) vector_length; -/* - d_tn->obj_init = 0; // AC: commented out because __kmp_allocate zeroes the memory - d_tn->pod_init = 0; -*/ - lnk_tn = &(__kmp_threadprivate_d_table.data[ KMP_HASH(data) ]); + if (d_tn == 0) { + d_tn = (struct shared_common *)__kmp_allocate(sizeof(struct shared_common)); + d_tn->gbl_addr = data; - d_tn->next = *lnk_tn; - *lnk_tn = d_tn; - } + d_tn->ct.ctorv = ctor; + d_tn->cct.cctorv = cctor; + d_tn->dt.dtorv = dtor; + d_tn->is_vec = TRUE; + d_tn->vec_len = (size_t)vector_length; + /* + d_tn->obj_init = 0; // AC: commented out because __kmp_allocate + zeroes the memory + d_tn->pod_init = 0; + */ + lnk_tn = &(__kmp_threadprivate_d_table.data[KMP_HASH(data)]); + + d_tn->next = *lnk_tn; + *lnk_tn = d_tn; + } } |
