readerHelpers.hpp

Go to the documentation of this file.

 
#ifndef RTCTK_DATATASK_READERHELPERS_HPP
#define RTCTK_DATATASK_READERHELPERS_HPP
 
#include <rtctk/componentFramework/logger.hpp>
 
#include <chrono>
#include <cmath>
#include <system_error>
 
namespace rtctk::dataTask {
 
namespace detail {
 
[[deprecated]] inline std::chrono::milliseconds
CalcTimeout(size_t count, float loop_frequency, float error_margin) {
    using namespace std::chrono;
    return milliseconds{static_cast<int>(ceil(1000.0 * count / loop_frequency) * error_margin)};
}
 
template <typename ReaderType, typename Operation>
[[deprecated]] std::error_code
Read(ReaderType& reader, Operation&& op, size_t count, float loop_frequency, float error_margin) {
    using namespace std::chrono;
 
    auto& logger = rtctk::componentFramework::GetLogger("rtctk");
 
    auto timeout_short = CalcTimeout(1, loop_frequency, error_margin);
    // cppcheck-suppress unreadVariable
    auto timeout_total = CalcTimeout(count, loop_frequency, error_margin);
 
    // cppcheck-suppress unreadVariable
    size_t read = 0;
    std::error_code const ok;
    std::pair<std::error_code, size_t> ret;
    milliseconds time_elapsed{0};
    // cppcheck-suppress unreadVariable
    auto time_start = steady_clock::now();
 
    while (1) {
        ret = reader.Read(std::forward<Operation>(op), count - read, timeout_short);
        if (ret.first != ok) {
            LOG4CPLUS_ERROR(logger, "!Reading from shm timed out: check if queue is being filled");
            LOG4CPLUS_ERROR(logger,
                            "Read: " << ret.second << " in " << timeout_short.count() << " ms");
            LOG4CPLUS_ERROR(logger, "Expected: " << count);
            return ret.first;
        }
        read += ret.second;
        if (read == count) {
            return {};
        }
 
        time_elapsed = duration_cast<milliseconds>(steady_clock::now() - time_start);
        if (time_elapsed > timeout_total) {
            LOG4CPLUS_ERROR(logger, "Reading from shm timed out: check if queue is being filled");
            LOG4CPLUS_ERROR(logger, "Read: " << read << " in " << time_elapsed.count() << " ms");
            LOG4CPLUS_ERROR(logger, "Expected: " << read);
            return std::make_error_code(std::errc::timed_out);
        }
    }
}
 
template <typename ReaderType>
[[deprecated]] std::error_code
Skip(ReaderType& reader, size_t count, float loop_frequency, float error_margin) {
    using namespace std::chrono;
 
    auto& logger = rtctk::componentFramework::GetLogger("rtctk");
 
    auto timeout_short = CalcTimeout(1, loop_frequency, error_margin);
    // cppcheck-suppress unreadVariable
    auto timeout_total = CalcTimeout(count, loop_frequency, error_margin);
 
    // cppcheck-suppress unreadVariable
    size_t skipped = 0;
    std::error_code const ok;
    std::pair<std::error_code, size_t> ret;
    milliseconds time_elapsed{0};
    // cppcheck-suppress unreadVariable
    auto time_start = steady_clock::now();
 
    while (1) {
        ret = reader.Skip(count - skipped, timeout_short);
        if (ret.first != ok) {
            LOG4CPLUS_ERROR(logger, "!Skipping from shm timed out: check if queue is being filled");
            LOG4CPLUS_ERROR(logger,
                            "Read: " << ret.second << " in " << timeout_short.count() << " ms");
            LOG4CPLUS_ERROR(logger, "Expected: " << count);
            return ret.first;
        }
        skipped += ret.second;
        if (skipped == count) {
            return {};
        }
 
        time_elapsed = duration_cast<milliseconds>(steady_clock::now() - time_start);
        if (time_elapsed > timeout_total) {
            LOG4CPLUS_ERROR(logger, "Skipping from shm timed out: check if queue is being filled");
            LOG4CPLUS_ERROR(logger, "Read: " << skipped << " in " << time_elapsed.count() << " ms");
            LOG4CPLUS_ERROR(logger, "Expected: " << skipped);
            return std::make_error_code(std::errc::timed_out);
        }
    }
}
 
template <typename ReaderType>
[[deprecated]] std::error_code Reset(ReaderType& reader) {
    if (reader.Size() != 0) {
        return reader.Reset();
    }
    return {};
}
 
template <typename ReaderType>
[[deprecated]] size_t NumFree(ReaderType& reader) {
    return reader.Size() - reader.NumAvailable();
}
 
}  // namespace detail
 
}  // namespace rtctk::dataTask
 
#endif  // RTCTK_DATATASK_READERHELPERS_HPP