roland/xo-umbrella2
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

xo-reader2 stack: + TypeRegistry

Browse source
This commit is contained in:
Roland Conybeare 2026-02-15 22:57:15 -05:00
commit 0023831e4c
17 changed files with 318 additions and 136 deletions
Download patch file Download diff file Expand all files Collapse all files

2
xo-alloc2/utest/DArenaIterator.test.cpp
View file

@ -169,7 +169,7 @@ namespace xo {
/* arbitrary alloc size */
size_t req_z = 13;
byte * mem = a1o.alloc(typeseq::anon(), req_z);
byte * mem = a1o.alloc(typeseq::sentinel(), req_z);
REQUIRE(arena.error_count_ == 0);
REQUIRE(mem != nullptr);

10
xo-alloc2/utest/arena.test.cpp
View file

@ -159,7 +159,7 @@ namespace xo {
REQUIRE(a1o.allocated() == 0);
size_t z0 = 1;
byte * m0 = a1o.alloc(typeseq::anon(), 1);
byte * m0 = a1o.alloc(typeseq::sentinel(), 1);
REQUIRE(m0);
REQUIRE(a1o.last_error().error_ == error::ok);
@ -171,7 +171,7 @@ namespace xo {
REQUIRE(a1o.committed() <= a1o.reserved());
size_t z1 = 16;
byte * m1 = a1o.alloc(typeseq::anon(), z1);
byte * m1 = a1o.alloc(typeseq::sentinel(), z1);
REQUIRE(m1);
REQUIRE(a1o.last_error().error_ == error::ok);
@ -209,7 +209,7 @@ namespace xo {
REQUIRE(a1o.allocated() == 0);
size_t z0 = 1;
byte * m0 = a1o.alloc(typeseq::anon(), 1);
byte * m0 = a1o.alloc(typeseq::sentinel(), 1);
REQUIRE(m0);
@ -253,7 +253,7 @@ namespace xo {
REQUIRE(a1o.allocated() == 0);
size_t z0 = 1;
byte * m0 = a1o.alloc(typeseq::anon(), 1);
byte * m0 = a1o.alloc(typeseq::sentinel(), 1);
REQUIRE(m0);
@ -306,7 +306,7 @@ namespace xo {
REQUIRE(a1o.allocated() == 0);
size_t z0 = cfg.hugepage_z_ + 1;
byte * m0 = a1o.alloc(typeseq::anon(), z0);
byte * m0 = a1o.alloc(typeseq::sentinel(), z0);
REQUIRE(!m0);

2
xo-alloc2/utest/random_allocs.cpp
View file

@ -67,7 +67,7 @@ namespace utest {
bool ok_flag = true;
std::byte * mem = mm.alloc(typeseq::anon(), z);
std::byte * mem = mm.alloc(typeseq::sentinel(), z);
log && log(xtag("i_alloc", i_alloc),
xtag("si", si),

6
xo-arena/include/xo/arena/MemorySizeInfo.hpp
View file

@ -16,8 +16,10 @@ namespace xo {
using size_type = std::size_t;
MemorySizeInfo() = default;
MemorySizeInfo(std::string_view name, std::size_t u, std::size_t a, std::size_t c, std::size_t r)
: resource_name_{name}, used_{u}, allocated_{a}, committed_{c}, reserved_{r}
MemorySizeInfo(std::string_view name,
std::size_t u, std::size_t a, std::size_t c, std::size_t r)
: resource_name_{name},
used_{u}, allocated_{a}, committed_{c}, reserved_{r}
{}
static MemorySizeInfo sentinel() { return MemorySizeInfo(); }

4
xo-arena/src/arena/DArena.cpp
View file

@ -67,7 +67,7 @@ namespace xo {
DArena::DArena(const ArenaConfig & cfg)
{
*this = std::move(map(cfg));
*this = map(cfg);
}
DArena::DArena(const ArenaConfig & cfg,
@ -290,7 +290,7 @@ namespace xo {
(complete_flag
? alloc_mode::sub_complete
: alloc_mode::sub_incomplete),
typeseq::anon() /*typeseq: ignored*/,
typeseq::sentinel() /*typeseq: ignored*/,
0 /*age - ignored */);
}

6
xo-arena/utest/DArena.test.cpp
View file

@ -147,7 +147,7 @@ namespace xo {
REQUIRE(arena.allocated() == 0);
size_t z0 = 1;
byte * m0 = arena.alloc(typeseq::anon(), 1);
byte * m0 = arena.alloc(typeseq::sentinel(), 1);
REQUIRE(m0);
REQUIRE(arena.last_error().error_ == error::ok);
@ -159,7 +159,7 @@ namespace xo {
REQUIRE(arena.committed() <= arena.reserved());
size_t z1 = 16;
byte * m1 = arena.alloc(typeseq::anon(), z1);
byte * m1 = arena.alloc(typeseq::sentinel(), z1);
REQUIRE(m1);
REQUIRE(arena.last_error().error_ == error::ok);
@ -195,7 +195,7 @@ namespace xo {
REQUIRE(arena.allocated() == 0);
size_t z0 = 1;
byte * m0 = arena.alloc(typeseq::anon(), 1);
byte * m0 = arena.alloc(typeseq::sentinel(), 1);
REQUIRE(m0);

6
xo-facet/include/xo/facet/FacetRegistry.hpp
View file

@ -7,8 +7,9 @@
#pragma once
#include "TypeRegistry.hpp"
#include "facet_implementation.hpp"
#include "typeseq.hpp"
//#include "typeseq.hpp"
#include "obj.hpp"
#include <xo/arena/DArenaHashMap.hpp>
#include <xo/indentlog/scope.hpp>
@ -74,6 +75,9 @@ namespace xo {
static void register_impl() {
static FacetImplType<AFacet, DRepr> impl;
TypeRegistry::register_type<AFacet>();
TypeRegistry::register_type<DRepr>();
instance()._register_impl(typeseq::id<AFacet>(),
typeseq::id<DRepr>(),
&impl);

137
xo-facet/include/xo/facet/TypeRegistry.hpp Normal file
View file

@ -0,0 +1,137 @@
/** @file TypeRegistry.hpp
*
* @brief Runtime facet implementation lookup
*
* @author Roland Conybeare, Jan 2026
**/
#pragma once
#include "typeseq.hpp"
#include <xo/arena/DArenaVector.hpp>
#include <xo/indentlog/scope.hpp>
#include <utility>
namespace xo {
namespace facet {
/** @class TypeRegistry
*
* @brief Runtime registry for types.
*
* Just assigns ids and remembers names.
* Not a full reflection implementation
**/
class TypeRegistry {
public:
using ReprType = xo::mm::DArenaVector<typerecd>;
using ArenaConfig = xo::mm::ArenaConfig;
using MemorySizeVisitor = xo::mm::MemorySizeVisitor;
using typeseq = xo::reflect::typeseq;
/** singleton instance.
* @p hint_max_capacity is a lower bound for registry capacity.
* Only honored the first time instance is called.
**/
static TypeRegistry & instance(uint32_t hint_max_capacity = 1024) {
static TypeRegistry s_instance(hint_max_capacity);
return s_instance;
}
/** Type-safe registration
*
* Registers the compile-time FacetImplementation<AFacet, DRepr>
* for runtime lookup.
*
* @tparam AFacet abstract facet type
* @tparam DRepr data representation type
**/
template <typename T>
static void register_type() {
typerecd r = typerecd::recd<T>();
instance()._register_type(r);
}
/** Number of registered (facet, repr) pairs **/
std::size_t size() const { return registry_.size(); }
std::string_view id2name(typeseq id) const noexcept {
return instance()._id2name(id);
}
/** visit memory pools owned by facet registry **/
void visit_pools(const MemorySizeVisitor & visitor) {
registry_.visit_pools(visitor);
}
/** Check if type is registered **/
bool contains(typeseq id) const
{
if ((0 <= id.seqno())
&& (id.seqno() < static_cast<int32_t>(registry_.size())))
{
return (registry_.at(id.seqno()).seqno() == id.seqno());
}
return false;
}
void dump(std::ostream * p_out) const {
(*p_out) << std::endl;
(*p_out) << "<TypeRegistry" << std::endl;
for (const auto & item : registry_) {
(*p_out)
<< " [" << item.seqno() << "]"
<< " -> " << item.name() << std::endl;
}
(*p_out) << ">" << std::endl;
}
private:
/** Register a facet implementation (type-erased)
*
* @param facet_id typeseq for abstract facet (e.g., APrintable)
* @param repr_id typeseq for data representation (e.g., DFloat)
* @param impl pointer to stateless implementation instance
**/
void _register_type(const typerecd & recd)
{
if ((recd.seqno() >= 0)
&& (static_cast<int32_t>(registry_.size()) <= recd.seqno()))
{
registry_.resize(recd.seqno() + 1);
}
registry_.at(recd.seqno()) = recd;
}
/** Get typename from @p id.
**/
std::string_view _id2name(typeseq id) const
{
if ((0 <= id.seqno())
&& (static_cast<std::size_t>(id.seqno()) < registry_.size()))
{
return registry_.at(id.seqno()).name();
}
return typerecd::sentinel().name();
}
private:
TypeRegistry(uint32_t hint_max_capacity)
: registry_(ReprType::map(ArenaConfig()
.with_name("types")
.with_size(hint_max_capacity
* sizeof(typerecd))))
{}
/** runtime lookup table (AFacet,DRepr) -> impl **/
ReprType registry_;
};
} /*namespace facet*/
} /*namespace xo*/
/* end TypeRegistry.hpp */

2
xo-facet/include/xo/facet/typeseq.hpp
View file

@ -12,7 +12,7 @@
namespace xo {
namespace facet {
// Re-export from xo::arena namespace
using xo::reflect::typeseq_impl;
using xo::reflect::typerecd;
using xo::reflect::typeseq;
}
} /*namespace xo*/

2
xo-gc/src/gc/DX1Collector.cpp
View file

@ -279,7 +279,7 @@ namespace xo {
DX1Collector::add_gc_root_poly(obj<AGCObject> * p_root) noexcept
{
std::byte * mem
= roots_.alloc(typeseq::anon(),
= roots_.alloc(typeseq::sentinel(),
sizeof(obj<AGCObject>*));
assert(mem);

2
xo-gc/utest/DX1CollectorIterator.test.cpp
View file

@ -110,7 +110,7 @@ namespace xo {
REQUIRE(a1o.allocated() == 0);
size_t req_z = 13;
byte * mem = gc.alloc(typeseq::anon(), req_z);
byte * mem = gc.alloc(typeseq::sentinel(), req_z);
REQUIRE(mem != nullptr);

2
xo-gc/utest/random_allocs.cpp
View file

@ -67,7 +67,7 @@ namespace utest {
bool ok_flag = true;
std::byte * mem = mm.alloc(typeseq::anon(), z);
std::byte * mem = mm.alloc(typeseq::sentinel(), z);
log && log(xtag("i_alloc", i_alloc),
xtag("si", si),

2
xo-reader2/utest/SchematikaParser.test.cpp
View file

@ -78,7 +78,7 @@ namespace xo {
bool log_memory_layout(scope * p_log) {
auto visitor = [p_log](const MemorySizeInfo & info) {
*p_log && (*p_log)(xtag("resource", info.resource_name_),
*p_log && (*p_log)(xtag("name", info.resource_name_),
xtag("used", info.used_),
xtag("alloc", info.allocated_),
xtag("commit", info.committed_),

87
xo-refcnt/include/xo/cxxutil/demangle.hpp
View file

@ -2,91 +2,6 @@
#pragma once
#include <string>
#include <string_view>
#include <array> // std::array
#include <utility> // std::index_sequence
namespace xo {
namespace reflect {
template <std::size_t...Idxs>
constexpr auto
substring_as_array(std::string_view str,
std::index_sequence<Idxs...> indexes)
{
//return std::array<char, indexes.size()+1>{str[Idxs]..., '\n'};
return std::array<char, indexes.size()>{str[Idxs]...};
} /*substring_as_array*/
template <typename T> constexpr auto type_name_array() {
#if defined(__clang__)
constexpr auto prefix = std::string_view{"[T = "};
constexpr auto suffix = std::string_view{"]"};
constexpr auto function = std::string_view{__PRETTY_FUNCTION__};
#elif defined(__GNUC__)
constexpr auto prefix = std::string_view{"with T = "};
constexpr auto suffix = std::string_view{"]"};
constexpr auto function = std::string_view{__PRETTY_FUNCTION__};
#elif defined(_MSC_VER)
constexpr auto prefix = std::string_view{"type_name_array<"};
constexpr auto suffix = std::string_view{">(void)"};
constexpr auto function = std::string_view{__FUNCSIG__};
#else
# error type_name_array: Unsupported compiler
#endif
constexpr auto start = function.find(prefix) + prefix.size();
constexpr auto end = function.rfind(suffix);
//static_assert(start < end);
constexpr auto name = function.substr(start, (end - start));
constexpr auto ixseq = std::make_index_sequence<name.size()>{};
return substring_as_array(name, ixseq);
} /*type_name_array*/
template <typename T>
struct type_name_holder {
static inline constexpr auto value = type_name_array<T>();
};
template <typename T>
constexpr auto type_name() -> std::string_view
{
constexpr auto& value = type_name_holder<T>::value;
return std::string_view{value.data(), value.size()};
}
#ifdef NOT_IN_USE
template <std::string_view const&... Strs>
struct join
{
// Join all strings into a single std::array of chars
static constexpr auto impl() noexcept
{
constexpr std::size_t len = (Strs.size() + ... + 0);
std::array<char, len + 1> arr{};
auto append = [i = 0, &arr](auto const& s) mutable {
for (auto c : s) arr[i++] = c;
};
(append(Strs), ...);
arr[len] = 0;
return arr;
}
// Give the joined string static storage
static constexpr auto arr = impl();
// View as a std::string_view
static constexpr std::string_view value {arr.data(), arr.size() - 1};
};
// Helper to get the value out
template <std::string_view const&... Strs>
static constexpr auto join_v = join<Strs...>::value;
#endif
} /*namespace reflect*/
} /*namespace xo*/
#include <xo/reflectutil/type_name.hpp>
/* end demangle.hpp */

1
xo-refcnt/src/CMakeLists.txt
View file

@ -7,4 +7,5 @@ xo_install_include_tree3(include/xo/cxxutil)
# NOTE:
# dependency set here must be kept consistent with refcnt/cmake/refcntConfig.cmake.in
#
xo_dependency(${SELF_LIB} xo_reflectutil)
xo_dependency(${SELF_LIB} indentlog)

94
xo-reflectutil/include/xo/reflectutil/type_name.hpp Normal file
View file

@ -0,0 +1,94 @@
/* @file type_name.hpp */
#pragma once
//#include <string>
#include <string_view>
#include <array> // std::array
#include <utility> // std::index_sequence
namespace xo {
namespace reflect {
template <std::size_t...Idxs>
constexpr auto
substring_as_array(std::string_view str,
std::index_sequence<Idxs...> indexes)
{
//return std::array<char, indexes.size()+1>{str[Idxs]..., '\n'};
return std::array<char, indexes.size()>{str[Idxs]...};
} /*substring_as_array*/
template <typename T> constexpr auto type_name_array() {
#if defined(__clang__)
constexpr auto prefix = std::string_view{"[T = "};
constexpr auto suffix = std::string_view{"]"};
constexpr auto function = std::string_view{__PRETTY_FUNCTION__};
#elif defined(__GNUC__)
constexpr auto prefix = std::string_view{"with T = "};
constexpr auto suffix = std::string_view{"]"};
constexpr auto function = std::string_view{__PRETTY_FUNCTION__};
#elif defined(_MSC_VER)
constexpr auto prefix = std::string_view{"type_name_array<"};
constexpr auto suffix = std::string_view{">(void)"};
constexpr auto function = std::string_view{__FUNCSIG__};
#else
# error type_name_array: Unsupported compiler
#endif
constexpr auto start = function.find(prefix) + prefix.size();
constexpr auto end = function.rfind(suffix);
//static_assert(start < end);
constexpr auto name = function.substr(start, (end - start));
constexpr auto ixseq = std::make_index_sequence<name.size()>{};
return substring_as_array(name, ixseq);
} /*type_name_array*/
template <typename T>
struct type_name_holder {
static inline constexpr auto value = type_name_array<T>();
};
/** report name of type T as a string_view;
* using constexpr deps so runs at **/
template <typename T>
constexpr auto type_name() -> std::string_view
{
constexpr auto& value = type_name_holder<T>::value;
return std::string_view{value.data(), value.size()};
}
#ifdef NOT_IN_USE
template <std::string_view const&... Strs>
struct join
{
// Join all strings into a single std::array of chars
static constexpr auto impl() noexcept
{
constexpr std::size_t len = (Strs.size() + ... + 0);
std::array<char, len + 1> arr{};
auto append = [i = 0, &arr](auto const& s) mutable {
for (auto c : s) arr[i++] = c;
};
(append(Strs), ...);
arr[len] = 0;
return arr;
}
// Give the joined string static storage
static constexpr auto arr = impl();
// View as a std::string_view
static constexpr std::string_view value {arr.data(), arr.size() - 1};
};
// Helper to get the value out
template <std::string_view const&... Strs>
static constexpr auto join_v = join<Strs...>::value;
#endif
} /*namespace reflect*/
} /*namespace xo*/
/* end type_name.hpp */

89
xo-reflectutil/include/xo/reflectutil/typeseq.hpp
View file

@ -5,22 +5,20 @@
#pragma once
#include "type_name.hpp"
#include <iostream>
#include <cstdint>
namespace xo {
namespace reflect {
/**
* Tag here so we can preserve header-only implementation
* and still have static variable
*/
template<typename Tag = class typeseq_tag>
struct typeseq_impl {
/** create sentinel value **/
typeseq_impl() = default;
// template <typename Tag = class typerecd_tag>
struct typerecd {
/** sentinel value **/
typerecd() = default;
/** typeseq with specific unique id **/
explicit typeseq_impl(int32_t s) : seqno_{s} {}
/** type-record with specific, unique id **/
explicit typerecd(int32_t s,
std::string_view n) : seqno_{s}, name_{n} {}
/** Can't have this be constexpr.
* We need ids in shared libraries to be generated
@ -35,57 +33,88 @@ namespace xo {
* when using clang.
**/
template <typename T>
static typeseq_impl<Tag> id() {
static bool armed = true;
static typerecd recd() {
// reminder: {armed, id} are distint for each T
static bool s_armed = true;
static int32_t id = 0;
if (armed) {
armed = false;
id = ++s_next_id;
if (s_armed) {
s_armed = false;
id = require_next_id();
}
return typeseq_impl(id);
return typerecd(id, xo::reflect::type_name<T>());
}
static int32_t require_next_id() {
static int32_t s_next_id = 0;
return s_next_id++;
}
int32_t seqno() const { return seqno_; }
std::string_view name() const { return name_; }
/** sentinel typerecd instance **/
static typerecd sentinel() {
return typerecd(-1, "_%sentinel%_");
}
private:
int32_t seqno_ = 0;
std::string_view name_;
};
//template <typename Tag>
//int32_t typerecd_impl<Tag>::s_next_id = 0;
/**
* Tag here so we can preserve header-only implementation
* and still have static variable
*/
struct typeseq {
/** create sentinel value **/
typeseq() = default;
/** typeseq with specific unique id **/
explicit typeseq(int32_t s) : seqno_{s} {}
/** 'anonymous' sentinel type.
* Niche uses for this, e.g. untyped allocator
**/
static typeseq_impl<Tag> anon() {
return typeseq_impl(-1);
static typeseq sentinel() {
return typeseq(typerecd::sentinel().seqno());
}
template <typename T>
static typeseq id() {
return typeseq(xo::reflect::typerecd::recd<T>().seqno());
}
int32_t seqno() const { return seqno_; }
private:
static int32_t s_next_id;
int32_t seqno_ = 0;
};
template <typename Tag>
int32_t typeseq_impl<Tag>::s_next_id = 0;
//template <typename Tag>
//int32_t typeseq_impl<Tag>::s_next_id = 0;
template <typename Tag>
inline bool
operator==(const typeseq_impl<Tag> & lhs, const typeseq_impl<Tag> & rhs) {
operator==(const typeseq & lhs, const typeseq & rhs) {
return lhs.seqno() == rhs.seqno();
}
template <typename Tag>
inline bool
operator!=(const typeseq_impl<Tag> & lhs, const typeseq_impl<Tag> & rhs) {
operator!=(const typeseq & lhs, const typeseq & rhs) {
return lhs.seqno() != rhs.seqno();
}
template <typename Tag>
inline std::ostream &
operator<<(std::ostream & s, const typeseq_impl<Tag> & x) {
operator<<(std::ostream & s, const typeseq & x) {
s << x.seqno();
return s;
}
using typeseq = typeseq_impl<>;
} /*namespace reflect*/
} /*namespace xo*/