Gromacs
2024.4
|
#include "gmxpre.h"
#include "config.h"
#include <algorithm>
#include <map>
#include <optional>
#include <tuple>
#include <vector>
#include "gromacs/gpu_utils/gmxsycl.h"
#include "gromacs/hardware/device_management.h"
#include "gromacs/hardware/device_management_sycl_intel_device_ids.h"
#include "gromacs/utility/arrayref.h"
#include "gromacs/utility/exceptions.h"
#include "gromacs/utility/fatalerror.h"
#include "gromacs/utility/mpiinfo.h"
#include "gromacs/utility/strconvert.h"
#include "gromacs/utility/stringutil.h"
#include "gromacs/utility/unique_cptr.h"
#include "device_information.h"
Defines the SYCL implementations of the device management.
Functions | |
static std::optional < std::tuple< int, int > > | parseHardwareVersionNvidia (const std::string &archName) |
static std::optional < std::tuple< int, int > > | getHardwareVersionNvidia (const sycl::device &device) |
static std::optional < std::tuple< int, int, int > > | parseHardwareVersionAmd (const std::string &archName) |
static std::optional < std::tuple< int, int, int > > | getHardwareVersionAmd (const sycl::device &device) |
static std::optional < std::tuple< int, int, int > > | getHardwareVersionIntel (const sycl::device &device) |
static gmx::GpuAwareMpiStatus | getDeviceGpuAwareMpiStatus (const sycl::backend backend) |
void | warnWhenDeviceNotTargeted (const gmx::MDLogger &, const DeviceInformation &) |
Warn to the logger when the detected device was not one of the targets selected at configure time for compilation. More... | |
bool | isDeviceDetectionFunctional (std::string *errorMessage) |
Return whether GPU detection is functioning correctly. More... | |
static DeviceStatus | isDeviceCompatible (const sycl::device &syclDevice, const DeviceVendor gmx_unused deviceVendor, gmx::ArrayRef< const int > supportedSubGroupSizes) |
Checks that device deviceInfo is compatible with GROMACS. More... | |
static bool | isDeviceFunctional (const sycl::device &syclDevice, std::string *errorMessage) |
Checks that device deviceInfo is sane (ie can run a kernel). More... | |
static DeviceStatus | checkDevice (size_t deviceId, const DeviceInformation &deviceInfo) |
Checks that device deviceInfo is compatible and functioning. More... | |
static std::vector< sycl::device > | partitionDevices (const std::vector< sycl::device > &&devices) |
std::vector< std::unique_ptr < DeviceInformation > > | findDevices () |
Find all GPUs in the system. More... | |
void | setActiveDevice (const DeviceInformation &) |
Set the active GPU. More... | |
void | releaseDevice (DeviceInformation *) |
Releases the GPU device used by the active context at the time of calling (CUDA only). More... | |
std::string | getDeviceInformationString (const DeviceInformation &deviceInfo) |
Formats and returns a device information string for a given GPU. More... | |
|
static |
Checks that device deviceInfo
is compatible and functioning.
Checks the given SYCL device for compatibility and runs a dummy kernel on it to determine whether the device functions properly.
[in] | deviceId | Device number (internal to GROMACS). |
[in] | deviceInfo | The device info pointer. |
std::vector<std::unique_ptr<DeviceInformation> > findDevices | ( | ) |
Find all GPUs in the system.
Will detect every GPU supported by the device driver in use. Must only be called if canPerformDeviceDetection()
has returned true. This routine also checks for the compatibility of each device and fill the deviceInfo array with the required information on each device: ID, device properties, status.
Note that this function leaves the GPU runtime API error state clean; this is implemented ATM in the CUDA flavor. This invalidates any existing CUDA streams, allocated memory on GPU, etc.
InternalError | if a GPU API returns an unexpected failure (because the call to canDetectGpus() should always prevent this occuring) |
std::string getDeviceInformationString | ( | const DeviceInformation & | deviceInfo | ) |
Formats and returns a device information string for a given GPU.
Given an index directly into the array of available GPUs, returns a formatted info string for the respective GPU which includes ID, name, compute capability, and detection status.
[in] | deviceInfo | An information on device that is to be set. |
|
static |
Checks that device deviceInfo
is compatible with GROMACS.
[in] | syclDevice | SYCL device handle. |
[in] | deviceVendor | Device vendor. |
[in] | supportedSubGroupSizes | List of supported sub-group sizes as reported by the device. |
bool isDeviceDetectionFunctional | ( | std::string * | errorMessage | ) |
Return whether GPU detection is functioning correctly.
Returns true when this is a build of GROMACS configured to support GPU usage, and a valid device driver, ICD, and/or runtime was detected.
This function is not intended to be called from build configurations that do not support GPUs, and there will be no descriptive message in that case.
[out] | errorMessage | When returning false on a build configured with GPU support and non-nullptr was passed, the string contains a descriptive message about why GPUs cannot be detected. |
Does not throw.
|
static |
Checks that device deviceInfo
is sane (ie can run a kernel).
Compiles and runs a dummy kernel to determine whether the given SYCL device functions properly.
[in] | syclDevice | The device info pointer. |
[out] | errorMessage | An error message related to a SYCL error. |
std::bad_alloc | When out of memory. |
void releaseDevice | ( | DeviceInformation * | deviceInfo | ) |
Releases the GPU device used by the active context at the time of calling (CUDA only).
If deviceInfo
is nullptr, then it is understood that no device was selected so no context is active to be freed. Otherwise, the context is explicitly destroyed and therefore all data uploaded to the GPU is lost. This must only be called when none of this data is required anymore, because subsequent attempts to free memory associated with the context will otherwise fail.
Calls gmx_warning
upon errors.
[in] | deviceInfo | Information on the device to be released. |
void setActiveDevice | ( | const DeviceInformation & | deviceInfo | ) |
Set the active GPU.
This sets the device for which the device information is passed active. Essential in CUDA, where the device buffers and kernel launches are not connected to the device context. In OpenCL, checks the device vendor and makes vendor-specific performance adjustments.
[in] | deviceInfo | Information on the device to be set. |
Issues a fatal error for any critical errors that occur during initialization.
void warnWhenDeviceNotTargeted | ( | const gmx::MDLogger & | mdlog, |
const DeviceInformation & | deviceInfo | ||
) |
Warn to the logger when the detected device was not one of the targets selected at configure time for compilation.
[in] | mdlog | Logger |
[in] | deviceInfo | The device to potentially warn about |