computation.hpp

Go to the documentation of this file.

 
#ifndef RTCTK_EXAMPLEDATATASK_GPU_COMPUTATION_HPP
#define RTCTK_EXAMPLEDATATASK_GPU_COMPUTATION_HPP
 
#include <rtctk/componentFramework/matrixBuffer.hpp>
#include <rtctk/componentFramework/serviceContainer.hpp>
 
#include <rtctk/dataTask/computationBase.hpp>
#include <rtctk/exampleDataTask/gpuLib.hpp>
#include <rtctk/exampleTopics/topics.hpp>
 
#include <chrono>
#include <mutex>
#include <optional>
#include <vector>
 
namespace rtctk::exampleDataTask {
 
// the type of the shm supertopic
using TopicType = rtctk::exampleTopic::ScaoLoopTopic;
 
// type of the user-owned sample buffer
using BufferType = std::vector<decltype(decltype(TopicType::wfs)::slopes)>;
 
class Computation : public dataTask::ComputationBase<TopicType> {
public:
    using ServiceContainer = rtctk::componentFramework::ServiceContainer;
 
    template <typename T>
    using MatrixBuffer = rtctk::componentFramework::MatrixBuffer<T>;
 
    struct Result {
        std::vector<float> avg_slopes;
        std::vector<float> avg_modes;
    };
 
    struct ResultIf {
        virtual ~ResultIf() = default;
        virtual void OnResultAvailable(const Result& result) = 0;
    };
 
    Computation(ServiceContainer& services,
                ResultIf& publisher,
                const std::string& shm_name,
                size_t to_read,
                size_t to_skip,
                std::chrono::milliseconds sample_timeout,
                std::optional<numapp::NumaPolicies> thread_policies,
                size_t n_slopes,
                size_t n_modes,
                size_t gpu);
 
    ~Computation() override;
 
    void SetSlopesToModesMatrix(MatrixBuffer<float>&& s2m_matrix);
 
private:
    void OnThreadStart() override;
 
    void OnCycleStart(size_t to_read) override;
 
    void CopyData(size_t sample_idx, const TopicType& sample) noexcept override;
 
    void Compute() override;
 
    void Publish() override;
 
    ResultIf& m_publisher;
    size_t m_slopes;
    size_t m_modes;
    std::mutex m_mutex;  // protects m_s2m_matrix from concurrent access
    MatrixBuffer<float> m_s2m_matrix;
    Result m_result;
 
    GpuLib m_gpu_comp;
};
 
}  // namespace rtctk::exampleDataTask
 
#endif  // RTCTK_EXAMPLEDATATASK_GPU_COMPUTATION_HPP