BulkAliasAllocator.cxx

Go to the documentation of this file.

 
#include "openlcb/BulkAliasAllocator.hxx"
#include "openlcb/CanDefs.hxx"
#include "utils/MakeUnique.hxx"
 
namespace openlcb
{
 
class BulkAliasAllocator : public CallableFlow<BulkAliasRequest>
{
public:
    BulkAliasAllocator(IfCan *iface)
        : CallableFlow<BulkAliasRequest>(iface)
    {
    }
 
    Action entry() override
    {
        startTime_ = os_get_time_monotonic();
        pendingAliasesByTime_.clear();
        pendingAliasesByKey_.clear();
        nextToStampTime_ = 0;
        nextToClaim_ = 0;
        if_can()->frame_dispatcher()->register_handler(&conflictHandler_, 0, 0);
        return call_immediately(STATE(send_cid_frames));
    }
 
    Action send_cid_frames()
    {
        unsigned needed = std::min(request()->numAliases_,
            (unsigned)(config_bulk_alias_num_can_frames() + 3) / 4);
        if (!needed)
        {
            return call_immediately(STATE(wait_for_results));
        }
        bn_.reset(this);
        for (unsigned i = 0; i < needed; ++i)
        {
            NodeAlias next_alias = if_can()->alias_allocator()->get_new_seed();
            auto if_id = if_can()->alias_allocator()->if_node_id();
            send_can_frame(next_alias, (if_id >> 36) & 0xfff, 7);
            send_can_frame(next_alias, (if_id >> 24) & 0xfff, 6);
            send_can_frame(next_alias, (if_id >> 12) & 0xfff, 5);
            send_can_frame(next_alias, (if_id >> 0) & 0xfff, 4);
            --request()->numAliases_;
            pendingAliasesByTime_.push_back({next_alias});
            pendingAliasesByKey_.insert({next_alias});
        }
        bn_.notify();
        return wait_and_call(STATE(stamp_time));
    }
 
    Action stamp_time()
    {
        auto ctime = relative_time();
        for (unsigned i = nextToStampTime_; i < pendingAliasesByTime_.size();
             ++i)
        {
            pendingAliasesByTime_[i].cidTime_ = ctime;
        }
        nextToStampTime_ = pendingAliasesByTime_.size();
        // Go back to sending more CID frames as needed.
        return call_immediately(STATE(send_cid_frames));
    }
 
    Action wait_for_results()
    {
        if (nextToClaim_ == pendingAliasesByTime_.size())
        {
            return complete();
        }
        if (request()->numAliases_)
        {
            // Some conflicts were identified, go and allocate more.
            return call_immediately(STATE(send_cid_frames));
        }
        auto ctime = relative_time();
        unsigned num_sent = 0;
        bn_.reset(this);
        while ((nextToClaim_ < pendingAliasesByTime_.size()) &&
            (num_sent < (unsigned)(config_bulk_alias_num_can_frames())) &&
            (pendingAliasesByTime_[nextToClaim_].cidTime_ + ALLOCATE_DELAY <
                ctime))
        {
            NodeAlias a =
                (NodeAlias)(pendingAliasesByTime_[nextToClaim_].alias_);
            ++nextToClaim_;
            auto it = pendingAliasesByKey_.find(a);
            if (it->hasConflict_)
            {
                // we skip this alias because there was a conflict.
                continue;
            }
            if_can()->alias_allocator()->add_allocated_alias(a);
            ++num_sent;
            send_can_frame(a, CanDefs::RID_FRAME, 0);
        }
        if (bn_.abort_if_almost_done())
        {
            // no frame sent
            return sleep_and_call(
                &timer_, MSEC_TO_NSEC(10), STATE(wait_for_results));
        }
        else
        {
            bn_.notify();
            // Wait for outgoing frames to be gone and call this again.
            return wait();
        }
    }
 
    Action complete()
    {
        if_can()->frame_dispatcher()->unregister_handler_all(&conflictHandler_);
        pendingAliasesByTime_.clear();
        pendingAliasesByKey_.clear();
        return return_ok();
    }
 
private:
    void handle_conflict(Buffer<CanMessageData> *message)
    {
        auto rb = get_buffer_deleter(message);
        auto alias = CanDefs::get_src(GET_CAN_FRAME_ID_EFF(*message->data()));
        auto it = pendingAliasesByKey_.find(alias);
        if (it != pendingAliasesByKey_.end() && !it->hasConflict_)
        {
            it->hasConflict_ = 1;
            ++request()->numAliases_;
        }
    }
 
    IncomingFrameHandler::GenericHandler conflictHandler_ {
        this, &BulkAliasAllocator::handle_conflict};
 
    static constexpr unsigned ALLOCATE_DELAY = 20;
 
    void send_can_frame(NodeAlias src, uint16_t control_field, int sequence)
    {
        auto *b = if_can()->frame_write_flow()->alloc();
        b->set_done(bn_.new_child());
        CanDefs::control_init(*b->data(), src, control_field, sequence);
        if_can()->frame_write_flow()->send(b, 0);
    }
 
    IfCan *if_can()
    {
        return static_cast<IfCan *>(service());
    }
 
    unsigned relative_time()
    {
        return (os_get_time_monotonic() - startTime_) / MSEC_TO_NSEC(10);
    }
 
    struct PendingAliasInfo
    {
        PendingAliasInfo(NodeAlias alias)
            : alias_(alias)
            , cidTime_(0)
        {
        }
 
        unsigned alias_ : 12;
        unsigned cidTime_ : 8;
    };
    static_assert(sizeof(PendingAliasInfo) == 4, "memory bloat");
 
    struct AliasLookupInfo
    {
        AliasLookupInfo(NodeAlias alias)
            : alias_(alias)
            , hasConflict_(0)
        {
        }
 
        uint16_t alias_ : 12;
        uint16_t hasConflict_ : 1;
    };
    static_assert(sizeof(AliasLookupInfo) == 2, "memory bloat");
    struct LookupCompare
    {
        bool operator()(AliasLookupInfo a, AliasLookupInfo b)
        {
            return a.alias_ < b.alias_;
        }
    };
 
    StateFlowTimer timer_ {this};
    BarrierNotifiable bn_;
    long long startTime_;
    std::vector<PendingAliasInfo> pendingAliasesByTime_;
    SortedListSet<AliasLookupInfo, LookupCompare> pendingAliasesByKey_;
    uint16_t nextToStampTime_;
    uint16_t nextToClaim_;
};
 
std::unique_ptr<BulkAliasAllocatorInterface> create_bulk_alias_allocator(
    IfCan *can_if)
{
    return std::make_unique<BulkAliasAllocator>(can_if);
}
 
} // namespace openlcb