Introduce init_cuda

diff --git a/tests/cuda/cuda_evaluate_1d_shape.cu b/tests/cuda/cuda_evaluate_1d_shape.cu
index bb9129e4da7f38f8c79b8d4b78ae023de96c6a42..e2e4323c064f1b848df47b7bb9c90597954f8678 100644 (file)
--- a/tests/cuda/cuda_evaluate_1d_shape.cu
+++ b/tests/cuda/cuda_evaluate_1d_shape.cu
@@ -159,6 +159,8 @@ main()
   std::ofstream logfile("output");
   deallog.attach(logfile);
 
+  init_cuda();
+
   deallog.push("values");
   test<4, 4, 0, false>();
   test<3, 3, 0, false>();

diff --git a/tests/cuda/cuda_evaluate_2d_shape.cu b/tests/cuda/cuda_evaluate_2d_shape.cu
index 2c353ffabef2779b3f0cb67d58dc3546c0fb2b23..db81805e4dab531187e5a695fcd308b91642cdb7 100644 (file)
--- a/tests/cuda/cuda_evaluate_2d_shape.cu
+++ b/tests/cuda/cuda_evaluate_2d_shape.cu
@@ -184,6 +184,8 @@ main()
   std::ofstream logfile("output");
   deallog.attach(logfile);
 
+  init_cuda();
+
   deallog.push("values");
   test<4, 4, 0, false>();
   test<3, 3, 0, false>();

diff --git a/tests/cuda/cuda_tensor_01.cu b/tests/cuda/cuda_tensor_01.cu
index 615b2da0ad030699729a6c17027113e472073cee..d530992a4d3c6a022e024e66d2f01e276266376a 100644 (file)
--- a/tests/cuda/cuda_tensor_01.cu
+++ b/tests/cuda/cuda_tensor_01.cu
@@ -101,6 +101,8 @@ main()
   deallog << std::setprecision(5);
   deallog.attach(logfile);
 
+  init_cuda();
+
   test_cpu();
 
   test_gpu();

diff --git a/tests/cuda/cuda_vector_01.cu b/tests/cuda/cuda_vector_01.cu
index b44eb96bf141efdf44014f101c423664cda87145..cd042f05a6d062ad44a7de71730a9afec0e93119 100644 (file)
--- a/tests/cuda/cuda_vector_01.cu
+++ b/tests/cuda/cuda_vector_01.cu
@@ -115,6 +115,8 @@ main(int argc, char **argv)
   initlog();
   deallog.depth_console(0);
 
+  init_cuda();
+
   test();
 
   deallog << "OK" << std::endl;

diff --git a/tests/cuda/cuda_vector_02.cu b/tests/cuda/cuda_vector_02.cu
index b2ca855ab2b66033322170dc071ab3e9fcfad4df..ed240cea520b0a3771cb5d618044f9863d1156f2 100644 (file)
--- a/tests/cuda/cuda_vector_02.cu
+++ b/tests/cuda/cuda_vector_02.cu
@@ -111,6 +111,8 @@ main(int argc, char **argv)
   initlog();
   deallog.depth_console(0);
 
+  init_cuda();
+
   test();
 
   deallog << "OK" << std::endl;

diff --git a/tests/cuda/cuda_vector_03.cu b/tests/cuda/cuda_vector_03.cu
index 072252476913afa5834b8d0a4515ffc755c433fc..772928010e61cf706b4570f6a79ade5d4048a63b 100644 (file)
--- a/tests/cuda/cuda_vector_03.cu
+++ b/tests/cuda/cuda_vector_03.cu
@@ -41,6 +41,8 @@ main(int argc, char **argv)
   initlog();
   deallog.depth_console(0);
 
+  init_cuda();
+
   test();
 
   deallog << "OK" << std::endl;

diff --git a/tests/cuda/cuda_vector_04.cu b/tests/cuda/cuda_vector_04.cu
index c97ee9503112990e2f61bfced1399baa8e54a1b9..e54a829a648ef9cf290e00ba67b34e31cd08a1d0 100644 (file)
--- a/tests/cuda/cuda_vector_04.cu
+++ b/tests/cuda/cuda_vector_04.cu
@@ -49,6 +49,8 @@ main(int argc, char **argv)
   initlog();
   deallog.depth_console(0);
 
+  init_cuda();
+
   test();
 
   deallog << "OK" << std::endl;

diff --git a/tests/cuda/matrix_vector_common.h b/tests/cuda/matrix_vector_common.h
index a0f673a844628c820ccbb1611df5a2acc7cb19fd..ee06444eb21e467ae2bda61aad9442e82b57ddb9 100644 (file)
--- a/tests/cuda/matrix_vector_common.h
+++ b/tests/cuda/matrix_vector_common.h
@@ -159,6 +159,8 @@ main()
 
   deallog << std::setprecision(3);
 
+  init_cuda();
+
   {
     deallog.push("2d");
     test<2, 1>();

diff --git a/tests/cuda/parallel_vector_01.cu b/tests/cuda/parallel_vector_01.cu
index 9e53fb11e97987127cf8e1af7acce21505630dca..5021d1aa16d082e8255c60e1cd5a1903632c403f 100644 (file)
--- a/tests/cuda/parallel_vector_01.cu
+++ b/tests/cuda/parallel_vector_01.cu
@@ -85,18 +85,7 @@ main(int argc, char **argv)
   unsigned int myid = Utilities::MPI::this_mpi_process(MPI_COMM_WORLD);
   deallog.push(Utilities::int_to_string(myid));
 
-  Utilities::CUDA::Handle cuda_handle;
-  // By default, all the ranks will try to access the device 0. This is fine if
-  // we have one rank per node _and_ one gpu per node. If we have multiple GPUs
-  // on one node, we need each process to access a different GPU. We assume that
-  // each node has the same number of GPUs.
-  int         n_devices       = 0;
-  cudaError_t cuda_error_code = cudaGetDeviceCount(&n_devices);
-  AssertCuda(cuda_error_code);
-  int device_id   = myid % n_devices;
-  cuda_error_code = cudaSetDevice(device_id);
-  AssertCuda(cuda_error_code);
-
+  init_cuda(true);
 
   if (myid == 0)
     {

diff --git a/tests/cuda/parallel_vector_02.cu b/tests/cuda/parallel_vector_02.cu
index 7c1d0ba0bc7d2e3f2f0a7a1ac9c3c64dff456a79..e7664f4e1c158273ffc55d4dc84686e57a854fcf 100644 (file)
--- a/tests/cuda/parallel_vector_02.cu
+++ b/tests/cuda/parallel_vector_02.cu
@@ -97,17 +97,7 @@ main(int argc, char **argv)
   unsigned int myid = Utilities::MPI::this_mpi_process(MPI_COMM_WORLD);
   deallog.push(Utilities::int_to_string(myid));
 
-  Utilities::CUDA::Handle cuda_handle;
-  // By default, all the ranks will try to access the device 0. This is fine if
-  // we have one rank per node _and_ one gpu per node. If we have multiple GPUs
-  // on one node, we need each process to access a different GPU. We assume that
-  // each node has the same number of GPUs.
-  int         n_devices       = 0;
-  cudaError_t cuda_error_code = cudaGetDeviceCount(&n_devices);
-  AssertCuda(cuda_error_code);
-  int device_id   = myid % n_devices;
-  cuda_error_code = cudaSetDevice(device_id);
-  AssertCuda(cuda_error_code);
+  init_cuda(true);
 
   if (myid == 0)
     {

diff --git a/tests/cuda/parallel_vector_03.cu b/tests/cuda/parallel_vector_03.cu
index 1dfb25ceb2eeb9d93ad7e2c773a389f34254c810..0e34c7ed54694455ca6dd1bc49f5300b8ffeb928 100644 (file)
--- a/tests/cuda/parallel_vector_03.cu
+++ b/tests/cuda/parallel_vector_03.cu
@@ -102,17 +102,7 @@ main(int argc, char **argv)
   unsigned int myid = Utilities::MPI::this_mpi_process(MPI_COMM_WORLD);
   deallog.push(Utilities::int_to_string(myid));
 
-  Utilities::CUDA::Handle cuda_handle;
-  // By default, all the ranks will try to access the device 0. This is fine if
-  // we have one rank per node _and_ one gpu per node. If we have multiple GPUs
-  // on one node, we need each process to access a different GPU. We assume that
-  // each node has the same number of GPUs.
-  int         n_devices       = 0;
-  cudaError_t cuda_error_code = cudaGetDeviceCount(&n_devices);
-  AssertCuda(cuda_error_code);
-  int device_id   = myid % n_devices;
-  cuda_error_code = cudaSetDevice(device_id);
-  AssertCuda(cuda_error_code);
+  init_cuda(true);
 
   if (myid == 0)
     {

diff --git a/tests/cuda/parallel_vector_03a.cu b/tests/cuda/parallel_vector_03a.cu
index ddd3eac749ad00ead5a049267e0c714eba97fa5e..458b900a405338734481e83de75a03a23e2c6962 100644 (file)
--- a/tests/cuda/parallel_vector_03a.cu
+++ b/tests/cuda/parallel_vector_03a.cu
@@ -155,17 +155,7 @@ main(int argc, char **argv)
   unsigned int myid = Utilities::MPI::this_mpi_process(MPI_COMM_WORLD);
   deallog.push(Utilities::int_to_string(myid));
 
-  Utilities::CUDA::Handle cuda_handle;
-  // By default, all the ranks will try to access the device 0. This is fine if
-  // we have one rank per node _and_ one gpu per node. If we have multiple GPUs
-  // on one node, we need each process to access a different GPU. We assume that
-  // each node has the same number of GPUs.
-  int         n_devices       = 0;
-  cudaError_t cuda_error_code = cudaGetDeviceCount(&n_devices);
-  AssertCuda(cuda_error_code);
-  int device_id   = myid % n_devices;
-  cuda_error_code = cudaSetDevice(device_id);
-  AssertCuda(cuda_error_code);
+  init_cuda(true);
 
   if (myid == 0)
     {

diff --git a/tests/cuda/parallel_vector_04.cu b/tests/cuda/parallel_vector_04.cu
index 94731f7fd16882b47972439e8b773af4d978a5a3..e928ed32b176e04ce59ba699ff288d43ea77bc7e 100644 (file)
--- a/tests/cuda/parallel_vector_04.cu
+++ b/tests/cuda/parallel_vector_04.cu
@@ -153,22 +153,11 @@ main(int argc, char **argv)
   Utilities::MPI::MPI_InitFinalize mpi_initialization(
     argc, argv, testing_max_num_threads());
 
+  init_cuda(true);
+
   unsigned int myid = Utilities::MPI::this_mpi_process(MPI_COMM_WORLD);
   deallog.push(Utilities::int_to_string(myid));
 
-  Utilities::CUDA::Handle cuda_handle;
-  // By default, all the ranks will try to access the device 0. This is fine if
-  // we have one rank per node _and_ one gpu per node. If we have multiple GPUs
-  // on one node, we need each process to access a different GPU. We assume that
-  // each node has the same number of GPUs.
-  int         n_devices       = 0;
-  cudaError_t cuda_error_code = cudaGetDeviceCount(&n_devices);
-  AssertCuda(cuda_error_code);
-  int device_id   = myid % n_devices;
-  cuda_error_code = cudaSetDevice(device_id);
-  AssertCuda(cuda_error_code);
-
-
   if (myid == 0)
     {
       initlog();

diff --git a/tests/cuda/parallel_vector_05.cu b/tests/cuda/parallel_vector_05.cu
index 206c6c468e5c29eae56dba70c6e9e28babad4f7e..1519bd97e6934fe48c0cd5a7031c88858d1854ac 100644 (file)
--- a/tests/cuda/parallel_vector_05.cu
+++ b/tests/cuda/parallel_vector_05.cu
@@ -98,17 +98,7 @@ main(int argc, char **argv)
   unsigned int myid = Utilities::MPI::this_mpi_process(MPI_COMM_WORLD);
   deallog.push(Utilities::int_to_string(myid));
 
-  Utilities::CUDA::Handle cuda_handle;
-  // By default, all the ranks will try to access the device 0. This is fine if
-  // we have one rank per node _and_ one gpu per node. If we have multiple GPUs
-  // on one node, we need each process to access a different GPU. We assume that
-  // each node has the same number of GPUs.
-  int         n_devices       = 0;
-  cudaError_t cuda_error_code = cudaGetDeviceCount(&n_devices);
-  AssertCuda(cuda_error_code);
-  int device_id   = myid % n_devices;
-  cuda_error_code = cudaSetDevice(device_id);
-  AssertCuda(cuda_error_code);
+  init_cuda(true);
 
   if (myid == 0)
     {

diff --git a/tests/cuda/parallel_vector_06.cu b/tests/cuda/parallel_vector_06.cu
index a1ec4beb9b15463f94d5cbe69bff8a817ac4e7e9..bfe06fffaeff66fe648fadde5dd1cd007411da0d 100644 (file)
--- a/tests/cuda/parallel_vector_06.cu
+++ b/tests/cuda/parallel_vector_06.cu
@@ -143,18 +143,7 @@ main(int argc, char **argv)
   unsigned int myid = Utilities::MPI::this_mpi_process(MPI_COMM_WORLD);
   deallog.push(Utilities::int_to_string(myid));
 
-  Utilities::CUDA::Handle cuda_handle;
-  // By default, all the ranks will try to access the device 0. This is fine if
-  // we have one rank per node _and_ one gpu per node. If we have multiple GPUs
-  // on one node, we need each process to access a different GPU. We assume that
-  // each node has the same number of GPUs.
-  int         n_devices       = 0;
-  cudaError_t cuda_error_code = cudaGetDeviceCount(&n_devices);
-  AssertCuda(cuda_error_code);
-  int device_id   = myid % n_devices;
-  cuda_error_code = cudaSetDevice(device_id);
-  AssertCuda(cuda_error_code);
-
+  init_cuda(true);
 
   if (myid == 0)
     {

diff --git a/tests/cuda/parallel_vector_08.cu b/tests/cuda/parallel_vector_08.cu
index 993a32e55cc12b9a60a21cc2eaaed4594d4b5096..f0c4716232a51f064edf2acc1f9437e95ed7e7b6 100644 (file)
--- a/tests/cuda/parallel_vector_08.cu
+++ b/tests/cuda/parallel_vector_08.cu
@@ -126,17 +126,7 @@ main(int argc, char **argv)
   unsigned int myid = Utilities::MPI::this_mpi_process(MPI_COMM_WORLD);
   deallog.push(Utilities::int_to_string(myid));
 
-  Utilities::CUDA::Handle cuda_handle;
-  // By default, all the ranks will try to access the device 0. This is fine if
-  // we have one rank per node _and_ one gpu per node. If we have multiple GPUs
-  // on one node, we need each process to access a different GPU. We assume that
-  // each node has the same number of GPUs.
-  int         n_devices       = 0;
-  cudaError_t cuda_error_code = cudaGetDeviceCount(&n_devices);
-  AssertCuda(cuda_error_code);
-  int device_id   = myid % n_devices;
-  cuda_error_code = cudaSetDevice(device_id);
-  AssertCuda(cuda_error_code);
+  init_cuda(true);
 
   if (myid == 0)
     {

diff --git a/tests/cuda/parallel_vector_10.cu b/tests/cuda/parallel_vector_10.cu
index 4f08b4564027ce975fe2b986cd4a7d23f69043af..6b250c3292583de315dd4c7b0a7e9b377a23f60f 100644 (file)
--- a/tests/cuda/parallel_vector_10.cu
+++ b/tests/cuda/parallel_vector_10.cu
@@ -92,17 +92,7 @@ main(int argc, char **argv)
   unsigned int myid = Utilities::MPI::this_mpi_process(MPI_COMM_WORLD);
   deallog.push(Utilities::int_to_string(myid));
 
-  Utilities::CUDA::Handle cuda_handle;
-  // By default, all the ranks will try to access the device 0. This is fine if
-  // we have one rank per node _and_ one gpu per node. If we have multiple GPUs
-  // on one node, we need each process to access a different GPU. We assume that
-  // each node has the same number of GPUs.
-  int         n_devices       = 0;
-  cudaError_t cuda_error_code = cudaGetDeviceCount(&n_devices);
-  AssertCuda(cuda_error_code);
-  int device_id   = myid % n_devices;
-  cuda_error_code = cudaSetDevice(device_id);
-  AssertCuda(cuda_error_code);
+  init_cuda();
 
   if (myid == 0)
     {

diff --git a/tests/cuda/parallel_vector_11.cu b/tests/cuda/parallel_vector_11.cu
index 64840468e6cc11b001a078e974bd610a0decd48e..20997bf51f007bafcfd97082c5e3531a676cea6e 100644 (file)
--- a/tests/cuda/parallel_vector_11.cu
+++ b/tests/cuda/parallel_vector_11.cu
@@ -233,18 +233,7 @@ main(int argc, char **argv)
   unsigned int myid = Utilities::MPI::this_mpi_process(MPI_COMM_WORLD);
   deallog.push(Utilities::int_to_string(myid));
 
-  Utilities::CUDA::Handle cuda_handle;
-  // By default, all the ranks will try to access the device 0. This is fine if
-  // we have one rank per node _and_ one gpu per node. If we have multiple GPUs
-  // on one node, we need each process to access a different GPU. We assume that
-  // each node has the same number of GPUs.
-  int         n_devices       = 0;
-  cudaError_t cuda_error_code = cudaGetDeviceCount(&n_devices);
-  AssertCuda(cuda_error_code);
-  int device_id   = myid % n_devices;
-  cuda_error_code = cudaSetDevice(device_id);
-  AssertCuda(cuda_error_code);
-
+  init_cuda(true);
 
   if (myid == 0)
     {

diff --git a/tests/cuda/parallel_vector_12.cu b/tests/cuda/parallel_vector_12.cu
index 29e5c4da369597abd4cfdd35408e74eefba0760f..9103d9ef77dcd1566b902328ef2990ef0a768f2d 100644 (file)
--- a/tests/cuda/parallel_vector_12.cu
+++ b/tests/cuda/parallel_vector_12.cu
@@ -216,18 +216,7 @@ main(int argc, char **argv)
   unsigned int myid = Utilities::MPI::this_mpi_process(MPI_COMM_WORLD);
   deallog.push(Utilities::int_to_string(myid));
 
-  Utilities::CUDA::Handle cuda_handle;
-  // By default, all the ranks will try to access the device 0. This is fine if
-  // we have one rank per node _and_ one gpu per node. If we have multiple GPUs
-  // on one node, we need each process to access a different GPU. We assume that
-  // each node has the same number of GPUs.
-  int         n_devices       = 0;
-  cudaError_t cuda_error_code = cudaGetDeviceCount(&n_devices);
-  AssertCuda(cuda_error_code);
-  int device_id   = myid % n_devices;
-  cuda_error_code = cudaSetDevice(device_id);
-  AssertCuda(cuda_error_code);
-
+  init_cuda(true);
 
   if (myid == 0)
     {

diff --git a/tests/cuda/parallel_vector_13.cu b/tests/cuda/parallel_vector_13.cu
index 097ef2ed9d8586fa31da40f5c78a17d7655c6d20..c157244982da4a3c4c47cc23a8ebd893243a2fa4 100644 (file)
--- a/tests/cuda/parallel_vector_13.cu
+++ b/tests/cuda/parallel_vector_13.cu
@@ -113,17 +113,7 @@ main(int argc, char **argv)
   unsigned int myid = Utilities::MPI::this_mpi_process(MPI_COMM_WORLD);
   deallog.push(Utilities::int_to_string(myid));
 
-  Utilities::CUDA::Handle cuda_handle;
-  // By default, all the ranks will try to access the device 0. This is fine if
-  // we have one rank per node _and_ one gpu per node. If we have multiple GPUs
-  // on one node, we need each process to access a different GPU. We assume that
-  // each node has the same number of GPUs.
-  int         n_devices       = 0;
-  cudaError_t cuda_error_code = cudaGetDeviceCount(&n_devices);
-  AssertCuda(cuda_error_code);
-  int device_id   = myid % n_devices;
-  cuda_error_code = cudaSetDevice(device_id);
-  AssertCuda(cuda_error_code);
+  init_cuda(true);
 
   if (myid == 0)
     {

diff --git a/tests/cuda/parallel_vector_14.cu b/tests/cuda/parallel_vector_14.cu
index 955b562131968cf2a9dd09912312b45b66ac8a87..c3fab28bade4d73c1f4aaa827e022c14c18434ea 100644 (file)
--- a/tests/cuda/parallel_vector_14.cu
+++ b/tests/cuda/parallel_vector_14.cu
@@ -161,17 +161,7 @@ main(int argc, char **argv)
   unsigned int myid = Utilities::MPI::this_mpi_process(MPI_COMM_WORLD);
   deallog.push(Utilities::int_to_string(myid));
 
-  Utilities::CUDA::Handle cuda_handle;
-  // By default, all the ranks will try to access the device 0. This is fine if
-  // we have one rank per node _and_ one gpu per node. If we have multiple GPUs
-  // on one node, we need each process to access a different GPU. We assume that
-  // each node has the same number of GPUs.
-  int         n_devices       = 0;
-  cudaError_t cuda_error_code = cudaGetDeviceCount(&n_devices);
-  AssertCuda(cuda_error_code);
-  int device_id   = myid % n_devices;
-  cuda_error_code = cudaSetDevice(device_id);
-  AssertCuda(cuda_error_code);
+  init_cuda(true);
 
   if (myid == 0)
     {

diff --git a/tests/cuda/parallel_vector_15.cu b/tests/cuda/parallel_vector_15.cu
index 973b0313ed4cdbea5c4ca9aa1002978334da1b41..3a77b32fb921ca00f577cb56c8aa278a20d4cf85 100644 (file)
--- a/tests/cuda/parallel_vector_15.cu
+++ b/tests/cuda/parallel_vector_15.cu
@@ -111,17 +111,7 @@ main(int argc, char **argv)
   unsigned int myid = Utilities::MPI::this_mpi_process(MPI_COMM_WORLD);
   deallog.push(Utilities::int_to_string(myid));
 
-  Utilities::CUDA::Handle cuda_handle;
-  // By default, all the ranks will try to access the device 0. This is fine if
-  // we have one rank per node _and_ one gpu per node. If we have multiple GPUs
-  // on one node, we need each process to access a different GPU. We assume that
-  // each node has the same number of GPUs.
-  int         n_devices       = 0;
-  cudaError_t cuda_error_code = cudaGetDeviceCount(&n_devices);
-  AssertCuda(cuda_error_code);
-  int device_id   = myid % n_devices;
-  cuda_error_code = cudaSetDevice(device_id);
-  AssertCuda(cuda_error_code);
+  init_cuda(true);
 
   if (myid == 0)
     {

diff --git a/tests/cuda/parallel_vector_21.cu b/tests/cuda/parallel_vector_21.cu
index f8e75de788993622299b083d2487a5383b32ef57..99f867327d2b3cb838488d4760c3ebb0a4a99361 100644 (file)
--- a/tests/cuda/parallel_vector_21.cu
+++ b/tests/cuda/parallel_vector_21.cu
@@ -86,18 +86,7 @@ main(int argc, char **argv)
   Utilities::MPI::MPI_InitFinalize mpi_initialization(
     argc, argv, testing_max_num_threads());
 
-  unsigned int my_id = Utilities::MPI::this_mpi_process(MPI_COMM_WORLD);
-  Utilities::CUDA::Handle cuda_handle;
-  // By default, all the ranks will try to access the device 0. This is fine if
-  // we have one rank per node _and_ one gpu per node. If we have multiple GPUs
-  // on one node, we need each process to access a different GPU. We assume that
-  // each node has the same number of GPUs.
-  int         n_devices       = 0;
-  cudaError_t cuda_error_code = cudaGetDeviceCount(&n_devices);
-  AssertCuda(cuda_error_code);
-  int device_id   = my_id % n_devices;
-  cuda_error_code = cudaSetDevice(device_id);
-  AssertCuda(cuda_error_code);
+  init_cuda(true);
 
   MPILogInitAll log;
   test();

diff --git a/tests/cuda/precondition_01.cu b/tests/cuda/precondition_01.cu
index 9de6715e61fe230c2e9f0c64851dbc3988bb9b15..78569e9cedb21bdf863e300b236641875df43f4e 100644 (file)
--- a/tests/cuda/precondition_01.cu
+++ b/tests/cuda/precondition_01.cu
@@ -74,6 +74,8 @@ main()
   deallog << std::setprecision(10);
   deallog.depth_console(0);
 
+  init_cuda();
+
   Utilities::CUDA::Handle cuda_handle;
   deallog << "Testing float" << std::endl;
   test<float>(cuda_handle);

diff --git a/tests/cuda/precondition_02.cu b/tests/cuda/precondition_02.cu
index edfea90e81f54f470efd7633bb84fc0086c2b27a..e8b2099f6607ae20f5a4c7fc6c7543d12655e14a 100644 (file)
--- a/tests/cuda/precondition_02.cu
+++ b/tests/cuda/precondition_02.cu
@@ -74,6 +74,8 @@ main()
   deallog << std::setprecision(10);
   deallog.depth_console(0);
 
+  init_cuda();
+
   Utilities::CUDA::Handle cuda_handle;
   deallog << "Testing float" << std::endl;
   test<float>(cuda_handle);

diff --git a/tests/cuda/solver_01.cu b/tests/cuda/solver_01.cu
index 69b8c3274390ecfc2d9874d7b8a22e44ba0b7705..58d8ace4772d4924128808c2fbbcd2055a973ea0 100644 (file)
--- a/tests/cuda/solver_01.cu
+++ b/tests/cuda/solver_01.cu
@@ -76,6 +76,8 @@ main()
   initlog();
   deallog.depth_console(0);
 
+  init_cuda();
+
   Utilities::CUDA::Handle cuda_handle;
   test(cuda_handle);
 

diff --git a/tests/cuda/solver_02.cu b/tests/cuda/solver_02.cu
index cdf9d8a8ddbad4023ea79149bdab9ad0efd0c142..67333dfc01302bb09050456c2e9781d594982e60 100644 (file)
--- a/tests/cuda/solver_02.cu
+++ b/tests/cuda/solver_02.cu
@@ -107,6 +107,8 @@ main()
   initlog();
   deallog.depth_console(0);
 
+  init_cuda();
+
   Utilities::CUDA::Handle cuda_handle;
   test(cuda_handle);
 

diff --git a/tests/cuda/solver_03.cu b/tests/cuda/solver_03.cu
index 89250f51109f7926696b76b282c0706a406f4886..cc5c7dec4a5b7fe005550565082c0d0538c62769 100644 (file)
--- a/tests/cuda/solver_03.cu
+++ b/tests/cuda/solver_03.cu
@@ -76,6 +76,8 @@ main()
   initlog();
   deallog.depth_console(0);
 
+  init_cuda();
+
   Utilities::CUDA::Handle cuda_handle;
   test(cuda_handle);
 

diff --git a/tests/cuda/solver_04.cu b/tests/cuda/solver_04.cu
index 0aba76d39ba9e49739dc5f1a075ccfd63071003b..eb50a3bc145ab381217c427da4eb99e3bbc0abe3 100644 (file)
--- a/tests/cuda/solver_04.cu
+++ b/tests/cuda/solver_04.cu
@@ -77,6 +77,8 @@ main()
   initlog();
   deallog.depth_console(0);
 
+  init_cuda();
+
   Utilities::CUDA::Handle cuda_handle;
   test(cuda_handle);
 

diff --git a/tests/cuda/solver_05.cu b/tests/cuda/solver_05.cu
index 1a4bb7f48a14dc910783f681984ac073dec932be..f66ffbfad2ba6c5eac2c203dae58da07b8b4c99a 100644 (file)
--- a/tests/cuda/solver_05.cu
+++ b/tests/cuda/solver_05.cu
@@ -76,6 +76,8 @@ main()
   initlog();
   deallog.depth_console(0);
 
+  init_cuda();
+
   Utilities::CUDA::Handle cuda_handle;
   test(cuda_handle);
 

diff --git a/tests/cuda/solver_06.cu b/tests/cuda/solver_06.cu
index e8aa593338ac17d38a373a59b692c15c68f6e281..b8cd854b4713df2d50f5a99f0cd6acf06202f874 100644 (file)
--- a/tests/cuda/solver_06.cu
+++ b/tests/cuda/solver_06.cu
@@ -76,6 +76,8 @@ main()
   initlog();
   deallog.depth_console(0);
 
+  init_cuda();
+
   Utilities::CUDA::Handle cuda_handle;
   test(cuda_handle);
 

diff --git a/tests/cuda/solver_07.cu b/tests/cuda/solver_07.cu
index ea8561c29ab98af6e933a9aae7f48906e8ca2898..c6b99396c74f2babc04999e6af5453872cdd6f62 100644 (file)
--- a/tests/cuda/solver_07.cu
+++ b/tests/cuda/solver_07.cu
@@ -76,6 +76,8 @@ main()
   initlog();
   deallog.depth_console(0);
 
+  init_cuda();
+
   Utilities::CUDA::Handle cuda_handle;
   test(cuda_handle);
 

diff --git a/tests/cuda/solver_08.cu b/tests/cuda/solver_08.cu
index 0cd8caab521d9971a66c98d5cf25504bcf878eb9..fe381d2d1015598b0bc5a3dd7124ba0f98671848 100644 (file)
--- a/tests/cuda/solver_08.cu
+++ b/tests/cuda/solver_08.cu
@@ -76,6 +76,8 @@ main()
   initlog();
   deallog.depth_console(0);
 
+  init_cuda();
+
   Utilities::CUDA::Handle cuda_handle;
   test(cuda_handle);
 

diff --git a/tests/cuda/solver_09.cu b/tests/cuda/solver_09.cu
index 742924bcbfc7301ecd6a6f176d0bd5dcfb21a73c..8aa91ff3631103b18a343a834d281cc3fd4777c2 100644 (file)
--- a/tests/cuda/solver_09.cu
+++ b/tests/cuda/solver_09.cu
@@ -105,6 +105,8 @@ main()
   initlog();
   deallog.depth_console(0);
 
+  init_cuda();
+
   Utilities::CUDA::Handle cuda_handle;
   test(cuda_handle);
 

diff --git a/tests/cuda/solver_10.cu b/tests/cuda/solver_10.cu
index f38f500402b958d564f0dbe10c555b23cf2d07d6..396ef2ac47a384c4f2a66d972869d4439150e2ce 100644 (file)
--- a/tests/cuda/solver_10.cu
+++ b/tests/cuda/solver_10.cu
@@ -125,6 +125,8 @@ main()
   initlog();
   deallog.depth_console(10);
 
+  init_cuda();
+
   Utilities::CUDA::Handle cuda_handle;
   test(cuda_handle);
 

diff --git a/tests/cuda/sparse_matrix_01.cu b/tests/cuda/sparse_matrix_01.cu
index 1d7db49acba968fb69fa23ed78c5154e0d1867dd..4ca3de628a7361dfedbf4498f6de855dc096c847 100644 (file)
--- a/tests/cuda/sparse_matrix_01.cu
+++ b/tests/cuda/sparse_matrix_01.cu
@@ -213,6 +213,8 @@ main()
   initlog();
   deallog.depth_console(0);
 
+  init_cuda();
+
   Utilities::CUDA::Handle cuda_handle;
 
   test(cuda_handle);

diff --git a/tests/cuda/sparse_matrix_02.cu b/tests/cuda/sparse_matrix_02.cu
index bec9672194d60c803fa18ada41dc3e1cd55a7037..377789dd1672a119e6897895962978323ca5a8df 100644 (file)
--- a/tests/cuda/sparse_matrix_02.cu
+++ b/tests/cuda/sparse_matrix_02.cu
@@ -52,6 +52,8 @@ main()
   initlog();
   deallog.depth_console(0);
 
+  init_cuda();
+
   Utilities::CUDA::Handle cuda_handle;
 
   test(cuda_handle);

diff --git a/tests/cuda/vector_reinit_01.cu b/tests/cuda/vector_reinit_01.cu
index df834427b811b386d321b25cbc080b7f759fa25e..1bdfed9dc18f49be649badfc6707f53159b299f4 100644 (file)
--- a/tests/cuda/vector_reinit_01.cu
+++ b/tests/cuda/vector_reinit_01.cu
@@ -110,9 +110,9 @@ main(int argc, char **argv)
 {
   Utilities::MPI::MPI_InitFinalize mpi_initialization(
     argc, argv, testing_max_num_threads());
-  Utilities::CUDA::Handle cuda_handle;
 
   initlog();
+  init_cuda();
 
   do_test<
     LinearAlgebra::distributed::Vector<double, dealii::MemorySpace::CUDA>>();

diff --git a/tests/tests.h b/tests/tests.h
index 25ccf10ff5f26da4ae8499e2da9b452c78abfe43..6f564b535137a15af9a8eebe4d5b759c7c0c071c 100644 (file)
--- a/tests/tests.h
+++ b/tests/tests.h
@@ -20,6 +20,7 @@
 
 #include <deal.II/base/config.h>
 
+#include <deal.II/base/cuda.h>
 #include <deal.II/base/exceptions.h>
 #include <deal.II/base/job_identifier.h>
 #include <deal.II/base/logstream.h>
@@ -591,6 +592,42 @@ struct MPILogInitAll
 };
 
 
+#ifdef DEAL_II_COMPILER_CUDA_AWARE
+// By default, all the ranks will try to access the device 0. We can distribute
+// the load better by using a random device which is done in this function. In
+// case tests use MPI, we make sure to set subsequent devices. MPI needs to be
+// initialized before using this function.
+// Also initialize a dummy handle that makes sure that unused memory is released
+// before the device shuts down.
+void
+init_cuda(bool use_mpi = false)
+{
+  static Utilities::CUDA::Handle cuda_handle;
+#  ifndef DEAL_II_WITH_MPI
+  Assert(use_mpi == false, ExcInternalError());
+#  endif
+  const unsigned int my_id =
+    use_mpi ? Utilities::MPI::this_mpi_process(MPI_COMM_WORLD) : 0;
+  int         device_id       = 0;
+  int         n_devices       = 0;
+  cudaError_t cuda_error_code = cudaGetDeviceCount(&n_devices);
+  if (my_id == 0)
+    {
+      Testing::srand(std::time(nullptr));
+      AssertCuda(cuda_error_code);
+      device_id = Testing::rand() % n_devices;
+    }
+#  ifdef DEAL_II_WITH_MPI
+  if (use_mpi)
+    MPI_Bcast(&device_id, 1, MPI_INT, 0, MPI_COMM_WORLD);
+#  endif
+  device_id       = (device_id + my_id) % n_devices;
+  cuda_error_code = cudaSetDevice(device_id);
+  AssertCuda(cuda_error_code);
+}
+#endif
+
+
 
 /* Override the tbb assertion handler in order to print a stacktrace:*/