path: root/contrib/libs/cxxsupp/openmp/kmp_threadprivate.c

/* 
 * 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; 
    } 
}