bosdi 0.1.1__tar.gz

bosdi-0.1.1/Cargo.lock

@@ -0,0 +1,91 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "bosdi"
+version = "0.1.0"
+dependencies = [
+ "lazy_static",
+ "libloading",
+ "rayon",
+]
+
+[[package]]
+name = "cfg-if"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
+
+[[package]]
+name = "crossbeam-deque"
+version = "0.8.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9dd111b7b7f7d55b72c0a6ae361660ee5853c9af73f70c3c2ef6858b950e2e51"
+dependencies = [
+ "crossbeam-epoch",
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-epoch"
+version = "0.9.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5b82ac4a3c2ca9c3460964f020e1402edd5753411d7737aa39c3714ad1b5420e"
+dependencies = [
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-utils"
+version = "0.8.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28"
+
+[[package]]
+name = "either"
+version = "1.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "48c757948c5ede0e46177b7add2e67155f70e33c07fea8284df6576da70b3719"
+
+[[package]]
+name = "lazy_static"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
+
+[[package]]
+name = "libloading"
+version = "0.8.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d7c4b02199fee7c5d21a5ae7d8cfa79a6ef5bb2fc834d6e9058e89c825efdc55"
+dependencies = [
+ "cfg-if",
+ "windows-link",
+]
+
+[[package]]
+name = "rayon"
+version = "1.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "368f01d005bf8fd9b1206fb6fa653e6c4a81ceb1466406b81792d87c5677a58f"
+dependencies = [
+ "either",
+ "rayon-core",
+]
+
+[[package]]
+name = "rayon-core"
+version = "1.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "22e18b0f0062d30d4230b2e85ff77fdfe4326feb054b9783a3460d8435c8ab91"
+dependencies = [
+ "crossbeam-deque",
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "windows-link"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"

bosdi-0.1.1/Cargo.toml

@@ -0,0 +1,15 @@
+[package]
+name = "bosdi"
+version = "0.1.0"  # Keep in sync with pyproject.toml [project].version
+edition = "2021"
+description = "Rust core for BOSDI: batched OSDI device model evaluation via libloading + Rayon"
+license = "MIT"
+
+[lib]
+crate-type = ["staticlib"]
+name = "bosdi"
+
+[dependencies]
+lazy_static = "1.4"
+libloading = "0.8"
+rayon = "1.8"

bosdi-0.1.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Chris Daunt
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

bosdi-0.1.1/MANIFEST.in

@@ -0,0 +1,4 @@
+include Cargo.toml
+include Cargo.lock
+recursive-include src *.rs
+recursive-include _nanobind_src *

bosdi-0.1.1/PKG-INFO

@@ -0,0 +1,167 @@
+Metadata-Version: 2.4
+Name: bosdi
+Version: 0.1.1
+Summary: Make OSDI device models (Verilog-A compiled to .osdi) differentiable via JAX
+Author-email: Chris Daunt <chris@gdsfactory.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/gdsfactory/bosdi
+Project-URL: Repository, https://github.com/gdsfactory/bosdi
+Keywords: JAX,OSDI,Verilog-A,automatic differentiation,circuit simulation
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Rust
+Classifier: Topic :: Scientific/Engineering :: Electronic Design Automation (EDA)
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: equinox>=0.11
+Requires-Dist: jax<0.8,>=0.7.0
+Requires-Dist: jaxlib<0.8,>=0.7.0
+Dynamic: license-file
+
+# bosdi — Batched OSDI
+
+![CI](https://github.com/gdsfactory/bosdi/actions/workflows/test.yml/badge.svg)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+![Python 3.13](https://img.shields.io/badge/python-3.13-blue.svg)
+![Platform: Linux | macOS](https://img.shields.io/badge/platform-linux%20%7C%20macOS-lightgrey)
+![Status: Experimental](https://img.shields.io/badge/status-experimental-orange)
+
+> **Experimental** — bosdi is under active development. The OSDI binary evaluation path is stable and well-tested, but
+> the Verilog-A to JAX lowering compiler (`bosdi.va`) is in **alpha** and its API may change without notice. The VA
+> lowering depends on a [custom fork of OpenVAF](https://github.com/cdaunt/OpenVAF) that exposes the compiler's
+> intermediate representation; this fork is not yet merged upstream.
+
+Evaluate [OSDI](https://github.com/OpenVAF/OpenVAF) device models (Verilog-A compiled to `.osdi` binaries) in batched
+parallel via JAX.
+
+## Two evaluation paths
+
+bosdi provides two ways to evaluate Verilog-A compact models inside JAX:
+
+### OSDI binary path (stable)
+
+Loads a pre-compiled `.osdi` binary and evaluates N device instances in parallel via Rayon inside a JAX XLA custom call.
+The OSDI ABI provides analytical Jacobians with respect to **node voltages only** (conductances `dI/dV`, capacitances
+`dQ/dV`). A `@custom_jvp` rule makes `jax.grad()` work through node voltages — but not through model parameters or
+state.
+
+```python
+from osdi_loader import load_osdi_model
+from osdi_jax import osdi_eval
+
+model = load_osdi_model("path/to/device.osdi")
+N = 1024
+voltages = jnp.zeros((N, model.num_nodes), dtype=jnp.float64)
+params = jnp.full((N, model.num_params), jnp.nan, dtype=jnp.float64)
+old_state = jnp.zeros((N, model.num_states), dtype=jnp.float64)
+
+cur, cond, chg, cap, new_state = osdi_eval(model.id, voltages, params, old_state)
+
+# jax.grad works through node voltages
+grad_fn = jax.grad(lambda v: osdi_eval(model.id, v, params, old_state)[0].sum())
+```
+
+### VA to JAX lowering (alpha)
+
+Compiles Verilog-A source directly into pure JAX/Python, producing a function that is **fully differentiable** through
+all inputs — voltages, parameters, and temperature. This enables parameter optimization, sensitivity analysis, and
+end-to-end gradient-based design flows that the OSDI path cannot support.
+
+Requires [openvaf-r](https://github.com/cdaunt/OpenVAF) (a custom OpenVAF fork).
+
+```bash
+python -m bosdi.va device.va
+```
+
+### When to use which
+
+|                           | OSDI binary                                   | VA to JAX                                                                   |
+| ------------------------- | --------------------------------------------- | --------------------------------------------------------------------------- |
+| **Use case**              | Circuit simulation (Newton solve)             | Parameter fitting, sensitivity analysis, inverse design                     |
+| **Differentiable w.r.t.** | Node voltages only                            | Voltages, parameters, and temperature                                       |
+| **Performance**           | Fast — Rayon-parallel C/Rust, batched XLA FFI | Pure Python/JAX — slower per-eval, but composable with `jax.jit`/`jax.vmap` |
+| **Maturity**              | Stable                                        | Alpha                                                                       |
+| **Dependencies**          | None beyond bosdi                             | [openvaf-r](https://github.com/cdaunt/OpenVAF) fork                         |
+
+The OSDI path treats the compiled model as a black box and extracts only what the ABI exposes: currents, charges, and
+their Jacobians w.r.t. node voltages. This is exactly what a Newton solver needs, but the parameter axis is opaque to
+JAX — you cannot backpropagate through it.
+
+The VA to JAX path exists to remove that limitation. By lowering the Verilog-A source into native JAX operations, every
+computation becomes visible to JAX's autodiff, making the model fully differentiable. This is what enables
+gradient-based parameter extraction, design-space exploration, and end-to-end optimization of circuits where device
+parameters are the degrees of freedom.
+
+## Architecture
+
+```
+OSDI path:
+  Python: osdi_eval()  →  JAX XLA custom call
+    →  C++ (nanobind/XLA FFI): unpack buffers
+      →  Rust (Rayon): evaluate N devices in parallel
+        →  OSDI binary: currents, conductances, charges, capacitances
+
+VA path:
+  Verilog-A source  →  openvaf-r (MIR dump)
+    →  bosdi.va lowering + SCCP optimization
+      →  Pure JAX/Python function (fully differentiable)
+```
+
+## Installation
+
+### Using Pixi (recommended)
+
+```bash
+git clone https://github.com/gdsfactory/bosdi && cd bosdi
+pixi run build
+```
+
+### Using pip
+
+```bash
+pip install bosdi
+```
+
+## Build & test
+
+```bash
+pixi run build   # compile Rust static lib + C++ extension
+pixi run test    # run pytest suite
+
+# single test
+pixi run pytest tests/test_osdi.py::test_resistor_dc_evaluation -v
+```
+
+## OSDI outputs
+
+The OSDI path returns per-device arrays shaped by `model.num_nodes` (terminals + internal nodes + branch-current
+auxiliaries):
+
+| Output | Shape             | Description                                  |
+| ------ | ----------------- | -------------------------------------------- |
+| `cur`  | `[N, num_nodes]`  | Resistive current residual at each unknown   |
+| `cond` | `[N, num_nodes²]` | `G = ∂cur/∂V` Jacobian (flattened row-major) |
+| `chg`  | `[N, num_nodes]`  | Charge residual at each unknown              |
+| `cap`  | `[N, num_nodes²]` | `C = ∂chg/∂V` Jacobian (flattened row-major) |
+
+Pass `jnp.nan` for any parameter to use its Verilog-A default. Parameters can be addressed by name via
+`model.param_names`. See `tests/test_bsim4_model_card.py` for a full example.
+
+## Further reading
+
+- [OSDI technical reference](docs/osdi-technical-reference.md) — parameter handling, model introspection, output layout,
+  host-simulator integration (companion method vs MNA/DAE), and debug utilities
+
+## Limitations
+
+- **Platform:** Linux and macOS; Python 3.11+; OSDI 0.4 ABI only. `.osdi` binaries are platform-specific — compile from
+  `.va` sources via [openvaf-r](https://github.com/cdaunt/OpenVAF) on each target
+- **OSDI differentiability:** `jax.grad()` works through node voltages only, not model parameters — use the VA path for
+  parameter gradients
+- **Stateful models** (`num_states > 0`): evaluation is skipped and outputs are zeroed
+- **VA lowering (alpha):** user-defined `analog function` calls and noise contributions are not yet supported

bosdi-0.1.1/README.md

@@ -0,0 +1,142 @@
+# bosdi — Batched OSDI
+
+![CI](https://github.com/gdsfactory/bosdi/actions/workflows/test.yml/badge.svg)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+![Python 3.13](https://img.shields.io/badge/python-3.13-blue.svg)
+![Platform: Linux | macOS](https://img.shields.io/badge/platform-linux%20%7C%20macOS-lightgrey)
+![Status: Experimental](https://img.shields.io/badge/status-experimental-orange)
+
+> **Experimental** — bosdi is under active development. The OSDI binary evaluation path is stable and well-tested, but
+> the Verilog-A to JAX lowering compiler (`bosdi.va`) is in **alpha** and its API may change without notice. The VA
+> lowering depends on a [custom fork of OpenVAF](https://github.com/cdaunt/OpenVAF) that exposes the compiler's
+> intermediate representation; this fork is not yet merged upstream.
+
+Evaluate [OSDI](https://github.com/OpenVAF/OpenVAF) device models (Verilog-A compiled to `.osdi` binaries) in batched
+parallel via JAX.
+
+## Two evaluation paths
+
+bosdi provides two ways to evaluate Verilog-A compact models inside JAX:
+
+### OSDI binary path (stable)
+
+Loads a pre-compiled `.osdi` binary and evaluates N device instances in parallel via Rayon inside a JAX XLA custom call.
+The OSDI ABI provides analytical Jacobians with respect to **node voltages only** (conductances `dI/dV`, capacitances
+`dQ/dV`). A `@custom_jvp` rule makes `jax.grad()` work through node voltages — but not through model parameters or
+state.
+
+```python
+from osdi_loader import load_osdi_model
+from osdi_jax import osdi_eval
+
+model = load_osdi_model("path/to/device.osdi")
+N = 1024
+voltages = jnp.zeros((N, model.num_nodes), dtype=jnp.float64)
+params = jnp.full((N, model.num_params), jnp.nan, dtype=jnp.float64)
+old_state = jnp.zeros((N, model.num_states), dtype=jnp.float64)
+
+cur, cond, chg, cap, new_state = osdi_eval(model.id, voltages, params, old_state)
+
+# jax.grad works through node voltages
+grad_fn = jax.grad(lambda v: osdi_eval(model.id, v, params, old_state)[0].sum())
+```
+
+### VA to JAX lowering (alpha)
+
+Compiles Verilog-A source directly into pure JAX/Python, producing a function that is **fully differentiable** through
+all inputs — voltages, parameters, and temperature. This enables parameter optimization, sensitivity analysis, and
+end-to-end gradient-based design flows that the OSDI path cannot support.
+
+Requires [openvaf-r](https://github.com/cdaunt/OpenVAF) (a custom OpenVAF fork).
+
+```bash
+python -m bosdi.va device.va
+```
+
+### When to use which
+
+|                           | OSDI binary                                   | VA to JAX                                                                   |
+| ------------------------- | --------------------------------------------- | --------------------------------------------------------------------------- |
+| **Use case**              | Circuit simulation (Newton solve)             | Parameter fitting, sensitivity analysis, inverse design                     |
+| **Differentiable w.r.t.** | Node voltages only                            | Voltages, parameters, and temperature                                       |
+| **Performance**           | Fast — Rayon-parallel C/Rust, batched XLA FFI | Pure Python/JAX — slower per-eval, but composable with `jax.jit`/`jax.vmap` |
+| **Maturity**              | Stable                                        | Alpha                                                                       |
+| **Dependencies**          | None beyond bosdi                             | [openvaf-r](https://github.com/cdaunt/OpenVAF) fork                         |
+
+The OSDI path treats the compiled model as a black box and extracts only what the ABI exposes: currents, charges, and
+their Jacobians w.r.t. node voltages. This is exactly what a Newton solver needs, but the parameter axis is opaque to
+JAX — you cannot backpropagate through it.
+
+The VA to JAX path exists to remove that limitation. By lowering the Verilog-A source into native JAX operations, every
+computation becomes visible to JAX's autodiff, making the model fully differentiable. This is what enables
+gradient-based parameter extraction, design-space exploration, and end-to-end optimization of circuits where device
+parameters are the degrees of freedom.
+
+## Architecture
+
+```
+OSDI path:
+  Python: osdi_eval()  →  JAX XLA custom call
+    →  C++ (nanobind/XLA FFI): unpack buffers
+      →  Rust (Rayon): evaluate N devices in parallel
+        →  OSDI binary: currents, conductances, charges, capacitances
+
+VA path:
+  Verilog-A source  →  openvaf-r (MIR dump)
+    →  bosdi.va lowering + SCCP optimization
+      →  Pure JAX/Python function (fully differentiable)
+```
+
+## Installation
+
+### Using Pixi (recommended)
+
+```bash
+git clone https://github.com/gdsfactory/bosdi && cd bosdi
+pixi run build
+```
+
+### Using pip
+
+```bash
+pip install bosdi
+```
+
+## Build & test
+
+```bash
+pixi run build   # compile Rust static lib + C++ extension
+pixi run test    # run pytest suite
+
+# single test
+pixi run pytest tests/test_osdi.py::test_resistor_dc_evaluation -v
+```
+
+## OSDI outputs
+
+The OSDI path returns per-device arrays shaped by `model.num_nodes` (terminals + internal nodes + branch-current
+auxiliaries):
+
+| Output | Shape             | Description                                  |
+| ------ | ----------------- | -------------------------------------------- |
+| `cur`  | `[N, num_nodes]`  | Resistive current residual at each unknown   |
+| `cond` | `[N, num_nodes²]` | `G = ∂cur/∂V` Jacobian (flattened row-major) |
+| `chg`  | `[N, num_nodes]`  | Charge residual at each unknown              |
+| `cap`  | `[N, num_nodes²]` | `C = ∂chg/∂V` Jacobian (flattened row-major) |
+
+Pass `jnp.nan` for any parameter to use its Verilog-A default. Parameters can be addressed by name via
+`model.param_names`. See `tests/test_bsim4_model_card.py` for a full example.
+
+## Further reading
+
+- [OSDI technical reference](docs/osdi-technical-reference.md) — parameter handling, model introspection, output layout,
+  host-simulator integration (companion method vs MNA/DAE), and debug utilities
+
+## Limitations
+
+- **Platform:** Linux and macOS; Python 3.11+; OSDI 0.4 ABI only. `.osdi` binaries are platform-specific — compile from
+  `.va` sources via [openvaf-r](https://github.com/cdaunt/OpenVAF) on each target
+- **OSDI differentiability:** `jax.grad()` works through node voltages only, not model parameters — use the VA path for
+  parameter gradients
+- **Stateful models** (`num_states > 0`): evaluation is skipped and outputs are zeroed
+- **VA lowering (alpha):** user-defined `analog function` calls and noise contributions are not yet supported

bosdi-0.1.1/_nanobind_src/buffer.h

@@ -0,0 +1,166 @@
+#pragma once
+
+#include <string.h>
+#include <stdarg.h>
+#include <stdio.h> // vsnprintf
+
+NAMESPACE_BEGIN(NB_NAMESPACE)
+NAMESPACE_BEGIN(detail)
+
+struct Buffer {
+public:
+    // Disable copy/move constructor and assignment
+    Buffer(const Buffer &) = delete;
+    Buffer(Buffer &&) = delete;
+    Buffer &operator=(const Buffer &) = delete;
+    Buffer &operator=(Buffer &&) = delete;
+
+    Buffer(size_t size = 0) : m_start((char *) malloc(size)) {
+        if (!m_start) {
+            fprintf(stderr, "Buffer::Buffer(): out of memory (unrecoverable error)!");
+            abort();
+        }
+        m_end = m_start + size;
+        if (size)
+            clear();
+    }
+
+    ~Buffer() {
+        free(m_start);
+    }
+
+    /// Append a string with the specified length
+    void put(const char *str, size_t size) {
+        if (m_cur + size >= m_end)
+            expand(size + 1 - remain());
+
+        memcpy(m_cur, str, size);
+        m_cur += size;
+        *m_cur = '\0';
+    }
+
+    /// Append a string
+    template <size_t N> void put(const char (&str)[N]) {
+        put(str, N - 1);
+    }
+
+    /// Append a dynamic string
+    void put_dstr(const char *str) { put(str, strlen(str)); }
+
+    /// Append a single character to the buffer
+    void put(char c) {
+        if (m_cur + 1 >= m_end)
+            expand();
+        *m_cur++ = c;
+        *m_cur = '\0';
+    }
+
+    /// Append multiple copies of a single character to the buffer
+    void put(char c, size_t count) {
+        if (m_cur + count >= m_end)
+            expand(count + 1 - remain());
+        for (size_t i = 0; i < count; ++i)
+            *m_cur++ = c;
+        *m_cur = '\0';
+    }
+
+    /// Append a formatted (printf-style) string to the buffer
+#if defined(__GNUC__)
+    __attribute__((__format__ (__printf__, 2, 3)))
+#endif
+    size_t fmt(const char *format, ...) {
+        size_t written;
+        do {
+            size_t size = remain();
+            va_list args;
+            va_start(args, format);
+            written = (size_t) vsnprintf(m_cur, size, format, args);
+            va_end(args);
+
+            if (written + 1 < size) {
+                m_cur += written;
+                break;
+            }
+
+            expand();
+        } while (true);
+
+        return written;
+    }
+
+    const char *get() { return m_start; }
+
+    void clear() {
+        m_cur = m_start;
+        if (m_start != m_end)
+            m_start[0] = '\0';
+    }
+
+    /// Remove the last 'n' characters
+    void rewind(size_t n) {
+        if (m_cur < m_start + n)
+            m_cur = m_start;
+        else
+            m_cur -= n;
+        *m_cur = '\0';
+    }
+
+    /// Append an unsigned 32 bit integer
+    void put_uint32(uint32_t value) {
+        const int digits = 10;
+        const char *num = "0123456789";
+        char buf[digits];
+        size_t i = digits;
+
+        do {
+            buf[--i] = num[value % 10];
+            value /= 10;
+        } while (value);
+
+        return put(buf + i, digits - i);
+    }
+
+    char *copy(size_t offset = 0) const {
+        size_t copy_size = size() + 1 - offset;
+        char *tmp = (char *) malloc(copy_size);
+        if (!tmp) {
+            fprintf(stderr, "Buffer::copy(): out of memory (unrecoverable error)!");
+            abort();
+        }
+        memcpy(tmp, m_start + offset, copy_size);
+        return tmp;
+    }
+
+    size_t size() const { return (size_t) (m_cur - m_start); }
+    size_t remain() const { return (size_t) (m_end - m_cur); }
+
+private:
+    NB_NOINLINE void expand(size_t minval = 2) {
+        size_t old_alloc_size = m_end - m_start,
+               new_alloc_size = 2 * old_alloc_size + minval,
+               used_size      = (size_t) (m_cur - m_start),
+               copy_size      = used_size + 1;
+
+        if (old_alloc_size < copy_size)
+            copy_size = old_alloc_size;
+
+        char *tmp = (char *) malloc(new_alloc_size);
+        if (!tmp) {
+            fprintf(stderr, "Buffer::expand(): out of memory (unrecoverable error)!");
+            abort();
+        }
+
+        memcpy(tmp, m_start, copy_size);
+        free(m_start);
+
+        m_start = tmp;
+        m_end = m_start + new_alloc_size;
+        m_cur = m_start + used_size;
+    }
+
+private:
+    char *m_start{nullptr}, *m_cur{nullptr}, *m_end{nullptr};
+};
+
+NAMESPACE_END(detail)
+NAMESPACE_END(NB_NAMESPACE)