ComputeNonbondedCUDA.C File Reference

#include "common.h"
#include "charm++.h"
#include <cuda_runtime.h>
#include <cuda.h>
#include "WorkDistrib.h"
#include "ComputeMgr.h"
#include "ProxyMgr.h"
#include "ComputeNonbondedCUDAKernel.h"
#include "ComputeNonbondedCUDA.h"
#include "LJTable.h"
#include "ObjectArena.h"
#include "SortAtoms.h"
#include "Priorities.h"
#include <algorithm>
#include "NamdTypes.h"
#include "DeviceCUDA.h"
#include "CudaUtils.h"

Go to the source code of this file.

Classes

struct  exlist_sortop
struct  pid_sortop_reverse_priority
struct  cr_sortop_distance
struct  cr_sortop_reverse_priority

Defines

#define SET_EXCL(EXCL, BASE, DIFF)   (EXCL)[((BASE)+(DIFF))>>5] |= (1<<(((BASE)+(DIFF))&31))
#define CUDA_POLL(FN, ARG)   CcdCallFnAfter(FN,ARG,0.1)
#define GBISP(...)
#define count_limit   1000000

Functions

void cuda_errcheck (const char *msg)
static bool sortop_bitreverse (int a, int b)
void send_build_cuda_force_table ()
void build_cuda_force_table ()
void build_cuda_exclusions ()
void register_cuda_compute_self (ComputeID c, PatchID pid)
void register_cuda_compute_pair (ComputeID c, PatchID pid[], int t[])
void unregister_cuda_compute (ComputeID c)
void init_arrays ()
void CcdCallBacksReset (void *ignored, double curWallTime)
void cuda_check_progress (void *arg, double walltime)
void cuda_check_remote_progress (void *arg, double walltime)
void cuda_check_local_progress (void *arg, double walltime)
void cuda_check_remote_calc (void *arg, double walltime)
void cuda_check_local_calc (void *arg, double walltime)

Variables

__thread int max_grid_size
__thread cudaStream_t stream
__thread cudaStream_t stream2
__thread DeviceCUDAdeviceCUDA
static __thread
ComputeNonbondedCUDA
cudaCompute = 0
static __thread ComputeMgrcomputeMgr = 0
static __thread int2 * exclusionsByAtom
static __thread cudaEvent_t start_calc
static __thread cudaEvent_t end_remote_download
static __thread cudaEvent_t end_local_download
static __thread ResizeArray
< patch_pair > * 
patch_pairs_ptr
static __thread ResizeArray
< int > * 
patch_pair_num_ptr
static __thread int atom_params_size
static __thread atom_param * atom_params
static __thread int vdw_types_size
static __thread int * vdw_types
static __thread int dummy_size
static __thread float * dummy_dev
static __thread int force_ready_queue_size
static __thread int * force_ready_queue
static __thread int force_ready_queue_len
static __thread int force_ready_queue_next
static __thread int block_order_size
static __thread int * block_order
static __thread int num_atoms
static __thread int num_local_atoms
static __thread int num_remote_atoms
static __thread int virials_size
static __thread float * virials
static __thread int num_virials
static __thread float * slow_virials
static __thread int energy_gbis_size
static __thread float * energy_gbis
static __thread int intRad0H_size
static __thread float * intRad0H
static __thread int intRadSH_size
static __thread float * intRadSH
static __thread int bornRadH_size
static __thread float * bornRadH
static __thread int dHdrPrefixH_size
static __thread float * dHdrPrefixH
static __thread int cuda_timer_count
static __thread double cuda_timer_total
static __thread double kernel_time
static __thread double remote_submit_time
static __thread double local_submit_time
static __thread int check_count
static __thread int check_remote_count
static __thread int check_local_count
static __thread int kernel_launch_state = 0

Define Documentation

#define count_limit   1000000
#define CUDA_POLL ( FN,
ARG   )     CcdCallFnAfter(FN,ARG,0.1)
#define GBISP ( ...   ) 
#define SET_EXCL ( EXCL,
BASE,
DIFF   )     (EXCL)[((BASE)+(DIFF))>>5] |= (1<<(((BASE)+(DIFF))&31))

Function Documentation

void build_cuda_exclusions (  ) 

Definition at line 248 of file ComputeNonbondedCUDA.C.

References ComputeNonbondedCUDA::build_exclusions(), deviceCUDA, and DeviceCUDA::getMasterPe().

Referenced by ComputeMgr::recvBuildCudaExclusions().

00248                              {
00249   if ( deviceCUDA->getMasterPe() != CkMyPe() ) return;
00250   ComputeNonbondedCUDA::build_exclusions();
00251 }

void build_cuda_force_table (  ) 
void CcdCallBacksReset ( void *  ignored,
double  curWallTime 
)
void cuda_check_local_calc ( void *  arg,
double  walltime 
)

Definition at line 1618 of file ComputeNonbondedCUDA.C.

References CcdCallBacksReset(), computeMgr, CUDA_POLL, deviceCUDA, end_local_download, DeviceCUDA::getNextPeSharingGpu(), and ComputeMgr::sendYieldDevice().

Referenced by ComputeNonbondedCUDA::recvYieldDevice().

01618                                                        {
01619   // in theory we only need end_local_calc, but overlap isn't reliable
01620   // if ( cudaEventQuery(end_local_calc) == cudaSuccess ) {
01621   if ( cudaEventQuery(end_local_download) == cudaSuccess ) {
01622 // CkPrintf("Pe %d yielding to %d after local calc\n", CkMyPe(), next_pe_sharing_gpu);
01623     computeMgr->sendYieldDevice(deviceCUDA->getNextPeSharingGpu());
01624 // CkPrintf("Pe %d yielded to %d after local calc\n", CkMyPe(), next_pe_sharing_gpu);
01625   } else {
01626     CcdCallBacksReset(0,walltime);  // fix Charm++
01627     CUDA_POLL(cuda_check_local_calc, arg);
01628   }
01629 }

void cuda_check_local_progress ( void *  arg,
double  walltime 
)

Definition at line 995 of file ComputeNonbondedCUDA.C.

References CcdCallBacksReset(), check_local_count, check_remote_count, count_limit, cuda_errcheck(), CUDA_POLL, CUDA_TRACE_LOCAL, CUDA_TRACE_POLL_LOCAL, cudaDie(), end_local_download, kernel_time, local_submit_time, WorkDistrib::messageFinishCUDA(), and NAMD_bug().

Referenced by ComputeNonbondedCUDA::doWork(), and ComputeNonbondedCUDA::recvYieldDevice().

00995                                                            {
00996 
00997   CUDA_TRACE_POLL_LOCAL;
00998   cudaError_t err = cudaEventQuery(end_local_download);
00999   if ( err == cudaSuccess ) {
01000     CUDA_TRACE_LOCAL(local_submit_time,walltime);
01001     kernel_time = walltime - kernel_time;
01002     check_local_count = 0;
01003     cuda_errcheck("at cuda local stream completed");
01004     WorkDistrib::messageFinishCUDA((ComputeNonbondedCUDA *) arg);
01005   } else if ( err != cudaErrorNotReady ) {
01006     char errmsg[256];
01007     sprintf(errmsg,"in cuda_check_local_progress after polling %d times over %f s on step %d",
01008             check_local_count, walltime - local_submit_time,
01009             ((ComputeNonbondedCUDA *) arg)->step);
01010     cudaDie(errmsg,err);
01011   } else if ( ++check_local_count >= count_limit ) {
01012     char errmsg[256];
01013     sprintf(errmsg,"cuda_check_local_progress polled %d times over %f s on step %d",
01014             check_local_count, walltime - local_submit_time,
01015             ((ComputeNonbondedCUDA *) arg)->step);
01016     cudaDie(errmsg,err);
01017   } else if ( check_remote_count ) {
01018     NAMD_bug("nonzero check_remote_count in cuda_check_local_progress");
01019   } else {
01020     CcdCallBacksReset(0,walltime);  // fix Charm++
01021     CUDA_POLL(cuda_check_local_progress, arg);
01022   }
01023 }

void cuda_check_progress ( void *  arg,
double  walltime 
)

Definition at line 927 of file ComputeNonbondedCUDA.C.

References CcdCallBacksReset(), check_count, count_limit, CUDA_POLL, CUDA_TRACE_LOCAL, CUDA_TRACE_POLL_REMOTE, cudaDie(), force_ready_queue, force_ready_queue_len, force_ready_queue_next, kernel_time, and remote_submit_time.

Referenced by ComputeNonbondedCUDA::recvYieldDevice().

00927                                                      {
00928   CUDA_TRACE_POLL_REMOTE;
00929 
00930   int flindex;
00931   int poll_again = 1;
00932   while ( -1 != (flindex = force_ready_queue[force_ready_queue_next]) ) {
00933     //    CkPrintf("Pe %d forces ready %d is index %d at %lf\n",
00934     //       CkMyPe(), force_ready_queue_next, flindex, walltime);
00935     force_ready_queue[force_ready_queue_next] = -1;
00936     ++force_ready_queue_next;
00937     check_count = 0;
00938     if ( force_ready_queue_next == force_ready_queue_len ) {
00939       poll_again = 0;
00940       CUDA_TRACE_LOCAL(kernel_time,walltime);
00941       kernel_time = walltime - kernel_time;
00942       // need to guarantee this finishes before the last patch message!
00943       ((ComputeNonbondedCUDA *) arg)->workStarted = 0;
00944       ((ComputeNonbondedCUDA *) arg)->finishReductions();
00945     }
00946     ((ComputeNonbondedCUDA *) arg)->messageFinishPatch(flindex);
00947     if ( force_ready_queue_next == force_ready_queue_len ) break;
00948   }
00949   if ( ++check_count >= count_limit ) {
00950     char errmsg[256];
00951     sprintf(errmsg,"cuda_check_progress polled %d times over %f s on step %d",
00952             check_count, walltime - remote_submit_time,
00953             ((ComputeNonbondedCUDA *) arg)->step);
00954     cudaDie(errmsg,cudaSuccess);
00955   }
00956   if ( poll_again ) {
00957     CcdCallBacksReset(0,walltime);  // fix Charm++
00958     CUDA_POLL(cuda_check_progress, arg);
00959   }
00960 }

void cuda_check_remote_calc ( void *  arg,
double  walltime 
)

Definition at line 1605 of file ComputeNonbondedCUDA.C.

References CcdCallBacksReset(), computeMgr, CUDA_POLL, deviceCUDA, end_remote_download, DeviceCUDA::getNextPeSharingGpu(), and ComputeMgr::sendYieldDevice().

Referenced by ComputeNonbondedCUDA::recvYieldDevice().

01605                                                         {
01606   // in theory we only need end_remote_calc, but overlap isn't reliable
01607   // if ( cudaEventQuery(end_remote_calc) == cudaSuccess ) {
01608   if ( cudaEventQuery(end_remote_download) == cudaSuccess ) {
01609 // CkPrintf("Pe %d yielding to %d after remote calc\n", CkMyPe(), next_pe_sharing_gpu);
01610     computeMgr->sendYieldDevice(deviceCUDA->getNextPeSharingGpu());
01611 // CkPrintf("Pe %d yielded to %d after remote calc\n", CkMyPe(), next_pe_sharing_gpu);
01612   } else {
01613     CcdCallBacksReset(0,walltime);  // fix Charm++
01614     CUDA_POLL(cuda_check_remote_calc, arg);
01615   }
01616 }

void cuda_check_remote_progress ( void *  arg,
double  walltime 
)

Definition at line 962 of file ComputeNonbondedCUDA.C.

References CcdCallBacksReset(), check_local_count, check_remote_count, count_limit, cuda_errcheck(), CUDA_POLL, CUDA_TRACE_POLL_REMOTE, CUDA_TRACE_REMOTE, cudaDie(), deviceCUDA, end_remote_download, DeviceCUDA::getMergeGrids(), kernel_time, local_submit_time, WorkDistrib::messageFinishCUDA(), NAMD_bug(), and remote_submit_time.

Referenced by ComputeNonbondedCUDA::recvYieldDevice().

00962                                                             {
00963 
00964   CUDA_TRACE_POLL_REMOTE;
00965   cudaError_t err = cudaEventQuery(end_remote_download);
00966   if ( err == cudaSuccess ) {
00967     local_submit_time = walltime;
00968     CUDA_TRACE_REMOTE(remote_submit_time,local_submit_time);
00969     if ( deviceCUDA->getMergeGrids() ) {  // no local
00970       kernel_time = local_submit_time - kernel_time;
00971     }
00972     check_remote_count = 0;
00973     cuda_errcheck("at cuda remote stream completed");
00974     WorkDistrib::messageFinishCUDA((ComputeNonbondedCUDA *) arg);
00975   } else if ( err != cudaErrorNotReady ) {
00976     char errmsg[256];
00977     sprintf(errmsg,"in cuda_check_remote_progress after polling %d times over %f s on step %d",
00978             check_remote_count, walltime - remote_submit_time,
00979             ((ComputeNonbondedCUDA *) arg)->step);
00980     cudaDie(errmsg,err);
00981   } else if ( ++check_remote_count >= count_limit ) {
00982     char errmsg[256];
00983     sprintf(errmsg,"cuda_check_remote_progress polled %d times over %f s on step %d",
00984             check_remote_count, walltime - remote_submit_time,
00985             ((ComputeNonbondedCUDA *) arg)->step);
00986     cudaDie(errmsg,err);
00987   } else if ( check_local_count ) {
00988     NAMD_bug("nonzero check_local_count in cuda_check_remote_progress");
00989   } else {
00990     CcdCallBacksReset(0,walltime);  // fix Charm++
00991     CUDA_POLL(cuda_check_remote_progress, arg);
00992   }
00993 }

void cuda_errcheck ( const char *  msg  ) 

Definition at line 41 of file ComputeNonbondedCUDA.C.

References NAMD_die().

Referenced by ComputeNonbondedCUDA::ComputeNonbondedCUDA(), ComputePmeMgr::ComputePmeMgr(), cuda_bind_atom_params(), cuda_bind_atoms(), cuda_bind_exclusions(), cuda_bind_force_table(), cuda_bind_forces(), cuda_bind_GBIS_bornRad(), cuda_bind_GBIS_dEdaSum(), cuda_bind_GBIS_dHdrPrefix(), cuda_bind_GBIS_energy(), cuda_bind_GBIS_intRad(), cuda_bind_GBIS_psiSum(), cuda_bind_lj_table(), cuda_bind_patch_pairs(), cuda_bind_vdw_types(), cuda_bind_virials(), cuda_check_local_progress(), cuda_check_remote_progress(), cuda_GBIS_P1(), cuda_GBIS_P2(), cuda_GBIS_P3(), cuda_init(), cuda_nonbonded_forces(), ComputePme::doWork(), ComputeNonbondedCUDA::doWork(), ComputeNonbondedCUDA::finishReductions(), ComputePmeMgr::initialize(), ComputePmeMgr::initialize_computes(), and ComputePmeMgr::ungridCalc().

00041                                     {
00042   cudaError_t err;
00043   if ((err = cudaGetLastError()) != cudaSuccess) {
00044     char host[128];
00045     gethostname(host, 128);  host[127] = 0;
00046     char devstr[128] = "";
00047     int devnum;
00048     if ( cudaGetDevice(&devnum) == cudaSuccess ) {
00049       sprintf(devstr, " device %d", devnum);
00050     }
00051     cudaDeviceProp deviceProp;
00052     if ( cudaGetDeviceProperties(&deviceProp, devnum) == cudaSuccess ) {
00053       sprintf(devstr, " device %d pci %x:%x:%x", devnum,
00054         deviceProp.pciDomainID, deviceProp.pciBusID, deviceProp.pciDeviceID);
00055     }
00056     char errmsg[1024];
00057     sprintf(errmsg,"CUDA error %s on Pe %d (%s%s): %s", msg, CkMyPe(), host, devstr, cudaGetErrorString(err));
00058     NAMD_die(errmsg);
00059   }
00060 }

void init_arrays (  ) 

Definition at line 886 of file ComputeNonbondedCUDA.C.

References atom_params, atom_params_size, block_order, block_order_size, bornRadH, bornRadH_size, dHdrPrefixH, dHdrPrefixH_size, dummy_dev, dummy_size, energy_gbis, energy_gbis_size, force_ready_queue, force_ready_queue_len, force_ready_queue_next, force_ready_queue_size, intRad0H, intRad0H_size, intRadSH, intRadSH_size, num_atoms, num_local_atoms, num_remote_atoms, num_virials, vdw_types, vdw_types_size, virials, and virials_size.

Referenced by ComputeNonbondedCUDA::ComputeNonbondedCUDA().

00886                    {
00887 
00888   atom_params_size = 0;
00889   atom_params = NULL;
00890 
00891   vdw_types_size = 0;
00892   vdw_types = NULL;
00893   
00894   dummy_size = 0;
00895   dummy_dev = NULL;
00896 
00897   force_ready_queue_size = 0;
00898   force_ready_queue = NULL;
00899   force_ready_queue_len = 0;
00900   force_ready_queue_next = 0;
00901   
00902   block_order_size = 0;
00903   block_order = NULL;
00904   
00905   num_atoms = 0;
00906   num_local_atoms = 0;
00907   num_remote_atoms = 0;
00908 
00909   virials_size = 0;
00910   virials = NULL;
00911   num_virials = 0;
00912 
00913   energy_gbis_size = 0;
00914   energy_gbis = NULL;
00915 
00916   intRad0H_size = 0;
00917   intRad0H = NULL;
00918   intRadSH_size = 0;
00919   intRadSH = NULL;
00920   bornRadH_size = 0;
00921   bornRadH = NULL;
00922   dHdrPrefixH_size = 0;
00923   dHdrPrefixH = NULL;
00924 
00925 }

void register_cuda_compute_pair ( ComputeID  c,
PatchID  pid[],
int  t[] 
)

Definition at line 390 of file ComputeNonbondedCUDA.C.

References ResizeArray< Elem >::add(), ComputeNonbondedCUDA::compute_record::c, PatchMap::center(), cudaCompute, ComputeNonbondedCUDA::localComputeRecords, NAMD_bug(), ComputeNonbondedCUDA::compute_record::offset, ComputeNonbondedCUDA::patchMap, ComputeNonbondedCUDA::patchRecords, ComputeNonbondedCUDA::compute_record::pid, ComputeNonbondedCUDA::remoteComputeRecords, ComputeNonbondedCUDA::requirePatch(), Vector::x, Vector::y, and Vector::z.

Referenced by ComputeNonbondedPair::initialize().

00390                                                                      {
00391 
00392   if ( ! cudaCompute ) NAMD_bug("register_pair called early");
00393  
00394   cudaCompute->requirePatch(pid[0]);
00395   cudaCompute->requirePatch(pid[1]);
00396 
00397   ComputeNonbondedCUDA::compute_record cr;
00398   cr.c = c; 
00399   cr.pid[0] = pid[0];  cr.pid[1] = pid[1];
00400 
00401   int t1 = t[0];
00402   int t2 = t[1];
00403   Vector offset = cudaCompute->patchMap->center(pid[0])
00404                 - cudaCompute->patchMap->center(pid[1]);
00405   offset.x += (t1%3-1) - (t2%3-1);
00406   offset.y += ((t1/3)%3-1) - ((t2/3)%3-1);
00407   offset.z += (t1/9-1) - (t2/9-1);
00408   cr.offset = offset;
00409 
00410   if ( cudaCompute->patchRecords[pid[0]].isLocal ) {
00411     cudaCompute->localComputeRecords.add(cr);
00412   } else {
00413     cudaCompute->remoteComputeRecords.add(cr);
00414   }
00415 }

void register_cuda_compute_self ( ComputeID  c,
PatchID  pid 
)
void send_build_cuda_force_table (  ) 

Copyright (c) 1995, 1996, 1997, 1998, 1999, 2000 by The Board of Trustees of the University of Illinois. All rights reserved.

Definition at line 73 of file ComputeNonbondedCUDA.C.

References computeMgr, and ComputeMgr::sendBuildCudaForceTable().

Referenced by ComputeNonbondedUtil::select().

00073                                    {
00074   computeMgr->sendBuildCudaForceTable();
00075 }

static bool sortop_bitreverse ( int  a,
int  b 
) [inline, static]

Definition at line 62 of file ComputeNonbondedCUDA.C.

Referenced by cr_sortop_reverse_priority::pid_compare_priority().

00062                                                    {
00063   if ( a == b ) return 0; 
00064   for ( int bit = 1; bit; bit *= 2 ) {
00065     if ( (a&bit) != (b&bit) ) return ((a&bit) < (b&bit));
00066   }
00067   return 0;
00068 }

void unregister_cuda_compute ( ComputeID  c  ) 

Definition at line 417 of file ComputeNonbondedCUDA.C.

References NAMD_bug().

00417                                           {  // static
00418 
00419   NAMD_bug("unregister_compute unimplemented");
00420 
00421 }


Variable Documentation

__thread atom_param* atom_params [static]
__thread int atom_params_size [static]

Definition at line 825 of file ComputeNonbondedCUDA.C.

Referenced by ComputeNonbondedCUDA::doWork(), and init_arrays().

__thread int* block_order [static]
__thread int block_order_size [static]

Definition at line 839 of file ComputeNonbondedCUDA.C.

Referenced by ComputeNonbondedCUDA::doWork(), and init_arrays().

__thread float* bornRadH [static]
__thread int bornRadH_size [static]

Definition at line 860 of file ComputeNonbondedCUDA.C.

Referenced by ComputeNonbondedCUDA::doWork(), and init_arrays().

__thread int check_count [static]

Definition at line 882 of file ComputeNonbondedCUDA.C.

Referenced by cuda_check_progress().

__thread int check_local_count [static]
__thread int check_remote_count [static]
__thread ComputeMgr* computeMgr = 0 [static]
__thread int cuda_timer_count [static]

Definition at line 865 of file ComputeNonbondedCUDA.C.

Referenced by ComputeNonbondedCUDA::finishReductions().

__thread double cuda_timer_total [static]
__thread ComputeNonbondedCUDA* cudaCompute = 0 [static]

Definition at line 18 of file DeviceCUDA.C.

__thread float* dHdrPrefixH [static]
__thread int dHdrPrefixH_size [static]

Definition at line 862 of file ComputeNonbondedCUDA.C.

Referenced by ComputeNonbondedCUDA::doWork(), and init_arrays().

__thread float* dummy_dev [static]
__thread int dummy_size [static]
__thread cudaEvent_t end_local_download [static]
__thread cudaEvent_t end_remote_download [static]
__thread float* energy_gbis [static]
__thread int energy_gbis_size [static]

Definition at line 852 of file ComputeNonbondedCUDA.C.

Referenced by ComputeNonbondedCUDA::doWork(), and init_arrays().

__thread int2* exclusionsByAtom [static]
__thread int* force_ready_queue [static]
__thread int force_ready_queue_len [static]
__thread int force_ready_queue_next [static]
__thread int force_ready_queue_size [static]

Definition at line 834 of file ComputeNonbondedCUDA.C.

Referenced by ComputeNonbondedCUDA::doWork(), and init_arrays().

__thread float* intRad0H [static]
__thread int intRad0H_size [static]

Definition at line 856 of file ComputeNonbondedCUDA.C.

Referenced by ComputeNonbondedCUDA::doWork(), and init_arrays().

__thread float* intRadSH [static]
__thread int intRadSH_size [static]

Definition at line 858 of file ComputeNonbondedCUDA.C.

Referenced by ComputeNonbondedCUDA::doWork(), and init_arrays().

__thread int kernel_launch_state = 0 [static]

Definition at line 1043 of file ComputeNonbondedCUDA.C.

__thread double kernel_time [static]
__thread double local_submit_time [static]
__thread int max_grid_size
__thread int num_atoms [static]

Definition at line 842 of file ComputeNonbondedCUDA.C.

Referenced by ComputeNonbondedCUDA::doWork(), and init_arrays().

__thread int num_local_atoms [static]

Definition at line 843 of file ComputeNonbondedCUDA.C.

Referenced by ComputeNonbondedCUDA::doWork(), and init_arrays().

__thread int num_remote_atoms [static]

Definition at line 844 of file ComputeNonbondedCUDA.C.

Referenced by ComputeNonbondedCUDA::doWork(), and init_arrays().

__thread int num_virials [static]
__thread ResizeArray<int>* patch_pair_num_ptr [static]
__thread ResizeArray<patch_pair>* patch_pairs_ptr [static]
__thread double remote_submit_time [static]
__thread float* slow_virials [static]
__thread cudaEvent_t start_calc [static]
__thread cudaStream_t stream
__thread cudaStream_t stream2
__thread int* vdw_types [static]
__thread int vdw_types_size [static]

Definition at line 828 of file ComputeNonbondedCUDA.C.

Referenced by ComputeNonbondedCUDA::doWork(), and init_arrays().

__thread float* virials [static]
__thread int virials_size [static]

Definition at line 846 of file ComputeNonbondedCUDA.C.

Referenced by ComputeNonbondedCUDA::doWork(), and init_arrays().


Generated on 17 Jul 2019 for NAMD by  doxygen 1.6.1