Cleanup to CUDA compiler plugin

CMakeLists.txt

@@ -462,6 +462,21 @@ IF(OPENMM_BUILD_PME_PLUGIN)
    ADD_SUBDIRECTORY(plugins/cpupme)
 ENDIF(OPENMM_BUILD_PME_PLUGIN)
 
+# CUDA compiler plugin
+
+GET_FILENAME_COMPONENT(CUDA_LIB_DIR "${CUDA_cufft_LIBRARY}" PATH)
+FIND_LIBRARY(CUDA_nvrtc_LIBRARY nvrtc "${CUDA_LIB_DIR}")
+IF(CUDA_nvrtc_LIBRARY)
+    SET(OPENMM_BUILD_CUDA_COMPILER_PLUGIN ON CACHE BOOL "Build CUDA runtime compiler plugin")
+ELSE(CUDA_nvrtc_LIBRARY)
+    SET(OPENMM_BUILD_CUDA_COMPILER_PLUGIN OFF CACHE BOOL "Build CUDA runtime compiler plugin")
+ENDIF(CUDA_nvrtc_LIBRARY)
+SET(OPENMM_BUILD_CUDACOMPILER_PATH)
+IF(OPENMM_BUILD_CUDA_COMPILER_PLUGIN)
+   SET(OPENMM_BUILD_CUDACOMPILER_PATH ${CMAKE_CURRENT_SOURCE_DIR}/plugins/cudacompiler)
+   ADD_SUBDIRECTORY(plugins/cudacompiler)
+ENDIF(OPENMM_BUILD_CUDA_COMPILER_PLUGIN)
+
 IF(OPENMM_BUILD_SHARED_LIB)
     INSTALL_TARGETS(/lib RUNTIME_DIRECTORY /lib ${SHARED_TARGET})
 ENDIF(OPENMM_BUILD_SHARED_LIB)

platforms/cuda/src/CudaContext.cpp

@@ -537,13 +537,19 @@ CUmodule CudaContext::createModule(const string source, const map<string, string
         
         // If possible, write the PTX out to a temporary file so we can cache it for later use.
         
+        bool wroteCache = false;
         try {
             ofstream out(outputFile.c_str());
             out << ptx;
             out.close();
+            if (!out.fail())
+                wroteCache = true;
         }
         catch (...) {
-            // An error occurred.  Possibly we don't have permission to write to the tmep directory.  Just try to load the module directly.
+            // Ignore.
+        }
+        if (!wroteCache) {
+            // An error occurred.  Possibly we don't have permission to write to the temp directory.  Just try to load the module directly.
             
             CHECK_RESULT2(cuModuleLoadDataEx(&module, &ptx[0], 0, NULL, NULL), "Error loading CUDA module");
             return module;

plugins/cudacompiler/CMakeLists.txt

 #---------------------------------------------------
-# OpenMM CUDA RPMD Integrator
+# OpenMM CUDA runtime compiler
 #
-# Creates OpenMMCudaCompiler library,.
+# Creates OpenMMCudaCompiler library.
 #
 # Windows:
 #   OpenMMCudaCompiler.dll
@@ -62,8 +62,6 @@ ENDFOREACH(subdir)
 INCLUDE_DIRECTORIES(BEFORE ${CMAKE_CURRENT_SOURCE_DIR}/src)
 INCLUDE_DIRECTORIES(BEFORE ${CMAKE_SOURCE_DIR}/platforms/cuda/include)
 INCLUDE_DIRECTORIES(${CUDA_TOOLKIT_INCLUDE})
-GET_FILENAME_COMPONENT(CUDA_LIB_DIR "${CUDA_cufft_LIBRARY}" PATH)
-FIND_LIBRARY(CUDA_nvrtc_LIBRARY nvrtc "${CUDA_LIB_DIR}")
 
 # Build the shared plugin library.
 
@@ -102,8 +100,12 @@ ENDIF(OPENMM_BUILD_STATIC_LIB)
 INSTALL(TARGETS ${SHARED_TARGET} DESTINATION ${CMAKE_INSTALL_PREFIX}/lib/plugins)
 # Ensure that links to the main CUDA library will be resolved.
 IF (APPLE)
-    ENDIF (OPENMM_BUILD_SHARED_LIB)
+    IF (OPENMM_BUILD_SHARED_LIB)
         SET(CUDA_LIBRARY libOpenMMCUDA.dylib)
         INSTALL(CODE "EXECUTE_PROCESS(COMMAND install_name_tool -change ${CUDA_LIBRARY} @loader_path/${CUDA_LIBRARY} ${CMAKE_INSTALL_PREFIX}/lib/plugins/lib${SHARED_TARGET}.dylib)")
     ENDIF (OPENMM_BUILD_SHARED_LIB)
 ENDIF (APPLE)
+
+if(OPENMM_BUILD_CUDA_TESTS)
+    SUBDIRS (tests)
+endif(OPENMM_BUILD_CUDA_TESTS)

plugins/cudacompiler/src/CudaCompilerKernelFactory.cpp

@@ -29,15 +29,21 @@
 #include "internal/windowsExportCudaCompiler.h"
 #include "openmm/internal/ContextImpl.h"
 #include "openmm/OpenMMException.h"
-#include <cstdio>
+
 using namespace OpenMM;
 
 extern "C" OPENMM_EXPORT_CUDACOMPILER void registerKernelFactories() {
     try {
+        // Make sure this is at least CUDA 7.0.
+        
+        int driverVersion;
+        cuDriverGetVersion(&driverVersion);
+        if (driverVersion >= 7000) {
             Platform& platform = Platform::getPlatformByName("CUDA");
             CudaCompilerKernelFactory* factory = new CudaCompilerKernelFactory();
             platform.registerKernelFactory(CudaCompilerKernel::Name(), factory);
         }
+    }
     catch (std::exception ex) {
         // Ignore
     }

plugins/cudacompiler/tests/CMakeLists.txt

+#
+# Testing
+#
+
+ENABLE_TESTING()
+
+INCLUDE_DIRECTORIES(${CUDA_INCLUDE_DIR})
+
+# Automatically create tests using files named "Test*.cpp"
+FILE(GLOB TEST_PROGS "*Test*.cpp")
+FOREACH(TEST_PROG ${TEST_PROGS})
+    GET_FILENAME_COMPONENT(TEST_ROOT ${TEST_PROG} NAME_WE)
+
+    # Link with shared library
+    ADD_EXECUTABLE(${TEST_ROOT} ${TEST_PROG})
+    TARGET_LINK_LIBRARIES(${TEST_ROOT} ${SHARED_TARGET})
+    IF (APPLE)
+        SET_TARGET_PROPERTIES(${TEST_ROOT} PROPERTIES LINK_FLAGS "${EXTRA_COMPILE_FLAGS} -F/Library/Frameworks -framework CUDA" COMPILE_FLAGS "${EXTRA_COMPILE_FLAGS}")
+    ELSE (APPLE)
+        SET_TARGET_PROPERTIES(${TEST_ROOT} PROPERTIES LINK_FLAGS "${EXTRA_COMPILE_FLAGS}" COMPILE_FLAGS "${EXTRA_COMPILE_FLAGS}")
+    ENDIF (APPLE)
+    ADD_TEST(${TEST_ROOT} ${EXECUTABLE_OUTPUT_PATH}/${TEST_ROOT})
+
+ENDFOREACH(TEST_PROG ${TEST_PROGS})

plugins/cudacompiler/tests/TestCudaCompiler.cpp

+/* -------------------------------------------------------------------------- *
+ *                                   OpenMM                                   *
+ * -------------------------------------------------------------------------- *
+ * This is part of the OpenMM molecular simulation toolkit originating from   *
+ * Simbios, the NIH National Center for Physics-Based Simulation of           *
+ * Biological Structures at Stanford, funded under the NIH Roadmap for        *
+ * Medical Research, grant U54 GM072970. See https://simtk.org.               *
+ *                                                                            *
+ * Portions copyright (c) 2008-2015 Stanford University and the Authors.      *
+ * Authors: Peter Eastman                                                     *
+ * Contributors:                                                              *
+ *                                                                            *
+ * Permission is hereby granted, free of charge, to any person obtaining a    *
+ * copy of this software and associated documentation files (the "Software"), *
+ * to deal in the Software without restriction, including without limitation  *
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,   *
+ * and/or sell copies of the Software, and to permit persons to whom the      *
+ * Software is furnished to do so, subject to the following conditions:       *
+ *                                                                            *
+ * The above copyright notice and this permission notice shall be included in *
+ * all copies or substantial portions of the Software.                        *
+ *                                                                            *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR *
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,   *
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL    *
+ * THE AUTHORS, CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,    *
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR      *
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE  *
+ * USE OR OTHER DEALINGS IN THE SOFTWARE.                                     *
+ * -------------------------------------------------------------------------- */
+
+/**
+ * This tests using the CUDA runtime compiler plugin to compile kernels.
+ */
+
+#include "openmm/internal/AssertionUtilities.h"
+#include "openmm/Context.h"
+#include "CudaPlatform.h"
+#include "ReferencePlatform.h"
+#include "openmm/HarmonicBondForce.h"
+#include "openmm/NonbondedForce.h"
+#include "openmm/System.h"
+#include "openmm/LangevinIntegrator.h"
+#include "openmm/VerletIntegrator.h"
+#include "openmm/internal/ContextImpl.h"
+#include "CudaArray.h"
+#include "CudaNonbondedUtilities.h"
+#include "SimTKOpenMMRealType.h"
+#include "sfmt/SFMT.h"
+#include <iostream>
+#include <vector>
+
+using namespace OpenMM;
+using namespace std;
+
+CudaPlatform platform;
+
+extern "C" void registerCudaCompilerKernelFactories();
+
+/**
+ * A simple test taken from the NonbondedForce test suite.  Make sure it works as
+ * expected when using the runtime compiler.
+ */
+void testCoulomb() {
+    System system;
+    system.addParticle(1.0);
+    system.addParticle(1.0);
+    VerletIntegrator integrator(0.01);
+    NonbondedForce* forceField = new NonbondedForce();
+    forceField->addParticle(0.5, 1, 0);
+    forceField->addParticle(-1.5, 1, 0);
+    system.addForce(forceField);
+    Context context(system, integrator, platform);
+    vector<Vec3> positions(2);
+    positions[0] = Vec3(0, 0, 0);
+    positions[1] = Vec3(2, 0, 0);
+    context.setPositions(positions);
+    State state = context.getState(State::Forces | State::Energy);
+    const vector<Vec3>& forces = state.getForces();
+    double force = ONE_4PI_EPS0*(-0.75)/4.0;
+    ASSERT_EQUAL_VEC(Vec3(-force, 0, 0), forces[0], 1e-5);
+    ASSERT_EQUAL_VEC(Vec3(force, 0, 0), forces[1], 1e-5);
+    ASSERT_EQUAL_TOL(ONE_4PI_EPS0*(-0.75)/2.0, state.getPotentialEnergy(), 1e-5);
+}
+
+int main(int argc, char* argv[]) {
+    try {
+        Platform::registerPlatform(&platform);
+        registerCudaCompilerKernelFactories();
+        // Ensure that we won't use cached kernels.
+        platform.setPropertyDefaultValue(CudaPlatform::CudaTempDirectory(), "this does not exist");
+        testCoulomb();
+    }
+    catch(const exception& e) {
+        cout << "exception: " << e.what() << endl;
+        return 1;
+    }
+    cout << "Done" << endl;
+    return 0;
+}