| /* |
| * kmp_threadprivate.c -- OpenMP threadprivate support library |
| */ |
| |
| |
| //===----------------------------------------------------------------------===// |
| // |
| // The LLVM Compiler Infrastructure |
| // |
| // This file is dual licensed under the MIT and the University of Illinois Open |
| // Source Licenses. See LICENSE.txt for details. |
| // |
| //===----------------------------------------------------------------------===// |
| |
| |
| #include "kmp.h" |
| #include "kmp_itt.h" |
| #include "kmp_i18n.h" |
| |
| /* ------------------------------------------------------------------------ */ |
| /* ------------------------------------------------------------------------ */ |
| |
| #define USE_CHECKS_COMMON |
| |
| #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 ); |
| |
| struct shared_table __kmp_threadprivate_d_table; |
| |
| /* ------------------------------------------------------------------------ */ |
| /* ------------------------------------------------------------------------ */ |
| |
| static |
| #ifdef KMP_INLINE_SUBR |
| __forceinline |
| #endif |
| struct private_common * |
| __kmp_threadprivate_find_task_common( struct common_table *tbl, int gtid, void *pc_addr ) |
| |
| { |
| 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(); |
| #endif |
| |
| 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 ) ); |
| #endif |
| return tn; |
| } |
| } |
| return 0; |
| } |
| |
| static |
| #ifdef KMP_INLINE_SUBR |
| __forceinline |
| #endif |
| 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) { |
| #ifdef KMP_TASK_COMMON_DEBUG |
| KC_TRACE( 10, ( "__kmp_find_shared_task_common: thread#%d, found node %p on list\n", |
| gtid, pc_addr ) ); |
| #endif |
| return tn; |
| } |
| } |
| 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; |
| } |
| } |
| |
| 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; |
| } |
| } |
| } |
| |
| /* ------------------------------------------------------------------------ */ |
| /* ------------------------------------------------------------------------ */ |
| |
| /* 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; |
| #ifdef KMP_DEBUG |
| int gtid; |
| #endif |
| |
| __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;*/ |
| } |
| #endif /* KMP_DEBUG */ |
| |
| for (q = 0; q < KMP_HASH_TABLE_SIZE; ++q) |
| __kmp_threadprivate_d_table.data[ q ] = 0; |
| |
| 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); |
| } |
| } |
| } |
| } |
| __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 ) ); |
| } |
| } |
| } |
| |
| /* ------------------------------------------------------------------------ */ |
| /* ------------------------------------------------------------------------ */ |
| |
| #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 ) ); |
| } |
| } |
| } |
| } |
| } |
| #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 ); |
| |
| 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 ) ); |
| |
| 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 ); |
| |
| lnk_tn = &(__kmp_threadprivate_d_table.data[ KMP_HASH(pc_addr) ]); |
| |
| d_tn->next = *lnk_tn; |
| *lnk_tn = d_tn; |
| |
| __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 +++++++++ */ |
| |
| __kmp_acquire_lock( & __kmp_global_lock, gtid ); |
| |
| tn = (struct private_common *) __kmp_allocate( sizeof (struct private_common) ); |
| |
| 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. */ |
| |
| 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->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 ); |
| |
| /* +++++++++ 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 ); |
| } |
| #endif /* USE_CHECKS_COMMON */ |
| |
| 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 ) ); |
| } |
| #endif |
| 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( ); |
| #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 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 ); |
| } |
| } 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; |
| } |
| |
| /* ------------------------------------------------------------------------ */ |
| /* We are currently parallel, and we know the thread id. */ |
| /* ------------------------------------------------------------------------ */ |
| |
| /*! |
| @ingroup THREADPRIVATE |
| |
| @param loc source location information |
| @param data pointer to data being privatized |
| @param ctor pointer to constructor function for data |
| @param cctor pointer to copy constructor function for data |
| @param dtor pointer to destructor function for data |
| |
| 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; |
| |
| 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); |
| #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; |
| |
| 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; |
| |
| KC_TRACE( 10, ("__kmpc_threadprivate: T#%d called\n", global_tid ) ); |
| |
| #ifdef USE_CHECKS_COMMON |
| 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 ) ); |
| #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 ); |
| } |
| #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; |
| } |
| KC_TRACE( 10, ("__kmpc_threadprivate: T#%d exiting; return value = %p\n", |
| global_tid, ret ) ); |
| |
| return ret; |
| } |
| |
| /*! |
| @ingroup THREADPRIVATE |
| @param loc source location information |
| @param global_tid global thread number |
| @param data pointer to data to privatize |
| @param size size of data to privatize |
| @param cache pointer to cache |
| @return pointer to private storage |
| |
| 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 ); |
| } |
| |
| 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; |
| } |
| |
| /*! |
| @ingroup THREADPRIVATE |
| @param loc source location information |
| @param data pointer to data being privatized |
| @param ctor pointer to constructor function for data |
| @param cctor pointer to copy constructor function for data |
| @param dtor pointer to destructor function for data |
| @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; |
| |
| 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); |
| #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->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; |
| } |
| } |
