dynamic_loading.h

Go to the documentation of this file.

/*
 *  SPDX-FileCopyrightText: Copyright 2021, Siavash Ameli <sameli@berkeley.edu>
 *  SPDX-License-Identifier: BSD-3-Clause
 *  SPDX-FileType: SOURCE
 *
 *  This program is free software: you can redistribute it and/or modify it
 *  under the terms of the license found in the LICENSE.txt file in the root
 *  directory of this source tree.
 */
 
 
#ifndef _CUDA_DYNAMIC_LOADING_DYNAMIC_LOADING_H_
#define _CUDA_DYNAMIC_LOADING_DYNAMIC_LOADING_H_
 
 
// =======
// Headers
// =======
 
#if defined(WIN32) || defined(_WIN32) || defined(__WIN32) && \
    !defined(__CYGWIN__)
    #include <windows.h>  // HMODULE, TEXT, LoadLibrary, GetProcAddress
#elif defined(__unix__) || defined(__unix) || \
    (defined(__APPLE__) && defined(__MACH__))
    #include <dlfcn.h>  // dlopen, dlsym
#else
    #error "Unknown compiler"
#endif
#include <stdexcept>  // std::runtime_error
#include <sstream>  // std::ostringstream
 
 
// ===============
// dynamic loading
// ===============
 
 
namespace dynamic_loading
{
    // ==================
    // get library handle (unix)
    // ==================
 
    #if defined(__unix__) || defined(__unix) || \
        (defined(__APPLE__) && defined(__MACH__))
 
        static void* get_library_handle_unix(const char* lib_name)
        { 
            void* handle = dlopen(lib_name, RTLD_LAZY);
 
            if (!handle)
            {
                throw std::runtime_error(dlerror());
            }
 
            return handle;
        }
    #endif
 
 
    // ==================
    // get library handle (windows)
    // ==================
 
    #if defined(WIN32) || defined(_WIN32) || defined(__WIN32) && \
            !defined(__CYGWIN__)
 
        static HMODULE get_library_handle_windows(const char* lib_name)
        { 
            HMODULE handle = LoadLibrary(TEXT(lib_name));
 
            if (!handle)
            {
                std::ostringstream oss;
                oss << "Cannot load the shared library '" << lib_name << "'." \
                    << std::endl;
                std::string message = oss.str();
                throw std::runtime_error(message);
            }
 
            return handle;
        }
    #endif
 
 
    // ===========
    // load symbol
    // ===========
 
 
    template <typename Signature>
    Signature load_symbol(
            const char* lib_name,
            const char* symbol_name)
    {
        #if defined(WIN32) || defined(_WIN32) || defined(__WIN32) && \
                !defined(__CYGWIN__)
 
            HMODULE handle = get_library_handle_windows(lib_name);
            FARPROC symbol = GetProcAddress(handle, symbol_name);
 
            if (symbol == NULL)
            {
                std::ostringstream oss;
                oss << "The symbol '" << symbol << "' is failed to load " \
                    << "from the shared library '" << lib_name << "'." \
                    << std::endl;
                std::string message = oss.str();
                throw std::runtime_error(message);
            }
 
        #elif defined(__unix__) || defined(__unix) || \
            (defined(__APPLE__) && defined(__MACH__))
 
            void* handle = get_library_handle_unix(lib_name);
            void* symbol = dlsym(handle, symbol_name);
 
            char *error = dlerror();
            if (error != NULL)
            {
                throw std::runtime_error(dlerror());
            }
 
        #else
            #error "Unknown compiler"
        #endif
 
 
        return reinterpret_cast<Signature>(symbol);
    }
 
}  // namespace dynamic_loading
 
#endif  // _CUDA_DYNAMIC_LOADING_DYNAMIC_LOADING_H_