start_index.cpp

Go to the documentation of this file.

/******************************************************************************
 * Copyright 2023 NVIDIA Corporation. All rights reserved.
 *****************************************************************************/
 
// Note: This is an example without Index_connect. Usual case, we
// recommend to use the convenient class: Index_connect in the
// application_layer.
 
#include <mi/dice.h>
#include <nv/index/iindex.h>
 
#include <cstdio>
#include <iostream>
#include <map>
#include <sstream>
#include <string>
 
#ifndef MI_PLATFORM_WINDOWS
#include <dlfcn.h>
#else
#include <windows.h>
#endif  // MI_PLATFORM_WINDOWS
 
//----------------------------------------------------------------------
namespace {                     // anonymous namespace for the local functions
//----------------------------------------------------------------------
// Helper macro. Checks whether the expression is true and if not prints a message and exits.
//
// Note: gcc accepts ({}) expression, but intel compiler said 
//    error: destructible entities are not allowed inside of a statement
//    expression
// Therefore outmost () has been removed.
#define check_success(expr) \
    { if (!(expr)) { \
            fprintf(stderr, "Error in file %s, line %d: \"%s\".\n", __FILE__, __LINE__, #expr); \
            exit(EXIT_FAILURE); } }
 
//----------------------------------------------------------------------
// global variables to keep the library name and handles
static std::string G_nvindexlib_fname;
static void * G_p_handle = 0;
 
//----------------------------------------------------------------------
// print a info message to stdout if not unittest mode
//
// This function is a kind of logger, but used when the dice is not
// started or shutdown-ed.
//
// \param[in] message message output
// \param[in] opt_map option map that should contain dice::verbosity key value.
void info_cout(
    const std::string&                      message,
    std::map< std::string, std::string >&   opt_map)
{
    if(opt_map.find("dice::verbose") == opt_map.end())
    {
        // no verbose option found, just output all
        std::cout << "info: " << message << std::endl;
        return;
    }
    // when verbose option is less than there, return.
    std::string lv = opt_map["dice::verbose"];
    if((lv == "0") || (lv == "1") || (lv == "2")){
        return;
    }
    std::cout << "info: " << message << std::endl;
}
 
//----------------------------------------------------------------------
// Loads the nvindex library and calls the main factory function.
//
// \param nvindexlib_fname The file name of the IndeX library DSO.
// \return A pointer to an instance of the main
// nv::index::IIndex interface
nv::index::IIndex* load_and_get_iindex(const std::string & nvindexlib_fname)
{
#ifdef MI_PLATFORM_WINDOWS
    G_p_handle = LoadLibrary(TEXT(nvindexlib_fname.c_str()));
    if (!G_p_handle)
    {
        printf("error: Could not retrieve a handle to the %s library\n", nvindexlib_fname.c_str());
        return NULL;
    }
    void* symbol = GetProcAddress((HMODULE)G_p_handle, "nv_factory");
    if (!symbol)
    {
        printf("error: Could not retrieve the entry point into the %s library\n", nvindexlib_fname.c_str());
        return NULL;
    }
#else // MI_PLATFORM_WINDOWS
    G_p_handle = dlopen(nvindexlib_fname.c_str(), RTLD_LAZY);
    if (!G_p_handle) {
        printf("error: iindex: handle: %s\n", dlerror());
        return 0;
    }
 
    void* symbol = dlsym(G_p_handle, "nv_factory");
    if (!symbol) {
        printf("error: iindex: symbol: %s\n", dlerror());
        return NULL;
    }
#endif // MI_PLATFORM_WINDOWS
 
    G_nvindexlib_fname = nvindexlib_fname;
 
    return nv::index::nv_factory<nv::index::IIndex>(symbol);
}
 
//----------------------------------------------------------------------
// Unloads the nvindex library.
// \param[in] opt_map option map that should contain dice::verbosity key value.
// \return true when succeeded
bool unload_iindex(std::map< std::string, std::string > & opt_map)
{
    check_success(G_p_handle != 0);
#ifdef MI_PLATFORM_WINDOWS
    if (FALSE == FreeLibrary((HMODULE)G_p_handle)) {
        fprintf(stderr, "error: unload_iindex.\n");
        return false;
    }
#else // MI_PLATFORM_WINDOWS
    int result = dlclose(G_p_handle);
    if (result != 0) {
        fprintf(stderr, "error: unload_iindex: %s\n", dlerror());
        return false;
    }
 
#endif // MI_PLATFORM_WINDOWS
    return true;
}
 
//----------------------------------------------------------------------
// Creating and accessing an instance of NVIDIA IndeX library.
class Nvindex_access
{
public:
    // Constructor
    Nvindex_access()
    {
        // empty
    }
    // Destructor
    virtual ~Nvindex_access()
    {
        // empty
    }
 
    // Load nvindex library
    // \return true if loading was successful
    bool load_library();
 
    // Is the nvindex library initialized?
    // \return true when it has been initialized
    bool is_initialized() const
    {
        return m_nvindex_interface.is_valid_interface();
    }
 
    // Get to the nvindex interface
    // \return reference to the nvindex interface handle
    mi::base::Handle<nv::index::IIndex>& get_interface()
    {
        return m_nvindex_interface;
    }
 
    // Start IndeX service
    //  * start DiCE, IndeX
    // \return success when 0
    mi::Sint32 start_service()
    {
        check_success(m_nvindex_interface.is_valid_interface());
        m_nvindex_interface->start();
        // No application_layer support for this example.
        return 0;
    }
 
    // Shut down the nvindex and dice library
    // \return true when shutdown was successful
    bool shutdown();
 
    // clear the IIndex instance
    void clear()
    {
        m_nvindex_interface = 0;
    }
 
 
private:
    mi::base::Handle<nv::index::IIndex> m_nvindex_interface;
};
 
//----------------------------------------------------------------------
bool Nvindex_access::load_library()
{
    // load shared libraries.
    std::string lib_name = "libnvindex";
 
#if _WIN32
# ifdef DEBUG
    lib_name += "d.dll";
# else //  DEBUG
    lib_name += ".dll";
# endif // DEBUG
#else // _WIN32
    lib_name += ".so";
#endif // _WIN32
 
    m_nvindex_interface = load_and_get_iindex(lib_name);
 
    check_success(m_nvindex_interface != 0);
 
    return true;
}
 
//----------------------------------------------------------------------
bool Nvindex_access::shutdown()
{
    check_success(m_nvindex_interface.is_valid_interface());
    const mi::Sint32 nvi_shutdown = m_nvindex_interface->shutdown();
    if(nvi_shutdown != 0){
        fprintf(stderr, "error: failed IndeX library shutdown (code: %d)\n", nvi_shutdown);
    }
 
    return nvi_shutdown == 0;
}
 
//----------------------------------------------------------------------
} // namespace anonymous
//----------------------------------------------------------------------
// The main function initializes the NVIDIA IndeX library,
// starts it, and shuts it down after waiting for user input.
int main(int argc, char* argv[])
{
    const std::string com_name(argv[0]);
 
    std::map< std::string, std::string > opt_map;
    opt_map["dice::verbose"]  = "3";                        // log level
    opt_map["unittest"]       = "0";                              // default mode
 
    if(opt_map["unittest"] == "1")
    {
        opt_map["dice::verbose"] = "2";
    }
    info_cout("running " + com_name, opt_map);
 
    // Load NVIDIA IndeX library.
    Nvindex_access nvindex_accessor;
    check_success(nvindex_accessor.load_library());
 
    // Start IndeX service
    nvindex_accessor.start_service();
 
    // Access NVIDIA IndeX and DiCE API and library version once the NVIDIA IndeX has been started.
    info_cout("NVIDIA IndeX version: " + std::string(nvindex_accessor.get_interface()->get_version()), opt_map);
 
    const char* version = nvindex_accessor.get_interface()->get_dice_version();
    check_success(version != 0);
    info_cout("DiCE header  API version           = " + std::string(MI_NEURAYLIB_VERSION_QUALIFIED_STRING), opt_map);
    info_cout("DiCE library build version string  = \"" + std::string(version) + "\".",      opt_map);
 
    // Shut down NVIDIA IndeX library.
    check_success(nvindex_accessor.shutdown());
 
    // Clear the instance before unloading the library.
    nvindex_accessor.clear();
 
    // Unload the libraries.
    check_success(unload_iindex(opt_map));
 
    return EXIT_SUCCESS;
}