computationGpu.hpp

Go to the documentation of this file.

 
#ifndef RTCTK_EXAMPLEDATATASK_COMPUTATION_HPP
#define RTCTK_EXAMPLEDATATASK_COMPUTATION_HPP
 
#include "rtctk/componentFramework/logger.hpp"
#include "rtctk/componentFramework/runtimeRepoApiIf.hpp"
#include "rtctk/componentFramework/oldbApiIf.hpp"
#include "rtctk/componentFramework/matrixBuffer.hpp"
#include "rtctk/exampleDataTask/exampleGpuLib.hpp"
 
#include <string>
#include <vector>
#include <numeric>
#include <chrono>
 
using namespace rtctk::componentFramework;
using rtctk::componentFramework::MatrixBuffer;
using rtctk::componentFramework::GetLogger;
 
namespace rtctk::exampleDataTask {
 
template<class TopicType>
class ComputationGpu
{
    public:
        ComputationGpu(rtctk::componentFramework::RuntimeRepoApiIf& rtr, rtctk::componentFramework::OldbApiIf& oldb, std::string const& name)
        : m_rtr(rtr)
        , m_oldb(oldb)
        , m_name(name)
        , m_dp_slopes("/common/static/wfs_1/slopes")
        , m_dp_modes("/" + m_name + "/" + "static/computation/modes")
        , m_dp_iterations("/" + m_name + "/" + "static/common/samples_to_read")
        , m_dp_gpu("/" + m_name + "/" + "static/common/gpu")
        , m_dp_s2m("/" + m_name + "/" + "dynamic/computation/slopes2modes")
        , m_dp_avg_slopes("/common/dynamic/wfs_1/avg_slopes")
        , m_dp_avg_modes("/common/dynamic/wfs_1/avg_modes")
        , m_dp_stats_iteration("/" + m_name + "/" + "statistics/computation/iteration")
        , m_dp_stats_time("/" + m_name + "/" + "statistics/computation/time")
        , m_dp_stats_last_id("/" + m_name + "/" + "statistics/computation/last_sample_id")
        {
            m_sample_id = 0;
            m_callback_counter = 0;
            m_iteration = 0;
 
            // create some oldb points
            m_oldb.CreateDataPoint(m_dp_stats_iteration, "RtcInt32");
            m_oldb.CreateDataPoint(m_dp_stats_time, "RtcDouble");
            m_oldb.CreateDataPoint(m_dp_stats_last_id, "RtcInt32");
            m_oldb.SetDataPoint<int32_t>(m_dp_stats_iteration, 0);
            m_oldb.SetDataPoint<double>(m_dp_stats_time, 0.0);
            m_oldb.SetDataPoint<int32_t>(m_dp_stats_last_id, 0);
 
            StaticLoad();
        }
 
        ~ComputationGpu()
        {
            m_gpu_comp.reset();
        }
 
        void StaticLoad()
        {
            // read anything that is unlikely to change.
            m_n_slopes = m_rtr.GetDataPoint<int32_t>(m_dp_slopes);
            m_n_modes = m_rtr.GetDataPoint<int32_t>(m_dp_modes);
            m_n_iterations = m_rtr.GetDataPoint<int32_t>(m_dp_iterations);
            m_gpu = m_rtr.GetDataPoint<int32_t>(m_dp_gpu);
 
            // set vectors and matrix to correct size.
            m_buffer_matrix.resize(m_n_iterations, m_n_slopes);
            m_avg_slopes.resize(m_n_slopes);
            m_s2m_matrix.resize(m_n_modes, m_n_slopes);
            m_avg_modes.resize(m_n_modes);
 
            // fill with zeros where needed.
            std::fill (m_avg_slopes.begin(), m_avg_slopes.end(), 0.0); 
            std::fill (m_avg_modes.begin(), m_avg_modes.end(), 0.0);
 
            LOG4CPLUS_DEBUG(GetLogger(), "m_n_slopes: " << m_n_slopes);
            LOG4CPLUS_DEBUG(GetLogger(), "m_n_modes: " << m_n_modes);
            LOG4CPLUS_DEBUG(GetLogger(), "m_n_iterations: " << m_n_iterations);
            LOG4CPLUS_DEBUG(GetLogger(), "m_gpu: " << m_gpu);
 
            // call the constructor for the 
            m_gpu_comp = std::make_unique<exampleGpuLib>(m_n_slopes, m_n_modes, m_gpu);
 
            // set avg array to zero
            m_gpu_comp->SetAvgSlopes(m_avg_slopes);
            
            // dynamic load
            DynamicLoad();
        }
 
        void DynamicLoad()
        {
            // read things that will change
            m_s2m_matrix = m_rtr.GetDataPoint<MatrixBuffer<float>>(m_dp_s2m);
            if(m_n_modes != (int) m_s2m_matrix.get_nrows() || m_n_slopes != (int) m_s2m_matrix.get_ncols())
            {
                LOG4CPLUS_INFO(GetLogger(), "Computation::DynamicLoad() - s2m wrong shape ");
                LOG4CPLUS_INFO(GetLogger(), "Computation::DynamicLoad() - Expected: " << m_n_modes << " x " << m_n_slopes);
                LOG4CPLUS_INFO(GetLogger(), "Computation::DynamicLoad() - recieved: " << m_s2m_matrix.get_nrows() << " x " << m_s2m_matrix.get_ncols());
                throw std::runtime_error("s2m wrong shape");
            }
            assert((int)m_s2m_matrix.get_nrows() == m_n_modes);
            assert((int)m_s2m_matrix.get_ncols() == m_n_slopes);
 
            // upload to GPU
            m_gpu_comp->SetMatrix(m_s2m_matrix.data());
        }
 
        // TODO: come up with better name
        void ThreadInit()
        {
           m_gpu_comp->initReaderThread();
        }   
 
 
        void OnDataAvailable(TopicType const& sample) // TODO: should this be nothrow?
        {
            // call the GPU
            m_sample_id = sample.sample_id;
            m_gpu_comp->NewSample(sample.wfs.slopes.data(), m_callback_counter);
            m_callback_counter++;
        }
 
        void Reset()
        {
            m_iteration=0;
            ResetComputation();
        }
 
        void Compute()
        {   
            //TODO: add this back in later
            // assert(m_callback_counter == m_n_iterations);
            LOG4CPLUS_INFO(GetLogger(), "Computation::Compute() - samples: " << m_callback_counter);
            m_iteration++;
 
            auto time_start = std::chrono::system_clock::now();
            m_gpu_comp->Compute();
            auto time_stop = std::chrono::system_clock::now();
            std::chrono::duration<double> elapsed = time_stop - time_start;
            // get Result and avg array and save to 
            m_avg_slopes = m_gpu_comp->GetAvgSlopes();
            m_avg_modes =  m_gpu_comp->GetResults();
 
            // write output back to runtime repo
            m_rtr.SetDataPoint<std::vector<float>>(m_dp_avg_slopes, m_avg_slopes);
            m_rtr.SetDataPoint<std::vector<float>>(m_dp_avg_modes, m_avg_modes);
 
            // write statistics:
            m_oldb.SetDataPoint<int32_t>(m_dp_stats_iteration, m_iteration);
            m_oldb.SetDataPoint<double>(m_dp_stats_time, elapsed.count());
            m_oldb.SetDataPoint<int32_t>(m_dp_stats_last_id, m_sample_id);
            
            // reset the computation
            ResetComputation();
        }
 
        bool isComputing(){return m_computation_running;}
 
    protected:
        void ResetComputation()
        {
            // This is invoked going to idle to clean up incase of stoped part way through run.
            m_callback_counter = 0;
            // set avg to zero
            std::fill (m_avg_slopes.begin(), m_avg_slopes.end(), 0.0); 
            m_gpu_comp->SetAvgSlopes(m_avg_slopes);
        }
 
 
        rtctk::componentFramework::RuntimeRepoApiIf& m_rtr;
        rtctk::componentFramework::OldbApiIf& m_oldb;
        std::string m_name;
 
        // inputs
        DataPointPath m_dp_slopes;
        DataPointPath m_dp_modes;
        DataPointPath m_dp_iterations;
        DataPointPath m_dp_gpu;
        DataPointPath m_dp_s2m;
        
        //outputs to write
        DataPointPath m_dp_avg_slopes;
        DataPointPath m_dp_avg_modes;
 
        // write statistics:
        DataPointPath m_dp_stats_iteration;
        DataPointPath m_dp_stats_time;
        DataPointPath m_dp_stats_last_id;
 
        unsigned int m_sample_id;
        unsigned int m_iteration;
        std::atomic<unsigned int> m_callback_counter;
        std::atomic<bool> m_computation_running;
 
        std::unique_ptr<exampleGpuLib> m_gpu_comp;
        
        int m_n_slopes;
        int m_n_modes;
        int m_n_iterations;
        int m_gpu;
 
        std::vector<float> m_avg_slopes;
        std::vector<float> m_avg_modes;
        MatrixBuffer<float> m_buffer_matrix;
        MatrixBuffer<float> m_s2m_matrix;
};
 
} // namespace
 
#endif