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

xo-alloc2: + Allocator.alloc_range() with DArena input

Browse source
This commit is contained in:
Roland Conybeare 2025-12-18 18:34:54 -05:00
commit 181ae9f12b
13 changed files with 158 additions and 59 deletions
Download patch file Download diff file Expand all files Collapse all files

2
include/xo/alloc2/alloc/AAllocIterator.hpp
View file

@ -37,4 +37,4 @@ namespace xo {
} /*namespace mm*/
} /*namespace xo*/
/* end AllocIterator.hpp */
/* end AAllocIterator.hpp */

23
include/xo/alloc2/alloc/AAllocator.hpp
View file

@ -7,8 +7,10 @@
#include "AllocError.hpp"
#include "AllocInfo.hpp"
#include "xo/facet/facet_implementation.hpp"
#include "xo/facet/typeseq.hpp"
#include "AllocIterator.hpp"
#include <xo/facet/obj.hpp>
#include <xo/facet/facet_implementation.hpp>
#include <xo/facet/typeseq.hpp>
#include <string>
namespace xo {
@ -32,6 +34,8 @@ namespace xo {
using value_type = std::byte *;
/** object header, if configured **/
using header_type = std::uint64_t;
/** iterator range. These are forward iterators over allocs **/
using range_type = std::pair<obj<AAllocIterator>, obj<AAllocIterator>>;
///@}
/*
@ -85,20 +89,21 @@ namespace xo {
* Non-const @p d because may stash error details
**/
virtual AllocInfo alloc_info(Copaque d, value_type mem) const noexcept = 0;
/** Ideally we want to control allocation for iterator here.
* Awkward to describe to compiler since we don't have vt<AAllocator> yet.
* OTOH iteration over allocs is a niche feature.
* Consider alternatives:
/** Ideally we want to control allocator for iterator here.
* Awkward to supply to compiler since we don't have obj<AAllocator> yet.
* OTOH iteration over allocs is a super-niche feature.
*
* Rejected alternatives:
* - put begin/end in separate interface. e.g. extend AAllocator
* - layer of indirection: begin/end return iterator factory.
* Then allocator can be passed to iterator factory separately.
* Helps because factory can be static
* - abandon allocator support in this case. Instead will need to
* reinstate uvt<AAllocIterator> (unique variant), use heap
* - just pass DArena& for alloc-iterator-allocation
*
* @p mm is allocator for resulting iterator range
**/
//virtual facet::vt<AAllocIterator> begin(Copaque d, DArena & ialloc) const noexcept;
// virtual obj<AAllocIterator> end() const noexcept = 0;
virtual range_type alloc_range(Copaque d, DArena & mm) const noexcept = 0;
/** expand committed space in arena @p d
* to size at least @p z

24
include/xo/alloc2/alloc/AllocIterator.hpp
View file

@ -1,24 +0,0 @@
/** @file AllocIterator.hpp
*
* @author Roland Conybeare, Dec 2025
**/
#pragma once
namespace xo {
namespace mm {
/** @class AllocIterator
* @brief iterator over arena allocations.
*
* Intended for instrumentation/diagnostics.
* Not needed for normal operator
**/
struct AllocIterator {
};
} /*namespace mm*/
} /*namespace xo*/
/* end AllocIterator.hpp */

1
include/xo/alloc2/alloc/IAllocator_Any.hpp
View file

@ -45,6 +45,7 @@ namespace xo {
[[noreturn]] AllocInfo alloc_info(Copaque, value_type) const noexcept override { _fatal(); }
// defn in .cpp - problematic to require compiler know vt<AAllocIterator> defn here
//[[noreturn]] facet::vt<AAllocIterator> begin(Copaque, DArena &) const noexcept override; // { _fatal(); }
[[noreturn]] range_type alloc_range(Copaque, DArena &) const noexcept override { _fatal(); }
// non-const methods
[[noreturn]] bool expand(Opaque, std::size_t) const noexcept override { _fatal(); }

7
include/xo/alloc2/alloc/IAllocator_Xfer.hpp
View file

@ -39,12 +39,13 @@ namespace xo {
return I::contains(_dcast(d), p);
}
AllocError last_error(Copaque d) const noexcept override { return I::last_error(_dcast(d)); }
// non-const methods
AllocInfo alloc_info(Copaque d, value_type mem) const noexcept override {
return I::alloc_info(_dcast(d), mem);
}
range_type alloc_range(Copaque d, DArena & mm) const noexcept override { return I::alloc_range(_dcast(d), mm); }
// non-const methods
bool expand(Opaque d,
std::size_t z) const noexcept override { return I::expand(_dcast(d), z); }
value_type alloc(Opaque d,

8
include/xo/alloc2/arena/DArenaIterator.hpp
View file

@ -59,6 +59,14 @@ namespace xo {
**/
static DArenaIterator end(const DArena * arena);
/** Address of allocation header for beginning of alloc range in @p arena **/
static AllocHeader * begin_header(const DArena * arena);
/** Address of allocation header for end of alloc range.
* This is the address of header for _next_ allocation in @p arena
* i.e. free pointer
**/
static AllocHeader * end_header(const DArena * arena);
/** A valid iterator can be compared, at least with itself
* It can be dereferenced if is also non-empty
**/

23
include/xo/alloc2/arena/IAllocator_DArena.hpp
View file

@ -19,15 +19,20 @@ namespace xo {
}
namespace mm {
/* changes here coordinate with:
* AAllocator AAllocator.hpp
* IAllocator_Any IAllocator_Any.hpp
* IAllocator_Xfer IAllocator_Xfer.hpp
* RAllocator RAllocator.hpp
*/
/** @class IAllocator_DArena
* @brief Provide AAllocator interface for DArena state
**/
struct IAllocator_DArena {
/* changes here coordinate with:
* AAllocator AAllocator.hpp
* IAllocator_Any IAllocator_Any.hpp
* IAllocator_Xfer IAllocator_Xfer.hpp
* RAllocator RAllocator.hpp
*/
using size_type = std::size_t;
using value_type = std::byte *;
using range_type = std::pair<obj<AAllocIterator>,
obj<AAllocIterator>>;
enum class alloc_mode : uint8_t {
standard,
@ -44,9 +49,13 @@ namespace xo {
static size_type allocated(const DArena &) noexcept;
static bool contains(const DArena &, const void * p) noexcept;
static AllocError last_error(const DArena &) noexcept;
/** retrieve allocation bookkeeping info for @p mem from arena @p d **/
static AllocInfo alloc_info(const DArena &, value_type mem) noexcept;
/** create alloc-iterator range over allocs on @d,
* Iterators themselves allocated from @p ialloc.
**/
static range_type alloc_range(const DArena & d, DArena & ialloc) noexcept;
/** expand committed space in arena @p d
* to size at least @p z
* In practice will round up to a multiple of @ref page_z_.

6
include/xo/alloc2/gc/IAllocator_DX1Collector.hpp
View file

@ -31,6 +31,8 @@ namespace xo {
struct IAllocator_DX1Collector {
using size_type = std::size_t;
using value_type = std::byte *;
using range_type = std::pair<obj<AAllocIterator>,
obj<AAllocIterator>>;
// todo: available()
@ -51,6 +53,10 @@ namespace xo {
static AllocError last_error(const DX1Collector &) noexcept;
/** fetch allocation bookkeeping info **/
static AllocInfo alloc_info(const DX1Collector & d, value_type mem) noexcept;
/** create alloc-iterator range over allocs in @d,
* with iterator working storage obtained from @p ialloc
**/
static range_type alloc_range(const DX1Collector & d, DArena & ialloc) noexcept;
/** always alloc in gen0 to-space **/
static value_type alloc(DX1Collector & d, size_type z) noexcept;