sycl_tree_solver.hpp

Go to the documentation of this file.

#pragma once

 
#include <cstdint>
#include <memory>
#include <span>
#include <string_view>
 
#include "orrery/backend/executor.hpp"
#include "orrery/backend/sycl_device.hpp"
#include "orrery/backend/worker_statistics.hpp"
#include "orrery/core/softening.hpp"
#include "orrery/core/types.hpp"
#include "orrery/core/vec3_span.hpp"
#include "orrery/solvers/force_solver.hpp"
#include "orrery/solvers/interaction_count.hpp"
#include "orrery/solvers/octree.hpp"
 
#ifdef ORRERY_ENABLE_SYCL
 
namespace orrery::solvers {

enum class TreeTraversal : std::uint8_t {
    kIndependent,

    kCoherent,
};
 
[[nodiscard]] constexpr std::string_view to_string(TreeTraversal traversal) noexcept {
    return traversal == TreeTraversal::kCoherent ? "coherent" : "independent";
}

struct SyclTreeTimings {
    backend::Duration ordering{};

    backend::Duration gathering{};

    backend::Duration construction{};

    backend::Duration node_staging{};

    backend::Duration kernel{};

    backend::Duration scatter{};
};

class SyclTreeSolver final : public ForceSolver {
public:
    [[nodiscard]] static std::unique_ptr<SyclTreeSolver>
    try_create(TreeParameters parameters = {}, core::Softening softening = {},
               backend::Executor* executor = nullptr);
 
    ~SyclTreeSolver() override;
 
    SyclTreeSolver(const SyclTreeSolver&) = delete;
    SyclTreeSolver& operator=(const SyclTreeSolver&) = delete;
    SyclTreeSolver(SyclTreeSolver&&) noexcept;
    SyclTreeSolver& operator=(SyclTreeSolver&&) noexcept;

    void evaluate(core::Vec3Span<const core::Real> positions, std::span<const core::Real> masses,
                  core::Vec3Span<core::Real> accelerations) override;
 
    [[nodiscard]] std::string_view name() const noexcept override { return "sycl-tree"; }
 
    [[nodiscard]] core::Softening softening() const noexcept override;
 
    [[nodiscard]] InteractionCount interaction_count() const noexcept override;
 
    void reset_interaction_count() noexcept override;

    [[nodiscard]] const TreeParameters& parameters() const noexcept;

    [[nodiscard]] const Octree& tree() const noexcept;

    [[nodiscard]] TreeTraversal traversal() const noexcept;
 
    void select_traversal(TreeTraversal traversal) noexcept;

    void select_sub_group_width(unsigned width) noexcept;

    [[nodiscard]] unsigned sub_group_width() const noexcept;

    [[nodiscard]] std::span<const unsigned> supported_sub_group_widths() const noexcept;

    [[nodiscard]] core::Index work_group_size() const noexcept;

    [[nodiscard]] std::uint64_t node_visits() const noexcept;

    [[nodiscard]] const backend::DeviceDescription& device() const noexcept;

    [[nodiscard]] const SyclTreeTimings& timings() const noexcept;

    [[nodiscard]] bool uses_shared_memory() const noexcept;
 
private:
    struct Impl;
 
    explicit SyclTreeSolver(std::unique_ptr<Impl> impl) noexcept;
 
    std::unique_ptr<Impl> impl_;
};
 
} // namespace orrery::solvers
 
#endif // ORRERY_ENABLE_SYCL