dice.h

Go to the documentation of this file.

/***************************************************************************************************
 * Copyright 2023 NVIDIA Corporation. All rights reserved.
 **************************************************************************************************/
 
#ifndef MI_NEURAYLIB_DICE_H
#define MI_NEURAYLIB_DICE_H
 
#include <mi/base/handle.h>
#include <mi/base/lock.h>
#include <mi/base/interface_declare.h>
#include <mi/base/interface_implement.h>
#include <mi/neuraylib/iserializer.h>
#include <mi/neuraylib/iuser_class_factory.h>
 
#define MI_NEURAYLIB_DICE_VERSION_MAJOR  3
 
#define MI_NEURAYLIB_DICE_VERSION_MINOR  0
 
#define MI_NEURAYLIB_DICE_VERSION_QUALIFIER  ""
 
// This macro is defined if #MI_NEURAYLIB_DICE_VERSION_QUALIFIER is the empty string \c "".
#define MI_NEURAYLIB_DICE_VERSION_QUALIFIER_EMPTY
 
#define MI_NEURAYLIB_DICE_PRODUCT_VERSION_STRING  "2023"
 // end group mi_neuray_dice
 
namespace mi {
 
namespace neuraylib {
 
class IDistributed_cache;
class IElement;
class IExecution_listener;
class IFragmented_job;
class IGpu_description;
class IJob;
class IJob_execution_context;
class IScope;
class ITransaction;
class IRDMA_buffer;
class IRDMA_context;
 
class IDice_configuration : public
    mi::base::Interface_declare<0xfccbf7b8,0x30d1,0x4fbf,0xbd,0xc6,0x3b,0x96,0xe1,0xfb,0x40,0x6a>
{
public:
    virtual bool register_serializable_class(
        base::Uuid class_id,
        IUser_class_factory* factory) = 0;
 
    template <class T>
    bool register_serializable_class()
    {
        mi::base::Handle<IUser_class_factory> factory( new User_class_factory<T>());
        return register_serializable_class( typename T::IID(), factory.get());
    }
 
    virtual bool unregister_serializable_class( base::Uuid class_id) = 0;
 
    template <class T>
    bool unregister_serializable_class()
    {
        return unregister_serializable_class( typename T::IID());
    }
 
    virtual Sint32 set_gpu_enabled( bool value) = 0;
 
    virtual bool get_gpu_enabled() const = 0;
 
    virtual IRDMA_context* get_rdma_context( Uint32 host_id) = 0;
 
    virtual Uint32 get_highest_gpu_id( Uint32 host_id = 0) = 0;
 
    virtual const IGpu_description* get_gpu_description( Uint32 gpu_id, Uint32 host_id = 0) = 0;
 
};
 // end group mi_neuray_configuration
 
class ITag_set : public
    mi::base::Interface_declare<0xb8290f90,0x3692,0x4bb9,0x87,0x22,0x45,0x4a,0xd6,0xf1,0x1f,0xf5>
{
public:
    virtual Size get_length() const = 0;
    virtual Tag_struct get_tag( Size index) const = 0;
    virtual void add_tag( Tag_struct tag) = 0;
};
 
typedef Uint8 Privacy_level;
 // end group mi_neuray_dice
 
class IDice_transaction : public
    mi::base::Interface_declare<0x1885cbec,0x3cfc,0x4f9d,0xb2,0xe9,0xb2,0xbe,0xdc,0xc8,0x94,0x88>
{
public:
    virtual Sint32 commit() = 0;
 
    virtual void abort() = 0;
 
    virtual bool is_open() = 0;
 
    static const mi::Uint8 LOCAL_SCOPE = 255;
 
    virtual Tag_struct store(
        IElement* element,
        Tag_struct tag = NULL_TAG,
        const char* name = 0,
        Privacy_level privacy_level = LOCAL_SCOPE) = 0;
 
    virtual Tag_struct store(
        IJob* job,
        Tag_struct tag = NULL_TAG,
        const char* name = 0,
        Privacy_level privacy_level = LOCAL_SCOPE) = 0;
 
    virtual Tag_struct store_for_reference_counting(
        IElement* element,
        Tag_struct tag = NULL_TAG,
        const char* name = 0,
        Privacy_level privacy_level = LOCAL_SCOPE) = 0;
 
    virtual Tag_struct store_for_reference_counting(
        IJob* job,
        Tag_struct tag = NULL_TAG,
        const char* name = 0,
        Privacy_level privacy_level = LOCAL_SCOPE) = 0;
 
    virtual const base::IInterface* access( Tag_struct tag) = 0;
 
    template<class T>
    const T* access( Tag_struct tag)
    {
        const base::IInterface* ptr_iinterface = access( tag);
        if ( !ptr_iinterface)
            return 0;
        const T* ptr_T = static_cast<const T*>( ptr_iinterface->get_interface( typename T::IID()));
        ptr_iinterface->release();
        return ptr_T;
    }
 
    virtual base::IInterface* edit( Tag_struct tag) = 0;
 
    template<class T>
    T* edit( Tag_struct tag)
    {
        base::IInterface* ptr_iinterface = edit( tag);
        if ( !ptr_iinterface)
            return 0;
        T* ptr_T = static_cast<T*>( ptr_iinterface->get_interface( typename T::IID()));
        ptr_iinterface->release();
        return ptr_T;
    }
 
    virtual Sint32 localize( Tag_struct tag, Privacy_level privacy_level) = 0;
 
    virtual Sint32 remove( Tag_struct tag, bool only_localized = false) = 0;
 
    virtual const char* get_time_stamp() const = 0;
 
    virtual const char* get_time_stamp( Tag_struct tag) const = 0;
 
    virtual bool has_changed_since_time_stamp( Tag_struct tag, const char* time_stamp) const = 0;
 
    virtual const ITag_set* get_changed_elements_since_time_stamp(
        const char* time_stamp) const = 0;
 
    virtual const char* get_id() const = 0;
 
    virtual IScope* get_scope() const = 0;
 
    virtual Sint32 get_privacy_level( Tag_struct tag) const = 0;
 
    virtual void advise( Tag_struct tag) = 0;
 
    virtual Tag_struct reserve_tag() = 0;
 
    virtual const char* tag_to_name( Tag_struct tag) = 0;
 
    virtual Tag_struct name_to_tag( const char* name) = 0;
 
    virtual Sint32 execute_fragmented( IFragmented_job* job, Size count) = 0;
 
    virtual Sint32 execute_fragmented_async(
        IFragmented_job* job, Size count, IExecution_listener* listener) = 0;
 
    virtual void invalidate_job_results( Tag_struct tag) = 0;
};
 // end group mi_neuray_database_access
 
class IScheduler : public
    mi::base::Interface_declare<0xd0754018,0xca8f,0x48e0,0x8a,0x37,0xeb,0x83,0x31,0xb7,0x85,0x20>
{
public:
    virtual Sint32 execute_fragmented(
        IFragmented_job* job, Size count) = 0;
 
    virtual Sint32 execute_fragmented_async(
        IFragmented_job* job, Size count, IExecution_listener* listener) = 0;
 
    virtual void suspend_current_job() = 0;
 
   virtual void resume_current_job() = 0;
 
    virtual void yield() = 0;
};
 
class IElement : public
    mi::base::Interface_declare<0x3f377a88,0xb7aa,0x487b,0x98,0xe6,0x70,0x53,0xc2,0xfa,0xb9,0xc9,
                                neuraylib::ISerializable>
{
public:
    //  Sets the embedded pointer.
    //
    //  The embedded pointer is used for internal purposes. Users must not use this method.
    virtual bool set_pointer( const base::IInterface* pointer) = 0;
 
    //  Returns the embedded pointer.
    //
    //  The embedded pointer is used for internal purposes. Users must not use this method.
    virtual const base::IInterface* get_pointer() const = 0;
 
    virtual IElement* copy() const = 0;
 
    virtual const char* get_class_name() const = 0;
 
    virtual void get_references( ITag_set* result) const = 0;
 
    virtual Size get_size() const = 0;
 
    virtual bool get_send_to_all_nodes() const = 0;
 
    virtual bool get_offload_to_disk() const = 0;
};
 
class IJob : public
    mi::base::Interface_declare<0x0edda67e,0x8e93,0x4d41,0xa8,0xdb,0x58,0x5d,0x08,0xfd,0xb1,0xde,
                                neuraylib::ISerializable>
{
public:
    virtual IJob* copy() const = 0;
 
    virtual const char* get_class_name() const = 0;
 
    virtual Size get_size() const = 0;
 
    virtual IElement* execute( IDice_transaction* transaction) const = 0;
 
    virtual bool is_shared() const = 0;
 
    virtual bool is_local_only() const = 0;
 
    virtual bool is_parent() const = 0;
 
    virtual Float32 get_cpu_load() const = 0;
 
    virtual Float32 get_gpu_load() const = 0;
};
 
class IExecution_listener : public
    mi::base::Interface_declare<0x5700dbde,0xbe1d,0x4c07,0xa7,0x0d,0xf4,0x11,0x7e,0x9f,0x73,0xf1>
{
public:
    virtual void job_finished() = 0;
};
 
class IFragmented_job : public
    mi::base::Interface_declare<0x037f3783,0x187c,0x4bb7,0x92,0x50,0x6d,0xfe,0x1c,0x81,0x89,0xef,
                                neuraylib::ISerializable>
{
public:
    virtual void execute_fragment(
        IDice_transaction* transaction,
        Size index,
        Size count,
        const IJob_execution_context* context) = 0;
 
    virtual void execute_fragment_remote(
        ISerializer* serializer,
        IDice_transaction* transaction,
        Size index,
        Size count,
        const IJob_execution_context* context) = 0;
 
    virtual void receive_remote_result(
        IDeserializer* deserializer,
        IDice_transaction* transaction,
        Size index,
        Size count) = 0;
 
    virtual IRDMA_buffer* get_rdma_result_buffer( IRDMA_context* rdma_context, Size index) = 0;
 
    virtual IRDMA_buffer* execute_fragment_remote_rdma(
        IDice_transaction* transaction,
        Size index,
        Size count,
        IRDMA_context* rdma_context,
        const IJob_execution_context* context)  = 0;
 
    virtual void receive_remote_result_rdma(
        IRDMA_buffer* buffer,
        IDice_transaction* transaction,
        Size index,
        Size count) = 0;
 
    virtual void serialize( ISerializer* serializer) const = 0;
 
    virtual void deserialize( IDeserializer* deserializer) = 0;
 
    virtual void assign_fragments_to_hosts( Uint32* slots, Size nr_slots) = 0;
 
    enum Scheduling_mode {
        LOCAL = 0,
        CLUSTER = 1,
        ONCE_PER_HOST = 2,
        USER_DEFINED = 3,
        SCHEDULING_MODE_FORCE_32_BIT = 0xffffffffU
    };
 
    virtual Scheduling_mode get_scheduling_mode() const = 0;
 
    virtual Float32 get_cpu_load() const = 0;
 
    virtual Float32 get_gpu_load() const = 0;
 
    virtual void cancel() = 0;
 
    virtual Sint8 get_priority() const = 0;
 
    virtual Size get_thread_limit() const = 0;
 
    virtual bool get_allow_non_sequential_chunks() const = 0;
 
};
 
mi_static_assert( sizeof( IFragmented_job::Scheduling_mode) == sizeof( Uint32));
 
template <Uint32 id1, Uint16 id2, Uint16 id3
    , Uint8 id4, Uint8 id5, Uint8 id6, Uint8 id7
    , Uint8 id8, Uint8 id9, Uint8 id10, Uint8 id11
    , class I = base::IInterface>
class Base : public base::Interface_implement<I>
{
public:
    typedef Base<id1,id2,id3,id4,id5,id6,id7,id8,id9,id10,id11,I> Self;
 
    typedef base::Uuid_t<id1,id2,id3,id4,id5,id6,id7,id8,id9,id10,id11> IID;
 
    static bool compare_iid( const base::Uuid& iid)
    {
        if( iid == IID())
            return true;
        return I::compare_iid( iid);
    }
 
    virtual const base::IInterface* get_interface( const base::Uuid& interface_id) const
    {
        if( interface_id == IID()) {
            const Self* self = static_cast<const Self*>( this);
            self->retain();
            return self;
        }
        return I::get_interface_static( this, interface_id);
    }
 
    virtual base::IInterface* get_interface( const base::Uuid& interface_id)
    {
        if( interface_id == IID()) {
            Self* self = static_cast<Self*>( this);
            self->retain();
            return self;
        }
        return I::get_interface_static( this, interface_id);
    }
 
    using base::Interface_implement<I>::get_interface;
 
    virtual base::Uuid get_class_id() const
    {
        return IID();
    }
};
 
template <Uint32 id1, Uint16 id2, Uint16 id3
    , Uint8 id4, Uint8 id5, Uint8 id6, Uint8 id7
    , Uint8 id8, Uint8 id9, Uint8 id10, Uint8 id11
    , class I = IElement>
class Element :  public Base<id1,id2,id3,id4,id5,id6,id7,id8,id9,id10,id11,I>
{
public:
    Element() : m_pointer( 0) { }
 
    Element( const Element& /*other*/) : m_pointer( 0) { }
 
    Element& operator=( const Element& other)
    {
       return base::Interface_implement<I>::operator=( other);
    }
 
    ~Element()
    {
        mi_base_assert( m_pointer == 0);
    }
 
    //  Overrides the standard release() implementation.
    //
    //  If the release count drops to 1, and the embedded pointer is set, release it.
    virtual Uint32 release() const
    {
        base::Lock::Block block( &m_pointer_lock);
        base::Interface_implement<I>::retain();
        Uint32 count = base::Interface_implement<I>::release();
        if( count == 1) {
            block.release();
            return base::Interface_implement<I>::release();
        }
        if(( count == 2) && m_pointer) {
            m_pointer->release();
            m_pointer = 0;
        }
        return base::Interface_implement<I>::release();
    }
 
    //  Sets the embedded pointer.
    //
    //  The embedded pointer is used for internal purposes. Users must not use this method.
    virtual bool set_pointer( const base::IInterface* pointer)
    {
        base::Lock::Block block( &m_pointer_lock);
        if( m_pointer)
            return false;
        m_pointer = pointer;
        if( m_pointer)
            m_pointer->retain();
        return true;
    }
 
    //  Returns the embedded pointer.
    //
    //  The embedded pointer is used for internal purposes. Users must not use this method.
    virtual const base::IInterface* get_pointer() const
    {
        base::Lock::Block block( &m_pointer_lock);
        if( m_pointer)
            m_pointer->retain();
        return m_pointer;
    }
 
 
    virtual void get_references( ITag_set* result) const
    {
        // avoid warnings
        (void) result;
    }
 
    virtual Size get_size() const
    {
        return sizeof( *this);
    }
 
    virtual bool get_send_to_all_nodes() const
    {
        return true;
    }
 
    virtual bool get_offload_to_disk() const
    {
        return false;
    }
 
private:
    //  The embedded pointer.
    //
    //  The embedded pointer is used for internal purposes. Users must not access the pointer.
    mutable const base::IInterface* m_pointer;
 
    //  The lock that protects the embedded pointer.
    mutable base::Lock m_pointer_lock;
};
 
template <Uint32 id1, Uint16 id2, Uint16 id3
    , Uint8 id4, Uint8 id5, Uint8 id6, Uint8 id7
    , Uint8 id8, Uint8 id9, Uint8 id10, Uint8 id11
    , class I = IJob>
class Job : public Base<id1,id2,id3,id4,id5,id6,id7,id8,id9,id10,id11,I>
{
public:
    virtual Size get_size() const
    {
        return sizeof( *this);
    }
 
    virtual bool is_local_only() const { return false; }
 
    virtual bool is_shared() const { return false; }
 
    virtual bool is_parent() const { return false; }
 
    virtual Float32 get_cpu_load() const { return 1.0f; }
 
    virtual Float32 get_gpu_load() const { return 0.0f; }
};
 
template <Uint32 id1, Uint16 id2, Uint16 id3
    , Uint8 id4, Uint8 id5, Uint8 id6, Uint8 id7
    , Uint8 id8, Uint8 id9, Uint8 id10, Uint8 id11
    , class I = IFragmented_job>
class Fragmented_job :  public Base<id1,id2,id3,id4,id5,id6,id7,id8,id9,id10,id11,I>
{
public:
    virtual IFragmented_job::Scheduling_mode get_scheduling_mode() const
    {
        return IFragmented_job::LOCAL;
    }
 
    virtual Float32 get_cpu_load() const { return 1.0f; }
 
    virtual Float32 get_gpu_load() const { return 0.0f; }
 
    virtual Sint8 get_priority() const { return 0; }
 
    virtual Size get_thread_limit() const { return 0; }
 
    virtual bool get_allow_non_sequential_chunks() const { return false; }
 
    virtual void assign_fragments_to_hosts(
        Uint32* slots,
        Size nr_slots)
    {
        // avoid warnings
        (void) slots;
        (void) nr_slots;
    }
 
    virtual void execute_fragment_remote(
        ISerializer* serializer,
        IDice_transaction* transaction,
        Size index,
        Size count,
        const IJob_execution_context* context)
    {
        // avoid warnings
        (void) serializer;
        (void) transaction;
        (void) index;
        (void) count;
        (void) context;
    }
 
    virtual void receive_remote_result(
        IDeserializer* deserializer,
        IDice_transaction* transaction,
        Size index,
        Size count)
    {
        // avoid warnings
        (void) deserializer;
        (void) transaction;
        (void) index;
        (void) count;
    }
 
    virtual IRDMA_buffer* get_rdma_result_buffer( IRDMA_context* rdma_context, Size index)
    {
        // avoid warnings
        (void) rdma_context;
        (void) index;
        return 0;
    }
 
    virtual IRDMA_buffer* execute_fragment_remote_rdma(
        IDice_transaction* transaction,
        Size index,
        Size count,
        IRDMA_context* rdma_context,
        const IJob_execution_context* context)
    {
        // avoid warnings
        (void) transaction;
        (void) index;
        (void) count;
        (void) rdma_context;
        (void) context;
        return 0;
    }
 
    virtual void receive_remote_result_rdma(
        IRDMA_buffer* buffer, IDice_transaction* transaction, Size index, Size count)
    {
        // avoid warnings
        (void) buffer;
        (void) transaction;
        (void) index;
        (void) count;
    }
 
    virtual void serialize( ISerializer* serializer) const
    {
        // avoid warnings
        (void) serializer;
    }
 
    virtual void deserialize( IDeserializer* deserializer)
    {
        // avoid warnings
        (void) deserializer;
    }
 
    virtual void cancel() { }
};
 // end group mi_neuray_dice
 
} // namespace neuraylib
 
} // namespace mi
 
#endif // MI_NEURAYLIB_DICE_H