computation.hpp

Go to the documentation of this file.

 
#ifndef RTCTK_EXAMPLEDATATASK_GPU_COMPUTATION_HPP
#define RTCTK_EXAMPLEDATATASK_GPU_COMPUTATION_HPP
 
#include "rtctk/componentFramework/exceptions.hpp"
#include "rtctk/componentFramework/logger.hpp"
#include "rtctk/componentFramework/matrixBuffer.hpp"
#include "rtctk/exampleDataTask/gpuLib.hpp"
#include "rtctk/exampleTopics/topics.hpp"
 
#include <chrono>
#include <numeric>
#include <string>
#include <vector>
 
using namespace rtctk::componentFramework;
 
class Computation {
public:
    using TopicType = rtctk::exampleTopic::ScaoLoopTopic;
 
    Computation() {
        m_last_sample_id = 0;
        m_sample_idx = 0;
        m_iteration_idx = 0;
    }
 
    void SetStaticConfig(unsigned to_read, unsigned n_slopes, unsigned n_modes, unsigned gpu) {
        // read anything that is unlikely to change.
        m_n_samples_to_read = to_read;
        m_n_slopes = n_slopes;
        m_n_modes = n_modes;
 
        // set vectors and matrix to correct size.
        m_s2m_matrix.resize(m_n_modes, m_n_slopes);
 
        // some simple debug output
        LOG4CPLUS_DEBUG(GetLogger(), "m_n_slopes: " << m_n_slopes);
        LOG4CPLUS_DEBUG(GetLogger(), "m_n_modes: " << m_n_modes);
        LOG4CPLUS_DEBUG(GetLogger(), "m_n_samples_to_read: " << m_n_samples_to_read);
        LOG4CPLUS_DEBUG(GetLogger(), "m_gpu: " << gpu);
 
        // call the constructor for the
        m_gpu_comp = std::make_unique<GpuLib>(m_n_slopes, m_n_modes, gpu);
 
        // set avg array to zero
        m_gpu_comp->ResetAvgSlopes();
    }
 
    void SetDynamicConfig(MatrixBuffer<float>&& s2m_matrix) {
        m_s2m_matrix = std::move(s2m_matrix);
 
        if (m_n_modes != m_s2m_matrix.get_nrows() || m_n_slopes != m_s2m_matrix.get_ncols()) {
            std::stringstream err_text;
            err_text << "s2m wrong shape: ";
            err_text << " "
                     << "expected : " << m_n_modes << " x " << m_n_slopes;
            err_text << " "
                     << "received : " << m_s2m_matrix.get_nrows() << " x "
                     << m_s2m_matrix.get_ncols();
            using rtctk::componentFramework::RtctkException;
            CII_THROW(RtctkException, err_text.str());
        }
 
        // upload to GPU
        m_gpu_comp->SetMatrix(m_s2m_matrix.data());
    }
 
    void Reset() {
        // This is invoked to clean up in case of stopped during buffering of data.
        m_last_sample_id = 0;
        m_sample_idx = 0;
        m_iteration_idx = 0;
        m_gpu_comp->ResetAvgSlopes();
    }
 
    void ThreadInit() {
        m_gpu_comp->InitReaderThread();
    }
 
    void OnDataAvailable(TopicType const& sample) {
        m_last_sample_id = sample.sample_id;
        m_gpu_comp->NewSample(sample.wfs.slopes.data(), m_sample_idx);
        m_sample_idx++;
    }
 
    struct Result {
        std::vector<float> const& avg_slopes;
        std::vector<float> const& avg_modes;
 
        struct {
            unsigned last_sample_id;
            unsigned iteration_idx;
            std::chrono::duration<double> elapsed;
        } stats;
    };
 
    Result Compute() {
        using rtctk::componentFramework::GetLogger;
        using rtctk::componentFramework::RtctkException;
 
        if (m_sample_idx != m_n_samples_to_read) {
            CII_THROW(RtctkException, "not all data available");
        }
 
        LOG4CPLUS_INFO(GetLogger(), "Computation::Compute() - samples: " << m_sample_idx);
 
        auto time_start = std::chrono::system_clock::now();
 
        m_gpu_comp->Compute();
 
        auto elapsed = std::chrono::system_clock::now() - time_start;
 
        m_avg_slopes = std::move(m_gpu_comp->GetAvgSlopes());
        m_avg_modes = std::move(m_gpu_comp->GetResults());
 
        m_iteration_idx++;
        m_sample_idx = 0;
 
        m_gpu_comp->ResetAvgSlopes();
 
        return {m_avg_slopes, m_avg_modes, m_last_sample_id, m_iteration_idx, elapsed};
    }
 
private:
    unsigned m_last_sample_id;
    unsigned m_iteration_idx;
    unsigned m_sample_idx;
 
    unsigned m_n_slopes;
    unsigned m_n_modes;
    unsigned m_n_samples_to_read;
 
    std::vector<float> m_avg_slopes;
    std::vector<float> m_avg_modes;
    MatrixBuffer<float> m_s2m_matrix;
 
    std::unique_ptr<GpuLib> m_gpu_comp;
};
 
#endif  // RTCTK_EXAMPLEDATATASK_GPU_COMPUTATION_HPP