config.h

Go to the documentation of this file.

#ifndef ZTH_CONFIG_H
#define ZTH_CONFIG_H
/*
 * SPDX-FileCopyrightText: 2019-2026 Jochem Rutgers
 *
 * SPDX-License-Identifier: MPL-2.0
 */
 
#include <libzth/macros.h>
 
#ifdef __cplusplus
#  include <libzth/init.h>
 
#  include <cstddef>
#  include <sys/time.h>
 
#  if __cplusplus >= 201103L
#    include <cstdint>
#  else
#    include <stdint.h>
#  endif
 
#  include <memory>
 
namespace zth {
 
struct Env {
        enum { EnableDebugPrint, DoPerfEvent, PerfSyscall, CheckTimesliceOverrun };
};
 
bool config(int env /* one of Env::* */, bool whenUnset);
 
#  define zth_config(name) (::zth::config(::zth::Env::name, ::zth::Config::name))
 
#  if __cplusplus < 201103L
#    define ZTH_CONSTEXPR_RETURN(type, ...) \
            type x = {__VA_ARGS__};         \
            return x;
#  else // C++11 and up
#    define ZTH_CONSTEXPR_RETURN(type, ...) return {__VA_ARGS__};
#  endif // C++11 and up
 
struct DefaultConfig {
        static bool const Debug =
#  ifndef NDEBUG
#    ifdef ZTH_CONFIG_DEBUG
                ZTH_CONFIG_DEBUG;
#    else
                true;
#    endif
#  else
                false;
#  endif
 
        static bool const EnableAssert =
#  ifndef NDEBUG
                Debug
#    ifdef ZTH_CONFIG_ENABLE_ASSERT
                && ZTH_CONFIG_ENABLE_ASSERT
#    endif
                ;
#  else
                false;
#  endif
 
        static bool const EnableFullAssert =
#  ifdef ZTH_CONFIG_ENABLE_FULL_ASSERT
                EnableAssert && ZTH_CONFIG_ENABLE_FULL_ASSERT;
#  elif defined(ZTH_OS_BAREMETAL)
                // Assume we are a bit short on memory.
                false;
#  else
                        EnableAssert;
#  endif
 
        static bool const EnableBacktrace =
#  ifdef ZTH_CONFIG_ENABLE_BACKTRACE
                ZTH_CONFIG_ENABLE_BACKTRACE;
#  else
                Debug;
#  endif
 
        static bool const EnableThreads =
#  if ZTH_THREADS
                true;
#  else
                false;
#  endif
 
        static bool const EnableDebugPrint =
#  ifdef ZTH_CONFIG_ENABLE_DEBUG_PRINT
                ZTH_CONFIG_ENABLE_DEBUG_PRINT;
#  else
                false;
#  endif
 
        static bool const SupportDebugPrint =
#  ifdef ZTH_CONFIG_SUPPORT_DEBUG_PRINT
                Debug && ZTH_CONFIG_SUPPORT_DEBUG_PRINT;
#  elif defined(ZTH_OS_BAREMETAL)
                // Without OS, there is no environment to enable debugging when
                // it is not enabled right away.
                Debug && EnableDebugPrint;
#  else
                        Debug;
#  endif
 
        static bool const EnableColorLog =
#  ifdef ZTH_CONFIG_ENABLE_COLOR_LOG
                ZTH_CONFIG_ENABLE_COLOR_LOG;
#  else
                true;
#  endif
 
        static int const Print_banner = 12; // bright blue
        static int const Print_worker = 5;  // magenta
        static int const Print_waiter = 1;  // red
        static int const Print_io = 9;      // bright red
        static int const Print_perf = 6;    // cyan
        static int const Print_fiber = 10;  // bright green
        static int const Print_context = 2; // green
        static int const Print_sync = 11;   // bright yellow
        static int const Print_list = 8;    // bright black
        static int const Print_zmq = 9;     // bright red
        static int const Print_fsm = 14;    // bright cyan
        static int const Print_thread = 3;  // yellow
        static int const Print_coro = 13;   // bright magenta
 
        static size_t const DefaultFiberStackSize =
#  ifdef ZTH_CONFIG_DEFAULT_FIBER_STACK_SIZE
                ZTH_CONFIG_DEFAULT_FIBER_STACK_SIZE;
#  elif defined(ZTH_OS_BAREMETAL)
                0x2000;
#  else
                0x20000;
#  endif
 
        static bool const EnableStackGuard =
#  ifdef ZTH_CONFIG_ENABLE_STACK_GUARD
                ZTH_CONFIG_ENABLE_STACK_GUARD;
#  else
                Debug;
#  endif
 
        static bool const EnableStackWaterMark =
#  ifdef ZTH_CONFIG_ENABLE_STACK_WATER_MARK
                ZTH_CONFIG_ENABLE_STACK_WATER_MARK;
#  else
                Debug;
#  endif
 
        static bool const ContextSignals =
#  if defined(ZTH_CONFIG_CONTEXT_SIGNALS) && !defined(ZTH_OS_BAREMETAL)
                ZTH_CONFIG_CONTEXT_SIGNALS;
#  else
                false;
#  endif
 
        constexpr static struct timespec MinTimeslice()
        {
#  ifdef ZTH_CONFIG_MIN_TIMESLICE
#    define ZTH_CONFIG_MIN_TIMESLICE_ ZTH_CONFIG_MIN_TIMESLICE
#  else
#    define ZTH_CONFIG_MIN_TIMESLICE_ 100000
#  endif
                ZTH_CONSTEXPR_RETURN(struct timespec, 0, ZTH_CONFIG_MIN_TIMESLICE_)
#  undef ZTH_CONFIG_MIN_TIMESLICE_
        }
        constexpr static struct timespec TimesliceOverrunReportThreshold()
        {
#  ifdef ZTH_CONFIG_TIMESLICE_OVERRUN_REPORT_THRESHOLD
#    define ZTH_CONFIG_TIMESLICE_OVERRUN_REPORT_THRESHOLD_ \
            ZTH_CONFIG_TIMESLICE_OVERRUN_REPORT_THRESHOLD
#  else
#    define ZTH_CONFIG_TIMESLICE_OVERRUN_REPORT_THRESHOLD_ 10000000
#  endif
                ZTH_CONSTEXPR_RETURN(
                        struct timespec, 0, ZTH_CONFIG_TIMESLICE_OVERRUN_REPORT_THRESHOLD_)
#  undef ZTH_CONFIG_TIMESLICE_OVERRUN_REPORT_THRESHOLD_
        }
 
        static bool const CheckTimesliceOverrun =
#  ifdef ZTH_CONFIG_CHECK_TIMESLICE_OVERRUN
                ZTH_CONFIG_CHECK_TIMESLICE_OVERRUN;
#  else
                Debug;
#  endif
 
        static bool const NamedSynchronizer = SupportDebugPrint && Print_sync > 0;
 
        static size_t const PerfEventBufferSize =
#  ifdef ZTH_CONFIG_PERF_EVENT_BUFFER_SIZE
                ZTH_CONFIG_PERF_EVENT_BUFFER_SIZE;
#  elif defined(ZTH_OS_BAREMETAL)
                0x400;
#  else
                0x4000;
#  endif
 
        static size_t const PerfEventBufferSpare =
                PerfEventBufferSize > 64 ? PerfEventBufferSize / 2 : 32;
 
        static bool const DoPerfEvent = false;
 
        static bool const EnablePerfEvent =
#  ifdef ZTH_CONFIG_ENABLE_PERF_EVENT
                ZTH_CONFIG_ENABLE_PERF_EVENT;
#  elif defined(ZTH_OS_BAREMETAL)
                false;
#  else
                true;
#  endif
        static bool const PerfSyscall =
#  ifdef ZTH_CONFIG_PERF_SYSCALL
                ZTH_CONFIG_PERF_SYSCALL;
#  else
                true;
#  endif
 
        static bool const NamedFsm = Debug || (SupportDebugPrint && Print_fsm > 0);
 
        static bool const NamedObjects =
                SupportDebugPrint || EnablePerfEvent || NamedSynchronizer || CheckTimesliceOverrun;
 
        static bool const UseZMQ =
#  ifdef ZTH_HAVE_LIBZMQ
                true;
#  else
                false;
#  endif
 
        static bool const UseLimitedFormatSpecifiers =
#  if defined(ZTH_FORMAT_LIMITED) && ZTH_FORMAT_LIMITED
                true;
#  else
                false;
#  endif
 
        static bool const EnableExceptions =
#  if defined(__cpp_exceptions) && !defined(ZTH_DISABLE_EXCEPTIONS)
                true;
#  else
                false;
#  endif
 
        template <typename T>
        struct Allocator {
                typedef std::allocator<T> type;
        };
};
} // namespace zth
#endif // __cplusplus
 
#include "zth_config.h"
 
#undef ZTH_CONSTEXPR_RETURN
 
#ifdef __cplusplus
namespace zth {
 
struct Check {
        enum {
                Config_Debug,
                Config_EnableAssert,
                Config_EnableFullAssert,
                Config_EnableBacktrace,
                Config_EnableThreads,
                Config_SupportDebugPrint,
                Config_EnableColorLog,
                Config_DefaultFiberStackSize,
                Config_EnableStackGuard,
                Config_EnableStackWaterMark,
                Config_ContextSignals,
                Config_CheckTimesliceOverrun,
                Config_PerfEventBufferSize,
                Config_EnablePerfEvent,
                Config_PerfSyscall,
                Config_UseZMQ,
                Config_UseLimitedFormatSpecifiers,
                Config_EnableExceptions,
        };
};
 
void checkConfig(int check /* one if Check::Config_... */, size_t value);
 
static inline void checkConfig()
{
        static bool checked;
        if(checked)
                return;
 
#  define ZTH_CHECK(x) checkConfig(Check::Config_##x, (size_t)Config::x);
 
        ZTH_CHECK(Debug)
        ZTH_CHECK(EnableAssert)
        ZTH_CHECK(EnableFullAssert)
        ZTH_CHECK(EnableBacktrace)
        ZTH_CHECK(EnableThreads)
        ZTH_CHECK(SupportDebugPrint)
        ZTH_CHECK(EnableColorLog)
        ZTH_CHECK(DefaultFiberStackSize)
        ZTH_CHECK(EnableStackGuard)
        ZTH_CHECK(EnableStackWaterMark)
        ZTH_CHECK(ContextSignals)
        ZTH_CHECK(CheckTimesliceOverrun)
        ZTH_CHECK(PerfEventBufferSize)
        ZTH_CHECK(EnablePerfEvent)
        ZTH_CHECK(PerfSyscall)
        ZTH_CHECK(UseZMQ)
        ZTH_CHECK(UseLimitedFormatSpecifiers)
        ZTH_CHECK(EnableExceptions)
 
#  undef ZTH_CHECK
 
#  ifdef __cpp_exceptions
        static_assert(Config::EnableExceptions);
#  else
        static_assert(!Config::EnableExceptions);
#  endif
 
        checked = true;
}
 
ZTH_APP_INIT_CALL(checkConfig)
 
} // namespace zth
#endif // __cplusplus
 
#endif // ZTH_CONFIG_H