[REVIEW] Add GPU and CUDA validations

cpp/CMakeLists.txt

@@ -546,6 +546,7 @@ add_library(cudf
             src/utilities/legacy/error_utils.cpp
             src/utilities/nvtx/nvtx_utils.cpp
             src/utilities/nvtx/legacy/nvtx_utils.cpp
+            src/utilities/device.cu
             src/copying/copy.cpp
             src/copying/scatter.cu
             src/copying/shift.cu

cpp/include/cudf/utilities/device.hpp

@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) 2020, NVIDIA CORPORATION.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+
+namespace cudf {
+namespace experimental {
+
+/**
+ * @brief Returns the version number of the current CUDA Runtime instance.
+ * The version is returned as (1000 major + 10 minor). For example,
+ * CUDA 9.2 would be represented by 9020.
+ *
+ * This function returns -1 if runtime version is NULL.
+ *
+ * @return Integer containing the version of current CUDA Runtime.
+ */
+int get_cuda_runtime_version();
+
+
+/**
+ * @brief Returns the number of devices with compute capability greater or
+ * equal to 2.0 that are available for execution.
+ *
+ * This function returns -1 if NULL device pointer is assigned.
+ *
+ * @return Integer containing the number of compute-capable devices.
+ */
+int get_gpu_device_count();
+
+
+/**
+ * @brief Returns in the latest version of CUDA supported by the driver.
+ * The version is returned as (1000 major + 10 minor). For example,
+ * CUDA 9.2 would be represented by 9020. If no driver is installed,
+ * then 0 is returned as the driver version.
+ *
+ * This function returns -1 if driver version is NULL.
+ *
+ * @return Integer containing the latest version of CUDA supported by the driver.
+ */
+
+int get_cuda_latest_supported_driver_version();
+
+}  // namespace experimental
+}  // namespace cudf

cpp/src/utilities/device.cu

@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) 2020, NVIDIA CORPORATION.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <cuda_runtime_api.h>
+#include <cuda.h>
+
+namespace cudf {
+namespace experimental {
+
+/**
+ * @brief Returns the version number of the current CUDA Runtime instance.
+ * The version is returned as (1000 major + 10 minor). For example,
+ * CUDA 9.2 would be represented by 9020.
+ *
+ * This function returns -1 if runtime version is NULL.
+ *
+ * @return Integer containing the version of current CUDA Runtime.
+ */
+int get_cuda_runtime_version() {
+    int runtimeVersion;
+    cudaError_t status;
+    status = cudaRuntimeGetVersion(&runtimeVersion);
+    if (status != cudaSuccess) {
+      // If there is no GPU / any issues with the run time
+      // like driver initialization or Insufficient driver. 
+      return -1;
+    }
+    return runtimeVersion;
+}
+
+/**
+ * @brief Returns the number of devices with compute capability greater or
+ * equal to 2.0 that are available for execution.
+ *
+ * This function returns -1 if NULL device pointer is assigned.
+ *
+ * @return Integer containing the number of compute-capable devices.
+ */
+int get_gpu_device_count() {
+    int deviceCount;
+    cudaError_t status;
+    status = cudaGetDeviceCount(&deviceCount);
+    if (status != cudaSuccess) {
+      // If there is no GPU / any issues with the run time
+      // like driver initialization or Insufficient driver. 
+      return -1;
+    }
+    return deviceCount;
+}
+
+/**
+ * @brief Returns in the latest version of CUDA supported by the driver.
+ * The version is returned as (1000 major + 10 minor). For example,
+ * CUDA 9.2 would be represented by 9020. If no driver is installed,
+ * then 0 is returned as the driver version.
+ *
+ * This function returns -1 if driver version is NULL.
+ *
+ * @return Integer containing the latest version of CUDA supported by the driver.
+ */
+int get_cuda_latest_supported_driver_version() {
+  int driverVersion;
+  cudaError_t status;
+  status = cudaDriverGetVersion(&driverVersion);
+  if (status != cudaSuccess) {
+    // If there is no GPU / any issues with the run time
+    // like driver initialization or Insufficient driver. 
+    return -1;
+  }
+  return driverVersion;
+}
+
+}  // namespace experimental
+}  // namespace cudf

python/cudf/cudf/__init__.py

@@ -1,9 +1,15 @@
 # Copyright (c) 2018-2019, NVIDIA CORPORATION.
+""" __init__.py
 
-import cupy
+   isort:skip_file
+"""
 
-import rmm
+from cudf.utils.gpu_utils import validate_setup
+
+validate_setup()
 
+import cupy
+import rmm
 from cudf import core, datasets
 from cudf._version import get_versions
 from cudf.core import DataFrame, Index, MultiIndex, Series, from_pandas, merge

python/cudf/cudf/errors.py

@@ -0,0 +1,9 @@
+# Copyright (c) 2020, NVIDIA CORPORATION.
+
+
+class UnSupportedGPUError(Exception):
+    pass
+
+
+class UnSupportedCUDAError(Exception):
+    pass

python/cudf/cudf/utils/gpu.pxd

@@ -0,0 +1,9 @@
+# Copyright (c) 2020, NVIDIA CORPORATION.
+
+
+cdef extern from "cudf/utilities/device.hpp" namespace \
+        "cudf::experimental" nogil:
+
+    cdef int get_cuda_runtime_version() except +
+    cdef int get_gpu_device_count() except +
+    cdef int get_cuda_latest_supported_driver_version() except +

python/cudf/cudf/utils/gpu.pyx

@@ -0,0 +1,29 @@
+# Copyright (c) 2020, NVIDIA CORPORATION.
+
+from cudf.utils.gpu cimport (
+    get_cuda_runtime_version as cpp_get_cuda_runtime_version,
+    get_gpu_device_count as cpp_get_gpu_device_count,
+    get_cuda_latest_supported_driver_version as
+    cpp_get_cuda_latest_supported_driver_version
+)
+
+
+def get_cuda_runtime_version():
+    cdef int c_result
+    with nogil:
+        c_result = cpp_get_cuda_runtime_version()
+    return c_result
+
+
+def get_gpu_device_count():
+    cdef int c_result
+    with nogil:
+        c_result = cpp_get_gpu_device_count()
+    return c_result
+
+
+def get_cuda_latest_supported_driver_version():
+    cdef int c_result
+    with nogil:
+        c_result = cpp_get_cuda_latest_supported_driver_version()
+    return c_result

python/cudf/cudf/utils/gpu_utils.py

@@ -0,0 +1,74 @@
+def validate_setup():
+    from .gpu import get_gpu_device_count
+
+    gpus_count = get_gpu_device_count()
+
+    if gpus_count > 0:
+        # Cupy throws RunTimeException to get GPU count,
+        # hence obtaining GPU count by in-house cpp api above
+        import cupy
+
+        # 75 - Indicates to get "cudaDevAttrComputeCapabilityMajor" attribute
+        # 0 - Get GPU 0
+        major_version = cupy.cuda.runtime.deviceGetAttribute(75, 0)
+
+        if major_version >= 6:
+            # You have a GPU with NVIDIA Pascal™ architecture or better
+            # Hardware Generation	Compute Capability
+            #    Turing	                7.5
+            #    Volta	                7.x
+            #    Pascal	                6.x
+            #    Maxwell	            5.x
+            #    Kepler	                3.x
+            #    Fermi	                2.x
+            pass
+        else:
+            from cudf.errors import UnSupportedGPUError
+
+            raise UnSupportedGPUError(
+                "You will need a GPU with NVIDIA Pascal™ architecture or \
+                    better"
+            )
+
+        cuda_runtime_version = cupy.cuda.runtime.runtimeGetVersion()
+
+        if cuda_runtime_version > 10000:
+            # CUDA Runtime Version Check: Runtime version is greater than 10000
+            pass
+        else:
+            from cudf.errors import UnSupportedCUDAError
+
+            raise UnSupportedCUDAError(
+                "Please update your CUDA Runtime to 10.0 or above"
+            )
+
+        cuda_driver_version = cupy.cuda.runtime.driverGetVersion()
+
+        if cuda_driver_version == 0:
+            from cudf.errors import UnSupportedCUDAError
+
+            raise UnSupportedCUDAError("Please install CUDA Driver")
+        elif cuda_driver_version >= cuda_runtime_version:
+            # CUDA Driver Version Check:
+            # Driver Runtime version is >= Runtime version
+            pass
+        else:
+            from cudf.errors import UnSupportedCUDAError
+
+            raise UnSupportedCUDAError(
+                "Please update your NVIDIA GPU Driver to support CUDA \
+                    Runtime.\n"
+                "Detected CUDA Runtime version : "
+                + str(cuda_runtime_version)
+                + "\n"
+                "Latest version of CUDA \
+                    supported by current NVIDIA GPU Driver : "
+                + str(cuda_driver_version)
+            )
+
+    else:
+        import warnings
+
+        warnings.warn(
+            "You donot have an NVIDIA GPU, please install one and try again"
+        )