🔥 Remove sc

Author: elbeno

CMakeLists.txt

@@ -33,27 +33,9 @@ set(GEN_STR_CATALOG
     ${CMAKE_CURRENT_LIST_DIR}/tools/gen_str_catalog.py
     CACHE FILEPATH "Location of script to generate a string catalog")
 
-add_library(cib_sc INTERFACE)
-target_compile_features(cib_sc INTERFACE cxx_std_20)
-target_link_libraries_system(cib_sc INTERFACE fmt::fmt-header-only stdx)
-
-target_sources(
-    cib_sc
-    INTERFACE FILE_SET
-              sc
-              TYPE
-              HEADERS
-              BASE_DIRS
-              include
-              FILES
-              include/sc/format.hpp
-              include/sc/fwd.hpp
-              include/sc/lazy_string_format.hpp
-              include/sc/string_constant.hpp)
-
 add_library(cib_match INTERFACE)
 target_compile_features(cib_match INTERFACE cxx_std_20)
-target_link_libraries_system(cib_match INTERFACE cib_sc stdx)
+target_link_libraries_system(cib_match INTERFACE stdx)
 
 target_sources(
     cib_match
@@ -80,7 +62,7 @@ target_sources(
 
 add_library(cib_interrupt INTERFACE)
 target_compile_features(cib_interrupt INTERFACE cxx_std_20)
-target_link_libraries_system(cib_interrupt INTERFACE cib_sc concurrency stdx)
+target_link_libraries_system(cib_interrupt INTERFACE concurrency stdx)
 
 target_sources(
     cib_interrupt
@@ -124,7 +106,7 @@ target_sources(
 
 add_library(cib_log INTERFACE)
 target_compile_features(cib_log INTERFACE cxx_std_20)
-target_link_libraries_system(cib_log INTERFACE cib_sc stdx)
+target_link_libraries_system(cib_log INTERFACE stdx)
 
 target_sources(
     cib_log
@@ -147,7 +129,6 @@ target_link_libraries_system(
     cib_log
     cib_lookup
     cib_match
-    cib_sc
     stdx)
 
 target_sources(
@@ -238,7 +219,7 @@ target_sources(
 
 add_library(cib_flow INTERFACE)
 target_compile_features(cib_flow INTERFACE cxx_std_20)
-target_link_libraries_system(cib_flow INTERFACE cib_log cib_nexus cib_sc stdx)
+target_link_libraries_system(cib_flow INTERFACE cib_log cib_nexus stdx)
 
 target_sources(
     cib_flow
@@ -263,14 +244,7 @@ target_sources(
 
 add_library(cib_seq INTERFACE)
 target_compile_features(cib_seq INTERFACE cxx_std_20)
-target_link_libraries_system(
-    cib_seq
-    INTERFACE
-    cib_flow
-    cib_log
-    cib_nexus
-    cib_sc
-    stdx)
+target_link_libraries_system(cib_seq INTERFACE cib_flow cib_log cib_nexus stdx)
 
 target_sources(
     cib_seq
@@ -300,7 +274,6 @@ target_link_libraries_system(
     cib_match
     cib_msg
     cib_nexus
-    cib_sc
     cib_seq
     concurrency
     fmt::fmt-header-only
@@ -330,7 +303,6 @@ if(PROJECT_IS_TOP_LEVEL)
     clang_tidy_interface(cib_match)
     clang_tidy_interface(cib_msg)
     clang_tidy_interface(cib_nexus)
-    clang_tidy_interface(cib_sc)
     clang_tidy_interface(cib_seq)
 
     # Enable functional and performance test suites.

README.md

@@ -13,5 +13,4 @@ include::logging.adoc[]
 include::interrupts.adoc[]
 include::match.adoc[]
 include::message.adoc[]
-include::sc.adoc[]
 include::implementation_details.adoc[]

docs/index.adoc

@@ -47,7 +47,6 @@ _cib_ contains several parts that work together:
 - xref:interrupt.adoc#_the_interrupt_library[`interrupt`]
 - xref:match.adoc#_the_match_library[`match`]
 - xref:message.adoc#_the_message_library[`message`]
-- xref:sc.adoc#_the_sc_string_constant_library[`sc` (string constant)]
 
 === Sub-library DAG
 
@@ -57,24 +56,21 @@ library that contains all the functionality.
 [mermaid, format="svg"]
 ----
 flowchart BT
-  sc(cib_sc)
   nexus(cib_nexus)
   lookup(cib_lookup)
+  log(cib_log)
+  match(cib_match)
 
   flow(cib_flow) --> nexus
   flow --> log
 
-  interrupt(cib_interrupt) --> sc
-  match(cib_match) --> sc
-  log(cib_log) --> sc
-
-
   log_fmt(cib_log_fmt) --> log
   msg(cib_msg) --> log & match
   msg --> lookup
 
   log_mipi(cib_log_mipi) --> msg
   seq(cib_seq) --> flow
 
-  cib --> interrupt & seq & log_fmt & log_mipi
+  interrupt(cib_interrupt)
+  cib(cib) --> interrupt & seq & log_fmt & log_mipi
 ----

docs/intro.adoc

@@ -97,11 +97,11 @@ struct my_logger_config {
 
 Notice that the first two template parameters to log are the
 xref:logging.adoc#_log_levels[level] and the xref:logging.adoc#_modules[module
-ID]. The `ModuleId` type is a xref:sc.adoc#_string_constants[compile-time string].
+ID].
 
 The first two runtime parameters receive preprocessor `\_​_FILE_​\_` and `__LINE_​_` values
 respectively. The `msg` argument is a structure containing a
-xref:sc.adoc#_formatting_strings[compile-time format string] and runtime
+compile-time format string and runtime
 arguments to be interpolated into it. It supports an `apply` function, so one
 way to implement `log` is:
 
@@ -188,11 +188,52 @@ struct my_struct {
 }
 ----
 
-=== String data
-
-On a constrained system, space for text can be at a premium. The `sc` library
-and the MIPI Sys-T logger combine to
-xref:sc.adoc#_efficient_logging_with_mipi_sys_t[solve this problem].
+=== Efficient logging with MIPI Sys-T
+
+On a constrained system, space for text can be limited-to-nonexistent. `cib`
+uses `stdx::ct_format` and the
+https://github.com/intel/compile-time-init-build/tree/main/include/log/catalog/mipi_encoder.hpp[MIPI
+Sys-T logging config] to solve this problem.
+
+- First, each string constant contains string character data in its type.
+- The MIPI logger calls the function template specialization
+  https://github.com/intel/compile-time-init-build/blob/main/include/log/catalog/catalog.hpp[`catalog`]
+  to get the catalog ID corresponding to each string constant.
+
+But: the `catalog` function template is just that -- only a template -- to
+begin with. It is specialized as follows:
+
+- The application is built as a library.
+- Running `nm` on that library reveals missing symbols: precisely the function
+  specializations that are required for all the string constants.
+- Those symbols are used to generate the template specializations in another
+  file, which itself is compiled into a library.
+- String data is recovered from the symbol types and used to generate the
+  catalog collateral in XML and/or JSON format.
+- Link-time optimization inlines the `catalog` function template
+  specializations, each of which is a one-line function that returns a
+  catalog ID.
+
+Thus no string data exists in the executable, but the correct catalog IDs are
+used in logging, and the remote log handler can reconstitute the actual strings.
+The XML and JSON collateral also contains information about any runtime
+arguments that need to be interpolated into the string and whose values are sent
+by the MIPI Sys-T logger after the catalog ID.
+
+==== Tooling support
+
+The process of generating log strings from the type information revealed by
+missing symbols is automated by a
+https://github.com/intel/compile-time-init-build/blob/main/tools/gen_str_catalog.py[python
+script] provided and by a
+https://github.com/intel/compile-time-init-build/blob/main/cmake/string_catalog.cmake[CMake
+wrapper function (`gen_str_catalog`)] that drives the process. See
+https://github.com/intel/compile-time-init-build/blob/main/test/CMakeLists.txt[the
+test] that exercises that functionality for an example.
+
+NOTE: This process assigns IDs to both strings and
+xref:logging.adoc#_modules[log modules]. `catalog` is specialized for catalog
+IDs; `module` is specialized for module IDs.
 
 === Version logging