自学教程：C++ tMPI_Thread_mutex_lock函数代码示例

int gmx_fio_close(t_fileio *fio){    int rc = 0;    /* first lock the big open_files mutex. */    /* We don't want two processes operating on the list at the same time */    tMPI_Thread_mutex_lock(&open_file_mutex);    if (fio->iFTP == efTNG)    {        gmx_incons("gmx_fio_close should not be called on a TNG file");    }    gmx_fio_lock(fio);    /* first remove it from the list */    gmx_fio_remove(fio);    rc = gmx_fio_close_locked(fio);    gmx_fio_unlock(fio);    sfree(fio->fn);    sfree(fio);    tMPI_Thread_mutex_unlock(&open_file_mutex);    return rc;}

/* get the first open file, or NULL if there is none.   Returns a locked fio. */static t_fileio *gmx_fio_get_first(void){    t_fileio *ret;    /* first lock the big open_files mutex and the dummy's mutex */#ifdef GMX_THREAD_MPI    /* first lock the big open_files mutex. */    tMPI_Thread_mutex_lock(&open_file_mutex);#endif    gmx_fio_make_dummy();    gmx_fio_lock(open_files);    ret = open_files->next;    /* check whether there were any to begin with */    if (ret == open_files)    {        /* after this, the open_file pointer should never change */        ret = NULL;    }    else    {        gmx_fio_lock(open_files->next);    }    gmx_fio_unlock(open_files);    return ret;}

const char *ftp2defnm(int ftp){    const char *buf = NULL;#ifdef GMX_THREAD_MPI    tMPI_Thread_mutex_lock(&filenm_mutex);#endif    if (default_file_name)    {        buf = default_file_name;    }    else    {        if ((0 <= ftp) && (ftp < efNR))        {            buf = deffile[ftp].defnm;        }    }#ifdef GMX_THREAD_MPI    tMPI_Thread_mutex_unlock(&filenm_mutex);#endif    return buf;}

void set_command_line(int argc, char *argv[]){    int i;    size_t cmdlength;#ifdef GMX_THREADS    tMPI_Thread_mutex_lock(&init_mutex);#endif    if (cmd_line==NULL)    {        cmdlength = strlen(argv[0]);        for (i=1; i<argc; i++)         {            cmdlength += strlen(argv[i]);        }                /* Fill the cmdline string */        snew(cmd_line,cmdlength+argc+1);        for (i=0; i<argc; i++)         {            strcat(cmd_line,argv[i]);            strcat(cmd_line," ");        }    }#ifdef GMX_THREADS    tMPI_Thread_mutex_unlock(&init_mutex);#endif}

void* tMPI_Atomic_ptr_get(const tMPI_Atomic_ptr_t *a){    void* ret;    tMPI_Thread_mutex_lock(&tMPI_Atomic_mutex);    ret = a->value;    tMPI_Thread_mutex_unlock(&tMPI_Atomic_mutex);    return ret;}

int tMPI_Atomic_get(const tMPI_Atomic_t *a){    int ret;    tMPI_Thread_mutex_lock(&tMPI_Atomic_mutex);    ret = a->value;    tMPI_Thread_mutex_unlock(&tMPI_Atomic_mutex);    return ret;}

void tMPI_Spinlock_init( tMPI_Spinlock_t *x){    tMPI_Thread_mutex_lock(&tMPI_Atomic_mutex);    *x         = (tMPI_Spinlock_t)malloc(sizeof(tMPI_Spinlock_t));    (*x)->lock = (tMPI_Thread_mutex_t*)malloc(sizeof(tMPI_Thread_mutex_t));    tMPI_Thread_mutex_init((*x)->lock);    tMPI_Thread_mutex_unlock(&tMPI_Atomic_mutex);}

void setTimeValue(int tcontrol, real value){    tMPI_Thread_mutex_lock(&tc_mutex);    range_check(tcontrol, 0, TNR);    timecontrol[tcontrol].t    = value;    timecontrol[tcontrol].bSet = TRUE;    tMPI_Thread_mutex_unlock(&tc_mutex);}

int tMPI_Atomic_add_return(tMPI_Atomic_t *a, int i){    int t;    tMPI_Thread_mutex_lock(&tMPI_Atomic_mutex);    t        = a->value + i;    a->value = t;    tMPI_Thread_mutex_unlock(&tMPI_Atomic_mutex);    return t;}

int gmx_ffclose(FILE *fp){#ifdef SKIP_FFOPS    return fclose(fp);#else    t_pstack *ps, *tmp;    int       ret = 0;    tMPI_Thread_mutex_lock(&pstack_mutex);    ps = pstack;    if (ps == NULL)    {        if (fp != NULL)        {            ret = fclose(fp);        }    }    else if (ps->fp == fp)    {        if (fp != NULL)        {            ret = pclose(fp);        }        pstack = pstack->prev;        sfree(ps);    }    else    {        while ((ps->prev != NULL) && (ps->prev->fp != fp))        {            ps = ps->prev;        }        if ((ps->prev != NULL) && ps->prev->fp == fp)        {            if (ps->prev->fp != NULL)            {                ret = pclose(ps->prev->fp);            }            tmp      = ps->prev;            ps->prev = ps->prev->prev;            sfree(tmp);        }        else        {            if (fp != NULL)            {                ret = fclose(fp);            }        }    }    tMPI_Thread_mutex_unlock(&pstack_mutex);    return ret;#endif}

real rTimeValue(int tcontrol){    real ret;    tMPI_Thread_mutex_lock(&tc_mutex);    range_check(tcontrol, 0, TNR);    ret = timecontrol[tcontrol].t;    tMPI_Thread_mutex_unlock(&tc_mutex);    return ret;}

int tMPI_Atomic_swap(tMPI_Atomic_t *a, int b){    int ret;    tMPI_Thread_mutex_lock(&tMPI_Atomic_mutex);    ret      = a->value;    a->value = b;    tMPI_Thread_mutex_unlock(&tMPI_Atomic_mutex);    return ret;}

int tMPI_Atomic_fetch_add(tMPI_Atomic_t *a, int i){    int old_value;    tMPI_Thread_mutex_lock(&tMPI_Atomic_mutex);    old_value = a->value;    a->value  = old_value + i;    tMPI_Thread_mutex_unlock(&tMPI_Atomic_mutex);    return old_value;}

static void call_error_handler(const char *key, const char *file, int line, const char *msg){    if (msg == NULL)    {        msg = "Empty gmx_fatal message (bug).";    }    tMPI_Thread_mutex_lock(&error_mutex);    gmx_error_handler(gmx_strerror(key), msg, file, line);    tMPI_Thread_mutex_unlock(&error_mutex);}

voidgmx_nonbonded_setup(t_forcerec *   fr,                    gmx_bool       bGenericKernelOnly){    tMPI_Thread_mutex_lock(&nonbonded_setup_mutex);    /* Here we are guaranteed only one thread made it. */    if (nonbonded_setup_done == FALSE)    {        if (bGenericKernelOnly == FALSE)        {            /* Add the generic kernels to the structure stored statically in nb_kernel.c */            nb_kernel_list_add_kernels(kernellist_c, kernellist_c_size);            if (!(fr != NULL && fr->use_simd_kernels == FALSE))            {                /* Add interaction-specific kernels for different architectures */                /* Single precision */#if (defined GMX_SIMD_X86_SSE2) && !(defined GMX_DOUBLE)                nb_kernel_list_add_kernels(kernellist_sse2_single, kernellist_sse2_single_size);#endif#if (defined GMX_SIMD_X86_SSE4_1) && !(defined GMX_DOUBLE)                nb_kernel_list_add_kernels(kernellist_sse4_1_single, kernellist_sse4_1_single_size);#endif#if (defined GMX_SIMD_X86_AVX_128_FMA) && !(defined GMX_DOUBLE)                nb_kernel_list_add_kernels(kernellist_avx_128_fma_single, kernellist_avx_128_fma_single_size);#endif#if (defined GMX_SIMD_X86_AVX_256_OR_HIGHER) && !(defined GMX_DOUBLE)                nb_kernel_list_add_kernels(kernellist_avx_256_single, kernellist_avx_256_single_size);#endif                /* Double precision */#if (defined GMX_SIMD_X86_SSE2 && defined GMX_DOUBLE)                nb_kernel_list_add_kernels(kernellist_sse2_double, kernellist_sse2_double_size);#endif#if (defined GMX_SIMD_X86_SSE4_1 && defined GMX_DOUBLE)                nb_kernel_list_add_kernels(kernellist_sse4_1_double, kernellist_sse4_1_double_size);#endif#if (defined GMX_SIMD_X86_AVX_128_FMA && defined GMX_DOUBLE)                nb_kernel_list_add_kernels(kernellist_avx_128_fma_double, kernellist_avx_128_fma_double_size);#endif#if (defined GMX_SIMD_X86_AVX_256_OR_HIGHER && defined GMX_DOUBLE)                nb_kernel_list_add_kernels(kernellist_avx_256_double, kernellist_avx_256_double_size);#endif#if (defined GMX_SIMD_SPARC64_HPC_ACE && defined GMX_DOUBLE)                nb_kernel_list_add_kernels(kernellist_sparc64_hpc_ace_double, kernellist_sparc64_hpc_ace_double_size);#endif                ; /* empty statement to avoid a completely empty block */            }        }        /* Create a hash for faster lookups */        nb_kernel_list_hash_init();        nonbonded_setup_done = TRUE;    }    tMPI_Thread_mutex_unlock(&nonbonded_setup_mutex);}

/* NOTE: assumes atomic mutex is locked */static void tMPI_Spinlock_init_once(tMPI_Spinlock_t *x){    tMPI_Thread_mutex_lock(&tMPI_Atomic_mutex);    if (!*x)    {        *x         = (tMPI_Spinlock_t)malloc(sizeof(tMPI_Spinlock_t));        (*x)->lock = (tMPI_Thread_mutex_t*)malloc(sizeof(tMPI_Thread_mutex_t));        tMPI_Thread_mutex_init((*x)->lock);    }    tMPI_Thread_mutex_unlock(&tMPI_Atomic_mutex);}

gmx_bool bTimeSet(int tcontrol){    gmx_bool ret;    tMPI_Thread_mutex_lock(&tc_mutex);    range_check(tcontrol, 0, TNR);    ret = timecontrol[tcontrol].bSet;    tMPI_Thread_mutex_unlock(&tc_mutex);    return ret;}

void *tMPI_Atomic_ptr_swap(tMPI_Atomic_ptr_t *a, void *b){    void *ret;    tMPI_Thread_mutex_lock(&tMPI_Atomic_mutex);    ret      = a->value;    a->value = b;    tMPI_Thread_mutex_unlock(&tMPI_Atomic_mutex);    return ret;}

const char *command_line(void){    const char *ret;#ifdef GMX_THREADS    tMPI_Thread_mutex_lock(&init_mutex);#endif    ret=cmd_line; #ifdef GMX_THREADS    tMPI_Thread_mutex_unlock(&init_mutex);#endif    return ret;}

void setTimeValue(int tcontrol, real value){#ifdef GMX_THREAD_MPI    tMPI_Thread_mutex_lock(&tc_mutex);#endif    range_check(tcontrol, 0, TNR);    timecontrol[tcontrol].t    = value;    timecontrol[tcontrol].bSet = TRUE;#ifdef GMX_THREAD_MPI    tMPI_Thread_mutex_unlock(&tc_mutex);#endif}

void push_ps(FILE *fp){    t_pstack *ps;    tMPI_Thread_mutex_lock(&pstack_mutex);    snew(ps, 1);    ps->fp   = fp;    ps->prev = pstack;    pstack   = ps;    tMPI_Thread_mutex_unlock(&pstack_mutex);}

int tMPI_Atomic_ptr_cas(tMPI_Atomic_ptr_t * a, void *old_val, void *new_val){    int t = 0;    tMPI_Thread_mutex_lock(&tMPI_Atomic_mutex);    if (a->value == old_val)    {        a->value = new_val;        t        = 1;    }    tMPI_Thread_mutex_unlock(&tMPI_Atomic_mutex);    return t;}

void set_shift_consts(FILE *log,real r1,real rc,rvec box,t_forcerec *fr){#ifdef GMX_THREADS  /* at the very least we shouldn't allow multiple threads to set these      simulataneously */  tMPI_Thread_mutex_lock(&shift_mutex);#endif  /* A, B and C are recalculated in tables.c */  if (r1 < rc) {    A   = (2*r1-5*rc)/(p3(rc)*p2(rc-r1));    B   = (4*rc-2*r1)/(p3(rc)*p3(rc-r1));    /*C   = (10*rc*rc-5*rc*r1+r1*r1)/(6*rc*rc); Hermans Eq. not correct */  }  else    gmx_fatal(FARGS,"r1 (%f) >= rc (%f) in %s, line %d",	      r1,rc,__FILE__,__LINE__);  A_3 = A/3.0;  B_4 = B/4.0;  C   = 1/rc-A_3*p3(rc-r1)-B_4*p4(rc-r1);  N0  = 2.0*M_PI*p3(rc)*p3(rc-r1);  Vol     =(box[XX]*box[YY]*box[ZZ]);  FourPi_V=4.0*M_PI/Vol;  if (debug) {      fprintf(debug,"Constants for short-range and fourier stuff:/n"	      "r1 = %10.3f,  rc = %10.3f/n"	      "A  = %10.3e,  B  = %10.3e,  C  = %10.3e, FourPi_V = %10.3e/n",	      r1,rc,A,B,C,FourPi_V);  }  /* Constants derived by Mathematica */  c1 = -40*rc*rc    + 50*rc*r1    - 16*r1*r1;  c2 =  60*rc       - 30*r1;  c3 = -10*rc*rc*rc + 20*rc*rc*r1 - 13*rc*r1*r1 + 3*r1*r1*r1;  c4 = -20*rc*rc    + 40*rc*r1    - 14*r1*r1;  c5 = -c2;  c6 = -5*rc*rc*r1  +  7*rc*r1*r1 - 2*r1*r1*r1;  if (debug) {      fprintf(debug,"c1 = %10.3e,  c2 = %10.3e,  c3 = %10.3e/n"	      "c4 = %10.3e,  c5 = %10.3e,  c6 = %10.3e,  N0 = %10.3e/n",	      c1,c2,c3,c4,c5,c6,N0);  }      One_4pi = 1.0/(4.0*M_PI);#ifdef GMX_THREADS  tMPI_Thread_mutex_unlock(&shift_mutex);#endif}

real rTimeValue(int tcontrol){    real ret;#ifdef GMX_THREAD_MPI    tMPI_Thread_mutex_lock(&tc_mutex);#endif    range_check(tcontrol, 0, TNR);    ret = timecontrol[tcontrol].t;#ifdef GMX_THREAD_MPI    tMPI_Thread_mutex_unlock(&tc_mutex);#endif    return ret;}

gmx_bool bTimeSet(int tcontrol){    gmx_bool ret;#ifdef GMX_THREAD_MPI    tMPI_Thread_mutex_lock(&tc_mutex);#endif    range_check(tcontrol, 0, TNR);    ret = timecontrol[tcontrol].bSet;#ifdef GMX_THREAD_MPI    tMPI_Thread_mutex_unlock(&tc_mutex);#endif    return ret;}

void push_ps(FILE *fp){    t_pstack *ps;#ifdef GMX_THREADS    tMPI_Thread_mutex_lock(&pstack_mutex);#endif    snew(ps,1);    ps->fp   = fp;    ps->prev = pstack;    pstack   = ps;#ifdef GMX_THREADS    tMPI_Thread_mutex_unlock(&pstack_mutex);#endif}

static void log_action(int bMal,const char *what,const char *file,int line,                       int nelem,int size,void *ptr){  static int btot=0;  char *NN = "NULL";  int        bytes;    bytes=size*nelem;  if (!bMal)    bytes=-bytes;  #ifdef GMX_THREAD_MPI  tMPI_Thread_mutex_lock(&gmx_logfile_mtx);#endif  /* This total memory count is not correct, since with realloc   * it adds the whole size again, not just the increment.   */  /* This static variable is protected by the mutex too... */  btot+=bytes;      bytes/=1024;  if (debug && (bytes != 0)) {    fprintf(debug,"%s:%d kB (%7d kB) [%s, line %d, nelem %d, size %d]/n",	    what ? what : NN,bytes,btot/1024,	    file ? file : NN,line,nelem,size);  }  /* Print to stderr for things larger than 1 MB */  if (bytes >= 1024 || bytes <= -1024) {    char *fname=NULL;    if (file) {      fname = strrchr(file,DIR_SEPARATOR);      if (fname) {	fname++;      } else {	fname = file;      }    }    printf("%s: %.1f MB [%s, line %d, nelem %d, size %d]/n",	   what ? what  : NN,bytes/1024.0,	   file ? fname : NN,line,nelem,size);  }#ifdef GMX_THREAD_MPI  tMPI_Thread_mutex_unlock(&gmx_logfile_mtx);#endif}

gmx_bool is_pipe(FILE *fp){    tMPI_Thread_mutex_lock(&pstack_mutex);    t_pstack *ps = pstack;    while (ps != NULL)    {        if (ps->fp == fp)        {            tMPI_Thread_mutex_unlock(&pstack_mutex);            return TRUE;        }        ps = ps->prev;    }    tMPI_Thread_mutex_unlock(&pstack_mutex);    return FALSE;}