cluster_rendering_remotehost.cpp

Go to the documentation of this file.

/******************************************************************************
 * Copyright 2023 NVIDIA Corporation. All rights reserved.
 *****************************************************************************/
 
#include <mi/dice.h>
 
// Include code shared by all examples.
#include "utility/example_shared.h"
 
#include <nv/index/iindex.h>
 
#include <iostream>
#include <sstream>
#include <map>
#include <stdlib.h>
 
#include "utility/app_rendering_context.h"
 
#include <nv/index/app/forwarding_logger.h>
#include <nv/index/app/string_dict.h>
#include <nv/index/app/time_functions.h>
#include <nv/index/app/index_connect_.h> // FIXME should be updated to index_connect.h
 
namespace {                     // anonymous namespace for the local functions
 
//----------------------------------------------------------------------
// Local Index_connect for cluster_rendering_mainhost
class Cluster_rendering_remotehost_index_connect:
        public nv::index::app::Index_connect
{
public:
    Cluster_rendering_remotehost_index_connect()
        :
        Index_connect()
    {
        // INFO_LOG << "DEBUG: Cluster_rendering_remotehost_index_connect() ctor";
    }
 
    virtual ~Cluster_rendering_remotehost_index_connect()
    {
        // Note: Index_connect::~Index_connect() will be called after here.
        // INFO_LOG << "DEBUG: ~Cluster_rendering_remotehost_index_connect() dtor";
    }
 
protected:
    // override for unittest support
    virtual bool initialize_networking(
        mi::neuraylib::INetwork_configuration* network_configuration,
        nv::index::app::String_dict&           options) CPP11_OVERRIDE
    {
        check_success(network_configuration != 0);
 
        check_success(options.is_defined("unittest"));
        const bool is_unittest = nv::index::app::get_bool(options.get("unittest"));
        if (is_unittest)
        {
            info_cout("NETWORK: disabled networking mode.", options);
            network_configuration->set_mode(mi::neuraylib::INetwork_configuration::MODE_OFF);
        }
 
        return initialize_networking_as_default_udp(network_configuration, options);
    }
 
    // override
    virtual bool register_serializable_classes(
        mi::neuraylib::IDice_configuration* configuration_interface,
        nv::index::app::String_dict&        options) CPP11_OVERRIDE
    {
        // bool is_registered = false;
        // is_registered = get_index_interface()->register_serializable_class<Arrow_manipulator>();
        // check_success(is_registered);
        // return is_registered;
        return true;
    }
 
    // override
    virtual bool initialize_debug_configuration(
        mi::neuraylib::IDebug_configuration* debug_configuration,
        nv::index::app::String_dict&         options) CPP11_OVERRIDE
    {
        check_success(debug_configuration != 0);
        if (options.is_defined("dice::idebug_config::retention"))
        {
            bool conv_stat = false;
            const std::string retension = options.get("dice::idebug_config::retention");
            const mi::Sint32  debug_retention = nv::index::app::get_sint32(retension, &conv_stat);
            if (!conv_stat)
            {
                ERROR_LOG << "initialize_index_debug_configuration: failed integer conversion of dice::idebug_config::retention: "
                          << debug_retention;
                return false;
            }
 
            if(debug_retention > 0)
            {
                std::stringstream sstr;
                sstr << "retention=" << debug_retention;
                debug_configuration->set_option(sstr.str().c_str());
                INFO_LOG << "Set IDebug_configuration: " << sstr.str();
            }
        }
 
        return true;
    }
 
    // override    
    virtual bool initialize_general_configuration(
        mi::neuraylib::IGeneral_configuration* general_configuration,
        nv::index::app::String_dict&           options) CPP11_OVERRIDE
    {
        check_success(general_configuration != 0);
        general_configuration->set_host_property("sub_cluster_id", "0"); // set default cluster id 0
        return true;
    }
};
 
//----------------------------------------------------------------------
// Remote rendering loop
//
// \param[in] nvindex_accessor nvindex accessor
// \param[in] arc application rendering context
// \param[in] opt_map command line option map
// \return true when success
bool remote_rendering_loop(
    Cluster_rendering_remotehost_index_connect& index_connect,
    App_rendering_context&                      arc,
    nv::index::app::String_dict&                sdict)
{
    mi::base::Handle<nv::index::ICluster_configuration> rendering_properties_query(
        index_connect.get_index_interface()->get_api_component<nv::index::ICluster_configuration>());
    check_success(rendering_properties_query.is_valid_interface());
 
    mi::Uint32 number_of_hosts = rendering_properties_query->get_number_of_hosts();
 
    std::stringstream sstr;
    sstr << "**********************************************************************\n"
         << "info: NVIDIA IndeX remote service running and waiting for connections,\n"
         << "info: Cluster host id = " << rendering_properties_query->get_local_host_id() << "\n"
         << "info: ****************************************************************";
    INFO_LOG << sstr.str();
 
    check_success(sdict.is_defined("unittest"));
 
    const bool is_unittest = nv::index::app::get_bool(sdict.get("unittest", "false"));
    const mi::Sint32 remote_max_iter_when_unittest = 8;
 
    for(mi::Sint32 i = 0; true; ++i)
    {
        const mi::Uint32 new_number_of_hosts = rendering_properties_query->get_number_of_hosts();
 
        // Finish on lost host
        if (new_number_of_hosts < number_of_hosts)
        {
            std::stringstream sstr;
            sstr << "Leaving the NVIDIA IndeX remote service loop because at least one other cluster host has left. "
                 << "Previously, the cluster was composed by "
                 << number_of_hosts << " hosts. Now, only "
                 << new_number_of_hosts << " cluster hosts are left.";
            INFO_LOG << sstr.str();
 
            break;
        }
 
        // exit if unittest mode with max iters
        if (is_unittest&& (i>= remote_max_iter_when_unittest))
        {
            INFO_LOG << "The unit test exits because the test has reached the maximum number of iterations.";
 
            break;
        }
 
        number_of_hosts = new_number_of_hosts;
        nv::index::app::util::time::sleep(0.1f); // wait for 0.1 second
    }
 
    INFO_LOG << "Finished the NVIDIA IndeX remote service loop.";
 
    return true;
}
 
//----------------------------------------------------------------------
// set up as a remote host
//
// \param[in] nvindex_accessor nvindex library accessor
// \param[in,out] arc          application rendering context
// \return true when success
bool setup_remote_host(
    Cluster_rendering_remotehost_index_connect& index_connect,
    App_rendering_context&                      arc)
{
    arc.m_database = index_connect.get_index_interface()->get_api_component<mi::neuraylib::IDatabase>();
    check_success(arc.m_database.is_valid_interface());
 
    arc.m_global_scope = arc.m_database->get_global_scope();
    check_success(arc.m_global_scope.is_valid_interface());
 
    return true;
}
 
//----------------------------------------------------------------------
// network parameters
//
// \param[in,out] nvindex_accessor nvindex library accessor
// \param[in] opt_map command line option map
void config_network_parameters(
    Cluster_rendering_remotehost_index_connect& index_connect,
    nv::index::app::String_dict&                sdict)
{
    if (sdict.get("dice::network::additional_unicast_sockets", "0") != "0")
    {
        mi::base::Handle<mi::neuraylib::IDebug_configuration> debug_configuration(
            index_connect.get_index_interface()->get_api_component<mi::neuraylib::IDebug_configuration>());
        check_success(debug_configuration.is_valid_interface());
 
        std::stringstream sstr;
        sstr << "dice::network::additional_unicast_sockets="
             << sdict.get("dice::network::additional_unicast_sockets", "<undef>");
        const std::string additional_unicast_sockets = sstr.str();
        debug_configuration->set_option(additional_unicast_sockets.c_str());
    }
}
 
} // namespace anonymous
 
//----------------------------------------------------------------------
// main routine for the remote host
int main(int argc, char* argv[])
{
    const std::string com_name(argv[0]);
    nv::index::app::String_dict sdict;
    sdict.insert("dice::verbose", "3");                             // log level
    sdict.insert("dice::network::mode", "UDP");                     // network mode
    sdict.insert("dice::network::multicast_address", "239.43.1.1"); // multicast address
    sdict.insert("dice::network::additional_unicast_sockets", "0"); // default number of unicast sockets
    sdict.insert("unittest", "0");                                  // default mode
    sdict.insert("dice::idebug_config::retention", "0");            // retention
    sdict.insert("is_dump_comparison_image_when_failed", "1");      // default: dump images when failed.
    sdict.insert("is_call_from_test", "0");                         // default: not call from make check.
 
    Cluster_rendering_remotehost_index_connect index_connect;
    index_connect.process_command_line_arguments(argc, argv, sdict);
 
    if (nv::index::app::get_bool(sdict.get("unittest", "false")))
    {
        // try to randomize the multicast address for the test purpose. This does not guarantee, but practically fine.
        mi::Uint32 cur_time = static_cast<mi::Uint32>(nv::index::app::util::time::get_time() * 10000);
        srand(cur_time);
        mi::Sint64 r1 = (rand() % 254) + 1;
        mi::Sint64 r2 = (rand() % 254) + 1;
        std::stringstream sstr;
        sstr << "239.43." << r1 << "." << r2;
        std::string mc_addr = sstr.str();
 
        std::stringstream sstr2;
        sstr2 << "Cur_time: " << cur_time << ", Using multicast address: " << mc_addr;            
        info_cout(sstr2.str(), sdict);
 
        sdict.insert("dice::network::multicast_address", mc_addr);
 
        if (nv::index::app::get_bool(sdict.get("is_call_from_test", "false")))
        {
            sdict.insert("is_dump_comparison_image_when_failed", "0");
        }
        sdict.get("dice::verbose", "2");
    }
    info_cout("running " + com_name, sdict);
    info_cout("dice::verbose = " + sdict.get("dice::verbose"), sdict);
 
    // print help and exit if -h/-help
    if (sdict.is_defined("h") || sdict.is_defined("help"))
    {
        std::cout
            << "info: Usage: " << com_name << " [option]\n"
            << "Option: [-h]\n"
            << "            printout this message\n"
 
            << "        [-dice::verbose severity_level]\n"
            << "            verbose severity level (3 is info.).\n"
            << "            (default: " + sdict.get("dice::verbose", "<undef>") + ")\n"
 
            << "        [-dice::network::multicast_address address]\n"
            << "            set multicast address.\n"
            << "            (default: " << sdict.get("dice::network::multicast_address", "<undef>") << ")\n"
 
            << "        [-dice::network::additional_unicast_sockets int]\n"
            << "            set number of unicast sockets for remote host.\n"
            << "            (default: " << sdict.get("dice::network::additional_unicast_sockets", "<undef>") << ").\n"
 
            << "        [-unittest bool]\n"
            << "            when test true, unit test mode.\n"
            << "            (default: " << sdict.get("unittest", "<undef>") << ")"
            
            << "        [-dice::idebug_config::retention int]\n"
            << "            when set, set this idebug configuration option. not set when 0.\n"
            << "            (default: " << sdict.get("dice::idebug_config::retention", "<undef>") << ")"
            << std::endl;
        exit(1);
    }
 
    // index setting
    sdict.insert("index::config::set_monitor_performance_values", "true");
    sdict.insert("index::service", "rendering_and_compositing");
    sdict.insert("index::cuda_debug_checks", "false");
 
    // application_layer component loading
    sdict.insert("index::app::components::application_layer::component_name_list",
                 "canvas_infrastructure data_analysis_and_processing image io");
    // plugin: base_importer
    sdict.insert("index::app::plugins::base_importer::enabled", "true");
 
    // set network parameters for DiCE
    {
        config_network_parameters(index_connect, sdict);
    }
 
    info_cout(std::string("start IndeX via index_connect"), sdict);
    index_connect.initialize(sdict);
    check_success(index_connect.is_initialized());
 
    // setup
    App_rendering_context arc;
    check_success(setup_remote_host(index_connect, arc));
 
    // call remote rendering loop
    remote_rendering_loop(index_connect, arc, sdict);
 
    printf("Shutting down the NVIDIA IndeX library.\n");
    arc.shutdown();
    // index_connect will shutdown when out of scope
 
    printf("Terminating the NVIDIA IndeX remote service.\n");
    return 0;
}