qnx.h

Go to the documentation of this file.

// Copyright (c) 2026 Tinverse LLC. All rights reserved.
// SPDX-License-Identifier: LicenseRef-Tinverse-Commercial
 
 
#pragma once
 
namespace tsm {
 
inline constexpr unsigned qnx_supported_major = 7U;
 
} // namespace tsm
 
#if defined(__QNXNTO__)
#include <cstddef>
#include <cstdint>
#include <sys/neutrino.h>
#include <time.h>
#include <unistd.h>
#include <utility>
 
#include "tsm.h"
 
namespace tsm {
 
struct qnx_tick_source
{
    [[nodiscard]] tsm::tick_rep ticks() const noexcept
    {
        return static_cast<tsm::tick_rep>(ClockCycles());
    }
};
 
template<typename... Tasks>
class qnx_pulse_task_executor
{
  public:
    explicit qnx_pulse_task_executor(Tasks&... tasks)
      : ready_(tasks...)
    {
        channel_id_ = ChannelCreate(_NTO_CHF_PRIVATE);
        if (channel_id_ >= 0) {
            connection_id_ =
              ConnectAttach(0, 0, channel_id_, _NTO_SIDE_CHANNEL, 0);
        }
    }
 
    qnx_pulse_task_executor(qnx_pulse_task_executor const&) = delete;
    qnx_pulse_task_executor& operator=(qnx_pulse_task_executor const&) = delete;
 
    ~qnx_pulse_task_executor()
    {
        if (connection_id_ >= 0) {
            ConnectDetach(connection_id_);
        }
        if (channel_id_ >= 0) {
            ChannelDestroy(channel_id_);
        }
    }
 
    void start() {}
    void stop() {}
 
    [[nodiscard]] bool valid() const noexcept
    {
        return channel_id_ >= 0 && connection_id_ >= 0;
    }
 
    void wake()
    {
        if (connection_id_ >= 0) {
            static_cast<void>(MsgSendPulse(connection_id_, -1, wake_code, 0));
        }
    }
 
    void wake_from_isr()
    {
        wake();
    }
 
    void wait_for_work()
    {
        if (channel_id_ < 0) {
            return;
        }
 
        std::uint64_t timeout_ns = receive_timeout_ns;
        static_cast<void>(TimerTimeout(CLOCK_MONOTONIC,
                                       _NTO_TIMEOUT_RECEIVE,
                                       nullptr,
                                       &timeout_ns,
                                       nullptr));
 
        _pulse pulse{};
        static_cast<void>(
          MsgReceivePulse(channel_id_, &pulse, sizeof(pulse), nullptr));
    }
 
    [[nodiscard]] bool step()
    {
        return ready_.step();
    }
 
    std::size_t run_ready()
    {
        const auto ran = ready_.run_ready();
        if (ran == 0U) {
            wait_for_work();
        }
        return ran;
    }
 
    std::size_t tick(tsm::tick_rep elapsed_ticks = 1U)
    {
        const auto resumed = ready_.tick(elapsed_ticks);
        if (resumed != 0U) {
            wake();
        }
        return resumed;
    }
 
    std::size_t tick(tsm::tick_count elapsed_ticks)
    {
        return tick(elapsed_ticks.count());
    }
 
    void start_all()
    {
        ready_.start_all();
    }
 
    template<auto Entry, std::size_t Instance = 0U>
    [[nodiscard]] spawn_result start()
    {
        auto result = ready_.template start<Entry, Instance>();
        if (result == spawn_result::started) {
            wake();
        }
        return result;
    }
 
    template<auto Entry, typename... Args>
    [[nodiscard]] spawn_result spawn(Args&&... args)
    {
        auto result = ready_.template spawn<Entry>(std::forward<Args>(args)...);
        if (result == spawn_result::started) {
            wake();
        }
        return result;
    }
 
    [[nodiscard]] runtime::task_spawner<qnx_pulse_task_executor> spawner()
    {
        return runtime::task_spawner<qnx_pulse_task_executor>{ *this };
    }
 
    template<auto Entry, std::size_t Instance = 0U>
    [[nodiscard]] task_status task_status() const
    {
        return ready_.template task_status<Entry, Instance>();
    }
 
    template<auto Entry, std::size_t Instance = 0U>
    [[nodiscard]] task_failure_reason task_failure_reason() const
    {
        return ready_.template task_failure_reason<Entry, Instance>();
    }
 
    template<auto Entry, std::size_t Instance = 0U>
    [[nodiscard]] bool cancel() noexcept
    {
        const bool cancelled = ready_.template cancel<Entry, Instance>();
        if (cancelled) {
            wake();
        }
        return cancelled;
    }
 
    void cancel_all() noexcept
    {
        ready_.cancel_all();
        wake();
    }
 
  private:
    static constexpr int wake_code = _PULSE_CODE_MINAVAIL;
    static constexpr std::uint64_t receive_timeout_ns = 1'000'000ULL;
 
    runtime::cooperative_executor<Tasks...> ready_;
    int channel_id_{ -1 };
    int connection_id_{ -1 };
};
 
template<typename... Tasks>
qnx_pulse_task_executor(Tasks&...) -> qnx_pulse_task_executor<Tasks...>;
 
template<typename... Tasks>
using task_executor = qnx_pulse_task_executor<Tasks...>;
 
} // namespace tsm
 
#endif // defined(__QNXNTO__)