Added CUDA.

Author: classner

README.md

@@ -20,6 +20,7 @@ implemented for:
 - 'boost.system',
 - 'boost.test',
 - 'boost.thread',
+- 'cuda',
 - 'eigen',
 - 'fftw',
 - 'hdf5',

__init__.py

@@ -58,6 +58,10 @@
                    _check_dict as _hdf5_check_dict
 _check_dict = dict(_check_dict, **_hdf5_check_dict)
 
+from .cuda import CheckCUDA, \
+                   _check_dict as _cuda_check_dict
+_check_dict = dict(_check_dict, **_cuda_check_)
+
 def AddLibOptions(add_method, lib_names):
   r"""
   Provide the `AddOption` method for your enviromnent, and all command line

_tools.py

@@ -29,10 +29,10 @@ def _setupPaths(env,
     if lib:
         env.PrependUnique(LIBPATH=[lib])
 
-def _checkLibs(context, try_libs, source_file):
+def _checkLibs(context, try_libs, source_file, file_ending='.cpp'):
     init_libs = context.env.get('LIBS', [])
     context.env.PrependUnique(LIBS=[try_libs])
-    result = context.TryLink(source_file, '.cpp')
+    result = context.TryLink(source_file, file_ending)
     if not result :
         context.env.Replace(LIBS=init_libs)
     return result

cuda.py

@@ -0,0 +1,113 @@
+# -*- python -*-
+#
+# Copyright Christoph Lassner 2015.
+#
+# Distributed under the Boost Software License, Version 1.0.
+#    (See http://www.boost.org/LICENSE_1_0.txt)
+
+from __future__ import print_function
+import os
+
+from ._tools import _checkLibs, _setupPaths
+
+from SCons.SConf import CheckContext
+CheckContext.checkLibs = _checkLibs
+
+_check_dict = {}
+_cuda_option_dict  = {'--cuda-dir':
+                       {'dest':"cuda_prefix",
+                       'type':"string",
+                       'nargs':1,
+                       'action':"store",
+                       'metavar':"DIR",
+                       'default':os.environ.get("CUDA_ROOT"),
+                       'help':"prefix for cuda; should contain the	 'bin', 'include', and 'lib' folders."},
+                       '--cuda-inc-dir':
+                       {'dest':"cuda_include",
+                       'type':"string",
+                       'nargs':1,
+                       'action':"store",
+                       'metavar':"DIR",
+                       'help':"this folder should contain 'cuda.h'.",
+                       'default':os.environ.get("CUDA_INCLUDE_DIR")},
+                       '--cuda-lib-dir':
+                       {'dest':"cuda_lib",
+                       'type':"string",
+                       'nargs':1,
+                       'action':"store",
+                       'metavar':"DIR",
+                       'help':"this folder should contain 'libcudart_static.a'.",
+                       'default':os.environ.get("CUDA_LIB_DIR")}}
+
+def CheckCUDA(context):
+    context.Message("Checking for CUDA...")
+    if os.name == 'nt':
+      result, nvcc_cmd = context.TryAction("where nvcc")
+      result, cl_cmd = context.TryAction("where cl")
+      nvcc_cmd = None
+    else:
+      result, nvcc_cmd = context.TryAction("which nvcc > $TARGET")
+    context.Result(result)
+    if result:
+        if not nvcc_cmd is None:
+          print("Using nvcc at", nvcc_cmd.strip())
+    context.Message("Check building with CUDA...")
+    sample_source_file = r"""
+#include <stdio.h>
+ 
+__global__
+void add(int *a, int *b, int *c ) {
+	*c = *a + *b;
+}
+ 
+int main( void ) {
+	int a, b, c;
+	// host copies of a, b, c
+	int *dev_a, *dev_b, *dev_c;
+	// device copies of a, b, c
+	int size = sizeof(int);
+	// we need space for an integer
+	// allocate device copies of a, b, c
+	cudaMalloc( (void**)&dev_a, size );
+	cudaMalloc( (void**)&dev_b, size );
+	cudaMalloc( (void**)&dev_c, size );
+	a = 2;
+	b = 7;
+	// copy inputs to device
+	cudaMemcpy(dev_a, &a, size, cudaMemcpyHostToDevice);
+	cudaMemcpy(dev_b, &b, size, cudaMemcpyHostToDevice);
+	// launch add() kernel on GPU, passing parameters
+	add<<< 1, 1 >>>(dev_a,dev_b,dev_c);
+	// copy device result back to host copy of c
+	cudaMemcpy( &c,dev_c, size,cudaMemcpyDeviceToHost);
+	cudaFree(dev_a);
+	cudaFree(dev_b);
+	cudaFree(dev_c);
+	return 0;
+}
+"""
+    context.Message('Check building with CUDA... ')
+    ex_prefix_dir = context.env.GetOption("cuda_prefix")
+    ex_lib_dir = context.env.GetOption("cuda_lib")
+    ex_include_dir = context.env.GetOption("cuda_include")
+    _setupPaths(context.env,
+                prefix = ex_prefix_dir,
+                include = ex_include_dir,
+                lib = ex_lib_dir
+                )
+    context.env.Tool('nvcc')
+    result_bld = (context.checkLibs(['cublas', 'cublas_device',
+                                     'cufft', 'cufftw', 'curand'],
+                                     sample_source_file,
+                                     '.cu'))
+    if not result_bld:
+        context.Result(0)
+        print("Cannot build with CUDA.")
+        return False
+    result, output = context.TryRun(sample_source_file, '.cu')
+    if not result:
+        print("Warning: cannot run program built with CUDA. Continuing anyway.")
+    context.Result(1)
+    return True
+_check_dict['cuda'] = {'options': {},
+                       'checks': [CheckCUDA]}