idistributed_data_locality.h

Go to the documentation of this file.

/******************************************************************************
 * Copyright 2023 NVIDIA Corporation. All rights reserved.
 *****************************************************************************/
 
#ifndef NVIDIA_INDEX_IDISTRIBUTED_DATA_LOCALITY_H
#define NVIDIA_INDEX_IDISTRIBUTED_DATA_LOCALITY_H
 
#include <mi/dice.h>
#include <mi/base/interface_declare.h>
#include <mi/neuraylib/iserializer.h>
 
#include <nv/index/idistributed_data_edit.h>
 
namespace nv
{
namespace index
{
 
struct Subregion_identifier
{
    mi::Uint32      id; //<! Numerical value that serves as unique identifier.
};
 
class IDistributed_data_locality_query_mode :
    public mi::base::Interface_declare<0x841224fe, 0x3c17, 0x43b3, 0xa1, 0xc1, 0xba, 0x30, 0x72, 0xc8, 0x44, 0xf1>
{
public:
    enum Query_mode_flags {
        QUERY_MODE_NONE                     = 0x00u,    
        QUERY_MODE_IMPORT_UNAVAILABLE_DATA  = 0x01u,    
 
        QUERY_MODE_DEFAULT                  = QUERY_MODE_IMPORT_UNAVAILABLE_DATA    
    };
public:
    virtual const mi::neuraylib::Tag_struct& get_distributed_data_tag() const = 0;
 
    virtual mi::Uint32 get_query_mode_flags() const = 0;
};
 
class Distributed_data_locality_query_mode :
    public mi::base::Interface_implement<nv::index::IDistributed_data_locality_query_mode>
{
public:
    Distributed_data_locality_query_mode(
        const mi::neuraylib::Tag_struct& tag) : m_distribute_data_tag(tag) {}
    virtual ~Distributed_data_locality_query_mode() {}
 
    virtual const mi::neuraylib::Tag_struct& get_distributed_data_tag() const { return m_distribute_data_tag; };
 
    virtual mi::Uint32 get_query_mode_flags() const { return IDistributed_data_locality_query_mode::QUERY_MODE_DEFAULT; }
 
private:
    mi::neuraylib::Tag_struct m_distribute_data_tag;  
};
 
class IDistributed_data_subset_locality_query_mode :
    public mi::base::Interface_declare<0x841224fe, 0x3c17, 0x43b3, 0xa2, 0xc4, 0xbc, 0x22, 0xa2, 0xa8, 0xcc, 0xa7,
    nv::index::IDistributed_data_locality_query_mode>
{
public:
    virtual const mi::math::Bbox_struct<mi::Float32, 3>& get_spatial_coverage() const = 0;
};
 
class Distributed_data_subset_locality_query_mode :
    public mi::base::Interface_implement<nv::index::IDistributed_data_subset_locality_query_mode>
{
public:
    Distributed_data_subset_locality_query_mode(
        const mi::neuraylib::Tag_struct&                tag,
        const mi::math::Bbox_struct<mi::Float32, 3>&    coverage)
        : m_distribute_data_tag(tag),
        m_spatial_coverage(coverage) {}
 
    Distributed_data_subset_locality_query_mode(
        const mi::neuraylib::Tag_struct&                tag,
        const mi::math::Bbox_struct<mi::Sint32, 3>&     coverage)
        : m_distribute_data_tag(tag)
    {
        // Following is still unfortunate, i.e., the need to convert to float typed bbox.
        m_spatial_coverage.min.x = static_cast<mi::Float32>(coverage.min.x);
        m_spatial_coverage.min.y = static_cast<mi::Float32>(coverage.min.y);
        m_spatial_coverage.min.z = static_cast<mi::Float32>(coverage.min.z);
        m_spatial_coverage.max.x = static_cast<mi::Float32>(coverage.max.x);
        m_spatial_coverage.max.y = static_cast<mi::Float32>(coverage.max.y);
        m_spatial_coverage.max.z = static_cast<mi::Float32>(coverage.max.z);
    }
 
    virtual ~Distributed_data_subset_locality_query_mode() {}
 
    virtual const mi::neuraylib::Tag_struct& get_distributed_data_tag()           const { return m_distribute_data_tag; };
 
    virtual mi::Uint32 get_query_mode_flags() const { return IDistributed_data_locality_query_mode::QUERY_MODE_DEFAULT; }
 
    virtual const mi::math::Bbox_struct<mi::Float32, 3>& get_spatial_coverage()   const { return m_spatial_coverage; };
 
private:
    mi::neuraylib::Tag_struct               m_distribute_data_tag;
    mi::math::Bbox_struct<mi::Float32, 3>   m_spatial_coverage;
};
 
class IDistributed_height_field_locality_query_mode :
    public mi::base::Interface_declare<0xc985b49c,0xdb6a,0x4808,0x94,0x19,0xe8,0x3c,0xbb,0x69,0x77,0x59,
        nv::index::IDistributed_data_locality_query_mode>
{
public:
    enum Height_field_locality_query_mode {
        HEIGHT_FIELD_LOCALITY_QUERY_SUBSETS_UNIQUE_CLUSTER  = 0x01u, 
        HEIGHT_FIELD_LOCALITY_QUERY_SUBSETS_UNIQUE_PER_HOST = 0x02u  
    };
 
    virtual Height_field_locality_query_mode get_query_mode()                   const = 0;
    
    virtual const mi::math::Bbox_struct<mi::Float32, 2>& get_spatial_coverage() const = 0;
};
 
class Distributed_height_field_locality_query_mode :
    public mi::base::Interface_implement<nv::index::IDistributed_height_field_locality_query_mode>
{
public:
    Distributed_height_field_locality_query_mode(
        Height_field_locality_query_mode                query_mode,
        const mi::neuraylib::Tag_struct&                tag,
        const mi::math::Bbox_struct<mi::Float32, 2>&    coverage)
        : m_query_mode(query_mode),
          m_distribute_data_tag(tag),
          m_spatial_coverage(coverage) {}
 
    Distributed_height_field_locality_query_mode(
        Height_field_locality_query_mode                query_mode,
        const mi::neuraylib::Tag_struct&                tag,
        const mi::math::Bbox_struct<mi::Sint32, 2>&     coverage)
        : m_query_mode(query_mode), 
          m_distribute_data_tag(tag)
    {
        // Following is still unfortunate, i.e., the need to convert to float typed bbox.
        m_spatial_coverage.min.x = static_cast<mi::Float32>(coverage.min.x);
        m_spatial_coverage.min.y = static_cast<mi::Float32>(coverage.min.y);
        m_spatial_coverage.max.x = static_cast<mi::Float32>(coverage.max.x);
        m_spatial_coverage.max.y = static_cast<mi::Float32>(coverage.max.y);
    }
 
    virtual ~Distributed_height_field_locality_query_mode() {}
 
    virtual Height_field_locality_query_mode get_query_mode()                     const { return m_query_mode;          }
 
    virtual const mi::neuraylib::Tag_struct& get_distributed_data_tag()           const { return m_distribute_data_tag; }
 
    virtual mi::Uint32 get_query_mode_flags() const { return IDistributed_data_locality_query_mode::QUERY_MODE_DEFAULT; }
 
    virtual const mi::math::Bbox_struct<mi::Float32, 2>& get_spatial_coverage()   const { return m_spatial_coverage;    }
 
private:
    Height_field_locality_query_mode        m_query_mode;
    mi::neuraylib::Tag_struct               m_distribute_data_tag;
    mi::math::Bbox_struct<mi::Float32, 2>   m_spatial_coverage;
};
 
class IRegular_heightfield_locality_query_mode :
    public mi::base::Interface_declare<0xde972a15, 0x1593, 0x4db3, 0xa0, 0x2f, 0xa, 0x3e, 0x46, 0xe0, 0x90, 0xc,
        nv::index::IDistributed_data_locality_query_mode>
{
public:
    virtual bool is_editing_mode() const = 0;
    virtual const mi::math::Bbox_struct<mi::Uint32, 2>& get_spatial_coverage() const = 0;
};
 
class Regular_heightfield_locality_query_mode :
    public mi::base::Interface_implement<nv::index::IRegular_heightfield_locality_query_mode>
{
public:
    Regular_heightfield_locality_query_mode(
        const mi::neuraylib::Tag_struct&                tag,
        const mi::math::Bbox_struct<mi::Uint32, 2>&     coverage,
        bool                                            editing_mode = false)
        : m_editing_mode(editing_mode),
          m_distribute_data_tag(tag),
          m_spatial_coverage(coverage) {}
    virtual ~Regular_heightfield_locality_query_mode() {}
 
    virtual bool                                         is_editing_mode()          const { return m_editing_mode; }
    virtual const mi::neuraylib::Tag_struct&             get_distributed_data_tag() const { return m_distribute_data_tag; }
 
    virtual mi::Uint32 get_query_mode_flags() const { return IDistributed_data_locality_query_mode::QUERY_MODE_DEFAULT; }
 
    virtual const mi::math::Bbox_struct<mi::Uint32, 2>&  get_spatial_coverage()     const { return m_spatial_coverage; }
 
private:
    bool                                    m_editing_mode;
    mi::neuraylib::Tag_struct               m_distribute_data_tag;
    mi::math::Bbox_struct<mi::Uint32, 2>    m_spatial_coverage;
};
 
class IDistributed_data_locality :
    public mi::base::Interface_declare<0x64624ed0,0x6e2a,0x48c9,0xb9,0x73,0x61,0x8d,0x32,0xd0,0x5e,0xf5,
                                       mi::neuraylib::ISerializable>
{
public:
    virtual mi::Uint32 get_nb_cluster_nodes() const = 0;
 
    virtual mi::Uint32 get_cluster_node(mi::Uint32 index) const = 0;
 
    virtual mi::Size get_nb_bounding_box(mi::Uint32 cluster_node_id) const = 0;
 
    virtual const mi::math::Bbox_struct<mi::Sint32, 3> get_bounding_box(
        mi::Uint32 cluster_node_id,
        mi::Uint32 bounding_box_index) const = 0;
 
    virtual Subregion_identifier get_subregion(
        mi::Uint32 cluster_node_id,
        mi::Uint32 bounding_box_index) const = 0;
};
 
class IDistributed_data_job_scheduler;
 
 
class IData_assignment :
    public mi::base::Interface_declare<0x141852fe,0x1a17,0x4ab1,0xc7,0x03,0x3b,0xa0,0x10,0xc1,0xaa,0xf3>
{
public:
    virtual mi::Uint32 get_host_id() const = 0;
    virtual mi::Uint32 get_sub_cluster_id() const = 0;
    virtual mi::Sint32 get_device_id() const = 0;
 
    virtual Subregion_identifier get_subregion() const = 0;
    virtual const mi::math::Bbox_struct<mi::Float32, 3>& get_subregion_box() const = 0;
 
    virtual mi::Size get_nb_datasets() const = 0;
    virtual mi::neuraylib::Tag_struct get_dataset(
        mi::Uint32                              dataset_index,
        mi::math::Bbox_struct<mi::Float32, 3>&  subset_data_bbox) const = 0;
};
 
class IDistributed_data_assignments : 
    public mi::base::Interface_declare<0x141852fe,0x1a17,0x4ab1,0xc7,0x03,0x1a,0xa0,0x10,0xc1,0xaa,0xf1>
{
public:
    virtual mi::Size get_nb_assignments() const = 0;
 
    virtual IData_assignment* get_assignment(mi::Size assignment_index) const = 0;
    virtual IData_assignment* get_assignment(const mi::math::Bbox_struct<mi::Float32, 3>& bbox) const = 0;
};
 
class IData_distribution :
    public mi::base::Interface_declare<0xc37caf77,0xe632,0x46ad,0x8c,0x19,0x6d,0x57,0x56,0x04,0xda,0x68,
                                       mi::neuraylib::IElement>
{
public:
    virtual IDistributed_data_job_scheduler* create_scheduler() const = 0;
 
    virtual IDistributed_data_locality* get_data_locality(
        const mi::base::Uuid&                           class_id,
        IDistributed_data_locality_query_mode*          query_method,
        mi::neuraylib::IDice_transaction*               dice_transaction) const = 0;
 
 
    template <class T>
    IDistributed_data_locality* get_data_locality(
        IDistributed_data_locality_query_mode*          query_method,
        mi::neuraylib::IDice_transaction*               dice_transaction) const
    {
        return get_data_locality(typename T::IID(), query_method, dice_transaction);
    }
 
    template <class T>
    IDistributed_data_locality* get_data_locality(
        mi::neuraylib::Tag_struct                       tag,
        const mi::math::Bbox_struct<mi::Float32, 3>&    query_bbox,
        mi::neuraylib::IDice_transaction*               dice_transaction) const
    {
        mi::base::Handle<IDistributed_data_subset_locality_query_mode> selection(
            new Distributed_data_subset_locality_query_mode(tag, query_bbox));
        return get_data_locality(typename T::IID(), selection.get(), dice_transaction);
    }
 
    virtual IDistributed_data_assignments* get_data_assignments(
        mi::neuraylib::IDice_transaction*   dice_transaction,
        mi::Uint32                          host_id = 0) const = 0;
};
 
}} // namespace index / nv
 
#endif // NVIDIA_INDEX_IDISTRIBUTED_DATA_LOCALITY_H