Plugins work with CPU platform. This involved separating the reference...

Plugins work with CPU platform.  This involved separating the reference implementations of plugins into their own libraries.

plugins/drude/platforms/reference/tests/TestReferenceDrudeForce.cpp

@@ -47,6 +47,8 @@
 using namespace OpenMM;
 using namespace std;
 
+extern "C" OPENMM_EXPORT void registerDrudeReferenceKernelFactories();
+
 void validateForce(System& system, vector<Vec3>& positions, double expectedEnergy) {
     // Given a System containing a Drude force, check that its energy has the expected value.
     
@@ -193,6 +195,7 @@ void testChangingParameters() {
 
 int main() {
     try {
+        registerDrudeReferenceKernelFactories();
         testSingleParticle();
         testAnisotropicParticle();
         testThole();

plugins/drude/platforms/reference/tests/TestReferenceDrudeLangevinIntegrator.cpp

@@ -48,6 +48,8 @@
 using namespace OpenMM;
 using namespace std;
 
+extern "C" OPENMM_EXPORT void registerDrudeReferenceKernelFactories();
+
 void testSinglePair() {
     const double temperature = 300.0;
     const double temperatureDrude = 10.0;
@@ -174,6 +176,7 @@ void testWater() {
 
 int main() {
     try {
+        registerDrudeReferenceKernelFactories();
         testSinglePair();
         testWater();
     }

plugins/drude/platforms/reference/tests/TestReferenceDrudeSCFIntegrator.cpp

@@ -48,6 +48,8 @@
 using namespace OpenMM;
 using namespace std;
 
+extern "C" OPENMM_EXPORT void registerDrudeReferenceKernelFactories();
+
 void testWater() {
     // Create a box of SWM4-NDP water molecules.  This involves constraints, virtual sites,
     // and Drude particles.
@@ -126,6 +128,7 @@ void testWater() {
 
 int main() {
     try {
+        registerDrudeReferenceKernelFactories();
         testWater();
     }
     catch(const std::exception& e) {

plugins/rpmd/CMakeLists.txt

@@ -22,7 +22,7 @@ SET(CREATE_SERIALIZABLE_OPENMM_RPMD FALSE )
 
 # The source is organized into subdirectories, but we handle them all from
 # this CMakeLists file rather than letting CMake visit them as SUBDIRS.
-SET(OPENMM_RPMD_PLUGIN_SOURCE_SUBDIRS . openmmapi platforms/reference)
+SET(OPENMM_RPMD_PLUGIN_SOURCE_SUBDIRS . openmmapi)
 
 SET(OPENMM_RPMD_LIBRARY_NAME OpenMMRPMD)
 SET(SHARED_RPMD_TARGET ${OPENMM_RPMD_LIBRARY_NAME})
@@ -80,46 +80,18 @@ FOREACH(subdir ${OPENMM_RPMD_PLUGIN_SOURCE_SUBDIRS})
     INCLUDE_DIRECTORIES(BEFORE ${CMAKE_CURRENT_SOURCE_DIR}/${subdir}/include)
 ENDFOREACH(subdir)
 
-INCLUDE_DIRECTORIES(BEFORE ${OPENMM_DIR}/platforms/reference/src)
-INCLUDE_DIRECTORIES(BEFORE ${OPENMM_DIR}/platforms/reference/src/SimTKReference)
-INCLUDE_DIRECTORIES(BEFORE ${CMAKE_CURRENT_SOURCE_DIR}/platforms/reference/src)
-INCLUDE_DIRECTORIES(BEFORE ${CMAKE_CURRENT_SOURCE_DIR}/platforms/reference/src/SimTKReference)
-
 # ----------------------------------------------------------------------------
 
-# If API_RPMD wrappers are being generated, and add them to the build.
-#IF(OPENMM_BUILD_C_AND_FORTRAN_WRAPPERS)
-#    ADD_SUBDIRECTORY(wrappers)
-#    SET(SOURCE_RPMD_FILES ${SOURCE_RPMD_FILES} wrappers/RPMDOpenMMCWrapper.cpp  wrappers/RPMDOpenMMFortranWrapper.cpp)
-#    SET_SOURCE_FILES_PROPERTIES(wrappers/RPMDOpenMMCWrapper.cpp wrappers/RPMDOpenMMFortranWrapper.cpp PROPERTIES GENERATED TRUE)
-#ENDIF(OPENMM_BUILD_C_AND_FORTRAN_WRAPPERS)
-
 INCLUDE_DIRECTORIES(BEFORE ${CMAKE_CURRENT_SOURCE_DIR}/src)
 
 ADD_LIBRARY(${SHARED_RPMD_TARGET} SHARED ${SOURCE_RPMD_FILES} ${SOURCE_RPMD_INCLUDE_FILES} ${API_RPMD_ABS_INCLUDE_FILES})
 SET_TARGET_PROPERTIES(${SHARED_RPMD_TARGET} PROPERTIES LINK_FLAGS "${EXTRA_COMPILE_FLAGS}" COMPILE_FLAGS "${EXTRA_COMPILE_FLAGS} -DOPENMM_RPMD_BUILDING_SHARED_LIBRARY -DLEPTON_BUILDING_SHARED_LIBRARY")
 
-#IF( CREATE_SERIALIZABLE_OPENMM_RPMD )
-#    ADD_LIBRARY(${SHARED_RPMD_SERIALIZABLE_TARGET} SHARED ${SOURCE_RPMD_FILES} ${SOURCE_RPMD_INCLUDE_FILES} ${API_RPMD_ABS_INCLUDE_FILES})
-#    SET_TARGET_PROPERTIES(${SHARED_RPMD_SERIALIZABLE_TARGET} PROPERTIES COMPILE_FLAGS "-DOPENMM_RPMD_BUILDING_SHARED_LIBRARY -DLEPTON_BUILDING_SHARED_LIBRARY -DOPENMM_SERIALIZE")
-#    INCLUDE_DIRECTORIES(BEFORE ${CMAKE_CURRENT_SOURCE_DIR}/../../serialization/include)
-#ENDIF( CREATE_SERIALIZABLE_OPENMM_RPMD )
-
 IF(OPENMM_BUILD_STATIC_LIB)
   ADD_LIBRARY(${STATIC_RPMD_TARGET} STATIC ${SOURCE_RPMD_FILES} ${SOURCE_RPMD_INCLUDE_FILES} ${API_RPMD_ABS_INCLUDE_FILES})
   SET_TARGET_PROPERTIES(${STATIC_RPMD_TARGET} PROPERTIES LINK_FLAGS "${EXTRA_COMPILE_FLAGS}" COMPILE_FLAGS "${EXTRA_COMPILE_FLAGS} -DOPENMM_USE_STATIC_LIBRARIES -DOPENMM_BUILDING_STATIC_LIBRARY -DLEPTON_USE_STATIC_LIBRARIES -DLEPTON_BUILDING_STATIC_LIBRARY")
 ENDIF(OPENMM_BUILD_STATIC_LIB)
 
-#IF(OPENMM_BUILD_C_AND_FORTRAN_WRAPPERS)
-#    ADD_DEPENDENCIES(${SHARED_RPMD_TARGET} RPMDApiWrappers)
-#    IF( CREATE_SERIALIZABLE_OPENMM_RPMD )
-#        ADD_DEPENDENCIES(${SHARED_RPMD_SERIALIZABLE_TARGET} RPMDApiWrappers)
-#    ENDIF( CREATE_SERIALIZABLE_OPENMM_RPMD )
-#    IF(OPENMM_BUILD_STATIC_LIB)
-#        ADD_DEPENDENCIES(${STATIC_RPMD_TARGET} RPMDApiWrappers)
-#    ENDIF(OPENMM_BUILD_STATIC_LIB)
-#ENDIF(OPENMM_BUILD_C_AND_FORTRAN_WRAPPERS)
-
 # ----------------------------------------------------------------------------
 
 # On Linux need to link to libdl
@@ -148,18 +120,9 @@ IF(OPENMM_BUILD_STATIC_LIB)
     TARGET_LINK_LIBRARIES( ${STATIC_RPMD_TARGET} ${STATIC_TARGET} )
 ENDIF(OPENMM_BUILD_STATIC_LIB)
 
-ADD_SUBDIRECTORY(platforms/reference/tests)
-
 # Which hardware platforms to build
 
-#SET(OPENMM_BUILD_RPMD_PATH)
-#SET(OPENMM_BUILD_RPMD_CUDA_PATH)
-#IF(OPENMM_BUILD_RPMD_CUDA_LIB)
-#    ADD_SUBDIRECTORY(platforms/cuda)
-#    SET(OPENMM_BUILD_RPMD_PATH ${CMAKE_CURRENT_SOURCE_DIR}/platforms/cuda)
-#    SET(OPENMM_BUILD_RPMD_CUDA_PATH ${CMAKE_CURRENT_SOURCE_DIR}/platforms/cuda)
-#    SET(OPENMM_RPMD_CUDA_SOURCE_SUBDIRS . openmmapi olla platforms/cuda)
-#ENDIF(OPENMM_BUILD_RPMD_CUDA_LIB)
+ADD_SUBDIRECTORY(platforms/reference)
 
 IF(OPENCL_FOUND)
     SET(OPENMM_BUILD_RPMD_OPENCL_LIB ON CACHE BOOL "Build RPMD implementation for OpenCL")
@@ -208,7 +171,3 @@ ENDIF (EXECUTABLE_OUTPUT_PATH)
 #IF (OPENMM_BUILD_SERIALIZATION_SUPPORT)
 #    ADD_SUBDIRECTORY(serialization)
 #ENDIF (OPENMM_BUILD_SERIALIZATION_SUPPORT)
-
-#INCLUDE(ApiDoxygen.cmake)
-
-#ADD_SUBDIRECTORY(tests)

plugins/rpmd/platforms/reference/CMakeLists.txt

+#---------------------------------------------------
+# OpenMM Reference RPMD Integrator
+#
+# Creates OpenMM library, base name=OpenMMRPMDReference.
+# Default libraries are shared & optimized. Variants
+# are created for debug (_d).
+#
+# Windows:
+#   OpenMMRPMDReference[_d].dll
+#   OpenMMRPMDReference[_d].lib
+# Unix:
+#   libOpenMMRPMDReference[_d].so
+#----------------------------------------------------
+
+# The source is organized into subdirectories, but we handle them all from
+# this CMakeLists file rather than letting CMake visit them as SUBDIRS.
+SET(OPENMM_SOURCE_SUBDIRS .)
+
+
+# Collect up information about the version of the OpenMM library we're building
+# and make it available to the code so it can be built into the binaries.
+
+SET(OPENMMRPMDREFERENCE_LIBRARY_NAME OpenMMRPMDReference)
+
+SET(SHARED_TARGET ${OPENMMRPMDREFERENCE_LIBRARY_NAME})
+
+
+# Ensure that debug libraries have "_d" appended to their names.
+# CMake gets this right on Windows automatically with this definition.
+IF (${CMAKE_GENERATOR} MATCHES "Visual Studio")
+    SET(CMAKE_DEBUG_POSTFIX "_d" CACHE INTERNAL "" FORCE)
+ENDIF (${CMAKE_GENERATOR} MATCHES "Visual Studio")
+
+# But on Unix or Cygwin we have to add the suffix manually
+IF (UNIX AND CMAKE_BUILD_TYPE MATCHES Debug)
+    SET(SHARED_TARGET ${SHARED_TARGET}_d)
+ENDIF (UNIX AND CMAKE_BUILD_TYPE MATCHES Debug)
+
+
+# These are all the places to search for header files which are
+# to be part of the API.
+SET(API_INCLUDE_DIRS) # start empty
+FOREACH(subdir ${OPENMM_SOURCE_SUBDIRS})
+    # append
+    SET(API_INCLUDE_DIRS ${API_INCLUDE_DIRS}
+                         ${CMAKE_CURRENT_SOURCE_DIR}/${subdir}/include
+                         ${CMAKE_CURRENT_SOURCE_DIR}/${subdir}/include/internal)
+ENDFOREACH(subdir)
+
+# We'll need both *relative* path names, starting with their API_INCLUDE_DIRS,
+# and absolute pathnames.
+SET(API_REL_INCLUDE_FILES)   # start these out empty
+SET(API_ABS_INCLUDE_FILES)
+
+FOREACH(dir ${API_INCLUDE_DIRS})
+    FILE(GLOB fullpaths ${dir}/*.h)	# returns full pathnames
+    SET(API_ABS_INCLUDE_FILES ${API_ABS_INCLUDE_FILES} ${fullpaths})
+
+    FOREACH(pathname ${fullpaths})
+        GET_FILENAME_COMPONENT(filename ${pathname} NAME)
+        SET(API_REL_INCLUDE_FILES ${API_REL_INCLUDE_FILES} ${dir}/${filename})
+    ENDFOREACH(pathname)
+ENDFOREACH(dir)
+
+# collect up source files
+SET(SOURCE_FILES) # empty
+SET(SOURCE_INCLUDE_FILES)
+
+FOREACH(subdir ${OPENMM_SOURCE_SUBDIRS})
+    FILE(GLOB_RECURSE src_files  ${CMAKE_CURRENT_SOURCE_DIR}/${subdir}/src/*.cpp ${CMAKE_CURRENT_SOURCE_DIR}/${subdir}/src/*.c)
+    FILE(GLOB incl_files ${CMAKE_CURRENT_SOURCE_DIR}/${subdir}/src/*.h)
+    SET(SOURCE_FILES         ${SOURCE_FILES}         ${src_files})   #append
+    SET(SOURCE_INCLUDE_FILES ${SOURCE_INCLUDE_FILES} ${incl_files})
+    INCLUDE_DIRECTORIES(BEFORE ${CMAKE_CURRENT_SOURCE_DIR}/${subdir}/include)
+ENDFOREACH(subdir)
+
+INCLUDE_DIRECTORIES(BEFORE ${CMAKE_CURRENT_SOURCE_DIR}/src)
+INCLUDE_DIRECTORIES(BEFORE ${CMAKE_SOURCE_DIR}/platforms/reference/include)
+INCLUDE_DIRECTORIES(BEFORE ${CMAKE_SOURCE_DIR}/platforms/reference/src)
+
+# Create the library
+
+INCLUDE_DIRECTORIES(${REFERENCE_INCLUDE_DIR})
+
+ADD_LIBRARY(${SHARED_TARGET} SHARED ${SOURCE_FILES} ${SOURCE_INCLUDE_FILES} ${API_ABS_INCLUDE_FILES})
+
+IF (UNIX AND CMAKE_BUILD_TYPE MATCHES Debug)
+    SET(MAIN_OPENMM_LIB ${OPENMM_LIBRARY_NAME}_d)
+ELSE (UNIX AND CMAKE_BUILD_TYPE MATCHES Debug)
+    SET(MAIN_OPENMM_LIB ${OPENMM_LIBRARY_NAME})
+ENDIF (UNIX AND CMAKE_BUILD_TYPE MATCHES Debug)
+TARGET_LINK_LIBRARIES(${SHARED_TARGET} ${MAIN_OPENMM_LIB})
+TARGET_LINK_LIBRARIES(${SHARED_TARGET} debug ${SHARED_RPMD_TARGET} optimized ${SHARED_RPMD_TARGET})
+SET_TARGET_PROPERTIES(${SHARED_TARGET} PROPERTIES LINK_FLAGS "${EXTRA_COMPILE_FLAGS}" COMPILE_FLAGS "${EXTRA_COMPILE_FLAGS} -msse2 -DOPENMM_BUILDING_SHARED_LIBRARY")
+
+INSTALL(TARGETS ${SHARED_TARGET} DESTINATION ${CMAKE_INSTALL_PREFIX}/lib/plugins)
+SUBDIRS (tests)

plugins/rpmd/platforms/reference/src/ReferenceRpmdKernelFactory.cpp

@@ -32,22 +32,21 @@
 
 using namespace OpenMM;
 
-#if defined(WIN32)
-    #include <windows.h>
-    extern "C" void initRpmdReferenceKernels();
-    BOOL WINAPI DllMain(HANDLE hModule, DWORD  ul_reason_for_call, LPVOID lpReserved) {
-        if (ul_reason_for_call == DLL_PROCESS_ATTACH)
-            initRpmdReferenceKernels();
-        return TRUE;
+extern "C" OPENMM_EXPORT void registerPlatforms() {
+}
+
+extern "C" OPENMM_EXPORT void registerKernelFactories() {
+    for (int i = 0; i < Platform::getNumPlatforms(); i++) {
+        Platform& platform = Platform::getPlatform(i);
+        if (dynamic_cast<ReferencePlatform*>(&platform) != NULL) {
+            ReferenceRpmdKernelFactory* factory = new ReferenceRpmdKernelFactory();
+            platform.registerKernelFactory(IntegrateRPMDStepKernel::Name(), factory);
+        }
     }
-#else
-    extern "C" void __attribute__((constructor)) initRpmdReferenceKernels();
-#endif
+}
 
-extern "C" void initRpmdReferenceKernels() {
-    Platform& platform = Platform::getPlatformByName("Reference");
-    ReferenceRpmdKernelFactory* factory = new ReferenceRpmdKernelFactory();
-    platform.registerKernelFactory(IntegrateRPMDStepKernel::Name(), factory);
+extern "C" OPENMM_EXPORT void registerRpmdReferenceKernelFactories() {
+    registerKernelFactories();
 }
 
 KernelImpl* ReferenceRpmdKernelFactory::createKernelImpl(std::string name, const Platform& platform, ContextImpl& context) const {

plugins/rpmd/platforms/reference/tests/CMakeLists.txt

@@ -2,11 +2,9 @@
 # Testing
 #
 ENABLE_TESTING()
-#INCLUDE_DIRECTORIES(${CUDA_INCLUDE})
 INCLUDE_DIRECTORIES(${OPENMM_DIR}/platforms/reference/include)
 INCLUDE_DIRECTORIES(${OPENMM_DIR}/openmmapi/include/openmm)
 INCLUDE_DIRECTORIES(${OPENMM_DIR}/platforms/reference/src)
-#INCLUDE_DIRECTORIES(${OPENMM_DIR}/platforms/reference/src/kernels)
 
 SET(SHARED_OPENMM_RPMD_TARGET OpenMMRPMD)
 

plugins/rpmd/platforms/reference/tests/TestReferenceRpmd.cpp

@@ -51,6 +51,8 @@
 using namespace OpenMM;
 using namespace std;
 
+extern "C" OPENMM_EXPORT void registerRpmdReferenceKernelFactories();
+
 void testFreeParticles() {
     const int numParticles = 100;
     const int numCopies = 30;
@@ -455,6 +457,7 @@ void testWithBarostat() {
 
 int main() {
     try {
+        registerRpmdReferenceKernelFactories();
         testFreeParticles();
         testCMMotionRemoval();
         testVirtualSites();