Include nvml at runtime (#26)

* handle nvml dynamically

* make nvmlLib instead of using HMODULE

* Update main.cpp

* remove CUDA from CI

* uhhhhh lol

Author: Erimelowo

.github/workflows/vs17.yml

@@ -10,10 +10,6 @@ jobs:
         with:
           submodules: true
           fetch-depth: 0
-      - uses: Jimver/cuda-toolkit@v0.2.10
-        id: cuda-toolkit
-        with:
-          cuda: '12.1.0'
       - name: Configure
         run: cmake -B build
       - name: Build Debug

CMakeLists.txt

@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.15)
+cmake_minimum_required(VERSION 3.17)
 
 project(OpenVR-Dynamic-Resolution)
 
@@ -25,11 +25,10 @@ include_directories(include)
 set(CMAKE_SKIP_BUILD_RPATH  FALSE)
 set(CMAKE_BUILD_WITH_INSTALL_RPATH TRUE)
 set(CMAKE_INSTALL_RPATH $ORIGIN)
-include_directories("C:/Program Files/NVIDIA GPU Computing Toolkit/CUDA/v12.1/include")
 
 # Project
 add_executable("${PROJECT_NAME}" "src/main.cpp" "src/pathtools_excerpt.cpp" "src/setup.cpp")
-target_link_libraries("${PROJECT_NAME}" PRIVATE "${OPENVR_LIB}" fmt::fmt-header-only ${CURSES_LIBRARIES} "C:/Program Files/NVIDIA GPU Computing Toolkit/CUDA/v12.1/lib/x64/nvml.lib")
+target_link_libraries("${PROJECT_NAME}" PRIVATE "${OPENVR_LIB}" fmt::fmt-header-only ${CURSES_LIBRARIES})
 target_include_directories("${PROJECT_NAME}" PUBLIC ${protos_OUTPUT_DIR} PRIVATE ${CMAKE_CURRENT_BINARY_DIR})
 target_compile_features("${PROJECT_NAME}" PRIVATE cxx_std_17)
 

README.md

@@ -61,9 +61,7 @@ Settings are found in the `settings.ini` file. Do not rename that file. It shoul
 
 ## Building from source
 
-We assume that you already have Git, Cuda and CMake installed.
-Depending on where you installed cuda, you may need to edit the include and lib paths in the CMakeLists.txt file.  
-It is assumed that you have cuda 12.1, however, older versions may work if the path is specified.  
+We assume that you already have Git and CMake installed.
 To build the project, run:
 
 ```

src/main.cpp

@@ -5,8 +5,10 @@
 #include <args.hxx>
 #include <curses.h>
 #include <stdlib.h>
-#if __has_include("nvml.h")
-#include <nvml.h>
+#ifdef _WIN32
+#include <Windows.h>
+#else
+#include <dlfcn.h>
 #endif
 
 #include "SimpleIni.h"
@@ -15,7 +17,7 @@
 using namespace std::chrono_literals;
 using namespace vr;
 
-static constexpr const char *version = "v.0.3.1";
+static constexpr const char *version = "v.0.3.2";
 
 int autoStart = 1;
 int minimizeOnStart = 0;
@@ -39,33 +41,59 @@ float vramTarget = 0.8;
 float vramLimit = 0.9;
 int vramMonitorEnabled = 1;
 
-#if __has_include("nvml.h")
-nvmlDevice_t nvmlDevice;
+// NVML stuff
+typedef enum nvmlReturn_enum
+{
+	NVML_SUCCESS = 0,					// The operation was successful.
+	NVML_ERROR_UNINITIALIZED = 1,		// NVML was not first initialized with nvmlInit().
+	NVML_ERROR_INVALID_ARGUMENT = 2,	// A supplied argument is invalid.
+	NVML_ERROR_NOT_SUPPORTED = 3,		// The requested operation is not available on target device.
+	NVML_ERROR_NO_PERMISSION = 4,		// The currrent user does not have permission for operation.
+	NVML_ERROR_ALREADY_INITIALIZED = 5, // NVML has already been initialized.
+	NVML_ERROR_NOT_FOUND = 6,			// A query to find an object was unccessful.
+	NVML_ERROR_UNKNOWN = 7,				// An internal driver error occurred.
+} nvmlReturn_t;
+typedef nvmlReturn_t (*nvmlInit_t)();
+typedef nvmlReturn_t (*nvmlShutdown_t)();
+typedef struct
+{
+	unsigned long long total;
+	unsigned long long free;
+	unsigned long long used;
+} nvmlMemory_t;
+typedef nvmlReturn_t (*nvmlDevice_t)();
+typedef nvmlReturn_t (*nvmlDeviceGetHandleByIndex_t)(unsigned int, nvmlDevice_t *);
+typedef nvmlReturn_t (*nvmlDeviceGetMemoryInfo_t)(nvmlDevice_t, nvmlMemory_t *);
+#ifdef _WIN32
+typedef HMODULE(nvmlLib);
+#else
+typedef void *(nvmlLib);
 #endif
 
-float getVramUsage()
+nvmlDevice_t nvmlDevice;
+
+float getVramUsage(nvmlLib nvmlLibrary)
 {
-	if (vramMonitorEnabled == 0)
-	{
+	if (vramMonitorEnabled == 0 || !nvmlLibrary)
 		return 0.0f;
-	}
-	#if __has_include("nvml.h")
+
 	nvmlReturn_t result;
-	nvmlMemory_t memory;
+	nvmlMemory_t memoryInfo;
 	unsigned int deviceCount;
 
 	// Get memory info
-	result = nvmlDeviceGetMemoryInfo(nvmlDevice, &memory);
+	nvmlDeviceGetMemoryInfo_t nvmlDeviceGetMemoryInfoPtr;
+#ifdef _WIN32
+	nvmlDeviceGetMemoryInfoPtr = (nvmlDeviceGetMemoryInfo_t)GetProcAddress(nvmlLibrary, "nvmlDeviceGetMemoryInfo");
+#else
+	nvmlDeviceGetMemoryInfoPtr = (nvmlDeviceGetMemoryInfo_t)dlsym(nvmlLibrary, "nvmlDeviceGetMemoryInfo");
+#endif
+	result = nvmlDeviceGetMemoryInfoPtr(nvmlDevice, &memoryInfo);
 	if (result != NVML_SUCCESS)
-	{
-		return -1.0f;
-	}
+		return -result;
 
 	// Return VRAM usage as a percentage
-	return (float)memory.used / (float)memory.total;
-	#endif
-
-	return 0.0f;
+	return (float)memoryInfo.used / (float)memoryInfo.total;
 }
 
 bool loadSettings()
@@ -110,6 +138,12 @@ long getCurrentTimeMillis()
 
 int main(int argc, char *argv[])
 {
+#ifdef _WIN32
+	HMODULE nvmlLibrary = LoadLibraryA("nvml.dll");
+#else
+	void *nvmlLibrary = dlopen("libnvidia-ml.so", RTLD_LAZY);
+#endif
+
 	int rows, cols;		 // max rows and cols
 	initscr();			 // Initialize screen
 	cbreak();			 // Disable line-buffering (for input)
@@ -147,11 +181,6 @@ int main(int argc, char *argv[])
 		ShowWindow(GetConsoleWindow(), SW_HIDE);
 #endif
 
-#if defined(__linux__)
-	// VRAM monitoring is not supported on Linux
-	vramMonitorEnabled = false;
-#endif
-
 	// Set auto-start
 	int autoStartResult = handle_setup(autoStart);
 
@@ -175,27 +204,49 @@ int main(int argc, char *argv[])
 	vr::VRSettings()->SetFloat(vr::k_pch_SteamVR_Section,
 							   vr::k_pch_SteamVR_SupersampleScale_Float, initialRes);
 
-	// Initialise VRAM monitoring stuff
-	#if __has_include("nvml.h")
+	// Initialise NVML
+	nvmlInit_t nvmlInitPtr;
+#ifdef _WIN32
+	nvmlInitPtr = (nvmlInit_t)GetProcAddress(nvmlLibrary, "nvmlInit");
+#else
+	nvmlInitPtr = (nvmlInit_t)dlsym(nvmlLibrary, "nvmlShutdown");
+#endif
+	if (!nvmlInitPtr)
+		vramMonitorEnabled = 0;
 	if (vramMonitorEnabled == 1)
 	{
 		nvmlReturn_t result;
 		// Initialize NVML library
-		result = nvmlInit();
-		if (NVML_SUCCESS != result)
-		{
+		result = nvmlInitPtr();
+		if (result != NVML_SUCCESS)
 			vramMonitorEnabled = 0;
-		}
 
 		// Get device handle
-		result = nvmlDeviceGetHandleByIndex(0, &nvmlDevice);
-		if (NVML_SUCCESS != result)
+		nvmlDeviceGetHandleByIndex_t nvmlDeviceGetHandleByIndexPtr;
+#ifdef _WIN32
+		nvmlDeviceGetHandleByIndexPtr = (nvmlDeviceGetHandleByIndex_t)GetProcAddress(nvmlLibrary, "nvmlDeviceGetHandleByIndex");
+#else
+		nvmlDeviceGetHandleByIndexPtr = (nvmlDeviceGetHandleByIndex_t)dlsym(nvmlLibrary, "nvmlDeviceGetHandleByIndex");
+#endif
+		if (!nvmlDeviceGetHandleByIndexPtr)
+			vramMonitorEnabled = 0;
+		else
+			result = nvmlDeviceGetHandleByIndexPtr(0, &nvmlDevice);
+		if (result != NVML_SUCCESS || vramMonitorEnabled == 0)
 		{
-			nvmlShutdown();
+			nvmlShutdown_t nvmlShutdownPtr;
+#ifdef _WIN32
+			nvmlShutdownPtr = (nvmlShutdown_t)GetProcAddress(nvmlLibrary, "nvmlShutdown");
+#else
+			nvmlShutdownPtr = (nvmlShutdown_t)dlsym(nvmlLibrary, "nvmlShutdown");
+#endif
 			vramMonitorEnabled = 0;
+			if (nvmlShutdownPtr)
+			{
+				nvmlShutdownPtr();
+			}
 		}
 	}
-	#endif
 
 	// Initialize loop variables
 	long lastChangeTime = getCurrentTimeMillis();
@@ -279,7 +330,7 @@ int main(int argc, char *argv[])
 		mvprintw(9, 0, "%s", fmt::format("GPU frametime: {} ms", displayedAverageTime).c_str());
 		if (vramMonitorEnabled)
 		{
-			std::string vramUsage = std::to_string(getVramUsage() * 100).substr(0, 4);
+			std::string vramUsage = std::to_string(getVramUsage(nvmlLibrary) * 100).substr(0, 4);
 			mvprintw(10, 0, "%s", fmt::format("VRAM usage: {}%", vramUsage).c_str());
 		}
 		else
@@ -315,8 +366,8 @@ int main(int argc, char *argv[])
 		if (currentTime - resChangeDelayMs > lastChangeTime)
 		{
 			lastChangeTime = currentTime;
-			bool vramLimitReached = vramLimit < getVramUsage();
-			bool vramTargetReached = vramTarget < getVramUsage();
+			bool vramLimitReached = vramLimit < getVramUsage(nvmlLibrary);
+			bool vramTargetReached = vramTarget < getVramUsage(nvmlLibrary);
 			bool dashboardOpen = VROverlay()->IsDashboardVisible();
 
 			if (averageGpuTime > minGpuTimeThreshold && !dashboardOpen)
@@ -386,4 +437,24 @@ int main(int argc, char *argv[])
 		// ZZzzzz
 		std::this_thread::sleep_for(std::chrono::milliseconds(sleepTime));
 	}
+
+	// TODO actually be able to get out of the while loop
+
+#ifdef _WIN32
+	nvmlShutdown_t nvmlShutdownPtr = (nvmlShutdown_t)GetProcAddress(nvmlLibrary, "nvmlShutdown");
+	if (nvmlShutdownPtr)
+	{
+		nvmlShutdownPtr();
+	}
+	FreeLibrary(nvmlLibrary);
+#else
+	nvmlShutdown_t nvmlShutdownPtr = (nvmlShutdown_t)dlsym(nvmlLibrary, "nvmlShutdown");
+	if (nvmlShutdownPtr)
+	{
+		nvmlShutdownPtr();
+	}
+	dlclose(nvmlLibrary);
+#endif
+
+	return 0;
 }