UT_HoudiniExecutionContext.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * NAME:        UT_HoudiniExecutionContext.h
 *
 * COMMENTS:
 *
 */

#ifndef __UT_HOUDINIEXECUTIONCONTEXT_H__
#define __UT_HOUDINIEXECUTIONCONTEXT_H__

#include "UT_API.h"
#include "UT_BoostAsio.h"
#include "UT_Debug.h"
#include "UT_IOObject.h"
#include "UT_NonCopyable.h"
#include "UT_UniquePtr.h"

class UT_HoudiniExecutor;

class UT_API UT_HoudiniExecutionContext : public hboost::asio::execution_context
{
public:
    class UT_API Event
    {
    public:
        Event() = default;
        virtual ~Event() = default;
        UT_NON_COPYABLE(Event)
        virtual void invoke() = 0;
    };
private:
    template <typename F>
    class CallbackEvent : public UT_HoudiniExecutionContext::Event
    {
    public:
        CallbackEvent(F f) :
            myFunc(std::move(f))
        {}

        void invoke() override { myFunc(); }

    private:
        F myFunc;
    };
public:
    using executor_type = UT_HoudiniExecutor;

    UT_HoudiniExecutionContext(const UT_HoudiniExecutionContext&) = delete;
    UT_HoudiniExecutionContext& operator=(const UT_HoudiniExecutionContext&) = delete;

    // Get the executor used by houdini to post work to the event loop
    static UT_HoudiniExecutor houdiniExecutor();

    static UT_HoudiniExecutionContext* instance()
    {
        UT_ASSERT(theInstance);
        return theInstance;
    }

    static bool hasInstance()
    {
        return theInstance != nullptr;
    }

    template <typename F>
    void post(F f)
    {
        post_(UTmakeUnique<CallbackEvent<F>>(std::move(f)));
    }

    virtual void onWorkStarted() {}
    virtual void onWorkFinished() {}

    UT_HoudiniExecutor get_executor();
    UT_HoudiniExecutor get_executor() const;

protected:
    UT_HoudiniExecutionContext()
    {
        UT_ASSERT_P(theInstance == nullptr);
        theInstance = this;
    }
    virtual ~UT_HoudiniExecutionContext() = default;

    virtual void post_(UT_UniquePtr<Event> ev) = 0;

    /// Used ONLY for unit tests where each test should have their own ctx
    /// so we need to clear the instance.
    static void clearInstance()
    {
        theInstance = nullptr;
    }

private:
    static UT_HoudiniExecutionContext* theInstance;
};

// This is an event loop for running just callback events from an exection
// context. This is meant to be used when an app doesnt have an event loop but
// requires one (i.e. asyncio). This IS NOT houdini event loop.
class UT_API UT_HoudiniWorkEventLoop
{
public:
    using event_t = UT_HoudiniExecutionContext::Event;
    using exception_handler_t = bool(*)(std::exception_ptr);

    UT_HoudiniWorkEventLoop() :
        myIOContext(1),
        myIsRunning(false),
        myClosed(false)
    {}

    void postEvent(UT_UniquePtr<event_t> ev)
    {
        hboost::asio::post(myIOContext, [event = std::move(ev)]()
        {
            event->invoke();
        });
    }

    void stop()
    {
        UT_TrackedIOObject::cancelAll();
        if (myWork)
        {
            myWork->reset();
            myWork.reset();
        }
    }
    void close();
    bool isRunning() const { return myIsRunning; }
    bool isClosed() const { return myClosed; }
    void run(exception_handler_t exception_handler = nullptr);
    void restart()
    {
        myIOContext.restart();
    }
    exint poll() { return myIOContext.poll(); }

private:
    // TODO: replace this with a custom loop that just processes callbacks.
    // Using UT_IOContext is overkill here.
    ASIO_IOContext myIOContext;
    UT_UniquePtr<hboost::asio::executor_work_guard<hboost::asio::io_context::executor_type>> myWork;
    bool myIsRunning;
    bool myClosed;
};

class UT_API UT_HoudiniEventLoopExecutionContext
    : public UT_HoudiniExecutionContext
{
public:
    UT_HoudiniEventLoopExecutionContext() : UT_HoudiniExecutionContext() {}

    UT_HoudiniWorkEventLoop& loop() { return myLoop; }

protected:
    void post_(UT_UniquePtr<Event> ev) override
    {
        myLoop.postEvent(std::move(ev));
    }

private:
    UT_HoudiniWorkEventLoop myLoop;
};

/// Defines how the completion handler should run. In this all completion
/// handlers are handed off to Qt for processing at a later time.
class UT_HoudiniExecutor
{
public:
    UT_HoudiniExecutor(UT_HoudiniExecutionContext& context)
        : myCtx(std::addressof(context))
    {
    }

    // When using Boost.Asio with the Network TS these functions should be
    // defined in favour of the other ones. Since we are not using the Network
    // TS we define the other set of functions instead.
#if 0
    UI_QtExecutionContext& query(hboost::asio::execution::detail::context_t) const
    {
        return *myCtx;
    }

    static constexpr hboost::asio::execution::blocking_t query(
            hboost::asio::execution::blocking_t)
    {
        return hboost::asio::execution::blocking.never;
    }

    static constexpr hboost::asio::exection::relationship_t query(
            hboost::asio::execution::relationship_t)
    {
        return hboost::asio::execution::relationship.fork;
    }

    static constexpr hboost::asio::execution::outstanding_work_t query(
            hboost::asio::execution::outstanding_work_t)
    {
        return hboost::asio::execution::outstanding_work.tracked;
    }

    template <typename OtherAllocator>
    static constexpr auto query(
            hboost::asio::execution::allocator_t<OtherAllocator>)
    {
        return std::allocator<void>();
    }

    static constexpr auto query(hboost::asio::execution::allocator_t<void>)
    {
        return std::allocator<void>();
    }

    template <typename F>
    void execute(F f) const
    {
        myCtx->execute(std::move(f));
    }
#else
    // All required function to be an executor.
    UT_HoudiniExecutionContext& context() { return *myCtx; }
    void on_work_started() const { myCtx->onWorkStarted(); }
    void on_work_finished() const { myCtx->onWorkFinished(); }
    template <typename F, typename OtherAllocator>
    void dispatch(F f, const OtherAllocator& a) const
    {
        execute(std::move(f));
    }
    template <typename F, typename OtherAllocator>
    void post(F f, const OtherAllocator& a) const
    {
        execute(std::move(f));
    }
    template <typename F, typename OtherAllocator>
    void defer(F f, const OtherAllocator& a) const
    {
        execute(std::move(f));
    }
    template <typename F>
    void execute(F f) const
    {
        myCtx->post(std::move(f));
    }
#endif

    bool operator==(const UT_HoudiniExecutor& rhs) const
    {
        return myCtx == rhs.myCtx;
    }
    bool operator!=(const UT_HoudiniExecutor& rhs) const { return !(*this == rhs); }

private:
    UT_HoudiniExecutionContext* myCtx;
};

// Ensure the UT_HoudiniExecutor satisfies the executor requirements.
static_assert(hboost::asio::is_executor<UT_HoudiniExecutor>::value);

#endif // __UT_HOUDINIEXECUTIONCONTEXT_H__