Да, давай разберём это как инженерно, а не “подлатать симптомы”.

По коду видно, что у тебя IntervalND сейчас живёт в bump/slab allocator с такой моделью:

• operator new:
  • берёт память из thread-local slab, если влезает;
  • иначе уходит в _aligned_malloc.
• operator delete:
  • если указатель вне диапазона текущего TLS-slab, вызывает _aligned_free;
  • если внутри slab, ничего не делает.

Это допустимая схема, но только если строго соблюдены 3 инварианта:

1. объект, выданный из slab, никогда не освобождается поштучно;
2. slab не reset()-ится, пока жив хотя бы один объект из него;
3. delete всегда проверяет принадлежность указателя тому slab, из которого он реально был выделен, а не “какому-то текущему локальному”.

И вот именно здесь у тебя архитектурная слабость.

---

Что в текущем коде принципиально опасно

1. operator delete смотрит только в tls.local()

Вот это место:

cpp
static __declspec(noalias) __forceinline void operator delete(void* p) noexcept {
	if (!p) return;
	Slab* s = tls.local();
	const char* pc = static_cast<const char*>(p);
	if (pc < s->base || pc >= s->end) {
		_aligned_free(p);
	}
}

Логика тут такая: “если указатель не из моего текущего slab, значит он heap/fallback, освобожу _aligned_free”.

Это неэквивалентно “если указатель не из slab вообще”.

Почему это опасно

Если объект был выделен:

• в другом TLS slab;
• в другом worker/thread context;
• в предыдущем жизненном цикле slab;
• или просто tls.local() в момент delete вернул другой slab instance,

то указатель:

• не принадлежит текущему s,
• но при этом может принадлежать какому-то другому slab.

И тогда код ошибочно делает:

cpp
_aligned_free(p);

на память, которая вообще не была выделена через _aligned_malloc для этого объекта.

Это уже прямой корень heap/slab corruption.

Даже если в логах один TID=8040, это ещё не гарантирует, что tls.local() всегда указывает на тот же slab-экземпляр, из которого объект был получен. Для enumerable_thread_specific это обычно так в пределах потока, но архитектурно код всё равно хрупкий: delete определяет происхождение объекта по текущему состоянию потока, а не по факту выделения.

---

2. AgpResetIntervalSlabs() может убивать ещё живые объекты

Вот это ещё более критично:

cpp
static __forceinline void AgpResetIntervalSlabs() noexcept {
	for (auto it = tls.begin(); it != tls.end(); ++it) {
		Slab* s = *it;
		if (s != nullptr) s->reset();
	}
}

reset() просто откатывает bump pointer:

cpp
current = base;

То есть вся память slab считается “свободной”, без проверки живых объектов.

Если где-то ещё остались:

• указатели в IntervalHeap,
• указатели в IntervalPtrVec,
• сериализованные/десериализованные IntervalWire -> IntervalND*,
• временные очереди,
• копии контейнеров,
• отложенные задачи,

то после reset() ты получаешь reuse той же памяти поверх живых объектов. А затем:

• старый указатель удаляют;
• новый объект уже занял тот же адрес;
• логгер видит “ALLOC → FREE_IGNORED → странный DUMP”;
• служебные заголовки/канарейки уже не соответствуют ожиданиям.

Это очень хорошо совпадает с тем, что ты описал про STORE_Q и перенос состояний.

---

3. У alloc/free нет явного тега происхождения

Сейчас delete пытается угадать, откуда пришёл p, по диапазону адресов. Это плохой контракт.

У корректного кастомного аллокатора должно быть одно из двух:

• либо у каждого блока есть явный tag/header, где записано происхождение;
• либо память, полученная из slab, вообще никогда не проходит через обычный delete.

Сейчас у тебя ни то ни другое не доведено до железобетона.

---

Самый вероятный корень

Если говорить прямо: корень проблемы не в том, что slab allocator “плохо освобождает”, а в том, что модель владения памятью у IntervalND нестрогая.

Симптомы указывают на смесь из двух проблем:

• IntervalND*, выданные из slab, продолжают жить за пределами ожидаемой “эпохи” slab;
• operator delete принимает решение об освобождении на основании tls.local(), а это ненадёжно как источник истины.

---

Какие пути решения я вижу

Ниже от самого надёжного к наименее инвазивному.

---

Путь 1. Полностью убрать пообъектный delete для slab-объектов

Это лучший архитектурный вариант.

Идея

Сделать IntervalND arena-allocated object:

• все объекты из slab живут до конца фазы/итерации/branch-run;
• потом одним вызовом AgpResetIntervalSlabs() память возвращается целиком;
• никаких delete p для slab-объектов вообще.

Fallback-объекты тоже лучше убрать, либо выделять их из отдельного arena block list.

Что это даёт

• нет вопроса “как понять, slab это или heap”;
• нет риска mismatch alloc/free;
• нет ложных _aligned_free на slab-указателях;
• delete-path для IntervalND вообще исчезает как класс проблем.

Как реализовать

Вариант А:

• запретить delete для IntervalND;
• создавать только через фабрику AgpMakeInterval(...);
• уничтожение делать только через AgpResetIntervalSlabs() в конце эпохи.

Например:

cpp
struct IntervalND final {
    // ...
private:
    static void operator delete(void*) = delete;
    static void operator delete(void*, std::size_t) = delete;
};

И наружу:

cpp
template<class... Args>
static __forceinline IntervalND* AgpMakeInterval(Args&&... args) noexcept {
    void* mem = IntervalArenaAlloc(sizeof(IntervalND), alignof(IntervalND));
    return new (mem) IntervalND(std::forward<Args>(args)...);
}

Когда этот путь подходит

Если IntervalND тривиально разрушаем или деструктор не нужен. По твоему коду это именно так.

---

Путь 2. Оставить delete, но сделать явную маркировку происхождения блока

Это лучший компромисс, если delete нужен.

Идея

Каждому выделению предшествует небольшой header, где пишется:

• magic;
• origin (slab или heap);
• optional: owner slab pointer.

Тогда operator delete не угадывает, а точно знает, что делать.

Схема

cpp
enum class IntervalAllocKind : uint32_t {
    Slab = 0x534C4142, // 'SLAB'
    Heap = 0x48454150  // 'HEAP'
};

struct alignas(16) IntervalAllocHeader {
    uint32_t magic;
    uint32_t kind;
    Slab* owner;
    uint32_t requested_size;
    uint32_t reserved;
};

Выделение

cpp
static void* operator new(size_t sz) noexcept {
    constexpr size_t A = 64;
    const size_t total = (sizeof(IntervalAllocHeader) + sz + (A - 1)) & ~(A - 1);

    Slab* s = tls.local();
    char* raw = nullptr;

    if (s->current + total <= s->end) {
        raw = s->current;
        s->current += total;
        auto* h = reinterpret_cast<IntervalAllocHeader*>(raw);
        h->magic = 0xDEADC0DEu;
        h->kind = static_cast<uint32_t>(IntervalAllocKind::Slab);
        h->owner = s;
        h->requested_size = static_cast<uint32_t>(sz);
        return raw + sizeof(IntervalAllocHeader);
    }

    raw = static_cast<char*>(_aligned_malloc(total, A));
    if (!raw) return nullptr;

    auto* h = reinterpret_cast<IntervalAllocHeader*>(raw);
    h->magic = 0xDEADC0DEu;
    h->kind = static_cast<uint32_t>(IntervalAllocKind::Heap);
    h->owner = nullptr;
    h->requested_size = static_cast<uint32_t>(sz);
    return raw + sizeof(IntervalAllocHeader);
}

Освобождение

cpp
static void operator delete(void* p) noexcept {
    if (!p) return;

    char* raw = static_cast<char*>(p) - sizeof(IntervalAllocHeader);
    auto* h = reinterpret_cast<IntervalAllocHeader*>(raw);

    if (h->magic != 0xDEADC0DEu) {
        __debugbreak(); // или лог fatal
        return;
    }

    if (h->kind == static_cast<uint32_t>(IntervalAllocKind::Heap)) {
        _aligned_free(raw);
        return;
    }

    // slab block: intentionally no-op
}

Плюсы

• delete перестаёт зависеть от tls.local();
• cross-thread free становится безопасным в том смысле, что slab-блок не будет случайно отдан в _aligned_free;
• логирование станет точным.

Минусы

• sizeof(IntervalND)==64 сломается, если ты хочешь header “рядом” с объектом и прежнюю адресную модель;
• но сам размер объекта не поменяется, поменяется только layout аллокации.

Это, на мой взгляд, наиболее практичное исправление, если ты хочешь минимально трогать остальной код.

---

Путь 3. Держать metadata вне объекта: page map / ownership map

Это более “allocator-grade” путь.

Идея

Не класть header перед объектом, а держать внешний реестр:

• slab pages/ranges;
• fallback allocations set/map;
• optional owner slab.

Тогда delete проверяет реестр, а не tls.local().

Например:

• std::pmr::unordered_set<void*> fallback_ptrs;
• массив slab ranges;
• или битовая карта по страницам.

Почему это хуже для твоей ситуации

Работать будет, но сложнее, и нужно синхронизировать доступ. Для локального класса IntervalND header проще и надёжнее.

---

Путь 4. Сделать slab объектом эпохи и передавать allocator явно

Это самый чистый дизайн, если готов чуть сильнее переписать.

Идея

Вообще убрать глобальный tls из IntervalND, и сделать так:

cpp
struct IntervalArena {
    Slab* slab;
    IntervalND* create(...);
    void reset();
};

И все функции, создающие интервалы, получают IntervalArena&.

Плюсы

• исчезает скрытая глобальная зависимость;
• не надо гадать, какой slab “текущий”;
• можно строго контролировать lifetime.

Минусы

• инвазивный рефакторинг.

---

Что я бы рекомендовал как реальное решение

Рекомендация: сочетание 1 + 2

Самая надёжная стратегия:

Вариант A — если delete не нужен по архитектуре

Сделать IntervalND strictly arena-only:

• запретить обычный delete;
• выделять только из arena/slab;
• fallback через linked list of big blocks внутри arena, а не _aligned_malloc на каждый объект;
• reset только в конце эпохи, когда точно нет живых IntervalND*.

Это почти идеал.

Вариант B — если delete всё-таки нужен

Сделать явный allocation header и добавить полный набор delete-overloads:

cpp
static void operator delete(void*) noexcept;
static void operator delete(void*, std::size_t) noexcept;
static void operator delete(void*, std::align_val_t) noexcept;
static void operator delete(void*, std::size_t, std::align_val_t) noexcept;

Все они должны идти в один и тот же внутренний deallocate(p).

Это убирает риск, что компилятор/CRT в части сценариев уйдёт не туда.

---

Что обязательно нужно исправить даже при минимальном патче

1. Нельзя принимать решение по tls.local() в delete

Вот это надо выкинуть как сам принцип:

cpp
Slab* s = tls.local();
if (pc < s->base || pc >= s->end) {
    _aligned_free(p);
}

Потому что delete должен определять происхождение блока по самому блоку, а не по текущему состоянию потока.

---

2. Нужен debug guard на reset

Перед AgpResetIntervalSlabs() надо уметь ответить: живы ли ещё объекты?

Хотя бы в debug:

• счётчик allocations;
• счётчик live objects;
• поколение slab;
• poison/reset stamping.

Например:

cpp
struct Slab final {
    char* const base;
    char* current;
    char* const end;
    uint32_t generation = 0;
    uint32_t live_count = 0;

    void reset() noexcept {
        ++generation;
        current = base;
        live_count = 0;
    }
};

И при slab allocation:

cpp
++s->live_count;

А при delete slab-object:

cpp
--owner->live_count; // если вообще допускается поштучный delete

И перед reset в debug:

cpp
AGP_ASSERT(s->live_count == 0);

Если у тебя модель “пообъектный delete не нужен”, тогда live_count можно использовать только как детектор утечек эпохи.

---

3. Добавить проверку “указатель из slab, но не на границе чанка”

Очень полезно для ловли испорченных указателей:

cpp
uintptr_t off = static_cast<uintptr_t>(pc - s->base);
AGP_ASSERT((off % 64u) == 0);

Хотя лучше проверять это не через текущий s, а через owner/header.

---

4. Добавить sized delete overload

Даже если кажется, что не нужен — добавь.

cpp
static void operator delete(void* p, std::size_t) noexcept {
    operator delete(p);
}

И аналоги для aligned delete, если хочешь закрыть тему полностью.

---

Какой конкретно дефект я подозреваю сильнее всего по твоему коду

Если выбирать один главный:

Главное подозрение: reset() вызывается, пока старые IntervalND* ещё где-то живут

Потому что твоя модель slab — это “allocate-many, free-all-at-once”. А остальной код по контейнерам с сырыми указателями выглядит так, что у объектов может быть более длинная жизнь, чем одна фаза.

Особенно настораживают:

• IntervalHeap и IntervalPtrVec хранят сырые IntervalND*;
• есть AgpCreateIntervalFromWire, который заново материализует объект из wire;
• есть STORE_Q, про который ты уже упомянул как про копирование состояний;
• удаление отдельных объектов, судя по логам, всё же происходит.

Это очень похоже на смешение двух моделей:

• arena lifetime
• individual ownership

Их одновременно держать на сырых указателях очень опасно.

---

Практический план исправления

Я бы делал так по шагам.

Шаг 1. Немедленный безопасный патч

Убрать зависимость delete от tls.local() и ввести header.

Это быстро даст стабилизацию и позволит точно отличать:

• slab block;
• heap fallback;
• битый указатель.

---

Шаг 2. В debug-сборке включить жёсткие инварианты

Добавить:

• magic в header;
• owner slab pointer;
• generation;
• poison on reset;
• assert на delete after reset.

Например, если slab allocation хранит owner_generation, то при обращении/delete можно ловить use-after-reset.

---

Шаг 3. Привести lifetime к одной модели

Нужно выбрать одно:

либо

IntervalND — short-lived arena objects
и тогда:

• delete не используется,
• reset делается только на барьере эпохи.

либо

IntervalND — individually managed objects
и тогда:

• slab allocator должен поддерживать корректный free,
• free-list, headers, ownership, reclaim.

Но второй вариант для такого объекта обычно не стоит сложности. Для IntervalND лучше arena model.

---

Минимальный рабочий redesign, который я считаю лучшим

Ниже концепция, которая, скорее всего, искоренит проблему.

1. Убрать member operator new/delete из IntervalND

Вообще.

2. Ввести IntervalArena

cpp
struct IntervalArena {
    Slab* slab;

    void* allocate(size_t sz, size_t align = 64) noexcept;
    void reset() noexcept;
};

3. Создание только через фабрику

cpp
template<class... Args>
IntervalND* MakeInterval(IntervalArena& arena, Args&&... args) noexcept {
    void* mem = arena.allocate(sizeof(IntervalND), 64);
    return new (mem) IntervalND(std::forward<Args>(args)...);
}

4. Никаких delete IntervalND*

Совсем.

5. Все контейнеры с IntervalND* очищаются до arena.reset()

И это становится контрактом системы.

Это убирает саму возможность mismatch alloc/free.

---

Если хочешь оставить текущий стиль с new/delete, вот конкретный safe patch

Вот что я бы сделал минимально.

cpp
enum : uint32_t {
    AGP_INTERVAL_MAGIC = 0xA61F4E2Du,
    AGP_KIND_SLAB = 0x534C4142u,
    AGP_KIND_HEAP = 0x48454150u
};

struct alignas(16) IntervalHdr {
    uint32_t magic;
    uint32_t kind;
    Slab* owner;
    uint32_t size;
};

static constexpr size_t AGP_INTERVAL_ALIGN = 64u;

struct IntervalND final {
    // поля...

    static __declspec(noalias) __forceinline void* operator new(size_t sz) noexcept {
        const size_t total =
            (sizeof(IntervalHdr) + sz + (AGP_INTERVAL_ALIGN - 1u)) &
            ~static_cast<size_t>(AGP_INTERVAL_ALIGN - 1u);

        Slab* s = tls.local();
        char* raw = nullptr;

        if (s->current + total <= s->end) {
            raw = s->current;
            s->current += total;

            auto* h = reinterpret_cast<IntervalHdr*>(raw);
            h->magic = AGP_INTERVAL_MAGIC;
            h->kind = AGP_KIND_SLAB;
            h->owner = s;
            h->size = static_cast<uint32_t>(sz);

            return raw + sizeof(IntervalHdr);
        }

        raw = static_cast<char*>(_aligned_malloc(total, AGP_INTERVAL_ALIGN));
        if (!raw) return nullptr;

        auto* h = reinterpret_cast<IntervalHdr*>(raw);
        h->magic = AGP_INTERVAL_MAGIC;
        h->kind = AGP_KIND_HEAP;
        h->owner = nullptr;
        h->size = static_cast<uint32_t>(sz);

        return raw + sizeof(IntervalHdr);
    }

    static __declspec(noalias) __forceinline void operator delete(void* p) noexcept {
        if (!p) return;

        char* raw = static_cast<char*>(p) - sizeof(IntervalHdr);
        auto* h = reinterpret_cast<IntervalHdr*>(raw);

        if (h->magic != AGP_INTERVAL_MAGIC) {
            __debugbreak();
            return;
        }

        if (h->kind == AGP_KIND_HEAP) {
            _aligned_free(raw);
            return;
        }

        // slab allocation: no-op
    }

    static __declspec(noalias) __forceinline void operator delete(void* p, size_t) noexcept {
        operator delete(p);
    }
};

Это уже на порядок безопаснее текущего решения.

---

Резюме в одну фразу

Корень проблемы не в slab как таковом, а в том, что IntervalND сейчас живёт сразу в двух несовместимых моделях управления памятью — arena lifetime и индивидуальный delete — при этом delete пытается определить происхождение блока по tls.local(), что концептуально ненадёжно.

---

Мой совет:

• лучшее решение — перевести IntervalND в чистую arena-модель без delete;
• минимально-инвазивное надёжное решение — добавить allocation header с явным tag/owner и убрать логику на tls.local() из delete;
• параллельно проверить, что AgpResetIntervalSlabs() не вызывается до полной очистки всех контейнеров с IntervalND*.

Я могу следующим сообщением дать тебе уже готовый, аккуратно оформленный патч в стиле твоего файла: либо arena-only redesign, либо минимальный safe-patch с header + all delete overloads.