Replace pthreads with C++ threads (#4833)

* Replace pthreads with C++ threads

* Try to fix CI errors

* Try including -pthread linker option

CMakeLists.txt

@@ -94,15 +94,6 @@ SET(OPENMM_SOURCE_SUBDIRS . openmmapi olla libraries/jama libraries/quern librar
 IF(X86 OR ARM)
     SET(OPENMM_SOURCE_SUBDIRS ${OPENMM_SOURCE_SUBDIRS} libraries/vecmath)
 ENDIF()
-IF(WIN32)
-    SET(OPENMM_SOURCE_SUBDIRS ${OPENMM_SOURCE_SUBDIRS} libraries/pthreads)
-ELSE(WIN32)
-    IF (NOT ANDROID)
-        SET(PTHREADS_LIB pthread)
-        # in linux, even in static builds we link against the dynamic object (since its tied to libc versions)
-        SET(PTHREADS_LIB_STATIC pthread)
-    ENDIF (NOT ANDROID)
-ENDIF(WIN32)
 
 SET (CMAKE_CXX_STANDARD 11)
 
@@ -136,9 +127,9 @@ ELSEIF(MSVC)
     # Explicitly suppress warnings 4305 and 4244.
     SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /wd4305 /wd4244")
 ELSEIF(X86)
-    SET(EXTRA_COMPILE_FLAGS "-msse2")
+    SET(EXTRA_COMPILE_FLAGS "-msse2 -pthread")
 ELSE()
-    SET(EXTRA_COMPILE_FLAGS)
+    SET(EXTRA_COMPILE_FLAGS "-pthread")
 ENDIF()
 
 IF(UNIX AND NOT CMAKE_BUILD_TYPE)
@@ -281,13 +272,13 @@ ENDIF (MSVC)
 
 IF(OPENMM_BUILD_SHARED_LIB)
     ADD_LIBRARY(${SHARED_TARGET} SHARED ${SOURCE_FILES} ${SOURCE_INCLUDE_FILES} ${API_ABS_INCLUDE_FILES})
-    SET_TARGET_PROPERTIES(${SHARED_TARGET} PROPERTIES LINK_FLAGS "${EXTRA_LINK_FLAGS}" COMPILE_FLAGS "${EXTRA_COMPILE_FLAGS} -DOPENMM_BUILDING_SHARED_LIBRARY -DLEPTON_BUILDING_SHARED_LIBRARY -DPTHREAD_BUILDING_SHARED_LIBRARY")
+    SET_TARGET_PROPERTIES(${SHARED_TARGET} PROPERTIES LINK_FLAGS "${EXTRA_LINK_FLAGS}" COMPILE_FLAGS "${EXTRA_COMPILE_FLAGS} -DOPENMM_BUILDING_SHARED_LIBRARY -DLEPTON_BUILDING_SHARED_LIBRARY")
 ENDIF(OPENMM_BUILD_SHARED_LIB)
 
 IF(OPENMM_BUILD_STATIC_LIB)
     ADD_LIBRARY(${STATIC_TARGET} STATIC ${SOURCE_FILES} ${SOURCE_INCLUDE_FILES} ${API_ABS_INCLUDE_FILES})
     SET(EXTRA_COMPILE_FLAGS "${EXTRA_COMPILE_FLAGS} -DOPENMM_USE_STATIC_LIBRARIES -DLEPTON_USE_STATIC_LIBRARIES -DPTW32_STATIC_LIB")
-    SET_TARGET_PROPERTIES(${STATIC_TARGET} PROPERTIES LINK_FLAGS "${EXTRA_LINK_FLAGS}" COMPILE_FLAGS "${EXTRA_COMPILE_FLAGS} -DOPENMM_BUILDING_STATIC_LIBRARY -DLEPTON_BUILDING_STATIC_LIBRARY -DPTHREAD_BUILDING_STATIC_LIBRARY")
+    SET_TARGET_PROPERTIES(${STATIC_TARGET} PROPERTIES LINK_FLAGS "${EXTRA_LINK_FLAGS}" COMPILE_FLAGS "${EXTRA_COMPILE_FLAGS} -DOPENMM_BUILDING_STATIC_LIBRARY -DLEPTON_BUILDING_STATIC_LIBRARY")
 ENDIF(OPENMM_BUILD_STATIC_LIB)
 
 IF(OPENMM_BUILD_C_AND_FORTRAN_WRAPPERS)
@@ -302,18 +293,18 @@ IF(NOT APPLE)
     FIND_LIBRARY(DL_LIBRARY dl)
     IF(DL_LIBRARY)
         IF(OPENMM_BUILD_SHARED_LIB)
-            TARGET_LINK_LIBRARIES(${SHARED_TARGET} ${DL_LIBRARY} ${PTHREADS_LIB})
+            TARGET_LINK_LIBRARIES(${SHARED_TARGET} ${DL_LIBRARY})
         ENDIF(OPENMM_BUILD_SHARED_LIB)
         IF(OPENMM_BUILD_STATIC_LIB)
-            TARGET_LINK_LIBRARIES(${STATIC_TARGET} ${DL_LIBRARY} ${PTHREADS_LIB})
+            TARGET_LINK_LIBRARIES(${STATIC_TARGET} ${DL_LIBRARY})
         ENDIF(OPENMM_BUILD_STATIC_LIB)
         MARK_AS_ADVANCED(DL_LIBRARY)
     ELSE(DL_LIBRARY)
         IF(OPENMM_BUILD_SHARED_LIB)
             IF (ANDROID)
-                TARGET_LINK_LIBRARIES(${SHARED_TARGET} ${PTHREADS_LIB} cpufeatures)
+                TARGET_LINK_LIBRARIES(${SHARED_TARGET} cpufeatures)
             ELSE (ANDROID)
-                TARGET_LINK_LIBRARIES(${SHARED_TARGET} ${PTHREADS_LIB})
+                TARGET_LINK_LIBRARIES(${SHARED_TARGET})
             ENDIF (ANDROID)
         ENDIF(OPENMM_BUILD_SHARED_LIB)
     ENDIF(DL_LIBRARY)

libraries/pthreads/src/pthread.cpp

-#include "pthread.h"
-
-PTHREAD_EXPORT volatile long _pthread_cancelling;
-
-PTHREAD_EXPORT int _pthread_concur;
-
-/* Will default to zero as needed */
-PTHREAD_EXPORT pthread_once_t _pthread_tls_once;
-PTHREAD_EXPORT DWORD _pthread_tls;
-
-/* Note initializer is zero, so this works */
-PTHREAD_EXPORT pthread_rwlock_t _pthread_key_lock;
-PTHREAD_EXPORT long _pthread_key_max;
-PTHREAD_EXPORT long _pthread_key_sch;
-PTHREAD_EXPORT void (**_pthread_key_dest)(void *);

openmmapi/include/openmm/internal/ThreadPool.h

@@ -9,7 +9,7 @@
  * Biological Structures at Stanford, funded under the NIH Roadmap for        *
  * Medical Research, grant U54 GM072970. See https://simtk.org.               *
  *                                                                            *
- * Portions copyright (c) 2013-2017 Stanford University and the Authors.      *
+ * Portions copyright (c) 2013-2025 Stanford University and the Authors.      *
  * Authors: Peter Eastman                                                     *
  * Contributors:                                                              *
  *                                                                            *
@@ -34,8 +34,10 @@
 
 #define NOMINMAX
 #include "windowsExport.h"
+#include <condition_variable>
 #include <functional>
-#include <pthread.h>
+#include <mutex>
+#include <thread>
 #include <vector>
 
 namespace OpenMM {
@@ -91,10 +93,10 @@ public:
 private:
     bool isDeleted;
     int numThreads, waitCount;
-    std::vector<pthread_t> thread;
+    std::vector<std::thread> threads;
     std::vector<ThreadData*> threadData;
-    pthread_cond_t startCondition, endCondition;
-    pthread_mutex_t lock;
+    std::condition_variable startCondition, endCondition;
+    std::mutex lock;
     Task* currentTask;
     std::function<void (ThreadPool& pool, int)> currentFunction;
 };

openmmapi/src/ThreadPool.cpp

@@ -6,7 +6,7 @@
  * Biological Structures at Stanford, funded under the NIH Roadmap for        *
  * Medical Research, grant U54 GM072970. See https://simtk.org.               *
  *                                                                            *
- * Portions copyright (c) 2013-2017 Stanford University and the Authors.      *
+ * Portions copyright (c) 2013-2025 Stanford University and the Authors.      *
  * Authors: Peter Eastman                                                     *
  * Contributors:                                                              *
  *                                                                            *
@@ -57,7 +57,7 @@ static void* threadBody(void* args) {
     ThreadPool::ThreadData& data = *reinterpret_cast<ThreadPool::ThreadData*>(args);
     while (true) {
         // Wait for the signal to start running.
-        
+
         data.owner.syncThreads();
         if (data.isDeleted)
             break;
@@ -71,34 +71,26 @@ ThreadPool::ThreadPool(int numThreads) : currentTask(NULL) {
     if (numThreads <= 0)
         numThreads = getNumProcessors();
     this->numThreads = numThreads;
-    pthread_cond_init(&startCondition, NULL);
-    pthread_cond_init(&endCondition, NULL);
-    pthread_mutex_init(&lock, NULL);
-    thread.resize(numThreads);
-    pthread_mutex_lock(&lock);
+    unique_lock<mutex> ul(lock);
     waitCount = 0;
     for (int i = 0; i < numThreads; i++) {
         ThreadData* data = new ThreadData(*this, i);
         data->isDeleted = false;
         threadData.push_back(data);
-        pthread_create(&thread[i], NULL, threadBody, data);
+        threads.push_back(thread(threadBody, data));
     }
     while (waitCount < numThreads)
-        pthread_cond_wait(&endCondition, &lock);
-    pthread_mutex_unlock(&lock);
+        endCondition.wait(ul);
 }
 
 ThreadPool::~ThreadPool() {
     for (auto data : threadData)
         data->isDeleted = true;
-    pthread_mutex_lock(&lock);
-    pthread_cond_broadcast(&startCondition);
-    pthread_mutex_unlock(&lock);
-    for (auto t : thread)
-        pthread_join(t, NULL);
-    pthread_mutex_destroy(&lock);
-    pthread_cond_destroy(&startCondition);
-    pthread_cond_destroy(&endCondition);
+    lock.lock();
+    startCondition.notify_all();
+    lock.unlock();
+    for (auto &t : threads)
+        t.join();
 }
 
 int ThreadPool::getNumThreads() const {
@@ -117,25 +109,22 @@ void ThreadPool::execute(function<void (ThreadPool&, int)> task) {
 }
 
 void ThreadPool::syncThreads() {
-    pthread_mutex_lock(&lock);
+    unique_lock<mutex> ul(lock);
     waitCount++;
-    pthread_cond_signal(&endCondition);
-    pthread_cond_wait(&startCondition, &lock);
-    pthread_mutex_unlock(&lock);
+    endCondition.notify_one();
+    startCondition.wait(ul);
 }
 
 void ThreadPool::waitForThreads() {
-    pthread_mutex_lock(&lock);
+    unique_lock<mutex> ul(lock);
     while (waitCount < numThreads)
-        pthread_cond_wait(&endCondition, &lock);
-    pthread_mutex_unlock(&lock);
+        endCondition.wait(ul);
 }
 
 void ThreadPool::resumeThreads() {
-    pthread_mutex_lock(&lock);
+    unique_lock<mutex> ul(lock);
     waitCount = 0;
-    pthread_cond_broadcast(&startCondition);
-    pthread_mutex_unlock(&lock);
+    startCondition.notify_all();
 }
 
 } // namespace OpenMM

platforms/common/include/openmm/common/ComputeContext.h

@@ -9,7 +9,7 @@
  * Biological Structures at Stanford, funded under the NIH Roadmap for        *
  * Medical Research, grant U54 GM072970. See https://simtk.org.               *
  *                                                                            *
- * Portions copyright (c) 2019-2024 Stanford University and the Authors.      *
+ * Portions copyright (c) 2019-2025 Stanford University and the Authors.      *
  * Authors: Peter Eastman                                                     *
  * Contributors:                                                              *
  *                                                                            *
@@ -40,10 +40,12 @@
 #include "openmm/common/IntegrationUtilities.h"
 #include "openmm/common/NonbondedUtilities.h"
 #include "openmm/Vec3.h"
-#include <pthread.h>
+#include <condition_variable>
 #include <map>
+#include <mutex>
 #include <queue>
 #include <string>
+#include <thread>
 #include <vector>
 
 namespace OpenMM {
@@ -485,7 +487,7 @@ public:
      * Get the thread used by this context for executing parallel computations.
      */
     WorkThread& getWorkThread() {
-        return *thread;
+        return *workThread;
     }
     /**
      * Get the names of all parameters with respect to which energy derivatives are computed.
@@ -555,7 +557,7 @@ protected:
     std::vector<ReorderListener*> reorderListeners;
     std::vector<ForcePreComputation*> preComputations;
     std::vector<ForcePostComputation*> postComputations;
-    WorkThread* thread;
+    WorkThread* workThread;
 };
 
 struct ComputeContext::Molecule {
@@ -610,9 +612,9 @@ private:
     std::queue<ComputeContext::WorkTask*> tasks;
     bool waiting, finished, threwException;
     OpenMMException stashedException;
-    pthread_mutex_t queueLock;
-    pthread_cond_t waitForTaskCondition, queueEmptyCondition;
-    pthread_t thread;
+    std::mutex queueLock;
+    std::condition_variable waitForTaskCondition, queueEmptyCondition;
+    std::thread workThread;
 };
 
 /**

platforms/common/src/ComputeContext.cpp

@@ -45,13 +45,11 @@ const int ComputeContext::ThreadBlockSize = 64;
 const int ComputeContext::TileSize = 32;
 
 ComputeContext::ComputeContext(const System& system) : system(system), time(0.0), stepCount(0), computeForceCount(0), stepsSinceReorder(99999),
-        forceNextReorder(false), atomsWereReordered(false), forcesValid(false), thread(NULL) {
-    thread = new WorkThread();
+        forceNextReorder(false), atomsWereReordered(false), forcesValid(false) {
+    workThread = new WorkThread();
 }
 
 ComputeContext::~ComputeContext() {
-    if (thread != NULL)
-        delete thread;
 }
 
 void ComputeContext::addForce(ComputeForceInfo* force) {
@@ -700,7 +698,7 @@ int ComputeContext::findLegalFFTDimension(int minimum) {
 
 struct ComputeContext::WorkThread::ThreadData {
     ThreadData(std::queue<ComputeContext::WorkTask*>& tasks, bool& waiting,  bool& finished, bool& threwException, OpenMMException& stashedException,
-            pthread_mutex_t& queueLock, pthread_cond_t& waitForTaskCondition, pthread_cond_t& queueEmptyCondition) :
+            mutex& queueLock, condition_variable& waitForTaskCondition, condition_variable& queueEmptyCondition) :
         tasks(tasks), waiting(waiting), finished(finished), threwException(threwException), stashedException(stashedException),
         queueLock(queueLock), waitForTaskCondition(waitForTaskCondition), queueEmptyCondition(queueEmptyCondition) {
     }
@@ -709,32 +707,33 @@ struct ComputeContext::WorkThread::ThreadData {
     bool& finished;
     bool& threwException;
     OpenMMException& stashedException;
-    pthread_mutex_t& queueLock;
-    pthread_cond_t& waitForTaskCondition;
-    pthread_cond_t& queueEmptyCondition;
+    mutex& queueLock;
+    condition_variable& waitForTaskCondition;
+    condition_variable& queueEmptyCondition;
 };
 
 static void* threadBody(void* args) {
     ComputeContext::WorkThread::ThreadData& data = *reinterpret_cast<ComputeContext::WorkThread::ThreadData*>(args);
     while (!data.finished || data.tasks.size() > 0) {
-        pthread_mutex_lock(&data.queueLock);
-        while (data.tasks.empty() && !data.finished) {
-            data.waiting = true;
-            pthread_cond_signal(&data.queueEmptyCondition);
-            pthread_cond_wait(&data.waitForTaskCondition, &data.queueLock);
-        }
-        // If we keep going after having caught an exception once, next tasks will likely throw too and we don't want the initial exception overshadowed.
-        while (data.threwException && !data.tasks.empty()) {
-            delete data.tasks.front();
-            data.tasks.pop();
-        }
         ComputeContext::WorkTask* task = NULL;
-        if (!data.tasks.empty()) {
-            data.waiting = false;
-            task = data.tasks.front();
-            data.tasks.pop();
+        {
+            unique_lock<mutex> lock(data.queueLock);
+            while (data.tasks.empty() && !data.finished) {
+                data.waiting = true;
+                data.queueEmptyCondition.notify_one();
+                data.waitForTaskCondition.wait(lock);
+            }
+            // If we keep going after having caught an exception once, next tasks will likely throw too and we don't want the initial exception overshadowed.
+            while (data.threwException && !data.tasks.empty()) {
+                delete data.tasks.front();
+                data.tasks.pop();
+            }
+            if (!data.tasks.empty()) {
+                data.waiting = false;
+                task = data.tasks.front();
+                data.tasks.pop();
+            }
         }
-        pthread_mutex_unlock(&data.queueLock);
         if (task != NULL) {
             try {
                 task->execute();
@@ -747,36 +746,29 @@ static void* threadBody(void* args) {
         }
     }
     data.waiting = true;
-    pthread_cond_signal(&data.queueEmptyCondition);
+    data.queueEmptyCondition.notify_one();
     delete &data;
     return 0;
 }
 
 ComputeContext::WorkThread::WorkThread() : waiting(true), finished(false), threwException(false), stashedException("Default WorkThread exception. This should never be thrown.") {
-    pthread_mutex_init(&queueLock, NULL);
-    pthread_cond_init(&waitForTaskCondition, NULL);
-    pthread_cond_init(&queueEmptyCondition, NULL);
     ThreadData* data = new ThreadData(tasks, waiting, finished, threwException, stashedException, queueLock, waitForTaskCondition, queueEmptyCondition);
-    pthread_create(&thread, NULL, threadBody, data);
+    workThread = thread(threadBody, data);
 }
 
 ComputeContext::WorkThread::~WorkThread() {
-    pthread_mutex_lock(&queueLock);
+    queueLock.lock();
     finished = true;
-    pthread_cond_broadcast(&waitForTaskCondition);
-    pthread_mutex_unlock(&queueLock);
-    pthread_join(thread, NULL);
-    pthread_mutex_destroy(&queueLock);
-    pthread_cond_destroy(&waitForTaskCondition);
-    pthread_cond_destroy(&queueEmptyCondition);
+    waitForTaskCondition.notify_all();
+    queueLock.unlock();
+    workThread.join();
 }
 
 void ComputeContext::WorkThread::addTask(ComputeContext::WorkTask* task) {
-    pthread_mutex_lock(&queueLock);
+    unique_lock<mutex> lock(queueLock);
     tasks.push(task);
     waiting = false;
-    pthread_cond_signal(&waitForTaskCondition);
-    pthread_mutex_unlock(&queueLock);
+    waitForTaskCondition.notify_one();
 }
 
 bool ComputeContext::WorkThread::isWaiting() {
@@ -788,14 +780,15 @@ bool ComputeContext::WorkThread::isFinished() {
 }
 
 bool ComputeContext::WorkThread::isCurrentThread() {
-    return (pthread_self() == thread);
+    return (this_thread::get_id() == workThread.get_id());
 }
 
 void ComputeContext::WorkThread::flush() {
-    pthread_mutex_lock(&queueLock);
-    while (!waiting)
-       pthread_cond_wait(&queueEmptyCondition, &queueLock);
-    pthread_mutex_unlock(&queueLock);
+    {
+        unique_lock<mutex> lock(queueLock);
+        while (!waiting)
+            queueEmptyCondition.wait(lock);
+    }
     if (threwException) {
         threwException = false;
         throw stashedException;

platforms/cpu/sharedTarget/CMakeLists.txt

@@ -17,7 +17,7 @@ ENDIF()
 
 ADD_LIBRARY(${SHARED_TARGET} SHARED ${SOURCE_FILES} ${SOURCE_INCLUDE_FILES} ${API_ABS_INCLUDE_FILES})
 
-TARGET_LINK_LIBRARIES(${SHARED_TARGET} ${OPENMM_LIBRARY_NAME} ${PTHREADS_LIB})
+TARGET_LINK_LIBRARIES(${SHARED_TARGET} ${OPENMM_LIBRARY_NAME})
 SET_TARGET_PROPERTIES(${SHARED_TARGET} PROPERTIES LINK_FLAGS "${EXTRA_LINK_FLAGS}" COMPILE_FLAGS "${EXTRA_COMPILE_FLAGS} -DOPENMM_CPU_BUILDING_SHARED_LIBRARY")
 
 INSTALL_TARGETS(/lib/plugins RUNTIME_DIRECTORY /lib/plugins ${SHARED_TARGET})

platforms/cpu/staticTarget/CMakeLists.txt

@@ -15,7 +15,7 @@ FOREACH(file ${SOURCE_FILES})
 ENDFOREACH(file)
 ADD_LIBRARY(${STATIC_TARGET} STATIC ${SOURCE_FILES} ${SOURCE_INCLUDE_FILES} ${API_ABS_INCLUDE_FILES})
 
-TARGET_LINK_LIBRARIES(${STATIC_TARGET} ${OPENMM_LIBRARY_NAME}_static ${PTHREADS_LIB_STATIC})
+TARGET_LINK_LIBRARIES(${STATIC_TARGET} ${OPENMM_LIBRARY_NAME}_static)
 SET_TARGET_PROPERTIES(${STATIC_TARGET} PROPERTIES LINK_FLAGS "${EXTRA_LINK_FLAGS}" COMPILE_FLAGS "${EXTRA_COMPILE_FLAGS} -DOPENMM_CPU_BUILDING_STATIC_LIBRARY")
 
 INSTALL_TARGETS(/lib/plugins RUNTIME_DIRECTORY /lib/plugins ${STATIC_TARGET})

platforms/cuda/include/CudaContext.h

@@ -35,7 +35,6 @@
     // Prevent Windows from defining macros that interfere with other code.
     #define NOMINMAX
 #endif
-#include <pthread.h>
 #include <cuda.h>
 #include <builtin_types.h>
 #include <vector_functions.h>

platforms/cuda/sharedTarget/CMakeLists.txt

@@ -14,7 +14,7 @@ ADD_LIBRARY(${SHARED_TARGET} SHARED ${SOURCE_FILES} ${SOURCE_INCLUDE_FILES} ${AP
 ADD_DEPENDENCIES(${SHARED_TARGET} CommonKernels)
 
 FIND_LIBRARY(NVRTC_LIB nvrtc PATHS "${CUDAToolkit_LIBRARY_DIR}")
-TARGET_LINK_LIBRARIES(${SHARED_TARGET} ${OPENMM_LIBRARY_NAME} CUDA::cuda_driver CUDA::cufft ${NVRTC_LIB} ${PTHREADS_LIB})
+TARGET_LINK_LIBRARIES(${SHARED_TARGET} ${OPENMM_LIBRARY_NAME} CUDA::cuda_driver CUDA::cufft ${NVRTC_LIB})
 SET_TARGET_PROPERTIES(${SHARED_TARGET} PROPERTIES COMPILE_FLAGS "${EXTRA_COMPILE_FLAGS} -DOPENMM_COMMON_BUILDING_SHARED_LIBRARY")
 IF (APPLE)
     SET_TARGET_PROPERTIES(${SHARED_TARGET} PROPERTIES LINK_FLAGS "${EXTRA_COMPILE_FLAGS} -F/Library/Frameworks -framework CUDA")

platforms/cuda/src/CudaContext.cpp

@@ -547,11 +547,7 @@ CUmodule CudaContext::createModule(const string source, const map<string, string
 
     stringstream tempFileName;
     tempFileName << "openmmTempKernel" << this; // Include a pointer to this context as part of the filename to avoid collisions.
-#ifdef WIN32
-    tempFileName << "_" << GetCurrentProcessId();
-#else
-    tempFileName << "_" << getpid();
-#endif
+    tempFileName << "_" << this_thread::get_id();
     string outputFile = (tempDir+tempFileName.str()+".ptx");
 
     // Split the command line flags into an array of options.

platforms/cuda/staticTarget/CMakeLists.txt

@@ -12,7 +12,7 @@ ADD_CUSTOM_COMMAND(OUTPUT ${KERNELS_CPP} ${KERNELS_H}
 SET_SOURCE_FILES_PROPERTIES(${KERNELS_CPP} ${KERNELS_H} PROPERTIES GENERATED TRUE)
 ADD_LIBRARY(${STATIC_TARGET} STATIC ${SOURCE_FILES} ${SOURCE_INCLUDE_FILES} ${API_ABS_INCLUDE_FILES})
 
-TARGET_LINK_LIBRARIES(${STATIC_TARGET} ${OPENMM_LIBRARY_NAME} CUDA::cuda_driver CUDA::cufft_static CUDA::nvrtc_static ${PTHREADS_LIB_STATIC})
+TARGET_LINK_LIBRARIES(${STATIC_TARGET} ${OPENMM_LIBRARY_NAME} CUDA::cuda_driver CUDA::cufft_static CUDA::nvrtc_static)
 SET_TARGET_PROPERTIES(${STATIC_TARGET} PROPERTIES COMPILE_FLAGS "${EXTRA_COMPILE_FLAGS} -DOPENMM_COMMON_BUILDING_STATIC_LIBRARY")
 IF (APPLE)
     SET_TARGET_PROPERTIES(${STATIC_TARGET} PROPERTIES LINK_FLAGS "${EXTRA_COMPILE_FLAGS} -F/Library/Frameworks -framework CUDA")

platforms/hip/CMakeLists.txt

@@ -100,7 +100,7 @@ IF(OPENMM_BUILD_SHARED_LIB)
     ADD_LIBRARY(${SHARED_TARGET} SHARED ${SOURCE_FILES} ${SOURCE_INCLUDE_FILES} ${API_ABS_INCLUDE_FILES})
     ADD_DEPENDENCIES(${SHARED_TARGET} CommonKernels HipKernels)
 
-    TARGET_LINK_LIBRARIES(${SHARED_TARGET} PUBLIC ${OPENMM_LIBRARY_NAME} ${PTHREADS_LIB} hip::host hiprtc::hiprtc)
+    TARGET_LINK_LIBRARIES(${SHARED_TARGET} PUBLIC ${OPENMM_LIBRARY_NAME} hip::host hiprtc::hiprtc)
     SET_TARGET_PROPERTIES(${SHARED_TARGET} PROPERTIES COMPILE_FLAGS "${EXTRA_COMPILE_FLAGS} -DOPENMM_COMMON_BUILDING_SHARED_LIBRARY")
     SET_TARGET_PROPERTIES(${SHARED_TARGET} PROPERTIES LINK_FLAGS "${EXTRA_LINK_FLAGS}")
 
@@ -113,7 +113,7 @@ IF(OPENMM_BUILD_STATIC_LIB)
     ADD_LIBRARY(${STATIC_TARGET} STATIC ${SOURCE_FILES} ${SOURCE_INCLUDE_FILES} ${API_ABS_INCLUDE_FILES})
     ADD_DEPENDENCIES(${STATIC_TARGET} CommonKernels HipKernels)
 
-    TARGET_LINK_LIBRARIES(${STATIC_TARGET} ${OPENMM_LIBRARY_NAME} ${PTHREADS_LIB_STATIC} hip::host hiprtc::hiprtc)
+    TARGET_LINK_LIBRARIES(${STATIC_TARGET} ${OPENMM_LIBRARY_NAME} hip::host hiprtc::hiprtc)
     SET_TARGET_PROPERTIES(${STATIC_TARGET} PROPERTIES COMPILE_FLAGS "${EXTRA_COMPILE_FLAGS} -DOPENMM_COMMON_BUILDING_STATIC_LIBRARY")
     SET_TARGET_PROPERTIES(${STATIC_TARGET} PROPERTIES LINK_FLAGS "${EXTRA_LINK_FLAGS}")
 

platforms/hip/include/HipContext.h

@@ -46,7 +46,6 @@
     // Prevent Windows from defining macros that interfere with other code.
     #define NOMINMAX
 #endif
-#include <pthread.h>
 #include <hip/hip_runtime.h>
 #include "openmm/common/windowsExportCommon.h"
 #include "HipArray.h"

platforms/opencl/include/OpenCLContext.h

@@ -48,7 +48,6 @@
     // Prevent Windows from defining macros that interfere with other code.
     #define NOMINMAX
 #endif
-#include <pthread.h>
 #include "opencl.hpp"
 #include "openmm/common/windowsExportCommon.h"
 #include "OpenCLArray.h"

platforms/opencl/sharedTarget/CMakeLists.txt

@@ -14,7 +14,7 @@ SET_SOURCE_FILES_PROPERTIES(${KERNELS_CPP} ${KERNELS_H} ${COMMON_KERNELS_CPP} PR
 ADD_LIBRARY(${SHARED_TARGET} SHARED ${SOURCE_FILES} ${SOURCE_INCLUDE_FILES} ${API_ABS_INCLUDE_FILES})
 ADD_DEPENDENCIES(${SHARED_TARGET} CommonKernels)
 
-TARGET_LINK_LIBRARIES(${SHARED_TARGET} ${OPENMM_LIBRARY_NAME}  ${OPENCL_LIBRARIES} ${PTHREADS_LIB})
+TARGET_LINK_LIBRARIES(${SHARED_TARGET} ${OPENMM_LIBRARY_NAME} ${OPENCL_LIBRARIES})
 SET_TARGET_PROPERTIES(${SHARED_TARGET} PROPERTIES LINK_FLAGS "${EXTRA_LINK_FLAGS}" COMPILE_FLAGS "${EXTRA_COMPILE_FLAGS} -DOPENMM_COMMON_BUILDING_SHARED_LIBRARY")
 
 INSTALL_TARGETS(/lib/plugins RUNTIME_DIRECTORY /lib/plugins ${SHARED_TARGET})

platforms/opencl/staticTarget/CMakeLists.txt

@@ -13,7 +13,7 @@ ADD_CUSTOM_COMMAND(OUTPUT ${KERNELS_CPP} ${KERNELS_H}
 SET_SOURCE_FILES_PROPERTIES(${KERNELS_CPP} ${KERNELS_H} PROPERTIES GENERATED TRUE)
 ADD_LIBRARY(${STATIC_TARGET} STATIC ${SOURCE_FILES} ${SOURCE_INCLUDE_FILES} ${API_ABS_INCLUDE_FILES})
 
-TARGET_LINK_LIBRARIES(${STATIC_TARGET} ${OPENMM_LIBRARY_NAME}  ${OPENCL_LIBRARIES} ${PTHREADS_LIB_STATIC})
+TARGET_LINK_LIBRARIES(${STATIC_TARGET} ${OPENMM_LIBRARY_NAME} ${OPENCL_LIBRARIES})
 SET_TARGET_PROPERTIES(${STATIC_TARGET} PROPERTIES LINK_FLAGS "${EXTRA_LINK_FLAGS}" COMPILE_FLAGS "${EXTRA_COMPILE_FLAGS} -DOPENMM_COMMON_BUILDING_STATIC_LIBRARY")
 
 INSTALL_TARGETS(/lib/plugins RUNTIME_DIRECTORY /lib/plugins ${STATIC_TARGET})

plugins/amoeba/platforms/cuda/CMakeLists.txt

@@ -102,7 +102,7 @@ IF (OPENMM_BUILD_SHARED_LIB)
     ADD_LIBRARY(${SHARED_TARGET} SHARED ${SOURCE_FILES} ${SOURCE_INCLUDE_FILES} ${API_ABS_INCLUDE_FILES})
     ADD_DEPENDENCIES(${SHARED_TARGET} AmoebaCommonKernels)
 
-    TARGET_LINK_LIBRARIES(${SHARED_TARGET} ${OPENMM_LIBRARY_NAME} ${PTHREADS_LIB})
+    TARGET_LINK_LIBRARIES(${SHARED_TARGET} ${OPENMM_LIBRARY_NAME})
     TARGET_LINK_LIBRARIES(${SHARED_TARGET} ${OPENMM_LIBRARY_NAME}CUDA)
     TARGET_LINK_LIBRARIES(${SHARED_TARGET} ${SHARED_AMOEBA_TARGET})
     SET_TARGET_PROPERTIES(${SHARED_TARGET} PROPERTIES COMPILE_FLAGS "${EXTRA_COMPILE_FLAGS} -DOPENMM_BUILDING_SHARED_LIBRARY")
@@ -120,7 +120,7 @@ ENDIF (OPENMM_BUILD_SHARED_LIB)
 IF(OPENMM_BUILD_STATIC_LIB)
     ADD_LIBRARY(${STATIC_TARGET} STATIC ${SOURCE_FILES} ${SOURCE_INCLUDE_FILES} ${API_ABS_INCLUDE_FILES})
 
-    TARGET_LINK_LIBRARIES(${STATIC_TARGET} ${OPENMM_LIBRARY_NAME} ${PTHREADS_LIB})
+    TARGET_LINK_LIBRARIES(${STATIC_TARGET} ${OPENMM_LIBRARY_NAME})
     TARGET_LINK_LIBRARIES(${STATIC_TARGET} ${OPENMM_LIBRARY_NAME}CUDA)
     TARGET_LINK_LIBRARIES(${STATIC_TARGET} ${STATIC_AMOEBA_TARGET})
     SET_TARGET_PROPERTIES(${STATIC_TARGET} PROPERTIES COMPILE_FLAGS "${EXTRA_COMPILE_FLAGS} -DOPENMM_BUILDING_STATIC_LIBRARY")

plugins/amoeba/platforms/hip/CMakeLists.txt

@@ -83,7 +83,7 @@ IF (OPENMM_BUILD_SHARED_LIB)
     ADD_LIBRARY(${SHARED_TARGET} SHARED ${SOURCE_FILES} ${SOURCE_INCLUDE_FILES} ${API_ABS_INCLUDE_FILES})
     ADD_DEPENDENCIES(${SHARED_TARGET} AmoebaCommonKernels)
 
-    TARGET_LINK_LIBRARIES(${SHARED_TARGET} ${OPENMM_LIBRARY_NAME} ${PTHREADS_LIB})
+    TARGET_LINK_LIBRARIES(${SHARED_TARGET} ${OPENMM_LIBRARY_NAME})
     TARGET_LINK_LIBRARIES(${SHARED_TARGET} ${OPENMM_LIBRARY_NAME}HIP)
     TARGET_LINK_LIBRARIES(${SHARED_TARGET} ${SHARED_AMOEBA_TARGET})
     SET_TARGET_PROPERTIES(${SHARED_TARGET} PROPERTIES COMPILE_FLAGS "${EXTRA_COMPILE_FLAGS} -DOPENMM_BUILDING_SHARED_LIBRARY")
@@ -97,7 +97,7 @@ ENDIF (OPENMM_BUILD_SHARED_LIB)
 IF(OPENMM_BUILD_STATIC_LIB)
     ADD_LIBRARY(${STATIC_TARGET} STATIC ${SOURCE_FILES} ${SOURCE_INCLUDE_FILES} ${API_ABS_INCLUDE_FILES})
 
-    TARGET_LINK_LIBRARIES(${STATIC_TARGET} ${OPENMM_LIBRARY_NAME} ${PTHREADS_LIB})
+    TARGET_LINK_LIBRARIES(${STATIC_TARGET} ${OPENMM_LIBRARY_NAME})
     TARGET_LINK_LIBRARIES(${STATIC_TARGET} ${OPENMM_LIBRARY_NAME}HIP)
     TARGET_LINK_LIBRARIES(${STATIC_TARGET} ${STATIC_AMOEBA_TARGET})
     SET_TARGET_PROPERTIES(${STATIC_TARGET} PROPERTIES COMPILE_FLAGS "${EXTRA_COMPILE_FLAGS} -DOPENMM_BUILDING_STATIC_LIBRARY")