Hxcore.ol -

| Aspect | Guarantees | Implementation | |--------|------------|----------------| | Read‑only | Fully lock‑free, memory‑consistent across threads. | Uses std::atomic for pointer/handle reads; no mutexes. | | Write | Exclusive access per arena. | Arena.mutate() acquires a spin‑lock (std::atomic_flag). Nested guards are re‑entrant. | | Multi‑process | Safe when using shared‑memory arena; readers see writes after the guard exits. | Memory barriers (std::atomic_thread_fence) inserted at guard exit. | | Atomic fields | view.atomic_int32 provides fetch_add, compare_exchange. | Implemented with std::atomic<int32_t> placed directly in the arena. |

| Aspect | Description | |--------|-------------| | Package name | hxcore.ol (Object‑Layer) | | Primary purpose | Provides a lightweight, zero‑copy, memory‑mapped object model that abstracts raw buffers, hierarchical structures, and typed data into a uniform API. | | Key design goals | - Zero‑copy (direct view onto memory‑mapped files or shared buffers)
- Deterministic memory layout (C‑compatible, little‑/big‑endian aware)
- Extensible type system (primitives, containers, custom structs)
- Thread‑safe, lock‑free reads
- Pluggable serialization (binary, JSON, protobuf, custom) | | Typical use‑cases | • High‑frequency trading data feeds
• Scientific simulation snapshots
• Large‑scale telemetry ingestion
• In‑memory OLAP cubes
• Real‑time ML feature stores | | Supported languages | Python (C‑extension), C++, Rust (via FFI), Java (JNI wrapper). The Python package ships a compiled binary hxcore.ol that calls into the C++ core. | | Version | hxcore.ol >= 2.4.1 (current stable) | | License | Apache‑2.0 (commercial support available) | hxcore.ol

Unlike pure-play software companies, HXCORE.OL owns a proprietary dataset of North Sea wind patterns dating back to 2010. This historical data, combined with real-time sensor feeds, gives its AI models a significant accuracy advantage over new entrants. Data is the new oil, and HXCORE.OL owns a refinery. Unlike pure-play software companies, HXCORE

struct Trade:
  timestamp: int64   # epoch‑ms
  symbol:   fixed[8] # ASCII padded with 0
  price:    float64
  quantity: int32
  flags:    bitfield[8]  # optional bit flags

import numpy as np
import hxcore.ol as hx
# Obtain a NumPy view of a contiguous Float64 array in the arena
arr_view = hx.ArrayView(arena, handle_of_float64_array)
np_array = np.ndarray(shape=arr_view.shape,
                      dtype=np.float64,
                      buffer=arr_view.buffer,
                      offset=arr_view.offset,
                      strides=arr_view.strides)
# Pandas DataFrame directly from arena structs (no copy)
df = hx.pandas.from_arena(arena, struct_name='Trade')

If you are considering integrating hxcore.ol into your workflow, these five features constitute its value proposition:

+--------------------------------------------------------------+
|                        hxcore.ol (C++ core)                |
|   +----------------------+   +---------------------------+  |
|   |   Arena Manager      |   |   Schema Registry         |  |
|   |  - mmap, shm, heap  |   |  - compile-time / runtime |  |
|   +----------+-----------+   +-----------+---------------+  |
|              |                           |                 |
|   +----------v-----------+   +-----------v---------------+  |
|   |   Object Store       |   |   Accessor Engine         |  |
|   |  - Handles ↔ pointers|   |  - Inline getters/setters |  |
|   +----------+-----------+   +-----------+---------------+  |
|              |                           |                 |
|   +----------v-----------+   +-----------v---------------+  |
|   |   Buffer View Layer  |   |   Serialization Backends |  |
|   |  - Python buffer     |   |  - Binary, JSON, Protobuf|  |
|   +----------------------+   +---------------------------+  |
+--------------------------------------------------------------+

The Python package (hxcore.ol) is a thin C‑extension that forwards calls to the C++ core.
All read‑only operations are lock‑free; writes go through a mutation guard that uses a per‑arena std::atomic_flag to ensure exclusive access.