AliasAllocator.hxx

Go to the documentation of this file.

 
#ifndef _OPENLCB_ALIASALLOCATOR_HXX_
#define _OPENLCB_ALIASALLOCATOR_HXX_
 
#include "openlcb/IfCan.hxx"
#include "openlcb/Defs.hxx"
#include "executor/StateFlow.hxx"
 
namespace openlcb
{
 
extern size_t g_alias_test_conflicts;
 
struct AliasInfo
{
    AliasInfo()
        : alias(0)
        , state(STATE_EMPTY)
        , return_to_reallocation(1)
    {
    }
 
    void reset()
    {
        alias = 0;
        state = STATE_EMPTY;
        return_to_reallocation = 1;
    }
 
    void do_not_reallocate()
    {
        return_to_reallocation = 0;
    }
 
    uint16_t alias : 12;
    uint16_t state : 3;
    uint16_t return_to_reallocation : 1;
 
    enum State
    {
        STATE_EMPTY = 0,
        STATE_CHECKING,
        STATE_RESERVED,
        STATE_ASSIGNED,
        STATE_CONFLICT
    };
};
 
class AliasAllocator : public StateFlow<Buffer<AliasInfo>, QList<1>>
{
public:
    AliasAllocator(NodeID if_id, IfCan *if_can);
 
    virtual ~AliasAllocator();
 
    NodeID if_node_id()
    {
        return if_id_;
    }
 
    void reinit_seed();
 
    NodeAlias get_new_seed();
 
    NodeAlias get_allocated_alias(NodeID destination_id, Executable *done);
 
    unsigned num_reserved_aliases();
 
    void clear_reserved_aliases();
 
    void return_alias(NodeID id, NodeAlias alias);
 
    void add_allocated_alias(NodeAlias alias);
 
#ifdef GTEST
    void TEST_finish_pending_allocation();
 
    void TEST_add_allocated_alias(NodeAlias alias);
 
    void TEST_set_reserve_unused_alias_count(unsigned count)
    {
        reserveUnusedAliases_ = count;
    }
#endif
 
private:
    class ConflictHandler : public IncomingFrameHandler
    {
    public:
        ConflictHandler(AliasAllocator *parent) : parent_(parent)
        {
        }
        void send(Buffer<CanMessageData> *message, unsigned priority) override;
 
    private:
        AliasAllocator *parent_;
    } conflictHandler_;
 
    friend class ConflictHandler;
 
    AliasInfo *pending_alias()
    {
        return message()->data();
    }
 
    Action entry() override;
    Action handle_allocate_for_cid_frame();
    Action send_cid_frame();
    Action wait_done();
    Action send_rid_frame();
 
    Action handle_alias_conflict();
 
    void next_seed();
 
    friend class AsyncAliasAllocatorTest;
    friend class AsyncIfTest;
 
    StateFlowTimer timer_;
 
    Q waitingClients_;
 
    NodeID if_id_;
 
    IfCan *if_can()
    {
        return static_cast<IfCan *>(service());
    }
 
    unsigned cid_frame_sequence_ : 3;
    unsigned conflict_detected_ : 1;
 
    unsigned seed_ : 12;
 
    unsigned reserveUnusedAliases_ : 8;
 
    BarrierNotifiable n_;
 
    // SleepData sleep_helper_;
};
 
class AddAliasAllocator
{
public:
    AddAliasAllocator(NodeID if_id, IfCan *iface)
    {
        iface->set_alias_allocator(new AliasAllocator(if_id, iface));
    }
};
 
}  // namespace openlcb
 
 
#endif // _OPENLCB_ALIASALLOCATOR_HXX_