xac_compute.cpp

Go to the documentation of this file.

/******************************************************************************
 * Copyright 2023 NVIDIA Corporation. All rights reserved.
 *****************************************************************************/
// Example for IndeX XAC compute.
 
 
#include "xac_compute.h"
#include "xac_compute_app.h"
#include "xac_compute_scenes.h"
 
#include <nv/index/icompute.h>
#include <nv/index/idistributed_data_access.h>
 
// Include code shared by all examples.
#define USE_NVINDEX_ACCESS
#include "utility/example_shared.h"
#include "utility/app_rendering_context.h"
#include "utility/canvas_utility.h"
 
#include <nv/index/app/iimage_importer.h>
#include <nv/index/app/index_connect_.h> // FIXME should be updated to index_connect.h
 
#include <iostream>
#include <sstream>
 
//----------------------------------------------------------------------
namespace xac_compute {
 
//----------------------------------------------------------------------
class Create_xac_compute_index_connect:
        public nv::index::app::Index_connect
{
public:
    Create_xac_compute_index_connect()
        :
        Index_connect()
    {
        // INFO_LOG << "DEBUG: Create_xac_compute_index_connect() ctor";
    }
 
    virtual ~Create_xac_compute_index_connect()
    {
        // Note: Index_connect::~Index_connect() will be called after here.
        // INFO_LOG << "DEBUG: ~Create_xac_compute_index_connect() dtor";
    }
 
    // launch application
    mi::Sint32 launch();
 
protected:
    // virtual bool evaluate_options(nv::index::app::String_dict& sdict) CPP11_OVERRIDE;
    // override
    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 true;
        }
 
        return initialize_networking_as_default_udp(network_configuration, options);
    }
protected:
 
private:
    // This session tag
    mi::neuraylib::Tag                                                                m_session_tag;
    // NVIDIA IndeX cluster configuration
    mi::base::Handle<nv::index::ICluster_configuration>                               m_cluster_configuration;
    // Application layer image file canvas (a render target)
    mi::base::Handle<nv::index::app::canvas_infrastructure::IIndex_image_file_canvas> m_image_file_canvas;    
    // Create_icons options
    std::string                                                                       m_outfname;
    bool                                                                              m_is_unittest;
    // std::string                                                                       m_verify_image_fname_sequence;
    // std::string                                                                       m_verify_image_fname;
 
};
 
 
// //----------------------------------------------------------------------
// mi::Sint32 launch()
// {
 
// }
 
// //----------------------------------------------------------------------
// bool evaluate_options(nv::index::app::String_dict& sdict)
// {
 
// }
 
 
using mi::base::Handle;
using mi::neuraylib::IDice_transaction;
using mi::neuraylib::Tag_struct;
 
 
 
//----------------------------------------------------------------------
const IXac_compute_scene_setup* handle_arguments(
    Option_map& opt_map, 
    int argc, char* argv[])
{
    get_default_options(opt_map);
    process_command_line(argc, argv, opt_map.get_map());
 
    if (nv::index::app::get_bool(opt_map["unittest"])) {
        if (nv::index::app::get_bool(opt_map["is_call_from_test"])) {
            opt_map["is_dump_comparison_image_when_failed"] = "0";
        }
        opt_map["outfname"] = "";  // turn off file output in the unit test mode
        opt_map["dice::verbose"] = "2";
    }
    const std::string com_name(argv[0]);
    info_cout(std::string("running ") + com_name, opt_map.get_map());
    info_cout(std::string("outfname = [") + opt_map["outfname"] +
        "], verify_image_fname = [" + opt_map["verify_image_fname"] +
        "], dice::verbose = " + opt_map["dice::verbose"], opt_map.get_map());
 
 
    // print help and exit if -h
    if (opt_map.has_key("h")) {
        std::cout << "info: Usage: " << com_name << " [option]\n" << get_usage(opt_map);
 
        exit(1);
    }
 
    int iscene = nv::index::app::get_sint32(opt_map["scene"]);
    const IXac_compute_scene_setup* scene_setup = get_scene_setup(iscene);
    return scene_setup;
}
 
 
 
//----------------------------------------------------------------------
 
std::string get_error_info(const nv::index::IError_set* err_set)
{
    std::ostringstream os;
    const mi::Uint32 nb_err = err_set->get_nb_errors();
    for (mi::Uint32 e = 0; e < nb_err; ++e)
    {
        if (e != 0) os << '\n';
        Handle<const nv::index::IError> err(err_set->get_error(e));
        os << err->get_error_string();
    }
    return os.str();
}
 
 
//----------------------------------------------------------------------
 
inline mi::Uint32 reverse(mi::Uint32 x)
{
    // after http://aggregate.org/MAGIC
 
    x = ((x & 0xaaaaaaaau) >> 1u) | ((x & 0x55555555u) << 1u);
    x = ((x & 0xccccccccu) >> 2u) | ((x & 0x33333333u) << 2u);
    x = ((x & 0xf0f0f0f0u) >> 4u) | ((x & 0x0f0f0f0fu) << 4u);
    x = ((x & 0xff00ff00u) >> 8u) | ((x & 0x00ff00ffu) << 8u);
    x = (x >> 16u) | (x << 16u);
 
    return x;
}
 
 
struct Plane_img_helper 
{
    Plane_img_helper(
        nv::index::app::IApplication_layer* app_layer,
        const Vec2u&                        res,
        const std::string&                  plane_img_basename,
        const std::string&                  verify_img_basename)
        : app_layer_ref(app_layer)
        , colors(res.x* res.y)
        , resolution(res)
        , img_basename(!verify_img_basename.empty() ? verify_img_basename : plane_img_basename)
        , write_image(!plane_img_basename.empty())
        , verify_image(!verify_img_basename.empty())
    {
    }
 
    bool write_or_verify(const char* postfix) const;
 
    nv::index::app::IApplication_layer* app_layer_ref;
    std::vector<mi::math::Color_struct> colors;
    Vec2u           resolution;
    std::string     img_basename;
    bool            write_image;
    bool            verify_image;
};
 
 
 
bool Plane_img_helper::write_or_verify(const char* postfix) const
{
    std::string imgfname = img_basename + postfix;
    if (verify_image) {
 
        check_success(app_layer_ref != 0);
        mi::base::Handle<nv::index::app::image::IImage_importer> image_importer(
            app_layer_ref->get_api_component<nv::index::app::image::IImage_importer>());
        check_success(image_importer.is_valid_interface());
        mi::base::Handle<mi::neuraylib::ICanvas> canvas(
            image_importer->create_canvas_from_file(imgfname.c_str()));
        check_success(canvas.is_valid_interface());
 
        std::map<std::string, std::string> opt_map;
        // When "1" force to dump the images.
        opt_map["is_dump_comparison_image"] = "0";
        // When "1" dump the images when comparison failed.
        opt_map["is_dump_comparison_image_when_failed"] = "0";
        return verify_canvas_result(app_layer_ref, canvas.get(), imgfname, opt_map);
    }
    else if (write_image) 
    {
        return export_color_pixels(app_layer_ref, colors, resolution, imgfname);
    }
    return true;
}
 
 
 
bool print_compute_info(
    Nvindex_access&                    nvindex_accessor,
    const Compute_launch_info&         launch_info,
    const nv::index::ICompute_results* cpt_results,
    IDice_transaction*                 transaction,
    const std::string&                 plane_img_basename,
    const std::string&                 verify_img_basename)
{
    if (cpt_results == NULL) {
        ERROR_LOG << "NULL compute results.";
        return false;
    }
 
    if (!cpt_results->is_valid()) {
        ERROR_LOG << "Invalid compute results.";
        return false;
    }
    Handle<const nv::index::IError_set> err_set(cpt_results->get_error_set());
    if (err_set && err_set->any_errors()) {
        ERROR_LOG << "Compute results has errors: \n" << get_error_info(err_set.get());
        return false;
    }
 
 
    const bool use_compute_plane = launch_info.plane_tag.is_valid();
    if (use_compute_plane) {
        Handle<nv::index::IDistributed_data_access> data_access(cpt_results->access_compute_results());
        if (!data_access) {
            ERROR_LOG << "Compute plane results - no data access.";
            return false;
        }
 
        const int access_status = data_access->access(
            launch_info.scene_roi, // query full scene bbox
            transaction);
 
        if (access_status < 0) {
            ERROR_LOG << "Compute plane results - access error " << access_status << ".";
            return false;
        }
 
        Handle<const nv::index::IDistributed_data_subset> result_data_subset(
            data_access->get_distributed_data_subset());
        if (!result_data_subset) {
            ERROR_LOG << "Compute plane results - no data subset.";
            return false;
        }
        Handle<const nv::index::ICompute_result_buffer_2D> result_buffer(
            result_data_subset->get_interface<const nv::index::ICompute_result_buffer_2D>());
        if (!result_buffer) {
            ERROR_LOG << "Compute plane results - data subset is not result buffer.";
            return false;
        }
 
        // now we have the 2D result buffer, do something with it...
        std::ostringstream ss;
        const Vec2u res = result_buffer->get_resolution();
        ss << "Compute plane result [" << res.x << "x" << res.y << "]["
            << result_buffer->get_nb_values() << "] ( ";
        for (mi::Uint32 i=0; i < result_buffer->get_nb_values(); ++i) {
            ss << result_buffer->get_value_size(i) << " ";
        }
        ss << ")";
        INFO_LOG << ss.str();
 
 
        Plane_img_helper helper(nvindex_accessor.get_application_layer_interface(),
                                res, plane_img_basename, verify_img_basename);
 
        if (helper.write_image || helper.verify_image) {
 
            const size_t nb_pixels = res.x * res.y;
            //std::vector<mi::math::Color_struct> colors(nb_pixels);
 
            const float* values = reinterpret_cast<const float*>(result_buffer->get_values(0));
            for (size_t i = 0; i < nb_pixels; ++i) {
                float s = values[i];
                mi::math::Color_struct col = {s,s,s,1.f};
                helper.colors[i] = col;
            }
            if (!helper.write_or_verify("_plane_compute.ppm")) {
                return false;
            }
 
            const mi::Uint32* masks = result_buffer->get_value_masks();
            const mi::math::Color_struct mcol[2] = {
                {1.f, 0.f, 0.f, 1.f},   // 0 == red
                {0.f, 1.f, 0.f, 1.f}    // 1 == green
            };
            for (size_t i = 0; i < nb_pixels; ++i) {
                helper.colors[i] = mcol[masks[i] & 0x1];
            }
            if (!helper.write_or_verify("_plane_compute_mask.ppm")) {
                return false;
            }
 
            const Vec3f* values2 = reinterpret_cast<const Vec3f*>(result_buffer->get_values(1));
            for (size_t i = 0; i < nb_pixels; ++i) {
                Vec3f v = values2[i];
                mi::math::Color_struct col = {v.x, v.y, v.z, 1.f};
                helper.colors[i] = col;
            }
            if (!helper.write_or_verify("_plane_compute2.ppm")) {
                return false;
            }
 
            if (result_buffer->get_nb_values() > 2) {
                const mi::Uint32* values3 = reinterpret_cast<const mi::Uint32*>(result_buffer->get_values(2));
                for (size_t i = 0; i < nb_pixels; ++i) {
                    mi::Uint32 v = reverse(values3[i] * 0x18273645u);
                    mi::math::Color_struct col = {
                        ((v >> 24) & 0xff) / 255.f,
                        ((v >> 16) & 0xff) / 255.f,
                        ((v >> 8) & 0xff) / 255.f,
                        1.f};
                    helper.colors[i] = col;
                }
                if (!helper.write_or_verify("_plane_compute3.ppm")) {
                    return false;
                }
            }
            if (result_buffer->get_nb_values() > 3) {
                const mi::Uint32* values4 = reinterpret_cast<const mi::Uint32*>(result_buffer->get_values(3));
                for (size_t i = 0; i < nb_pixels; ++i) {
                    float s = values4[i] * 0.1f;
                    mi::math::Color_struct col = {s,s,s,1.f};
                    helper.colors[i] = col;
                }
                if (!helper.write_or_verify("_plane_compute4.ppm")) {
                    return false;
                }
            }
        }
    }
    return true;
}
 
 
bool print_compute_info(
    Nvindex_access&                                   nvindex_accessor,
    const Compute_launch_info&                        launch_info,
    const Handle<const nv::index::ICompute_results>&  cpt_results,
    App_rendering_context&                            arc,
    const Option_map&                                 opt_map,
    int                                               frame_idx)
{
    Handle<IDice_transaction> transaction(arc.m_global_scope->create_transaction<IDice_transaction>());
 
    std::string plane_img_basename = get_output_file_name(opt_map["outfname"], frame_idx);
 
    std::stringstream ref_img_opt;
    ref_img_opt << "verify_plane_fname_" << frame_idx;
    std::string verify_fname = opt_map[ref_img_opt.str()];
 
    bool result = 
        print_compute_info(nvindex_accessor, launch_info, cpt_results.get(), transaction.get(), plane_img_basename, verify_fname);
 
    transaction->commit();
 
    return result;
}
 
 
//----------------------------------------------------------------------
 
 
Handle<const nv::index::ICompute_results>
perform_compute(
    Nvindex_access&            nvindex_accessor,
    const Compute_launch_info& launch_info,
    App_rendering_context&     arc,
    const Option_map&          opt_map)
{
    const bool use_compute_plane = nv::index::app::get_sint32(opt_map["compute_plane"]) != 0;
 
 
    Handle<IDice_transaction> transaction(arc.m_global_scope->create_transaction<IDice_transaction>());
    check_success(transaction.is_valid_interface());
 
    //Handle<const nv::index::ISession> session(transaction->access<const nv::index::ISession>(arc.m_session_tag));
    //check_success(session.is_valid_interface());
 
    //Handle<const nv::index::IScene> scene(transaction->access<const nv::index::IScene>(session->get_scene()));
    //check_success(scene.is_valid_interface());
 
    // needed?
    arc.m_iindex_session->update(arc.m_session_tag, transaction.get());
 
    // Access the compute interface.
    Handle<nv::index::IIndex_compute> index_compute(nvindex_accessor.get_interface()->get_api_component<nv::index::IIndex_compute>());
    check_success(index_compute.is_valid_interface());
 
    // Create a compute launch request.
    Handle<nv::index::ICompute_launch_request> launch_request(index_compute->create_launch_request());
    check_success(launch_request.is_valid_interface());
 
    // Set up the request.
    if (use_compute_plane) {
        // XAC compute plane supports a separate compute target and write target.
        launch_request->set_launch(
            launch_info.plane_compute_program_tag,
            launch_info.scene_element_tag,      // compute-target
            launch_info.plane_tag);             // write-target
    }
    else {
        launch_request->set_launch(
            launch_info.compute_program_tag,
            launch_info.scene_element_tag);
    }
 
    // Optionally set region of interest. (An empty bbox means use complete dataset)
    if (launch_info.compute_roi.is_volume()) {
        launch_request->set_region_of_interest(launch_info.compute_roi);
    }
 
 
    // Launch.
    Handle<const nv::index::ICompute_results> cpt_results;
 
    if (launch_request->is_valid()) {
        cpt_results = index_compute->perform_compute(
            launch_request.get(),
            arc.m_iindex_rendering.get(),
            arc.m_session_tag,
            transaction.get());
    }
    else {
        ERROR_LOG << "Invalid compute launch request.";
    }
 
    transaction->commit();
 
    return cpt_results;
}
 
 
bool run_compute(
    Nvindex_access&             nvindex_accessor,
    const Compute_launch_info&  launch_info,
    App_rendering_context&      arc,
    const Option_map&           opt_map,
    int                         frame_idx)
{
    Handle<const nv::index::ICompute_results> cpt_results =
        perform_compute(nvindex_accessor, launch_info, arc, opt_map);
 
    return print_compute_info(nvindex_accessor, launch_info, cpt_results, arc, opt_map, frame_idx);
}
 
 
 
// Render a frame and save the rendered image to a file or verify using a reference image.
bool render_frame_and_save_or_verify(
    Nvindex_access&             nvindex_accessor,
    mi::Sint32                  frame_idx,
    App_rendering_context&      arc,
    const Option_map&           opt_map)
{
    const std::string out_fname = get_output_file_name(opt_map["outfname"], frame_idx);
 
    INFO_LOG << "Rendering frame " << (frame_idx + 1) << " \n";
    Handle<const nv::index::IFrame_results> frame_results(render_frame(arc, out_fname));
    Handle<const nv::index::IError_set> err_set(frame_results->get_error_set());
    if (err_set && err_set->any_errors()) {
        ERROR_LOG << "IIndex_rendering rendering call failed with the following error(s): \n"
            << get_error_info(err_set.get());
        return false;
    }
 
    print_performance(frame_results.get(), opt_map);
 
    // verify the generated frame
    std::stringstream ref_img_opt;
    ref_img_opt << "verify_image_fname_" << frame_idx;
 
    std::string verify_fname = opt_map[ref_img_opt.str()];
    if (!verify_fname.empty()) {
        if (!(verify_canvas_result(nvindex_accessor.get_application_layer_interface(),
                                   arc.m_image_canvas.get(), verify_fname, opt_map.get_map()))) {
            return false;
        }
    }
 
    return true;
}
 
 
bool reload_scene(
    Nvindex_access&                 nvindex_accessor,
    const IXac_compute_scene_setup* scene_setup,
    App_rendering_context&          arc,
    const Option_map&               opt_map)
{
    {
        Handle<IDice_transaction> transaction(arc.m_global_scope->create_transaction<IDice_transaction>());
        check_success(transaction.is_valid_interface());
 
        //Handle<const nv::index::ISession> session(transaction->access<const nv::index::ISession>(arc.m_session_tag));
        //check_success(session.is_valid_interface());
 
        //Handle<const nv::index::IScene> scene(transaction->access<const nv::index::IScene>(session->get_scene()));
        //check_success(scene.is_valid_interface());
 
        // needed?
        arc.m_iindex_session->update(arc.m_session_tag, transaction.get());
 
        scene_setup->unload_scene(arc.m_session_tag, opt_map, transaction.get());
        transaction->commit();
    }
 
    bool ok = false;
    if (scene_setup->can_reload())
    {
        Handle<IDice_transaction> transaction(arc.m_global_scope->create_transaction<IDice_transaction>());
        check_success(transaction.is_valid_interface());
 
        //Handle<const nv::index::ISession> session(transaction->access<const nv::index::ISession>(arc.m_session_tag));
        //check_success(session.is_valid_interface());
 
        //Handle<const nv::index::IScene> scene(transaction->access<const nv::index::IScene>(session->get_scene()));
        //check_success(scene.is_valid_interface());
 
        // needed?
        arc.m_iindex_session->update(arc.m_session_tag, transaction.get());
 
        ok = scene_setup->reload_scene(nvindex_accessor, arc.m_session_tag, opt_map, transaction.get());
        transaction->commit();
    }
    else {
        ok = true; // testing unload only
    }
    return ok;
}
 
 
 
// returns 0 if success, else error (exit) code
mi::Sint32 run_test_sequence(
    const IXac_compute_scene_setup* scene_setup,
    Nvindex_access&                 nvindex_accessor,
    const Option_map&               opt_map)
{
    mi::Sint32 exit_code = 0;
 
    const char* sep_line = "----------------------------------------------------------------------------";
 
    App_rendering_context arc;
    setup_app_context(arc, nvindex_accessor);
 
    // Verifying that local host has joined. This may fail when there is a license problem.
    check_success(arc.is_local_host_joined());
 
    INFO_LOG << "\n" << sep_line << "\n    XAC Compute Example - Scene " << scene_setup->name() << "\n" << sep_line;
 
    // Scene setup
    Compute_launch_info launch_info;
    setup_scene(nvindex_accessor, scene_setup, launch_info, arc, opt_map);
 
    setup_performance_monitoring(arc, opt_map);
 
    const mi::Uint32 compute_mode = nv::index::app::get_uint32(opt_map["run_compute"]);
 
    int frame_idx = 0;
    // Compute, pre-render
    if (compute_mode >= 2) {
        if (!run_compute(nvindex_accessor, launch_info, arc, opt_map, frame_idx)) {
            exit_code = 2;
            return exit_code;
        }
    }
 
 
    // Rendering 1st
    INFO_LOG << sep_line;
    if (!render_frame_and_save_or_verify(nvindex_accessor, frame_idx, arc, opt_map)) {
        exit_code = 1;
        return exit_code;
    }
 
 
    frame_idx = 1;
    // Compute, post-render
    if (compute_mode == 1 || compute_mode == 3) {
        if (!run_compute(nvindex_accessor, launch_info, arc, opt_map, frame_idx)) {
            exit_code = 3;
            return exit_code;
        }
    }
 
    // Rendering 2nd
    INFO_LOG << sep_line;
    if (!render_frame_and_save_or_verify(nvindex_accessor, frame_idx, arc, opt_map)) {
        exit_code = 4;
        return exit_code;
    }
 
    frame_idx = 2;
    // Export computed data
    if (nv::index::app::get_bool(opt_map["export_scene"])) {
        if (!export_scene_data(scene_setup, arc, opt_map)) {
            exit_code = 5;
            return exit_code;
        }
 
        if (!reload_scene(nvindex_accessor, scene_setup, arc, opt_map)) {
            exit_code = 6;
            return exit_code;
        }
        INFO_LOG << sep_line;
        if (!render_frame_and_save_or_verify(nvindex_accessor, frame_idx, arc, opt_map)) {
            exit_code = 7;
            return exit_code;
        }
    }
    return exit_code;
}
 
}//xac_compute
//----------------------------------------------------------------------
 
//=================================================================================================
 
int main(int argc, char* argv[])
{
    using namespace xac_compute;
 
    Option_map opt_map;
    const IXac_compute_scene_setup* scene_setup = handle_arguments(opt_map, argc, argv);
 
    // Load IndeX library
    const std::string comp_dso_prefix = "libnvindex_application_layer_";
    const std::string plug_dso_prefix = "libnvindex_plugin_";
    Nvindex_access nvindex_accessor;
    check_success(nvindex_accessor.load_library());
    check_success(nvindex_accessor.load_application_layer_library());
    check_success(nvindex_accessor.load_application_layer_component((comp_dso_prefix + "canvas_infrastructure").c_str()));
    check_success(nvindex_accessor.load_application_layer_component((comp_dso_prefix + "image").c_str())); 
    check_success(nvindex_accessor.load_application_layer_component((comp_dso_prefix + "io").c_str())); 
    check_success(nvindex_accessor.load_application_layer_component((comp_dso_prefix + "data_analysis_and_processing").c_str())); 
    check_success(nvindex_accessor.load_application_layer_plugin(   (plug_dso_prefix + "base_importer").  c_str())); 
    check_success(nvindex_accessor.load_application_layer_plugin(   (plug_dso_prefix + "legacy_importer").c_str())); 
 
    start_nvindex_service(nvindex_accessor, opt_map, scene_setup);
    if (!nvindex_accessor.is_initialized()) {
        info_cout("Fatal error! Initialization of the IndeX library failed.", opt_map.get_map());
        return 1;
    }
 
    mi::Sint32 exit_code = run_test_sequence(scene_setup, nvindex_accessor, opt_map);
 
    nvindex_accessor.shutdown();
 
    return exit_code;
}