[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill-nvidia-nvshmem-get-started":3,"mdc--4cijuh-key":36,"related-repo-nvidia-nvshmem-get-started":1426,"related-org-nvidia-nvshmem-get-started":1509},{"slug":4,"name":4,"fn":5,"description":6,"org":7,"tags":11,"stars":20,"repoUrl":21,"updatedAt":22,"license":23,"forks":24,"topics":25,"repo":31,"sourceUrl":34,"mdContent":35},"nvshmem-get-started","onboard developers to NVSHMEM","Guide NVSHMEM beginners through fit assessment, mental models, first C\u002FC++ or Python NVSHMEM programs, compilation, launching, and next steps. Use for onboarding.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":9},"nvidia","NVIDIA","https:\u002F\u002Fpexgzepcugksgbtrxkhf.supabase.co\u002Fstorage\u002Fv1\u002Fobject\u002Fpublic\u002Forg-logos\u002Fnvidia.png",[12,16,19],{"name":13,"slug":14,"type":15},"Onboarding","onboarding","tag",{"name":17,"slug":18,"type":15},"Documentation","documentation",{"name":9,"slug":8,"type":15},579,"https:\u002F\u002Fgithub.com\u002FNVIDIA\u002Fnvshmem","2026-08-31T09:18:55.48573","Apache-2.0",104,[26,27,28,29,8,30],"communciations","cpp","cuda","deep-learning","python",{"repoUrl":21,"stars":20,"forks":24,"topics":32,"description":33},[26,27,28,29,8,30],"NVIDIA NVSHMEM is a parallel programming interface for NVIDIA GPUs based on OpenSHMEM. NVSHMEM can significantly reduce multi-process communication and coordination overheads by allowing programmers to perform one-sided communication from within CUDA kernels and on CUDA streams.","https:\u002F\u002Fgithub.com\u002FNVIDIA\u002Fnvshmem\u002Ftree\u002FHEAD\u002Fskills\u002Fnvshmem-get-started","---\nname: nvshmem-get-started\ndescription: Guide NVSHMEM beginners through fit assessment, mental models, first C\u002FC++ or Python NVSHMEM programs, compilation, launching, and next steps. Use for onboarding.\nlicense: Apache-2.0\nmetadata:\n  author: NVIDIA NVSHMEM Team \u003Cnvshmem@nvidia.com>\n  tags:\n    - nvshmem\n    - getting-started\n    - tutorial\n---\n\n# Getting Started with NVSHMEM\n\n## Purpose\n\nGuide a beginner to the next useful action. Teach the stable mental model, program structure, build pattern, and launch pattern directly. Route installation, version-sensitive variants, advanced integrations, and failures to the appropriate specialist skill.\n\n## Prerequisites\n\n- Require no credentials, installed software, or GPU access for fit assessment and conceptual guidance.\n- Keep the bundled [mental model](references\u002Fmental-model.md), [basic API calls](references\u002Fbasic-api-calls.md), and [NVSHMEM4Py program guide](references\u002Fnvshmem4py-programs.md) available for the teaching paths that require them.\n- Keep `$nvshmem-install`, `$nvshmem-docs`, and `$nvshmem-troubleshoot-and-report-bugs` available for complete installation, version-specific, and failure handoffs. If a specialist skill is unavailable, follow the documented fallback instead of inventing current details.\n\n## Inputs\n\n- **Required:** Obtain the user's goal or requested learning stage from the explicit user prompt.\n- **Optional:** Obtain application communication needs, language, NVSHMEM and NVSHMEM4Py versions, source or script path, Python interpreter\u002Fenvironment, installation prefix, target GPU architecture, launcher, PE and node counts, and target environment only when the selected path needs them.\n- **Source precedence:** Prefer the current explicit user prompt, then explicit invocation arguments, then non-conflicting agent context, then answers to focused follow-up questions. Report conflicting values instead of choosing silently.\n\n## Instructions\n\n### Execution Boundary\n\nDefault to explaining the workflow and printing commands for the user to run. Do not compile, launch a program, submit a scheduler job, allocate resources, or modify the environment unless the user explicitly asks for execution. Treat requests to learn, get started, or receive help running a program as requests for guidance, not execution approval.\n\n### Choose a Starting Point\n\nWhen the requested stage is clear, skip the menu and handle that stage. Otherwise ask what the user wants to do and present all options in one response:\n\n1. Decide whether NVSHMEM fits my use case.\n2. Learn the NVSHMEM mental model.\n3. Install NVSHMEM.\n4. Run a precompiled NVSHMEM example.\n5. Compile or link a C\u002FC++ application.\n6. Write an NVSHMEM C\u002FC++ or NVSHMEM4Py program.\n7. Recommend the next step.\n\nFor option 7, first determine whether NVSHMEM fits the intended communication pattern. Then ask whether NVSHMEM is installed, whether an example has run successfully, and whether source code already exists. Recommend the mental model when the user is completely new, installation when NVSHMEM is absent, a precompiled example after installation, program design when no source exists, and compilation when source is ready.\n\n### Decide When to Use NVSHMEM\n\nStart from the application's communication needs rather than from a list of APIs. Describe NVSHMEM as a strong fit when several of these conditions apply:\n\n- GPU threads should initiate communication directly from CUDA kernels without returning control to the CPU for every exchange.\n- The application needs fine-grained, one-sided put, get, atomic, signaling, or synchronization operations between GPUs.\n- Long-running or fused kernels should combine computation and communication while reducing kernel-launch and CPU-GPU synchronization overhead.\n- Communication should overlap with computation to improve strong scaling as the amount of work per GPU becomes smaller.\n- A partitioned global address space with collectively allocated symmetric GPU memory fits the application's data layout.\n- The application already uses OpenSHMEM concepts or needs NVSHMEM alongside MPI or OpenSHMEM for GPU-resident communication.\n\nGive representative workload patterns without claiming that NVSHMEM is mandatory for them:\n\n- neighbor or halo exchanges in multi-GPU stencils, solvers, and simulations;\n- irregular or fine-grained communication in graph and data-analytics workloads;\n- persistent GPU kernels that communicate repeatedly during computation;\n- custom GPU-initiated reductions, broadcasts, queues, and producer-consumer protocols;\n- applications whose strong scaling is limited by repeated CPU orchestration of GPU communication.\n\nExplain when another model may be simpler:\n\n- Use ordinary CUDA for a single GPU or when no inter-GPU communication is required.\n- Prefer NCCL when the application primarily makes standard bulk-collective calls—especially host-issued all-reduce, all-gather, reduce-scatter, or broadcast operations. NCCL is generally better suited than NVSHMEM for this pattern.\n- Prefer MPI when communication is coarse-grained, CPU-driven send and receive is sufficient, or symmetric allocation would complicate the design.\n- Reconsider NVSHMEM when the target cannot provide the required GPU, launcher, bootstrap, or transport environment.\n\nAsk where communication is initiated, whether it is fine- or coarse-grained, which operations dominate, whether communication must occur inside kernels, and what GPU\u002Fnode topology is targeted. Conclude with one of `strong fit`, `possible fit`, or `likely simpler with another model`, and explain the deciding factors. Link to the official [NVSHMEM Introduction and Advantages](https:\u002F\u002Fdocs.nvidia.com\u002Fnvshmem\u002Fapi\u002Flatest\u002Fintroduction.html#advantages-of-nvshmem).\n\n### Teach the Mental Model\n\nRead [references\u002Fmental-model.md](references\u002Fmental-model.md) completely before teaching the conceptual path. Explain the mental model without API-name clutter and use its illustrative ring shift when a concrete example would help. Before introducing C\u002FC++ primitives, read [references\u002Fbasic-api-calls.md](references\u002Fbasic-api-calls.md) completely and present only the API groups relevant to the user's goal. For a Python request, also read [references\u002Fnvshmem4py-programs.md](references\u002Fnvshmem4py-programs.md) before outlining the program lifecycle or launch workflow. Keep examples framed as teaching aids rather than environment-specific recipes.\n\n### Resolve the Hands-On Path\n\nCollect only the context required by the selected path. Do not ask for every environment detail up front.\n\n#### Install NVSHMEM\n\nBefore invoking `$nvshmem-install`, follow this intake order: resolve the requested version or `latest`, ask whether the user needs C\u002FC++, Python, or both, then at step 3 ask whether the user is an administrator on the target system with root or `sudo` rights. On a managed cluster, also ask whether the user is authorized to change the compute-node image or shared software stack. Do not infer either answer from shell access, package-manager availability, or target type.\n\nInvoke `$nvshmem-install`. Pass the administrator and target-scope authority status together with the requested API or language, target environment, preferred install method, version policy, and whether the user needs runtime files, development headers and libraries, or static linking. For an unprivileged cluster user, do not frame DEB, RPM, APT, DNF, YUM, or another system package path as directly usable; prefer a site module, approved container, compatible user-owned prefix, or a clearly labeled administrator handoff.\n\n#### Design a C\u002FC++ Program\n\nRead [references\u002Fbasic-api-calls.md](references\u002Fbasic-api-calls.md) before explaining API-family choices or recommending specific primitives.\n\nTeach this stable structure directly:\n\n1. Choose initialization. Use `nvshmem_init` for the basic standalone pattern. Use `nvshmemx_init_attr` when the application must integrate an MPI, OpenSHMEM, or other bootstrap context.\n2. Initialize, query a node-local PE ID, and select the CUDA device before allocating symmetric memory or launching kernels.\n3. Allocate symmetric objects collectively. Require every PE to call allocation and deallocation routines in matching order with identical arguments.\n4. Choose the operation family:\n   - Use put or get for remote data movement.\n   - Use atomics for remote updates.\n   - Use signals and waits for point-to-point coordination.\n   - Use team collectives for group communication.\n5. Choose the invocation context: host API, device API inside a kernel, or on-stream API composed with CUDA stream work.\n6. Identify remote data with a symmetric address and destination PE. Never send a symmetric pointer value to another PE for it to reuse as a local pointer.\n7. Add the required ordering and completion. Use `nvshmem_fence` to order later operations after earlier operations to the same PE, `nvshmem_quiet` or its on-stream form for completion, and barriers, signals and waits, or collectives to coordinate PEs.\n8. Free symmetric allocations collectively and finalize.\n\nUse the ring-shift example in [references\u002Fmental-model.md](references\u002Fmental-model.md) as the first concrete illustration; read that reference before presenting the example.\n\n#### Design or Run an NVSHMEM4Py Program\n\nRead [references\u002Fnvshmem4py-programs.md](references\u002Fnvshmem4py-programs.md) completely. Ask only for the Python script path, Python interpreter or environment, NVSHMEM4Py version if known, initialization choice (standalone or MPI), launcher, PE and node counts, and whether the run is local or scheduled.\n\nTeach the same PE, symmetric-memory, one-sided-operation, and completion model as C\u002FC++, then map it to the Python lifecycle: choose and set the local CUDA device, initialize NVSHMEM4Py, collectively create symmetric arrays, perform the required communication and synchronization, free every symmetric array collectively, and finalize. Do not present C\u002FC++ API names as Python APIs.\n\nInvoke `$nvshmem-docs` with the requested NVSHMEM version or `latest` before giving Python API names, a runnable code sample, package-version compatibility, framework interoperability, initialization arguments, or exact launch commands. Pass the script path and all known Python, launcher, PE, node, and environment details. Use the documentation result to give a version-matched, user-runnable command shape. Confirm that the selected Python environment, the script, CUDA, NVSHMEM runtime libraries, and the NVSHMEM4Py package are available on every participating node.\n\nWhen the user supplies a simple NVSHMEM4Py script, use the example in [references\u002Fnvshmem4py-programs.md](references\u002Fnvshmem4py-programs.md) to trace its device selection, initialization, symmetric allocation, communication, stream completion, collective cleanup, and launch requirements. Identify missing lifecycle steps or a mismatch between the script's initialization and launcher; do not execute or rewrite the script unless requested.\n\nStart with two PEs on one node and one PE per GPU by default. Require the launcher to propagate the selected Python environment and CUDA\u002FNVSHMEM environment to every PE. Explain the expected per-PE output and validate the small run before suggesting a larger or multi-node run.\n\n#### Compile and Link C\u002FC++\n\nAsk for the source path, NVSHMEM installation prefix, target GPU architecture, and whether the project uses a direct `nvcc` command or CMake. For a standard CUDA source file, explain that the application must enable relocatable device code, include the NVSHMEM headers, search the installed library directory, and link both the host and device libraries.\n\nProvide this command shape after replacing or clearly labeling its variables:\n\n```bash\nnvcc -rdc=true \\\n  -ccbin g++ \\\n  -gencode=\"$NVCC_GENCODE\" \\\n  -I\"$NVSHMEM_HOME\u002Finclude\" \\\n  application.cu \\\n  -L\"$NVSHMEM_HOME\u002Flib\" \\\n  -lnvshmem_host -lnvshmem_device \\\n  -o application\n```\n\nExplain that `NVSHMEM_HOME` names the installed prefix and `NVCC_GENCODE` must select the target GPU architecture. For CMake, prefer the config files installed with NVSHMEM and use `find_package` in config mode; inspect the installed package before naming an imported target.\n\n#### Run a Precompiled Program\n\nAsk for the executable path, launcher, PE and node counts, and whether the run is local or scheduled. Confirm that the executable and NVSHMEM runtime libraries are visible on every participating node.\n\nStart with two PEs on one node, use one PE per GPU by default, and expand only after the small run succeeds. Present the command shape that matches the available launcher:\n\n```bash\nmpirun -n \u003Cnumber-of-pes> \u003Cprogram> [arguments]\n```\n\n```bash\nsrun -n \u003Cnumber-of-pes> \u003Cprogram> [arguments]\n```\n\n```bash\nnvshmrun -n \u003Cnumber-of-pes> \u003Cprogram> [arguments]\n```\n\nRequire the launcher to propagate the CUDA and NVSHMEM environment to every PE. Explain the expected per-PE output and verify it before recommending a larger or multi-node run.\n\n#### Invoke Documentation Only for Variants\n\nInvoke `$nvshmem-docs` with a complete requested version or `latest` when the request needs any of the following:\n\n- exact package-specific example paths or binary names;\n- PMI, PMI-2, PMIx, Hydra installation, or non-default bootstrap wiring;\n- multi-node transport setup or transport-specific link dependencies;\n- static linking, shared-library composition, symbol visibility, or non-`nvcc` toolchains;\n- exact CMake package or imported-target names;\n- release-specific API availability, flags, requirements, limitations, or commands.\n\n## Limitations\n\n- Provide introductory guidance, not exhaustive API, installation, launcher, transport, or performance coverage.\n- Treat command blocks as adaptable shapes. Do not claim that they match an installed release, package layout, cluster policy, or target architecture without version-specific documentation and target inspection.\n- Cover first-program and launch guidance for C\u002FC++ CUDA and NVSHMEM4Py. Route Python API details, installation, and version compatibility to `$nvshmem-docs` rather than inferring them.\n- Assess architectural fit from the stated communication pattern; do not promise a speedup without representative measurements on the target topology.\n- Keep execution outside the default scope. A request for explanation, onboarding, or help running a program does not authorize environment changes or workload execution.\n\n## Troubleshooting\n\n| Symptom | Likely cause class | Response |\n| --- | --- | --- |\n| Compilation or linking fails | Source, flags, library order, package layout, or version mismatch | Invoke `$nvshmem-troubleshoot-and-report-bugs` with the full command and diagnostics. |\n| A program errors or hangs | Launcher, bootstrap, transport, topology, runtime configuration, or program behavior | Invoke `$nvshmem-troubleshoot-and-report-bugs` with the complete launch stanza and output from every PE. |\n| A specialist skill is unavailable | The normal diagnostic or version-specific route cannot be used | Invoke `$nvshmem-docs` for version-matched troubleshooting, FAQ, and support routes; do not invent a workaround. |\n\nFor an execution failure, pass or collect the complete command or batch-script launch stanza and complete stdout and stderr from every PE, including output before the first error and per-PE logs. For a compile or link failure, pass or collect the complete compiler or linker command, full diagnostic output, undefined symbols, and library order. In both cases, include the NVSHMEM version, relevant CUDA and launcher versions, and target environment details when available.\n\nKeep installation and program-writing requests on their normal routes unless the user explicitly reports a failure in one of the two stages above.\n\n## Examples\n\nFit assessment:\n\n```text\nUse $nvshmem-get-started to assess whether a multi-GPU stencil with GPU-resident halo exchanges is a strong NVSHMEM fit or is simpler with MPI.\n```\n\nAsk only for communication facts that affect the decision, then conclude with `strong fit`, `possible fit`, or `likely simpler with another model` and explain the deciding factors.\n\nFirst-program guidance:\n\n```text\nUse $nvshmem-get-started to help me design, compile, and launch my first C++ NVSHMEM ring program without executing anything.\n```\n\nTeach the mental model before concrete primitives, present adaptable compile and launch shapes, and keep execution outside scope unless the user separately requests it.\n\nNVSHMEM4Py first-run guidance:\n\n```text\nUse $nvshmem-get-started to help me run my first NVSHMEM4Py program with two GPUs, without executing anything.\n```\n\nRead the NVSHMEM4Py program guide, collect the Python environment and launcher context, obtain current version-matched Python API and launch details from `$nvshmem-docs`, and provide a user-runnable small-run plan.\n",{"data":37,"body":44},{"name":4,"description":6,"license":23,"metadata":38},{"author":39,"tags":40},"NVIDIA NVSHMEM Team \u003Cnvshmem@nvidia.com>",[41,42,43],"nvshmem","getting-started","tutorial",{"type":45,"children":46},"root",[47,56,63,69,75,143,149,183,189,196,201,207,212,251,256,262,267,300,305,333,338,361,399,405,428,434,439,446,474,486,492,502,507,605,616,622,632,637,655,666,671,677,690,695,881,910,916,921,926,989,1044,1099,1104,1110,1128,1168,1174,1209,1215,1320,1325,1330,1336,1341,1351,1375,1380,1389,1394,1399,1408,1420],{"type":48,"tag":49,"props":50,"children":52},"element","h1",{"id":51},"getting-started-with-nvshmem",[53],{"type":54,"value":55},"text","Getting Started with NVSHMEM",{"type":48,"tag":57,"props":58,"children":60},"h2",{"id":59},"purpose",[61],{"type":54,"value":62},"Purpose",{"type":48,"tag":64,"props":65,"children":66},"p",{},[67],{"type":54,"value":68},"Guide a beginner to the next useful action. Teach the stable mental model, program structure, build pattern, and launch pattern directly. Route installation, version-sensitive variants, advanced integrations, and failures to the appropriate specialist skill.",{"type":48,"tag":57,"props":70,"children":72},{"id":71},"prerequisites",[73],{"type":54,"value":74},"Prerequisites",{"type":48,"tag":76,"props":77,"children":78},"ul",{},[79,85,115],{"type":48,"tag":80,"props":81,"children":82},"li",{},[83],{"type":54,"value":84},"Require no credentials, installed software, or GPU access for fit assessment and conceptual guidance.",{"type":48,"tag":80,"props":86,"children":87},{},[88,90,97,99,105,107,113],{"type":54,"value":89},"Keep the bundled ",{"type":48,"tag":91,"props":92,"children":94},"a",{"href":93},"references\u002Fmental-model.md",[95],{"type":54,"value":96},"mental model",{"type":54,"value":98},", ",{"type":48,"tag":91,"props":100,"children":102},{"href":101},"references\u002Fbasic-api-calls.md",[103],{"type":54,"value":104},"basic API calls",{"type":54,"value":106},", and ",{"type":48,"tag":91,"props":108,"children":110},{"href":109},"references\u002Fnvshmem4py-programs.md",[111],{"type":54,"value":112},"NVSHMEM4Py program guide",{"type":54,"value":114}," available for the teaching paths that require them.",{"type":48,"tag":80,"props":116,"children":117},{},[118,120,127,128,134,135,141],{"type":54,"value":119},"Keep ",{"type":48,"tag":121,"props":122,"children":124},"code",{"className":123},[],[125],{"type":54,"value":126},"$nvshmem-install",{"type":54,"value":98},{"type":48,"tag":121,"props":129,"children":131},{"className":130},[],[132],{"type":54,"value":133},"$nvshmem-docs",{"type":54,"value":106},{"type":48,"tag":121,"props":136,"children":138},{"className":137},[],[139],{"type":54,"value":140},"$nvshmem-troubleshoot-and-report-bugs",{"type":54,"value":142}," available for complete installation, version-specific, and failure handoffs. If a specialist skill is unavailable, follow the documented fallback instead of inventing current details.",{"type":48,"tag":57,"props":144,"children":146},{"id":145},"inputs",[147],{"type":54,"value":148},"Inputs",{"type":48,"tag":76,"props":150,"children":151},{},[152,163,173],{"type":48,"tag":80,"props":153,"children":154},{},[155,161],{"type":48,"tag":156,"props":157,"children":158},"strong",{},[159],{"type":54,"value":160},"Required:",{"type":54,"value":162}," Obtain the user's goal or requested learning stage from the explicit user prompt.",{"type":48,"tag":80,"props":164,"children":165},{},[166,171],{"type":48,"tag":156,"props":167,"children":168},{},[169],{"type":54,"value":170},"Optional:",{"type":54,"value":172}," Obtain application communication needs, language, NVSHMEM and NVSHMEM4Py versions, source or script path, Python interpreter\u002Fenvironment, installation prefix, target GPU architecture, launcher, PE and node counts, and target environment only when the selected path needs them.",{"type":48,"tag":80,"props":174,"children":175},{},[176,181],{"type":48,"tag":156,"props":177,"children":178},{},[179],{"type":54,"value":180},"Source precedence:",{"type":54,"value":182}," Prefer the current explicit user prompt, then explicit invocation arguments, then non-conflicting agent context, then answers to focused follow-up questions. Report conflicting values instead of choosing silently.",{"type":48,"tag":57,"props":184,"children":186},{"id":185},"instructions",[187],{"type":54,"value":188},"Instructions",{"type":48,"tag":190,"props":191,"children":193},"h3",{"id":192},"execution-boundary",[194],{"type":54,"value":195},"Execution Boundary",{"type":48,"tag":64,"props":197,"children":198},{},[199],{"type":54,"value":200},"Default to explaining the workflow and printing commands for the user to run. Do not compile, launch a program, submit a scheduler job, allocate resources, or modify the environment unless the user explicitly asks for execution. Treat requests to learn, get started, or receive help running a program as requests for guidance, not execution approval.",{"type":48,"tag":190,"props":202,"children":204},{"id":203},"choose-a-starting-point",[205],{"type":54,"value":206},"Choose a Starting Point",{"type":48,"tag":64,"props":208,"children":209},{},[210],{"type":54,"value":211},"When the requested stage is clear, skip the menu and handle that stage. Otherwise ask what the user wants to do and present all options in one response:",{"type":48,"tag":213,"props":214,"children":215},"ol",{},[216,221,226,231,236,241,246],{"type":48,"tag":80,"props":217,"children":218},{},[219],{"type":54,"value":220},"Decide whether NVSHMEM fits my use case.",{"type":48,"tag":80,"props":222,"children":223},{},[224],{"type":54,"value":225},"Learn the NVSHMEM mental model.",{"type":48,"tag":80,"props":227,"children":228},{},[229],{"type":54,"value":230},"Install NVSHMEM.",{"type":48,"tag":80,"props":232,"children":233},{},[234],{"type":54,"value":235},"Run a precompiled NVSHMEM example.",{"type":48,"tag":80,"props":237,"children":238},{},[239],{"type":54,"value":240},"Compile or link a C\u002FC++ application.",{"type":48,"tag":80,"props":242,"children":243},{},[244],{"type":54,"value":245},"Write an NVSHMEM C\u002FC++ or NVSHMEM4Py program.",{"type":48,"tag":80,"props":247,"children":248},{},[249],{"type":54,"value":250},"Recommend the next step.",{"type":48,"tag":64,"props":252,"children":253},{},[254],{"type":54,"value":255},"For option 7, first determine whether NVSHMEM fits the intended communication pattern. Then ask whether NVSHMEM is installed, whether an example has run successfully, and whether source code already exists. Recommend the mental model when the user is completely new, installation when NVSHMEM is absent, a precompiled example after installation, program design when no source exists, and compilation when source is ready.",{"type":48,"tag":190,"props":257,"children":259},{"id":258},"decide-when-to-use-nvshmem",[260],{"type":54,"value":261},"Decide When to Use NVSHMEM",{"type":48,"tag":64,"props":263,"children":264},{},[265],{"type":54,"value":266},"Start from the application's communication needs rather than from a list of APIs. Describe NVSHMEM as a strong fit when several of these conditions apply:",{"type":48,"tag":76,"props":268,"children":269},{},[270,275,280,285,290,295],{"type":48,"tag":80,"props":271,"children":272},{},[273],{"type":54,"value":274},"GPU threads should initiate communication directly from CUDA kernels without returning control to the CPU for every exchange.",{"type":48,"tag":80,"props":276,"children":277},{},[278],{"type":54,"value":279},"The application needs fine-grained, one-sided put, get, atomic, signaling, or synchronization operations between GPUs.",{"type":48,"tag":80,"props":281,"children":282},{},[283],{"type":54,"value":284},"Long-running or fused kernels should combine computation and communication while reducing kernel-launch and CPU-GPU synchronization overhead.",{"type":48,"tag":80,"props":286,"children":287},{},[288],{"type":54,"value":289},"Communication should overlap with computation to improve strong scaling as the amount of work per GPU becomes smaller.",{"type":48,"tag":80,"props":291,"children":292},{},[293],{"type":54,"value":294},"A partitioned global address space with collectively allocated symmetric GPU memory fits the application's data layout.",{"type":48,"tag":80,"props":296,"children":297},{},[298],{"type":54,"value":299},"The application already uses OpenSHMEM concepts or needs NVSHMEM alongside MPI or OpenSHMEM for GPU-resident communication.",{"type":48,"tag":64,"props":301,"children":302},{},[303],{"type":54,"value":304},"Give representative workload patterns without claiming that NVSHMEM is mandatory for them:",{"type":48,"tag":76,"props":306,"children":307},{},[308,313,318,323,328],{"type":48,"tag":80,"props":309,"children":310},{},[311],{"type":54,"value":312},"neighbor or halo exchanges in multi-GPU stencils, solvers, and simulations;",{"type":48,"tag":80,"props":314,"children":315},{},[316],{"type":54,"value":317},"irregular or fine-grained communication in graph and data-analytics workloads;",{"type":48,"tag":80,"props":319,"children":320},{},[321],{"type":54,"value":322},"persistent GPU kernels that communicate repeatedly during computation;",{"type":48,"tag":80,"props":324,"children":325},{},[326],{"type":54,"value":327},"custom GPU-initiated reductions, broadcasts, queues, and producer-consumer protocols;",{"type":48,"tag":80,"props":329,"children":330},{},[331],{"type":54,"value":332},"applications whose strong scaling is limited by repeated CPU orchestration of GPU communication.",{"type":48,"tag":64,"props":334,"children":335},{},[336],{"type":54,"value":337},"Explain when another model may be simpler:",{"type":48,"tag":76,"props":339,"children":340},{},[341,346,351,356],{"type":48,"tag":80,"props":342,"children":343},{},[344],{"type":54,"value":345},"Use ordinary CUDA for a single GPU or when no inter-GPU communication is required.",{"type":48,"tag":80,"props":347,"children":348},{},[349],{"type":54,"value":350},"Prefer NCCL when the application primarily makes standard bulk-collective calls—especially host-issued all-reduce, all-gather, reduce-scatter, or broadcast operations. NCCL is generally better suited than NVSHMEM for this pattern.",{"type":48,"tag":80,"props":352,"children":353},{},[354],{"type":54,"value":355},"Prefer MPI when communication is coarse-grained, CPU-driven send and receive is sufficient, or symmetric allocation would complicate the design.",{"type":48,"tag":80,"props":357,"children":358},{},[359],{"type":54,"value":360},"Reconsider NVSHMEM when the target cannot provide the required GPU, launcher, bootstrap, or transport environment.",{"type":48,"tag":64,"props":362,"children":363},{},[364,366,372,373,379,381,387,389,397],{"type":54,"value":365},"Ask where communication is initiated, whether it is fine- or coarse-grained, which operations dominate, whether communication must occur inside kernels, and what GPU\u002Fnode topology is targeted. Conclude with one of ",{"type":48,"tag":121,"props":367,"children":369},{"className":368},[],[370],{"type":54,"value":371},"strong fit",{"type":54,"value":98},{"type":48,"tag":121,"props":374,"children":376},{"className":375},[],[377],{"type":54,"value":378},"possible fit",{"type":54,"value":380},", or ",{"type":48,"tag":121,"props":382,"children":384},{"className":383},[],[385],{"type":54,"value":386},"likely simpler with another model",{"type":54,"value":388},", and explain the deciding factors. Link to the official ",{"type":48,"tag":91,"props":390,"children":394},{"href":391,"rel":392},"https:\u002F\u002Fdocs.nvidia.com\u002Fnvshmem\u002Fapi\u002Flatest\u002Fintroduction.html#advantages-of-nvshmem",[393],"nofollow",[395],{"type":54,"value":396},"NVSHMEM Introduction and Advantages",{"type":54,"value":398},".",{"type":48,"tag":190,"props":400,"children":402},{"id":401},"teach-the-mental-model",[403],{"type":54,"value":404},"Teach the Mental Model",{"type":48,"tag":64,"props":406,"children":407},{},[408,410,414,416,420,422,426],{"type":54,"value":409},"Read ",{"type":48,"tag":91,"props":411,"children":412},{"href":93},[413],{"type":54,"value":93},{"type":54,"value":415}," completely before teaching the conceptual path. Explain the mental model without API-name clutter and use its illustrative ring shift when a concrete example would help. Before introducing C\u002FC++ primitives, read ",{"type":48,"tag":91,"props":417,"children":418},{"href":101},[419],{"type":54,"value":101},{"type":54,"value":421}," completely and present only the API groups relevant to the user's goal. For a Python request, also read ",{"type":48,"tag":91,"props":423,"children":424},{"href":109},[425],{"type":54,"value":109},{"type":54,"value":427}," before outlining the program lifecycle or launch workflow. Keep examples framed as teaching aids rather than environment-specific recipes.",{"type":48,"tag":190,"props":429,"children":431},{"id":430},"resolve-the-hands-on-path",[432],{"type":54,"value":433},"Resolve the Hands-On Path",{"type":48,"tag":64,"props":435,"children":436},{},[437],{"type":54,"value":438},"Collect only the context required by the selected path. Do not ask for every environment detail up front.",{"type":48,"tag":440,"props":441,"children":443},"h4",{"id":442},"install-nvshmem",[444],{"type":54,"value":445},"Install NVSHMEM",{"type":48,"tag":64,"props":447,"children":448},{},[449,451,456,458,464,466,472],{"type":54,"value":450},"Before invoking ",{"type":48,"tag":121,"props":452,"children":454},{"className":453},[],[455],{"type":54,"value":126},{"type":54,"value":457},", follow this intake order: resolve the requested version or ",{"type":48,"tag":121,"props":459,"children":461},{"className":460},[],[462],{"type":54,"value":463},"latest",{"type":54,"value":465},", ask whether the user needs C\u002FC++, Python, or both, then at step 3 ask whether the user is an administrator on the target system with root or ",{"type":48,"tag":121,"props":467,"children":469},{"className":468},[],[470],{"type":54,"value":471},"sudo",{"type":54,"value":473}," rights. On a managed cluster, also ask whether the user is authorized to change the compute-node image or shared software stack. Do not infer either answer from shell access, package-manager availability, or target type.",{"type":48,"tag":64,"props":475,"children":476},{},[477,479,484],{"type":54,"value":478},"Invoke ",{"type":48,"tag":121,"props":480,"children":482},{"className":481},[],[483],{"type":54,"value":126},{"type":54,"value":485},". Pass the administrator and target-scope authority status together with the requested API or language, target environment, preferred install method, version policy, and whether the user needs runtime files, development headers and libraries, or static linking. For an unprivileged cluster user, do not frame DEB, RPM, APT, DNF, YUM, or another system package path as directly usable; prefer a site module, approved container, compatible user-owned prefix, or a clearly labeled administrator handoff.",{"type":48,"tag":440,"props":487,"children":489},{"id":488},"design-a-cc-program",[490],{"type":54,"value":491},"Design a C\u002FC++ Program",{"type":48,"tag":64,"props":493,"children":494},{},[495,496,500],{"type":54,"value":409},{"type":48,"tag":91,"props":497,"children":498},{"href":101},[499],{"type":54,"value":101},{"type":54,"value":501}," before explaining API-family choices or recommending specific primitives.",{"type":48,"tag":64,"props":503,"children":504},{},[505],{"type":54,"value":506},"Teach this stable structure directly:",{"type":48,"tag":213,"props":508,"children":509},{},[510,531,536,541,569,574,579,600],{"type":48,"tag":80,"props":511,"children":512},{},[513,515,521,523,529],{"type":54,"value":514},"Choose initialization. Use ",{"type":48,"tag":121,"props":516,"children":518},{"className":517},[],[519],{"type":54,"value":520},"nvshmem_init",{"type":54,"value":522}," for the basic standalone pattern. Use ",{"type":48,"tag":121,"props":524,"children":526},{"className":525},[],[527],{"type":54,"value":528},"nvshmemx_init_attr",{"type":54,"value":530}," when the application must integrate an MPI, OpenSHMEM, or other bootstrap context.",{"type":48,"tag":80,"props":532,"children":533},{},[534],{"type":54,"value":535},"Initialize, query a node-local PE ID, and select the CUDA device before allocating symmetric memory or launching kernels.",{"type":48,"tag":80,"props":537,"children":538},{},[539],{"type":54,"value":540},"Allocate symmetric objects collectively. Require every PE to call allocation and deallocation routines in matching order with identical arguments.",{"type":48,"tag":80,"props":542,"children":543},{},[544,546],{"type":54,"value":545},"Choose the operation family:\n",{"type":48,"tag":76,"props":547,"children":548},{},[549,554,559,564],{"type":48,"tag":80,"props":550,"children":551},{},[552],{"type":54,"value":553},"Use put or get for remote data movement.",{"type":48,"tag":80,"props":555,"children":556},{},[557],{"type":54,"value":558},"Use atomics for remote updates.",{"type":48,"tag":80,"props":560,"children":561},{},[562],{"type":54,"value":563},"Use signals and waits for point-to-point coordination.",{"type":48,"tag":80,"props":565,"children":566},{},[567],{"type":54,"value":568},"Use team collectives for group communication.",{"type":48,"tag":80,"props":570,"children":571},{},[572],{"type":54,"value":573},"Choose the invocation context: host API, device API inside a kernel, or on-stream API composed with CUDA stream work.",{"type":48,"tag":80,"props":575,"children":576},{},[577],{"type":54,"value":578},"Identify remote data with a symmetric address and destination PE. Never send a symmetric pointer value to another PE for it to reuse as a local pointer.",{"type":48,"tag":80,"props":580,"children":581},{},[582,584,590,592,598],{"type":54,"value":583},"Add the required ordering and completion. Use ",{"type":48,"tag":121,"props":585,"children":587},{"className":586},[],[588],{"type":54,"value":589},"nvshmem_fence",{"type":54,"value":591}," to order later operations after earlier operations to the same PE, ",{"type":48,"tag":121,"props":593,"children":595},{"className":594},[],[596],{"type":54,"value":597},"nvshmem_quiet",{"type":54,"value":599}," or its on-stream form for completion, and barriers, signals and waits, or collectives to coordinate PEs.",{"type":48,"tag":80,"props":601,"children":602},{},[603],{"type":54,"value":604},"Free symmetric allocations collectively and finalize.",{"type":48,"tag":64,"props":606,"children":607},{},[608,610,614],{"type":54,"value":609},"Use the ring-shift example in ",{"type":48,"tag":91,"props":611,"children":612},{"href":93},[613],{"type":54,"value":93},{"type":54,"value":615}," as the first concrete illustration; read that reference before presenting the example.",{"type":48,"tag":440,"props":617,"children":619},{"id":618},"design-or-run-an-nvshmem4py-program",[620],{"type":54,"value":621},"Design or Run an NVSHMEM4Py Program",{"type":48,"tag":64,"props":623,"children":624},{},[625,626,630],{"type":54,"value":409},{"type":48,"tag":91,"props":627,"children":628},{"href":109},[629],{"type":54,"value":109},{"type":54,"value":631}," completely. Ask only for the Python script path, Python interpreter or environment, NVSHMEM4Py version if known, initialization choice (standalone or MPI), launcher, PE and node counts, and whether the run is local or scheduled.",{"type":48,"tag":64,"props":633,"children":634},{},[635],{"type":54,"value":636},"Teach the same PE, symmetric-memory, one-sided-operation, and completion model as C\u002FC++, then map it to the Python lifecycle: choose and set the local CUDA device, initialize NVSHMEM4Py, collectively create symmetric arrays, perform the required communication and synchronization, free every symmetric array collectively, and finalize. Do not present C\u002FC++ API names as Python APIs.",{"type":48,"tag":64,"props":638,"children":639},{},[640,641,646,648,653],{"type":54,"value":478},{"type":48,"tag":121,"props":642,"children":644},{"className":643},[],[645],{"type":54,"value":133},{"type":54,"value":647}," with the requested NVSHMEM version or ",{"type":48,"tag":121,"props":649,"children":651},{"className":650},[],[652],{"type":54,"value":463},{"type":54,"value":654}," before giving Python API names, a runnable code sample, package-version compatibility, framework interoperability, initialization arguments, or exact launch commands. Pass the script path and all known Python, launcher, PE, node, and environment details. Use the documentation result to give a version-matched, user-runnable command shape. Confirm that the selected Python environment, the script, CUDA, NVSHMEM runtime libraries, and the NVSHMEM4Py package are available on every participating node.",{"type":48,"tag":64,"props":656,"children":657},{},[658,660,664],{"type":54,"value":659},"When the user supplies a simple NVSHMEM4Py script, use the example in ",{"type":48,"tag":91,"props":661,"children":662},{"href":109},[663],{"type":54,"value":109},{"type":54,"value":665}," to trace its device selection, initialization, symmetric allocation, communication, stream completion, collective cleanup, and launch requirements. Identify missing lifecycle steps or a mismatch between the script's initialization and launcher; do not execute or rewrite the script unless requested.",{"type":48,"tag":64,"props":667,"children":668},{},[669],{"type":54,"value":670},"Start with two PEs on one node and one PE per GPU by default. Require the launcher to propagate the selected Python environment and CUDA\u002FNVSHMEM environment to every PE. Explain the expected per-PE output and validate the small run before suggesting a larger or multi-node run.",{"type":48,"tag":440,"props":672,"children":674},{"id":673},"compile-and-link-cc",[675],{"type":54,"value":676},"Compile and Link C\u002FC++",{"type":48,"tag":64,"props":678,"children":679},{},[680,682,688],{"type":54,"value":681},"Ask for the source path, NVSHMEM installation prefix, target GPU architecture, and whether the project uses a direct ",{"type":48,"tag":121,"props":683,"children":685},{"className":684},[],[686],{"type":54,"value":687},"nvcc",{"type":54,"value":689}," command or CMake. For a standard CUDA source file, explain that the application must enable relocatable device code, include the NVSHMEM headers, search the installed library directory, and link both the host and device libraries.",{"type":48,"tag":64,"props":691,"children":692},{},[693],{"type":54,"value":694},"Provide this command shape after replacing or clearly labeling its variables:",{"type":48,"tag":696,"props":697,"children":702},"pre",{"className":698,"code":699,"language":700,"meta":701,"style":701},"language-bash shiki shiki-themes material-theme-lighter material-theme material-theme-palenight","nvcc -rdc=true \\\n  -ccbin g++ \\\n  -gencode=\"$NVCC_GENCODE\" \\\n  -I\"$NVSHMEM_HOME\u002Finclude\" \\\n  application.cu \\\n  -L\"$NVSHMEM_HOME\u002Flib\" \\\n  -lnvshmem_host -lnvshmem_device \\\n  -o application\n","bash","",[703],{"type":48,"tag":121,"props":704,"children":705},{"__ignoreMap":701},[706,729,747,775,806,819,849,867],{"type":48,"tag":707,"props":708,"children":711},"span",{"class":709,"line":710},"line",1,[712,717,723],{"type":48,"tag":707,"props":713,"children":715},{"style":714},"--shiki-light:#E2931D;--shiki-default:#FFCB6B;--shiki-dark:#FFCB6B",[716],{"type":54,"value":687},{"type":48,"tag":707,"props":718,"children":720},{"style":719},"--shiki-light:#91B859;--shiki-default:#C3E88D;--shiki-dark:#C3E88D",[721],{"type":54,"value":722}," -rdc=true",{"type":48,"tag":707,"props":724,"children":726},{"style":725},"--shiki-light:#90A4AE;--shiki-default:#EEFFFF;--shiki-dark:#BABED8",[727],{"type":54,"value":728}," \\\n",{"type":48,"tag":707,"props":730,"children":732},{"class":709,"line":731},2,[733,738,743],{"type":48,"tag":707,"props":734,"children":735},{"style":719},[736],{"type":54,"value":737},"  -ccbin",{"type":48,"tag":707,"props":739,"children":740},{"style":719},[741],{"type":54,"value":742}," g++",{"type":48,"tag":707,"props":744,"children":745},{"style":725},[746],{"type":54,"value":728},{"type":48,"tag":707,"props":748,"children":750},{"class":709,"line":749},3,[751,756,762,767,771],{"type":48,"tag":707,"props":752,"children":753},{"style":719},[754],{"type":54,"value":755},"  -gencode=",{"type":48,"tag":707,"props":757,"children":759},{"style":758},"--shiki-light:#39ADB5;--shiki-default:#89DDFF;--shiki-dark:#89DDFF",[760],{"type":54,"value":761},"\"",{"type":48,"tag":707,"props":763,"children":764},{"style":725},[765],{"type":54,"value":766},"$NVCC_GENCODE",{"type":48,"tag":707,"props":768,"children":769},{"style":758},[770],{"type":54,"value":761},{"type":48,"tag":707,"props":772,"children":773},{"style":725},[774],{"type":54,"value":728},{"type":48,"tag":707,"props":776,"children":778},{"class":709,"line":777},4,[779,784,788,793,798,802],{"type":48,"tag":707,"props":780,"children":781},{"style":719},[782],{"type":54,"value":783},"  -I",{"type":48,"tag":707,"props":785,"children":786},{"style":758},[787],{"type":54,"value":761},{"type":48,"tag":707,"props":789,"children":790},{"style":725},[791],{"type":54,"value":792},"$NVSHMEM_HOME",{"type":48,"tag":707,"props":794,"children":795},{"style":719},[796],{"type":54,"value":797},"\u002Finclude",{"type":48,"tag":707,"props":799,"children":800},{"style":758},[801],{"type":54,"value":761},{"type":48,"tag":707,"props":803,"children":804},{"style":725},[805],{"type":54,"value":728},{"type":48,"tag":707,"props":807,"children":809},{"class":709,"line":808},5,[810,815],{"type":48,"tag":707,"props":811,"children":812},{"style":719},[813],{"type":54,"value":814},"  application.cu",{"type":48,"tag":707,"props":816,"children":817},{"style":725},[818],{"type":54,"value":728},{"type":48,"tag":707,"props":820,"children":822},{"class":709,"line":821},6,[823,828,832,836,841,845],{"type":48,"tag":707,"props":824,"children":825},{"style":719},[826],{"type":54,"value":827},"  -L",{"type":48,"tag":707,"props":829,"children":830},{"style":758},[831],{"type":54,"value":761},{"type":48,"tag":707,"props":833,"children":834},{"style":725},[835],{"type":54,"value":792},{"type":48,"tag":707,"props":837,"children":838},{"style":719},[839],{"type":54,"value":840},"\u002Flib",{"type":48,"tag":707,"props":842,"children":843},{"style":758},[844],{"type":54,"value":761},{"type":48,"tag":707,"props":846,"children":847},{"style":725},[848],{"type":54,"value":728},{"type":48,"tag":707,"props":850,"children":852},{"class":709,"line":851},7,[853,858,863],{"type":48,"tag":707,"props":854,"children":855},{"style":719},[856],{"type":54,"value":857},"  -lnvshmem_host",{"type":48,"tag":707,"props":859,"children":860},{"style":719},[861],{"type":54,"value":862}," -lnvshmem_device",{"type":48,"tag":707,"props":864,"children":865},{"style":725},[866],{"type":54,"value":728},{"type":48,"tag":707,"props":868,"children":870},{"class":709,"line":869},8,[871,876],{"type":48,"tag":707,"props":872,"children":873},{"style":719},[874],{"type":54,"value":875},"  -o",{"type":48,"tag":707,"props":877,"children":878},{"style":719},[879],{"type":54,"value":880}," application\n",{"type":48,"tag":64,"props":882,"children":883},{},[884,886,892,894,900,902,908],{"type":54,"value":885},"Explain that ",{"type":48,"tag":121,"props":887,"children":889},{"className":888},[],[890],{"type":54,"value":891},"NVSHMEM_HOME",{"type":54,"value":893}," names the installed prefix and ",{"type":48,"tag":121,"props":895,"children":897},{"className":896},[],[898],{"type":54,"value":899},"NVCC_GENCODE",{"type":54,"value":901}," must select the target GPU architecture. For CMake, prefer the config files installed with NVSHMEM and use ",{"type":48,"tag":121,"props":903,"children":905},{"className":904},[],[906],{"type":54,"value":907},"find_package",{"type":54,"value":909}," in config mode; inspect the installed package before naming an imported target.",{"type":48,"tag":440,"props":911,"children":913},{"id":912},"run-a-precompiled-program",[914],{"type":54,"value":915},"Run a Precompiled Program",{"type":48,"tag":64,"props":917,"children":918},{},[919],{"type":54,"value":920},"Ask for the executable path, launcher, PE and node counts, and whether the run is local or scheduled. Confirm that the executable and NVSHMEM runtime libraries are visible on every participating node.",{"type":48,"tag":64,"props":922,"children":923},{},[924],{"type":54,"value":925},"Start with two PEs on one node, use one PE per GPU by default, and expand only after the small run succeeds. Present the command shape that matches the available launcher:",{"type":48,"tag":696,"props":927,"children":929},{"className":698,"code":928,"language":700,"meta":701,"style":701},"mpirun -n \u003Cnumber-of-pes> \u003Cprogram> [arguments]\n",[930],{"type":48,"tag":121,"props":931,"children":932},{"__ignoreMap":701},[933],{"type":48,"tag":707,"props":934,"children":935},{"class":709,"line":710},[936,941,946,951,956,961,966,970,975,980,984],{"type":48,"tag":707,"props":937,"children":938},{"style":714},[939],{"type":54,"value":940},"mpirun",{"type":48,"tag":707,"props":942,"children":943},{"style":719},[944],{"type":54,"value":945}," -n",{"type":48,"tag":707,"props":947,"children":948},{"style":758},[949],{"type":54,"value":950}," \u003C",{"type":48,"tag":707,"props":952,"children":953},{"style":719},[954],{"type":54,"value":955},"number-of-pe",{"type":48,"tag":707,"props":957,"children":958},{"style":725},[959],{"type":54,"value":960},"s",{"type":48,"tag":707,"props":962,"children":963},{"style":758},[964],{"type":54,"value":965},">",{"type":48,"tag":707,"props":967,"children":968},{"style":758},[969],{"type":54,"value":950},{"type":48,"tag":707,"props":971,"children":972},{"style":719},[973],{"type":54,"value":974},"progra",{"type":48,"tag":707,"props":976,"children":977},{"style":725},[978],{"type":54,"value":979},"m",{"type":48,"tag":707,"props":981,"children":982},{"style":758},[983],{"type":54,"value":965},{"type":48,"tag":707,"props":985,"children":986},{"style":725},[987],{"type":54,"value":988}," [arguments]\n",{"type":48,"tag":696,"props":990,"children":992},{"className":698,"code":991,"language":700,"meta":701,"style":701},"srun -n \u003Cnumber-of-pes> \u003Cprogram> [arguments]\n",[993],{"type":48,"tag":121,"props":994,"children":995},{"__ignoreMap":701},[996],{"type":48,"tag":707,"props":997,"children":998},{"class":709,"line":710},[999,1004,1008,1012,1016,1020,1024,1028,1032,1036,1040],{"type":48,"tag":707,"props":1000,"children":1001},{"style":714},[1002],{"type":54,"value":1003},"srun",{"type":48,"tag":707,"props":1005,"children":1006},{"style":719},[1007],{"type":54,"value":945},{"type":48,"tag":707,"props":1009,"children":1010},{"style":758},[1011],{"type":54,"value":950},{"type":48,"tag":707,"props":1013,"children":1014},{"style":719},[1015],{"type":54,"value":955},{"type":48,"tag":707,"props":1017,"children":1018},{"style":725},[1019],{"type":54,"value":960},{"type":48,"tag":707,"props":1021,"children":1022},{"style":758},[1023],{"type":54,"value":965},{"type":48,"tag":707,"props":1025,"children":1026},{"style":758},[1027],{"type":54,"value":950},{"type":48,"tag":707,"props":1029,"children":1030},{"style":719},[1031],{"type":54,"value":974},{"type":48,"tag":707,"props":1033,"children":1034},{"style":725},[1035],{"type":54,"value":979},{"type":48,"tag":707,"props":1037,"children":1038},{"style":758},[1039],{"type":54,"value":965},{"type":48,"tag":707,"props":1041,"children":1042},{"style":725},[1043],{"type":54,"value":988},{"type":48,"tag":696,"props":1045,"children":1047},{"className":698,"code":1046,"language":700,"meta":701,"style":701},"nvshmrun -n \u003Cnumber-of-pes> \u003Cprogram> [arguments]\n",[1048],{"type":48,"tag":121,"props":1049,"children":1050},{"__ignoreMap":701},[1051],{"type":48,"tag":707,"props":1052,"children":1053},{"class":709,"line":710},[1054,1059,1063,1067,1071,1075,1079,1083,1087,1091,1095],{"type":48,"tag":707,"props":1055,"children":1056},{"style":714},[1057],{"type":54,"value":1058},"nvshmrun",{"type":48,"tag":707,"props":1060,"children":1061},{"style":719},[1062],{"type":54,"value":945},{"type":48,"tag":707,"props":1064,"children":1065},{"style":758},[1066],{"type":54,"value":950},{"type":48,"tag":707,"props":1068,"children":1069},{"style":719},[1070],{"type":54,"value":955},{"type":48,"tag":707,"props":1072,"children":1073},{"style":725},[1074],{"type":54,"value":960},{"type":48,"tag":707,"props":1076,"children":1077},{"style":758},[1078],{"type":54,"value":965},{"type":48,"tag":707,"props":1080,"children":1081},{"style":758},[1082],{"type":54,"value":950},{"type":48,"tag":707,"props":1084,"children":1085},{"style":719},[1086],{"type":54,"value":974},{"type":48,"tag":707,"props":1088,"children":1089},{"style":725},[1090],{"type":54,"value":979},{"type":48,"tag":707,"props":1092,"children":1093},{"style":758},[1094],{"type":54,"value":965},{"type":48,"tag":707,"props":1096,"children":1097},{"style":725},[1098],{"type":54,"value":988},{"type":48,"tag":64,"props":1100,"children":1101},{},[1102],{"type":54,"value":1103},"Require the launcher to propagate the CUDA and NVSHMEM environment to every PE. Explain the expected per-PE output and verify it before recommending a larger or multi-node run.",{"type":48,"tag":440,"props":1105,"children":1107},{"id":1106},"invoke-documentation-only-for-variants",[1108],{"type":54,"value":1109},"Invoke Documentation Only for Variants",{"type":48,"tag":64,"props":1111,"children":1112},{},[1113,1114,1119,1121,1126],{"type":54,"value":478},{"type":48,"tag":121,"props":1115,"children":1117},{"className":1116},[],[1118],{"type":54,"value":133},{"type":54,"value":1120}," with a complete requested version or ",{"type":48,"tag":121,"props":1122,"children":1124},{"className":1123},[],[1125],{"type":54,"value":463},{"type":54,"value":1127}," when the request needs any of the following:",{"type":48,"tag":76,"props":1129,"children":1130},{},[1131,1136,1141,1146,1158,1163],{"type":48,"tag":80,"props":1132,"children":1133},{},[1134],{"type":54,"value":1135},"exact package-specific example paths or binary names;",{"type":48,"tag":80,"props":1137,"children":1138},{},[1139],{"type":54,"value":1140},"PMI, PMI-2, PMIx, Hydra installation, or non-default bootstrap wiring;",{"type":48,"tag":80,"props":1142,"children":1143},{},[1144],{"type":54,"value":1145},"multi-node transport setup or transport-specific link dependencies;",{"type":48,"tag":80,"props":1147,"children":1148},{},[1149,1151,1156],{"type":54,"value":1150},"static linking, shared-library composition, symbol visibility, or non-",{"type":48,"tag":121,"props":1152,"children":1154},{"className":1153},[],[1155],{"type":54,"value":687},{"type":54,"value":1157}," toolchains;",{"type":48,"tag":80,"props":1159,"children":1160},{},[1161],{"type":54,"value":1162},"exact CMake package or imported-target names;",{"type":48,"tag":80,"props":1164,"children":1165},{},[1166],{"type":54,"value":1167},"release-specific API availability, flags, requirements, limitations, or commands.",{"type":48,"tag":57,"props":1169,"children":1171},{"id":1170},"limitations",[1172],{"type":54,"value":1173},"Limitations",{"type":48,"tag":76,"props":1175,"children":1176},{},[1177,1182,1187,1199,1204],{"type":48,"tag":80,"props":1178,"children":1179},{},[1180],{"type":54,"value":1181},"Provide introductory guidance, not exhaustive API, installation, launcher, transport, or performance coverage.",{"type":48,"tag":80,"props":1183,"children":1184},{},[1185],{"type":54,"value":1186},"Treat command blocks as adaptable shapes. Do not claim that they match an installed release, package layout, cluster policy, or target architecture without version-specific documentation and target inspection.",{"type":48,"tag":80,"props":1188,"children":1189},{},[1190,1192,1197],{"type":54,"value":1191},"Cover first-program and launch guidance for C\u002FC++ CUDA and NVSHMEM4Py. Route Python API details, installation, and version compatibility to ",{"type":48,"tag":121,"props":1193,"children":1195},{"className":1194},[],[1196],{"type":54,"value":133},{"type":54,"value":1198}," rather than inferring them.",{"type":48,"tag":80,"props":1200,"children":1201},{},[1202],{"type":54,"value":1203},"Assess architectural fit from the stated communication pattern; do not promise a speedup without representative measurements on the target topology.",{"type":48,"tag":80,"props":1205,"children":1206},{},[1207],{"type":54,"value":1208},"Keep execution outside the default scope. A request for explanation, onboarding, or help running a program does not authorize environment changes or workload execution.",{"type":48,"tag":57,"props":1210,"children":1212},{"id":1211},"troubleshooting",[1213],{"type":54,"value":1214},"Troubleshooting",{"type":48,"tag":1216,"props":1217,"children":1218},"table",{},[1219,1243],{"type":48,"tag":1220,"props":1221,"children":1222},"thead",{},[1223],{"type":48,"tag":1224,"props":1225,"children":1226},"tr",{},[1227,1233,1238],{"type":48,"tag":1228,"props":1229,"children":1230},"th",{},[1231],{"type":54,"value":1232},"Symptom",{"type":48,"tag":1228,"props":1234,"children":1235},{},[1236],{"type":54,"value":1237},"Likely cause class",{"type":48,"tag":1228,"props":1239,"children":1240},{},[1241],{"type":54,"value":1242},"Response",{"type":48,"tag":1244,"props":1245,"children":1246},"tbody",{},[1247,1272,1296],{"type":48,"tag":1224,"props":1248,"children":1249},{},[1250,1256,1261],{"type":48,"tag":1251,"props":1252,"children":1253},"td",{},[1254],{"type":54,"value":1255},"Compilation or linking fails",{"type":48,"tag":1251,"props":1257,"children":1258},{},[1259],{"type":54,"value":1260},"Source, flags, library order, package layout, or version mismatch",{"type":48,"tag":1251,"props":1262,"children":1263},{},[1264,1265,1270],{"type":54,"value":478},{"type":48,"tag":121,"props":1266,"children":1268},{"className":1267},[],[1269],{"type":54,"value":140},{"type":54,"value":1271}," with the full command and diagnostics.",{"type":48,"tag":1224,"props":1273,"children":1274},{},[1275,1280,1285],{"type":48,"tag":1251,"props":1276,"children":1277},{},[1278],{"type":54,"value":1279},"A program errors or hangs",{"type":48,"tag":1251,"props":1281,"children":1282},{},[1283],{"type":54,"value":1284},"Launcher, bootstrap, transport, topology, runtime configuration, or program behavior",{"type":48,"tag":1251,"props":1286,"children":1287},{},[1288,1289,1294],{"type":54,"value":478},{"type":48,"tag":121,"props":1290,"children":1292},{"className":1291},[],[1293],{"type":54,"value":140},{"type":54,"value":1295}," with the complete launch stanza and output from every PE.",{"type":48,"tag":1224,"props":1297,"children":1298},{},[1299,1304,1309],{"type":48,"tag":1251,"props":1300,"children":1301},{},[1302],{"type":54,"value":1303},"A specialist skill is unavailable",{"type":48,"tag":1251,"props":1305,"children":1306},{},[1307],{"type":54,"value":1308},"The normal diagnostic or version-specific route cannot be used",{"type":48,"tag":1251,"props":1310,"children":1311},{},[1312,1313,1318],{"type":54,"value":478},{"type":48,"tag":121,"props":1314,"children":1316},{"className":1315},[],[1317],{"type":54,"value":133},{"type":54,"value":1319}," for version-matched troubleshooting, FAQ, and support routes; do not invent a workaround.",{"type":48,"tag":64,"props":1321,"children":1322},{},[1323],{"type":54,"value":1324},"For an execution failure, pass or collect the complete command or batch-script launch stanza and complete stdout and stderr from every PE, including output before the first error and per-PE logs. For a compile or link failure, pass or collect the complete compiler or linker command, full diagnostic output, undefined symbols, and library order. In both cases, include the NVSHMEM version, relevant CUDA and launcher versions, and target environment details when available.",{"type":48,"tag":64,"props":1326,"children":1327},{},[1328],{"type":54,"value":1329},"Keep installation and program-writing requests on their normal routes unless the user explicitly reports a failure in one of the two stages above.",{"type":48,"tag":57,"props":1331,"children":1333},{"id":1332},"examples",[1334],{"type":54,"value":1335},"Examples",{"type":48,"tag":64,"props":1337,"children":1338},{},[1339],{"type":54,"value":1340},"Fit assessment:",{"type":48,"tag":696,"props":1342,"children":1346},{"className":1343,"code":1345,"language":54,"meta":701},[1344],"language-text","Use $nvshmem-get-started to assess whether a multi-GPU stencil with GPU-resident halo exchanges is a strong NVSHMEM fit or is simpler with MPI.\n",[1347],{"type":48,"tag":121,"props":1348,"children":1349},{"__ignoreMap":701},[1350],{"type":54,"value":1345},{"type":48,"tag":64,"props":1352,"children":1353},{},[1354,1356,1361,1362,1367,1368,1373],{"type":54,"value":1355},"Ask only for communication facts that affect the decision, then conclude with ",{"type":48,"tag":121,"props":1357,"children":1359},{"className":1358},[],[1360],{"type":54,"value":371},{"type":54,"value":98},{"type":48,"tag":121,"props":1363,"children":1365},{"className":1364},[],[1366],{"type":54,"value":378},{"type":54,"value":380},{"type":48,"tag":121,"props":1369,"children":1371},{"className":1370},[],[1372],{"type":54,"value":386},{"type":54,"value":1374}," and explain the deciding factors.",{"type":48,"tag":64,"props":1376,"children":1377},{},[1378],{"type":54,"value":1379},"First-program guidance:",{"type":48,"tag":696,"props":1381,"children":1384},{"className":1382,"code":1383,"language":54,"meta":701},[1344],"Use $nvshmem-get-started to help me design, compile, and launch my first C++ NVSHMEM ring program without executing anything.\n",[1385],{"type":48,"tag":121,"props":1386,"children":1387},{"__ignoreMap":701},[1388],{"type":54,"value":1383},{"type":48,"tag":64,"props":1390,"children":1391},{},[1392],{"type":54,"value":1393},"Teach the mental model before concrete primitives, present adaptable compile and launch shapes, and keep execution outside scope unless the user separately requests it.",{"type":48,"tag":64,"props":1395,"children":1396},{},[1397],{"type":54,"value":1398},"NVSHMEM4Py first-run guidance:",{"type":48,"tag":696,"props":1400,"children":1403},{"className":1401,"code":1402,"language":54,"meta":701},[1344],"Use $nvshmem-get-started to help me run my first NVSHMEM4Py program with two GPUs, without executing anything.\n",[1404],{"type":48,"tag":121,"props":1405,"children":1406},{"__ignoreMap":701},[1407],{"type":54,"value":1402},{"type":48,"tag":64,"props":1409,"children":1410},{},[1411,1413,1418],{"type":54,"value":1412},"Read the NVSHMEM4Py program guide, collect the Python environment and launcher context, obtain current version-matched Python API and launch details from ",{"type":48,"tag":121,"props":1414,"children":1416},{"className":1415},[],[1417],{"type":54,"value":133},{"type":54,"value":1419},", and provide a user-runnable small-run plan.",{"type":48,"tag":1421,"props":1422,"children":1423},"style",{},[1424],{"type":54,"value":1425},"html .light .shiki span {color: var(--shiki-light);background: var(--shiki-light-bg);font-style: var(--shiki-light-font-style);font-weight: var(--shiki-light-font-weight);text-decoration: var(--shiki-light-text-decoration);}html.light .shiki span {color: var(--shiki-light);background: var(--shiki-light-bg);font-style: var(--shiki-light-font-style);font-weight: var(--shiki-light-font-weight);text-decoration: var(--shiki-light-text-decoration);}html .default .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html .dark .shiki span {color: var(--shiki-dark);background: var(--shiki-dark-bg);font-style: var(--shiki-dark-font-style);font-weight: var(--shiki-dark-font-weight);text-decoration: var(--shiki-dark-text-decoration);}html.dark .shiki span {color: var(--shiki-dark);background: var(--shiki-dark-bg);font-style: var(--shiki-dark-font-style);font-weight: var(--shiki-dark-font-weight);text-decoration: var(--shiki-dark-text-decoration);}",{"items":1427,"total":1508},[1428,1442,1456,1468,1480,1486,1498],{"slug":1429,"name":1429,"fn":1430,"description":1431,"org":1432,"tags":1433,"stars":20,"repoUrl":21,"updatedAt":1441},"nvshmem-collect-performance-data","collect NVSHMEM performance metrics","Collect and package NVSHMEM put\u002Fget bandwidth, latency, and other perftest results with system and topology evidence for performance sanity checks.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":9},[1434,1437,1438],{"name":1435,"slug":1436,"type":15},"Monitoring","monitoring",{"name":9,"slug":8,"type":15},{"name":1439,"slug":1440,"type":15},"Performance","performance","2026-08-31T09:19:00.917887",{"slug":1443,"name":1443,"fn":1444,"description":1445,"org":1446,"tags":1447,"stars":20,"repoUrl":21,"updatedAt":1455},"nvshmem-configure-nic-pe-mapping","configure NVSHMEM NIC-to-PE mappings","Recommend NVSHMEM NIC-to-PE mappings and environment exports. Use for HCA selection, multi-NIC configuration, or topology-based mapping diagnostics.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":9},[1448,1451,1454],{"name":1449,"slug":1450,"type":15},"Configuration","configuration",{"name":1452,"slug":1453,"type":15},"Networking","networking",{"name":9,"slug":8,"type":15},"2026-08-31T09:19:06.10294",{"slug":1457,"name":1457,"fn":1458,"description":1459,"org":1460,"tags":1461,"stars":20,"repoUrl":21,"updatedAt":1467},"nvshmem-docs","fetch official NVSHMEM documentation","Find version-aware official NVSHMEM and NVSHMEM4Py documentation for releases, installation, APIs, runtime settings, transports, containers, and troubleshooting.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":9},[1462,1463,1464],{"name":17,"slug":18,"type":15},{"name":9,"slug":8,"type":15},{"name":1465,"slug":1466,"type":15},"Reference","reference","2026-08-31T09:19:00.214841",{"slug":1469,"name":1469,"fn":1470,"description":1471,"org":1472,"tags":1473,"stars":20,"repoUrl":21,"updatedAt":1479},"nvshmem-enable-tma","optimize NVSHMEM CUDA kernels for TMA","Prepare or review NVSHMEM CUDA kernels for TMA SMEM registration and direct-SMEM transfers. Do not use for unrelated CUDA tuning.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":9},[1474,1477,1478],{"name":1475,"slug":1476,"type":15},"Engineering","engineering",{"name":9,"slug":8,"type":15},{"name":1439,"slug":1440,"type":15},"2026-08-31T09:18:50.449676",{"slug":4,"name":4,"fn":5,"description":6,"org":1481,"tags":1482,"stars":20,"repoUrl":21,"updatedAt":22},{"slug":8,"name":9,"logoUrl":10,"githubOrg":9},[1483,1484,1485],{"name":17,"slug":18,"type":15},{"name":9,"slug":8,"type":15},{"name":13,"slug":14,"type":15},{"slug":1487,"name":1487,"fn":1488,"description":1489,"org":1490,"tags":1491,"stars":20,"repoUrl":21,"updatedAt":1497},"nvshmem-install","install and validate NVSHMEM","Plan and validate NVSHMEM and NVSHMEM4Py installations. Use for package, container, or source deployments.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":9},[1492,1495,1496],{"name":1493,"slug":1494,"type":15},"Deployment","deployment",{"name":1475,"slug":1476,"type":15},{"name":9,"slug":8,"type":15},"2026-08-31T09:18:50.105521",{"slug":1499,"name":1499,"fn":1500,"description":1501,"org":1502,"tags":1503,"stars":20,"repoUrl":21,"updatedAt":1507},"nvshmem-select-remote-transport","select NVSHMEM remote transport configurations","Select an NVSHMEM remote transport from target system and kernel evidence. Use for inter-node selection, compatibility checks, or configuration.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":9},[1504,1505,1506],{"name":1449,"slug":1450,"type":15},{"name":9,"slug":8,"type":15},{"name":1439,"slug":1440,"type":15},"2026-08-31T09:18:59.493722",9,{"items":1510,"total":1664},[1511,1527,1542,1553,1565,1579,1592,1606,1619,1630,1644,1653],{"slug":1512,"name":1512,"fn":1513,"description":1514,"org":1515,"tags":1516,"stars":1524,"repoUrl":1525,"updatedAt":1526},"nemoclaw-user-guide","retrieve NemoClaw documentation and configuration","Guides human users' AI agents to the NemoClaw docs MCP server and canonical Fern documentation in Markdown form. Use when users ask how to install, configure, operate, troubleshoot, secure, or learn NemoClaw with an AI coding assistant. Trigger keywords - nemoclaw docs, use nemoclaw with ai agent, nemoclaw mcp docs, nemoclaw install help, nemoclaw quickstart, nemoclaw markdown docs, llms.txt, agent skills.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":9},[1517,1518,1521],{"name":17,"slug":18,"type":15},{"name":1519,"slug":1520,"type":15},"MCP","mcp",{"name":1522,"slug":1523,"type":15},"Search","search",21777,"https:\u002F\u002Fgithub.com\u002FNVIDIA\u002FNemoClaw","2026-08-25T03:29:57.273192",{"slug":1528,"name":1528,"fn":1529,"description":1530,"org":1531,"tags":1532,"stars":1539,"repoUrl":1540,"updatedAt":1541},"mcore-build-and-dependency","manage Megatron-LM development environments","Container-based dev environment setup and dependency management for Megatron-LM. Covers acquiring and launching the CI container, uv package management, and updating uv.lock.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":9},[1533,1536,1537],{"name":1534,"slug":1535,"type":15},"Containers","containers",{"name":1493,"slug":1494,"type":15},{"name":1538,"slug":30,"type":15},"Python",17049,"https:\u002F\u002Fgithub.com\u002FNVIDIA\u002FMegatron-LM","2026-07-27T06:06:11.249662",{"slug":1543,"name":1543,"fn":1544,"description":1545,"org":1546,"tags":1547,"stars":1539,"repoUrl":1540,"updatedAt":1552},"mcore-bump-base-image","update NVIDIA PyTorch base images","Bump the NVIDIA PyTorch base image (`nvcr.io\u002Fnvidia\u002Fpytorch:YY.MM-py3`) used by Megatron-LM CI. Covers the two pin sites (GitHub CI in `docker\u002F.ngc_version.dev` and GitLab CI in `.gitlab\u002Fstages\u002F01.build.yml`), the post-bump CI loop (re-run functional tests, refresh golden values, mark broken tests), and the gotchas that bit PRs",{"slug":8,"name":9,"logoUrl":10,"githubOrg":9},[1548,1551],{"name":1549,"slug":1550,"type":15},"CI\u002FCD","ci-cd",{"name":1493,"slug":1494,"type":15},"2026-07-14T05:25:59.97109",{"slug":1554,"name":1554,"fn":1555,"description":1556,"org":1557,"tags":1558,"stars":1539,"repoUrl":1540,"updatedAt":1564},"mcore-cicd","manage CI\u002FCD pipelines for Megatron-LM","CI\u002FCD reference for Megatron-LM. Covers CI pipeline structure, PR scope labels, triggering internal GitLab CI (which force-pushes the current branch to a pull-request\u002FBRANCH ref — always dry-run and verify the destination first; never run against shared or protected branches), and CI failure investigation.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":9},[1559,1560,1561],{"name":1549,"slug":1550,"type":15},{"name":1493,"slug":1494,"type":15},{"name":1562,"slug":1563,"type":15},"GitHub","github","2026-08-28T14:38:16.959248",{"slug":1566,"name":1566,"fn":1567,"description":1568,"org":1569,"tags":1570,"stars":1539,"repoUrl":1540,"updatedAt":1578},"mcore-create-issue","investigate CI failures and create issues","Investigate a failing GitHub Actions run or job and create a GitHub issue for the failure.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":9},[1571,1574,1575],{"name":1572,"slug":1573,"type":15},"Debugging","debugging",{"name":1562,"slug":1563,"type":15},{"name":1576,"slug":1577,"type":15},"Triage","triage","2026-07-14T05:25:57.442089",{"slug":1580,"name":1580,"fn":1581,"description":1582,"org":1583,"tags":1584,"stars":1539,"repoUrl":1540,"updatedAt":1591},"mcore-linting-and-formatting","lint and format Megatron-LM code","Linting and formatting for Megatron-LM. Covers running autoformat.sh, tools (ruff, black, isort, pylint, mypy), and code style rules.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":9},[1585,1588],{"name":1586,"slug":1587,"type":15},"Best Practices","best-practices",{"name":1589,"slug":1590,"type":15},"Code Analysis","code-analysis","2026-07-14T05:25:56.18433",{"slug":1593,"name":1593,"fn":1594,"description":1595,"org":1596,"tags":1597,"stars":1539,"repoUrl":1540,"updatedAt":1605},"mcore-migrate-gpt-to-hybrid","migrate Megatron-LM models to HybridModel","Migration guide for moving Megatron Core GPTModel checkpoints, model providers, training commands, and layer mappings to HybridModel, including the mechanical steps for transferring an existing pretrain_gpt.py launch script.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":9},[1598,1601,1604],{"name":1599,"slug":1600,"type":15},"Machine Learning","machine-learning",{"name":1602,"slug":1603,"type":15},"Migration","migration",{"name":9,"slug":8,"type":15},"2026-08-21T03:36:57.470256",{"slug":1607,"name":1607,"fn":1608,"description":1609,"org":1610,"tags":1611,"stars":1539,"repoUrl":1540,"updatedAt":1618},"mcore-onboard-gb200-1node-tests","onboard functional tests for GB200","Onboard 1-node GitHub MR functional tests for GB200 from existing mr-scoped 2-node tests.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":9},[1612,1615],{"name":1613,"slug":1614,"type":15},"QA","qa",{"name":1616,"slug":1617,"type":15},"Testing","testing","2026-07-14T05:25:53.673039",{"slug":1620,"name":1620,"fn":1621,"description":1622,"org":1623,"tags":1624,"stars":1539,"repoUrl":1540,"updatedAt":1629},"mcore-run-on-slurm","launch distributed training jobs on SLURM","How to launch distributed Megatron-LM training jobs on a SLURM cluster. Covers a minimal sbatch skeleton, environment-variable setup for torch.distributed.run, CUDA_DEVICE_MAX_CONNECTIONS rules across hardware and parallelism modes, container conventions, monitoring, and per-rank failure diagnosis.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":9},[1625,1626],{"name":1493,"slug":1494,"type":15},{"name":1627,"slug":1628,"type":15},"Infrastructure","infrastructure","2026-07-14T05:25:49.362534",{"slug":1631,"name":1631,"fn":1632,"description":1633,"org":1634,"tags":1635,"stars":1539,"repoUrl":1540,"updatedAt":1643},"mcore-split-pr","split pull requests to reduce review load","Split a PR into multiple PRs to reduce the number of required CODEOWNERS reviewer groups.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":9},[1636,1639,1640],{"name":1637,"slug":1638,"type":15},"Code Review","code-review",{"name":1562,"slug":1563,"type":15},{"name":1641,"slug":1642,"type":15},"Pull Requests","pull-requests","2026-08-25T03:29:16.211287",{"slug":1645,"name":1645,"fn":1646,"description":1647,"org":1648,"tags":1649,"stars":1539,"repoUrl":1540,"updatedAt":1652},"mcore-testing","run and manage Megatron-LM tests","Test system for Megatron-LM. Covers test layout, recipe YAML structure, adding and running unit and functional tests, golden values, marker filters, and CI parity.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":9},[1650,1651],{"name":1613,"slug":1614,"type":15},{"name":1616,"slug":1617,"type":15},"2026-07-14T05:25:54.928983",{"slug":1654,"name":1654,"fn":1655,"description":1656,"org":1657,"tags":1658,"stars":1539,"repoUrl":1540,"updatedAt":1663},"nightly-sync","manage nightly main-to-dev sync workflows","Domain knowledge for the nightly main-to-dev sync workflow. Covers merge strategy, CI architecture, failure investigation, and known issues.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":9},[1659,1662],{"name":1660,"slug":1661,"type":15},"Automation","automation",{"name":1549,"slug":1550,"type":15},"2026-07-30T05:29:03.275638",563]