diff --git a/CHANGELOG.md b/CHANGELOG.md index 9d7ec3d..5e4ffa0 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -17,9 +17,8 @@ under *Changed* or *Removed*. The `Unreleased` block accumulates entries during development and is rolled into a dated version block (`## [X.Y.Z] — YYYY-MM-DD`) when a release PR closes a milestone. -These entries are being assembled for **`v1.0.0`** (Milestone 7); the summary headline -below is the draft `v1.0.0` entry headline, finalized and dated by the release PR -(ROADMAP §7.7). + +## [1.0.0] — 2026-06-14 **Milestone 7 — Release & Polish (`v1.0.0`).** The first **stable** release: the public C ABI (`memory_pool_create` / `_alloc` / `_free` / `_destroy` plus the O(1) @@ -34,7 +33,7 @@ published Doxygen API-reference site (M7.1), the expanded usage / performance / compatibility README (M7.2), the install / packaging layout (M7.4), and the patterns-catalogue (M7.5) and spec-compliance (M7.6) acceptance audits. The row-by-row Spec Coverage Map acceptance is recorded in M7.6; no spec row regresses. -Full release notes will live in `docs/releases/v1.0.0.md` (M7.7). +Full release notes in [`docs/releases/v1.0.0.md`](docs/releases/v1.0.0.md). ### Added (M7.1) @@ -864,7 +863,8 @@ Milestone 2 → `v0.2.0`. Full release notes in --- -[Unreleased]: https://github.com/danielPoloWork/pbr-cpp-memory-pool/compare/v0.6.0...HEAD +[Unreleased]: https://github.com/danielPoloWork/pbr-cpp-memory-pool/compare/v1.0.0...HEAD +[1.0.0]: https://github.com/danielPoloWork/pbr-cpp-memory-pool/releases/tag/v1.0.0 [0.6.0]: https://github.com/danielPoloWork/pbr-cpp-memory-pool/releases/tag/v0.6.0 [0.5.0]: https://github.com/danielPoloWork/pbr-cpp-memory-pool/releases/tag/v0.5.0 [0.4.0]: https://github.com/danielPoloWork/pbr-cpp-memory-pool/releases/tag/v0.4.0 diff --git a/README.md b/README.md index 1726cc4..e20f2f3 100644 --- a/README.md +++ b/README.md @@ -5,7 +5,7 @@ [![docs-site](https://github.com/danielPoloWork/pbr-cpp-memory-pool/actions/workflows/docs-site.yml/badge.svg)](https://github.com/danielPoloWork/pbr-cpp-memory-pool/actions/workflows/docs-site.yml) [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE) [![Standard: C++17 / ANSI C](https://img.shields.io/badge/Standard-C%2B%2B17%20%2F%20ANSI%20C-blue.svg)](docs/specs/01_spec_cpp_memory_pool.md) -[![Status: v0.6.0 observability](https://img.shields.io/badge/Status-v0.6.0%20observability-green.svg)](https://github.com/danielPoloWork/pbr-cpp-memory-pool/releases/tag/v0.6.0) +[![Status: v1.0.0 stable](https://img.shields.io/badge/Status-v1.0.0%20stable-brightgreen.svg)](https://github.com/danielPoloWork/pbr-cpp-memory-pool/releases/tag/v1.0.0) > Part of the **Purpose-Built References (PBR)** series — small, didactic, production-quality C/C++ reference implementations of high-performance building blocks. @@ -191,7 +191,7 @@ Reports for other host × compiler combinations (Linux / GCC, Linux / Clang, mac ## Status -`v0.6.0` — observability & decorators. Optional statistics, on-demand logging, and lifecycle-event notification, all **opt-in by type** — a program that uses `Pool` directly is byte-identical to v0.5.0 and pays nothing. The header-only `InstrumentedPool` **Decorator** composes a `Pool` and counts allocation activity (allocations / deallocations / failures / live + the `peak_live_` high-water mark) via relaxed atomics, exposed as a `PoolStats` snapshot plus `write_summary`; a runtime **Observer** (`PoolObserver` via `add_observer`) delivers `exhausted` / `grew` / `destroyed` events from the same interception points. The one library-side addition is a `grow_count_` atomic on `struct memory_pool` (bumped only on the growth slow path) behind the O(1) `memory_pool_growths` accessor, within the ADR-0015 192-byte budget. The new `zero_overhead` test verifies the zero-cost-when-disabled contract structurally. Two new ADRs (0025–0026) bring the total to 26; **Decorator** and **Observer** flip to Implemented. Release notes for `v0.6.0` live in [`docs/releases/v0.6.0.md`](docs/releases/v0.6.0.md). +`v1.0.0` — **the first stable release.** The public C ABI (`memory_pool_create` / `_alloc` / `_free` / `_destroy` plus the O(1) introspection accessors) and the C++ surface (`Pool`, `TypedPool`, `PoolAllocator`, `InstrumentedPool`, `PoolObserver`) are frozen under the SemVer 1.0 promise — no breaking change without a `2.0.0`. `v1.0.0` seals the feature set built across Milestones 0–6 — the O(1) implicit-free-list fixed-block pool with zero per-block metadata, the RAII / typed / STL-allocator C++ wrappers, compile-time-configurable thread safety, optional geometric dynamic growth, and opt-in observability — and adds the Milestone 7 polish: the published Doxygen API site (M7.1), the expanded usage / performance / compatibility README (M7.2), `find_package` install + pkg-config packaging (M7.4), and the patterns-catalogue (M7.5) and specification-compliance (M7.6, [ADR-0029](docs/adr/0029-spec-compliance-acceptance-audit.md)) acceptance audits. All fifteen Spec Coverage Map rows are ✅, re-verified end-to-end. Twenty-nine ADRs (0001–0029) record every decision; all eleven adopted design patterns are Implemented. Release notes for `v1.0.0` live in [`docs/releases/v1.0.0.md`](docs/releases/v1.0.0.md). | Milestone | Title | Status | |-----------|------------------------------------|-------------| @@ -202,8 +202,8 @@ Reports for other host × compiler combinations (Linux / GCC, Linux / Clang, mac | 4 | Thread-Safe Variant | ✅ complete | | 5 | Dynamic Growth Mode | ✅ complete | | 6 | Observability & Decorators | ✅ complete | -| 7 | Release & Polish | ⏳ next | -| 8 | i18n & Post-Release Governance | ⏳ planned | +| 7 | Release & Polish | ✅ complete | +| 8 | i18n & Post-Release Governance | ⏳ next | See [`ROADMAP.md`](ROADMAP.md) for the per-task breakdown and the Spec Coverage Map at the bottom (traceability from spec sections to roadmap items). diff --git a/ROADMAP.md b/ROADMAP.md index 4078118..f7ec19e 100644 --- a/ROADMAP.md +++ b/ROADMAP.md @@ -114,7 +114,7 @@ Goal: ship a v1.0.0 reference implementation. - [x] 7.4 ADR: install / packaging layout (public-header export, pkg-config, CMake `find_package` config file) — phase 1 distribution per ADR-0004 §5. Implemented as [ADR-0028](docs/adr/0028-install-and-packaging-layout.md) plus the CMake install/export machinery: a `PBR_MEMORY_POOL_INSTALL` option (default `PROJECT_IS_TOP_LEVEL`, so an embedding parent's `cmake --install` is not polluted) gates `install(TARGETS … EXPORT)` + `install(EXPORT … NAMESPACE pbr::)`, the full `it/d4np/memorypool/` public-header tree, a relocatable package config via `configure_package_config_file` with a `SameMajorVersion` version file, a pkg-config [`pbr-memory-pool.pc`](cmake/pbr-memory-pool.pc.in), and `LICENSE` under `share/doc/`. The internal target `pbr_memory_pool` carries `EXPORT_NAME memory_pool` so the **installed** imported target is `pbr::memory_pool` — identical to the in-build alias, so `target_link_libraries(app pbr::memory_pool)` is the one link line for `add_subdirectory` / `FetchContent` **and** installed-package consumers. [`release.yml`](.github/workflows/release.yml)'s `build-artifacts` job now packages via `cmake --install` (full headers + archive + config + `.pc`) instead of hand-copying — fixing a latent bug where four of the seven public headers and the package config were missing from release tarballs (the ADR-0004 §5 "install the artifacts from a Release" path). Verified end-to-end locally (MSVC 19.51 + Ninja): configure → build → `cmake --install` to a staging prefix, then a separate consumer project did `find_package(pbr_memory_pool CONFIG REQUIRED)` + linked `pbr::memory_pool` and ran (`consumer OK: got=7 block_size=64`); the exported target resolves to `pbr::memory_pool` and the `.pc` carries the correct prefix/libdir/version. Phase 2 (vcpkg / Conan) stays deferred post-v1.0 (items 7.8 / 7.9). pkg-config `.pc` `prefix=` reflects the configure-time prefix (documented limitation, ADR-0028 §6). - [x] 7.5 Patterns catalogue audit — verify every adopted pattern has both an ADR and a code location; refresh statuses. All **eleven** adopted patterns in [`docs/patterns/README.md`](docs/patterns/README.md) (RAII, Pimpl, Factory Method, Builder, Adapter, Iterator, Strategy, Template Method, Composite, Decorator, Observer) were audited and confirmed to have (a) an `Accepted` ADR — 0010, 0011, 0018, 0019, 0020, 0021, 0023, 0025, 0026 — and (b) a live code location whose named symbol exists in `src/main/cpp/it/d4np/memorypool/` (verified by grep: `class Pool` / `PoolBuilder` / `PoolAllocator` / `FreeListIterator` / `FreeListView` / `InstrumentedPool`, `struct PoolObserver` / `Chunk`, `SingleThreadedPolicy` / `MutexPolicy` / `LockFreePolicy`, `alloc_skeleton` / `free_skeleton`, the `memory_pool_debug_*` / `memory_pool_growths` accessors). Every status is correctly `Implemented`; no status changed. The audit refreshed **forward-looking phrasing that diverged from the realized design**: the Factory Method row no longer claims M4 thread-safety would be Factory-dispatched (it became the compile-time **Strategy** #7); the Builder row records that growth landed via `.with_growth_factor()` while thread safety is a compile-time knob (not a builder method); the Composite row drops the stale "dormant until M5.3" note (dynamic growth now populates `overflow_`); and the RAII row drops M2-era scaffolding phrasing. A dated audit-provenance note was added to the catalogue, and Object Pool is explicitly recorded as the project premise (spec-fixed, tracked under *Candidate patterns*) rather than a discretionary Adopted row. Documentation-only — no code, ADR, or spec change. - [x] 7.6 **Spec compliance acceptance** — walk every row of the Spec Coverage Map (below) and confirm each requirement is satisfied by a passing test, a documented ADR, or both. Record the audit outcome in an ADR. Done as [ADR-0029](docs/adr/0029-spec-compliance-acceptance-audit.md): every one of the fifteen Spec Coverage Map rows was re-verified end-to-end against live evidence — ten CTest targets (95 doctest cases across `pool_smoke`/`typed_pool`/`pool_allocator`/`free_list_iterator`/`container_integration`/`concurrency_stress`/`dynamic_growth`/`instrumented_pool`/`zero_overhead` + the `spec_6_2_valgrind` C program), the `c_consumer_min.c` ANSI-C consumer, and the `ci.yml` jobs (`build` incl. ASan/UBSan, `ansi-c-compat` C89/C99, `zero-external-deps`, `valgrind`, `thread-safety`, `tsan`, `bench-smoke`, `bench-policy-smoke`) — each cross-referenced to its satisfying ADR. **Verdict: no gap, regression, or unsupported ✅ mark; the implementation satisfies every normative spec clause and the project is acceptance-ready for `v1.0.0`.** No coverage cell changes state (all fifteen remain ✅); deferred items (double-free detection, per-thread caches, lock-free dynamic growth, shrink-on-idle) correspond to no spec clause and are out of acceptance scope. Documentation-only — no code or spec change. -- [ ] 7.7 **Close Milestone 7 → `v1.0.0`**: bump `version.hpp`, roll `CHANGELOG.md`, draft `docs/releases/v1.0.0.md`, open the release PR for the maintainer to tag and publish (ADR-0004 §2). +- [x] 7.7 **Close Milestone 7 → `v1.0.0`**: bump `version.hpp`, roll `CHANGELOG.md`, draft `docs/releases/v1.0.0.md`, open the release PR for the maintainer to tag and publish (ADR-0004 §2). [`version.hpp`](src/main/cpp/it/d4np/memorypool/version.hpp) is bumped to `MAJOR=1 MINOR=0 PATCH=0` and `PBR_MEMORY_POOL_VERSION_STRING` to `"1.0.0"`; the `pool_smoke` version-check `TEST_CASE` asserts the new components. [`CHANGELOG.md`](CHANGELOG.md) `[Unreleased]` is rolled into a sealed `## [1.0.0] — 2026-06-14` block (the M7.3 v1.0.0 headline, finalized, + the M7.1–M7.6 subsections), the meta-paragraph restored to a fresh empty `[Unreleased]`, and the bottom-of-file link references rewritten (`[Unreleased]` → `compare/v1.0.0...HEAD`, new `[1.0.0]` → `releases/tag/v1.0.0`). [`docs/releases/v1.0.0.md`](docs/releases/v1.0.0.md) carries the human-prose release notes for `release.yml`. [`README.md`](README.md) status badge (green `v0.6.0 observability` → bright-green `v1.0.0 stable`), status paragraph, and milestone table (Milestone 7 `⏳ next` → `✅ complete`, Milestone 8 `⏳ planned` → `⏳ next`) are refreshed. The maintainer reviews and merges this PR, then the agent tags `v1.0.0` from `master` per [ADR-0008](docs/adr/0008-delegate-tag-creation-and-push-to-the-agent.md), and the maintainer clicks *Publish* on the draft GitHub Release produced by `release.yml`. - [ ] 7.8 *(Stretch, post-v1.0)* vcpkg port: register `pbr-memory-pool` in microsoft/vcpkg, with portfile pinning to the v1.0.0 tag — phase 2 distribution per ADR-0004 §5. - [ ] 7.9 *(Stretch, post-v1.0)* Conan recipe: publish a `conanfile.py` to ConanCenter or a self-hosted recipe index, with the same v1.0.0 pin — phase 2 distribution per ADR-0004 §5. @@ -167,6 +167,16 @@ When a roadmap item flips from ⏳ to ✅, update the corresponding cell(s) in t > Living, dated note describing where the project stands at the end of the most recent work session. Updated at the close of each session so the next session resumes from a known point without re-reading the full PR history. Latest entry first; older entries are kept for trail. +### 2026-06-14 — End of M7 release session (v1.0.0 — the stable release) + +- **Done in this session** — the whole of Milestone 7: 7.1 (ADR-0027 Doxygen API site → GitHub Pages, PR #53), 7.2 (full usage / performance / compatibility README, PR #55), 7.3 (CHANGELOG audit + draft v1.0.0 headline, PR #56), 7.4 (ADR-0028 install/export + pkg-config `find_package`, PR #57), 7.5 (patterns-catalogue audit, PR #58), 7.6 (ADR-0029 spec-compliance acceptance audit, PR #59), and 7.7 (this release PR — bump to `1.0.0`, roll `CHANGELOG.md` into `[1.0.0] — 2026-06-14`, add `docs/releases/v1.0.0.md`, refresh README). +- **Library state on `master`** — the v0.6.0 surface, now **frozen as the stable v1.0.0 API**. No code behaviour changed in M7 (it is a docs/packaging/audit milestone); the only source change this session is the version bump in `version.hpp` + the `pool_smoke` version assertions. The CMake build gained install/export rules (ADR-0028): `find_package(pbr_memory_pool CONFIG REQUIRED)` + `pbr::memory_pool`, a relocatable package config, and a pkg-config `.pc`; `release.yml` now packages via `cmake --install`. A `docs-site.yml` workflow publishes the Doxygen API reference to GitHub Pages (Pages is enabled). CTest still registers ten binaries. +- **ADRs accepted to date** — 0001–0026 (see prior checkpoints) plus 0027 (Doxygen site pipeline), 0028 (install/packaging layout), 0029 (spec-compliance acceptance audit). Total: **29**. +- **Patterns catalogue** — all eleven adopted patterns (RAII, Pimpl, Factory Method, Builder, Adapter, Iterator, Strategy, Template Method, Composite, Decorator, Observer) Implemented and audited (M7.5). +- **Spec Coverage Map state at `v1.0.0`** — all **fifteen** rows ✅, re-verified end-to-end and accepted in ADR-0029 (M7.6). No gap, regression, or unsupported mark. +- **Open issues / follow-ups carried into the next session** — none blocking. Deferred (documented, no spec clause): double-free detection, per-thread caches, lock-free dynamic growth, shrink-on-idle, and Phase-2 packaging (vcpkg/Conan, ROADMAP §7.8–§7.9). After this release PR merges, the agent tags `v1.0.0` from `master` (ADR-0008) and the maintainer clicks *Publish* on the draft GitHub Release. +- **Resume the next session with** — Milestone 8 (Internationalization & Post-Release Governance, targeting `v1.1.0`): 8.1 (ADR — docs i18n architecture), then 8.2 (scaffold the i18n skeleton), 8.3/8.4 (zh-Hans / ja translations), 8.5 (maintenance protocol), 8.6 (agent-runnable consistency lint), 8.7 (wire the lint into the agent contract), 8.8 (close M8 → `v1.1.0`). + ### 2026-06-14 — End of M6 release session (v0.6.0) - **Done in this session** — the whole of Milestone 6: 6.1 (ADR-0025 `InstrumentedPool` Decorator, PR #47), 6.2 (ADR-0026 Observer for pool-lifecycle events + `memory_pool_growths` accessor + `grow_count_`, PR #48), 6.3 (the `zero_overhead` zero-overhead-when-disabled verification test, PR #49), and 6.4 (this release PR — bump to `0.6.0`, roll `CHANGELOG.md` into `[0.6.0] — 2026-06-14`, add `docs/releases/v0.6.0.md`, refresh README). diff --git a/docs/releases/v1.0.0.md b/docs/releases/v1.0.0.md new file mode 100644 index 0000000..dcd36a6 --- /dev/null +++ b/docs/releases/v1.0.0.md @@ -0,0 +1,95 @@ +# pbr-cpp-memory-pool v1.0.0 — the first stable release + +`v1.0.0` is the **stable reference release** of `pbr-cpp-memory-pool`. The public C ABI and the C++ surface are now **frozen under the SemVer 1.0 promise** — no breaking change without a `2.0.0`. Milestone 7 added the release polish (published API docs, an expanded README, installable packaging, and the compliance audits) on top of the feature set delivered across Milestones 0–6. + +## What the library is + +A fixed-block-size memory pool with **constant-time O(1) allocation and deallocation** and **zero external fragmentation**, built on an **implicit free list** (free blocks store the next-free pointer in their own storage, so live blocks carry zero per-block metadata — spec §4). It is **C++17 internally with an ANSI C (C89-compatible) public surface** and **no external dependencies** (spec §3.3). + +### The public C API (spec §5) + +```c +typedef struct memory_pool memory_pool_t; + +memory_pool_t* memory_pool_create(size_t block_size, size_t block_count); +void* memory_pool_alloc(memory_pool_t* pool); +void memory_pool_free(memory_pool_t* pool, void* block); +void memory_pool_destroy(memory_pool_t* pool); +``` + +### The C++ surface + +- **`Pool`** — move-only RAII owner (ctor → create, dtor → destroy), with the dual-verb exception policy (`allocate` throws `std::bad_alloc`, `try_allocate` is `noexcept`), the `Pool::make` Factory Method, and the fluent `PoolBuilder`. +- **`TypedPool`** — compile-time-correct `block_size` for `T`, with `construct` / `destroy` object-lifetime verbs. +- **`PoolAllocator`** — a *Cpp17Allocator* Adapter so `std::list` / `std::map` / `std::set` and custom containers draw nodes from the pool. +- **`InstrumentedPool` + `PoolObserver`** — opt-in Decorator (counters, occupancy, on-demand logging) and runtime Observer (lifecycle events), zero cost to an undecorated `Pool`. +- **`FreeListView`** — a read-only diagnostic Iterator over the free list, compiled out of release builds unless explicitly enabled. + +### Capabilities delivered across Milestones 0–6 + +- **O(1) alloc/free** on the implicit free list; `NULL` (C) / `std::bad_alloc` (C++) on exhaustion (spec §2.1–§2.3). +- **Optional, macro-configurable thread safety** — `NONE` (default, single-thread fast path preserved), `MUTEX`, or `LOCKFREE` (ABA-tagged Treiber stack), a compile-time Strategy so the single-threaded build pays nothing (spec §2.4). +- **Optional dynamic growth** — geometric overflow chunks acquired on exhaustion (Composite chunk list), opt-in per pool (spec §2.2). +- **Minimal overhead** — 0 bytes per block, ≤ 192 bytes per pool, CI-gated (spec §3.2). +- **Leak-free** — `destroy` returns every byte to the OS, Valgrind-gated (spec §3.1). + +## Milestone 7 — what `v1.0.0` adds on top + +- **M7.1 — Doxygen API-reference site** ([ADR-0027](../adr/0027-doxygen-html-site-and-publication-pipeline.md)): the public-header contract is built warn-as-error on every PR and published to GitHub Pages on `master`. +- **M7.2 — README for the v1.0 audience**: a full **Usage** section (six compilable examples), a consolidated **Performance** summary, and a **Compatibility** matrix. +- **M7.4 — Install / packaging, Phase 1** ([ADR-0028](../adr/0028-install-and-packaging-layout.md)): `find_package(pbr_memory_pool CONFIG REQUIRED)` + `target_link_libraries(app pbr::memory_pool)`, a relocatable package config, and a pkg-config `.pc`. Release tarballs are now complete `find_package`-ready install trees. +- **M7.3 / M7.5 / M7.6 — audits**: the CHANGELOG v1.0.0 audit, the patterns-catalogue audit (all eleven adopted patterns have an ADR + a live code location), and the **specification-compliance acceptance audit** ([ADR-0029](../adr/0029-spec-compliance-acceptance-audit.md)). + +## Stability promise + +From `v1.0.0` the public C ABI (`memory_pool_*`, including the O(1) introspection accessors) and the C++ surface (`Pool`, `TypedPool`, `PoolAllocator`, `InstrumentedPool`, `PoolObserver`) are stable. Source-incompatible changes will only land in a future `2.0.0`; `1.x` releases are additive or fix-only. The CMake package config advertises `SameMajorVersion` compatibility accordingly. + +## Spec Coverage Map — accepted + +All **fifteen** Spec Coverage Map rows are ✅, re-verified end-to-end in the M7.6 acceptance audit ([ADR-0029](../adr/0029-spec-compliance-acceptance-audit.md)) against ten CTest targets (95 doctest cases + the `spec_6_2_valgrind` C program), the `c_consumer_min.c` ANSI-C consumer, and the CI build / sanitizer / Valgrind / thread-safety / TSan / benchmark / C89-C99 / zero-dependency jobs. **No gap, regression, or unsupported mark.** + +## Architecture Decision Records + +Twenty-nine ADRs (0001–0029) record every architectural decision — the free-list layout, the C/C++ boundary and exception policy, the eleven design patterns, the thread-safety and dynamic-growth strategies, the metadata budget, the documentation and packaging pipelines, and the v1.0 acceptance audit. Index: [`docs/adr/README.md`](../adr/README.md). + +## Performance + +Versus `malloc`/`free` on the maintainer's Skylake × MSVC × x64 reference host: a pre-sized fixed pool is **4–11× faster** single-threaded, a *growing* pool stays **~2× faster** amortized, and under contention `LOCKFREE` beats `MUTEX`. Full reports under [`docs/bench/`](../bench/); methodology in [ADR-0014](../adr/0014-microbenchmark-methodology-pool-vs-malloc.md). + +## What this release does **not** contain (deferred, by design) + +- **Double-free detection** (deferred from M2 / [ADR-0012](../adr/0012-foreign-pointer-and-out-of-range-pointer-policy.md)). +- **Per-thread caches** ([ADR-0020](../adr/0020-thread-safety-strategy-and-compile-time-knob.md) §4) and **lock-free dynamic growth** ([ADR-0024](../adr/0024-dynamic-growth-synchronization-and-creation-surface.md) §2). +- **Pool shrink-on-idle** ([ADR-0022](../adr/0022-dynamic-growth-policy-and-chunk-linking.md)). +- **vcpkg / Conan packaging** — Phase 2 distribution, post-1.0 (ROADMAP §7.8–§7.9). + +None corresponds to a spec clause, so none affects the v1.0 acceptance. + +## Install and use + +```bash +cmake -S . -B build -DCMAKE_BUILD_TYPE=Release -DPBR_MEMORY_POOL_BUILD_TESTS=OFF +cmake --build build +cmake --install build --prefix /your/prefix +``` + +```cmake +find_package(pbr_memory_pool CONFIG REQUIRED) +target_link_libraries(my_app PRIVATE pbr::memory_pool) +``` + +## Verifying the release + +Each platform tarball produced by `release.yml` is a complete `cmake --install` tree — the full public-header set, the static archive, the CMake package config, and the pkg-config `.pc` — plus top-level `LICENSE` / `README.md` / `CHANGELOG.md`. SHA-256 checksums are in `SHA256SUMS`: + +```bash +sha256sum --check SHA256SUMS +``` + +## Links + +- Changelog entry: [`CHANGELOG.md` — `[1.0.0]`](../../CHANGELOG.md#100--2026-06-14) +- Milestone plan: [`ROADMAP.md` — Milestone 7](../../ROADMAP.md#milestone-7--release--polish) +- Specification: [`docs/specs/01_spec_cpp_memory_pool.md`](../specs/01_spec_cpp_memory_pool.md) +- Acceptance audit: [ADR-0029](../adr/0029-spec-compliance-acceptance-audit.md) +- Previous release: [`docs/releases/v0.6.0.md`](v0.6.0.md) diff --git a/src/main/cpp/it/d4np/memorypool/version.hpp b/src/main/cpp/it/d4np/memorypool/version.hpp index 6dc13ba..86034fd 100644 --- a/src/main/cpp/it/d4np/memorypool/version.hpp +++ b/src/main/cpp/it/d4np/memorypool/version.hpp @@ -17,16 +17,16 @@ namespace it::d4np::memorypool { /** Major version component (incremented for breaking changes post-1.0). */ -inline constexpr unsigned PBR_MEMORY_POOL_VERSION_MAJOR = 0; +inline constexpr unsigned PBR_MEMORY_POOL_VERSION_MAJOR = 1; /** Minor version component (incremented with each closed milestone pre-1.0). */ -inline constexpr unsigned PBR_MEMORY_POOL_VERSION_MINOR = 6; +inline constexpr unsigned PBR_MEMORY_POOL_VERSION_MINOR = 0; /** Patch version component (incremented for hotfixes between milestones). */ inline constexpr unsigned PBR_MEMORY_POOL_VERSION_PATCH = 0; /** Pre-formatted version string, kept in lockstep with the components above. */ -inline constexpr const char* PBR_MEMORY_POOL_VERSION_STRING = "0.6.0"; +inline constexpr const char* PBR_MEMORY_POOL_VERSION_STRING = "1.0.0"; } // namespace it::d4np::memorypool diff --git a/src/test/cpp/it/d4np/memorypool/pool_smoke_test.cpp b/src/test/cpp/it/d4np/memorypool/pool_smoke_test.cpp index de8ca2d..e31341a 100644 --- a/src/test/cpp/it/d4np/memorypool/pool_smoke_test.cpp +++ b/src/test/cpp/it/d4np/memorypool/pool_smoke_test.cpp @@ -56,11 +56,11 @@ TEST_CASE("version constants are consistent with the project version") { const std::string_view ver{mem::PBR_MEMORY_POOL_VERSION_STRING}; CHECK(ver.find('.') != std::string_view::npos); - // Milestone 6 closes at v0.6.0; these constants are bumped from this - // release PR (M6.4) in lockstep with version.hpp. Milestone 7 will - // bump them again to 1.0.0 when M7.7 lands. - CHECK(mem::PBR_MEMORY_POOL_VERSION_MAJOR == 0U); - CHECK(mem::PBR_MEMORY_POOL_VERSION_MINOR == 6U); + // Milestone 7 closes at v1.0.0 — the first stable release; these constants + // are bumped from this release PR (M7.7) in lockstep with version.hpp. The + // public C ABI and C++ surface are frozen here under the SemVer 1.0 promise. + CHECK(mem::PBR_MEMORY_POOL_VERSION_MAJOR == 1U); + CHECK(mem::PBR_MEMORY_POOL_VERSION_MINOR == 0U); CHECK(mem::PBR_MEMORY_POOL_VERSION_PATCH == 0U); }