feat: support CCL Broadcast

[GordonYang1]

Summary

This PR adds Broadcast support to the shared CCL backend abstraction, including native bindings through the existing NCCL and MCCL provider layers for the public infinicclBroadcast() API and its legacy in-place infinicclBcast() alias. It also teaches Broadcast dispatch to follow the backend/device combination stored in the communicator for mixed-backend bootstrap flows, adds generated-bridge dependency tracking for header-only operation implementations, and includes CCL-only plus OpenMPI-assisted Broadcast example programs covering out-of-place, in-place, and legacy broadcast flows with correctness and communication-bandwidth reporting.

Changes

• Public API and Dispatch

  • Enable the existing infinicclBroadcast() and infinicclBcast() APIs for configured CCL backends through generated bridge dispatch.
  • Redispatch Broadcast according to the initialized backend and device stored in the supplied communicator.
  • Keep bootstrap broadcasts on the communicator's initialized MPI backend in mixed MPI and CCL configurations.

• Common CCL Implementation

  • Add a shared CCL Broadcast implementation following the existing provider-oriented AllReduce structure.
  • Validate the CCL communicator instance and map InfiniCCL data types through the configured provider before dispatch.
  • Return NotSupported when the selected provider cannot represent the requested data type.

• Existing CCL Provider Bindings

  • Extend the existing NCCL and MCCL API wrappers with thin bindings to ncclBroadcast() and mcclBroadcast().
  • Register Broadcast and the legacy in-place Bcast alias with the existing NCCL and MCCL provider layers.

• Bridge Generation

  • Track base, backend, and device headers as generated bridge dependencies.
  • Regenerate the bridge when a header-only operation implementation is added, removed, or changed.

• Examples and Validation

  • Add a thread-per-GPU single-node CCL Broadcast example.
  • Add an OpenMPI-assisted CCL Broadcast example that uses OpenMPI for rank discovery and unique-ID broadcast, then initializes a native CCL communicator for GPU data broadcast.
  • Validate out-of-place Broadcast, in-place Broadcast, and legacy in-place Bcast with the last GPU rank as root.
  • Propagate validation failures through the process exit status and reset buffers independently for every scenario.
  • Parse numeric options without exceptions and validate host-name discovery in the CCL-only example.
  • Report payload size, average time, algorithm bandwidth as count * type_size / time, and bus bandwidth with the Broadcast correction factor of 1 for every scenario.

Platform and Backend Affected

Platform

• CPU
• NVIDIA GPU
• Iluvatar GPU
• MetaX GPU
• Moore Threads GPU
• Cambricon MLU
• HYGON DCU

Backend

• OpenMPI
• MPICH
• NCCL
• MCCL

Performance Impact

• No performance impact
• Performance improved
• Performance regression possible

This adds a GPU-native CCL path for Broadcast, avoiding the existing MPI host-staging path when a supported CCL backend is selected. Existing MPI collectives are intended to remain unchanged.

Known Issues & Future Work

• CCL collective support now covers AllReduce, Broadcast, and the legacy Bcast alias; other CCL collective operations remain future work.
• Broadcast inherits the backend/device combinations and data type support of the existing CCL providers; this PR does not add a new provider or device integration.
• The server examples validate Float32 payloads with the last rank as root on the default stream. Additional data types, roots, non-default streams, and runtime coverage on Iluvatar and Moore Threads remain future work.

Test Results

The tested head is 7c6d61b2670a709597b0ba1a72de9e829bdc1659. Its four focused commits are rebased linearly on ef4045a2d99837c75c2acd90aae57dacb83172d2. The current-commit evidence contains exactly 15 canonical logs: all 15 targets passed on the full matrix. All 23 expected validation outcomes are positive with no negative result; in the pure-NCCL log, one asynchronous NCCL INFO line split the first Correct: label from its immediately following YES token, while the target and runner both exited successfully.

Every Broadcast scenario used 1,048,576 Float32 elements (4.00 MiB), 2 warm-up iterations, and 20 profiled iterations. The three values in each cell are out-of-place / in-place / legacy Bcast:

Path	Test topology	Time	Alg BW	Bus BW
Pure NCCL	8 NVIDIA A100 GPUs	1.921 / 2.161 / 0.853 ms	2.18 / 1.94 / 4.92 GB/s	2.18 / 1.94 / 4.92 GB/s
OpenMPI + NCCL hybrid	8 NVIDIA A100 GPUs	0.054 / 0.380 / 0.963 ms	77.26 / 11.04 / 4.35 GB/s	77.26 / 11.04 / 4.35 GB/s
Heterogeneous OpenMPI	8 NVIDIA A100 + 8 MetaX C550 GPUs	3.596 / 3.153 / 3.152 ms	1.17 / 1.33 / 1.33 GB/s	1.17 / 1.33 / 1.33 GB/s
Pure MCCL	8 MetaX C550 GPUs	0.378 / 0.444 / 0.459 ms	11.10 / 9.45 / 9.14 GB/s	11.10 / 9.45 / 9.14 GB/s

Algorithm bandwidth uses count * sizeof(float) / time; Broadcast bus bandwidth uses a correction factor of 1, so it equals algorithm bandwidth. Values were independently checked against the three-decimal displayed time and are execution evidence, not a cross-platform benchmark comparison.

• The pure NCCL and OpenMPI+NCCL configurations each passed both selected targets, 2/2, on all 8 A100 GPUs.
• The heterogeneous OpenMPI configuration passed all 9 MPI targets on 16 ranks, mapping ranks 0-7 to NVIDIA devices 0-7 and ranks 8-15 to MetaX devices 0-7.
• The pure MCCL configuration passed both selected targets on all 8 MetaX C550 GPUs, mapping ranks 0-7 to devices 0-7.
• All five formal runner invocations returned zero. There were no harness retries, MetaX vendor queue retries, timeouts, missing canonical logs, or finalization errors.

Test Involved Platform

• CPU
• NVIDIA GPU
• Iluvatar GPU
• MetaX GPU
• Moore Threads GPU
• Cambricon MLU
• HYGON DCU

Test Involved Backend

• OpenMPI
• MPICH
• NCCL
• MCCL

Pure CCL (NCCL) on single-node NVIDIA:
ccl_all_reduce.log
ccl_broadcast.log

CCL + MPI on single-node NVIDIA:
ccl_mpi_hybrid_all_reduce.log
ccl_mpi_hybrid_broadcast.log

MPI on Heterogeneous Cluster:
mpi_all_gather.log
mpi_all_reduce.log
mpi_all_to_all.log
mpi_broadcast.log
mpi_gather.log
mpi_reduce.log
mpi_reduce_scatter.log
mpi_scatter.log
mpi_send_recv.log

Pure CCL (MCCL) on single-node MetaX:
ccl_all_reduce.log
ccl_broadcast.log

---

Checklist

Every contributor must verify every item below before requesting
review. Tick each box only after the check has actually been performed —
do not tick speculatively. If an item truly does not apply, replace the
checkbox with N/A and briefly explain why in an inline comment.

Title, Branch, and Commits

• PR title follows Conventional Commits (e.g. feat: …, fix(nccl): …).
• Branch name follows <type>/xxx-yyyy-zzzz where <type> matches the PR title's Conventional Commits type and words are joined with hyphens (see CONTRIBUTING.md §Branches).
• Each commit message follows Conventional Commits.
• Small PR is a single squashable commit; or, for a large PR, every commit is meaningful, well-formed, and independently reviewable (see CONTRIBUTING.md §Pull Requests).
• No stray merge commits from master — the branch is rebased cleanly on top of the current master.
• No fixup! / squash! / wip commits remain.

Scope and Design

• Changes are minimal — no unrelated modifications were introduced (CONTRIBUTING.md §Code/General).
• No dead code, commented-out blocks, debug prints, printf/std::cout/print(...) left behind, or TODO without an owner and issue link.
• No unrelated formatting churn that would obscure the diff.
• Public API changes (if any) are intentional, documented, and reflected in affected callers/tests.

General Code Hygiene

• The code is self-explanatory; comments were added only where the intent or rationale is non-obvious (CONTRIBUTING.md §Code/General).
• Every modified or added file ends with a single trailing newline (CONTRIBUTING.md §Code/General).
• No trailing whitespace, inconsistent indentation, or mixed formatting styles remain.
• Identifiers referenced in comments or error messages are wrapped in Markdown backticks (e.g. the `AllReduce` implementation) (CONTRIBUTING.md §Code/General).
• All comments and error messages are in English (CONTRIBUTING.md §Code/General).
• Comments and error messages are complete sentences — capitalized first letter, terminal punctuation — unless the language/framework convention says otherwise (CONTRIBUTING.md §Code/General; §Python).

C++ Specific (if C++ files changed)

• Code follows the Google C++ Style Guide strictly.
• clang-format (version 16, per .github/workflows/clang-format.yml) has been run against all modified applicable files; the diff is clean.
• No exceptions are thrown. Error paths use assert with messages that include at least __FILE__, __LINE__, and __func__ (CONTRIBUTING.md §C++).
• Error and warning message wording follows the LLVM Coding Standards (CONTRIBUTING.md §C++).
• N/A- Constructor initializer list order matches member declaration order (CONTRIBUTING.md §C++).
• Exactly one blank line between classes, between classes and functions, and between functions (CONTRIBUTING.md §C++).
• Exactly one blank line between members (functions and variables) within a class (CONTRIBUTING.md §C++).
• Exactly one blank line before and after the contents of a namespace (CONTRIBUTING.md §C++).

Python Specific (if Python files changed)

• N/A- Code is PEP 8 compliant; ruff check passes cleanly on CI (see `.github/workflows/ruff.yml).
• N/A- ruff format --check passes cleanly — if not, run ruff format and commit the result.
• N/A- Comments are complete English sentences, starting with a capital letter and ending with punctuation; Markdown backticks are used for code references (CONTRIBUTING.md §Python).
• N/A- Framework-specific conventions (e.g. lowercase pytest.skip messages without terminal period) are honored where applicable (CONTRIBUTING.md §Python).
• N/A- No blank line between the function signature and the body when there is no docstring or comment (CONTRIBUTING.md §Python).
• N/A- A blank line is present before and after if, for, and similar control-flow statements (CONTRIBUTING.md §Python).
• N/A- A blank line appears before each return, except when it directly follows a control-flow statement (CONTRIBUTING.md §Python).
• N/A- Docstrings (if any) follow PEP 257 (CONTRIBUTING.md §Python).
• N/A- Type hints are added / kept consistent with the surrounding code.

Testing

• All applicable example programs have been built and tested successfully on at least one supported heterogeneous cluster setup.

Build, CI, and Tooling

• N/A- New backends or devices have been added to auto-detection in CMakeLists.txt under if(AUTO_DETECT_DEVICES) or to if(AUTO_DETECT_BACKENDS) if applicable.
• Both CI workflows (clang-format.yml, ruff.yml) are green locally (or expected to be green on CI).

Documentation

• N/A- README.md, CONTRIBUTING.md, or inline docs updated when behavior, build flags, or developer workflow changed.
• N/A- Any user-visible breaking change is called out explicitly under "Summary" and in the commit/PR title with a ! or BREAKING CHANGE: footer.

Security and Safety

• No secrets, access tokens, internal URLs, customer data, or personal hardware identifiers have been committed.
• N/A- Third-party code is license-compatible and attributed.
• No unsafe pointer arithmetic, uninitialized reads, or missing bounds checks were introduced.