boost/math
2
0
Fork 0
mirror of https://github.com/boostorg/math.git synced 2026-01-27 07:02:08 +00:00
Code Issues Projects Releases Wiki Activity

Fix tests to be clean with cuda-memcheck.

Browse Source
This commit is contained in:
jzmaddock
2016-01-22 15:35:38 +00:00
parent cce006fe2d
commit c043cabcb0
19 changed files with 42 additions and 271 deletions
Download Patch File Download Diff File Expand all files Collapse all files

15
test/cuda/beta_double.cu
View File

@@ -117,21 +117,6 @@ int main(void)
}
std::cout << "Test PASSED with calculation time: " << t << "s" << std::endl;
// Reset the device and exit
// cudaDeviceReset causes the driver to clean up all state. While
// not mandatory in normal operation, it is good practice. It is also
// needed to ensure correct operation when the application is being
// profiled. Calling cudaDeviceReset causes all profile data to be
// flushed before the application exits
err = cudaDeviceReset();
if (err != cudaSuccess)
{
std::cerr << "Failed to deinitialize the device! error=" << cudaGetErrorString(err) << std::endl;
return EXIT_FAILURE;
}
std::cout << "Done\n";
}
catch(const std::exception& e)

15
test/cuda/beta_float.cu
View File

@@ -117,21 +117,6 @@ int main(void)
}
std::cout << "Test PASSED with calculation time: " << t << "s" << std::endl;
// Reset the device and exit
// cudaDeviceReset causes the driver to clean up all state. While
// not mandatory in normal operation, it is good practice. It is also
// needed to ensure correct operation when the application is being
// profiled. Calling cudaDeviceReset causes all profile data to be
// flushed before the application exits
err = cudaDeviceReset();
if (err != cudaSuccess)
{
std::cerr << "Failed to deinitialize the device! error=" << cudaGetErrorString(err) << std::endl;
return EXIT_FAILURE;
}
std::cout << "Done\n";
}
catch(const std::exception& e)

15
test/cuda/cbrt_double.cu
View File

@@ -90,21 +90,6 @@ int main(void)
}
std::cout << "Test PASSED, normal calculation time: " << t << "s" << std::endl;
// Reset the device and exit
// cudaDeviceReset causes the driver to clean up all state. While
// not mandatory in normal operation, it is good practice. It is also
// needed to ensure correct operation when the application is being
// profiled. Calling cudaDeviceReset causes all profile data to be
// flushed before the application exits
err = cudaDeviceReset();
if (err != cudaSuccess)
{
std::cerr << "Failed to deinitialize the device! error=" << cudaGetErrorString(err) << std::endl;
return EXIT_FAILURE;
}
std::cout << "Done\n";
return 0;

15
test/cuda/cbrt_float.cu
View File

@@ -89,21 +89,6 @@ int main(void)
}
std::cout << "Test PASSED in " << t << "s" << std::endl;
// Reset the device and exit
// cudaDeviceReset causes the driver to clean up all state. While
// not mandatory in normal operation, it is good practice. It is also
// needed to ensure correct operation when the application is being
// profiled. Calling cudaDeviceReset causes all profile data to be
// flushed before the application exits
err = cudaDeviceReset();
if (err != cudaSuccess)
{
std::cerr << "Failed to deinitialize the device! error=" << cudaGetErrorString(err) << std::endl;
return EXIT_FAILURE;
}
std::cout << "Done\n";
return 0;

43
test/cuda/cuda_managed_ptr.hpp
View File

@@ -24,10 +24,44 @@ protected:
int managed_holder_base::count = 0;
//
// Reset the device and exit:
// cudaDeviceReset causes the driver to clean up all state. While
// not mandatory in normal operation, it is good practice. It is also
// needed to ensure correct operation when the application is being
// profiled. Calling cudaDeviceReset causes all profile data to be
// flushed before the application exits.
//
// We have a global instance of this class, plus instances for each
// managed pointer. Last one out the door switches the lights off.
//
class cudaResetter
{
static int count;
public:
cudaResetter() { ++count; }
~cudaResetter()
{
if(--count == 0)
{
cudaError_t err = cudaDeviceReset();
if(err != cudaSuccess)
{
std::cerr << "Failed to deinitialize the device! error=" << cudaGetErrorString(err) << std::endl;
}
}
}
};
int cudaResetter::count = 0;
cudaResetter global_resetter;
template <class T>
class cuda_managed_ptr
{
T* data;
static const cudaResetter resetter;
cuda_managed_ptr(const cuda_managed_ptr&) = delete;
cuda_managed_ptr& operator=(cuda_managed_ptr const&) = delete;
void free()
@@ -35,7 +69,11 @@ class cuda_managed_ptr
if(data)
{
cudaDeviceSynchronize();
cudaFree(data);
cudaError_t err = cudaFree(data);
if(err != cudaSuccess)
{
std::cerr << "Failed to deinitialize the device! error=" << cudaGetErrorString(err) << std::endl;
}
}
}
public:
@@ -92,6 +130,9 @@ public:
const T& operator[](std::size_t n)const { return data[n]; }
};
template <class T>
cudaResetter const cuda_managed_ptr<T>::resetter;
#endif

15
test/cuda/erf_double.cu
View File

@@ -89,21 +89,6 @@ int main(void)
}
std::cout << "Test PASSED with calculation time: " << t << "s" << std::endl;
// Reset the device and exit
// cudaDeviceReset causes the driver to clean up all state. While
// not mandatory in normal operation, it is good practice. It is also
// needed to ensure correct operation when the application is being
// profiled. Calling cudaDeviceReset causes all profile data to be
// flushed before the application exits
err = cudaDeviceReset();
if (err != cudaSuccess)
{
std::cerr << "Failed to deinitialize the device! error=" << cudaGetErrorString(err) << std::endl;
return EXIT_FAILURE;
}
std::cout << "Done\n";
return 0;

15
test/cuda/erf_float.cu
View File

@@ -90,21 +90,6 @@ int main(void)
}
std::cout << "Test PASSED in " << t << "s" << std::endl;
// Reset the device and exit
// cudaDeviceReset causes the driver to clean up all state. While
// not mandatory in normal operation, it is good practice. It is also
// needed to ensure correct operation when the application is being
// profiled. Calling cudaDeviceReset causes all profile data to be
// flushed before the application exits
err = cudaDeviceReset();
if (err != cudaSuccess)
{
std::cerr << "Failed to deinitialize the device! error=" << cudaGetErrorString(err) << std::endl;
return EXIT_FAILURE;
}
std::cout << "Done\n";
return 0;

15
test/cuda/erf_inv_double.cu
View File

@@ -96,21 +96,6 @@ int main(void)
}
std::cout << "Test PASSED with calculation time: " << t << "s" << std::endl;
// Reset the device and exit
// cudaDeviceReset causes the driver to clean up all state. While
// not mandatory in normal operation, it is good practice. It is also
// needed to ensure correct operation when the application is being
// profiled. Calling cudaDeviceReset causes all profile data to be
// flushed before the application exits
err = cudaDeviceReset();
if (err != cudaSuccess)
{
std::cerr << "Failed to deinitialize the device! error=" << cudaGetErrorString(err) << std::endl;
return EXIT_FAILURE;
}
std::cout << "Done\n";
return 0;

15
test/cuda/erf_inv_float.cu
View File

@@ -96,21 +96,6 @@ int main(void)
}
std::cout << "Test PASSED with calculation time: " << t << "s" << std::endl;
// Reset the device and exit
// cudaDeviceReset causes the driver to clean up all state. While
// not mandatory in normal operation, it is good practice. It is also
// needed to ensure correct operation when the application is being
// profiled. Calling cudaDeviceReset causes all profile data to be
// flushed before the application exits
err = cudaDeviceReset();
if (err != cudaSuccess)
{
std::cerr << "Failed to deinitialize the device! error=" << cudaGetErrorString(err) << std::endl;
return EXIT_FAILURE;
}
std::cout << "Done\n";
return 0;

15
test/cuda/gamma_p_deriv_double.cu
View File

@@ -111,21 +111,6 @@ int main(void)
}
std::cout << "Test PASSED with calculation time: " << t << "s" << std::endl;
// Reset the device and exit
// cudaDeviceReset causes the driver to clean up all state. While
// not mandatory in normal operation, it is good practice. It is also
// needed to ensure correct operation when the application is being
// profiled. Calling cudaDeviceReset causes all profile data to be
// flushed before the application exits
err = cudaDeviceReset();
if (err != cudaSuccess)
{
std::cerr << "Failed to deinitialize the device! error=" << cudaGetErrorString(err) << std::endl;
return EXIT_FAILURE;
}
std::cout << "Done\n";
}
catch(const std::exception& e)

15
test/cuda/gamma_p_deriv_float.cu
View File

@@ -123,21 +123,6 @@ int main(void)
}
std::cout << "Test PASSED with calculation time: " << t << "s" << std::endl;
// Reset the device and exit
// cudaDeviceReset causes the driver to clean up all state. While
// not mandatory in normal operation, it is good practice. It is also
// needed to ensure correct operation when the application is being
// profiled. Calling cudaDeviceReset causes all profile data to be
// flushed before the application exits
err = cudaDeviceReset();
if (err != cudaSuccess)
{
std::cerr << "Failed to deinitialize the device! error=" << cudaGetErrorString(err) << std::endl;
return EXIT_FAILURE;
}
std::cout << "Done\n";
}
catch(const std::exception& e)

15
test/cuda/gamma_p_double.cu
View File

@@ -123,21 +123,6 @@ int main(void)
}
std::cout << "Test PASSED with calculation time: " << t << "s" << std::endl;
// Reset the device and exit
// cudaDeviceReset causes the driver to clean up all state. While
// not mandatory in normal operation, it is good practice. It is also
// needed to ensure correct operation when the application is being
// profiled. Calling cudaDeviceReset causes all profile data to be
// flushed before the application exits
err = cudaDeviceReset();
if (err != cudaSuccess)
{
std::cerr << "Failed to deinitialize the device! error=" << cudaGetErrorString(err) << std::endl;
return EXIT_FAILURE;
}
std::cout << "Done\n";
}
catch(const std::exception& e)

15
test/cuda/gamma_p_float.cu
View File

@@ -123,21 +123,6 @@ int main(void)
}
std::cout << "Test PASSED with calculation time: " << t << "s" << std::endl;
// Reset the device and exit
// cudaDeviceReset causes the driver to clean up all state. While
// not mandatory in normal operation, it is good practice. It is also
// needed to ensure correct operation when the application is being
// profiled. Calling cudaDeviceReset causes all profile data to be
// flushed before the application exits
err = cudaDeviceReset();
if (err != cudaSuccess)
{
std::cerr << "Failed to deinitialize the device! error=" << cudaGetErrorString(err) << std::endl;
return EXIT_FAILURE;
}
std::cout << "Done\n";
}
catch(const std::exception& e)

15
test/cuda/ibeta_derivative_double.cu
View File

@@ -135,21 +135,6 @@ int main(void)
}
std::cout << "Test PASSED with calculation time: " << t << "s" << std::endl;
// Reset the device and exit
// cudaDeviceReset causes the driver to clean up all state. While
// not mandatory in normal operation, it is good practice. It is also
// needed to ensure correct operation when the application is being
// profiled. Calling cudaDeviceReset causes all profile data to be
// flushed before the application exits
err = cudaDeviceReset();
if (err != cudaSuccess)
{
std::cerr << "Failed to deinitialize the device! error=" << cudaGetErrorString(err) << std::endl;
return EXIT_FAILURE;
}
std::cout << "Done\n";
}
catch(const std::exception& e)

15
test/cuda/ibeta_derivative_float.cu
View File

@@ -138,21 +138,6 @@ int main(void)
}
std::cout << "Test PASSED with calculation time: " << t << "s" << std::endl;
// Reset the device and exit
// cudaDeviceReset causes the driver to clean up all state. While
// not mandatory in normal operation, it is good practice. It is also
// needed to ensure correct operation when the application is being
// profiled. Calling cudaDeviceReset causes all profile data to be
// flushed before the application exits
err = cudaDeviceReset();
if (err != cudaSuccess)
{
std::cerr << "Failed to deinitialize the device! error=" << cudaGetErrorString(err) << std::endl;
return EXIT_FAILURE;
}
std::cout << "Done\n";
}
catch(const std::exception& e)

15
test/cuda/lgamma_double.cu
View File

@@ -115,21 +115,6 @@ int main(void)
}
std::cout << "Test PASSED with calculation time: " << t << "s" << std::endl;
// Reset the device and exit
// cudaDeviceReset causes the driver to clean up all state. While
// not mandatory in normal operation, it is good practice. It is also
// needed to ensure correct operation when the application is being
// profiled. Calling cudaDeviceReset causes all profile data to be
// flushed before the application exits
err = cudaDeviceReset();
if (err != cudaSuccess)
{
std::cerr << "Failed to deinitialize the device! error=" << cudaGetErrorString(err) << std::endl;
return EXIT_FAILURE;
}
std::cout << "Done\n";
}
catch(const std::exception& e)

15
test/cuda/lgamma_float.cu
View File

@@ -115,21 +115,6 @@ int main(void)
}
std::cout << "Test PASSED with calculation time: " << t << "s" << std::endl;
// Reset the device and exit
// cudaDeviceReset causes the driver to clean up all state. While
// not mandatory in normal operation, it is good practice. It is also
// needed to ensure correct operation when the application is being
// profiled. Calling cudaDeviceReset causes all profile data to be
// flushed before the application exits
err = cudaDeviceReset();
if (err != cudaSuccess)
{
std::cerr << "Failed to deinitialize the device! error=" << cudaGetErrorString(err) << std::endl;
return EXIT_FAILURE;
}
std::cout << "Done\n";
}
catch(const std::exception& e)

15
test/cuda/tgamma_double.cu
View File

@@ -115,21 +115,6 @@ int main(void)
}
std::cout << "Test PASSED with calculation time: " << t << "s" << std::endl;
// Reset the device and exit
// cudaDeviceReset causes the driver to clean up all state. While
// not mandatory in normal operation, it is good practice. It is also
// needed to ensure correct operation when the application is being
// profiled. Calling cudaDeviceReset causes all profile data to be
// flushed before the application exits
err = cudaDeviceReset();
if (err != cudaSuccess)
{
std::cerr << "Failed to deinitialize the device! error=" << cudaGetErrorString(err) << std::endl;
return EXIT_FAILURE;
}
std::cout << "Done\n";
}
catch(const std::exception& e)

15
test/cuda/tgamma_float.cu
View File

@@ -115,21 +115,6 @@ int main(void)
}
std::cout << "Test PASSED with calculation time: " << t << "s" << std::endl;
// Reset the device and exit
// cudaDeviceReset causes the driver to clean up all state. While
// not mandatory in normal operation, it is good practice. It is also
// needed to ensure correct operation when the application is being
// profiled. Calling cudaDeviceReset causes all profile data to be
// flushed before the application exits
err = cudaDeviceReset();
if (err != cudaSuccess)
{
std::cerr << "Failed to deinitialize the device! error=" << cudaGetErrorString(err) << std::endl;
return EXIT_FAILURE;
}
std::cout << "Done\n";
}
catch(const std::exception& e)