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 <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
                true;
#  else
                false;
#  endif
 
        static bool const EnableAssert =
#  ifndef NDEBUG
                Debug;
#  else
                false;
#  endif
 
        static bool const EnableFullAssert =
#  ifdef ZTH_OS_BAREMETAL
                // Assume we are a bit short on memory.
                false;
#  else
                EnableAssert;
#  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_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 = true;
 
        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 = 0x20000;
        static bool const EnableStackGuard = Debug;
        static bool const EnableStackWaterMark = Debug;
        static bool const ContextSignals = false;
 
        constexpr static struct timespec MinTimeslice()
        {
                ZTH_CONSTEXPR_RETURN(struct timespec, 0, 100000)
        }
        constexpr static struct timespec TimesliceOverrunReportThreshold()
        {
                ZTH_CONSTEXPR_RETURN(struct timespec, 0, 10000000)
        }
 
        static bool const CheckTimesliceOverrun = Debug;
        static bool const NamedSynchronizer = SupportDebugPrint && Print_sync > 0;
 
        static size_t const PerfEventBufferSize = 128;
        static size_t const PerfEventBufferThresholdToTriggerVCDWrite = PerfEventBufferSize / 2;
        static size_t const PerfVCDFileBuffer = 0x1000;
 
        static bool const DoPerfEvent = false;
        static bool const EnablePerfEvent =
#  ifdef ZTH_OS_BAREMETAL
                // No environment, so only enable when we are actually saving it.
                DoPerfEvent;
#  else
                true;
#  endif
        static bool const PerfSyscall = true;
 
        static bool const NamedFsm = Debug || (EnableDebugPrint && 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
 
        template <typename T>
        struct Allocator {
                typedef std::allocator<T> type;
        };
};
} // namespace zth
#endif // __cplusplus
 
#include "zth_config.h"
 
#undef ZTH_CONSTEXPR_RETURN
#endif // ZTH_CONFIG_H