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

xo-object2 stack: refactor/tidy after GCObject -> alloc2

Browse source
This commit is contained in:
Roland Conybeare 2026-03-05 20:11:05 +11:00
commit af0be72853
10 changed files with 168 additions and 423 deletions
Download patch file Download diff file Expand all files Collapse all files

16
idl/GCObject.json5
View file

@ -1,24 +1,26 @@
{
mode: "facet",
output_cpp_dir: "src/gc",
output_hpp_dir: "include/xo/gc",
output_impl_subdir: "detail",
output_cpp_dir: "src/alloc2",
output_hpp_dir: "include/xo/alloc2",
output_impl_subdir: "gc",
includes: [
"<xo/alloc2/Allocator.hpp>",
"<xo/gc/Collector.hpp>",
"<xo/alloc2/Collector.hpp>",
"<cstdint>",
"<cstddef>",
],
// extra includes in GCObject.hpp, if any
user_hpp_includes: [],
user_hpp_includes: [
"\"gc/RCollector_aux.hpp\"",
],
namespace1: "xo",
namespace2: "mm",
pretext: [
"namespace xo { namespace mm { class ACollector; }}",
],
facet: "GCObject",
detail_subdir: "detail",
brief: "xxx",
detail_subdir: "gc",
brief: "gc-aware object, providing collector hooks",
using_doxygen: true,
doc: [
"GC hooks for collector-aware data"

26
include/xo/alloc2/GCObject.hpp
View file

@ -18,30 +18,6 @@
#include "gc/IGCObject_Xfer.hpp"
#include "gc/RGCObject.hpp"
namespace xo {
namespace mm {
/** defined here to avoid #include cycle, since
* template obj<AGCObject,DRepr> awkward to make available there
**/
template <typename Object>
template <typename DRepr>
void
RCollector<Object>::forward_inplace(xo::facet::obj<AGCObject,DRepr> * p_obj)
{
this->forward_inplace(p_obj->iface(), (void **)&(p_obj->data_));
}
template <typename Object>
template <typename DRepr>
void
RCollector<Object>::forward_inplace(DRepr ** p_repr)
{
// fetch static interface for DRepr
auto iface = xo::facet::impl_for<AGCObject,DRepr>();
this->forward_inplace(&iface, (void **)p_repr);
}
}
}
#include "gc/RCollector_aux.hpp"
/* end GCObject.hpp */

117
include/xo/alloc2/GCObjectConversion.hpp Normal file
View file

@ -0,0 +1,117 @@
/** @file GCObjectConversion.hpp
*
* @author Roland Conybeare, Jan 2026
**/
#pragma once
#include <xo/alloc2/GCObject.hpp>
#include <xo/alloc2/Allocator.hpp>
#include <xo/facet/FacetRegistry.hpp>
#include <xo/facet/obj.hpp>
#include <xo/indentlog/scope.hpp>
namespace xo {
namespace scm {
/** @brief compile-time conversion obj<AGCObject> <-> T
*
* Specialize for each T that participates in conversion.
* Methods here aren't implemented
**/
template <typename T>
struct GCObjectConversion {
using AGCObject = xo::mm::AGCObject;
using AAllocator = xo::mm::AAllocator;
/** find gc-aware representation for @p x.
* If necessary allocate from @p mm, but may
* refer to @p x in-place
**/
static obj<AGCObject> to_gco(obj<AAllocator> mm, const T & x);
/** convert to native representation @tparam T from gc-aware
* @p gco. If necessary allocate from @p mm, but
* may instead refer to @p x in-place
**/
static T from_gco(obj<AAllocator> mm, obj<AGCObject> gco);
};
/** Motivating use-case for GCObjectConversion is to transform
* primitive function arguments and results to/from gc-aware
* representation.
*
* However: Schematika also supports runtime polymorphism
* which leads to primitives that expect obj<AFacet> arguments.
*
* Also, Schematika expression parser needs representation for
* expressions, before type unification.
*
* Consider a function like:
* def fact = lambda (n : i64) { if (n <= 0) then 1 else (n * fact(n - 1)); }
* During expression parsing the rhs argument to multiply has unknown type.
* To construct an expression for input to unification will use polymorphic
* binding for multiply primitive, relying on specialization here for
* its implementation.
**/
template <typename AFacet, typename DRepr>
struct GCObjectConversion<obj<AFacet,DRepr>> {
using AGCObject = xo::mm::AGCObject;
using AAllocator = xo::mm::AAllocator;
using FacetRegistry = xo::facet::FacetRegistry;
using DVariantPlaceholder = xo::facet::DVariantPlaceholder;
static obj<AGCObject> to_gco(obj<AAllocator>,
obj<AFacet,DRepr> gco) {
if constexpr (std::is_same_v<AFacet, AGCObject>) {
// trivial conversion!
return gco;
} else if constexpr (std::is_same_v<DRepr, DVariantPlaceholder>) {
// runtime polymorphism
return FacetRegistry::instance().variant<AGCObject,AFacet>(gco);
} else /* DRepr != DVariantPlaceholder */ {
// known content w/ fat object pointer
return obj<AGCObject,DRepr>(gco.data());
}
}
static obj<AFacet,DRepr> from_gco(obj<AAllocator>,
obj<AGCObject> gco) {
scope log(XO_DEBUG(false));
if constexpr (std::is_same_v<AFacet, AGCObject>) {
// Need accurate handling of DVariantPlaceholder.
// runtime type must be some concrete type.
// Only use obj<AFacet,DRepr>::from when DRepr is a concrete type
if constexpr (std::is_same_v<DRepr,DVariantPlaceholder>) {
// At comptime gco has unknown repr. At runtime
// will have some known repr, which assignment here will transfer
return gco;
} else {
// Runtime conversion to concrete type DRepr
auto retval = obj<AFacet,DRepr>::from(gco);
if (!retval) {
log.retroactively_enable();
log && log(xtag("gco.tseq", gco._typeseq()));
log && log(xtag("DRepr.tseq", reflect::typeseq::id<DRepr>()));
}
assert(retval);
return retval;
}
} else {
// both runtime and comptime polymorphism
// use same path here, since representation of @p gco
// is type-erased here
return FacetRegistry::instance().variant<AFacet,AGCObject>(gco);
}
}
};
} /*namespace scm */
} /*namespace xo*/
/* end GCObjectConversion.hpp */

2
include/xo/alloc2/gc/AGCObject.hpp
View file

@ -31,7 +31,7 @@ using Copaque = const void *;
using Opaque = void *;
/**
GC hooks for collector-aware data
GC hooks for collector-aware data
**/
class AGCObject {
public:

40
include/xo/alloc2/gc/RCollector_aux.hpp Normal file
View file

@ -0,0 +1,40 @@
/** @file RCollector_aux.hpp
*
* Out-of-line definitions for RCollector template methods
* that depend on RGCObject (avoiding #include cycle in RCollector.hpp).
*
* Included via user_hpp_includes in GCObject.json5.
*
* @author Roland Conybeare
**/
#pragma once
namespace xo {
namespace mm {
/** defined here to avoid #include cycle, since
* template obj<AGCObject,DRepr> awkward to make available
* in RCollector.hpp
**/
template <typename Object>
template <typename DRepr>
void
RCollector<Object>::forward_inplace(xo::facet::obj<AGCObject,DRepr> * p_obj)
{
this->forward_inplace(p_obj->iface(), (void **)&(p_obj->data_));
}
template <typename Object>
template <typename DRepr>
void
RCollector<Object>::forward_inplace(DRepr ** p_repr)
{
// fetch static interface for DRepr
auto iface = xo::facet::impl_for<AGCObject,DRepr>();
this->forward_inplace(&iface, (void **)p_repr);
}
}
}
/* end RCollector_aux.hpp */

22
include/xo/gc/GCObject.hpp
View file

@ -1,22 +0,0 @@
/** @file GCObject.hpp
*
* Generated automagically from ingredients:
* 1. code generator:
* [xo-facet/codegen/genfacet]
* arguments:
* --input [idl/GCObject.json5]
* 2. jinja2 template for facet .hpp file:
* [facet.hpp.j2]
* 3. idl for facet methods
* [idl/GCObject.json5]
**/
#pragma once
#include "detail/AGCObject.hpp"
#include "detail/IGCObject_Any.hpp"
#include "detail/IGCObject_Xfer.hpp"
#include "detail/RGCObject.hpp"
/* end GCObject.hpp */

87
include/xo/gc/detail/AGCObject.hpp
View file

@ -1,87 +0,0 @@
/** @file AGCObject.hpp
*
* Generated automagically from ingredients:
* 1. code generator:
* [xo-facet/codegen/genfacet]
* arguments:
* --input [idl/GCObject.json5]
* 2. jinja2 template for abstract facet .hpp file:
* [abstract_facet.hpp.j2]
* 3. idl for facet methods
* [idl/GCObject.json5]
**/
#pragma once
// includes (via {facet_includes})
#include <xo/alloc2/Allocator.hpp>
#include <xo/gc/Collector.hpp>
#include <cstdint>
#include <cstddef>
#include <xo/facet/obj.hpp>
#include <xo/facet/facet_implementation.hpp>
#include <xo/facet/typeseq.hpp>
namespace xo { namespace mm { class ACollector; }}
namespace xo {
namespace mm {
using Copaque = const void *;
using Opaque = void *;
/**
GC hooks for collector-aware data
**/
class AGCObject {
public:
/** @defgroup mm-gcobject-type-traits **/
///@{
// types
/** integer identifying a type **/
using typeseq = xo::facet::typeseq;
using Copaque = const void *;
using Opaque = void *;
/** type for an amount of memory **/
using size_type = std::size_t;
/** fomo allocator type **/
using AAllocator = xo::mm::AAllocator;
/** fomo collector type **/
using ACollector = xo::mm::ACollector;
///@}
/** @defgroup mm-gcobject-methods **/
///@{
// const methods
/** RTTI: unique id# for actual runtime data representation **/
virtual typeseq _typeseq() const noexcept = 0;
/** destroy instance @p d; calls c++ dtor only for actual runtime type; does not recover memory **/
virtual void _drop(Opaque d) const noexcept = 0;
/** memory consumption for this instance **/
virtual size_type shallow_size(Copaque data) const noexcept = 0;
/** copy instance using allocator **/
virtual Opaque shallow_copy(Copaque data, obj<AAllocator> mm) const noexcept = 0;
// nonconst methods
/** during GC: forward immdiate children **/
virtual size_type forward_children(Opaque data, obj<ACollector> gc) const noexcept = 0;
///@}
}; /*AGCObject*/
/** Implementation IGCObject_DRepr of AGCObject for state DRepr
* should provide a specialization:
*
* template <>
* struct xo::facet::FacetImplementation<AGCObject, DRepr> {
* using Impltype = IGCObject_DRepr;
* };
*
* then IGCObject_ImplType<DRepr> --> IGCObject_DRepr
**/
template <typename DRepr>
using IGCObject_ImplType = xo::facet::FacetImplType<AGCObject, DRepr>;
} /*namespace mm*/
} /*namespace xo*/
/* AGCObject.hpp */

93
include/xo/gc/detail/IGCObject_Any.hpp
View file

@ -1,93 +0,0 @@
/** @file IGCObject_Any.hpp
*
* Generated automagically from ingredients:
* 1. code generator:
* [xo-facet/codegen/genfacet]
* arguments:
* --input [idl/GCObject.json5]
* 2. jinja2 template for abstract facet .hpp file:
* [iface_facet_any.hpp.j2]
* 3. idl for facet methods
* [idl/GCObject.json5]
**/
#pragma once
#include "AGCObject.hpp"
#include <xo/facet/obj.hpp>
namespace xo { namespace mm { class IGCObject_Any; } }
namespace xo {
namespace facet {
template <>
struct FacetImplementation<xo::mm::AGCObject,
DVariantPlaceholder>
{
using ImplType = xo::mm::IGCObject_Any;
};
}
}
namespace xo {
namespace mm {
/** @class IGCObject_Any
* @brief AGCObject implementation for empty variant instance
**/
class IGCObject_Any : public AGCObject {
public:
/** @defgroup mm-gcobject-any-type-traits **/
///@{
/** integer identifying a type **/
using typeseq = xo::facet::typeseq;
using size_type = AGCObject::size_type;
using AAllocator = AGCObject::AAllocator;
using ACollector = AGCObject::ACollector;
///@}
/** @defgroup mm-gcobject-any-methods **/
///@{
const AGCObject * iface() const { return std::launder(this); }
// from AGCObject
// builtin methods
typeseq _typeseq() const noexcept override { return s_typeseq; }
[[noreturn]] void _drop(Opaque) const noexcept override { _fatal(); }
// const methods
[[noreturn]] size_type shallow_size(Copaque) const noexcept override { _fatal(); }
[[noreturn]] Opaque shallow_copy(Copaque, obj<AAllocator>) const noexcept override { _fatal(); }
// nonconst methods
[[noreturn]] size_type forward_children(Opaque, obj<ACollector>) const noexcept override;
///@}
private:
/** @defgraoup mm-gcobject-any-private-methods **/
///@{
[[noreturn]] static void _fatal();
///@}
public:
/** @defgroup mm-gcobject-any-member-vars **/
///@{
static typeseq s_typeseq;
static bool _valid;
///@}
};
} /*namespace mm */
} /*namespace xo */
/* IGCObject_Any.hpp */

95
include/xo/gc/detail/IGCObject_Xfer.hpp
View file

@ -1,95 +0,0 @@
/** @file IGCObject_Xfer.hpp
*
* Generated automagically from ingredients:
* 1. code generator:
* [xo-facet/codegen/genfacet]
* arguments:
* --input [idl/GCObject.json5]
* 2. jinja2 template for abstract facet .hpp file:
* [iface_facet_any.hpp.j2]
* 3. idl for facet methods
* [idl/GCObject.json5]
**/
#pragma once
#include <xo/alloc2/Allocator.hpp>
#include <xo/gc/Collector.hpp>
#include <cstdint>
#include <cstddef>
namespace xo {
namespace mm {
/** @class IGCObject_Xfer
**/
template <typename DRepr, typename IGCObject_DRepr>
class IGCObject_Xfer : public AGCObject {
public:
/** @defgroup mm-gcobject-xfer-type-traits **/
///@{
/** actual implementation (not generated; often delegates to DRepr) **/
using Impl = IGCObject_DRepr;
/** integer identifying a type **/
using typeseq = AGCObject::typeseq;
using size_type = AGCObject::size_type;
using AAllocator = AGCObject::AAllocator;
using ACollector = AGCObject::ACollector;
///@}
/** @defgroup mm-gcobject-xfer-methods **/
///@{
static const DRepr & _dcast(Copaque d) { return *(const DRepr *)d; }
static DRepr & _dcast(Opaque d) { return *(DRepr *)d; }
// from AGCObject
// builtin methods
typeseq _typeseq() const noexcept override { return s_typeseq; }
void _drop(Opaque d) const noexcept override { _dcast(d).~DRepr(); }
// const methods
size_type shallow_size(Copaque data) const noexcept override {
return I::shallow_size(_dcast(data));
}
Opaque shallow_copy(Copaque data, obj<AAllocator> mm) const noexcept override {
return I::shallow_copy(_dcast(data), mm);
}
// non-const methods
size_type forward_children(Opaque data, obj<ACollector> gc) const noexcept override {
return I::forward_children(_dcast(data), gc);
}
///@}
private:
using I = Impl;
public:
/** @defgroup mm-gcobject-xfer-member-vars **/
///@{
/** typeseq for template parameter DRepr **/
static typeseq s_typeseq;
/** true iff satisfies facet implementation **/
static bool _valid;
///@}
};
template <typename DRepr, typename IGCObject_DRepr>
xo::facet::typeseq
IGCObject_Xfer<DRepr, IGCObject_DRepr>::s_typeseq
= xo::facet::typeseq::id<DRepr>();
template <typename DRepr, typename IGCObject_DRepr>
bool
IGCObject_Xfer<DRepr, IGCObject_DRepr>::_valid
= xo::facet::valid_facet_implementation<AGCObject,
IGCObject_Xfer>();
} /*namespace mm */
} /*namespace xo*/
/* end IGCObject_Xfer.hpp */

93
include/xo/gc/detail/RGCObject.hpp
View file

@ -1,93 +0,0 @@
/** @file RGCObject.hpp
*
* Generated automagically from ingredients:
* 1. code generator:
* [xo-facet/codegen/genfacet]
* arguments:
* --input [idl/GCObject.json5]
* 2. jinja2 template for abstract facet .hpp file:
* [iface_facet_any.hpp.j2]
* 3. idl for facet methods
* [idl/GCObject.json5]
**/
#pragma once
#include "AGCObject.hpp"
namespace xo {
namespace mm {
/** @class RGCObject
**/
template <typename Object>
class RGCObject : public Object {
private:
using O = Object;
public:
/** @defgroup mm-gcobject-router-type-traits **/
///@{
using ObjectType = Object;
using DataPtr = Object::DataPtr;
using typeseq = xo::reflect::typeseq;
using size_type = AGCObject::size_type;
using AAllocator = AGCObject::AAllocator;
using ACollector = AGCObject::ACollector;
///@}
/** @defgroup mm-gcobject-router-ctors **/
///@{
RGCObject() {}
RGCObject(Object::DataPtr data) : Object{std::move(data)} {}
RGCObject(const AGCObject * iface, void * data)
requires std::is_same_v<typename Object::DataType, xo::facet::DVariantPlaceholder>
: Object(iface, data) {}
///@}
/** @defgroup mm-gcobject-router-methods **/
///@{
// explicit injected content
// builtin methods
typeseq _typeseq() const noexcept { return O::iface()->_typeseq(); }
void _drop() const noexcept { O::iface()->_drop(O::data()); }
// const methods
size_type shallow_size() const noexcept {
return O::iface()->shallow_size(O::data());
}
Opaque shallow_copy(obj<AAllocator> mm) const noexcept {
return O::iface()->shallow_copy(O::data(), mm);
}
// non-const methods (still const in router!)
size_type forward_children(obj<ACollector> gc) noexcept {
return O::iface()->forward_children(O::data(), gc);
}
///@}
/** @defgroup mm-gcobject-member-vars **/
///@{
static bool _valid;
///@}
};
template <typename Object>
bool
RGCObject<Object>::_valid = xo::facet::valid_object_router<Object>();
} /*namespace mm*/
} /*namespace xo*/
namespace xo { namespace facet {
template <typename Object>
struct RoutingFor<xo::mm::AGCObject, Object> {
using RoutingType = xo::mm::RGCObject<Object>;
};
} }
/* end RGCObject.hpp */