Dispatch.hpp

Go to the documentation of this file.

#pragma once
 
#include <future>
 
#ifdef MAYAFLUX_PLATFORM_MACOS
#include <CoreFoundation/CoreFoundation.h>
#include <dispatch/dispatch.h>
#include <pthread.h>
#endif
 
#ifdef MAYAFLUX_PLATFORM_WINDOWS
#include <windows.h>
#ifdef ERROR
#undef ERROR
#endif // ERROR
 
#define MAYAFLUX_WM_DISPATCH (WM_USER + 0x0001)
#endif // MAYAFLUX_PLATFORM_WINDOWS
 
namespace MayaFlux::Parallel {
 
#ifdef MAYAFLUX_PLATFORM_MACOS
/**
 * @brief Execute a function on the main dispatch queue (macOS only)
 * @tparam Func Callable type
 * @tparam Args Argument types
 * @param func Function to execute
 * @param args Arguments to forward to the function
 *
 * Schedules work on the main queue asynchronously. Returns immediately.
 * Use this for AppKit operations that must execute on the main thread.
 */
template <typename Func, typename... Args>
void dispatch_main_async(Func&& func, Args&&... args)
{
    dispatch_async(dispatch_get_main_queue(), ^{
        std::invoke(std::forward<Func>(func), std::forward<Args>(args)...);
    });
}
 
/**
 * @brief Execute a function on the main dispatch queue and wait (macOS only)
 * @tparam Func Callable type that returns a result
 * @tparam Args Argument types
 * @param func Function to execute
 * @param args Arguments to forward to the function
 * @return The result returned by func
 *
 * Runs directly when called on the main thread, otherwise schedules work on
 * the main queue synchronously and blocks until complete.
 * WARNING: Can deadlock during Cocoa modal loops.
 */
template <typename Func, typename... Args>
auto dispatch_main_sync(Func&& func, Args&&... args) -> decltype(auto)
{
    using ResultType = std::invoke_result_t<Func, Args...>;
 
    if constexpr (std::is_void_v<ResultType>) {
        if (pthread_main_np() != 0) {
            std::invoke(std::forward<Func>(func), std::forward<Args>(args)...);
            return;
        }
        dispatch_sync(dispatch_get_main_queue(), ^{
            std::invoke(std::forward<Func>(func), std::forward<Args>(args)...);
        });
    } else {
        if (pthread_main_np() != 0) {
            return static_cast<ResultType>(std::invoke(std::forward<Func>(func), std::forward<Args>(args)...));
        }
        __block ResultType result;
        dispatch_sync(dispatch_get_main_queue(), ^{
            result = std::invoke(std::forward<Func>(func), std::forward<Args>(args)...);
        });
        return result;
    }
}
 
/**
 * @brief Execute a function on the main queue with timeout (macOS only)
 * @tparam Func Callable type
 * @tparam Args Argument types
 * @param timeout_ms Timeout in milliseconds
 * @param func Function to execute
 * @param args Arguments to forward to the function
 * @return true if completed before timeout, false if timed out
 *
 * Schedules work asynchronously and waits with timeout.
 * Returns false if the operation doesn't complete in time.
 */
template <typename Func, typename... Args>
bool dispatch_main_async_with_timeout(std::chrono::milliseconds timeout_ms, Func&& func, Args&&... args)
{
    auto completed = std::make_shared<std::atomic<bool>>(false); // Shared pointer for capture
 
    dispatch_async(dispatch_get_main_queue(), ^{
        std::invoke(std::forward<Func>(func), std::forward<Args>(args)...);
        completed->store(true, std::memory_order_release);
    });
 
    auto start = std::chrono::steady_clock::now();
    while (!completed->load(std::memory_order_acquire)) {
        if (std::chrono::steady_clock::now() - start > timeout_ms) {
            return false;
        }
        std::this_thread::sleep_for(std::chrono::milliseconds(1));
    }
 
    return true;
}
 
/**
 * @brief Wait for a future, keeping the main run loop alive on the main thread
 * @tparam T Future value type
 * @param future Future to wait on
 * @return The value held by the future
 *
 * Work queued to the main queue, such as window creation, cannot run while
 * the main thread is blocked in future.get(). On the main thread this pumps
 * the default run loop until the future is ready, on any other thread it
 * simply waits. Other platforms just wait.
 */
template <typename T>
T await_future(std::future<T> future)
{
    if (pthread_main_np() != 0) {
        while (future.wait_for(std::chrono::milliseconds(0)) != std::future_status::ready) {
            CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0.01, false);
        }
    }
    return future.get();
}
#else
// On linux platforms, these just execute directly
template <typename Func, typename... Args>
void dispatch_main_async(Func&& func, Args&&... args)
{
    std::invoke(std::forward<Func>(func), std::forward<Args>(args)...);
}
 
template <typename Func, typename... Args>
auto dispatch_main_sync(Func&& func, Args&&... args) -> decltype(auto)
{
    return std::invoke(std::forward<Func>(func), std::forward<Args>(args)...);
}
 
template <typename Func, typename... Args>
bool dispatch_main_async_with_timeout(std::chrono::milliseconds /*timeout_ms*/, Func&& func, Args&&... args)
{
    std::invoke(std::forward<Func>(func), std::forward<Args>(args)...);
    return true;
}
 
template <typename T>
T await_future(std::future<T> future)
{
    return future.get();
}
#endif
 
} // namespace MayaFlux::Parallel