mccl 0.3.0__tar.gz

mccl-0.3.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 MCCL Contributors
+
+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.

mccl-0.3.0/MANIFEST.in

@@ -0,0 +1,3 @@
+# Ensure native sources ship in sdist (wheels are built on macOS arm64 only).
+recursive-include csrc *
+include LICENSE README.md pyproject.toml setup.py

mccl-0.3.0/PKG-INFO

@@ -0,0 +1,162 @@
+Metadata-Version: 2.4
+Name: mccl
+Version: 0.3.0
+Summary: MPS-native ProcessGroup backend for PyTorch Distributed on Apple Silicon
+License: MIT
+Project-URL: Repository, https://github.com/OWNER/REPO
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: torch>=2.5.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-timeout>=2.1; extra == "dev"
+Dynamic: license-file
+Dynamic: requires-python
+
+# MCCL
+
+[![CI](https://github.com/OWNER/REPO/actions/workflows/ci.yml/badge.svg)](https://github.com/OWNER/REPO/actions/workflows/ci.yml)
+
+`torch.distributed` backend for DDP and collectives on **MPS** (Apple Silicon). TCP by default; RDMA only if the machine/OS actually supports it.
+
+## Requirements
+
+- Apple Silicon Mac (arm64). No Intel.
+- **Xcode Command Line Tools** — `xcode-select --install` (needed to compile the extension).
+- **Full Xcode** — optional; speeds up Metal by emitting a `.metallib` at build time instead of JIT at runtime.
+- **Python 3.11+**
+- **PyTorch 2.5+** installed *before* you build or `pip install` this package.
+
+## Install
+
+```bash
+pip install torch
+pip install mccl
+```
+
+Source tree: `pip install -e ".[dev]"`. If the PyPI name `mccl` is taken, rename in `pyproject.toml` and `setup.py`.
+
+Demo: https://github.com/user-attachments/assets/21865149-b077-4b65-93cc-f9e319ff0328
+
+## Examples
+
+```bash
+python examples/ddp_dummy_train.py --baseline
+torchrun --nproc_per_node=2 --nnodes=1 --master_addr=127.0.0.1 --master_port=29500 \
+  examples/ddp_dummy_train.py
+```
+
+Defaults there: DDP `BATCH_SIZE=128` per rank → global 256 with 2 ranks; baseline path uses global 256 unless you override. Shrink batch if you OOM.
+
+Minimal DDP script (run with `torchrun` below). Multi-node needs `MCCL_LISTEN_ADDR`, `MCCL_PORT_BASE`, etc. — [docs/MULTINODE.md](docs/MULTINODE.md).
+
+```python
+import os
+import torch
+import torch.nn as nn
+import torch.distributed as dist
+from torch.nn.parallel import DistributedDataParallel as DDP
+import mccl
+
+def main():
+    rank = int(os.environ["RANK"])
+    world_size = int(os.environ["WORLD_SIZE"])
+    device = torch.device("mps:0")
+
+    dist.init_process_group(backend="mccl", device_id=device)
+
+    torch.manual_seed(42)
+    model = nn.Sequential(nn.Linear(512, 256), nn.ReLU(), nn.Linear(256, 10)).to(device)
+    ddp_model = DDP(model)
+    optimizer = torch.optim.AdamW(ddp_model.parameters(), lr=1e-3)
+    loss_fn = nn.CrossEntropyLoss()
+
+    for step in range(10):
+        x = torch.randn(8, 512, device=device)
+        y = torch.randint(0, 10, (8,), device=device)
+        optimizer.zero_grad(set_to_none=True)
+        loss_fn(ddp_model(x), y).backward()
+        optimizer.step()
+        if rank == 0:
+            print(step, "ok")
+
+    dist.destroy_process_group()
+
+if __name__ == "__main__":
+    main()
+```
+
+```bash
+torchrun --nproc_per_node=2 --nnodes=1 --master_addr=127.0.0.1 --master_port=29500 your_train.py
+```
+
+## Throughput
+
+One saved run, **M4 Max** + **M1 Max** MBPs, TCP over TB, global batch **256**, ~**96.5M** params. Your numbers will differ.
+
+```
+single M1 Max (MPS):   78.3 samples/s   (global_batch=256, world=1)
+DDP (MCCL):          134.2 samples/s   (global_batch=256, world=2)
+baseline / DDP:      0.58×  (~172% DDP vs baseline)
+```
+
+Tiny batches = comm noise dominates. Different chips on each rank = slowest one paces the step.
+
+```bash
+python examples/ddp_dummy_train.py --baseline --save-stats baseline_stats.json
+torchrun --nproc_per_node=2 --nnodes=1 --master_addr=127.0.0.1 --master_port=29500 \
+  examples/ddp_dummy_train.py --save-stats ddp_stats.json
+python examples/benchmark_throughput.py --baseline baseline_stats.json --ddp ddp_stats.json -o bench
+```
+
+`bash scripts/benchmark_matrix.sh` for more sweeps.
+
+![bench](bench.png)  
+![bars](bench_bars.png)
+
+## PyPI (maintainers)
+
+**CI (tests only):** push to **`main`** or **`master`**, or open a PR targeting those branches. That runs [`.github/workflows/ci.yml`](.github/workflows/ci.yml) — it does **not** upload to PyPI.
+
+**Upload:** [`.github/workflows/publish.yml`](.github/workflows/publish.yml) runs on **GitHub Release (published)** or **Actions → Publish to PyPI → Run workflow** (`workflow_dispatch`).
+
+1. GitHub repo → **Settings → Secrets and variables → Actions** → New repository secret **`PYPI_API_TOKEN`** (PyPI → Account settings → API tokens).
+2. Bump **`version`** in `pyproject.toml`, `setup.py`, and the assertion in `tests/test_build.py`.
+3. Either: **Releases → Draft a new release** → publish (triggers upload), or **Actions** tab → **Publish to PyPI** → **Run workflow** → branch `main`.
+
+First-time PyPI: create the **`mccl`** project on pypi.org (or change the package `name` everywhere if the name is taken).
+
+## Collectives
+
+`allreduce`, `broadcast`, `barrier`, `allgather`, `reduce_scatter`, `send`, `recv`
+
+## Diagnostics
+
+```python
+mccl.get_metrics(); mccl.log_metrics(); mccl.reset_metrics()
+```
+
+Verbose startup: `MCCL_LOG_LEVEL=INFO`. Stuck multi-node: [docs/MULTINODE.md](docs/MULTINODE.md).
+
+## Transport
+
+Bench plots were TCP over a Thunderbolt-style link, not RDMA. Wi‑Fi/Ethernet work, just slower. TB wiring: [docs/THUNDERBOLT_SETUP.md](docs/THUNDERBOLT_SETUP.md). RDMA path exists on TB5-capable hardware + `librdma.dylib`; `rdma_ctl enable` from Recovery once; we didn’t use that for the graphs above.
+
+## Internals
+
+Apple Silicon is **UMA**: GPU and CPU share a physical memory pool. MPS tensors are usually **`MTLBuffer`s**; with **`MTLStorageModeShared`**, `buffer.contents` is a CPU pointer into the **same pages** the GPU uses (`extract_mps_buffer`, `MPSInterop.mm`). MCCL **exploits that** by staging sends from that pointer, writing receives with `memcpy` into it, and running **Accelerate/vDSP** in **`AccelerateOps.mm`** on the same bytes—no duplicate host tensor when the fast path applies. **Private** GPU storage still needs a **blit** through a shared staging buffer (`chunked_blit_*`).
+
+I/O runs on a **queued worker** (`ProgressEngine`, `csrc/runtime/`). Before the worker reads or sends, **`commit_mps_and_signal` / `wait_for_mps`** (`EventSync.mm`) align CPU access with a finished PyTorch MPS command buffer via **`MTLSharedEvent`**; `MCCL_EVENT_SYNC=0` forces stream sync instead. `ProcessGroupMCCL.cpp` submits work into this pipeline. [docs/DEVELOPING.md](docs/DEVELOPING.md) covers collectives and transport.
+
+## License
+
+MIT — [LICENSE](LICENSE)

mccl-0.3.0/README.md

@@ -0,0 +1,138 @@
+# MCCL
+
+[![CI](https://github.com/OWNER/REPO/actions/workflows/ci.yml/badge.svg)](https://github.com/OWNER/REPO/actions/workflows/ci.yml)
+
+`torch.distributed` backend for DDP and collectives on **MPS** (Apple Silicon). TCP by default; RDMA only if the machine/OS actually supports it.
+
+## Requirements
+
+- Apple Silicon Mac (arm64). No Intel.
+- **Xcode Command Line Tools** — `xcode-select --install` (needed to compile the extension).
+- **Full Xcode** — optional; speeds up Metal by emitting a `.metallib` at build time instead of JIT at runtime.
+- **Python 3.11+**
+- **PyTorch 2.5+** installed *before* you build or `pip install` this package.
+
+## Install
+
+```bash
+pip install torch
+pip install mccl
+```
+
+Source tree: `pip install -e ".[dev]"`. If the PyPI name `mccl` is taken, rename in `pyproject.toml` and `setup.py`.
+
+Demo: https://github.com/user-attachments/assets/21865149-b077-4b65-93cc-f9e319ff0328
+
+## Examples
+
+```bash
+python examples/ddp_dummy_train.py --baseline
+torchrun --nproc_per_node=2 --nnodes=1 --master_addr=127.0.0.1 --master_port=29500 \
+  examples/ddp_dummy_train.py
+```
+
+Defaults there: DDP `BATCH_SIZE=128` per rank → global 256 with 2 ranks; baseline path uses global 256 unless you override. Shrink batch if you OOM.
+
+Minimal DDP script (run with `torchrun` below). Multi-node needs `MCCL_LISTEN_ADDR`, `MCCL_PORT_BASE`, etc. — [docs/MULTINODE.md](docs/MULTINODE.md).
+
+```python
+import os
+import torch
+import torch.nn as nn
+import torch.distributed as dist
+from torch.nn.parallel import DistributedDataParallel as DDP
+import mccl
+
+def main():
+    rank = int(os.environ["RANK"])
+    world_size = int(os.environ["WORLD_SIZE"])
+    device = torch.device("mps:0")
+
+    dist.init_process_group(backend="mccl", device_id=device)
+
+    torch.manual_seed(42)
+    model = nn.Sequential(nn.Linear(512, 256), nn.ReLU(), nn.Linear(256, 10)).to(device)
+    ddp_model = DDP(model)
+    optimizer = torch.optim.AdamW(ddp_model.parameters(), lr=1e-3)
+    loss_fn = nn.CrossEntropyLoss()
+
+    for step in range(10):
+        x = torch.randn(8, 512, device=device)
+        y = torch.randint(0, 10, (8,), device=device)
+        optimizer.zero_grad(set_to_none=True)
+        loss_fn(ddp_model(x), y).backward()
+        optimizer.step()
+        if rank == 0:
+            print(step, "ok")
+
+    dist.destroy_process_group()
+
+if __name__ == "__main__":
+    main()
+```
+
+```bash
+torchrun --nproc_per_node=2 --nnodes=1 --master_addr=127.0.0.1 --master_port=29500 your_train.py
+```
+
+## Throughput
+
+One saved run, **M4 Max** + **M1 Max** MBPs, TCP over TB, global batch **256**, ~**96.5M** params. Your numbers will differ.
+
+```
+single M1 Max (MPS):   78.3 samples/s   (global_batch=256, world=1)
+DDP (MCCL):          134.2 samples/s   (global_batch=256, world=2)
+baseline / DDP:      0.58×  (~172% DDP vs baseline)
+```
+
+Tiny batches = comm noise dominates. Different chips on each rank = slowest one paces the step.
+
+```bash
+python examples/ddp_dummy_train.py --baseline --save-stats baseline_stats.json
+torchrun --nproc_per_node=2 --nnodes=1 --master_addr=127.0.0.1 --master_port=29500 \
+  examples/ddp_dummy_train.py --save-stats ddp_stats.json
+python examples/benchmark_throughput.py --baseline baseline_stats.json --ddp ddp_stats.json -o bench
+```
+
+`bash scripts/benchmark_matrix.sh` for more sweeps.
+
+![bench](bench.png)  
+![bars](bench_bars.png)
+
+## PyPI (maintainers)
+
+**CI (tests only):** push to **`main`** or **`master`**, or open a PR targeting those branches. That runs [`.github/workflows/ci.yml`](.github/workflows/ci.yml) — it does **not** upload to PyPI.
+
+**Upload:** [`.github/workflows/publish.yml`](.github/workflows/publish.yml) runs on **GitHub Release (published)** or **Actions → Publish to PyPI → Run workflow** (`workflow_dispatch`).
+
+1. GitHub repo → **Settings → Secrets and variables → Actions** → New repository secret **`PYPI_API_TOKEN`** (PyPI → Account settings → API tokens).
+2. Bump **`version`** in `pyproject.toml`, `setup.py`, and the assertion in `tests/test_build.py`.
+3. Either: **Releases → Draft a new release** → publish (triggers upload), or **Actions** tab → **Publish to PyPI** → **Run workflow** → branch `main`.
+
+First-time PyPI: create the **`mccl`** project on pypi.org (or change the package `name` everywhere if the name is taken).
+
+## Collectives
+
+`allreduce`, `broadcast`, `barrier`, `allgather`, `reduce_scatter`, `send`, `recv`
+
+## Diagnostics
+
+```python
+mccl.get_metrics(); mccl.log_metrics(); mccl.reset_metrics()
+```
+
+Verbose startup: `MCCL_LOG_LEVEL=INFO`. Stuck multi-node: [docs/MULTINODE.md](docs/MULTINODE.md).
+
+## Transport
+
+Bench plots were TCP over a Thunderbolt-style link, not RDMA. Wi‑Fi/Ethernet work, just slower. TB wiring: [docs/THUNDERBOLT_SETUP.md](docs/THUNDERBOLT_SETUP.md). RDMA path exists on TB5-capable hardware + `librdma.dylib`; `rdma_ctl enable` from Recovery once; we didn’t use that for the graphs above.
+
+## Internals
+
+Apple Silicon is **UMA**: GPU and CPU share a physical memory pool. MPS tensors are usually **`MTLBuffer`s**; with **`MTLStorageModeShared`**, `buffer.contents` is a CPU pointer into the **same pages** the GPU uses (`extract_mps_buffer`, `MPSInterop.mm`). MCCL **exploits that** by staging sends from that pointer, writing receives with `memcpy` into it, and running **Accelerate/vDSP** in **`AccelerateOps.mm`** on the same bytes—no duplicate host tensor when the fast path applies. **Private** GPU storage still needs a **blit** through a shared staging buffer (`chunked_blit_*`).
+
+I/O runs on a **queued worker** (`ProgressEngine`, `csrc/runtime/`). Before the worker reads or sends, **`commit_mps_and_signal` / `wait_for_mps`** (`EventSync.mm`) align CPU access with a finished PyTorch MPS command buffer via **`MTLSharedEvent`**; `MCCL_EVENT_SYNC=0` forces stream sync instead. `ProcessGroupMCCL.cpp` submits work into this pipeline. [docs/DEVELOPING.md](docs/DEVELOPING.md) covers collectives and transport.
+
+## License
+
+MIT — [LICENSE](LICENSE)

mccl-0.3.0/csrc/backend/MPSDispatch.cpp

@@ -0,0 +1,144 @@
+/**
+ * MPS dispatch key registration for c10d collective ops.
+ *
+ * PyTorch 2.10 routes all c10d ops through the c10 Dispatcher, keyed by the
+ * device type of the tensor arguments. Out of the box only CPU, CUDA, and
+ * PrivateUse1 keys are registered. This file adds the MPS key so that
+ * collectives on MPS tensors route to the MCCL backend.
+ *
+ * Each implementation is a thin shim that extracts the Backend for MPS from
+ * the ProcessGroup and forwards to the corresponding virtual method — the
+ * same pattern PyTorch uses internally for CPU/CUDA in Ops.cpp.
+ */
+
+#include <torch/library.h>
+#include <torch/csrc/distributed/c10d/ProcessGroup.hpp>
+#include <torch/csrc/distributed/c10d/Types.hpp>
+
+namespace mccl {
+namespace {
+
+std::tuple<std::vector<at::Tensor>, c10::intrusive_ptr<c10d::Work>>
+allreduce_MPS(
+    at::TensorList tensors,
+    const c10::intrusive_ptr<c10d::ProcessGroup>& process_group,
+    const c10::intrusive_ptr<c10d::ReduceOp>& reduce_op,
+    const std::optional<at::Tensor>& sparse_indices,
+    bool async_op,
+    int64_t timeout) {
+  auto tensor_vec = tensors.vec();
+  c10d::AllreduceOptions opts;
+  opts.reduceOp = *reduce_op;
+  opts.sparseIndices = sparse_indices;
+  opts.asyncOp = async_op;
+  if (timeout >= 0)
+    opts.timeout = std::chrono::milliseconds(timeout);
+  auto work =
+      process_group->getBackend(c10::DeviceType::MPS)->allreduce(tensor_vec, opts);
+  return {std::move(tensor_vec), work};
+}
+
+std::tuple<std::vector<at::Tensor>, c10::intrusive_ptr<c10d::Work>>
+broadcast_MPS(
+    at::TensorList tensors,
+    const c10::intrusive_ptr<c10d::ProcessGroup>& process_group,
+    int64_t root_rank,
+    int64_t root_tensor,
+    bool async_op,
+    int64_t timeout) {
+  auto tensor_vec = tensors.vec();
+  c10d::BroadcastOptions opts;
+  opts.rootRank = root_rank;
+  opts.rootTensor = root_tensor;
+  opts.asyncOp = async_op;
+  if (timeout >= 0)
+    opts.timeout = std::chrono::milliseconds(timeout);
+  auto work =
+      process_group->getBackend(c10::DeviceType::MPS)->broadcast(tensor_vec, opts);
+  return {std::move(tensor_vec), work};
+}
+
+c10::intrusive_ptr<c10d::Work> barrier_MPS(
+    at::Tensor /* tensor */,
+    const c10::intrusive_ptr<c10d::ProcessGroup>& process_group,
+    const std::vector<int64_t>& device_ids,
+    bool async_op,
+    int64_t timeout) {
+  c10d::BarrierOptions opts;
+  opts.device_ids = device_ids;
+  opts.asyncOp = async_op;
+  if (timeout >= 0)
+    opts.timeout = std::chrono::milliseconds(timeout);
+  return process_group->getBackend(c10::DeviceType::MPS)->barrier(opts);
+}
+
+std::tuple<std::vector<std::vector<at::Tensor>>, c10::intrusive_ptr<c10d::Work>>
+allgather_MPS(
+    const std::vector<std::vector<at::Tensor>>& output_tensors,
+    at::TensorList input_tensors,
+    const c10::intrusive_ptr<c10d::ProcessGroup>& process_group,
+    bool async_op,
+    int64_t timeout) {
+  auto output_vec = output_tensors;
+  auto input_vec = input_tensors.vec();
+  c10d::AllgatherOptions opts;
+  opts.asyncOp = async_op;
+  if (timeout >= 0)
+    opts.timeout = std::chrono::milliseconds(timeout);
+  auto work = process_group->getBackend(c10::DeviceType::MPS)
+                  ->allgather(output_vec, input_vec, opts);
+  return {std::move(output_vec), work};
+}
+
+std::tuple<std::vector<at::Tensor>, c10::intrusive_ptr<c10d::Work>>
+reduce_scatter_MPS(
+    const at::TensorList& output_tensors,
+    const std::vector<std::vector<at::Tensor>>& input_tensors,
+    const c10::intrusive_ptr<c10d::ProcessGroup>& process_group,
+    const c10::intrusive_ptr<c10d::ReduceOp>& reduce_op,
+    bool async_op,
+    int64_t timeout) {
+  auto output_vec = output_tensors.vec();
+  auto input_vec = input_tensors;
+  c10d::ReduceScatterOptions opts;
+  opts.reduceOp = *reduce_op;
+  opts.asyncOp = async_op;
+  if (timeout >= 0)
+    opts.timeout = std::chrono::milliseconds(timeout);
+  auto work = process_group->getBackend(c10::DeviceType::MPS)
+                  ->reduce_scatter(output_vec, input_vec, opts);
+  return {std::move(output_vec), work};
+}
+
+c10::intrusive_ptr<c10d::Work> send_MPS(
+    at::TensorList tensors,
+    const c10::intrusive_ptr<c10d::ProcessGroup>& process_group,
+    int64_t dst_rank,
+    int64_t tag) {
+  auto tensor_vec = tensors.vec();
+  return process_group->getBackend(c10::DeviceType::MPS)
+      ->send(tensor_vec, static_cast<int>(dst_rank), static_cast<int>(tag));
+}
+
+c10::intrusive_ptr<c10d::Work> recv_MPS(
+    at::TensorList tensors,
+    const c10::intrusive_ptr<c10d::ProcessGroup>& process_group,
+    int64_t src_rank,
+    int64_t tag) {
+  auto tensor_vec = tensors.vec();
+  return process_group->getBackend(c10::DeviceType::MPS)
+      ->recv(tensor_vec, static_cast<int>(src_rank), static_cast<int>(tag));
+}
+
+TORCH_LIBRARY_IMPL(c10d, MPS, m) {
+  m.impl("allreduce_", allreduce_MPS);
+  m.impl("broadcast_", broadcast_MPS);
+  m.impl("barrier", barrier_MPS);
+  m.impl("allgather_", allgather_MPS);
+  m.impl("reduce_scatter_", reduce_scatter_MPS);
+  m.impl("send", send_MPS);
+  m.impl("recv_", recv_MPS);
+}
+
+} // anonymous namespace
+} // namespace mccl

mccl-0.3.0/csrc/backend/Options.hpp

@@ -0,0 +1,47 @@
+#pragma once
+
+#include <torch/torch.h>
+#include <c10d/ProcessGroup.hpp>
+#include <chrono>
+#include <string>
+
+#include "compression/Compression.hpp"
+
+namespace mccl {
+
+struct MCCLOptions : public c10d::Backend::Options {
+    MCCLOptions()
+        : c10d::Backend::Options("mccl", std::chrono::milliseconds(30000)) {}
+
+    explicit MCCLOptions(std::chrono::milliseconds timeout)
+        : c10d::Backend::Options("mccl", timeout) {}
+
+    // Transport
+    std::string transport = "auto";  // "auto", "tcp", "rdma"
+    std::string listen_addr = "0.0.0.0";
+    uint16_t port_base = 29600;
+    std::string ifname;
+    size_t chunk_bytes = 4 * 1024 * 1024;
+    size_t small_msg_threshold = 65536;
+    bool transport_crc = false;
+
+    // Compute
+    bool fast_math = true;
+    uint32_t gpu_threshold = 4096;
+    bool overlap_comm = true;
+
+    // Engine
+    size_t max_queue_depth = 1024;
+
+    // Compression
+    CompressionMode compression = CompressionMode::NONE;
+    double topk_ratio = 0.01;
+
+    // Watchdog
+    std::chrono::milliseconds watchdog_timeout{300000};
+
+    // Health monitor
+    std::chrono::milliseconds heartbeat_interval{5000};
+};
+
+} // namespace mccl