src/gromacs/taskassignment/usergpuids.cpp

   1 /*
   2  * This file is part of the GROMACS molecular simulation package.
   3  *
   4  * Copyright (c) 2017,2018,2019,2020, by the GROMACS development team, led by
   5  * Mark Abraham, David van der Spoel, Berk Hess, and Erik Lindahl,
   6  * and including many others, as listed in the AUTHORS file in the
   7  * top-level source directory and at http://www.gromacs.org.
   8  *
   9  * GROMACS is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public License
  11  * as published by the Free Software Foundation; either version 2.1
  12  * of the License, or (at your option) any later version.
  13  *
  14  * GROMACS is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public
  20  * License along with GROMACS; if not, see
  21  * http://www.gnu.org/licenses, or write to the Free Software Foundation,
  22  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA.
  23  *
  24  * If you want to redistribute modifications to GROMACS, please
  25  * consider that scientific software is very special. Version
  26  * control is crucial - bugs must be traceable. We will be happy to
  27  * consider code for inclusion in the official distribution, but
  28  * derived work must not be called official GROMACS. Details are found
  29  * in the README & COPYING files - if they are missing, get the
  30  * official version at http://www.gromacs.org.
  31  *
  32  * To help us fund GROMACS development, we humbly ask that you cite
  33  * the research papers on the package. Check out http://www.gromacs.org.
  34  */
  35 /*! \internal \file
  36  * \brief Defines routines for handling user-specified GPU IDs.
  37  *
  38  * \author Mark Abraham <mark.j.abraham@gmail.com>
  39  * \ingroup module_taskassignment
  40  */
  41 #include "gmxpre.h"
  42
  43 #include "usergpuids.h"
  44
  45 #include <cctype>
  46
  47 #include <algorithm>
  48 #include <sstream>
  49 #include <string>
  50 #include <vector>
  51
  52 #include "gromacs/hardware/device_management.h"
  53 #include "gromacs/hardware/hw_info.h"
  54 #include "gromacs/utility/exceptions.h"
  55 #include "gromacs/utility/stringutil.h"
  56
  57 namespace gmx
  58 {
  59
  60 /*! \brief Parse a GPU ID specifier string into a container.
  61  *
  62  * \param[in]   gpuIdString  String like "013" or "0,1,3" typically
  63  *                           supplied by the user.
  64  *                           Must contain only unique decimal digits, or only decimal
  65  *                           digits separated by comma delimiters. A terminal
  66  *                           comma is accceptable (and required to specify a
  67  *                           single ID that is larger than 9).
  68  *
  69  * \returns  A vector of numeric IDs extracted from \c gpuIdString.
  70  *
  71  * \throws   std::bad_alloc     If out of memory.
  72  *           InvalidInputError  If an invalid character is found (ie not a digit or ',').
  73  */
  74 static std::vector<int> parseGpuDeviceIdentifierList(const std::string& gpuIdString)
  75 {
  76     std::vector<int> digits;
  77     auto             foundCommaDelimiters = gpuIdString.find(',') != std::string::npos;
  78     if (!foundCommaDelimiters)
  79     {
  80         for (const auto& c : gpuIdString)
  81         {
  82             if (std::isdigit(c) == 0)
  83             {
  84                 GMX_THROW(InvalidInputError(
  85                         formatString("Invalid character in GPU ID string: \"%c\"\n", c)));
  86             }
  87             // Convert each character in the token to an integer
  88             digits.push_back(c - '0');
  89         }
  90     }
  91     else
  92     {
  93         if (gpuIdString[0] == ',')
  94         {
  95             GMX_THROW(InvalidInputError("Invalid use of leading comma in GPU ID string"));
  96         }
  97         std::istringstream ss(gpuIdString);
  98         std::string        token;
  99         digits.reserve(gpuIdString.length());
 100         token.reserve(gpuIdString.length());
 101         while (std::getline(ss, token, ','))
 102         {
 103             // Convert the whole token to an integer
 104             if (token.empty())
 105             {
 106                 GMX_THROW(InvalidInputError("Invalid use of comma in GPU ID string"));
 107             }
 108             digits.push_back(std::stoi(token));
 109         }
 110     }
 111     return digits;
 112 }
 113
 114 std::vector<int> parseUserGpuIdString(const std::string& gpuIdString)
 115 {
 116     // An optional comma is used to separate GPU IDs assigned to the
 117     // same type of task, which will be useful for any nodes that have
 118     // more than ten GPUs.
 119
 120     auto digits = parseGpuDeviceIdentifierList(gpuIdString);
 121
 122     // Check and enforce that no duplicate IDs are allowed
 123     for (size_t i = 0; i != digits.size(); ++i)
 124     {
 125         for (size_t j = i + 1; j != digits.size(); ++j)
 126         {
 127             if (digits[i] == digits[j])
 128             {
 129                 GMX_THROW(
 130                         InvalidInputError(formatString("The string of available GPU device IDs "
 131                                                        "'%s' may not contain duplicate device IDs",
 132                                                        gpuIdString.c_str())));
 133             }
 134         }
 135     }
 136     return digits;
 137 }
 138
 139 std::vector<int> makeGpuIdsToUse(const gmx_gpu_info_t& gpuInfo, const std::string& gpuIdsAvailableString)
 140 {
 141     auto             compatibleGpus  = getCompatibleGpus(gpuInfo);
 142     std::vector<int> gpuIdsAvailable = parseUserGpuIdString(gpuIdsAvailableString);
 143
 144     if (gpuIdsAvailable.empty())
 145     {
 146         return compatibleGpus;
 147     }
 148
 149     std::vector<int> gpuIdsToUse;
 150     gpuIdsToUse.reserve(gpuIdsAvailable.size());
 151     std::vector<int> availableGpuIdsThatAreIncompatible;
 152     for (const auto& availableGpuId : gpuIdsAvailable)
 153     {
 154         bool availableGpuIsCompatible = false;
 155         for (const auto& compatibleGpuId : compatibleGpus)
 156         {
 157             if (availableGpuId == compatibleGpuId)
 158             {
 159                 availableGpuIsCompatible = true;
 160                 break;
 161             }
 162         }
 163         if (availableGpuIsCompatible)
 164         {
 165             gpuIdsToUse.push_back(availableGpuId);
 166         }
 167         else
 168         {
 169             // Prepare data for an error message about all incompatible available GPU IDs.
 170             availableGpuIdsThatAreIncompatible.push_back(availableGpuId);
 171         }
 172     }
 173     if (!availableGpuIdsThatAreIncompatible.empty())
 174     {
 175         auto message = "You requested mdrun to use GPUs with IDs " + gpuIdsAvailableString
 176                        + ", but that includes the following incompatible GPUs: "
 177                        + formatAndJoin(availableGpuIdsThatAreIncompatible, ",", StringFormatter("%d"))
 178                        + ". Request only compatible GPUs.";
 179         GMX_THROW(InvalidInputError(message));
 180     }
 181     return gpuIdsToUse;
 182 }
 183
 184 std::vector<int> parseUserTaskAssignmentString(const std::string& gpuIdString)
 185 {
 186     // Implement any additional constraints here that need to be imposed
 187
 188     return parseGpuDeviceIdentifierList(gpuIdString);
 189 }
 190
 191 std::vector<int> makeGpuIds(ArrayRef<const int> compatibleGpus, size_t numGpuTasks)
 192 {
 193     std::vector<int> gpuIdsToUse;
 194
 195     gpuIdsToUse.reserve(numGpuTasks);
 196
 197     auto currentGpuId = compatibleGpus.begin();
 198     for (size_t i = 0; i != numGpuTasks; ++i)
 199     {
 200         GMX_ASSERT(!compatibleGpus.empty(),
 201                    "Must have compatible GPUs from which to build a list of GPU IDs to use");
 202         gpuIdsToUse.push_back(*currentGpuId);
 203         ++currentGpuId;
 204         if (currentGpuId == compatibleGpus.end())
 205         {
 206             // Wrap around and assign tasks again.
 207             currentGpuId = compatibleGpus.begin();
 208         }
 209     }
 210     std::sort(gpuIdsToUse.begin(), gpuIdsToUse.end());
 211     return gpuIdsToUse;
 212 }
 213
 214 std::string makeGpuIdString(const std::vector<int>& gpuIds, int totalNumberOfTasks)
 215 {
 216     auto resultGpuIds = makeGpuIds(gpuIds, totalNumberOfTasks);
 217     return formatAndJoin(resultGpuIds, ",", StringFormatter("%d"));
 218 }
 219
 220 void checkUserGpuIds(const gmx_gpu_info_t&   gpu_info,
 221                      const std::vector<int>& compatibleGpus,
 222                      const std::vector<int>& gpuIds)
 223 {
 224     bool        foundIncompatibleGpuIds = false;
 225     std::string message =
 226             "Some of the requested GPUs do not exist, behave strangely, or are not compatible:\n";
 227
 228     for (const auto& gpuId : gpuIds)
 229     {
 230         if (std::find(compatibleGpus.begin(), compatibleGpus.end(), gpuId) == compatibleGpus.end())
 231         {
 232             foundIncompatibleGpuIds = true;
 233             message += gmx::formatString("    GPU #%d: %s\n", gpuId,
 234                                          getGpuCompatibilityDescription(gpu_info, gpuId));
 235         }
 236     }
 237     if (foundIncompatibleGpuIds)
 238     {
 239         GMX_THROW(InconsistentInputError(message));
 240     }
 241 }
 242
 243 } // namespace gmx