priomapl1.h

Go to the documentation of this file.

/*===========================================================================
     _____        _____        _____        _____
 ___|    _|__  __|_    |__  __|__   |__  __| __  |__  ______
|    \  /  | ||    \      ||     |     ||  |/ /     ||___   |
|     \/   | ||     \     ||     \     ||     \     ||___   |
|__/\__/|__|_||__|\__\  __||__|\__\  __||__|\__\  __||______|
    |_____|      |_____|      |_____|      |_____|

--[Mark3 Realtime Platform]--------------------------------------------------

Copyright (c) 2012 - 2019 m0slevin, all rights reserved.
See license.txt for more information
===========================================================================*/
#pragma once

#include "kerneltypes.h"
#include "mark3cfg.h"
#include "threadport.h"

namespace Mark3
{
//---------------------------------------------------------------------------
template <typename T, size_t C>
class PriorityMapL1
{
public:
    PriorityMapL1()
    {
        m_uXPriorityMap = 0;
    }

    void Set(T uXPrio_)
    {
        auto uXPrioBit = PrioBit(uXPrio_);
        m_uXPriorityMap |= (1 << uXPrioBit);
    }

    void Clear(T uXPrio_)
    {
        auto uXPrioBit = PrioBit(uXPrio_);
        m_uXPriorityMap &= ~(1 << uXPrioBit);
    }

    T HighestPriority(void)
    {
        auto uXPrio = PriorityFromBitmap(m_uXPriorityMap);
        return uXPrio;
    }

private:
    static inline T PrioBit(T prio) { return prio & m_uXPrioMapBitMask; }

    static inline T PrioMapWordIndex(T prio) { return prio >> m_uXPrioMapWordShift; }

    static inline T PriorityFromBitmap(T uXPrio_)
    {
#if PORT_USE_HW_CLZ
        // Support hardware-accelerated Count-leading-zeros instruction
        return m_uXPrioMapBits - PORT_CLZ(uXPrio_);
#else
        // Default un-optimized count-leading zeros operation
        T uXMask  = 1 << (m_uXPrioMapBits - 1);
        auto           u8Zeros = T { 0 };

        while (uXMask) {
            if (uXMask & uXPrio_) {
                return (m_uXPrioMapBits - u8Zeros);
            }

            uXMask >>= 1;
            u8Zeros++;
        }
        return 0;
#endif
    }

    static constexpr size_t m_uXPrioMapShiftLUT[9] = {0, 3, 4, 0, 5, 0, 0, 0, 6};
    static constexpr auto m_uXPrioMapWordShift = T { m_uXPrioMapShiftLUT[sizeof(T)] };
    static constexpr auto m_uXPrioMapBits    = T { 8 * sizeof(T) };
    static constexpr auto m_uXPrioMapBitMask = T { (1 << m_uXPrioMapWordShift) - 1 };

    T m_uXPriorityMap;
};
} // namespace Mark3