HowTo needed: CPP17 branch -> replac log messages and generate json file

[tunguskar]

CPP17 Branch: I havent found any how to on using the log library. More precise, what do I have to do/call to replace my log messages with the index and how to generate the related json file with this indexes. Maybe someone can help me?

[elbeno]

It works basically the same way on the 17 branch as on main. See:

• https://github.com/intel/compile-time-init-build/blob/cpp17/tools/gen_str_catalog.py
• https://github.com/intel/compile-time-init-build/blob/cpp17/CMakeLists.txt#L80

This is the relevant script & cmake driver code that generates the string catalog. At this point the 17 branch tooling is less developed than that on main, but the process is the same:

• compile your code as a library
• run nm to extract the undefined symbols
• use the python script to generate the function template overloads according to the missing symbols (also the json/XML)
• compile that strings library
• link everything with LTO so that the one-liner string ID functions get inlined

Main branch docs: https://intel.github.io/compile-time-init-build/#_efficient_logging_with_mipi_sys_t

[tunguskar]

Thanks I will give it a try

[tunguskar]

I tried it now like this:

testLib.hpp

struct loggerOnTarget : logging::null::config
{

  static auto terminate() noexcept -> void
  {
    puts("Terminating...\n");
  }

  struct
  {
    template <logging::level L, typename... Ts>
    constexpr auto log(Ts &&...) const noexcept -> void
    {
      // TODO: There has to be added the index
    }
  } logger;
};

template <>
inline auto logging::config<> = loggerOnTarget{};

void testFunc(void)
{
   volatile auto test = "test"_sc;
  CIB_INFO("Info");
  CIB_TRACE("Trace");
  CIB_WARN("Warn");
  CIB_ERROR("Error");
}

now creating a test App as a lib

testAppLib.hpp

#pragma once

int main(void);

and the cpp

#include <standard/testLib.hpp>

int main(void)
{   
  testFunc();
}

configure and build

than doing the nm:

nm -uC test_lib.a >> undefined_symbols.txt

output:

testAppLib.cpp.o:
                 U _GLOBAL_OFFSET_TABLE_
                 U std::runtime_error::what() const
                 U std::runtime_error::~runtime_error()
                 U std::ios_base::Init::Init()
                 U std::ios_base::Init::~Init()
                 U typeinfo for std::runtime_error
                 U vtable for __cxxabiv1::__si_class_type_info
                 U operator delete(void*, unsigned long)
                 U __cxa_atexit
                 U __dso_handle
                 U __stack_chk_fail

on this file a

python3 gen_str_catalog.py undefined_symbols.txt strings.cpp strings.json strings.xml

finds no missing symbols. I thought that at least the test_sc should be found.

[elbeno]

Your log code is not actually doing anything, so there is no use of the strings. In particular there is no call to any specialization of catalog (https://github.com/intel/compile-time-init-build/blob/cpp17/include/log/catalog/catalog.hpp#L11). Hence nm finds no missing symbols because there are none.

[tunguskar]

Thanks @elbeno, sorry for so much questions. I added now several configs. Just for others which have the same question than me:

Target Logger (replace the cout statements with a uart, or whatever write routine)

struct loggerOnTarget : logging::null::config
{

  static auto terminate() noexcept -> void
  {
    puts("Terminating...\n");
  }

  struct
  {

    template <logging::level Level, typename FilenameStringType,
              typename LineNumberType, typename MsgType>
    auto log(FilenameStringType, LineNumberType,
                               MsgType const &msg) -> void 
    {
      using Message = message<Level, MsgType>;
      const uint32_t msg_id = catalog<Message>();

      std::cout << "ID: " << msg_id << " ";

      msg.args.apply([](auto... args){
        logArgs(args...);
      });
    }

    template<typename... Args>
    static void logArgs(const uint8_t t, Args&&... args){

      std::cout << "Arg: " << static_cast<int>(t);
      logArgs(args...);
    }

    static void logArgs() 
    {
      std::cout << std::endl;
    }
  } logger;
};

template <>
inline auto logging::config<> = loggerOnTarget{};

or dump to a container:

/**
 * The Second one outputs the formated string to a buffer
 */
class LogContainer
{
public:
  static auto &get()
  {
    return buffer;
  }

  static void dump()
  {
    puts(buffer.c_str());
  }

private:
  static std::string buffer;
};

std::string LogContainer::buffer{};

template <typename... TDestinations>
struct custom_config : logging::fmt::config<TDestinations...>
{
  using base = logging::fmt::config<TDestinations...>;

  // Inherit the base class constructor
  constexpr explicit custom_config(TDestinations... dests) : base{std::forward<TDestinations>(dests)...}
  {
  }

  [[noreturn]] static auto terminate()
  {
    // Custom termination logic
    puts("Custom termination logic.\n");
  }
};

template <>
inline auto logging::config<> = custom_config{std::back_inserter(LogContainer::get())};

or just stream to cout:

template <>
inline auto logging::config<> = logging::fmt::config{std::ostream_iterator<char>{std::cout}};