Common compute framework to unify CUDA and OpenCL code (#2488)

* Began creating common compute framework to unify code between CUDA and OpenCL

* Began OpenCL implementation of common compute framework

* Common implementation of CMMotionRemover

* CUDA implementation of common compute interface

* Converted HarmonicBondForce to common compute API

* Converted standard bonded forces to common compute API

* Converted ExpressionUtilities to common compute API

* Created ComputeParameterSet

* Converted custom bonded forces to common compute API

* Converted CustomCentroidBondForce to common compute API

* Converted CustomManyParticleForce to common compute API

* Moved lots of duplicate code from CudaContext and OpenCLContext to ComputeContext

* Converted GayBerneForce to common compute API

* Removed obsolete kernels

* Converted verlet integrators to common compute API

* Converted Langevin and Brownian integrators to common compute API

* Converted CustomIntegrator to common compute API

* Converted CustomNonbondedForce to common compute API

* Removed uses of a deprecated API

* Fixed failing test cases

* Converted GBSAOBCForce to common compute API

* Began converting CustomGBForce to common compute API

* Finished converting CustomGBForce to common compute API

* Merged duplicated code in CudaIntegrationUtilities and OpenCLIntegrationUtilities

* Converted RMSDForce and AndersenThermostat to common compute API

* Converted CustomHbondForce to common compute API

* Merged scripts for encoding kernel sources

* Converted Drude plugin to common compute API

* Fixed errors in CMake scripts

* Attempt at fixing errors on Windows

* Added discussion of common compute API to developer guide

* Added Windows export macro for common classes

* Fixed error in CMMotionRemover

* Ubdated travis to newer Ubuntu version

* Fixed errors on CPU OpenCL

* Fixed Windows linking errors

* Added missing pragma for 32 bit atomics

* Replaced long long with mm_long

* More fixes to Windows linking

* Bug fix

platforms/common/include/openmm/common/NonbondedUtilities.h

+#ifndef OPENMM_NONBONDEDUTILITIES_H_
+#define OPENMM_NONBONDEDUTILITIES_H_
+
+/* -------------------------------------------------------------------------- *
+ *                                   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) 2009-2019 Stanford University and the Authors.      *
+ * Authors: Peter Eastman                                                     *
+ * Contributors:                                                              *
+ *                                                                            *
+ * This program is free software: you can redistribute it and/or modify       *
+ * it under the terms of the GNU Lesser General Public License as published   *
+ * by the Free Software Foundation, either version 3 of the License, or       *
+ * (at your option) any later version.                                        *
+ *                                                                            *
+ * This program is distributed in the hope that it will be useful,            *
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of             *
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the              *
+ * GNU Lesser General Public License for more details.                        *
+ *                                                                            *
+ * You should have received a copy of the GNU Lesser General Public License   *
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.      *
+ * -------------------------------------------------------------------------- */
+
+#include "openmm/common/ArrayInterface.h"
+#include "openmm/common/ComputeParameterInfo.h"
+#include <string>
+#include <vector>
+
+namespace OpenMM {
+
+/**
+ * This class provides a generic interface for calculating nonbonded interactions.  Clients only need
+ * to provide the code for evaluating a single interaction and the list of parameters it depends on.
+ * A complete kernel is then synthesized using an appropriate algorithm to evaluate all interactions on
+ * all atoms.  Call addInteraction() to define a nonbonded interaction, and addParameter() to define
+ * per-particle parameters that the interaction depends on.
+ *
+ * During each force or energy evaluation, the following sequence of steps takes place:
+ *
+ * 1. Data structures (e.g. neighbor lists) are calculated to allow nonbonded interactions to be evaluated
+ * quickly.
+ *
+ * 2. calcForcesAndEnergy() is called on each ForceImpl in the System.
+ *
+ * 3. Finally, the default interaction kernel is invoked to calculate all interactions that were added
+ * to it.
+ *
+ * This sequence means that the default interaction kernel may depend on quantities that were calculated
+ * by ForceImpls during calcForcesAndEnergy().
+ */
+
+class OPENMM_EXPORT_COMMON NonbondedUtilities {
+public:
+    virtual ~NonbondedUtilities() {
+    }
+    /**
+     * Add a nonbonded interaction to be evaluated by the default interaction kernel.
+     *
+     * @param usesCutoff     specifies whether a cutoff should be applied to this interaction
+     * @param usesPeriodic   specifies whether periodic boundary conditions should be applied to this interaction
+     * @param usesExclusions specifies whether this interaction uses exclusions.  If this is true, it must have identical exclusions to every other interaction.
+     * @param cutoffDistance the cutoff distance for this interaction (ignored if usesCutoff is false)
+     * @param exclusionList  for each atom, specifies the list of other atoms whose interactions should be excluded
+     * @param kernel         the code to evaluate the interaction
+     * @param forceGroup     the force group in which the interaction should be calculated
+     */
+    virtual void addInteraction(bool usesCutoff, bool usesPeriodic, bool usesExclusions, double cutoffDistance, const std::vector<std::vector<int> >& exclusionList, const std::string& kernel, int forceGroup) = 0;
+    /**
+     * Add a per-atom parameter that the default interaction kernel may depend on.
+     */
+    virtual void addParameter(ComputeParameterInfo parameter) = 0;
+    /**
+     * Add an array (other than a per-atom parameter) that should be passed as an argument to the default interaction kernel.
+     */
+    virtual void addArgument(ComputeParameterInfo parameter) = 0;
+    /**
+     * Register that the interaction kernel will be computing the derivative of the potential energy
+     * with respect to a parameter.
+     * 
+     * @param param   the name of the parameter
+     * @return the variable that will be used to accumulate the derivative.  Any code you pass to addInteraction() should
+     * add its contributions to this variable.
+     */
+    virtual std::string addEnergyParameterDerivative(const std::string& param) = 0;
+    /**
+     * Get the number of force buffers required for nonbonded forces.
+     */
+    virtual int getNumForceBuffers() const = 0;
+    /**
+     * Get whether a cutoff is being used.
+     */
+    virtual bool getUseCutoff() = 0;
+    /**
+     * Get whether periodic boundary conditions are being used.
+     */
+    virtual bool getUsePeriodic() = 0;
+    /**
+     * Get the number of thread blocks used for computing nonbonded forces.
+     */
+    virtual int getNumForceThreadBlocks() = 0;
+    /**
+     * Get the size of each thread block used for computing nonbonded forces.
+     */
+    virtual int getForceThreadBlockSize() = 0;
+    /**
+     * Get the maximum cutoff distance used by any interaction.
+     */
+    virtual double getMaxCutoffDistance() = 0;
+    /**
+     * Given a nonbonded cutoff, get the padded cutoff distance used in computing
+     * the neighbor list.
+     */
+    virtual double padCutoff(double cutoff) = 0;
+    /**
+     * Get the array containing the center of each atom block.
+     */
+    virtual ArrayInterface& getBlockCenters() = 0;
+    /**
+     * Get the array containing the dimensions of each atom block.
+     */
+    virtual ArrayInterface& getBlockBoundingBoxes() = 0;
+    /**
+     * Get the array whose first element contains the number of tiles with interactions.
+     */
+    virtual ArrayInterface& getInteractionCount() = 0;
+    /**
+     * Get the array containing tiles with interactions.
+     */
+    virtual ArrayInterface& getInteractingTiles() = 0;
+    /**
+     * Get the array containing the atoms in each tile with interactions.
+     */
+    virtual ArrayInterface& getInteractingAtoms() = 0;
+    /**
+     * Get the array containing exclusion flags.
+     */
+    virtual ArrayInterface& getExclusions() = 0;
+    /**
+     * Get the array containing tiles with exclusions.
+     */
+    virtual ArrayInterface& getExclusionTiles() = 0;
+    /**
+     * Get the array containing the index into the exclusion array for each tile.
+     */
+    virtual ArrayInterface& getExclusionIndices() = 0;
+    /**
+     * Get the array listing where the exclusion data starts for each row.
+     */
+    virtual ArrayInterface& getExclusionRowIndices() = 0;
+    /**
+     * Get the array containing a flag for whether the neighbor list was rebuilt
+     * on the most recent call to prepareInteractions().
+     */
+    virtual ArrayInterface& getRebuildNeighborList() = 0;
+};
+
+} // namespace OpenMM
+
+#endif /*OPENMM_NONBONDEDUTILITIES_H_*/

platforms/opencl/include/windowsExportOpenCL.h → platforms/common/include/openmm/common/windowsExportCommon.h

-#ifndef OPENMM_WINDOWSEXPORTOPENCL_H_
-#define OPENMM_WINDOWSEXPORTOPENCL_H_
+#ifndef OPENMM_WINDOWSEXPORTCOMMON_H_
+#define OPENMM_WINDOWSEXPORTCOMMON_H_
 
 /*
  * Shared libraries are messy in Visual Studio. We have to distinguish three
@@ -12,7 +12,7 @@
  *       being compiled with the expectation of linking with the
  *       OpenMM static library (nothing special needed)
  * In the CMake script for building this library, we define one of the symbols
- *     OPENMM_OPENCL_BUILDING_{SHARED|STATIC}_LIBRARY
+ *     OPENMM_COMMON_BUILDING_{SHARED|STATIC}_LIBRARY
  * Client code normally has no special symbol defined, in which case we'll
  * assume it wants to use the shared library. However, if the client defines
  * the symbol OPENMM_USE_STATIC_LIBRARIES we'll suppress the dllimport so
@@ -27,15 +27,15 @@
     #pragma warning(disable:4996)
     // Keep MS VC++ quiet about lack of dll export of private members.
     #pragma warning(disable:4251)
-    #if defined(OPENMM_OPENCL_BUILDING_SHARED_LIBRARY)
-        #define OPENMM_EXPORT_OPENCL __declspec(dllexport)
-    #elif defined(OPENMM_OPENCL_BUILDING_STATIC_LIBRARY) || defined(OPENMM_OPENCL_USE_STATIC_LIBRARIES)
-        #define OPENMM_EXPORT_OPENCL
+    #if defined(OPENMM_COMMON_BUILDING_SHARED_LIBRARY)
+        #define OPENMM_EXPORT_COMMON __declspec(dllexport)
+    #elif defined(OPENMM_COMMON_BUILDING_STATIC_LIBRARY) || defined(OPENMM_COMMON_USE_STATIC_LIBRARIES)
+        #define OPENMM_EXPORT_COMMON
     #else
-        #define OPENMM_EXPORT_OPENCL __declspec(dllimport)   // i.e., a client of a shared library
+        #define OPENMM_EXPORT_COMMON __declspec(dllimport)   // i.e., a client of a shared library
     #endif
 #else
-    #define OPENMM_EXPORT_OPENCL // Linux, Mac
+    #define OPENMM_EXPORT_COMMON // Linux, Mac
 #endif
 
-#endif // OPENMM_WINDOWSEXPORTOPENCL_H_
+#endif // OPENMM_WINDOWSEXPORTCOMMON_H_

plugins/drude/platforms/opencl/src/OpenCLDrudeKernelSources.cpp.in → platforms/common/src/CommonKernelSources.cpp.in

@@ -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) 2010 Stanford University and the Authors.           *
+ * Portions copyright (c) 2019 Stanford University and the Authors.           *
  * Authors: Peter Eastman                                                     *
  * Contributors:                                                              *
  *                                                                            *
@@ -24,7 +24,7 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.      *
  * -------------------------------------------------------------------------- */
 
-#include "OpenCLDrudeKernelSources.h"
+#include "CommonKernelSources.h"
 
 using namespace OpenMM;
 using namespace std;

plugins/drude/platforms/opencl/src/OpenCLDrudeKernelSources.h.in → platforms/common/src/CommonKernelSources.h.in

-#ifndef OPENMM_OPENCLDRUDEKERNELSOURCES_H_
-#define OPENMM_OPENCLDRUDEKERNELSOURCES_H_
+#ifndef OPENMM_COMMONKERNELSOURCES_H_
+#define OPENMM_COMMONKERNELSOURCES_H_
 
 /* -------------------------------------------------------------------------- *
  *                                   OpenMM                                   *
@@ -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) 2010 Stanford University and the Authors.           *
+ * Portions copyright (c) 2019 Stanford University and the Authors.           *
  * Authors: Peter Eastman                                                     *
  * Contributors:                                                              *
  *                                                                            *
@@ -27,21 +27,22 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.      *
  * -------------------------------------------------------------------------- */
 
+#include "openmm/common/windowsExportCommon.h"
 #include <string>
 
 namespace OpenMM {
 
 /**
- * This class is a central holding place for the source code of OpenCL kernels.
- * The CMake build script inserts declarations into it based on the .cu files in the
+ * This class is a central holding place for the source code of common kernels.
+ * The CMake build script inserts declarations into it based on the .cc files in the
  * kernels subfolder.
  */
 
-class OpenCLDrudeKernelSources {
+class OPENMM_EXPORT_COMMON CommonKernelSources {
 public:
-@CL_FILE_DECLARATIONS@
+@KERNEL_FILE_DECLARATIONS@
 };
 
 } // namespace OpenMM
 
-#endif /*OPENMM_OPENCLDRUDEKERNELSOURCES_H_*/
+#endif /*OPENMM_COMMONKERNELSOURCES_H_*/

platforms/common/src/ComputeArray.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) 2019 Stanford University and the Authors.           *
+ * Authors: Peter Eastman                                                     *
+ * Contributors:                                                              *
+ *                                                                            *
+ * This program is free software: you can redistribute it and/or modify       *
+ * it under the terms of the GNU Lesser General Public License as published   *
+ * by the Free Software Foundation, either version 3 of the License, or       *
+ * (at your option) any later version.                                        *
+ *                                                                            *
+ * This program is distributed in the hope that it will be useful,            *
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of             *
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the              *
+ * GNU Lesser General Public License for more details.                        *
+ *                                                                            *
+ * You should have received a copy of the GNU Lesser General Public License   *
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.      *
+ * -------------------------------------------------------------------------- */
+
+#include "openmm/common/ComputeArray.h"
+#include "openmm/common/ComputeContext.h"
+
+using namespace OpenMM;
+
+ComputeArray::ComputeArray() : impl(NULL) {
+}
+
+ComputeArray::~ComputeArray() {
+    if (impl != NULL)
+        delete impl;
+}
+
+ArrayInterface& ComputeArray::getArray() {
+    if (impl == NULL)
+        throw OpenMMException("ComputeArray has not been initialized");
+    return *impl;
+}
+
+void ComputeArray::initialize(ComputeContext& context, int size, int elementSize, const std::string& name) {
+    if (impl != NULL)
+        throw OpenMMException("The array "+getName()+" has already been initialized");
+    impl = context.createArray();
+    impl->initialize(context, size, elementSize, name);
+}
+
+void ComputeArray::resize(int size) {
+    if (impl == NULL)
+        throw OpenMMException("ComputeArray has not been initialized");
+    impl->resize(size);
+}
+
+bool ComputeArray::isInitialized() const {
+    return (impl != NULL);
+}
+
+int ComputeArray::getSize() const {
+    if (impl == NULL)
+        throw OpenMMException("ComputeArray has not been initialized");
+    return impl->getSize();
+}
+
+int ComputeArray::getElementSize() const {
+    if (impl == NULL)
+        throw OpenMMException("ComputeArray has not been initialized");
+    return impl->getElementSize();
+}
+
+const std::string& ComputeArray::getName() const {
+    if (impl == NULL)
+        throw OpenMMException("ComputeArray has not been initialized");
+    return impl->getName();
+}
+
+ComputeContext& ComputeArray::getContext() {
+    if (impl == NULL)
+        throw OpenMMException("ComputeArray has not been initialized");
+    return impl->getContext();
+}
+
+void ComputeArray::upload(const void* data, bool blocking) {
+    if (impl == NULL)
+        throw OpenMMException("ComputeArray has not been initialized");
+    impl->upload(data, blocking);
+}
+
+void ComputeArray::download(void* data, bool blocking) const {
+    if (impl == NULL)
+        throw OpenMMException("ComputeArray has not been initialized");
+    impl->download(data, blocking);
+}
+
+void ComputeArray::copyTo(ArrayInterface& dest) const {
+    if (impl == NULL)
+        throw OpenMMException("ComputeArray has not been initialized");
+    impl->copyTo(dest);
+}
\ No newline at end of file

platforms/opencl/src/OpenCLForceInfo.cpp → platforms/common/src/ComputeForceInfo.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) 2009 Stanford University and the Authors.           *
+ * Portions copyright (c) 2012-2019 Stanford University and the Authors.      *
  * Authors: Peter Eastman                                                     *
  * Contributors:                                                              *
  *                                                                            *
@@ -24,23 +24,23 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.      *
  * -------------------------------------------------------------------------- */
 
-#include "OpenCLForceInfo.h"
+#include "openmm/common/ComputeForceInfo.h"
 
 using namespace OpenMM;
 using namespace std;
 
-bool OpenCLForceInfo::areParticlesIdentical(int particle1, int particle2) {
+bool ComputeForceInfo::areParticlesIdentical(int particle1, int particle2) {
     return true;
 }
 
-int OpenCLForceInfo::getNumParticleGroups() {
+int ComputeForceInfo::getNumParticleGroups() {
     return 0;
 }
 
-void OpenCLForceInfo::getParticlesInGroup(int index, vector<int>& particles) {
+void ComputeForceInfo::getParticlesInGroup(int index, vector<int>& particles) {
     return;
 }
 
-bool OpenCLForceInfo::areGroupsIdentical(int group1, int group2) {
+bool ComputeForceInfo::areGroupsIdentical(int group1, int group2) {
     return true;
 }

platforms/common/src/ComputeParameterSet.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) 2009-2019 Stanford University and the Authors.      *
+ * Authors: Peter Eastman                                                     *
+ * Contributors:                                                              *
+ *                                                                            *
+ * This program is free software: you can redistribute it and/or modify       *
+ * it under the terms of the GNU Lesser General Public License as published   *
+ * by the Free Software Foundation, either version 3 of the License, or       *
+ * (at your option) any later version.                                        *
+ *                                                                            *
+ * This program is distributed in the hope that it will be useful,            *
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of             *
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the              *
+ * GNU Lesser General Public License for more details.                        *
+ *                                                                            *
+ * You should have received a copy of the GNU Lesser General Public License   *
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.      *
+ * -------------------------------------------------------------------------- */
+
+#include "openmm/common/ComputeParameterSet.h"
+#include "openmm/OpenMMException.h"
+#include <cmath>
+#include <sstream>
+
+using namespace OpenMM;
+using namespace std;
+
+ComputeParameterSet::ComputeParameterSet(ComputeContext& context, int numParameters, int numObjects, const string& name, bool arrayPerParameter, bool useDoublePrecision) :
+            context(context), numParameters(numParameters), numObjects(numObjects), name(name) {
+    int params = numParameters;
+    int bufferCount = 0;
+    elementSize = (useDoublePrecision ? sizeof(double) : sizeof(float));
+    string elementType = (useDoublePrecision ? "double" : "float");
+    if (!arrayPerParameter) {
+        while (params > 2) {
+            std::stringstream name;
+            name << "param" << (++bufferCount);
+            arrays.push_back(context.createArray());
+            arrays.back()->initialize(context, numObjects, elementSize*4, name.str());
+            params -= 4;
+        }
+        if (params > 1) {
+            std::stringstream name;
+            name << "param" << (++bufferCount);
+            arrays.push_back(context.createArray());
+            arrays.back()->initialize(context, numObjects, elementSize*2, name.str());
+            params -= 2;
+        }
+    }
+    while (params > 0) {
+        std::stringstream name;
+        name << "param" << (++bufferCount);
+            arrays.push_back(context.createArray());
+        arrays.back()->initialize(context, numObjects, elementSize, name.str());
+        params--;
+    }
+    for (ArrayInterface* array : arrays)
+        parameters.push_back(ComputeParameterInfo(*array, array->getName(), elementType, array->getElementSize()/elementSize));
+}
+
+ComputeParameterSet::~ComputeParameterSet() {
+    for (ArrayInterface* array : arrays)
+        delete array;
+}
+
+template <class T>
+void ComputeParameterSet::getParameterValues(vector<vector<T> >& values) {
+    if (sizeof(T) != elementSize)
+        throw OpenMMException("Called getParameterValues() with vector of wrong type");
+    values.resize(numObjects);
+    for (int i = 0; i < numObjects; i++)
+        values[i].resize(numParameters);
+    int base = 0;
+    for (int i = 0; i < (int) arrays.size(); i++) {
+        if (arrays[i]->getElementSize() == 4*elementSize) {
+            vector<T> data(4*numObjects);
+            arrays[i]->download(data.data());
+            for (int j = 0; j < numObjects; j++) {
+                values[j][base] = data[4*j];
+                if (base+1 < numParameters)
+                    values[j][base+1] = data[4*j+1];
+                if (base+2 < numParameters)
+                    values[j][base+2] = data[4*j+2];
+                if (base+3 < numParameters)
+                    values[j][base+3] = data[4*j+3];
+            }
+            base += 4;
+        }
+        else if (arrays[i]->getElementSize() == 2*elementSize) {
+            vector<T> data(2*numObjects);
+            arrays[i]->download(data.data());
+            for (int j = 0; j < numObjects; j++) {
+                values[j][base] = data[2*j];
+                if (base+1 < numParameters)
+                    values[j][base+1] = data[2*j+1];
+            }
+            base += 2;
+        }
+        else if (arrays[i]->getElementSize() == elementSize) {
+            vector<T> data(numObjects);
+            arrays[i]->download(data.data());
+            for (int j = 0; j < numObjects; j++)
+                values[j][base] = data[j];
+            base++;
+        }
+        else
+            throw OpenMMException("Internal error: Unknown buffer type in ComputeParameterSet");
+    }
+}
+
+template <class T>
+void ComputeParameterSet::setParameterValues(const vector<vector<T> >& values) {
+    if (sizeof(T) != elementSize)
+        throw OpenMMException("Called setParameterValues() with vector of wrong type");
+    int base = 0;
+    for (int i = 0; i < (int) arrays.size(); i++) {
+        if (arrays[i]->getElementSize() == 4*elementSize) {
+            vector<T> data(4*numObjects);
+            for (int j = 0; j < numObjects; j++) {
+                data[4*j] = values[j][base];
+                if (base+1 < numParameters)
+                    data[4*j+1] = values[j][base+1];
+                if (base+2 < numParameters)
+                    data[4*j+2] = values[j][base+2];
+                if (base+3 < numParameters)
+                    data[4*j+3] = values[j][base+3];
+            }
+            arrays[i]->upload(data.data());
+            base += 4;
+        }
+        else if (arrays[i]->getElementSize() == 2*elementSize) {
+            vector<T> data(2*numObjects);
+            for (int j = 0; j < numObjects; j++) {
+                data[2*j] = values[j][base];
+                if (base+1 < numParameters)
+                    data[2*j+1] = values[j][base+1];
+            }
+            arrays[i]->upload(data.data());
+            base += 2;
+        }
+        else if (arrays[i]->getElementSize() == elementSize) {
+            vector<T> data(numObjects);
+            for (int j = 0; j < numObjects; j++)
+                data[j] = values[j][base];
+            arrays[i]->upload(data.data());
+            base++;
+        }
+        else
+            throw OpenMMException("Internal error: Unknown buffer type in ComputeParameterSet");
+    }
+}
+
+string ComputeParameterSet::getParameterSuffix(int index, const std::string& extraSuffix) const {
+    const string suffixes[] = {".x", ".y", ".z", ".w"};
+    int buffer = -1;
+    for (int i = 0; buffer == -1 && i < (int) parameters.size(); i++) {
+        if (index*elementSize < parameters[i].getSize())
+            buffer = i;
+        else
+            index -= parameters[i].getSize()/elementSize;
+    }
+    if (buffer == -1)
+        throw OpenMMException("Internal error: Illegal argument to ComputeParameterSet::getParameterSuffix() ("+name+")");
+    stringstream suffix;
+    suffix << (buffer+1) << extraSuffix;
+    if (parameters[buffer].getSize() != elementSize)
+        suffix << suffixes[index];
+    return suffix.str();
+}
+
+/**
+ * Define template instantiations for float and double versions of getParameterValues() and setParameterValues().
+ */
+namespace OpenMM {
+template void ComputeParameterSet::getParameterValues<float>(vector<vector<float> >& values);
+template void ComputeParameterSet::setParameterValues<float>(const vector<vector<float> >& values);
+template void ComputeParameterSet::getParameterValues<double>(vector<vector<double> >& values);
+template void ComputeParameterSet::setParameterValues<double>(const vector<vector<double> >& values);
+}
\ No newline at end of file