using mcx::utils::SystemMode = typedef cmd_line::SystemMode;

template <typename ElementType >
using mcx::utils::span = typedef tcb::span<ElementType>;

template <typename T >
constexpr T singleBit(
    unsigned int idx
)

template <typename T >
constexpr bool getBit(
    T x,
    unsigned int idx
)

template <typename T >
constexpr T setBit(
    T x,
    unsigned int idx
)

template <typename T >
constexpr T clearBit(
    T x,
    unsigned int idx
)

template <typename T >
constexpr T setBitTo(
    T x,
    unsigned int idx,
    bool val
)

static size_t getKey(
    char * hash,
    size_t len
)

static std::string removeSpaces(
    const std::string & orig
)

void parseCmdLine(
    int argc,
    char ** argv,
    CommandLineArgs * cmd_args
)

void printSystemConfig(
    const CommandLineArgs & cmd_args,
    const char * system_name
)

uint64_t localTimeMilliS()

uint64_t zuluTimeMilliS()

bool demangle(
    const char * name,
    std::string & demangled_name
)

int isValidNumber(
    const std::string & str
)

void listFile(
    std::string initial_path,
    std::vector< ProcessInfo > * proc_id_list
)

bool setCpuAffinity(
    pid_t pid,
    const std::vector< uint32_t > & cpu_list
)

bool setIrqSmpAffinity(
    const std::string & irq_path,
    const std::string & param_name,
    const std::vector< uint32_t > & cpu_list
)

std::vector< uint32_t > invertCpuList(
    const std::vector< uint32_t > & cpu_list
)

bool isolateCpuListForProc(
    pid_t pid,
    const std::vector< uint32_t > & cpu_list
)

bool isolateCpuListForIrq(
    const std::string & irq_path,
    const std::vector< uint32_t > & cpu_list
)

std::vector< ProcessInfo > getProcessId(
    const std::vector< std::string > & proc_list
)

bool bindProcList(
    const std::vector< uint32_t > & cpu_list,
    const std::vector< std::string > & proc_list
)

bool bindIrqList(
    const std::vector< uint32_t > & cpu_list,
    const std::vector< uint32_t > & irq_list
)

void isolateCpuList(
    const std::vector< uint32_t > & cpu_list
)

void resetIsolateCpu()

std::vector< uint32_t > fromCpuSet(
    const cpu_set_t & cpuset
)

cpu_set_t toCpuSet(
    const std::vector< uint32_t > & cpu_list
)

std::vector< uint32_t > getAllCpu()

std::vector< uint32_t > getAvailableCpu()

std::vector< uint32_t > getIsolatedCpu()

bool reserveProcessMemory(
    size_t size_mb
)

size_t getStackSize(
    pthread_attr_t & attr
)

bool setStackSize(
    pthread_attr_t & attr,
    size_t size_bytes
)

bool prefaultThreadStack(
    pthread_attr_t & attr
)

PageFaults getPageFaults(
    PageFaults * page_faults,
    int where =RUSAGE_THREAD
)

bool showPageFaults(
    PageFaults * page_faults,
    int where
)

bool startLowLatency()

void stopLowLatency()

bool configureMallocBehavior(
    size_t size_mb
)

static std::atomic< bool > sig_initialized(
    false 
)

static std::atomic< bool > sig_terminated(
    false 
)

void signalCallbackHandler(
    int 
)

bool running()

bool setSwappiness(
    size_t swappiness
)

bool setPrintkLevel(
    size_t level
)

bool setCpuFreqPolicy(
    unsigned int cpu_id,
    const char * governor
)

bool startRealTime(
    size_t size_mb
)

bool startRealTime(
    const std::vector< uint32_t > & cpu_list,
    size_t size_mb =256
)

bool startRealTime(
    cmd_line::Realtime opt
)

bool startRealTime()

void stopRealTime(
    cmd_line::Realtime opt
)

void stopRealTime()

inline int schedSetAttr(
    pid_t pid,
    const SchedAttr * attr,
    unsigned int flags
)

inline int schedGetAttr(
    pid_t pid,
    SchedAttr * attr,
    unsigned int size,
    unsigned int flags
)

inline bool schedSelect(
    pid_t pid,
    SchedType sched_type,
    unsigned int dt_usec,
    int priority =0
)

template <typename ElementType >
span< ElementType > make_span(
    ElementType el
)

template <typename ElementType >
span< ElementType > make_span(
    ElementType * el,
    size_t s
)

template <typename... Args>
auto make_span(
    Args &&... args
)

constexpr Timespec64 timespecToTimespec64(
    const struct timespec & t
)

template <typename TIMESPEC >
constexpr uint64_t timespecToNanoS(
    const TIMESPEC & time
)

template <typename TIMESPEC >
constexpr uint64_t timespecToMicroS(
    const TIMESPEC & time
)

template <typename TIMESPEC >
constexpr uint64_t timespecToMilliS(
    const TIMESPEC & time
)

template <typename TIMESPEC >
constexpr double timespecToS(
    const TIMESPEC & time
)

template <typename TIMESPEC >
constexpr timespec diff(
    const TIMESPEC & start,
    const TIMESPEC & end
)

template <typename TIMESPEC >
constexpr void correctNSec(
    TIMESPEC * time_n_sec
)

template <typename TIMESPEC >
constexpr void incTime(
    TIMESPEC * time,
    const TIMESPEC & duration
)

template <typename TIMESPEC >
constexpr void setTime(
    TIMESPEC * time,
    const TIMESPEC & value
)

const char * version()

static void constructor()

const char * tinyXMLErr2Str(
    int error
)

std::string buildPath(
    std::initializer_list< std::string > str_list
)

inline void ltrim(
    std::string & s
)

inline std::string ltrimc(
    std::string s
)

inline void rtrim(
    std::string & s
)

inline std::string rtrimc(
    std::string s
)

inline void trim(
    std::string & s
)

inline std::string trimc(
    std::string s
)

static std::vector< uint32_t > cpu_isolated_list = {};

static int pm_qos_fd = -1;

static constexpr uint64_t NSEC = 1000000000;

static constexpr uint64_t MSEC = 1000000;

static constexpr uint64_t NSEC_MILISEC = 1000000;

static constexpr uint64_t NSEC_MSEC = 1000;