computation.hpp

Go to the documentation of this file.

 
#ifndef RTCTK_EXAMPLEDATATASK_COMPUTATION_HPP
#define RTCTK_EXAMPLEDATATASK_COMPUTATION_HPP
 
#include "rtctk/componentFramework/exceptions.hpp"
#include "rtctk/componentFramework/logger.hpp"
#include "rtctk/componentFramework/matrixBuffer.hpp"
 
#include <cblas.h>
#include <chrono>
#include <lapacke.h>
#include <string>
#include <vector>
 
// for python computation
#include "rtctk/componentFramework/matrixBufferPy.hpp"
 
namespace rtctk::exampleDataTask {
 
using namespace rtctk::componentFramework;
 
// Constructor not required, all local vars are set by the SetStaticConfig method
// cppcheck-suppress noConstructor
class Computation {
public:
    enum class Algorithm : uint8_t { SimpleInversion, PythonInversion };
 
    Computation() : m_logger(GetLogger("app")) {
    }
 
    void SetStaticConfig(size_t n_slopes, size_t n_acts) {
        m_n_slopes = n_slopes;
        m_n_acts = n_acts;
 
        // set vectors and matrix to correct size.
        m_im.resize(m_n_acts, m_n_slopes);
        m_cm.resize(m_n_slopes, m_n_acts);
        m_ipiv.resize(m_n_acts);
 
        // some simple debug output
        LOG4CPLUS_DEBUG(m_logger, "m_n_slopes: " << m_n_slopes);
        LOG4CPLUS_DEBUG(m_logger, "m_n_acts: " << m_n_acts);
    }
 
    void SetDynamicConfig(MatrixBuffer<float>&& data) {
        m_im = std::move(data);
 
        if (m_n_acts != m_im.GetNrows() || m_n_slopes != m_im.GetNcols()) {
            std::stringstream err_text;
            err_text << "IM wrong shape, "
                     << "expected:" << m_n_acts << " x " << m_n_slopes
                     << "received: " << m_im.GetNrows() << " x " << m_im.GetNcols();
            using rtctk::componentFramework::RtctkException;
            CII_THROW(RtctkException, err_text.str());
        }
    }
 
    struct Result {
        const MatrixBuffer<float>& cm;
 
        struct {
            std::chrono::duration<double> elapsed;
        } stats;
    };
 
    Result Compute(Algorithm algorithm) {
        auto time_start = std::chrono::steady_clock::now();
 
        if (algorithm == Algorithm::SimpleInversion) {
            // Invert the matrix in a very simple way.
            memcpy(m_cm.data(), m_im.data(), m_n_slopes * m_n_acts * sizeof(float));
            LAPACKE_sgetrf(
                LAPACK_ROW_MAJOR, m_n_acts, m_n_slopes, m_cm.data(), m_n_slopes, m_ipiv.data());
            LAPACKE_sgetri(LAPACK_ROW_MAJOR, m_n_slopes, m_cm.data(), m_n_acts, m_ipiv.data());
        } else {
            // Always acquire the Python GIL before calling Python code.
            py::gil_scoped_acquire gil;
            // Load the Python module and setup the function to call. You can do this earlier in the
            // constructor to speed things up.
            // cppcheck-suppress unreadVariable
            auto py_compute_module = py::module::import("rtctk_example_data_task_py_lib");
            auto py_inversion = py_compute_module.attr("inversion");
            // Do the computation.
            py_inversion(&m_im, &m_cm);
        }
 
        auto elapsed = std::chrono::steady_clock::now() - time_start;
 
        return {m_cm, elapsed};
    }
 
private:
    log4cplus::Logger& m_logger;
 
    // static config
    size_t m_n_slopes;
    size_t m_n_acts;
 
    // input data
    MatrixBuffer<float> m_im;
 
    // output data
    MatrixBuffer<float> m_cm;
 
    std::vector<int> m_ipiv;
};
 
}  // namespace rtctk::exampleDataTask
 
#endif  // RTCTK_EXAMPLEDATATASK_COMPUTATION_HPP