Improve error reporting for CUDA device polling 08/4708/1
authorJim Phillips <jim@ks.uiuc.edu>
Wed, 17 Oct 2018 19:57:05 +0000 (14:57 -0500)
committerJim Phillips <jim@ks.uiuc.edu>
Wed, 17 Oct 2018 19:57:05 +0000 (14:57 -0500)
Fix cases where calling cuda_errcheck would do nothing
because device had not returned error to use cudaDie.
Also provide uniform and complete messages in all cases.

Change-Id: Ia2ee1c1b33a2f5dd97e705869b97e70e9e666771

src/ComputeBondedCUDA.C
src/ComputeNonbondedCUDA.C
src/ComputePme.C
src/CudaComputeNonbonded.C

index c5dd6f0..a5d1286 100644 (file)
@@ -878,18 +878,24 @@ void ComputeBondedCUDA::forceDoneCheck(void *arg, double walltime) {
   if (err == cudaSuccess) {
     // Event has occurred
     c->checkCount = 0;
-    traceUserBracketEvent(CUDA_BONDED_KERNEL_EVENT, c->beforeForceCompute, CkWallTimer());
+    traceUserBracketEvent(CUDA_BONDED_KERNEL_EVENT, c->beforeForceCompute, walltime);
     c->finishPatches();
     return;
   } else if (err != cudaErrorNotReady) {
     // Anything else is an error
-    NAMD_bug("ComputeBondedCUDA::forceDoneCheck, cudaEventQuery returned error");
+    char errmsg[256];
+    sprintf(errmsg,"in ComputeBondedCUDA::forceDoneCheck after polling %d times over %f s",
+            c->checkCount, walltime - c->beforeForceCompute);
+    cudaDie(errmsg,err);
   }
 
   // Event has not occurred
   c->checkCount++;
   if (c->checkCount >= 1000000) {
-    NAMD_bug("ComputeBondedCUDA::forceDoneCheck, check count exceeded");
+    char errmsg[256];
+    sprintf(errmsg,"ComputeBondedCUDA::forceDoneCheck polled %d times over %f s",
+            c->checkCount, walltime - c->beforeForceCompute);
+    cudaDie(errmsg,err);
   }
 
   // Call again 
index 1238fed..61804a0 100644 (file)
@@ -951,8 +951,7 @@ void cuda_check_progress(void *arg, double walltime) {
     sprintf(errmsg,"cuda_check_progress polled %d times over %f s on step %d",
             check_count, walltime - remote_submit_time,
             ((ComputeNonbondedCUDA *) arg)->step);
-    cuda_errcheck(errmsg);
-    NAMD_die(errmsg);
+    cudaDie(errmsg,cudaSuccess);
   }
   if ( poll_again ) {
     CcdCallBacksReset(0,walltime);  // fix Charm++
@@ -974,15 +973,17 @@ void cuda_check_remote_progress(void *arg, double walltime) {
     cuda_errcheck("at cuda remote stream completed");
     WorkDistrib::messageFinishCUDA((ComputeNonbondedCUDA *) arg);
   } else if ( err != cudaErrorNotReady ) {
-    cuda_errcheck("in cuda_check_remote_progress");
-    NAMD_bug("cuda_errcheck missed error in cuda_check_remote_progress");
+    char errmsg[256];
+    sprintf(errmsg,"in cuda_check_remote_progress after polling %d times over %f s on step %d",
+            check_remote_count, walltime - remote_submit_time,
+            ((ComputeNonbondedCUDA *) arg)->step);
+    cudaDie(errmsg,err);
   } else if ( ++check_remote_count >= count_limit ) {
     char errmsg[256];
     sprintf(errmsg,"cuda_check_remote_progress polled %d times over %f s on step %d",
             check_remote_count, walltime - remote_submit_time,
             ((ComputeNonbondedCUDA *) arg)->step);
-    cuda_errcheck(errmsg);
-    NAMD_die(errmsg);
+    cudaDie(errmsg,err);
   } else if ( check_local_count ) {
     NAMD_bug("nonzero check_local_count in cuda_check_remote_progress");
   } else {
@@ -1002,15 +1003,17 @@ void cuda_check_local_progress(void *arg, double walltime) {
     cuda_errcheck("at cuda local stream completed");
     WorkDistrib::messageFinishCUDA((ComputeNonbondedCUDA *) arg);
   } else if ( err != cudaErrorNotReady ) {
-    cuda_errcheck("in cuda_check_local_progress");
-    NAMD_bug("cuda_errcheck missed error in cuda_check_local_progress");
+    char errmsg[256];
+    sprintf(errmsg,"in cuda_check_local_progress after polling %d times over %f s on step %d",
+            check_local_count, walltime - local_submit_time,
+            ((ComputeNonbondedCUDA *) arg)->step);
+    cudaDie(errmsg,err);
   } else if ( ++check_local_count >= count_limit ) {
     char errmsg[256];
     sprintf(errmsg,"cuda_check_local_progress polled %d times over %f s on step %d",
             check_local_count, walltime - local_submit_time,
             ((ComputeNonbondedCUDA *) arg)->step);
-    cuda_errcheck(errmsg);
-    NAMD_die(errmsg);
+    cudaDie(errmsg,err);
   } else if ( check_remote_count ) {
     NAMD_bug("nonzero check_remote_count in cuda_check_local_progress");
   } else {
index fb90375..8e30dea 100644 (file)
@@ -2472,6 +2472,8 @@ void ComputePmeMgr::recvAck(PmeAckMsg *msg) {
 
 extern "C" void CcdCallBacksReset(void *ignored,double curWallTime);  // fix Charm++
 
+void cudaDie(const char *msg, cudaError_t err=cudaSuccess);
+
 void cuda_check_pme_forces(void *arg, double walltime) {
   ComputePmeMgr *argp = (ComputePmeMgr *) arg;
 
@@ -2497,15 +2499,14 @@ void cuda_check_pme_forces(void *arg, double walltime) {
             argp->forces_done_count/EVENT_STRIDE,
             argp->check_forces_count, walltime - argp->forces_time,
             argp->saved_sequence);
-    cuda_errcheck(errmsg);
-    NAMD_bug("cuda_errcheck missed error in cuda_check_pme_forces");
+    cudaDie(errmsg,err);
   } else if ( ++(argp->check_forces_count) >= count_limit ) {
     char errmsg[256];
-    sprintf(errmsg,"cuda_check_pme_forces polled %d times over %f s on seq %d",
+    sprintf(errmsg,"cuda_check_pme_forces for event %d polled %d times over %f s on seq %d",
+            argp->forces_done_count/EVENT_STRIDE,
             argp->check_forces_count, walltime - argp->forces_time,
             argp->saved_sequence);
-    cuda_errcheck(errmsg);
-    NAMD_die(errmsg);
+    cudaDie(errmsg,err);
   } else {
     break; // call again
   }
@@ -3453,15 +3454,17 @@ void cuda_check_pme_charges(void *arg, double walltime) {
     argp->sendChargeGridReady();
     argp->check_charges_count = 0;
   } else if ( err != cudaErrorNotReady ) {
-    cuda_errcheck("in cuda_check_pme_charges");
-    NAMD_bug("cuda_errcheck missed error in cuda_check_pme_charges");
+    char errmsg[256];
+    sprintf(errmsg,"in cuda_check_pme_charges after polling %d times over %f s on seq %d",
+            argp->check_charges_count, walltime - argp->charges_time,
+            argp->saved_sequence);
+    cudaDie(errmsg,err);
   } else if ( ++(argp->check_charges_count) >= count_limit ) {
     char errmsg[256];
     sprintf(errmsg,"cuda_check_pme_charges polled %d times over %f s on seq %d",
             argp->check_charges_count, walltime - argp->charges_time,
             argp->saved_sequence);
-    cuda_errcheck(errmsg);
-    NAMD_die(errmsg);
+    cudaDie(errmsg,err);
   } else {
     CcdCallBacksReset(0,walltime);  // fix Charm++
     CUDA_POLL(cuda_check_pme_charges, arg);
index dae8ada..5c0bee8 100644 (file)
@@ -1490,8 +1490,10 @@ void CudaComputeNonbonded::forceDoneCheck(void *arg, double walltime) {
       return;
     } else if (err != cudaErrorNotReady) {
       // Anything else is an error
-      cudaCheck(err);
-      // NAMD_bug("CudaComputeNonbonded::forceDoneCheck, cudaEventQuery returned error");
+      char errmsg[256];
+      sprintf(errmsg,"in CudaComputeNonbonded::forceDoneCheck after polling %d times over %f s",
+              c->checkCount, walltime - c->beforeForceCompute);
+      cudaDie(errmsg,err);
     }
   }
 
@@ -1501,7 +1503,10 @@ void CudaComputeNonbonded::forceDoneCheck(void *arg, double walltime) {
   // Event has not occurred
   c->checkCount++;
   if (c->checkCount >= 1000000) {
-    NAMD_bug("CudaComputeNonbonded::forceDoneCheck, check count exceeded");
+    char errmsg[256];
+    sprintf(errmsg,"CudaComputeNonbonded::forceDoneCheck polled %d times over %f s",
+            c->checkCount, walltime - c->beforeForceCompute);
+    cudaDie(errmsg,cudaSuccess);
   }
 
   // Call again